MSVehicle.h

Go to the documentation of this file.

/****************************************************************************/
// Representation of a vehicle 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 MSVehicle_h
#define MSVehicle_h


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

#include <list>
#include <deque>
#include <map>
#include <set>
#include <string>
#include <vector>
#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 MSDevice_Transportable;
class MSContainer;
class MSJunction;
class MSLeaderInfo;

// ===========================================================================
// 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(SUMOReal pos, SUMOReal speed, SUMOReal posLat, SUMOReal backPos);

        State(const State& state);

        State& operator=(const State& state);

        bool operator!=(const State& state);

        SUMOReal pos() const {
            return myPos;
        }

        SUMOReal speed() const {
            return mySpeed;
        };

        SUMOReal posLat() const {
            return myPosLat;
        }

        SUMOReal backPos() const {
            return myBackPos;
        }

        SUMOReal lastCoveredDist() const {
            return myLastCoveredDist;
        }


    private:
        SUMOReal myPos;

        SUMOReal mySpeed;

        SUMOReal myPosLat;

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

        SUMOReal myPreviousSpeed;

        SUMOReal 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,
              const MSVehicleType* type, const SUMOReal speedFactor);

    virtual ~MSVehicle();




    void onRemovalFromNet(const MSMoveReminder::Notification reason);





    bool hasArrived() const;

    bool replaceRoute(const MSRoute* route, bool onInit = false, int offset = 0, bool addStops = true);


    bool willPass(const MSEdge* const edge) const;

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

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




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


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


    bool executeMove();


    SUMOReal getDeltaPos(SUMOReal accel);




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

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

    SUMOReal getPositionOnLane(const MSLane* lane) const;

    SUMOReal getBackPositionOnLane(const MSLane* lane) const;

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

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

    SUMOReal getRightSideOnLane() const;

    SUMOReal getLateralOverlap() const;

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

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

    SUMOReal getLatOffset(const MSLane* lane) const;

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


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


    SUMOReal getAcceleration() const {
        return myAcceleration;
    }





    SUMOReal getSlope() const;


    Position getPosition(const SUMOReal offset = 0) const;


    MSLane* getLane() const {
        return myLane;
    }


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


    inline bool isOnRoad() const {
        return myAmOnNet;
    }


    bool isFrontOnLane(const MSLane* lane) const;


    const MSEdge* getRerouteOrigin() const;


    SUMOTime getWaitingTime() const {
        return myWaitingTime;
    }

    SUMOTime getTimeLoss() const {
        return myTimeLoss;
    }


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


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


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

    SUMOReal getTimeLossSeconds() const {
        return STEPS2TIME(myTimeLoss);
    }


    SUMOReal getAngle() const {
        return myAngle;
    }

    SUMOReal computeAngle() const;

    void setAngle(SUMOReal angle);

    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 < SUMOReal(60) / SUMOReal(3.6);
    }


    void activateReminders(const MSMoveReminder::Notification reason);

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



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

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

    void enterLaneAtLaneChange(MSLane* enteredLane);


    void leaveLane(const MSMoveReminder::Notification reason);


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

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

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


    //
    struct LaneQ {
        MSLane* lane;
        SUMOReal length;
        SUMOReal currentLength;
        SUMOReal occupation;
        SUMOReal 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, SUMOReal density);


    void fixPosition();


    void replaceVehicleType(MSVehicleType* type);


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


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




    struct Stop {
        MSRouteIterator edge;
        const MSLane* lane;
        MSStoppingPlace* busstop;
        MSStoppingPlace* containerstop;
        MSParkingArea* parkingarea;
        MSChargingStation* chargingStation;
        SUMOReal startPos;
        SUMOReal endPos;
        SUMOTime duration;
        SUMOTime until;
        bool triggered;
        bool containerTriggered;
        bool parking;
        bool reached;
        std::set<std::string> awaitedPersons;
        std::set<std::string> awaitedContainers;
        SUMOTime timeToBoardNextPerson;
        SUMOTime timeToLoadNextContainer;

        void write(OutputDevice& dev) const;

        SUMOReal getEndPos(const SUMOVehicle& veh) const;
    };


    bool addStop(const SUMOVehicleParameter::Stop& stopPar, std::string& errorMsg, SUMOTime untilOffset = 0);

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


    MSParkingArea* getNextParkingArea();

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

    bool isStopped() const;

    bool isParking() const;

    bool isRemoteControlled() const;

    SUMOReal nextStopDist() const {
        return myStopDist;
    }

    bool isStoppedTriggered() const;

    bool isStoppedInRange(SUMOReal pos) const;

    bool knowsEdgeTest(MSEdge& edge) const;
    int getLaneIndex() const;

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


    SUMOReal processNextStop(SUMOReal currentVelocity);

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

    SUMOReal getTimeGapOnLane() const;




    SUMOReal getCO2Emissions() const;


    SUMOReal getCOEmissions() const;


    SUMOReal getHCEmissions() const;


    SUMOReal getNOxEmissions() const;


    SUMOReal getPMxEmissions() const;


    SUMOReal getFuelConsumption() const;


    SUMOReal getElectricityConsumption() const;


    SUMOReal getHarmonoise_NoiseEmissions() const;





    void addPerson(MSTransportable* person);



    void addContainer(MSTransportable* container);

    void removeTransportable(MSTransportable* t);

    const std::vector<MSTransportable*>& getPersons() const;

    const std::vector<MSTransportable*>& getContainers() const;

    int getPersonNumber() const;

    int getContainerNumber() const;


    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;


