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.sourceforge.net/
// Copyright (C) 2001-2011 DLR (http://www.dlr.de/) and contributors
/****************************************************************************/
//
//   This program 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 2 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 "MSBaseVehicle.h"
#include "MSEdge.h"
#include "MSRoute.h"
#include "MSGlobals.h"
#include <list>
#include <deque>
#include <map>
#include <string>
#include <vector>
#include <utils/common/MsgHandler.h>
#include <utils/common/ToString.h>
#include <utils/common/SUMOVehicle.h>
#include <utils/common/SUMOVehicleClass.h>
#include "MSVehicleType.h"
#include <utils/common/SUMOAbstractRouter.h>

#ifdef HAVE_MESOSIM
#include <mesosim/MEVehicle.h>
#endif


// ===========================================================================
// class declarations
// ===========================================================================
class MSLane;
class MSLink;
class MSMoveReminder;
class MSLaneChanger;
class MSVehicleTransfer;
class MSAbstractLaneChangeModel;
class MSBusStop;
class MSPerson;
class MSDevice;
class MSEdgeWeightsStorage;
class OutputDevice;
class Position;
class MSDevice_Person;
#ifdef _MESSAGES
class MSMessageEmitter;
#endif


// ===========================================================================
// 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, int vehicleIndex) throw(ProcessError);

    virtual ~MSVehicle() throw();





    void onRemovalFromNet(const MSMoveReminder::Notification reason) throw();





    bool ends() const throw();


    bool replaceRoute(const MSRoute* route, bool onInit=false) throw();


    bool willPass(const MSEdge* const edge) const throw();


    MSEdgeWeightsStorage& getWeightsStorage() throw();






    bool moveChecked();


    SUMOReal gap2pred(const MSVehicle& pred) const throw() {
        SUMOReal gap = pred.getPositionOnLane() - pred.getVehicleType().getLengthWithGap() - getPositionOnLane();
        if (gap<0&&gap>-1.0e-12) {
            gap = 0;
        }
        return gap;
    }


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





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



    bool moveRegardingCritical(SUMOTime t, const MSLane* const lane, const MSVehicle* const pred,
                               const MSVehicle* const neigh, SUMOReal lengthsInFront) throw();





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


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


    SUMOReal getPreDawdleAcceleration() const throw() {
        return myPreDawdleAcceleration;
    }





    Position getPosition() const throw();


    MSLane* getLane() const throw() {
        return myLane;
    }


    inline bool isOnRoad() const throw() {
        return myAmOnNet;
    }


    SUMOTime getWaitingTime() const throw() {
        return myWaitingTime;
    }


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


    SUMOReal getAngle() const throw();


    class Influencer;

    void setIndividualMaxSpeed(SUMOReal individualMaxSpeed) {
        myHasIndividualMaxSpeed = true;
        myIndividualMaxSpeed = individualMaxSpeed;
    }

    void unsetIndividualMaxSpeed(void) {
        myHasIndividualMaxSpeed = false;
    }

    void setPreDawdleAcceleration(SUMOReal accel) {
        myPreDawdleAcceleration = accel;
    }


    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) throw();

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



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


    void enterLaneAtLaneChange(MSLane* enteredLane);


    void leaveLane(const MSMoveReminder::Notification reason);


    void vsafeCriticalCont(SUMOTime t, SUMOReal boundVSafe);



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


    struct LaneQ {
        MSLane* lane;
        SUMOReal length;
        SUMOReal occupation;
        SUMOReal nextOccupation;
        int bestLaneOffset;
        bool allowsContinuation;
        std::vector<MSLane*> bestContinuations;
    };

    virtual const std::vector<LaneQ> &getBestLanes(bool forceRebuild=false, MSLane* startLane=0) const throw();


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

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


    void replaceVehicleType(MSVehicleType* type) throw();


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


    inline MSCFModel::VehicleVariables* getCarFollowVariables() const throw() {
        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;
    };


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


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

    bool isStopped() const;

    bool isParking() const;

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

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


    SUMOReal processNextStop(SUMOReal currentVelocity) throw();




    SUMOReal getHBEFA_CO2Emissions() const throw();


    SUMOReal getHBEFA_COEmissions() const throw();


    SUMOReal getHBEFA_HCEmissions() const throw();


    SUMOReal getHBEFA_NOxEmissions() const throw();


    SUMOReal getHBEFA_PMxEmissions() const throw();


    SUMOReal getHBEFA_FuelConsumption() const throw();


    SUMOReal getHarmonoise_NoiseEmissions() const throw();

    void addPerson(MSPerson* person) throw();




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


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


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


    int getSignals() const throw() {
        return mySignals;
    }


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




