ROEdge.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2002-2025 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 basic edge for routing applications
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <string>
#include <map>
#include <vector>
#include <algorithm>
#include <utils/common/Named.h>
#include <utils/common/StdDefs.h>
#include <utils/common/ValueTimeLine.h>
#include <utils/common/SUMOVehicleClass.h>
#include <utils/common/RandHelper.h>
#include <utils/emissions/PollutantsInterface.h>
#include <utils/geom/Boundary.h>
#include <utils/router/FlippedEdge.h>
#ifdef HAVE_FOX
#include <utils/foxtools/fxheader.h>
#endif
#include <utils/vehicle/SUMOVTypeParameter.h>
#include "RONet.h"
#include "RONode.h"
#include "ROVehicle.h"
 
 
// ===========================================================================
// class declarations
// ===========================================================================
class ROLane;
class ROEdge;
 
typedef std::vector<ROEdge*> ROEdgeVector;
typedef std::vector<const ROEdge*> ConstROEdgeVector;
typedef std::vector<std::pair<const ROEdge*, const ROEdge*> > ROConstEdgePairVector;
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class ROEdge : public Named, public Parameterised {
public:
    ROEdge(const std::string& id, RONode* from, RONode* to, int index, const int priority, const std::string& type, const std::string& routingType);
 
    ROEdge(const std::string& id, const RONode* from, const RONode* to, SVCPermissions p);
 
 
    virtual ~ROEdge();
 
 
 
 
    virtual void addLane(ROLane* lane);
 
 
    virtual void addSuccessor(ROEdge* s, ROEdge* via = nullptr, std::string dir = "");
 
 
    inline void setFunction(SumoXMLEdgeFunc func) {
        myFunction = func;
    }
 
 
    inline void setSource(const bool isSource = true) {
        myAmSource = isSource;
    }
 
 
    inline void setSink(const bool isSink = true) {
        myAmSink = isSink;
    }
 
 
    inline void setSpeedRestrictions(const std::map<SUMOVehicleClass, double>* restrictions) {
        mySpeedRestrictions = restrictions;
    }
 
    inline void setTimePenalty(double value) {
        myTimePenalty = value;
    }
 
    inline double getTimePenalty() const {
        return myTimePenalty;
    }
 
    inline bool isNormal() const {
        return myFunction == SumoXMLEdgeFunc::NORMAL;
    }
 
    inline bool isInternal() const {
        return myFunction == SumoXMLEdgeFunc::INTERNAL;
    }
 
    inline bool isCrossing() const {
        return myFunction == SumoXMLEdgeFunc::CROSSING;
    }
 
    inline bool isWalkingArea() const {
        return myFunction == SumoXMLEdgeFunc::WALKINGAREA;
    }
 
    inline bool isTazConnector() const {
        return myFunction == SumoXMLEdgeFunc::CONNECTOR;
    }
 
    void setOtherTazConnector(const ROEdge* edge) {
        myOtherTazConnector = edge;
    }
 
    const ROEdge* getOtherTazConnector() const {
        return myOtherTazConnector;
    }
 
    void buildTimeLines(const std::string& measure, const bool boundariesOverride);
 
    void cacheParamRestrictions(const std::vector<std::string>& restrictionKeys);
 
 
 
 
 
    inline SumoXMLEdgeFunc getFunction() const {
        return myFunction;
    }
 
 
    inline bool isSink() const {
        return myAmSink;
    }
 
 
    double getLength() const {
        return myLength;
    }
 
    int getNumericalID() const {
        return myIndex;
    }
 
 
    double getSpeedLimit() const {
        return mySpeed;
    }
 
    // sufficient for the astar air-distance heuristic
    double getLengthGeometryFactor() const;
 
    int getNumLanes() const {
        return (int) myLanes.size();
    }
 
 
    bool isConnectedTo(const ROEdge& e, const SUMOVehicleClass vClass, bool ignoreTransientPermissions = false) const;
 
 
    inline bool prohibits(const ROVehicle* const vehicle, bool checkRestrictions = false) const {
        const SUMOVehicleClass vclass = vehicle->getVClass();
        return (myCombinedPermissions & vclass) != vclass || (checkRestrictions && restricts(vehicle));
    }
 
    inline SVCPermissions getPermissions() const {
        return myCombinedPermissions;
    }
 
    inline bool restricts(const ROVehicle* const vehicle) const {
        const std::vector<double>& vTypeRestrictions = vehicle->getType()->paramRestrictions;
        assert(vTypeRestrictions.size() == myParamRestrictions.size());
        for (int i = 0; i < (int)vTypeRestrictions.size(); i++) {
            if (vTypeRestrictions[i] > myParamRestrictions[i]) {
                return true;
            }
        }
        return false;
    }
 
 
    bool allFollowersProhibit(const ROVehicle* const vehicle) const;
 
 
 
 
 
    void addEffort(double value, double timeBegin, double timeEnd);
 
 
    void addTravelTime(double value, double timeBegin, double timeEnd);
 
 
    int getNumSuccessors() const;
 
 
    const ROEdgeVector& getSuccessors(SUMOVehicleClass vClass = SVC_IGNORING) const;
 
    const ROConstEdgePairVector& getViaSuccessors(SUMOVehicleClass vClass = SVC_IGNORING, bool ignoreTransientPermissions = false) const;
 
 
    int getNumPredecessors() const;
 
 
    const ROEdgeVector& getPredecessors() const {
        return myApproachingEdges;
    }
 
    const ROEdge* getNormalBefore() const;
 
    const ROEdge* getNormalAfter() const;
 
    double getEffort(const ROVehicle* const veh, double time) const;
 
 
    bool hasLoadedTravelTime(double time) const;
 
 
    double getTravelTime(const ROVehicle* const veh, double time) const;
 
 
    static inline double getEffortStatic(const ROEdge* const edge, const ROVehicle* const veh, double time) {
        return edge->getEffort(veh, time);
    }
 
 
    static inline double getTravelTimeStatic(const ROEdge* const edge, const ROVehicle* const veh, double time) {
        return edge->getTravelTime(veh, time) * getRoutingFactor(edge, veh);
    }
 
    static inline double getTravelTimeStaticRandomized(const ROEdge* const edge, const ROVehicle* const veh, double time) {
        return edge->getTravelTime(veh, time)
            * (1 + RandHelper::randHash(veh->getRandomSeed() ^ edge->getNumericalID()) * (gWeightsRandomFactor - 1))
            * getRoutingFactor(edge, veh);
    }
 
    static inline double getTravelTimeAggregated(const ROEdge* const edge, const ROVehicle* const veh, double time) {
        return edge->getTravelTime(veh, time) * getRoutingFactor(edge, veh);
    }
 
    static inline double getTravelTimeStaticPriorityFactor(const ROEdge* const edge, const ROVehicle* const veh, double time) {
        double result = edge->getTravelTime(veh, time);
        // lower priority should result in higher effort (and the edge with
        // minimum priority receives a factor of myPriorityFactor
        const double relativeInversePrio = 1 - ((edge->getPriority() - myMinEdgePriority) / myEdgePriorityRange);
        result *= 1 + relativeInversePrio * myPriorityFactor;
        return result * getRoutingFactor(edge, veh);
    }
 
    static inline double getRoutingFactor(const ROEdge* const edge, const ROVehicle* const veh) {
        return gRoutingPreferences ?  1 / edge->getPreference(veh->getVTypeParameter()) : 1;
    }
 
 
    inline double getMinimumTravelTime(const ROVehicle* const veh) const {
        if (isTazConnector()) {
            return 0;
        } else if (veh != 0) {
            return myLength / getMaxSpeed(veh);
        } else {
            return myLength / mySpeed;
        }
    }
 
    inline double getMaxSpeed(const RORoutable* const veh) const {
        return MIN2(veh->getMaxSpeed(), veh->getChosenSpeedFactor() * getVClassMaxSpeed(veh->getVClass()));
    }
 
    inline double getVClassMaxSpeed(SUMOVehicleClass vclass) const {
        if (mySpeedRestrictions != 0) {
            std::map<SUMOVehicleClass, double>::const_iterator r = mySpeedRestrictions->find(vclass);
            if (r != mySpeedRestrictions->end()) {
                return r->second;
            }
        }
        return mySpeed;
    }
 
    template<PollutantsInterface::EmissionType ET>
    static double getEmissionEffort(const ROEdge* const edge, const ROVehicle* const veh, double time) {
        double ret = 0;
        if (!edge->getStoredEffort(time, ret)) {
            const SUMOVTypeParameter* const type = veh->getType();
            const double vMax = edge->getMaxSpeed(veh);
            const double accel = type->getCFParam(SUMO_ATTR_ACCEL, SUMOVTypeParameter::getDefaultAccel(type->vehicleClass)) * type->getCFParam(SUMO_ATTR_SIGMA, SUMOVTypeParameter::getDefaultImperfection(type->vehicleClass)) / 2.;
            ret = PollutantsInterface::computeDefault(type->emissionClass, ET, vMax, accel, 0, edge->getTravelTime(veh, time), nullptr); // @todo: give correct slope
        }
        return ret;
    }
 
 
    static double getNoiseEffort(const ROEdge* const edge, const ROVehicle* const veh, double time);
 
    static double getStoredEffort(const ROEdge* const edge, const ROVehicle* const /*veh*/, double time) {
        double ret = 0;
        edge->getStoredEffort(time, ret);
        return ret;
    }
 
 
    double getDistanceTo(const ROEdge* other, const bool doBoundaryEstimate = false) const;
 
 
    static const ROEdgeVector& getAllEdges();
 
    static void setGlobalOptions(const bool interpolate) {
        myInterpolate = interpolate;
    }
 
    static void disableTimelineWarning() {
        myHaveTTWarned = true;
    }
 
    static const Position getStopPosition(const SUMOVehicleParameter::Stop& stop);
 
    inline double getPreference(const SUMOVTypeParameter& pars) const {
        return RONet::getInstance()->getPreference(getRoutingType(), pars);
    }
 
    int getPriority() const {
        return myPriority;
    }
 
    const std::string& getType() const {
        return myType;
    }
 
    const std::string& getRoutingType() const {
        return myRoutingType.empty() ? myType : myRoutingType;
    }
 
    const RONode* getFromJunction() const {
        return myFromJunction;
    }
 
    const RONode* getToJunction() const {
        return myToJunction;
    }
 
    const std::vector<ROLane*>& getLanes() const {
        return myLanes;
    }
 
    inline const ROEdge* getBidiEdge() const {
        return myBidiEdge;
    }
 
    inline void setBidiEdge(const ROEdge* bidiEdge) {
        myBidiEdge = bidiEdge;
    }
 
    ReversedEdge<ROEdge, ROVehicle>* getReversedRoutingEdge() const {
        if (myReversedRoutingEdge == nullptr) {
            myReversedRoutingEdge = new ReversedEdge<ROEdge, ROVehicle>(this);
        }
        return myReversedRoutingEdge;
    }
 
    // @note If not called before, the flipped routing edge is created
    FlippedEdge<ROEdge, RONode, ROVehicle>* getFlippedRoutingEdge() const {
        if (myFlippedRoutingEdge == nullptr) {
            myFlippedRoutingEdge = new FlippedEdge<ROEdge, RONode, ROVehicle>(this);
        }
        return myFlippedRoutingEdge;
    }
 
    RailEdge<ROEdge, ROVehicle>* getRailwayRoutingEdge() const {
        if (myRailwayRoutingEdge == nullptr) {
            myRailwayRoutingEdge = new RailEdge<ROEdge, ROVehicle>(this);
        }
        return myRailwayRoutingEdge;
    }
 
    bool hasStoredEffort() const {
        return myUsingETimeLine;
    }
 
    static bool initPriorityFactor(double priorityFactor);
 
protected:
    bool getStoredEffort(double time, double& ret) const;
 
protected:
    RONode* myFromJunction;
    RONode* myToJunction;
 
    const int myIndex;
 
    const int myPriority;
 
    const std::string myType;
 
    const std::string myRoutingType;
 
    double mySpeed;
 
    double myLength;
 
    bool myAmSink, myAmSource;
    mutable ValueTimeLine<double> myTravelTimes;
    bool myUsingTTTimeLine;
 
    mutable ValueTimeLine<double> myEfforts;
    bool myUsingETimeLine;
 
    static bool myInterpolate;
 
    static bool myHaveEWarned;
    static bool myHaveTTWarned;
 
    ROEdgeVector myFollowingEdges;
 
    ROConstEdgePairVector myFollowingViaEdges;
 
    ROEdgeVector myApproachingEdges;
 
    SumoXMLEdgeFunc myFunction;
 
    const std::map<SUMOVehicleClass, double>* mySpeedRestrictions;
 
    std::vector<ROLane*> myLanes;
 
    SVCPermissions myCombinedPermissions;
 
    const ROEdge* myOtherTazConnector;
 
    const ROEdge* myBidiEdge;
 
    Boundary myBoundary;
 
    double myTimePenalty;
 
    std::vector<double> myParamRestrictions;
 
    static ROEdgeVector myEdges;
 
    static double myPriorityFactor;
    static double myMinEdgePriority;
    static double myEdgePriorityRange;
 
    mutable std::map<SUMOVehicleClass, ROEdgeVector> myClassesSuccessorMap;
 
    mutable std::map<SUMOVehicleClass, ROConstEdgePairVector> myClassesViaSuccessorMap;
 
    mutable ReversedEdge<ROEdge, ROVehicle>* myReversedRoutingEdge = nullptr;
    mutable FlippedEdge<ROEdge, RONode, ROVehicle>* myFlippedRoutingEdge = nullptr;
    mutable RailEdge<ROEdge, ROVehicle>* myRailwayRoutingEdge = nullptr;
 
#ifdef HAVE_FOX
    mutable FXMutex myLock;
#endif
 
private:
    ROEdge(const ROEdge& src);
 
    ROEdge& operator=(const ROEdge& src);
 
};