#ifndef NO_TRACI

    SUMOReal getSpeedWithoutTraciInfluence() const;

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

    bool addTraciBusOrContainerStop(const std::string& stopId, const SUMOTime duration, const SUMOTime until, const bool parking,
                                    const bool triggered, const bool containerTriggered, const bool isContainerStop, std::string& errorMsg);

    Stop& getNextStop();

    bool resumeFromStopping();


    SUMOReal updateFurtherLanes(std::vector<MSLane*>& furtherLanes,
                                std::vector<SUMOReal>& 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, SUMOReal> >& speedTimeLine);


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

        int getSpeedMode() const;

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

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


        SUMOReal changeRequestRemainingSeconds(const SUMOTime currentTime) const;

        inline bool getRespectJunctionPriority() const {
            return myRespectJunctionPriority;
        }


        inline bool getEmergencyBrakeRedLight() const {
            return myEmergencyBrakeRedLight;
        }

        void setSpeedMode(int speedMode);

        void setLaneChangeMode(int value);


        inline SUMOReal getOriginalSpeed() const {
            return myOriginalSpeed;
        }

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

        SUMOTime getLastAccessTimeStep() const {
            return myLastVTDAccess;
        }

        void postProcessVTD(MSVehicle* v);

        SUMOReal implicitSpeedVTD(const MSVehicle* veh, SUMOReal oldSpeed);

        SUMOReal implicitDeltaPosVTD(const MSVehicle* veh);

        bool isVTDControlled() const;

        bool isVTDAffected(SUMOTime t) const;

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

        int getSignals() const {
            return myTraCISignals;
        }

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

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

        SUMOReal myOriginalSpeed;

        bool mySpeedAdaptationStarted;

        bool myConsiderSafeVelocity;

        bool myConsiderMaxAcceleration;

        bool myConsiderMaxDeceleration;

        bool myRespectJunctionPriority;

        bool myEmergencyBrakeRedLight;

        Position myVTDXYPos;
        MSLane* myVTDLane;
        SUMOReal myVTDPos;
        SUMOReal myVTDPosLat;
        SUMOReal myVTDAngle;
        int myVTDEdgeOffset;
        ConstMSEdgeVector myVTDRoute;
        SUMOTime myLastVTDAccess;


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

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

    };


    Influencer& getInfluencer();

    const Influencer* getInfluencer() const;

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

    int influenceChangeDecision(int state);

    void setVTDState(Position xyPos);

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

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

#endif



    void saveState(OutputDevice& out);

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

protected:

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


    void adaptLaneEntering2MoveReminder(const MSLane& enteredLane);



    void setBlinkerInformation();

    void setEmergencyBlueLight(SUMOTime currentTime);

    void updateOccupancyAndCurrentBestLane(const MSLane* startLane);

    const ConstMSEdgeVector getStopEdges() const;

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

    SUMOTime myWaitingTime;
    WaitingTimeCollector myWaitingTimeCollector;

    SUMOTime myTimeLoss;

    State myState;

    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 retrival 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;
    static std::vector<MSTransportable*> myEmptyTransportableVector;

    std::list<Stop> myStops;

    MSDevice_Transportable* myPersonDevice;

    MSDevice_Transportable* myContainerDevice;

    SUMOReal myAcceleration;

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

    int mySignals;

    bool myAmOnNet;

    bool myAmRegisteredAsWaitingForPerson;

    bool myAmRegisteredAsWaitingForContainer;

    bool myHaveToWaitOnNextLink;

    SUMOReal myAngle;

    SUMOReal myStopDist;

    mutable Position myCachedPosition;

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

        DriveProcessItem(MSLink* link, SUMOReal vPass, SUMOReal vWait, bool setRequest,
                         SUMOTime arrivalTime, SUMOReal arrivalSpeed,
                         SUMOTime arrivalTimeBraking, SUMOReal arrivalSpeedBraking,
                         SUMOReal distance,
                         SUMOReal 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(-1.) {
            assert(vWait >= 0 || !MSGlobals::gSemiImplicitEulerUpdate);
            assert(vPass >= 0 || !MSGlobals::gSemiImplicitEulerUpdate);
        };


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


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

    typedef std::vector< DriveProcessItem > DriveItemVector;
    DriveItemVector myLFLinkLanes;

    void planMoveInternal(const SUMOTime t, MSLeaderInfo ahead, DriveItemVector& lfLinks, SUMOReal& myStopDist) const;

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

    void removeApproachingInformation(DriveItemVector& lfLinks) const;


    inline SUMOReal estimateLeaveSpeed(const MSLink* const link, const SUMOReal 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*, SUMOReal> leaderInfo,
                       const SUMOReal seen, DriveProcessItem* const lastLink,
                       const MSLane* const lane, SUMOReal& v, SUMOReal& vLinkPass,
                       SUMOReal 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,
                        SUMOReal latOffset,
                        const SUMOReal seen, DriveProcessItem* const lastLink,
                        const MSLane* const lane, SUMOReal& v, SUMOReal& vLinkPass) 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(SUMOReal vNext);

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;

#ifndef NO_TRACI
    Influencer* myInfluencer;
#endif

private:
    MSVehicle();

    MSVehicle(const MSVehicle&);

    MSVehicle& operator=(const MSVehicle&);

    MSEdgeWeightsStorage& _getWeightsStorage() const;

};


#endif

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