MSVehicle.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 vehicle in the micro simulation
/****************************************************************************/
#ifndef MSVehicle_h
#define MSVehicle_h


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

#include <list>
#include <deque>
#include <map>
#include <set>
#include <string>
#include <vector>
#include <memory>
#include "MSGlobals.h"
#include "MSVehicleType.h"
#include "MSBaseVehicle.h"
#include "MSLink.h"
#include "MSLane.h"

#define INVALID_SPEED 299792458 + 1 // nothing can go faster than the speed of light! Refs. #2577

// ===========================================================================
// class declarations
// ===========================================================================
class SUMOSAXAttributes;
class MSMoveReminder;
class MSLaneChanger;
class MSVehicleTransfer;
class MSAbstractLaneChangeModel;
class MSStoppingPlace;
class MSChargingStation;
class MSParkingArea;
class MSPerson;
class MSDevice;
class MSEdgeWeightsStorage;
class OutputDevice;
class Position;
class MSContainer;
class MSJunction;
class MSLeaderInfo;
//class MSDriverState;
class MSSimpleDriverState;

// ===========================================================================
// class definitions
// ===========================================================================
class MSVehicle : public MSBaseVehicle {
public:

    friend class MSLaneChanger;
    friend class MSLaneChangerSublane;

    class State {
        friend class MSVehicle;
        friend class MSLaneChanger;
        friend class MSLaneChangerSublane;

    public:
        State(double pos, double speed, double posLat, double backPos);

        State(const State& state);

        State& operator=(const State& state);

        bool operator!=(const State& state);

        double pos() const {
            return myPos;
        }

        double speed() const {
            return mySpeed;
        };

        double posLat() const {
            return myPosLat;
        }

        double backPos() const {
            return myBackPos;
        }

        double lastCoveredDist() const {
            return myLastCoveredDist;
        }


    private:
        double myPos;

        double mySpeed;

        double myPosLat;

        // if the vehicle occupies multiple lanes, this is the position relative
        // to the lane occupied by its back
        double myBackPos;

        double myPreviousSpeed;

        double myLastCoveredDist;

    };


    class WaitingTimeCollector {
        friend class MSVehicle;

        typedef std::list<std::pair<SUMOTime, SUMOTime> > waitingIntervalList;

    public:
        WaitingTimeCollector(SUMOTime memory = MSGlobals::gWaitingTimeMemory);

        WaitingTimeCollector(const WaitingTimeCollector& wt);

        WaitingTimeCollector& operator=(const WaitingTimeCollector& wt);

        bool operator!=(const WaitingTimeCollector& wt) const;

        WaitingTimeCollector& operator=(SUMOTime t);

        // return the waiting time within the last memory millisecs
        SUMOTime cumulatedWaitingTime(SUMOTime memory = -1) const;

        // process time passing for dt millisecs
        void passTime(SUMOTime dt, bool waiting);

        // maximal memory time stored
        SUMOTime getMemorySize() const {
            return myMemorySize;
        }

        // maximal memory time stored
        const waitingIntervalList& getWaitingIntervals() const {
            return myWaitingIntervals;
        }

    private:
        SUMOTime myMemorySize;

        waitingIntervalList myWaitingIntervals;

        void appendWaitingTime(SUMOTime dt);
    };


    enum ChangeRequest {
        REQUEST_NONE,
        REQUEST_LEFT,
        REQUEST_RIGHT,
        REQUEST_HOLD
    };

    MSVehicle(SUMOVehicleParameter* pars, const MSRoute* route,
              MSVehicleType* type, const double speedFactor);

    virtual ~MSVehicle();




    void onRemovalFromNet(const MSMoveReminder::Notification reason);





    bool hasArrived() const;

    bool replaceRoute(const MSRoute* route, const std::string& info, bool onInit = false, int offset = 0, bool addStops = true, bool removeStops = true);


    bool willPass(const MSEdge* const edge) const;

    int getRoutePosition() const;
    void resetRoutePosition(int index);

    const MSEdgeWeightsStorage& getWeightsStorage() const;
    MSEdgeWeightsStorage& getWeightsStorage();




    void workOnMoveReminders(double oldPos, double newPos, double newSpeed);


    bool checkActionStep(const SUMOTime t);

    void resetActionOffset(const SUMOTime timeUntilNextAction = 0);


