MSLane.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
/****************************************************************************/
// Representation of a lane in the micro simulation
/****************************************************************************/
#ifndef MSLane_h
#define MSLane_h


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

#include <vector>
#include <deque>
#include <cassert>
#include <utils/common/Named.h>
#include <utils/common/Parameterised.h>
#include <utils/common/SUMOVehicleClass.h>
#include <utils/vehicle/SUMOVehicle.h>
#include <utils/common/NamedRTree.h>
#include <utils/geom/PositionVector.h>
#include "MSLinkCont.h"
#include "MSLeaderInfo.h"
#include "MSMoveReminder.h"
#include <libsumo/Helper.h>


// ===========================================================================
// class declarations
// ===========================================================================
class MSEdge;
class MSVehicle;
class MSLaneChanger;
class MSLink;
class MSVehicleTransfer;
class MSVehicleControl;
class OutputDevice;
class MSLeaderInfo;


// ===========================================================================
// class definitions
// ===========================================================================
class MSLane : public Named, public Parameterised {
public:
    friend class MSLaneChanger;
    friend class MSLaneChangerSublane;

    friend class MSXMLRawOut;

    friend class MSQueueExport;
    friend class AnyVehicleIterator;

    typedef std::vector<MSVehicle*> VehCont;

    struct VehPosition : public std::binary_function < const MSVehicle*, double, bool > {
        bool operator()(const MSVehicle* cmp, double pos) const;
    };

    // TODO: Better documentation
    class AnyVehicleIterator {
    public:
        AnyVehicleIterator(
            const MSLane* lane,
            int i1,
            int i2,
            int i3,
            const int i1End,
            const int i2End,
            const int i3End,
            bool downstream = true) :
            myLane(lane),
            myI1(i1),
            myI2(i2),
            myI3(i3),
            myI1End(i1End),
            myI2End(i2End),
            myI3End(i3End),
            myDownstream(downstream),
            myDirection(downstream ? 1 : -1) {
        }

        bool operator== (AnyVehicleIterator const& other) const {
            return (myI1 == other.myI1
                    && myI2 == other.myI2
                    && myI3 == other.myI3
                    && myI1End == other.myI1End
                    && myI2End == other.myI2End
                    && myI3End == other.myI3End);
        }

        bool operator!= (AnyVehicleIterator const& other) const {
            return !(*this == other);
        }

        const MSVehicle* operator->() {
            return **this;
        }

        const MSVehicle* operator*();

        AnyVehicleIterator& operator++();

    private:
        bool nextIsMyVehicles() const;

        const MSLane* myLane;
        int myI1;
        int myI2;
        int myI3;
        int myI1End;
        int myI2End;
        int myI3End;
        bool myDownstream;
        int myDirection;

    };


public:
    enum CollisionAction {
        COLLISION_ACTION_NONE,
        COLLISION_ACTION_WARN,
        COLLISION_ACTION_TELEPORT,
        COLLISION_ACTION_REMOVE
    };

    MSLane(const std::string& id, double maxSpeed, double length, MSEdge* const edge,
           int numericalID, const PositionVector& shape, double width,
           SVCPermissions permissions, int index, bool isRampAccel);


    virtual ~MSLane();




    void addLink(MSLink* link);

    void addNeigh(const std::string& id);




    virtual void addMoveReminder(MSMoveReminder* rem);


    inline const std::vector< MSMoveReminder* >& getMoveReminders() const {
        return myMoveReminders;
    }




    bool insertVehicle(MSVehicle& v);


    bool isInsertionSuccess(MSVehicle* vehicle, double speed, double pos, double posLat,
                            bool recheckNextLanes,
                            MSMoveReminder::Notification notification);

    // XXX: Documentation?
    bool checkFailure(const MSVehicle* aVehicle, double& speed, double& dist, const double nspeed, const bool patchSpeed, const std::string errorMsg) const;

    bool lastInsertion(MSVehicle& veh, double mspeed, double posLat, bool patchSpeed);

    bool freeInsertion(MSVehicle& veh, double speed, double posLat,
                       MSMoveReminder::Notification notification = MSMoveReminder::NOTIFICATION_DEPARTED);


    void forceVehicleInsertion(MSVehicle* veh, double pos, MSMoveReminder::Notification notification, double posLat = 0);




    virtual double setPartialOccupation(MSVehicle* v);

    virtual void resetPartialOccupation(MSVehicle* v);

    virtual void setManeuverReservation(MSVehicle* v);

    virtual void resetManeuverReservation(MSVehicle* v);

