MSEdge.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
// Copyright (C) 2001-2018 German Aerospace Center (DLR) and others.
// This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v2.0
// which accompanies this distribution, and is available at
// http://www.eclipse.org/legal/epl-v20.html
// SPDX-License-Identifier: EPL-2.0
/****************************************************************************/
// A road/street connecting two junctions
/****************************************************************************/
#ifndef MSEdge_h
#define MSEdge_h


// ===========================================================================
// included modules
// ===========================================================================
#include <config.h>

#include <vector>
#include <map>
#include <string>
#include <iostream>
#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/vehicle/SUMOVehicle.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 MSContainer;
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 {
public:
    typedef std::map< const MSEdge*, std::vector<MSLane*>* > AllowedLanesCont;

    typedef std::map< SUMOVehicleClass, AllowedLanesCont > ClassedAllowedLanesCont;


public:
    MSEdge(const std::string& id, int numericalID, const SumoXMLEdgeFunc function,
           const std::string& streetName, const std::string& edgeType, int priority);


    virtual ~MSEdge();


    void initialize(const std::vector<MSLane*>* lanes);


    void recalcCache();


    void closeBuilding();

    void buildLaneChanger();

    /* @brief returns whether initizliaing a lane change is permitted on this edge
     * @note Has to be called after all sucessors and predecessors have been set (after closeBuilding())
     */
    bool allowsLaneChanging();


    MSLane* leftLane(const MSLane* const lane) const;


    MSLane* rightLane(const MSLane* const lane) const;


    MSLane* parallelLane(const MSLane* const lane, int offset) const;


    const std::vector<MSLane*>& getLanes() const {
        return *myLanes;
    }

    inline const std::set<MSTransportable*>& 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) const;


    const std::vector<MSLane*>* allowedLanes(SUMOVehicleClass vclass = SVC_IGNORING) const;




    inline SumoXMLEdgeFunc getFunction() const {
        return myFunction;
    }

    inline bool isInternal() const {
        return myFunction == EDGEFUNC_INTERNAL;
    }

    inline bool isCrossing() const {
        return myFunction == EDGEFUNC_CROSSING;
    }


    void checkAndRegisterBiDirEdge();

    inline const MSEdge* getBidiEdge() const {
        return myBidiEdge;
    }

    inline bool isWalkingArea() const {
        return myFunction == EDGEFUNC_WALKINGAREA;
    }

    inline bool isTazConnector() const {
        return myFunction == EDGEFUNC_CONNECTOR;
    }

    inline int getNumericalID() const {
        return myNumericalID;
    }


    const std::string& getStreetName() const {
        return myStreetName;
    }

    const std::string& getEdgeType() const {
        return myEdgeType;
    }

    int getPriority() const {
        return myPriority;
    }

    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);

    int getNumSuccessors() const {
        return (int) mySuccessors.size();
    }


    const MSEdgeVector& getSuccessors(SUMOVehicleClass vClass = SVC_IGNORING) const;

    const MSConstEdgePairVector& getViaSuccessors(SUMOVehicleClass vClass = SVC_IGNORING) 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) {
        myFromJunction = from;
        myToJunction = 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 == EDGEFUNC_CONNECTOR) {
            return 0;
        } else if (veh != 0) {
            return getLength() / getVehicleMaxSpeed(veh);
        } else {
            return getLength() / getSpeedLimit();
        }
    }


    static inline double getTravelTimeStatic(const MSEdge* const edge, const SUMOVehicle* const veh, double time) {
        return MSNet::getInstance()->getTravelTime(edge, veh, time);
    }

    double getRoutingSpeed() const;



    bool insertVehicle(SUMOVehicle& v, SUMOTime time, const bool checkOnly = false, const bool forceCheck = false) const;


    MSLane* getFreeLane(const std::vector<MSLane*>* allowed, const SUMOVehicleClass vclass, double departPos) const;


    MSLane* getDepartLane(MSVehicle& veh) const;


    inline SUMOTime getLastFailedInsertionTime() const {
        return myLastFailedInsertionTime;
    }


    inline void setLastFailedInsertionTime(SUMOTime time) const {
        myLastFailedInsertionTime = time;
    }


    virtual void changeLanes(SUMOTime t);


    const MSEdge* getInternalFollowingEdge(const MSEdge* followerAfterInternal) const;


    double getInternalFollowingLengthTo(const MSEdge* followerAfterInternal) const;

    const MSEdge* getNormalBefore() const;

    inline bool prohibits(const SUMOVehicle* const vehicle) const {
        if (vehicle == 0) {
            return false;
        }
        const SUMOVehicleClass svc = vehicle->getVClass();
        return (myCombinedPermissions & svc) != svc;
    }

    inline SVCPermissions getPermissions() const {
        return myCombinedPermissions;
    }

    double getWidth() const {
        return myWidth;
    }

    const std::vector<double> getSubLaneSides() const {
        return mySublaneSides;
    }

    void rebuildAllowedLanes();


    double getDistanceTo(const MSEdge* other) const;


    inline double getLength() const {
        return myLength;
    }


    double getSpeedLimit() const;

    double getLengthGeometryFactor() const;

    void setMaxSpeed(double val) const;

    double getVehicleMaxSpeed(const SUMOVehicle* const veh) const;


    virtual void addPerson(MSTransportable* p) const {
        myPersons.insert(p);
    }

    virtual void removePerson(MSTransportable* p) const {
        std::set<MSTransportable*>::iterator i = myPersons.find(p);
        if (i != myPersons.end()) {
            myPersons.erase(i);
        }
    }

    virtual void addContainer(MSTransportable* container) const {
        myContainers.insert(container);
    }

    virtual void removeContainer(MSTransportable* container) const {
        std::set<MSTransportable*>::iterator i = myContainers.find(container);
        if (i != myContainers.end()) {
            myContainers.erase(i);
        }
    }

    inline bool isRoundabout() const {
        return myAmRoundabout;
    }

    void markAsRoundabout() {
        myAmRoundabout = true;
    }

    void markDelayed() const {
        myAmDelayed = true;
    }

    // return whether there have been vehicles on this edge at least once
    inline bool isDelayed() const {
        return myAmDelayed;
    }

    bool hasLaneChanger() const {
        return myLaneChanger != 0;
    }

    bool canChangeToOpposite();

    const MSEdge* getOppositeEdge() const;

    double getMeanSpeed() const;

    bool hasMinorLink() const;

    bool isFringe() const {
        return myAmFringe;
    }

    virtual bool isSelected() const {
        return false;
    }

    virtual void lock() const {}

    virtual void unlock() const {};

    static bool dictionary(const std::string& id, MSEdge* edge);

    static MSEdge* dictionary(const std::string& id);

    static int dictSize();

    static const MSEdgeVector& getAllEdges();

    static void clear();

    static void insertIDs(std::vector<std::string>& into);


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);