    void updateActionOffset(const SUMOTime oldActionStepLength, const SUMOTime newActionStepLength);


    void planMove(const SUMOTime t, const MSLeaderInfo& ahead, const double lengthsInFront);


    bool executeMove();

    double getDeltaPos(double accel);




    double getPositionOnLane() const {
        return myState.myPos;
    }

    double getLastStepDist() const {
        return myState.lastCoveredDist();
    }

    double getPositionOnLane(const MSLane* lane) const;

    double getBackPositionOnLane(const MSLane* lane) const;

    double getBackPositionOnLane() const {
        return getBackPositionOnLane(myLane);
    }

    double getLateralPositionOnLane() const {
        return myState.myPosLat;
    }

    double getRightSideOnLane() const;

    double lateralDistanceToLane(const int offset) const;

    double getLateralOverlap() const;
    double getLateralOverlap(double posLat) const;

    double getRightSideOnEdge(const MSLane* lane = 0) const;

    double getCenterOnEdge(const MSLane* lane = 0) const;

    double getLatOffset(const MSLane* lane) const;

    double getSpeed() const {
        return myState.mySpeed;
    }


    double getPreviousSpeed() const {
        return myState.myPreviousSpeed;
    }


    double getAcceleration() const {
        return myAcceleration;
    }


    SUMOTime getActionStepLength() const {
        return myType->getActionStepLength();
    }

    double getActionStepLengthSecs() const {
        return myType->getActionStepLengthSecs();
    }


    SUMOTime getLastActionTime() const {
        return myLastActionTime;
    }






    double getSlope() const;


    Position getPosition(const double offset = 0) const;


    Position getPositionAlongBestLanes(double offset) const;


    MSLane* getLane() const {
        return myLane;
    }


    double
    getMaxSpeedOnLane() const {
        if (myLane != 0) {
            return myLane->getVehicleMaxSpeed(this);
        } else {
            return myType->getMaxSpeed();
        }
    }


    inline bool isOnRoad() const {
        return myAmOnNet;
    }


    inline bool isActive() const {
        return myActionStep;
    }

    inline bool isActionStep(SUMOTime t) const {
        return (t - myLastActionTime) % getActionStepLength() == 0;
//        return t%getActionStepLength() == 0; // synchronized actions for all vehicles with identical actionsteplengths
    }


    bool isFrontOnLane(const MSLane* lane) const;


    const MSEdge* getRerouteOrigin() const;


    SUMOTime getWaitingTime() const {
        return myWaitingTime;
    }

    SUMOTime getTimeLoss() const {
        return TIME2STEPS(myTimeLoss);
    }


    SUMOTime getAccumulatedWaitingTime() const {
        return myWaitingTimeCollector.cumulatedWaitingTime(MSGlobals::gWaitingTimeMemory);
    }

    double getWaitingSeconds() const {
        return STEPS2TIME(myWaitingTime);
    }


    double getAccumulatedWaitingSeconds() const {
        return STEPS2TIME(getAccumulatedWaitingTime());
    }

    double getTimeLossSeconds() const {
        return myTimeLoss;
    }


    double getAngle() const {
        return myAngle;
    }


    Position getVelocityVector() const {
        return Position(std::cos(myAngle) * myState.speed(), std::sin(myAngle) * myState.speed());
    }

    double computeAngle() const;

    void setAngle(double angle, bool straightenFurther = false);

    static bool overlap(const MSVehicle* veh1, const MSVehicle* veh2) {
        if (veh1->myState.myPos < veh2->myState.myPos) {
            return veh2->myState.myPos - veh2->getVehicleType().getLengthWithGap() < veh1->myState.myPos;
        }
        return veh1->myState.myPos - veh1->getVehicleType().getLengthWithGap() < veh2->myState.myPos;
    }


    bool congested() const {
        return myState.mySpeed < double(60) / double(3.6);
    }


    void activateReminders(const MSMoveReminder::Notification reason, const MSLane* enteredLane = 0);

    bool enterLaneAtMove(MSLane* enteredLane, bool onTeleporting = false);



    void enterLaneAtInsertion(MSLane* enteredLane, double pos, double speed, double posLat,
                              MSMoveReminder::Notification notification);

    void setTentativeLaneAndPosition(MSLane* lane, double pos, double posLat = 0);

