MSEdge.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 road/street connecting two junctions
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <vector>
#include <map>
#include <string>
#include <unordered_map>
#include <iostream>
#ifdef HAVE_FOX
#include <utils/foxtools/fxheader.h>
#endif
#include <utils/common/Named.h>
#include <utils/common/Parameterised.h>
#include <utils/common/SUMOTime.h>
#include <utils/common/SUMOVehicleClass.h>
#include <utils/geom/Boundary.h>
#include <utils/router/ReversedEdge.h>
#include <utils/router/RailEdge.h>
#include <utils/vehicle/SUMOVehicle.h>
#include <utils/vehicle/SUMOTrafficObject.h>
#include "MSNet.h"
 
 
// ===========================================================================
// class declarations
// ===========================================================================
class Boundary;
class OutputDevice;
class SUMOVehicle;
class SUMOVehicleParameter;
class MSVehicle;
class MSLane;
class MSLaneChanger;
class MSPerson;
class MSJunction;
class MSEdge;
class MSTransportable;
 
 
// ===========================================================================
// class definitions
// ===========================================================================
typedef std::vector<MSEdge*> MSEdgeVector;
typedef std::vector<const MSEdge*> ConstMSEdgeVector;
typedef std::vector<std::pair<const MSEdge*, const MSEdge*> > MSConstEdgePairVector;
 
class MSEdge : public Named, public Parameterised {
private:
    typedef std::vector<std::pair<SVCPermissions, std::shared_ptr<const std::vector<MSLane*> > > > AllowedLanesCont;
 
    typedef std::map<const MSEdge*, AllowedLanesCont> AllowedLanesByTarget;
 
 
public:
    friend class MSLaneChangerSublane; // needs access to myLaneChanger
 
    MSEdge(const std::string& id, int numericalID, const SumoXMLEdgeFunc function,
           const std::string& streetName, const std::string& edgeType,
           const std::string& routingType, int priority, double distance);
 
 
    virtual ~MSEdge();
 
 
    void initialize(const std::vector<MSLane*>* lanes);
 
 
    void recalcCache();
 
 
    virtual void closeBuilding();
 
    void buildLaneChanger();
 
    /* @brief returns whether initializing a lane change is permitted on this edge
     * @note Has to be called after all successors and predecessors have been set (after closeBuilding())
     */
    bool allowsLaneChanging() const;
 
 
    MSLane* leftLane(const MSLane* const lane) const;
 
 
    MSLane* rightLane(const MSLane* const lane) const;
 
 
    MSLane* parallelLane(const MSLane* const lane, int offset, bool includeOpposite = true) const;
 
 
    inline const std::vector<MSLane*>& getLanes() const {
        return *myLanes;
    }
 
    inline int getNumLanes() const {
        return (int)myLanes->size();
    }
 
    int getNumDrivingLanes() const;
 
    int getVehicleNumber() const;
 
    bool isEmpty() const;
 
    std::vector<const SUMOVehicle*> getVehicles() const;
 
    double getBruttoOccupancy() const;
 
    double getFlow() const;
 
    double getWaitingSeconds() const;
 
    double getOccupancy() const;
 
    inline const std::set<MSTransportable*, ComparatorNumericalIdLess>& getPersons() const {
        return myPersons;
    }
 
    std::vector<MSTransportable*> getSortedPersons(SUMOTime timestep, bool includeRiding = false) const;
 
 
    std::vector<MSTransportable*> getSortedContainers(SUMOTime timestep, bool includeRiding = false) const;
 
    const std::vector<MSLane*>* allowedLanes(const MSEdge& destination,
            SUMOVehicleClass vclass = SVC_IGNORING, bool ignoreTransientPermissions = false) const;
 
 
 
    const std::vector<MSLane*>* allowedLanes(SUMOVehicleClass vclass = SVC_IGNORING) const;
    const std::vector<MSLane*>* allowedLanes(SUMOVehicleClass vclass, bool ignoreTransientPermissions) const;
 