    const MSLeaderInfo& getLastVehicleInformation(const MSVehicle* ego, double latOffset, double minPos = 0, bool allowCached = true) const;

    const MSLeaderInfo& getFirstVehicleInformation(const MSVehicle* ego, double latOffset, bool onlyFrontOnLane, double maxPos = std::numeric_limits<double>::max(), bool allowCached = true) const;



    int getVehicleNumber() const {
        return (int)myVehicles.size();
    }

    int getVehicleNumberWithPartials() const {
        return (int)myVehicles.size() + (int)myPartialVehicles.size();
    }

    int getPartialVehicleNumber() const {
        return (int)myPartialVehicles.size();
    }


    virtual const VehCont& getVehiclesSecure() const {
        return myVehicles;
    }


    AnyVehicleIterator anyVehiclesBegin() const {
        return AnyVehicleIterator(this, 0, 0, 0,
                                  (int)myVehicles.size(), (int)myPartialVehicles.size(), (int)myTmpVehicles.size(), true);
    }

    AnyVehicleIterator anyVehiclesEnd() const {
        return AnyVehicleIterator(this, (int)myVehicles.size(), (int)myPartialVehicles.size(), (int)myTmpVehicles.size(),
                                  (int)myVehicles.size(), (int)myPartialVehicles.size(), (int)myTmpVehicles.size(), true);
    }

    AnyVehicleIterator anyVehiclesUpstreamBegin() const {
        return AnyVehicleIterator(this, (int)myVehicles.size() - 1, (int)myPartialVehicles.size() - 1, (int)myTmpVehicles.size() - 1,
                                  -1, -1, -1, false);
    }

    AnyVehicleIterator anyVehiclesUpstreamEnd() const {
        return AnyVehicleIterator(this, -1, -1, -1, -1, -1, -1, false);
    }

    virtual void releaseVehicles() const { }





    inline int getNumericalID() const {
        return myNumericalID;
    }


    inline const PositionVector& getShape() const {
        return myShape;
    }

    inline double getLengthGeometryFactor() const {
        return myLengthGeometryFactor;
    }

    inline bool isAccelLane() const {
        return myIsRampAccel;
    }

    /* @brief fit the given lane position to a visibly suitable geometry position
     * (lane length might differ from geometry length) */
    inline double interpolateLanePosToGeometryPos(double lanePos) const {
        return lanePos * myLengthGeometryFactor;
    }

    /* @brief fit the given lane position to a visibly suitable geometry position
     * and return the coordinates */
    inline const Position geometryPositionAtOffset(double offset, double lateralOffset = 0) const {
        return myShape.positionAtOffset(interpolateLanePosToGeometryPos(offset), lateralOffset);
    }

    /* @brief fit the given geomtry position to a valid lane position
     * (lane length might differ from geometry length) */
    inline double interpolateGeometryPosToLanePos(double geometryPos) const {
        return geometryPos / myLengthGeometryFactor;
    }

    inline double getVehicleMaxSpeed(const SUMOVehicle* const veh) const {
        if (myRestrictions != 0) {
            std::map<SUMOVehicleClass, double>::const_iterator r = myRestrictions->find(veh->getVClass());
            if (r != myRestrictions->end()) {
                return MIN2(veh->getMaxSpeed(), r->second * veh->getChosenSpeedFactor());
            }
        }
        return MIN2(veh->getMaxSpeed(), myMaxSpeed * veh->getChosenSpeedFactor());
    }


    inline double getSpeedLimit() const {
        return myMaxSpeed;
    }


    inline double getLength() const {
        return myLength;
    }


    inline SVCPermissions getPermissions() const {
        return myPermissions;
    }


    double getWidth() const {
        return myWidth;
    }

    int getIndex() const {
        return myIndex;
    }

    int getCrossingIndex() const;



    virtual void planMovements(const SUMOTime t);

    void updateLeaderInfo(const MSVehicle* veh, VehCont::reverse_iterator& vehPart, VehCont::reverse_iterator& vehRes, MSLeaderInfo& ahead) const;

    virtual bool executeMovements(SUMOTime t, std::vector<MSLane*>& lanesWithVehiclesToIntegrate);

    virtual bool integrateNewVehicle(SUMOTime t);



    virtual void detectCollisions(SUMOTime timestep, const std::string& stage);


    virtual bool appropriate(const MSVehicle* veh);


    const MSLinkCont& getLinkCont() const;

    MSLink* getLinkTo(const MSLane*) const;