    void enterLaneAtLaneChange(MSLane* enteredLane);


    void leaveLane(const MSMoveReminder::Notification reason, const MSLane* approachedLane = 0);

    void updateDriveItems();

    const std::pair<double, LinkDirection>& getNextTurn() {
        return myNextTurn;
    }


    MSAbstractLaneChangeModel& getLaneChangeModel();
    const MSAbstractLaneChangeModel& getLaneChangeModel() const;

    const std::vector<MSLane*>& getFurtherLanes() const {
        return myFurtherLanes;
    }

    const std::vector<double>& getFurtherLanesPosLat() const {
        return myFurtherLanesPosLat;
    }


    bool onFurtherEdge(const MSEdge* edge) const;


    //
    struct LaneQ {
        MSLane* lane;
        double length;
        double currentLength;
        double occupation;
        double nextOccupation;
        int bestLaneOffset;
        bool allowsContinuation;
        /* @brief Longest sequence of (normal-edge) lanes that can be followed without a lane change
         * The 'length' attribute is the sum of these lane lengths
         * (There may be alternative sequences that have equal length)
         * It is the 'best' in the strategic sense of reducing required lane-changes
         */
        std::vector<MSLane*> bestContinuations;
    };

    const std::vector<LaneQ>& getBestLanes() const;

    void updateBestLanes(bool forceRebuild = false, const MSLane* startLane = 0);


    const std::vector<MSLane*>& getBestLanesContinuation() const;


    const std::vector<MSLane*>& getBestLanesContinuation(const MSLane* const l) const;

    /* @brief returns the current signed offset from the lane that is most
     * suited for continuing the current route (in the strategic sense of reducing lane-changes)
     * - 0 if the vehicle is one it's best lane
     * - negative if the vehicle should change to the right
     * - positive if the vehicle should change to the left
     */
    int getBestLaneOffset() const;

    void adaptBestLanesOccupation(int laneIndex, double density);


    void fixPosition();


    inline const MSCFModel& getCarFollowModel() const {
        return myType->getCarFollowModel();
    }

    inline std::shared_ptr<MSSimpleDriverState> getDriverState() const {
        return myDriverState;
    }


    inline MSCFModel::VehicleVariables* getCarFollowVariables() const {
        return myCFVariables;
    }



    class Stop {
    public:
        Stop(const SUMOVehicleParameter::Stop& par) : pars(par) {}
        MSRouteIterator edge;
        const MSLane* lane;
        MSStoppingPlace* busstop;
        MSStoppingPlace* containerstop;
        MSParkingArea* parkingarea;
        MSStoppingPlace* chargingStation;
        const SUMOVehicleParameter::Stop pars;
        SUMOTime duration;
        bool triggered;
        bool containerTriggered;
        bool reached;
        int numExpectedPerson;
        int numExpectedContainer;
        SUMOTime timeToBoardNextPerson;
        SUMOTime timeToLoadNextContainer;
        bool collision;

        void write(OutputDevice& dev) const;

        double getEndPos(const SUMOVehicle& veh) const;

        std::string getDescription() const;
    private:
        Stop& operator=(const Stop& src);

    };


    bool addStop(const SUMOVehicleParameter::Stop& stopPar, std::string& errorMsg, SUMOTime untilOffset = 0, bool collision = false,
                 MSRouteIterator* searchStart = 0);

    bool replaceParkingArea(MSParkingArea* parkingArea, std::string& errorMsg);

    void createDriverState();

    MSParkingArea* getNextParkingArea();

    bool hasStops() const {
        return !myStops.empty();
    }

    inline bool hasDriverState() const {
        return (myDriverState != nullptr);
    }

    bool isStopped() const;

    SUMOTime remainingStopDuration() const;

    bool willStop() const;

    bool isStoppedOnLane() const;

    bool keepStopping(bool afterProcessing = false) const;

    SUMOTime collisionStopTime() const;

    bool isParking() const;

    bool isRemoteControlled() const;

    bool wasRemoteControlled(SUMOTime lookBack = DELTA_T) const;

    double nextStopDist() const {
        return myStopDist;
    }

    bool isStoppedTriggered() const;

    bool isStoppedInRange(double pos) const;

    int getLaneIndex() const;