    inline bool isConnectedTo(const MSEdge& destination, SUMOVehicleClass vclass, bool ignoreTransientPermissions = false) const {
        const std::vector<MSLane*>* const lanes = allowedLanes(destination, vclass, ignoreTransientPermissions);
        return lanes != nullptr && !lanes->empty();
    }
 
 
 
 
    inline SumoXMLEdgeFunc getFunction() const {
        return myFunction;
    }
 
    inline bool isNormal() const {
        return myFunction == SumoXMLEdgeFunc::NORMAL;
    }
 
    inline bool isInternal() const {
        return myFunction == SumoXMLEdgeFunc::INTERNAL;
    }
 
    inline bool isCrossing() const {
        return myFunction == SumoXMLEdgeFunc::CROSSING;
    }
 
 
    void checkAndRegisterBiDirEdge(const std::string& bidiID = "");
 
    inline const MSEdge* getBidiEdge() const {
        return myBidiEdge;
    }
 
    inline bool isWalkingArea() const {
        return myFunction == SumoXMLEdgeFunc::WALKINGAREA;
    }
 
    inline bool isTazConnector() const {
        return myFunction == SumoXMLEdgeFunc::CONNECTOR;
    }
 
    void setOtherTazConnector(const MSEdge* edge) {
        myOtherTazConnector = edge;
    }
 
    const MSEdge* getOtherTazConnector() const {
        return myOtherTazConnector;
    }
 
    inline int getNumericalID() const {
        return myNumericalID;
    }
 
 
    const std::string& getStreetName() const {
        return myStreetName;
    }
 
    const std::string& getEdgeType() const {
        return myEdgeType;
    }
 
    const std::string& getRoutingType() const {
        return myRoutingType.empty() ? myEdgeType : myRoutingType;
    }
 
    double getPreference(const SUMOVTypeParameter& pars) const;
 
    // @brief try to infer edge type for internal edges
    void inferEdgeType();
 
    int getPriority() const {
        return myPriority;
    }
 
    double getDistance() const {
        return myDistance;
    }
 
    double getDistanceAt(double pos) const;
 
    bool hasDistance() const {
        return myDistance != 0;
    }
 
    void setCrossingEdges(const std::vector<std::string>& crossingEdges)        {
        myCrossingEdges.clear();
        myCrossingEdges.insert(myCrossingEdges.begin(), crossingEdges.begin(), crossingEdges.end());
    }
 
    const std::vector<std::string>& getCrossingEdges() const {
        return myCrossingEdges;
    }
 
 
 
    void addSuccessor(MSEdge* edge, const MSEdge* via = nullptr);
 
    void resetTAZ(MSJunction* junction);
 
    int getNumSuccessors() const {
        return (int) mySuccessors.size();
    }
 
 
    const MSEdgeVector& getSuccessors(SUMOVehicleClass vClass = SVC_IGNORING) const;
 
    const MSConstEdgePairVector& getViaSuccessors(SUMOVehicleClass vClass = SVC_IGNORING, bool ignoreTransientPermissions = false) const;
 
 
    int getNumPredecessors() const {
        return (int) myPredecessors.size();
    }
 
 
    const MSEdgeVector& getPredecessors() const {
        return myPredecessors;
    }
 
 
    const MSJunction* getFromJunction() const {
        return myFromJunction;
    }
 
    const MSJunction* getToJunction() const {
        return myToJunction;
    }
 
 
    void setJunctions(MSJunction* from, MSJunction* to);
 
 
 
 
    bool isVaporizing() const {
        return myVaporizationRequests > 0;
    }
 
 
    SUMOTime incVaporization(SUMOTime t);
 
 
    SUMOTime decVaporization(SUMOTime t);
 
 
    double getCurrentTravelTime(const double minSpeed = NUMERICAL_EPS) const;
 
 
    inline double getMinimumTravelTime(const SUMOVehicle* const veh) const {
        if (myFunction == SumoXMLEdgeFunc::CONNECTOR) {
            return 0;
        } else if (veh != 0) {
            return getLength() / getVehicleMaxSpeed(veh) + myTimePenalty;
        } else {
            return myEmptyTraveltime;
        }
    }
 