    MSLink* getEntryLink() const;


    bool empty() const {
        assert(myVehBuffer.size() == 0);
        return myVehicles.empty();
    }

    void setMaxSpeed(double val);

    void setLength(double val);

    MSEdge& getEdge() const {
        return *myEdge;
    }


    const MSEdge* getNextNormal() const;


    const MSLane* getFirstInternalInConnection(double& offset) const;



    static bool dictionary(const std::string& id, MSLane* lane);


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


    static void clear();


    static int dictSize() {
        return (int)myDict.size();
    }


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


    template<class RTREE>
    static void fill(RTREE& into);



    // XXX: succLink does not exist... Documentation?
    static MSLinkCont::const_iterator succLinkSec(const SUMOVehicle& veh,
            int nRouteSuccs,
            const MSLane& succLinkSource,
            const std::vector<MSLane*>& conts);


    bool isLinkEnd(MSLinkCont::const_iterator& i) const;

    bool isLinkEnd(MSLinkCont::iterator& i);

    bool isEmpty() const;

    bool isInternal() const;

    MSVehicle* getLastFullVehicle() const;

    MSVehicle* getFirstFullVehicle() const;

    MSVehicle* getLastAnyVehicle() const;

    MSVehicle* getFirstAnyVehicle() const;

    /* @brief remove the vehicle from this lane
     * @param[notify] whether moveReminders of the vehicle shall be triggered
     */
    virtual MSVehicle* removeVehicle(MSVehicle* remVehicle, MSMoveReminder::Notification notification, bool notify = true);

    void leftByLaneChange(MSVehicle* v);
    void enteredByLaneChange(MSVehicle* v);

    MSLane* getParallelLane(int offset) const;


    void setPermissions(SVCPermissions permissions, long long transientID);
    void resetPermissions(long long transientID);


    inline bool allowsVehicleClass(SUMOVehicleClass vclass) const {
        return (myPermissions & vclass) == vclass;
    }

    void addIncomingLane(MSLane* lane, MSLink* viaLink);


    struct IncomingLaneInfo {
        MSLane* lane;
        double length;
        MSLink* viaLink;
    };

    const std::vector<IncomingLaneInfo>& getIncomingLanes() const {
        return myIncomingLanes;
    }


    void addApproachingLane(MSLane* lane, bool warnMultiCon);
    bool isApproachedFrom(MSEdge* const edge);
    bool isApproachedFrom(MSEdge* const edge, MSLane* const lane);

    double getStopOffset(const MSVehicle* veh) const;

    const std::map<SVCPermissions, double>& getStopOffsets() const {
        return myStopOffsets;
    };

    void setStopOffsets(std::map<SVCPermissions, double> stopOffsets) {
        myStopOffsets = stopOffsets;
    };

    MSLeaderDistanceInfo getFollowersOnConsecutive(const MSVehicle* ego, double backOffset,
            bool allSublanes, double searchDist = -1, bool ignoreMinorLinks = false) const;

    double getMissingRearGap(const MSVehicle* leader, double backOffset, double leaderSpeed) const;

    std::pair<MSVehicle* const, double> getLeader(const MSVehicle* veh, const double vehPos, const std::vector<MSLane*>& bestLaneConts, double dist = -1, bool checkTmpVehicles = false) const;

    std::pair<MSVehicle* const, double> getLeaderOnConsecutive(double dist, double seen,
            double speed, const MSVehicle& veh, const std::vector<MSLane*>& bestLaneConts) const;

    void getLeadersOnConsecutive(double dist, double seen, double speed, const MSVehicle* ego,
                                 const std::vector<MSLane*>& bestLaneConts, MSLeaderDistanceInfo& result) const;

    std::pair<MSVehicle* const, double> getCriticalLeader(double dist, double seen, double speed, const MSVehicle& veh) const;

    /* @brief return the partial vehicle closest behind ego or 0
     * if no such vehicle exists */
    MSVehicle* getPartialBehind(const MSVehicle* ego) const;

    MSLeaderInfo getPartialBeyond() const;

    MSLane* getLogicalPredecessorLane() const;

    MSLane* getLogicalPredecessorLane(const MSEdge& fromEdge) const;


    MSLane* getCanonicalPredecessorLane() const;


    MSLane* getCanonicalSuccessorLane() const;

    LinkState getIncomingLinkState() const;

    const std::vector<std::pair<const MSLane*, const MSEdge*> > getOutgoingViaLanes() const;



    double getMeanSpeed() const;

    double getWaitingSeconds() const;