    double getDistanceToPosition(double destPos, const MSEdge* destEdge) const;


    double processNextStop(double currentVelocity);

    std::pair<const MSVehicle* const, double> getLeader(double dist = 0) const;

    double getTimeGapOnLane() const;




    double getCO2Emissions() const;


    double getCOEmissions() const;


    double getHCEmissions() const;


    double getNOxEmissions() const;


    double getPMxEmissions() const;


    double getFuelConsumption() const;


    double getElectricityConsumption() const;


    double getHarmonoise_NoiseEmissions() const;





    void addPerson(MSTransportable* person);



    void addContainer(MSTransportable* container);


    enum Signalling {
        VEH_SIGNAL_NONE = 0,
        VEH_SIGNAL_BLINKER_RIGHT = 1,
        VEH_SIGNAL_BLINKER_LEFT = 2,
        VEH_SIGNAL_BLINKER_EMERGENCY = 4,
        VEH_SIGNAL_BRAKELIGHT = 8,
        VEH_SIGNAL_FRONTLIGHT = 16,
        VEH_SIGNAL_FOGLIGHT = 32,
        VEH_SIGNAL_HIGHBEAM = 64,
        VEH_SIGNAL_BACKDRIVE = 128,
        VEH_SIGNAL_WIPER = 256,
        VEH_SIGNAL_DOOR_OPEN_LEFT = 512,
        VEH_SIGNAL_DOOR_OPEN_RIGHT = 1024,
        VEH_SIGNAL_EMERGENCY_BLUE = 2048,
        VEH_SIGNAL_EMERGENCY_RED = 4096,
        VEH_SIGNAL_EMERGENCY_YELLOW = 8192
    };


    enum LaneChangeMode {
        LC_NEVER      = 0,  // lcModel shall never trigger changes at this level
        LC_NOCONFLICT = 1,  // lcModel may trigger changes if not in conflict with TraCI request
        LC_ALWAYS     = 2   // lcModel may always trigger changes of this level regardless of requests
    };


    enum TraciLaneChangePriority {
        LCP_ALWAYS        = 0,  // change regardless of blockers, adapt own speed and speed of blockers
        LCP_NOOVERLAP     = 1,  // change unless overlapping with blockers, adapt own speed and speed of blockers
        LCP_URGENT        = 2,  // change if not blocked, adapt own speed and speed of blockers
        LCP_OPPORTUNISTIC = 3   // change if not blocked
    };


    void switchOnSignal(int signal) {
        mySignals |= signal;
    }


    void switchOffSignal(int signal) {
        mySignals &= ~signal;
    }


    int getSignals() const {
        return mySignals;
    }


    bool signalSet(int which) const {
        return (mySignals & which) != 0;
    }


    bool unsafeLinkAhead(const MSLane* lane) const;

    bool passingMinor() const;



    double getSpeedWithoutTraciInfluence() const;

    bool rerouteParkingArea(const std::string& parkingAreaID, std::string& errorMsg);

    bool addTraciStop(MSLane* const lane, const double startPos, const double endPos, const SUMOTime duration, const SUMOTime until,
                      const bool parking, const bool triggered, const bool containerTriggered, std::string& errorMsg);

    bool addTraciStopAtStoppingPlace(const std::string& stopId, const SUMOTime duration, const SUMOTime until, const bool parking,
                                     const bool triggered, const bool containerTriggered, const SumoXMLTag stoppingPlaceType, std::string& errorMsg);

    Stop& getNextStop();

    std::list<Stop> getMyStops();

    bool resumeFromStopping();


    double updateFurtherLanes(std::vector<MSLane*>& furtherLanes,
                              std::vector<double>& furtherLanesPosLat,
                              const std::vector<MSLane*>& passedLanes);

    PositionVector getBoundingBox() const;

    PositionVector getBoundingPoly() const;

    class Influencer {
    public:
        Influencer();


        ~Influencer();


        void setSpeedTimeLine(const std::vector<std::pair<SUMOTime, double> >& speedTimeLine);


        void setLaneTimeLine(const std::vector<std::pair<SUMOTime, int> >& laneTimeLine);

        void setSublaneChange(double latDist);

        int getSpeedMode() const;

        int getLaneChangeMode() const;

        int getRoutingMode() const {
            return myRoutingMode;
        }
        SUMOTime getLaneTimeLineDuration();

