MSVehicle.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2001-2026 German Aerospace Center (DLR) and others.
// This program and the accompanying materials are made available under the
// terms of the Eclipse Public License 2.0 which is available at
// https://www.eclipse.org/legal/epl-2.0/
// This Source Code may also be made available under the following Secondary
// Licenses when the conditions for such availability set forth in the Eclipse
// Public License 2.0 are satisfied: GNU General Public License, version 2
// or later which is available at
// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
/****************************************************************************/
// Representation of a vehicle in the micro simulation
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <list>
#include <deque>
#include <map>
#include <set>
#include <string>
#include <vector>
#include <memory>
#include "MSGlobals.h"
#include "MSBaseVehicle.h"
#include "MSNet.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 MSStop;
class MSChargingStation;
class MSOverheadWire;
class MSParkingArea;
class MSPerson;
class MSDevice;
class OutputDevice;
class Position;
class MSJunction;
class MSLeaderInfo;
class MSLeaderDistanceInfo;
class MSDevice_DriverState;
class MSSimpleDriverState;
class MSDevice_Friction;
 
 
// ===========================================================================
// 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, double previousSpeed);
 
        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 {
    public:
        WaitingTimeCollector(SUMOTime memory = MSGlobals::gWaitingTimeMemory);
 
        // 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);
 
        const std::string getState() const;
 
        void setState(const std::string& state);
 
    private:
        SUMOTime myMemorySize;
 
        std::deque<std::pair<SUMOTime, SUMOTime> > myWaitingIntervals;
    };
 
 
    enum ChangeRequest {
        REQUEST_NONE,
        REQUEST_LEFT,
        REQUEST_RIGHT,
        REQUEST_HOLD
    };
 
    MSVehicle(SUMOVehicleParameter* pars, ConstMSRoutePtr route,
              MSVehicleType* type, const double speedFactor);
 
    virtual ~MSVehicle();
 
    void initDevices();
 
    bool hasValidRouteStart(std::string& msg);
 
 
 
    void onRemovalFromNet(const MSMoveReminder::Notification reason);
 
 
 
 
 
    bool hasArrived() const;
 
    bool replaceRoute(ConstMSRoutePtr route, const std::string& info, bool onInit = false, int offset = 0, bool addStops = true, bool removeStops = true, std::string* msgReturn = nullptr);
 
 
 
 
 
    void workOnMoveReminders(double oldPos, double newPos, double newSpeed);
 
    void workOnIdleReminders();
 
    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);
 
    void setApproachingForAllLinks();
 
    void registerInsertionApproach(MSLink* link, double dist);
 
 
    bool executeMove();
 
    void executeFractionalMove(double dist);
 
    double getDeltaPos(const double accel) const;
 
 
 
 
    double getPositionOnLane() const {
        return myState.myPos;
    }
 
    double getLastStepDist() const {
        return myState.lastCoveredDist();
    }
 
    double getPositionOnLane(const MSLane* lane) const;
 
    inline double getBackPositionOnLane(const MSLane* lane) const {
        return getBackPositionOnLane(lane, false);
    }
 
    double getBackPositionOnLane() const {
        return getBackPositionOnLane(myLane);
    }
 
    double getLateralPositionOnLane() const {
        return myState.myPosLat;
    }
 
    void setLateralPositionOnLane(double posLat) {
        myState.myPosLat = posLat;
    }
 
    void invalidateCachedPosition() {
        myCachedPosition = Position::INVALID;
    }
 
    double getRightSideOnLane() const;
 
    double getLeftSideOnLane() const;
 
    double getRightSideOnLane(const MSLane* lane) const;
 
    double getLeftSideOnLane(const MSLane* lane) const;
 
    double lateralDistanceToLane(const int offset) const;
 
    double getLateralOverlap() const;
    double getLateralOverlap(const MSLane* lane) const;
    double getLateralOverlap(double posLat, const MSLane* lane) const;
 
    double getLeftSideOnEdge(const MSLane* lane = 0) 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;
    }
 
 
    void setPreviousSpeed(double prevSpeed, double prevAcceleration);
 
 
    double getAcceleration() const {
        return myAcceleration;
    }
 
    double getCurrentApparentDecel() const;
 
    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;
 
 
    const MSLane* getLane() const {
        return myLane;
    }
 
    MSLane* getMutableLane() const {
        return myLane;
    }
 
    // @brief return the lane on which the back of this vehicle resides
    const MSLane* getBackLane() const;
 
    double getMaxSpeedOnLane() const;
 
    inline bool isOnRoad() const {
        return myAmOnNet;
    }
 
    void
    setIdling(bool amIdling) {
        myAmIdling = amIdling;
    }
 
    inline bool isIdling() const {
        return myAmIdling;
    }
 
    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* getCurrentEdge() const;
 
    const MSEdge* getNextEdgePtr() const;
 
    ConstMSEdgeVector::const_iterator getRerouteOrigin() const;
 
 
    SUMOTime getWaitingTime(const bool accumulated = false) const {
        if (!accumulated) {
            return myWaitingTime;
        }
        return myWaitingTimeCollector.cumulatedWaitingTime(MSGlobals::gWaitingTimeMemory);
    }
 
    SUMOTime getWaitingTimeFor(const MSLink* link) const;
 
 
    SUMOTime getTimeSinceStartup() const {
        return myTimeSinceStartup;
    }
 
    inline double getTimeSinceStartupSeconds() const {
        return STEPS2TIME(myTimeSinceStartup);
    }
 
    SUMOTime getTimeLoss() const {
        return TIME2STEPS(myTimeLoss);
    }
 
 
    double getAccumulatedWaitingSeconds() const {
        return STEPS2TIME(getWaitingTime(true));
    }
 
    double getTimeLossSeconds() const {
        return myTimeLoss;
    }
 
    double getStopDelay() const;
 
    double getStopArrivalDelay() const;
 
    double getAngle() const {
        return myAngle;
    }
 
    double getCurveRadius() const;
 
 
    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);
 
    void setActionStepLength(double actionStepLength, bool resetActionOffset = true);
 
    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;
 
 
    void 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 leaveLaneBack(const MSMoveReminder::Notification reason, const MSLane* leftLane);
 
    void updateDriveItems();
 
    const std::pair<double, const MSLink*>& 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;
 
    bool isBidiOn(const MSLane* lane) const;
 
 
    //
    struct LaneQ {
        MSLane* lane = nullptr;
        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);
 
    void updateLaneBruttoSum();
 
    const std::vector<MSLane*>& getBestLanesContinuation() const;
 
 
    const std::vector<MSLane*>& getBestLanesContinuation(const MSLane* const l) const;
 
    const std::vector<const MSLane*> getUpcomingLanesUntil(double distance) const;
 
    const std::vector<const MSLane*> getPastLanesUntil(double distance) const;
 
    const std::vector<MSLane*> getUpstreamOppositeLanes() 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 on its best lane
     * - negative if the vehicle should change to the right
     * - positive if the vehicle should change to the left
     */
    int getBestLaneOffset() const;
 
    double getBestLaneDist() const;
 
    void adaptBestLanesOccupation(int laneIndex, double density);
 
 
    void fixPosition();
 
    std::pair<const MSLane*, double> getLanePosAfterDist(double distance) const;
 
    inline const MSCFModel& getCarFollowModel() const {
        return myType->getCarFollowModel();
    }
 
    std::shared_ptr<MSSimpleDriverState> getDriverState() const;
 
    double getFriction() const;
 
    inline MSCFModel::VehicleVariables* getCarFollowVariables() const {
        return myCFVariables;
    }
 
    inline bool hasDriverState() const {
        return myDriverState != nullptr;
    }
 
 
    SUMOTime remainingStopDuration() const;
 
    bool instantStopping() const;
 
    bool willStop() const;
 
    bool isStoppedOnLane() const;
 
    bool keepStopping(bool afterProcessing = false) const;
 
    SUMOTime collisionStopTime() const;
 
    bool brokeDown() const;
 
    bool isRemoteControlled() const;
 
    bool wasRemoteControlled(SUMOTime lookBack = DELTA_T) const;
 
    double nextStopDist() const {
        return myStopDist;
    }
 
    int getLaneIndex() const;
 
    double getDistanceToPosition(double destPos, const MSLane* destLane) const;
 
 
    double processNextStop(double currentVelocity);
 
 
    std::pair<const MSVehicle* const, double> getLeader(double dist = 0, bool considerFoes = true) const;
 
    std::pair<const MSVehicle* const, double> getFollower(double dist = 0) const;
 
    double getTimeGapOnLane() const;
 
 
    void addTransportable(MSTransportable* transportable);
 
 
    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, double zipperDist) const;
 
    bool passingMinor() const;
 
 
 
    double getSpeedWithoutTraciInfluence() const;
 
    bool rerouteParkingArea(const std::string& parkingAreaID, std::string& errorMsg);
 
    bool addTraciStop(SUMOVehicleParameter::Stop stop, std::string& errorMsg);
 
    bool handleCollisionStop(MSStop& stop, const double distToStop);
 
    bool resumeFromStopping();
 
    double updateFurtherLanes(std::vector<MSLane*>& furtherLanes,
                              std::vector<double>& furtherLanesPosLat,
                              const std::vector<MSLane*>& passedLanes);
 
    PositionVector getBoundingBox(double offset = 0) const;
 
    PositionVector getBoundingPoly(double offset = 0) const;
 
    enum ManoeuvreType {
        MANOEUVRE_ENTRY,
        MANOEUVRE_EXIT,
        MANOEUVRE_NONE
    };
 
    bool setExitManoeuvre();
    void setManoeuvreType(const MSVehicle::ManoeuvreType mType);
 
    bool manoeuvreIsComplete() const;
    MSVehicle::ManoeuvreType getManoeuvreType() const;
 
 
    class Manoeuvre {
 
    public:
        Manoeuvre();
 
        Manoeuvre(const Manoeuvre& manoeuvre);
 
        Manoeuvre& operator=(const Manoeuvre& manoeuvre);
 
        bool operator!=(const Manoeuvre& manoeuvre);
 
        bool configureEntryManoeuvre(MSVehicle* veh);
 
        bool configureExitManoeuvre(MSVehicle* veh);
 
        bool entryManoeuvreIsComplete(MSVehicle* veh);
 
        bool
        manoeuvreIsComplete(const ManoeuvreType checkType) const;
 
        bool
        manoeuvreIsComplete() const;
 
        double getGUIIncrement() const;
 
        MSVehicle::ManoeuvreType getManoeuvreType() const;
 
        void setManoeuvreType(const MSVehicle::ManoeuvreType mType);
 
    private:
        std::string myManoeuvreVehicleID;
 
        std::string myManoeuvreStop;
 
        SUMOTime myManoeuvreStartTime;
 
        SUMOTime myManoeuvreCompleteTime;
 
        ManoeuvreType myManoeuvreType;
 
        // @brief Angle (radians) through which parking vehicle moves in each sim step
        double myGUIIncrement;
    };
 
    // Current or previous (completed) manoeuvre
    Manoeuvre myManoeuvre;
 
    class Influencer : public BaseInfluencer {
    private:
 
        class GapControlVehStateListener : public MSNet::VehicleStateListener {
            void vehicleStateChanged(const SUMOVehicle* const vehicle, MSNet::VehicleState to, const std::string& info = "");
        };
 
 
        struct GapControlState {
            GapControlState();
            virtual ~GapControlState();
            static void init();
            static void cleanup();
            void activate(double tauOriginal, double tauTarget, double additionalGap, double duration, double changeRate, double maxDecel, const MSVehicle* refVeh);
            void deactivate();
            double tauOriginal;
            double tauCurrent;
            double tauTarget;
            double addGapCurrent;
            double addGapTarget;
            double remainingDuration;
            double changeRate;
            double maxDecel;
            const MSVehicle* referenceVeh;
            bool active;
            bool gapAttained;
            const MSVehicle* prevLeader;
            SUMOTime lastUpdate;
            double timeHeadwayIncrement, spaceHeadwayIncrement;
 
            static std::map<const MSVehicle*, GapControlState*> refVehMap;
 
        private:
            static GapControlVehStateListener* myVehStateListener;
        };
 
 
    public:
        Influencer();
 
        ~Influencer();
 
        static void cleanup();
 
        void setSpeedTimeLine(const std::vector<std::pair<SUMOTime, double> >& speedTimeLine);
 
        bool hasSpeedTimeLine(SUMOTime t) const {
            return !mySpeedTimeLine.empty() && mySpeedTimeLine.front().first >= t;
        }
 
        void activateGapController(double originalTau, double newTimeHeadway, double newSpaceHeadway, double duration, double changeRate, double maxDecel, MSVehicle* refVeh = nullptr);
 
        void deactivateGapController();
 
        void setLaneTimeLine(const std::vector<std::pair<SUMOTime, int> >& laneTimeLine);
 
        void adaptLaneTimeLine(int indexShift);
 
        void setSublaneChange(double latDist);
 
        int getSpeedMode() const;
 
        int getLaneChangeMode() const;
 
        SUMOTime getLaneTimeLineDuration();
 
        SUMOTime getLaneTimeLineEnd();
 
        double influenceSpeed(SUMOTime currentTime, double speed, double vSafe, double vMin, double vMax);
 
        double gapControlSpeed(SUMOTime currentTime, const SUMOVehicle* veh, 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;
        }
 
        inline bool getRespectJunctionLeaderPriority() const {
            return myRespectJunctionLeaderPriority;
        }
 
 
        bool considerSafeVelocity() const {
            return myConsiderSafeVelocity;
        }
 
        bool considerSpeedLimit() const {
            // backward compatibility (when we ignore safe velocity we implicitly ignore speed limits as well)
            return myConsiderSpeedLimit && myConsiderSafeVelocity;
        }
 
        bool considerMaxDeceleration() const {
            return myConsiderMaxDeceleration;
        }
 
        void setSpeedMode(int speedMode);
 
        void setLaneChangeMode(int value);
 
        double getOriginalSpeed() const;
 
        void  setOriginalSpeed(double speed);
 
        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 updateRemoteControlRoute(MSVehicle* v);
 
        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.;
        }
 
        bool ignoreOverlap() const {
            return myTraciLaneChangePriority == LCP_ALWAYS;
        }
 
    private:
 
        void init();
 
    private:
        std::vector<std::pair<SUMOTime, double> > mySpeedTimeLine;
 
        std::vector<std::pair<SUMOTime, int> > myLaneTimeLine;
 
        std::shared_ptr<GapControlState> myGapControlState;
 
        double myOriginalSpeed;
 
        double myLatDist;
 
        bool mySpeedAdaptationStarted;
 
        bool myConsiderSafeVelocity;
 
        bool myConsiderSpeedLimit;
 
        bool myConsiderMaxAcceleration;
 
        bool myConsiderMaxDeceleration;
 
        bool myRespectJunctionPriority;
 
        bool myEmergencyBrakeRedLight;
 
        bool myRespectJunctionLeaderPriority;
 
        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;
 
    };
 
 
    BaseInfluencer& getBaseInfluencer();
    Influencer& getInfluencer();
 
    const BaseInfluencer* getBaseInfluencer() const;
    const Influencer* getInfluencer() const;
 
    bool hasInfluencer() const {
        return myInfluencer != nullptr;
    }
 
    int influenceChangeDecision(int state);
 
    void setRemoteState(Position xyPos);
 
    static int nextLinkPriority(const std::vector<MSLane*>& conts);
 
    bool isLeader(const MSLink* link, const MSVehicle* veh, const double gap) const;
 
    // @brief get the position of the back bumper;
    const Position getBackPosition() const;
 
    bool ignoreCollision() const;
 
    void updateParkingState();
 
    void replaceVehicleType(const MSVehicleType* type);
 
    double getBrakeGap(bool delayed = false) const;
 
 
 
    void saveState(OutputDevice& out);
 
    void loadState(const SUMOSAXAttributes& attrs, const SUMOTime offset);
 
    void loadPreviousApproaching(MSLink* link, bool setRequest,
                                 SUMOTime arrivalTime, double arrivalSpeed,
                                 double arrivalSpeedBraking,
                                 double dist, double leaveSpeed);
 