    double getBruttoOccupancy() const;


    double getNettoOccupancy() const;


    inline double getBruttoVehLenSum() const {
        return myBruttoVehicleLengthSum;
    }


    double getCO2Emissions() const;


    double getCOEmissions() const;


    double getPMxEmissions() const;


    double getNOxEmissions() const;


    double getHCEmissions() const;


    double getFuelConsumption() const;


    double getElectricityConsumption() const;


    double getHarmonoise_NoiseEmissions() const;

    void setRightSideOnEdge(double value, int rightmostSublane) {
        myRightSideOnEdge = value;
        myRightmostSublane = rightmostSublane;
    }

    void initRestrictions();

    double getRightSideOnEdge() const {
        return myRightSideOnEdge;
    }

    int getRightmostSublane() const {
        return myRightmostSublane;
    }

    double getCenterOnEdge() const {
        return myRightSideOnEdge + 0.5 * myWidth;
    }

    void sortPartialVehicles();

    void sortManeuverReservations();

    MSLane* getOpposite() const;

    double getOppositePos(double pos) const;

    /* @brief find leader for a vehicle depending on the relative driving direction
     * @param[in] ego The ego vehicle
     * @param[in] dist The look-ahead distance when looking at consecutive lanes
     * @param[in] oppositeDir Whether the lane has the opposite driving direction of ego
     * @return the leader vehicle and it's gap to ego
     */
    std::pair<MSVehicle* const, double> getOppositeLeader(const MSVehicle* ego, double dist, bool oppositeDir) const;

    /* @brief find follower for a vehicle that is located on the opposite of this lane
     * @param[in] ego The ego vehicle
     * @return the follower vehicle and it's gap to ego
     */
    std::pair<MSVehicle* const, double> getOppositeFollower(const MSVehicle* ego) const;


    std::pair<MSVehicle* const, double> getFollower(const MSVehicle* ego, double egoPos, double dist, bool ignoreMinorLinks) const;


    void addParking(MSVehicle* veh);

    virtual void removeParking(MSVehicle* veh);

    const std::set<const MSVehicle*>& getParkingVehicles() const {
        return myParkingVehicles;
    }

    virtual bool isSelected() const {
        return false;
    }


    void saveState(OutputDevice& out);

    void loadState(std::vector<std::string>& vehIDs, MSVehicleControl& vc);


    void visit(const LaneStoringVisitor& cont) const {
        cont.add(this);
    }

    static void initCollisionOptions(const OptionsCont& oc);

    static bool teleportOnCollision() {
        return myCollisionAction == COLLISION_ACTION_TELEPORT;
    }

    static CollisionAction getCollisionAction() {
        return myCollisionAction;
    }

    static const long CHANGE_PERMISSIONS_PERMANENT = 0;
    static const long CHANGE_PERMISSIONS_GUI = 1;

protected:
    virtual void swapAfterLaneChange(SUMOTime t);

    virtual void incorporateVehicle(MSVehicle* veh, double pos, double speed, double posLat,
                                    const MSLane::VehCont::iterator& at,
                                    MSMoveReminder::Notification notification = MSMoveReminder::NOTIFICATION_DEPARTED);

    void detectPedestrianJunctionCollision(const MSVehicle* collider, const PositionVector& colliderBoundary, const MSLane* foeLane,
                                           SUMOTime timestep, const std::string& stage);

    bool detectCollisionBetween(SUMOTime timestep, const std::string& stage, MSVehicle* collider, MSVehicle* victim,
                                std::set<const MSVehicle*, ComparatorIdLess>& toRemove,
                                std::set<const MSVehicle*>& toTeleport) const;

    void handleCollisionBetween(SUMOTime timestep, const std::string& stage, MSVehicle* collider, MSVehicle* victim,
                                double gap, double latGap,
                                std::set<const MSVehicle*, ComparatorIdLess>& toRemove,
                                std::set<const MSVehicle*>& toTeleport) const;

    double getMaximumBrakeDist() const;

    /* @brief determine depart speed and whether it may be patched
     * @param[in] veh The departing vehicle
     * @param[out] whether the speed may be patched to account for safety
     * @return the depart speed
     */
    double getDepartSpeed(const MSVehicle& veh, bool& patchSpeed);

    /* @brief determine the lateral depart position
     * @param[in] veh The departing vehicle
     * @return the lateral depart position
     */
    double getDepartPosLat(const MSVehicle& veh);

    double safeInsertionSpeed(const MSVehicle* veh, double seen, const MSLeaderInfo& leaders, double speed);