        double influenceSpeed(SUMOTime currentTime, double speed, double vSafe, double vMin, double vMax);

        int influenceChangeDecision(const SUMOTime currentTime, const MSEdge& currentEdge, const int currentLaneIndex, int state);


        double changeRequestRemainingSeconds(const SUMOTime currentTime) const;

        inline bool getRespectJunctionPriority() const {
            return myRespectJunctionPriority;
        }


        inline bool getEmergencyBrakeRedLight() const {
            return myEmergencyBrakeRedLight;
        }


        bool considerSafeVelocity() const {
            return myConsiderSafeVelocity;
        }

        void setSpeedMode(int speedMode);

        void setLaneChangeMode(int value);

        void setRoutingMode(int value) {
            myRoutingMode = value;
        }

        double getOriginalSpeed() const;

        void setRemoteControlled(Position xyPos, MSLane* l, double pos, double posLat, double angle, int edgeOffset, const ConstMSEdgeVector& route, SUMOTime t);

        SUMOTime getLastAccessTimeStep() const {
            return myLastRemoteAccess;
        }

        void postProcessRemoteControl(MSVehicle* v);

        double implicitSpeedRemote(const MSVehicle* veh, double oldSpeed);

        double implicitDeltaPosRemote(const MSVehicle* veh);

        bool isRemoteControlled() const;

        bool isRemoteAffected(SUMOTime t) const;

        void setSignals(int signals) {
            myTraCISignals = signals;
        }

        int getSignals() const {
            return myTraCISignals;
        }

        double getLatDist() const {
            return myLatDist;
        }

        void resetLatDist() {
            myLatDist = 0.;
        }

        SUMOAbstractRouter<MSEdge, SUMOVehicle>& getRouterTT() const;

    private:
        std::vector<std::pair<SUMOTime, double> > mySpeedTimeLine;

        std::vector<std::pair<SUMOTime, int> > myLaneTimeLine;

        double myOriginalSpeed;

        double myLatDist;

        bool mySpeedAdaptationStarted;

        bool myConsiderSafeVelocity;

        bool myConsiderMaxAcceleration;

        bool myConsiderMaxDeceleration;

        bool myRespectJunctionPriority;

        bool myEmergencyBrakeRedLight;

        Position myRemoteXYPos;
        MSLane* myRemoteLane;
        double myRemotePos;
        double myRemotePosLat;
        double myRemoteAngle;
        int myRemoteEdgeOffset;
        ConstMSEdgeVector myRemoteRoute;
        SUMOTime myLastRemoteAccess;


        LaneChangeMode myStrategicLC;
        LaneChangeMode myCooperativeLC;
        LaneChangeMode mySpeedGainLC;
        LaneChangeMode myRightDriveLC;
        LaneChangeMode mySublaneLC;
        TraciLaneChangePriority myTraciLaneChangePriority;

        // @brief the signals set via TraCI
        int myTraCISignals;

        int myRoutingMode;

    };


    Influencer& getInfluencer();

    const Influencer* getInfluencer() const;

    bool hasInfluencer() const {
        return myInfluencer != 0;
    }

    int influenceChangeDecision(int state);

    void setRemoteState(Position xyPos);

    double basePos(const MSEdge* edge) const;

    double getSafeFollowSpeed(const std::pair<const MSVehicle*, double> leaderInfo,
                              const double seen, const MSLane* const lane, double distToCrossing) const;

    static int nextLinkPriority(const std::vector<MSLane*>& conts);



    void saveState(OutputDevice& out);

    void loadState(const SUMOSAXAttributes& attrs, const SUMOTime offset);

protected:

    double getSpaceTillLastStanding(const MSLane* l, bool& foundStopped) const;


    void adaptLaneEntering2MoveReminder(const MSLane& enteredLane);


    void processLinkAproaches(double& vSafe, double& vSafeMin, double& vSafeMinDist);


    void processLaneAdvances(std::vector<MSLane*>& passedLanes, bool& moved, std::string& emergencyReason);


    double processTraCISpeedControl(double vSafe, double vNext);


    void removePassedDriveItems();

    void updateWaitingTime(double vNext);

    void updateTimeLoss(double vNext);

    bool canReverse() const;

    void setBrakingSignals(double vNext) ;

