MSLane.h

Go to the documentation of this file.

/****************************************************************************/
// Representation of a lane in the micro simulation
/****************************************************************************/
// SUMO, Simulation of Urban MObility; see http://sumo.dlr.de/
// Copyright (C) 2001-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 MSLane_h
#define MSLane_h


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

#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"
#ifndef NO_TRACI
#include <traci-server/TraCIServerAPI_Lane.h>
#endif


// ===========================================================================
// 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*, SUMOReal, bool > {
        bool operator()(const MSVehicle* cmp, SUMOReal pos) const;
    };

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

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

        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 myI1End;
        int myI2End;
        bool myDownstream;
        int myDirection;

    };


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

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


    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, SUMOReal speed, SUMOReal pos, SUMOReal posLat,
                            bool recheckNextLanes,
                            MSMoveReminder::Notification notification);

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

    bool lastInsertion(MSVehicle& veh, SUMOReal mspeed, bool patchSpeed);

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


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




    virtual SUMOReal setPartialOccupation(MSVehicle* v);

    virtual void resetPartialOccupation(MSVehicle* v);

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

    const MSLeaderInfo& getFirstVehicleInformation(const MSVehicle* ego, SUMOReal latOffset, bool onlyFrontOnLane, SUMOReal maxPos = std::numeric_limits<SUMOReal>::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, (int)myVehicles.size(), (int)myPartialVehicles.size(), true);
    }

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

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

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

    virtual void releaseVehicles() const { }





    inline int getNumericalID() const {
        return myNumericalID;
    }


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

    inline SUMOReal getLengthGeometryFactor() const {
        return myLengthGeometryFactor;
    }

    /* @brief fit the given lane position to a visibly suitable geometry position
     * (lane length might differ from geometry length) */
    inline SUMOReal interpolateLanePosToGeometryPos(SUMOReal 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(SUMOReal offset, SUMOReal 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 SUMOReal interpolateGeometryPosToLanePos(SUMOReal geometryPos) const {
        return geometryPos / myLengthGeometryFactor;
    }

    inline SUMOReal getVehicleMaxSpeed(const SUMOVehicle* const veh) const {
        if (myRestrictions != 0) {
            std::map<SUMOVehicleClass, SUMOReal>::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 SUMOReal getSpeedLimit() const {
        return myMaxSpeed;
    }


    inline SUMOReal getLength() const {
        return myLength;
    }


    inline SVCPermissions getPermissions() const {
        return myPermissions;
    }


    SUMOReal getWidth() const {
        return myWidth;
    }

    int getIndex() const {
        return myIndex;
    }

    int getCrossingIndex() const;



    virtual void planMovements(const SUMOTime t);

    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;

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

    void setMaxSpeed(SUMOReal val);

    void setLength(SUMOReal val);

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


    const MSEdge* getNextNormal() 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 transientID);
    void resetPermissions(long transientID);


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

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


    struct IncomingLaneInfo {
        MSLane* lane;
        SUMOReal 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);



    std::pair<MSVehicle* const, SUMOReal> getFollowerOnConsecutive(
        SUMOReal backOffset, SUMOReal leaderSpeed, SUMOReal leaderMaxDecel, SUMOReal dist = -1, bool ignoreMinorLinks = false) const;

    MSLeaderDistanceInfo getFollowersOnConsecutive(const MSVehicle* ego, bool allSublanes) const;

    SUMOReal getMissingRearGap(SUMOReal backOffset, SUMOReal leaderSpeed, SUMOReal leaderMaxDecel) const;

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

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

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

    std::pair<MSVehicle* const, SUMOReal> getCriticalLeader(SUMOReal dist, SUMOReal seen, SUMOReal 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;

    MSLane* getLogicalPredecessorLane() const;

    MSLane* getLogicalPredecessorLane(const MSEdge& fromEdge) const;

    LinkState getIncomingLinkState() const;

    std::vector<const MSLane*> getOutgoingLanes() const;



    SUMOReal getMeanSpeed() const;

    SUMOReal getWaitingSeconds() const;


    SUMOReal getBruttoOccupancy() const;


    SUMOReal getNettoOccupancy() const;


    inline SUMOReal getBruttoVehLenSum() const {
        return myBruttoVehicleLengthSum;
    }


    SUMOReal getCO2Emissions() const;


    SUMOReal getCOEmissions() const;


    SUMOReal getPMxEmissions() const;


    SUMOReal getNOxEmissions() const;


    SUMOReal getHCEmissions() const;


    SUMOReal getFuelConsumption() const;


    SUMOReal getElectricityConsumption() const;


    SUMOReal getHarmonoise_NoiseEmissions() const;

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

    SUMOReal getRightSideOnEdge() const {
        return myRightSideOnEdge;
    }

    int getRightmostSublane() const {
        return myRightmostSublane;
    }

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

    void sortPartialVehicles();

    MSLane* getOpposite() const;

    SUMOReal getOppositePos(SUMOReal pos) const;

    /* @brief find leader for a vehicle depending 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, SUMOReal> getOppositeLeader(const MSVehicle* ego, SUMOReal 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, SUMOReal> getOppositeFollower(const MSVehicle* ego) const;


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


    void saveState(OutputDevice& out);

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


#ifndef NO_TRACI

    void visit(const TraCIServerAPI_Lane::StoringVisitor& cont) const {
        cont.add(this);
    }
#endif

    static void initCollisionOptions(const OptionsCont& oc);

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

    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, SUMOReal pos, SUMOReal speed, SUMOReal posLat,
                                    const MSLane::VehCont::iterator& at,
                                    MSMoveReminder::Notification notification = MSMoveReminder::NOTIFICATION_DEPARTED);


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

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

    SUMOReal 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
     */
    SUMOReal getDepartSpeed(const MSVehicle& veh, bool& patchSpeed);

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

    SUMOReal basePos(const MSVehicle& veh) const;

    int myNumericalID;

    PositionVector myShape;

    int myIndex;

    VehCont myVehicles;

    VehCont myPartialVehicles;

    VehCont myTmpVehicles;

    VehCont myVehBuffer;


    SUMOReal myLength;

    const SUMOReal myWidth;

    MSEdge* const myEdge;

    SUMOReal myMaxSpeed;

    SVCPermissions myPermissions;

    SVCPermissions myOriginalPermissions;

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

    std::vector<IncomingLaneInfo> myIncomingLanes;
    mutable MSLane* myLogicalPredecessorLane;


    SUMOReal myBruttoVehicleLengthSum;

    SUMOReal 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 SUMOReal myLengthGeometryFactor;

    SUMOReal myRightSideOnEdge;
    int myRightmostSublane;

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

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

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

    static DictType myDict;

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

    static CollisionAction myCollisionAction;
    static bool myCheckJunctionCollisions;

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

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