    double getTimePenalty() const {
        return myTimePenalty;
    }
 
    static inline double getTravelTimeStatic(const MSEdge* const edge, const SUMOVehicle* const veh, double time) {
        return MSNet::getInstance()->getTravelTime(edge, veh, time);
    }
 
    static double getTravelTimeAggregated(const MSEdge* const edge, const SUMOVehicle* const veh, double time);
 
    double getRoutingSpeed() const;
 
 
 
    bool insertVehicle(SUMOVehicle& v, SUMOTime time, const bool checkOnly = false, const bool forceCheck = false) const;
 
    bool validateDepartSpeed(SUMOVehicle& v) const;
 
    MSLane* getFreeLane(const std::vector<MSLane*>* allowed, const SUMOVehicleClass vclass, double departPos) const;
 
    MSLane* getProbableLane(const std::vector<MSLane*>* allowed, const SUMOVehicleClass vclass, double departPos, double maxSpeed) const;
 
 
    MSLane* getDepartLane(MSVehicle& veh) const;
 
    /* @brief get the rightmost lane that allows the given vClass or nullptr
     * @param[in] defaultFirst Whether the first lane should be returned if all lanes are forbidden
     */
    MSLane* getFirstAllowed(SUMOVehicleClass vClass, bool defaultFirst = false, int routingMode = 0) const;
 
    MSLane* getDepartLaneMeso(SUMOVehicle& veh) const;
 
    inline SUMOTime getLastFailedInsertionTime() const {
        return myLastFailedInsertionTime;
    }
 
 
    inline void setLastFailedInsertionTime(SUMOTime time) const {
        myLastFailedInsertionTime = time;
    }
 
 
    void changeLanes(SUMOTime t) const;
 
 
    const MSEdge* getInternalFollowingEdge(const MSEdge* followerAfterInternal, SUMOVehicleClass vClass) const;
 
 
    double getInternalFollowingLengthTo(const MSEdge* followerAfterInternal, SUMOVehicleClass vClass) const;
 
    const MSEdge* getNormalBefore() const;
 
    const MSEdge* getNormalSuccessor() const;
 
    inline bool prohibits(const SUMOVehicle* const vehicle) const {
        if (vehicle == nullptr) {
            return false;
        }
        const SUMOVehicleClass svc = vehicle->getVClass();
        return (vehicle->ignoreTransientPermissions()
                ? (myOriginalCombinedPermissions & svc) != svc
                : (myCombinedPermissions & svc) != svc);
    }
 
    bool hasTransientPermissions() const;
 
    inline bool restricts(const SUMOVehicle* const /* vehicle */) const {
        return false;
    }
 
    inline SVCPermissions getPermissions() const {
        return myCombinedPermissions;
    }
 
    double getWidth() const {
        return myWidth;
    }
 
    const std::vector<double> getSubLaneSides() const {
        return mySublaneSides;
    }
 
    void rebuildAllowedLanes(const bool onInit = false, bool updateVehicles = false);
 
    void rebuildAllowedTargets(const bool updateVehicles = true);
 
 
    double getDistanceTo(const MSEdge* other, const bool doBoundaryEstimate = false) const;
 
 
    static const Position getStopPosition(const SUMOVehicleParameter::Stop& stop);
 
 
    inline double getLength() const {
        return myLength;
    }
 
 
    double getMinLength() const;
 
 
    double getSpeedLimit() const;
 
    double getSpeedLimit(SUMOVehicleClass svc) const;
 
    double getLengthGeometryFactor() const;
 
    void setMaxSpeed(const double val, const bool modified = true, const double jamThreshold = -1);
 
    void setFrictionCoefficient(double val) const;
 
    double getVehicleMaxSpeed(const SUMOTrafficObject* const veh) const;
 
 
    virtual void addTransportable(MSTransportable* t) const;
 
    virtual void removeTransportable(MSTransportable* t) const;
 
    inline bool isRoundabout() const {
        return myAmRoundabout;
    }
 