    void setBlinkerInformation();

    void setEmergencyBlueLight(SUMOTime currentTime);

    void updateOccupancyAndCurrentBestLane(const MSLane* startLane);

    const ConstMSEdgeVector getStopEdges() const;

    Position validatePosition(Position result, double offset = 0) const;

    virtual void drawOutsideNetwork(bool /*add*/) {};

    SUMOTime myWaitingTime;
    WaitingTimeCollector myWaitingTimeCollector;

    double myTimeLoss;

    State myState;

//    std::shared_ptr<MSDriverState> myDriverState;
    std::shared_ptr<MSSimpleDriverState> myDriverState;

    bool myActionStep;
    SUMOTime myLastActionTime;



    MSLane* myLane;

    MSAbstractLaneChangeModel* myLaneChangeModel;

    const MSEdge* myLastBestLanesEdge;
    const MSLane* myLastBestLanesInternalLane;

    /* @brief Complex data structure for keeping and updating LaneQ:
     * Each element of the outer vector corresponds to an upcoming edge on the vehicles route
     * The first element corresponds to the current edge and is returned in getBestLanes()
     * The other elements are only used as a temporary structure in updateBestLanes();
     */
    std::vector<std::vector<LaneQ> > myBestLanes;

    /* @brief iterator to speed up retrieval of the current lane's LaneQ in getBestLaneOffset() and getBestLanesContinuation()
     * This is updated in updateOccupancyAndCurrentBestLane()
     */
    std::vector<LaneQ>::iterator myCurrentLaneInBestLanes;

    static std::vector<MSLane*> myEmptyLaneVector;

    std::list<Stop> myStops;

    double myAcceleration;

    std::pair<double, LinkDirection> myNextTurn;

    std::vector<MSLane*> myFurtherLanes;
    std::vector<double> myFurtherLanesPosLat;

    int mySignals;

    bool myAmOnNet;

    bool myAmRegisteredAsWaitingForPerson;

    bool myAmRegisteredAsWaitingForContainer;

    bool myHaveToWaitOnNextLink;

    double myAngle;

    double myStopDist;

    SUMOTime myCollisionImmunity;

    mutable Position myCachedPosition;

protected:

    struct DriveProcessItem {
        MSLink* myLink;
        double myVLinkPass;
        double myVLinkWait;
        bool mySetRequest;
        SUMOTime myArrivalTime;
        double myArrivalSpeed;
        SUMOTime myArrivalTimeBraking;
        double myArrivalSpeedBraking;
        double myDistance;
        double accelV;
        bool hadVehicle;
        double availableSpace;

        DriveProcessItem(MSLink* link, double vPass, double vWait, bool setRequest,
                         SUMOTime arrivalTime, double arrivalSpeed,
                         SUMOTime arrivalTimeBraking, double arrivalSpeedBraking,
                         double distance,
                         double leaveSpeed = -1.) :
            myLink(link), myVLinkPass(vPass), myVLinkWait(vWait), mySetRequest(setRequest),
            myArrivalTime(arrivalTime), myArrivalSpeed(arrivalSpeed),
            myArrivalTimeBraking(arrivalTimeBraking), myArrivalSpeedBraking(arrivalSpeedBraking),
            myDistance(distance),
            accelV(leaveSpeed), hadVehicle(false), availableSpace(0) {
            assert(vWait >= 0 || !MSGlobals::gSemiImplicitEulerUpdate);
            assert(vPass >= 0 || !MSGlobals::gSemiImplicitEulerUpdate);
        };


        DriveProcessItem(double vWait, double distance, double _availableSpace = 0) :
            myLink(0), myVLinkPass(vWait), myVLinkWait(vWait), mySetRequest(false),
            myArrivalTime(0), myArrivalSpeed(0),
            myArrivalTimeBraking(0), myArrivalSpeedBraking(0),
            myDistance(distance),
            accelV(-1), hadVehicle(false), availableSpace(_availableSpace) {
            assert(vWait >= 0 || !MSGlobals::gSemiImplicitEulerUpdate);
        };


        inline void adaptLeaveSpeed(const double v) {
            if (accelV < 0) {
                accelV = v;
            } else {
                accelV = MIN2(accelV, v);
            }
        }
        inline double getLeaveSpeed() const {
            return accelV < 0 ? myVLinkPass : accelV;
        }
    };

