MSAbstractLaneChangeModel.h

Go to the documentation of this file.

/****************************************************************************/
// Interface for lane-change models
/****************************************************************************/
// 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 MSAbstractLaneChangeModel_h
#define MSAbstractLaneChangeModel_h


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

#include "MSLane.h"
#include "MSVehicle.h"


// ===========================================================================
// used enumeration
// ===========================================================================
enum LaneChangeAction {

    LCA_NONE = 0,
    LCA_URGENT = 1,
    LCA_SPEEDGAIN = 2,
    LCA_LEFT = 4,
    LCA_RIGHT = 8,

    LCA_WANTS_LANECHANGE = LCA_URGENT | LCA_SPEEDGAIN | LCA_LEFT | LCA_RIGHT,



    LCA_BLOCKED_BY_LEFT_LEADER = 16,
    LCA_BLOCKED_BY_LEFT_FOLLOWER = 32,

    LCA_BLOCKED_BY_RIGHT_LEADER = 64,
    LCA_BLOCKED_BY_RIGHT_FOLLOWER = 128,

    LCA_BLOCKED_LEFT = LCA_BLOCKED_BY_LEFT_LEADER | LCA_BLOCKED_BY_LEFT_FOLLOWER,
    LCA_BLOCKED_RIGHT = LCA_BLOCKED_BY_RIGHT_LEADER | LCA_BLOCKED_BY_RIGHT_FOLLOWER,
    LCA_BLOCKED_BY_LEADER = LCA_BLOCKED_BY_LEFT_LEADER | LCA_BLOCKED_BY_RIGHT_LEADER,
    LCA_BLOCKED_BY_FOLLOWER = LCA_BLOCKED_BY_LEFT_FOLLOWER | LCA_BLOCKED_BY_RIGHT_FOLLOWER,
    LCA_BLOCKED = LCA_BLOCKED_LEFT | LCA_BLOCKED_RIGHT

                  // The vehicle is blocked being overlapping
                  // This is currently not used, but I'll keep it while working on this, as
                  //  overlapping may be interested, but surely divided by leader/follower
                  // LCA_OVERLAPPING = 64

};





// ===========================================================================
// class definitions
// ===========================================================================
class MSAbstractLaneChangeModel {
public:
    class MSLCMessager {
    public:
        MSLCMessager(MSVehicle* leader,  MSVehicle* neighLead, MSVehicle* neighFollow) throw()
            : myLeader(leader), myNeighLeader(neighLead),
              myNeighFollower(neighFollow) { }


        ~MSLCMessager() { }


        void* informLeader(void* info, MSVehicle* sender) throw() {
            assert(myLeader!=0);
            return myLeader->getLaneChangeModel().inform(info, sender);
        }


        void* informNeighLeader(void* info, MSVehicle* sender) throw() {
            assert(myNeighLeader!=0);
            return myNeighLeader->getLaneChangeModel().inform(info, sender);
        }


        void* informNeighFollower(void* info, MSVehicle* sender) throw() {
            assert(myNeighFollower!=0);
            return myNeighFollower->getLaneChangeModel().inform(info, sender);
        }


    private:
        MSVehicle* myLeader;
        MSVehicle* myNeighLeader;
        MSVehicle* myNeighFollower;

    };



    MSAbstractLaneChangeModel(MSVehicle& v) throw()
        : myVehicle(v), myOwnState(0),
#ifndef NO_TRACI
          myChangeRequest(MSVehicle::REQUEST_NONE),
#endif
          myCarFollowModel(v.getCarFollowModel()) {
    }


    virtual ~MSAbstractLaneChangeModel() { }



    int getOwnState() const {
        return myOwnState;
    }

    void setOwnState(int state) {
        myOwnState = state;
    }

    virtual void prepareStep() { }

    virtual int wantsChangeToRight(
        MSLCMessager& msgPass, int blocked,
        const std::pair<MSVehicle*, SUMOReal> &leader,
        const std::pair<MSVehicle*, SUMOReal> &neighLead,
        const std::pair<MSVehicle*, SUMOReal> &neighFollow,
        const MSLane& neighLane,
        const std::vector<MSVehicle::LaneQ> &preb,
        MSVehicle** lastBlocked) = 0;

    virtual int wantsChangeToLeft(
        MSLCMessager& msgPass, int blocked,
        const std::pair<MSVehicle*, SUMOReal> &leader,
        const std::pair<MSVehicle*, SUMOReal> &neighLead,
        const std::pair<MSVehicle*, SUMOReal> &neighFollow,
        const MSLane& neighLane,
        const std::vector<MSVehicle::LaneQ> &preb,
        MSVehicle** lastBlocked) = 0;

    virtual void* inform(void* info, MSVehicle* sender) = 0;

    virtual SUMOReal patchSpeed(const SUMOReal min, const SUMOReal wanted, const SUMOReal max,
                                const MSCFModel& cfModel) = 0;

    virtual void changed() = 0;

#ifndef NO_TRACI

    virtual void requestLaneChange(MSVehicle::ChangeRequest request) {
        myChangeRequest = request;
    };

    virtual void fulfillChangeRequest(MSVehicle::ChangeRequest request) {
        if (request == myChangeRequest) {
            myChangeRequest = MSVehicle::REQUEST_NONE;
        }
    }
#endif

protected:
    virtual bool congested(const MSVehicle* const neighLeader) {
        if (neighLeader==0) {
            return false;
        }
        // Congested situation are relevant only on highways (maxSpeed > 70km/h)
        // and congested on German Highways means that the vehicles have speeds
        // below 60km/h. Overtaking on the right is allowed then.
        if ((myVehicle.getLane()->getMaxSpeed() <= 70.0 / 3.6) || (neighLeader->getLane()->getMaxSpeed() <= 70.0 / 3.6)) {

            return false;
        }
        if (myVehicle.congested() && neighLeader->congested()) {
            return true;
        }
        return false;
    }

    virtual bool predInteraction(const MSVehicle* const leader) {
        if (leader==0) {
            return false;
        }
        // let's check it on highways only
        if (leader->getSpeed()<(80.0/3.6)) {
            return false;
        }
        SUMOReal gap = leader->getPositionOnLane() - leader->getVehicleType().getLengthWithGap() - myVehicle.getPositionOnLane();
        return gap < myCarFollowModel.interactionGap(&myVehicle, leader->getSpeed());
    }



protected:
    MSVehicle& myVehicle;

    int myOwnState;


#ifndef NO_TRACI
    MSVehicle::ChangeRequest myChangeRequest;
#endif

    const MSCFModel& myCarFollowModel;

};


#endif

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