    void markAsRoundabout() {
        myAmRoundabout = true;
    }
 
    void markDelayed() const {
        myAmDelayed = true;
    }
 
    // return whether there have been vehicles on this or the bidi edge (if there is any) at least once
    inline bool isDelayed() const {
        return myAmDelayed || (myBidiEdge != nullptr && myBidiEdge->myAmDelayed);
    }
 
    bool hasLaneChanger() const {
        return myLaneChanger != nullptr;
    }
 
    std::pair<double, SUMOTime> getLastBlocked(int index) const;
 
    bool canChangeToOpposite() const;
 
    const MSEdge* getOppositeEdge() const;
 
    double getMeanSpeed() const;
 
    double getMeanFriction() const;
 
    double getMeanSpeedBike() const;
 
    bool hasMinorLink() const;
 
    bool isFringe() const {
        return myAmFringe;
    }
 
    bool hasChangeProhibitions(SUMOVehicleClass svc, int index) const;
 
    virtual bool isSelected() const {
        return false;
    }
 
    virtual void lock() const {}
 
    virtual void unlock() const {};
 
    void addWaiting(SUMOVehicle* vehicle) const;
 
    void removeWaiting(const SUMOVehicle* vehicle) const;
 
    /* @brief returns a vehicle that is waiting for a for a person or a container at this edge at the given position
     * @param[in] transportable The person or container that wants to ride
     * @param[in] position The vehicle shall be positioned in the interval [position - t, position + t], where t is some tolerance
     */
    SUMOVehicle* getWaitingVehicle(MSTransportable* transportable, const double position) const;
 
    void clearState();
 
    void postLoadInitLaneChanger();
 
    static DepartLaneDefinition& getDefaultDepartLaneDefinition() {
        return myDefaultDepartLaneDefinition;
    }
 
    static int& getDefaultDepartLane() {
        return myDefaultDepartLane;
    }
 
    static bool dictionary(const std::string& id, MSEdge* edge);
 
    static MSEdge* dictionary(const std::string_view& id);
 
    static MSEdge* dictionaryHint(const std::string& id, const int startIdx);
 
    static const MSEdgeVector& getAllEdges();
 
    static void clear();
 
    static void insertIDs(std::vector<std::string>& into);
 
    static SVCPermissions getMesoPermissions(SVCPermissions p, SVCPermissions ignoreIgnored = 0);
 
    static void setMesoIgnoredVClasses(SVCPermissions ignored) {
        myMesoIgnoredVClasses = ignored;
    }
 
public:
 
    static void parseEdgesList(const std::string& desc, ConstMSEdgeVector& into,
                               const std::string& rid);
 
 
    static void parseEdgesList(const std::vector<std::string>& desc, ConstMSEdgeVector& into,
                               const std::string& rid);
 
 
    ReversedEdge<MSEdge, SUMOVehicle>* getReversedRoutingEdge() const {
        if (myReversedRoutingEdge == nullptr) {
            myReversedRoutingEdge = new ReversedEdge<MSEdge, SUMOVehicle>(this);
        }
        return myReversedRoutingEdge;
    }
 
    RailEdge<MSEdge, SUMOVehicle>* getRailwayRoutingEdge() const {
        if (myRailwayRoutingEdge == nullptr) {
            myRailwayRoutingEdge = new RailEdge<MSEdge, SUMOVehicle>(this);
        }
        return myRailwayRoutingEdge;
    }
 
    const std::map<const MEVehicle*, std::pair<double, int> >& getMesoPositions() const;
 
    inline void invalidateMesoCache() const {
        myLastCacheUpdate = -1;
    }
 
protected:
    class by_id_sorter {
    public:
        explicit by_id_sorter() { }
 
        int operator()(const MSEdge* const e1, const MSEdge* const e2) const {
            return e1->getNumericalID() < e2->getNumericalID();
        }
 
    };
 
    class transportable_by_position_sorter {
    public:
        explicit transportable_by_position_sorter(SUMOTime timestep): myTime(timestep) { }
 
