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-2014 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 "MSVehicleType.h"
#include "MSBaseVehicle.h"
#include "MSLink.h"
#include "MSLane.h"


// ===========================================================================
// class declarations
// ===========================================================================
class SUMOSAXAttributes;
class MSMoveReminder;
class MSLaneChanger;
class MSVehicleTransfer;
class MSAbstractLaneChangeModel;
class MSBusStop;
class MSPerson;
class MSDevice;
class MSEdgeWeightsStorage;
class OutputDevice;
class Position;
class MSDevice_Person;
class MSJunction;


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

    friend class MSLaneChanger;

    class State {
        friend class MSVehicle;
        friend class MSLaneChanger;

    public:
        State(SUMOReal pos, SUMOReal speed);

        State(const State& state);

        State& operator=(const State& state);

        bool operator!=(const State& state);

        SUMOReal pos() const;

        SUMOReal speed() const {
            return mySpeed;
        };

    private:
        SUMOReal myPos;

        SUMOReal mySpeed;

    };


    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 willPass(const MSEdge* const edge) const;

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

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


    static inline SUMOReal gap(SUMOReal predPos, SUMOReal predLength, SUMOReal pos) {
        return predPos - predLength - pos;
    }





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


    void planMove(const SUMOTime t, const MSVehicle* pred, const SUMOReal lengthsInFront);


    bool executeMove();




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


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


    SUMOReal getAcceleration() const {
        return myAcceleration;
    }





    SUMOReal getSlope() const;


    Position getPosition(const SUMOReal offset = 0) const;


    MSLane* getLane() const {
        return myLane;
    }


    inline bool isOnRoad() const {
        return myAmOnNet;
    }


    const MSEdge* getRerouteOrigin() const;


    SUMOTime getWaitingTime() const {
        return myWaitingTime;
    }


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


    SUMOReal getAngle() const;


    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,
                              MSMoveReminder::Notification notification);

    void setTentativeLaneAndPosition(MSLane* lane, const SUMOReal pos);

    void enterLaneAtLaneChange(MSLane* enteredLane);


    void leaveLane(const MSMoveReminder::Notification reason);


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


    struct LaneQ {
        MSLane* lane;
        SUMOReal length;
        SUMOReal occupation;
        SUMOReal nextOccupation;
        int bestLaneOffset;
        bool allowsContinuation;
        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;

    int getBestLaneOffset() const;

    void adaptBestLanesOccupation(int laneIndex, SUMOReal density);


    bool 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;
        MSBusStop* busstop;
        SUMOReal startPos;
        SUMOReal endPos;
        SUMOTime duration;
        SUMOTime until;
        bool triggered;
        bool parking;
        bool reached;
        std::set<std::string> awaitedPersons;
    };


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


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

    bool isStopped() const;

    bool isParking() const;


    bool isStoppedTriggered() const;

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

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


    SUMOReal processNextStop(SUMOReal currentVelocity);

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

    SUMOReal getTimeGap() const;




    SUMOReal getCO2Emissions() const;


    SUMOReal getCOEmissions() const;


    SUMOReal getHCEmissions() const;


    SUMOReal getNOxEmissions() const;


    SUMOReal getPMxEmissions() const;


    SUMOReal getFuelConsumption() const;


    SUMOReal getHarmonoise_NoiseEmissions() const;





    void addPerson(MSPerson* person);


    unsigned int getPersonNumber() 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;
    }


#ifndef NO_TRACI

    SUMOReal getSpeedWithoutTraciInfluence() const;

    bool addTraciStop(MSLane* lane, SUMOReal pos, SUMOReal radius, SUMOTime duration,
                      bool parking, bool triggered, std::string& errorMsg);

    Stop& getNextStop();

    bool resumeFromStopping();


    class Influencer {
    public:
        Influencer();


        ~Influencer();


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


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


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

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


        SUMOReal changeRequestRemainingSeconds(const SUMOTime currentTime) const;

        void setConsiderSafeVelocity(bool value);


        void setConsiderMaxAcceleration(bool value);


        void setConsiderMaxDeceleration(bool value);


        void setRespectJunctionPriority(bool value);


        inline bool getRespectJunctionPriority() const {
            return myRespectJunctionPriority;
        }


        void setEmergencyBrakeRedLight(bool value);


        inline bool getEmergencyBrakeRedLight() const {
            return myEmergencyBrakeRedLight;
        }


        void setLaneChangeMode(int value);


        inline SUMOReal getOriginalSpeed() const {
            return myOriginalSpeed;
        }

        void setVTDControlled(bool c, MSLane* l, SUMOReal pos, int edgeOffset, const MSEdgeVector& route) {
            myAmVTDControlled = c;
            myVTDLane = l;
            myVTDPos = pos;
            myVTDEdgeOffset = edgeOffset;
            myVTDRoute = route;
        }

        void postProcessVTD(MSVehicle* v);

        inline bool isVTDControlled() const {
            return myAmVTDControlled;
        }

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

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

        SUMOReal myOriginalSpeed;

        bool mySpeedAdaptationStarted;

        bool myConsiderSafeVelocity;

        bool myConsiderMaxAcceleration;

        bool myConsiderMaxDeceleration;

        bool myRespectJunctionPriority;

        bool myEmergencyBrakeRedLight;

        bool myAmVTDControlled;
        MSLane* myVTDLane;
        SUMOReal myVTDPos;
        int myVTDEdgeOffset;
        MSEdgeVector myVTDRoute;


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

    };


    Influencer& getInfluencer();

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

    int influenceChangeDecision(int state);

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

#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 updateOccupancyAndCurrentBestLane(const MSLane* startLane);


    SUMOTime myWaitingTime;

    State myState;

    MSLane* myLane;

    MSAbstractLaneChangeModel* myLaneChangeModel;

    const MSEdge* myLastBestLanesEdge;
    const MSLane* myLastBestLanesInternalLane;

    std::vector<std::vector<LaneQ> > myBestLanes;
    std::vector<LaneQ>::iterator myCurrentLaneInBestLanes;
    static std::vector<MSLane*> myEmptyLaneVector;

    std::list<Stop> myStops;

    MSDevice_Person* myPersonDevice;

    SUMOReal myAcceleration;

    std::vector<MSLane*> myFurtherLanes;

    int mySignals;

    bool myAmOnNet;

    bool myAmRegisteredAsWaitingForPerson;

    bool myHaveToWaitOnNextLink;

    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);
            assert(vPass >= 0);
        };

        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);
        };


        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, const MSVehicle* pred, DriveItemVector& lfLinks) const;
    void checkRewindLinkLanes(const SUMOReal lengthsInFront, 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),
                    estimateSpeedAfterDistance(link->getLength(), vLinkPass, getVehicleType().getCarFollowModel().getMaxAccel()));
    }

    /* @brief estimate speed while accelerating for the given distance
     * @param[in] dist The distance during which accelerating takes place
     * @param[in] v The initial speed
     * @param[in] accel The acceleration
     */
    inline SUMOReal estimateSpeedAfterDistance(const SUMOReal dist, const SUMOReal v, const SUMOReal accel) const {
        // dist=v*t + 0.5*accel*t^2, solve for t and multiply with accel, then add v
        return MIN2(getVehicleType().getMaxSpeed(),
                    (SUMOReal)sqrt(2 * dist * accel + v * v));
    }


    /* @brief estimate speed while accelerating for the given distance
     * @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;

#ifdef HAVE_INTERNAL_LANES
    mutable std::map<const MSJunction*, std::set<std::string> > myLinkLeaders;
#endif

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

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