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 2001-2010 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 "MSEdge.h"
#include "MSNet.h"
#include "MSRoute.h"
#include "MSCORN.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 "MSVehicleQuitReminded.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 MSMoveReminder;
class MSLaneChanger;
class MSVehicleTransfer;
class MSAbstractLaneChangeModel;
class MSBusStop;
class OutputDevice;
class MSDevice;
class MSEdgeWeightsStorage;
#ifdef _MESSAGES
class MSMessageEmitter;
#endif


// ===========================================================================
// class definitions
// ===========================================================================
class MSVehicle : public MSVehicleQuitReminded
#ifdef HAVE_MESOSIM
        , public MEVehicle
#else
        , public SUMOVehicle
#endif
{
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;

    };



    virtual ~MSVehicle() throw();





    const SUMOVehicleParameter &getParameter() const throw() {
        return *myParameter;
    }


    const MSEdge &getDepartEdge() const {
        return **myCurrEdge;
    }


    SUMOTime getDesiredDepart() const throw() {
        return myParameter->depart;
    }





    void onTryEmit() throw();


    void onDepart() throw();


    void onRemovalFromNet(bool forTeleporting) throw();





    void removeOnTripEnd(MSVehicle *veh) throw();





    inline bool hasSuccEdge(unsigned int nSuccs) const throw() {
        return myCurrEdge + nSuccs < myRoute->end();
    }

    const MSEdge* succEdge(unsigned int nSuccs) const throw();


    bool moveRoutePointer(const MSEdge* targetEdge) throw();


    bool ends() const throw();


    const MSRoute &getRoute() const throw() {
        return *myRoute;
    }


    const MSRoute &getRoute(int index) const throw();


    bool replaceRoute(const MSEdgeVector &edges, SUMOTime simTime, bool onInit=false) throw();


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


    void reroute(SUMOTime t, SUMOAbstractRouter<MSEdge, SUMOVehicle> &router, bool withTaz=false) throw();


    MSEdgeWeightsStorage &getWeightsStorage() throw();


    bool hasValidRoute(std::string &msg) const throw();






    void moveFirstChecked();


    SUMOReal gap2pred(const MSVehicle& pred) const throw() {
        SUMOReal gap = pred.getPositionOnLane() - pred.getVehicleType().getLength() - 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;
    }




    int getCORNIntValue(MSCORN::Function f) const throw();


    void *getCORNPointerValue(MSCORN::Pointer p) const throw();


    bool hasCORNIntValue(MSCORN::Function f) const throw();


    bool hasCORNPointerValue(MSCORN::Pointer p) const throw();




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


    SUMOReal getPositionOnActiveMoveReminderLane(const MSLane * const searchedLane) const throw();



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




    const State &getState() const throw() {
        return myState;
    }

    SUMOReal getPositionOnLane() const throw() {
#ifdef HAVE_MESOSIM
        if (MSGlobals::gUseMesoSim) {
            return MEVehicle::getPositionOnLane();
        }
#endif
        return myState.myPos;
    }


    SUMOReal getSpeed() const throw() {
#ifdef HAVE_MESOSIM
        if (MSGlobals::gUseMesoSim) {
            return MEVehicle::getSpeed();
        }
#endif
        return myState.mySpeed;
    }

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



    SUMOReal getMaxSpeed() const {
        if (myHasIndividualMaxSpeed)
            return myIndividualMaxSpeed;
        return myType->getMaxSpeed();
    }

    SUMOReal adaptMaxSpeed(SUMOReal referenceSpeed) {
        if (myType->hasSpeedDeviation() && referenceSpeed != myReferenceSpeed) {
            myHasIndividualMaxSpeed = true;
            myIndividualMaxSpeed = myType->getMaxSpeedWithDeviation(referenceSpeed);
            myReferenceSpeed = referenceSpeed;
        }
        if (myHasIndividualMaxSpeed)
            return myIndividualMaxSpeed;
        return MIN2(myType->getMaxSpeed(), referenceSpeed);
    }

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

    void unsetIndividualMaxSpeed(void) {
        myHasIndividualMaxSpeed = false;
    }

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


    const std::string &getID() const throw();

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


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

    Position2D getPosition() const;




    void saveState(std::ostream &os);


    const MSEdge * const getEdge() const;


    void enterLaneAtMove(MSLane* enteredLane, SUMOReal driven);



    void enterLaneAtEmit(MSLane* enteredLane, SUMOReal pos, SUMOReal speed);


    void enterLaneAtLaneChange(MSLane* enteredLane);


    void leaveLaneAtMove(SUMOReal driven);


    void leaveLane(bool isArrival);


    friend class MSVehicleControl;

    void vsafeCriticalCont(SUMOTime t, SUMOReal minVSafe, SUMOReal lengthsInFront);

    MSLane *getTargetLane() const;

    const MSLane &getLane() const;

    inline bool isOnRoad() const throw() {
#ifdef HAVE_MESOSIM
        if (MSGlobals::gUseMesoSim) {
            return MEVehicle::getSegment() != 0;
        }
#endif
        return myLane!=0;
    }



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


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



    void quitRemindedEntered(MSVehicleQuitReminded *r);
    void quitRemindedLeft(MSVehicleQuitReminded *r);


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


    struct LaneQ {
        MSLane *lane;
        SUMOReal length;
        SUMOReal v;
        SUMOReal occupied;
        int bestLaneOffset;
        bool allowsContinuation;
        std::vector<MSLane*> joined;
    };

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



    inline const MSVehicleType &getVehicleType() const throw() {
        return *myType;
    }


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


    void writeXMLRoute(OutputDevice &os, int index=-1) const;




    struct Stop {
        const MSLane *lane;
        MSBusStop *busstop;
        SUMOReal pos;
        SUMOTime duration;
        SUMOTime until;
        bool reached;
    };


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


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

    bool isStopped();

    bool knowsEdgeTest(MSEdge &edge) const;


    const std::vector<MSDevice*> &getDevices() const {
        return myDevices;
    }

    void setWasVaporized(bool onDepart);

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