    bool checkForPedestrians(const MSVehicle* aVehicle, double& speed, double& dist, double pos, bool patchSpeed) const;

    int myNumericalID;

    PositionVector myShape;

    int myIndex;

    VehCont myVehicles;

    VehCont myPartialVehicles;

    VehCont myTmpVehicles;

    VehCont myVehBuffer;

    VehCont myManeuverReservations;

    /* @brief list of vehicles that are parking near this lane
     * (not necessarily on the road but having reached their stop on this lane)
     * */
    std::set<const MSVehicle*> myParkingVehicles;

    double myLength;

    const double myWidth;

    std::map<SVCPermissions, double> myStopOffsets;

    MSEdge* const myEdge;

    double myMaxSpeed;

    SVCPermissions myPermissions;

    SVCPermissions myOriginalPermissions;

    const std::map<SUMOVehicleClass, double>* myRestrictions;

    std::vector<IncomingLaneInfo> myIncomingLanes;

    mutable MSLane* myLogicalPredecessorLane;

    mutable MSLane* myCanonicalPredecessorLane;

    mutable MSLane* myCanonicalSuccessorLane;

    double myBruttoVehicleLengthSum;

    double myNettoVehicleLengthSum;

    MSLinkCont myLinks;

    std::map<MSEdge*, std::vector<MSLane*> > myApproachingLanes;

    mutable MSLeaderInfo myLeaderInfo;
    mutable MSLeaderInfo myFollowerInfo;

    mutable MSLeaderInfo myLeaderInfoTmp;

    mutable SUMOTime myLeaderInfoTime;
    mutable SUMOTime myFollowerInfoTime;

    const double myLengthGeometryFactor;

    const bool myIsRampAccel;

    double myRightSideOnEdge;
    int myRightmostSublane;

    // @brief the ids of neighboring lanes
    std::vector<std::string> myNeighs;

    // @brief transient changes in permissions
    std::map<long long, SVCPermissions> myPermissionChanges;

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

    static DictType myDict;

private:
    std::vector< MSMoveReminder* > myMoveReminders;

    static CollisionAction myCollisionAction;
    static bool myCheckJunctionCollisions;
    static SUMOTime myCollisionStopTime;
    static double myCollisionMinGapFactor;

    class vehicle_position_sorter {
    public:
        explicit vehicle_position_sorter(const MSLane* lane) :
            myLane(lane) {
        }


        int operator()(MSVehicle* v1, MSVehicle* v2) const;

        const MSLane* myLane;

    };

    class vehicle_natural_position_sorter {
    public:
        explicit vehicle_natural_position_sorter(const MSLane* lane) :
            myLane(lane) {
        }


        int operator()(MSVehicle* v1, MSVehicle* v2) const;

        const MSLane* myLane;

    };

    class by_connections_to_sorter {
    public:
        explicit by_connections_to_sorter(const MSEdge* const e);

        int operator()(const MSEdge* const e1, const MSEdge* const e2) const;

    private:
        by_connections_to_sorter& operator=(const by_connections_to_sorter&); // just to avoid a compiler warning
    private:
        const MSEdge* const myEdge;
        double myLaneDir;
    };



    class incoming_lane_priority_sorter {
    public:
        explicit incoming_lane_priority_sorter(const MSLane* targetLane);

        int operator()(const IncomingLaneInfo& lane1, const IncomingLaneInfo& lane2) const;

    private:
        incoming_lane_priority_sorter& operator=(const incoming_lane_priority_sorter&); // just to avoid a compiler warning
    private:
        const MSLane* const myLane;
        double myLaneDir;
    };


    class outgoing_lane_priority_sorter {
    public:
        explicit outgoing_lane_priority_sorter(const MSLane* sourceLane);

        int operator()(const MSLink* link1, const MSLink* link2) const;

    private:
        outgoing_lane_priority_sorter& operator=(const outgoing_lane_priority_sorter&); // just to avoid a compiler warning
    private:
        const MSLane* const myLane;
        double myLaneDir;
    };

    class edge_finder {
    public:
        edge_finder(MSEdge* e) : myEdge(e) {}
        bool operator()(const IncomingLaneInfo& ili) const {
            return &(ili.lane->getEdge()) == myEdge;
        }
    private:
        edge_finder& operator=(const edge_finder&); // just to avoid a compiler warning
    private:
        const MSEdge* const myEdge;
    };

private:
    MSLane(const MSLane&);

    MSLane& operator=(const MSLane&);


};


#endif

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