protected:
 
 
    void adaptLaneEntering2MoveReminder(const MSLane& enteredLane);
 
 
    void processLinkApproaches(double& vSafe, double& vSafeMin, double& vSafeMinDist);
 
 
    void processLaneAdvances(std::vector<MSLane*>& passedLanes, std::string& emergencyReason);
 
 
    double processTraCISpeedControl(double vSafe, double vNext);
 
 
    void removePassedDriveItems();
 
    void updateWaitingTime(double vNext);
 
    void updateTimeLoss(double vNext);
 
    /* @brief Check whether the vehicle is a train that can reverse its direction at the current point in its route
     * and return the speed in preparation for reversal
     *
     *  @param[out] canReverse
     *  @param[in] speedThreshold
     *  @return speed for reversal
     */
    double checkReversal(bool& canReverse, double speedThreshold = SUMO_const_haltingSpeed, double seen = 0) const;
 
    void setBrakingSignals(double vNext) ;
 
    void setBlinkerInformation();
 
    void setEmergencyBlueLight(SUMOTime currentTime);
 
    void computeFurtherLanes(MSLane* enteredLane, double pos, bool collision = false);
 
    void updateOccupancyAndCurrentBestLane(const MSLane* startLane);
 
    Position validatePosition(Position result, double offset = 0) const;
 
    virtual void drawOutsideNetwork(bool /*add*/) {};
 
    void boardTransportables(MSStop& stop);
 
    bool joinTrainPart(MSVehicle* veh);
 
    bool joinTrainPartFront(MSVehicle* veh);
 
    double slowDownForSchedule(double vMinComfortable) const;
 
    void interpolateLateralZ(Position& pos, double offset, double posLat) const;
 
    double getDistanceToLeaveJunction() const;
 
    double getAngleDiff() const;
 
