MSLink.h

Go to the documentation of this file.

/****************************************************************************/
// A connnection between lanes
/****************************************************************************/
// SUMO, Simulation of Urban MObility; see http://sumo.dlr.de/
// Copyright (C) 2002-2017 DLR (http://www.dlr.de/) and contributors
/****************************************************************************/
//
//   This file is part of SUMO.
//   SUMO is free software: you can redistribute it and/or modify
//   it under the terms of the GNU General Public License as published by
//   the Free Software Foundation, either version 3 of the License, or
//   (at your option) any later version.
//
/****************************************************************************/
#ifndef MSLink_h
#define MSLink_h


// ===========================================================================
// included modules
// ===========================================================================
#ifdef _MSC_VER
#include <windows_config.h>
#else
#include <config.h>
#endif

#include <vector>
#include <set>
#include <utils/common/SUMOTime.h>
#include <utils/common/SUMOVehicleClass.h>
#include <utils/xml/SUMOXMLDefinitions.h>


// ===========================================================================
// class declarations
// ===========================================================================
class MSLane;
class MSJunction;
class SUMOVehicle;
class MSVehicle;
class MSPerson;
class OutputDevice;
class MSTrafficLightLogic;


// ===========================================================================
// class definitions
// ===========================================================================
class MSLink {
public:

    // distance to link in m below which adaptation for zipper-merging should take place
    static const double ZIPPER_ADAPT_DIST;

    struct LinkLeader {
        LinkLeader(MSVehicle* _veh, double _gap, double _distToCrossing) :
            vehAndGap(std::make_pair(_veh, _gap)),
            distToCrossing(_distToCrossing) {}

        std::pair<MSVehicle*, double> vehAndGap;
        double distToCrossing;
    };

    typedef std::vector<LinkLeader> LinkLeaders;

    struct ApproachingVehicleInformation {
        ApproachingVehicleInformation(const SUMOTime _arrivalTime, const SUMOTime _leavingTime,
                                      const double _arrivalSpeed, const double _leaveSpeed,
                                      const bool _willPass,
                                      const SUMOTime _arrivalTimeBraking,
                                      const double _arrivalSpeedBraking,
                                      const SUMOTime _waitingTime,
                                      const double _dist
                                     ) :
            arrivalTime(_arrivalTime), leavingTime(_leavingTime),
            arrivalSpeed(_arrivalSpeed), leaveSpeed(_leaveSpeed),
            willPass(_willPass),
            arrivalTimeBraking(_arrivalTimeBraking),
            arrivalSpeedBraking(_arrivalSpeedBraking),
            waitingTime(_waitingTime),
            dist(_dist) {
        }

        const SUMOTime arrivalTime;
        const SUMOTime leavingTime;
        const double arrivalSpeed;
        const double leaveSpeed;
        const bool willPass;
        const SUMOTime arrivalTimeBraking;
        const double arrivalSpeedBraking;
        const SUMOTime waitingTime;
        const double dist;

    private:
        ApproachingVehicleInformation& operator=(const ApproachingVehicleInformation& s);

    };


    MSLink(MSLane* predLane, MSLane* succLane, MSLane* via, LinkDirection dir, LinkState state, double length, double foeVisibilityDistance, bool keepClear, MSTrafficLightLogic* logic, int tlLinkIdx);


    ~MSLink();


    void setRequestInformation(int index, bool hasFoes, bool isCont,
                               const std::vector<MSLink*>& foeLinks, const std::vector<MSLane*>& foeLanes,
                               MSLane* internalLaneBefore = 0);


    void setApproaching(const SUMOVehicle* approaching, const SUMOTime arrivalTime,
                        const double arrivalSpeed, const double leaveSpeed, const bool setRequest,
                        const SUMOTime arrivalTimeBraking, const double arrivalSpeedBraking,
                        const SUMOTime waitingTime, double dist);

    void removeApproaching(const SUMOVehicle* veh);

    void addBlockedLink(MSLink* link);

    /* @brief return information about this vehicle if it is registered as
     * approaching (dummy values otherwise)
     * @note used for visualisation of link items */
    ApproachingVehicleInformation getApproaching(const SUMOVehicle* veh) const;

    const std::map<const SUMOVehicle*, ApproachingVehicleInformation>& getApproaching() const {
        return myApproachingVehicles;
    }

    bool opened(SUMOTime arrivalTime, double arrivalSpeed, double leaveSpeed, double vehicleLength,
                double impatience, double decel, SUMOTime waitingTime,
                double posLat = 0,
                std::vector<const SUMOVehicle*>* collectFoes = 0) const;

    bool blockedAtTime(SUMOTime arrivalTime, SUMOTime leaveTime, double arrivalSpeed, double leaveSpeed,
                       bool sameTargetLane, double impatience, double decel, SUMOTime waitingTime,
                       std::vector<const SUMOVehicle*>* collectFoes = 0) const;


    bool isBlockingAnyone() const {
        return myApproachingVehicles.size() != 0;
    }

    bool willHaveBlockedFoe() const;



    bool hasApproachingFoe(SUMOTime arrivalTime, SUMOTime leaveTime, double speed, double decel) const;

    MSJunction* getJunction() const {
        return myJunction;
    }


    LinkState getState() const {
        return myState;
    }


    //@brief Returns the time of the last state change
    inline SUMOTime getLastStateChange() const {
        return myLastStateChange;
    }


    LinkDirection getDirection() const;