#ifndef NO_TRACI

    SUMOReal getSpeedWithoutTraciInfluence() const;

    bool addTraciStop(MSLane* lane, SUMOReal pos, SUMOReal radius, SUMOTime duration);


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


        ChangeRequest checkForLaneChanges(SUMOTime currentTime, const MSEdge& currentEdge, unsigned int currentLaneIndex);


        void setConsiderSafeVelocity(bool value);


        void setConsiderMaxAcceleration(bool value);


        void setConsiderMaxDeceleration(bool value);


        SUMOReal getOriginalSpeed() const {
            return myOriginalSpeed;
        }


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


    Influencer& getInfluencer();


#endif

protected:

    void checkRewindLinkLanes(SUMOReal lengthsInFront) throw();
    SUMOReal getSpaceTillLastStanding(MSLane* l, bool& foundStopped) throw();


    void adaptLaneEntering2MoveReminder(const MSLane& enteredLane) throw();



    void setBlinkerInformation() throw();


    SUMOTime myLastLaneChangeOffset;

    SUMOTime myWaitingTime;

#ifdef _MESSAGES

    MSMessageEmitter* myLCMsgEmitter;
    MSMessageEmitter* myBMsgEmitter;
    MSMessageEmitter* myHBMsgEmitter;
#endif

    State myState;

    MSLane* myLane;

    MSAbstractLaneChangeModel* myLaneChangeModel;

    mutable const MSEdge* myLastBestLanesEdge;
    mutable std::vector<std::vector<LaneQ> > myBestLanes;
    mutable std::vector<LaneQ>::iterator myCurrentLaneInBestLanes;
    static std::vector<MSLane*> myEmptyLaneVector;

    std::list<Stop> myStops;

    MSDevice_Person* myPersonDevice;

    SUMOReal myPreDawdleAcceleration;

    std::vector<MSLane*> myFurtherLanes;

    int mySignals;

    bool myAmOnNet;

    bool myAmRegisteredAsWaitingForPerson;

    bool myHaveToWaitOnNextLink;

private:
    struct DriveProcessItem {
        MSLink* myLink;
        SUMOReal myVLinkPass;
        SUMOReal myVLinkWait;
        bool mySetRequest;
        SUMOTime myArrivalTime;
        SUMOReal myArrivalSpeed;
        SUMOReal myDistance;
        DriveProcessItem(MSLink* link, SUMOReal vPass, SUMOReal vWait, bool setRequest,
                         SUMOTime arrivalTime, SUMOReal arrivalSpeed, SUMOReal distance) :
            myLink(link), myVLinkPass(vPass), myVLinkWait(vWait), mySetRequest(setRequest),
            myArrivalTime(arrivalTime), myArrivalSpeed(arrivalSpeed), myDistance(distance) { };
    };

    typedef std::vector< DriveProcessItem > DriveItemVector;

    DriveItemVector myLFLinkLanes;

    MSEdgeWeightsStorage* myEdgeWeights;

    MSCFModel::VehicleVariables* myCFVariables;

#ifndef NO_TRACI

    Influencer* myInfluencer;
#endif

private:
    MSVehicle();

    MSVehicle(const MSVehicle&);

    MSVehicle& operator=(const MSVehicle&);


};


#endif

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