protected:
 
    SUMOTime myWaitingTime;
    WaitingTimeCollector myWaitingTimeCollector;
 
    double myTimeLoss;
 
    State myState;
 
    MSDevice_DriverState* myDriverState;
 
    MSDevice_Friction* myFrictionDevice;
 
    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;
 
    double myAcceleration;
 
    std::pair<double, const MSLink*> myNextTurn;
 
    std::vector<MSLane*> myFurtherLanes;
    std::vector<double> myFurtherLanesPosLat;
 
    int mySignals;
 
    bool myAmOnNet;
 
    bool myAmIdling;
 
    bool myHaveToWaitOnNextLink;
 
    double myAngle;
    double myRawAngle;
    double myLastAngle;
 
    double myStopDist;
 
    double myStopSpeed;
 
    SUMOTime myCollisionImmunity;
 
    mutable Position myCachedPosition;
 
    SUMOTime myJunctionEntryTime;
    SUMOTime myJunctionEntryTimeNeverYield;
    SUMOTime myJunctionConflictEntryTime;
 
    SUMOTime myTimeSinceStartup;
    const MSLink* myHaveStoppedFor;
 
protected:
 
    struct DriveProcessItem {
        MSLink* myLink;
        double myVLinkPass;
        double myVLinkWait;
        bool mySetRequest;
        SUMOTime myArrivalTime;
        double myArrivalSpeed;
        double myArrivalSpeedBraking;
        double myDistance;
        double accelV;
        bool hadStoppedVehicle;
        double availableSpace;
 
        DriveProcessItem(MSLink* link, double vPass, double vWait, bool setRequest,
                         SUMOTime arrivalTime, double arrivalSpeed,
                         double arrivalSpeedBraking,
                         double distance,
                         double leaveSpeed) :
            myLink(link), myVLinkPass(vPass), myVLinkWait(vWait), mySetRequest(setRequest),
            myArrivalTime(arrivalTime), myArrivalSpeed(arrivalSpeed),
            myArrivalSpeedBraking(arrivalSpeedBraking),
            myDistance(distance),
            accelV(leaveSpeed), hadStoppedVehicle(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),
            myArrivalSpeedBraking(0),
            myDistance(distance),
            accelV(-1), hadStoppedVehicle(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 void adaptStopSpeed(const double v) {
            myVLinkWait = MIN2(myVLinkWait, 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 myLFLinkLanesPrev;
 
    DriveItemVector::iterator myNextDriveItem;
 
    void planMoveInternal(const SUMOTime t, MSLeaderInfo ahead, DriveItemVector& lfLinks, double& myStopDist, double& newStopSpeed, std::pair<double, const MSLink*>& myNextTurn) const;
 
    void checkRewindLinkLanes(const double lengthsInFront, DriveItemVector& lfLinks) const;
 
    void removeApproachingInformation(const DriveItemVector& lfLinks) const;
 
    /* @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] lastLink the lastLink index
     * @param[in,out] the safe velocity for driving
     * @param[in,out] the safe velocity for arriving at the next link
     */
    void adaptToLeader(const std::pair<const MSVehicle*, double> leaderInfo,
                       double seen,
                       DriveProcessItem* const lastLink,
                       double& v, double& vLinkPass) const;
 
    bool brakeForOverlap(const MSLink* link, const MSLane* lane) const;
 
public:
    void adaptToJunctionLeader(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;
 
    void adaptToOncomingLeader(const std::pair<const MSVehicle*, double> leaderInfo,
                               DriveProcessItem* const lastLink,
                               double& v, double& vLinkPass) const;
 
    bool ignoreRed(const MSLink* link, bool canBrake) const;
 
    bool ignoreFoe(const SUMOTrafficObject* foe) const;
 
    inline double accelThresholdForWaiting() const {
        return 0.5 * getCarFollowModel().getMaxAccel();
    }
 
    /* @brief return the previous lane in this vehicles route including internal lanes
     * @param[in] current The lane of which the predecessor should be returned
     * @param[in,out] routeIndex The index of the current or previous non-internal edge in the route
     */
    const MSLane* getPreviousLane(const MSLane* current, int& furtherIndex) 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;
protected:
 
    /* @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 adaptToLeaderDistance(const MSLeaderDistanceInfo& ahead, double latOffset,
                               double seen,
                               DriveProcessItem* const lastLink,
                               double& v, double& vLinkPass) const;
 
 
    void checkLinkLeaderCurrentAndParallel(const MSLink* link, const MSLane* lane, double seen,
                                           DriveProcessItem* const lastLink, double& v, double& vLinkPass, double& vLinkWait, bool& setRequest) const;
 
 
    void updateState(double vNext, bool parking = false);
 
 
    bool keepClear(const MSLink* link) const;
 
    std::pair<double, double> estimateTimeToNextStop() const;
 
    /* @brief special considerations for opposite direction driving so that the
     * result can be used directly by getPositionOnLane(...) */
    double getBackPositionOnLane(const MSLane* lane, bool calledByGetPosition) const;
 
    bool hasArrivedInternal(bool oppositeTransformed = true) const;
 
 
    SUMOTime getArrivalTime(SUMOTime t, double seen, double v, double arrivalSpeed) const;
 
    bool isOppositeLane(const MSLane* lane) const;
 
    void cleanupFurtherLanes();
 
    bool betterContinuation(const LaneQ* bestConnectedNext, const LaneQ& m) const;
 
    void resetApproachOnReroute();
 
private:
    MSCFModel::VehicleVariables* myCFVariables;
 
    Influencer* myInfluencer;
 
 
private:
    MSVehicle();
 
    MSVehicle(const MSVehicle&);
 
    MSVehicle& operator=(const MSVehicle&);
 
};