    void setTLState(LinkState state, SUMOTime t);


    MSLane* getLane() const;


    inline int getIndex() const {
        return myIndex;
    }

    inline int getTLIndex() const {
        return myTLIndex;
    }

    inline const MSTrafficLightLogic* getTLLogic() const {
        return myLogic;
    }

    inline bool havePriority() const {
        return myState >= 'A' && myState <= 'Z';
    }

    inline bool haveRed() const {
        return myState == LINKSTATE_TL_RED || myState == LINKSTATE_TL_REDYELLOW;
    }

    inline bool isTLSControlled() const {
        return myLogic != 0;
    }

    double getLength() const {
        return myLength;
    }


    double getFoeVisibilityDistance() const {
        return myFoeVisibilityDistance;
    }


    bool hasFoes() const {
        return myHasFoes;
    }

    // @todo documentation
    bool isCont() const {
        return myAmCont;
    }


    bool keepClear() const {
        return myKeepClear;
    }

    bool lastWasContMajor() const;

    double getInternalLengthsAfter() const;

    double getLengthBeforeCrossing(const MSLink* foeEntryLink) const;

    MSLane* getViaLane() const;

    LinkLeaders getLeaderInfo(const MSVehicle* ego, double dist, std::vector<const MSPerson*>* collectBlockers = 0) const;

    double getZipperSpeed(const MSVehicle* ego, const double dist, double vSafe,
                          SUMOTime arrivalTime,
                          std::vector<const SUMOVehicle*>* collectFoes) const;

    MSLane* getViaLaneOrLane() const;

    const MSLane* getLaneBefore() const;

    const MSLane* getInternalLaneBefore() const;

    SUMOTime getLeaveTime(const SUMOTime arrivalTime, const double arrivalSpeed, const double leaveSpeed, const double vehicleLength) const;

    void writeApproaching(OutputDevice& od, const std::string fromLaneID) const;

    void passedJunction(const MSVehicle* vehicle);

    MSLink* getParallelLink(int direction) const;

    bool isLeader(const MSVehicle* ego, const MSVehicle* foe) const;

    bool fromInternalLane() const;

    bool isExitLink() const;

    bool isInternalJunctionLink() const;

    SUMOTime getMesoTLSPenalty() const {
        return myMesoTLSPenalty;
    }

    double getGreenFraction() const {
        return myGreenFraction;
    }

    void setMesoTLSPenalty(const SUMOTime penalty) {
        myMesoTLSPenalty = penalty;
    }

    void setGreenFraction(const double fraction) {
        myGreenFraction = fraction;
    }

    const std::vector<const MSLane*>& getFoeLanes() {
        return myFoeLanes;
    }

    const std::vector<MSLink*>& getFoeLinks() {
        return myFoeLinks;
    }

    void initParallelLinks();

private:
    static inline bool unsafeMergeSpeeds(double leaderSpeed, double followerSpeed, double leaderDecel, double followerDecel) {
        // XXX mismatch between continuous an discrete deceleration
        return (leaderSpeed * leaderSpeed / leaderDecel) <= (followerSpeed * followerSpeed / followerDecel);
    }

    static bool maybeOccupied(MSLane* lane);

    static bool couldBrakeForLeader(double followDist, double leaderDist, const MSVehicle* follow, const MSVehicle* leader);

    MSLink* computeParallelLink(int direction);

    bool blockedByFoe(const SUMOVehicle* veh, const ApproachingVehicleInformation& avi, SUMOTime arrivalTime, SUMOTime leaveTime, double arrivalSpeed, double leaveSpeed,
                      bool sameTargetLane, double impatience, double decel, SUMOTime waitingTime) const;

private:
    MSLane* myLane;

    MSLane* myLaneBefore;

    std::map<const SUMOVehicle*, ApproachingVehicleInformation> myApproachingVehicles;
    std::set<MSLink*> myBlockedFoeLinks;

    int myIndex;

    const int myTLIndex;

    const MSTrafficLightLogic* myLogic;

    LinkState myState;

    SUMOTime myLastStateChange;

    LinkDirection myDirection;

    double myLength;

    double myFoeVisibilityDistance;

    bool myHasFoes;

    // @todo documentation
    bool myAmCont;

    bool myKeepClear;

    MSLane* const myInternalLane;

    /* @brief The preceding junction-internal lane, only used at
     * - exit links (from internal lane to normal lane)
     * - internal junction links (from internal lane to internal lane)
     */
    const MSLane* myInternalLaneBefore;

    SUMOTime myMesoTLSPenalty;
    double myGreenFraction;

    /* @brief lengths after the crossing point with foeLane
     * (lengthOnThis, lengthOnFoe)
     * (index corresponds to myFoeLanes)
     * empty vector for entry links
     * */
    std::vector<std::pair<double, double> > myLengthsBehindCrossing;

    // TODO: documentation
    std::vector<MSLink*> myFoeLinks;
    std::vector<const MSLane*> myFoeLanes;

    /* @brief with the same origin lane and the same destination edge that may
       be in conflict for sublane simulation */
    std::vector<MSLink*> mySublaneFoeLinks;

    static const SUMOTime myLookaheadTime;
    static const SUMOTime myLookaheadTimeZipper;

    MSLink* myParallelRight;
    MSLink* myParallelLeft;

    MSJunction* myJunction;

    MSLink(const MSLink& s);

    MSLink& operator=(const MSLink& s);

};


#endif

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