        int operator()(const MSTransportable* const c1, const MSTransportable* const c2) const;
    private:
        SUMOTime myTime;
    };
 
 
    double getDepartPosBound(const MSVehicle& veh, bool upper = true) const;
 
protected:
    const int myNumericalID;
 
    std::shared_ptr<const std::vector<MSLane*> > myLanes;
 
    MSLaneChanger* myLaneChanger;
 
    const SumoXMLEdgeFunc myFunction;
 
    int myVaporizationRequests;
 
    mutable SUMOTime myLastFailedInsertionTime;
 
    mutable std::set<int> myFailedInsertionMemory;
 
    std::vector<std::string> myCrossingEdges;
 
    MSEdgeVector mySuccessors;
 
    MSConstEdgePairVector myViaSuccessors;
 
    MSEdgeVector myPredecessors;
 
    MSJunction* myFromJunction;
    MSJunction* myToJunction;
 
    mutable std::set<MSTransportable*, ComparatorNumericalIdLess> myPersons;
 
    mutable std::set<MSTransportable*, ComparatorNumericalIdLess> myContainers;
 
 
    AllowedLanesCont myAllowed;
    AllowedLanesCont myOrigAllowed;
 
    AllowedLanesByTarget myAllowedTargets;
    AllowedLanesByTarget myOrigAllowedTargets;
 
    SVCPermissions myMinimumPermissions = SVCAll;
    SVCPermissions myCombinedPermissions = 0;
 
    SVCPermissions myOriginalMinimumPermissions = SVCAll;
    SVCPermissions myOriginalCombinedPermissions = SVCAll;
 
    bool myHaveTransientPermissions;
 
    const MSEdge* myOtherTazConnector;
 
    std::string myStreetName;
 
    std::string myEdgeType;
 
    std::string myRoutingType;
 
    const int myPriority;
 
    const double myDistance;
 
    double myWidth;
 
    double myLength;
 
    double myEmptyTraveltime;
 
    double myTimePenalty;
 
    mutable bool myAmDelayed;
 
    bool myAmRoundabout;
 
    bool myAmFringe;
 
    std::vector<double> mySublaneSides;
 
 
    typedef std::map< std::string, MSEdge* > DictType;
 
    static DictType myDict;
    static std::unordered_map<std::string_view, MSEdge*> myHashDict;
 
    static MSEdgeVector myEdges;
 
    static SVCPermissions myMesoIgnoredVClasses;
 
    static DepartLaneDefinition myDefaultDepartLaneDefinition;
    static int myDefaultDepartLane;
 
 
    mutable std::map<SUMOVehicleClass, MSEdgeVector> myClassesSuccessorMap;
 
    mutable std::map<SUMOVehicleClass, MSConstEdgePairVector> myClassesViaSuccessorMap;
    mutable std::map<SUMOVehicleClass, MSConstEdgePairVector> myOrigClassesViaSuccessorMap;
 
    Boundary myBoundary;
 
    mutable std::vector<SUMOVehicle*> myWaiting;
 
    mutable std::map<const MEVehicle*, std::pair<double, int> > myCachedMesoPos;
 
    mutable SUMOTime myLastCacheUpdate = -1;
 
#ifdef HAVE_FOX
    mutable FXMutex myWaitingMutex;
 
    mutable FXMutex mySuccessorMutex;
#endif
 
private:
 
    const MSEdge* myBidiEdge;
 
    mutable ReversedEdge<MSEdge, SUMOVehicle>* myReversedRoutingEdge = nullptr;
    mutable RailEdge<MSEdge, SUMOVehicle>* myRailwayRoutingEdge = nullptr;
 
    MSEdge(const MSEdge&);
 
    MSEdge& operator=(const MSEdge&) = delete;
 
    void setBidiLanes();
 
    bool isSuperposable(const MSEdge* other);
 
    void addToAllowed(const SVCPermissions permissions, std::shared_ptr<const std::vector<MSLane*> > allowedLanes, AllowedLanesCont& laneCont) const;
};