protected:
    class by_id_sorter {
    public:
        explicit by_id_sorter() { }

        int operator()(const MSEdge* const e1, const MSEdge* const e2) const {
            return e1->getID() < e2->getID();
        }

    };

    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;
    };


    const std::vector<MSLane*>* allowedLanes(const MSEdge* destination,
            SUMOVehicleClass vclass = SVC_IGNORING) const;


    const std::vector<MSLane*>* getAllowedLanesWithDefault(const AllowedLanesCont& c, const MSEdge* dest) const;

    double getDepartPosBound(const MSVehicle& veh, bool upper = true) const;

protected:
    const int myNumericalID;

    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*> myPersons;

    mutable std::set<MSTransportable*> myContainers;


    AllowedLanesCont myAllowed;

    // @note: this map is filled on demand
    mutable ClassedAllowedLanesCont myClassedAllowed;

    SVCPermissions myMinimumPermissions;
    SVCPermissions myCombinedPermissions;

    std::string myStreetName;

    std::string myEdgeType;

    const int myPriority;

    double myWidth;

    double myLength;

    double myEmptyTraveltime;

    mutable bool myAmDelayed;

    bool myAmRoundabout;

    bool myAmFringe;

    std::vector<double> mySublaneSides;


    typedef std::map< std::string, MSEdge* > DictType;

    static DictType myDict;

    static MSEdgeVector myEdges;


    mutable std::map<SUMOVehicleClass, MSEdgeVector> myClassesSuccessorMap;

    mutable std::map<SUMOVehicleClass, MSConstEdgePairVector> myClassesViaSuccessorMap;

    Boundary myTazBoundary;

private:

    const MSEdge* myBidiEdge;

    MSEdge(const MSEdge&);

    MSEdge& operator=(const MSEdge&);

    bool isSuperposable(const MSEdge* other);
};


#endif

/****************************************************************************/