    // TODO: Consider making LFLinkLanes a std::deque for efficient front removal (needs refactoring in checkRewindLinkLanes()...)
    typedef std::vector< DriveProcessItem > DriveItemVector;
    DriveItemVector myLFLinkLanes;
    DriveItemVector::iterator myNextDriveItem;

    void planMoveInternal(const SUMOTime t, MSLeaderInfo ahead, DriveItemVector& lfLinks, double& myStopDist, std::pair<double, LinkDirection>& myNextTurn) const;

    void checkRewindLinkLanes(const double lengthsInFront, DriveItemVector& lfLinks) const;

    void setApproachingForAllLinks(DriveItemVector& lfLinks) const;

    void removeApproachingInformation(DriveItemVector& lfLinks) const;


    inline double estimateLeaveSpeed(const MSLink* const link, const double vLinkPass) const {
        // estimate leave speed for passing time computation
        // l=linkLength, a=accel, t=continuousTime, v=vLeave
        // l=v*t + 0.5*a*t^2, solve for t and multiply with a, then add v
        return MIN2(link->getViaLaneOrLane()->getVehicleMaxSpeed(this),
                    getCarFollowModel().estimateSpeedAfterDistance(link->getLength(), vLinkPass, getVehicleType().getCarFollowModel().getMaxAccel()));
    }


    /* @brief adapt safe velocity in accordance to a moving obstacle:
     * - a leader vehicle
     * - a vehicle or pedestrian that crosses this vehicles path on an upcoming intersection
     * @param[in] leaderInfo The leading vehicle and the (virtual) distance to it
     * @param[in] seen the distance to the end of the current lane
     * @param[in] lastLink the lastLink index
     * @param[in] lane The current Lane the vehicle is on
     * @param[in,out] the safe velocity for driving
     * @param[in,out] the safe velocity for arriving at the next link
     * @param[in] distToCrossing The distance to the crossing point with the current leader where relevant or -1
     */
    void adaptToLeader(const std::pair<const MSVehicle*, double> leaderInfo,
                       const double seen, DriveProcessItem* const lastLink,
                       const MSLane* const lane, double& v, double& vLinkPass,
                       double distToCrossing = -1) const;

    /* @brief adapt safe velocity in accordance to multiple vehicles ahead:
     * @param[in] ahead The leader information according to the current lateral-resolution
     * @param[in] latOffset the lateral offset for locating the ego vehicle on the given lane
     * @param[in] seen the distance to the end of the current lane
     * @param[in] lastLink the lastLink index
     * @param[in] lane The current Lane the vehicle is on
     * @param[in,out] the safe velocity for driving
     * @param[in,out] the safe velocity for arriving at the next link
     */
    void adaptToLeaders(const MSLeaderInfo& ahead,
                        double latOffset,
                        const double seen, DriveProcessItem* const lastLink,
                        const MSLane* const lane, double& v, double& vLinkPass) const;

    void checkLinkLeader(const MSLink* link, const MSLane* lane, double seen,
                         DriveProcessItem* const lastLink, double& v, double& vLinkPass, double& vLinkWait, bool& setRequest,
                         bool isShadowLink = false) const;

    void checkLinkLeaderCurrentAndParallel(const MSLink* link, const MSLane* lane, double seen,
                                           DriveProcessItem* const lastLink, double& v, double& vLinkPass, double& vLinkWait, bool& setRequest) const;


    // @brief return the lane on which the back of this vehicle resides
    const MSLane* getBackLane() const;

    // @brief get the position of the back bumper;
    const Position getBackPosition() const;

    void updateState(double vNext);


    bool keepClear(const MSLink* link) const;

    bool ignoreRed(const MSLink* link, bool canBrake) const;

private:
    /* @brief The vehicle's knowledge about edge efforts/travel times; @see MSEdgeWeightsStorage
     * @note member is initialized on first access */
    mutable MSEdgeWeightsStorage* myEdgeWeights;

    MSCFModel::VehicleVariables* myCFVariables;

    Influencer* myInfluencer;

private:
    MSVehicle();

    MSVehicle(const MSVehicle&);

    MSVehicle& operator=(const MSVehicle&);

    MSEdgeWeightsStorage& _getWeightsStorage() const;

};


#endif

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