#ifndef NO_TRACI

    SUMOReal getSpeedWithoutTraciInfluence() const throw() {
        return speedWithoutTraciInfluence;
    }

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


    bool startSpeedAdaption(float newSpeed, SUMOTime duration, SUMOTime currentTime);

    void adaptSpeed();

    void checkLaneChangeConstraint(SUMOTime time);

    void checkForLaneChanges();

    void startLaneChange(unsigned lane, SUMOTime stickyTime);

    void processTraCICommands(SUMOTime time);
#endif

protected:




    void checkRewindLinkLanes(SUMOReal lengthsInFront) throw();


    void activateReminders(bool isEmit, bool isLaneChange) throw();


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



    void rebuildContinuationsFor(LaneQ &q, MSLane *l, MSRouteIterator ce, int seen) const;
    virtual void setBlinkerInformation() { }


    MSVehicle(SUMOVehicleParameter* pars, const MSRoute* route,
              const MSVehicleType* type, int vehicleIndex) throw(ProcessError);

    MSLane *myTarget;

    SUMOReal myLastLaneChangeOffset;

    SUMOTime myWaitingTime;

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

    const SUMOVehicleParameter* myParameter;

    const MSRoute* myRoute;

    State myState;

    SUMOReal myIndividualMaxSpeed;

    bool myHasIndividualMaxSpeed;

    SUMOReal myReferenceSpeed;

    MSLane* myLane;

    MSAbstractLaneChangeModel *myLaneChangeModel;

    const MSVehicleType * const myType;

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

    std::map<MSCORN::Pointer, void*> myPointerCORNMap;
    std::map<MSCORN::Function, int> myIntCORNMap;

    std::list<Stop> myStops;

    SUMOReal myArrivalPos;

    SUMOReal myPreDawdleAcceleration;

    std::vector<MSLane*> myFurtherLanes;


private:
    std::vector<MSDevice*> myDevices;

    MSRouteIterator myCurrEdge;


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

    typedef std::vector< DriveProcessItem > DriveItemVector;

    DriveItemVector myLFLinkLanes;



    typedef std::vector< MSMoveReminder* > MoveReminderCont;

    MoveReminderCont myMoveReminders;

    MoveReminderCont myOldLaneMoveReminders;

    typedef std::vector<SUMOReal> OffsetVector;

    OffsetVector myOldLaneMoveReminderOffsets;

    typedef std::vector<MSVehicleQuitReminded*> QuitRemindedVector;
    QuitRemindedVector myQuitReminded;



    class RouteReplaceInfo {
    public:
        RouteReplaceInfo(const MSEdge * const edge_, SUMOTime time_, MSRoute *route_)
                : edge(edge_), time(time_), route(route_) {}

        ~RouteReplaceInfo() { }

        const MSEdge *edge;

        SUMOTime time;

        MSRoute *route;

    };

    typedef std::vector<RouteReplaceInfo> ReplacedRoutesVector;


    struct DepartArrivalInformation {
        SUMOTime time;
        MSLane *lane;
        SUMOReal pos;
        SUMOReal speed;
    };


    MSEdgeWeightsStorage *myEdgeWeights;


#ifndef NO_TRACI
    /* indicates whether the vehicle is adapting its speed caused by the TraCI command slowDown*/
    bool adaptingSpeed;
    bool isLastAdaption;

    /* speed of the vehicle before any speed adaption began */
    SUMOReal speedBeforeAdaption;

    /* speed of the vehicle before influence of TraCI settings takes place */
    SUMOReal speedWithoutTraciInfluence;

    /* the amount by wich the speed shall be reduced */
    SUMOReal speedReduction;

    /* simulation time, when the last speed adaption started */
    SUMOTime timeBeforeAdaption;

    /* duration of the last speed adaption */
    SUMOTime adaptDuration;

    /* simulation time when the last lane change was forced */
    SUMOTime timeBeforeLaneChange;

    /* duration for which the last lane change will be in effect */
    SUMOTime laneChangeStickyTime;

    /* lane index of the destination road map position for an active lane change*/
    unsigned myDestinationLane;

    /* true if any forced lane change is in effect*/
    bool laneChangeConstraintActive;

#endif

private:
    MSVehicle();

    MSVehicle(const MSVehicle&);

    MSVehicle& operator=(const MSVehicle&);


};


#endif

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