MSLaneChanger Class Reference

#include <MSLaneChanger.h>

---

Detailed Description

Performs lane changing of vehicles.

Definition at line 51 of file MSLaneChanger.h.

Public Types
typedef std::vector< ChangeElem >	Changer
	The list of changers; For each lane, a ChangeElem is being build.
typedef Changer::iterator	ChangerIt
	the iterator moving over the ChangeElems
typedef Changer::const_iterator	ConstChangerIt
	the iterator moving over the ChangeElems
Public Member Functions
void	laneChange (SUMOTime t)
	Start lane-change-process for all vehicles on the edge'e lanes.
	MSLaneChanger (std::vector< MSLane * > *lanes)
	Constructor.
	~MSLaneChanger ()
	Destructor.
Protected Member Functions
int	advan2left (const std::pair< MSVehicle *const, SUMOReal > &leader, const std::pair< MSVehicle *const, SUMOReal > &rLead, const std::pair< MSVehicle *const, SUMOReal > &rFollow, int blocked, const std::vector< MSVehicle::LaneQ > &preb) const throw ()
int	advan2right (const std::pair< MSVehicle *const, SUMOReal > &leader, const std::pair< MSVehicle *const, SUMOReal > &rLead, const std::pair< MSVehicle *const, SUMOReal > &rFollow, int blocked, const std::vector< MSVehicle::LaneQ > &preb) const throw ()
bool	change ()
int	change2left (const std::pair< MSVehicle *const, SUMOReal > &leader, const std::pair< MSVehicle *const, SUMOReal > &rLead, const std::pair< MSVehicle *const, SUMOReal > &rFollow, const std::vector< MSVehicle::LaneQ > &preb) const throw ()
int	change2right (const std::pair< MSVehicle *const, SUMOReal > &leader, const std::pair< MSVehicle *const, SUMOReal > &rLead, const std::pair< MSVehicle *const, SUMOReal > &rFollow, const std::vector< MSVehicle::LaneQ > &preb) const throw ()
ChangerIt	findCandidate ()
	Find current candidate. If there is none, myChanger.end() is returned.
std::pair< MSVehicle *const, SUMOReal >	getRealFollower (const ChangerIt &target) const throw ()
std::pair< MSVehicle *const, SUMOReal >	getRealLeader (const ChangerIt &target) const throw ()
std::pair< MSVehicle *const, SUMOReal >	getRealLeftFollower () const throw ()
std::pair< MSVehicle *const, SUMOReal >	getRealLeftLeader () const throw ()
std::pair< MSVehicle *const, SUMOReal >	getRealRightFollower () const throw ()
std::pair< MSVehicle *const, SUMOReal >	getRealRightLeader () const throw ()
std::pair< MSVehicle *const, SUMOReal >	getRealThisLeader (const ChangerIt &target) const throw ()
void	initChanger ()
	Initialize the changer before looping over all vehicles.
bool	overlapWithHopped (ChangerIt target) const throw ()
void	setIsSafeChange (const std::pair< MSVehicle *const, SUMOReal > &neighLead, const std::pair< MSVehicle *const, SUMOReal > &neighFollow, const ChangerIt &target, int &blocked) const throw ()
void	setOverlap (const std::pair< MSVehicle *const, SUMOReal > &neighLead, const std::pair< MSVehicle *const, SUMOReal > &neighFollow, int &blocked) const throw ()
void	updateChanger (bool vehHasChanged)
void	updateLanes (SUMOTime t)
MSVehicle *	veh (ConstChangerIt ce) const throw ()
bool	vehInChanger () const throw ()
	Check if there is a single change-candidate in the changer. Returns true if there is one.
Protected Attributes
ChangerIt	myCandi
Changer	myChanger
	Container for ChangeElemements, one for every lane in the edge.
Private Member Functions
	MSLaneChanger (const MSLaneChanger &)
	Copy constructor.
	MSLaneChanger ()
	Default constructor.
MSLaneChanger &	operator= (const MSLaneChanger &)
	Assignment operator.
Data Structures
struct	ChangeElem

---

Member Typedef Documentation

typedef std::vector< ChangeElem > MSLaneChanger::Changer

The list of changers; For each lane, a ChangeElem is being build.

Definition at line 88 of file MSLaneChanger.h.

typedef Changer::iterator MSLaneChanger::ChangerIt

the iterator moving over the ChangeElems

Definition at line 91 of file MSLaneChanger.h.

typedef Changer::const_iterator MSLaneChanger::ConstChangerIt

the iterator moving over the ChangeElems

Definition at line 94 of file MSLaneChanger.h.

---

Constructor & Destructor Documentation

MSLaneChanger::MSLaneChanger

(

std::vector< MSLane * > *

lanes

)

Constructor.

Definition at line 49 of file MSLaneChanger.cpp.

References MSLaneChanger::ChangeElem::follow, MSLaneChanger::ChangeElem::hoppedVeh, MSLaneChanger::ChangeElem::lane, MSLaneChanger::ChangeElem::lastBlocked, MSLaneChanger::ChangeElem::lead, myChanger, and MSLaneChanger::ChangeElem::veh.

                                                      {
    assert(lanes->size() > 1);

    // Fill the changer with the lane-data.
    myChanger.reserve(lanes->size());
    for (std::vector<MSLane*>::iterator lane = lanes->begin(); lane != lanes->end(); ++lane) {
        ChangeElem ce;
        ce.follow    = 0;
        ce.lead      = 0;
        ce.lane      = *lane;
        ce.veh       = (*lane)->myVehicles.rbegin();
        ce.hoppedVeh = 0;
        ce.lastBlocked = 0;
        myChanger.push_back(ce);
    }
}

MSLaneChanger::~MSLaneChanger

(

)

Destructor.

Definition at line 67 of file MSLaneChanger.cpp.

{}

MSLaneChanger::MSLaneChanger

(

)

[private]

Default constructor.

MSLaneChanger::MSLaneChanger

(

const MSLaneChanger &

)

[private]

Copy constructor.

---

Member Function Documentation

int MSLaneChanger::advan2left	(	const std::pair< MSVehicle *const, SUMOReal > &	leader,
		const std::pair< MSVehicle *const, SUMOReal > &	rLead,
		const std::pair< MSVehicle *const, SUMOReal > &	rFollow,
		int	blocked,
		const std::vector< MSVehicle::LaneQ > &	preb
	)			const throw () [protected]

Returns true, if candidate has an advantage by changing to the left.

Definition at line 636 of file MSLaneChanger.cpp.

References MSVehicle::getLaneChangeModel(), myCandi, veh(), and MSAbstractLaneChangeModel::wantsChangeToLeft().

Referenced by change2left().

                                                                               {
    MSAbstractLaneChangeModel::MSLCMessager
    msg(leader.first, neighLead.first, neighFollow.first);
    return veh(myCandi)->getLaneChangeModel().wantsChangeToLeft(
               msg, blocked,
               leader, neighLead, neighFollow, *(myCandi+1)->lane,
               preb,
               &(myCandi->lastBlocked));
}

int MSLaneChanger::advan2right	(	const std::pair< MSVehicle *const, SUMOReal > &	leader,
		const std::pair< MSVehicle *const, SUMOReal > &	rLead,
		const std::pair< MSVehicle *const, SUMOReal > &	rFollow,
		int	blocked,
		const std::vector< MSVehicle::LaneQ > &	preb
	)			const throw () [protected]

Returns true, if candidate has an advantage by changing to the right.

Definition at line 620 of file MSLaneChanger.cpp.

References MSVehicle::getLaneChangeModel(), myCandi, veh(), and MSAbstractLaneChangeModel::wantsChangeToRight().

Referenced by change2right().

                                                                                {
    MSAbstractLaneChangeModel::MSLCMessager
    msg(leader.first, neighLead.first, neighFollow.first);
    return veh(myCandi)->getLaneChangeModel().wantsChangeToRight(
               msg, blocked,
               leader, neighLead, neighFollow, *(myCandi-1)->lane,
               preb,
               &(myCandi->lastBlocked));
}

bool MSLaneChanger::change

(

)

[protected]

Find a new candidate and try to change it.

Definition at line 112 of file MSLaneChanger.cpp.

References bla, change2left(), change2right(), MSAbstractLaneChangeModel::changed(), DELTA_T, MSVehicle::enterLaneAtLaneChange(), findCandidate(), MSAbstractLaneChangeModel::fulfillChangeRequest(), MSVehicle::getBestLanes(), MSVehicle::getLaneChangeModel(), MSVehicleType::getLength(), MSVehicle::getPositionOnLane(), getRealLeftFollower(), getRealLeftLeader(), getRealRightFollower(), getRealRightLeader(), getRealThisLeader(), MSVehicle::getSpeed(), MSAbstractLaneChangeModel::getState(), MSVehicle::getVehicleType(), LCA_BLOCKEDBY_FOLLOWER, LCA_BLOCKEDBY_LEADER, LCA_LEFT, LCA_RIGHT, LCA_SPEEDGAIN, LCA_URGENT, MSVehicle::leaveLane(), myCandi, myChanger, MSVehicle::myLastLaneChangeOffset, MSVehicle::myState, MSAbstractLaneChangeModel::prepareStep(), REQUEST_LEFT, REQUEST_RIGHT, MSAbstractLaneChangeModel::setState(), SUMOReal, and veh().

Referenced by laneChange().

                      {
    // Find change-candidate. If it is on an allowed lane, try to change
    // to the right (there is a rule in Germany that you have to change
    // to the right, unless you are overtaking). If change to the right
    // isn't possible, check if there is a possibility to overtake (on the
    // left.
    // If candidate isn't on an allowed lane, changing to an allowed has
    // priority.
    myCandi = findCandidate();
    MSVehicle* vehicle = veh(myCandi);
    const std::vector<MSVehicle::LaneQ> &preb = vehicle->getBestLanes();
    assert(preb.size()==myChanger.size());
    for (int i=0; i<(int) myChanger.size(); ++i) {
        ((std::vector<MSVehicle::LaneQ>&) preb)[i].occupied = myChanger[i].dens + preb[i].v;
    }

    vehicle->getLaneChangeModel().prepareStep();
    // check whether the vehicle wants and is able to change to right lane
    std::pair<MSVehicle * const, SUMOReal> rLead = getRealRightLeader();
    std::pair<MSVehicle * const, SUMOReal> lLead = getRealLeftLeader();
    std::pair<MSVehicle * const, SUMOReal> rFollow = getRealRightFollower();
    std::pair<MSVehicle * const, SUMOReal> lFollow = getRealLeftFollower();
    std::pair<MSVehicle * const, SUMOReal> leader = getRealThisLeader(myCandi);
    int state1 = change2right(leader, rLead, rFollow, preb);
    bool changingAllowed =
        (state1&(LCA_BLOCKEDBY_LEADER|LCA_BLOCKEDBY_FOLLOWER))==0;
    if ((state1&LCA_URGENT)!=0||(state1&LCA_SPEEDGAIN)!=0) {
        state1 |= LCA_RIGHT;
    }
    // change if the vehicle wants to and is allowed to change
    if ((state1&LCA_RIGHT)!=0&&changingAllowed) {
#ifndef NO_TRACI
        // inform lane change model about this change
        vehicle->getLaneChangeModel().fulfillChangeRequest(REQUEST_RIGHT);
        /*std::cout << "TraCI: lane changer fulfilled request for RIGHT |time " << MSNet::getInstance()->getCurrentTimeStep() << "s" << std::endl;*/
#endif
        (myCandi - 1)->hoppedVeh = vehicle;
        (myCandi - 1)->lane->myTmpVehicles.push_front(vehicle);
        vehicle->leaveLane(false);
        myCandi->lane->leftByLaneChange(vehicle);
        vehicle->enterLaneAtLaneChange((myCandi - 1)->lane);
        (myCandi - 1)->lane->enteredByLaneChange(vehicle);
        vehicle->myLastLaneChangeOffset = 0;
        vehicle->getLaneChangeModel().changed();
        (myCandi - 1)->dens += (myCandi - 1)->hoppedVeh->getVehicleType().getLength();
        return true;
    }
    if ((state1&LCA_RIGHT)!=0&&(state1&LCA_URGENT)!=0) {
        (myCandi - 1)->lastBlocked = vehicle;
    }

    // check whether the vehicle wants and is able to change to left lane
    int state2 =
        change2left(leader, lLead, lFollow,preb);
    if ((state2&LCA_URGENT)!=0||(state2&LCA_SPEEDGAIN)!=0) {
        state2 |= LCA_LEFT;
    }
    changingAllowed =
        (state2&(LCA_BLOCKEDBY_LEADER|LCA_BLOCKEDBY_FOLLOWER))==0;
    vehicle->getLaneChangeModel().setState(state2|state1);
    // change if the vehicle wants to and is allowed to change
    if ((state2&LCA_LEFT)!=0&&changingAllowed) {
#ifndef NO_TRACI
        // inform lane change model about this change
        vehicle->getLaneChangeModel().fulfillChangeRequest(REQUEST_LEFT);
        /*std::cout << "TraCI: lane changer fulfilled request for LEFT |time " << MSNet::getInstance()->getCurrentTimeStep() << "s" << std::endl;*/
#endif
        (myCandi + 1)->hoppedVeh = veh(myCandi);
        (myCandi + 1)->lane->myTmpVehicles.push_front(veh(myCandi));
        vehicle->leaveLane(false);
        myCandi->lane->leftByLaneChange(vehicle);
        vehicle->enterLaneAtLaneChange((myCandi + 1)->lane);
        (myCandi + 1)->lane->enteredByLaneChange(vehicle);
        vehicle->myLastLaneChangeOffset = 0;
        vehicle->getLaneChangeModel().changed();
        (myCandi + 1)->dens += (myCandi + 1)->hoppedVeh->getVehicleType().getLength();
        return true;
    }
    if ((state2&LCA_LEFT)!=0&&(state2&LCA_URGENT)!=0) {
        (myCandi + 1)->lastBlocked = vehicle;
    }

    if ((state1&(LCA_URGENT))!=0&&(state2&(LCA_URGENT))!=0) {
        // ... wants to go to the left AND to the right
        // just let them go to the right lane...
        state2 = 0;
        vehicle->getLaneChangeModel().setState(state1);
    }
    // check whether the vehicles should be swapped
    if (false&&((state1&(LCA_URGENT))!=0||(state2&(LCA_URGENT))!=0)) {
        // get the direction ...
        ChangerIt target;
        int dir;
        if ((state1&(LCA_URGENT))!=0) {
            // ... wants to go right
            target = myCandi - 1;
            dir = -1;
        }
        if ((state2&(LCA_URGENT))!=0) {
            // ... wants to go left
            target = myCandi + 1;
            dir = 1;
        }
        MSVehicle *prohibitor = target->lead;
        if (target->hoppedVeh!=0) {
            SUMOReal hoppedPos = target->hoppedVeh->getPositionOnLane();
            if (prohibitor==0||(
                        hoppedPos>vehicle->getPositionOnLane() && prohibitor->getPositionOnLane()>hoppedPos)) {

                prohibitor = 0;// !!! vehicles should not jump over more than one lanetarget->hoppedVeh;
            }
        }
        if (prohibitor!=0
                &&
                ((prohibitor->getLaneChangeModel().getState()&(LCA_URGENT/*|LCA_SPEEDGAIN*/))!=0
                 &&
                 (prohibitor->getLaneChangeModel().getState()&(LCA_LEFT|LCA_RIGHT))
                 !=
                 (vehicle->getLaneChangeModel().getState()&(LCA_LEFT|LCA_RIGHT))
                )
           ) {

            // check for position and speed
            if (prohibitor->getVehicleType().getLength()-vehicle->getVehicleType().getLength()==0) {
                // ok, may be swapped
                // remove vehicle to swap with
                MSLane::VehCont::iterator i =
                    find(
                        target->lane->myTmpVehicles.begin(),
                        target->lane->myTmpVehicles.end(),
                        prohibitor);
                if (i!=target->lane->myTmpVehicles.end()) {
                    MSVehicle *bla = *i;
                    assert(bla==prohibitor);
                    target->lane->myTmpVehicles.erase(i);
                    // set this vehicle
                    target->hoppedVeh = vehicle;
                    target->lane->myTmpVehicles.push_front(vehicle);
                    myCandi->hoppedVeh = prohibitor;
                    myCandi->lane->myTmpVehicles.push_front(prohibitor);

                    // leave lane and detectors
                    vehicle->leaveLane(false);
                    prohibitor->leaveLane(false);
                    // patch position and speed
                    SUMOReal p1 = vehicle->getPositionOnLane();
                    vehicle->myState.myPos = prohibitor->myState.myPos;
                    prohibitor->myState.myPos = p1;
                    p1 = vehicle->getSpeed();
                    vehicle->myState.mySpeed = prohibitor->myState.mySpeed;
                    prohibitor->myState.mySpeed = p1;
                    // enter lane and detectors
                    vehicle->enterLaneAtLaneChange(target->lane);
                    prohibitor->enterLaneAtLaneChange(myCandi->lane);
                    // mark lane change
                    vehicle->getLaneChangeModel().changed();
                    vehicle->myLastLaneChangeOffset = 0;
                    prohibitor->getLaneChangeModel().changed();
                    prohibitor->myLastLaneChangeOffset = 0;
                    (myCandi)->dens += prohibitor->getVehicleType().getLength();
                    (target)->dens += vehicle->getVehicleType().getLength();
                    return true;
                }
            }
        }
    }
    // Candidate didn't change lane.
    myCandi->lane->myTmpVehicles.push_front(veh(myCandi));
    vehicle->myLastLaneChangeOffset += DELTA_T;
    (myCandi)->dens += vehicle->getVehicleType().getLength();
    return false;
}

int MSLaneChanger::change2left	(	const std::pair< MSVehicle *const, SUMOReal > &	leader,
		const std::pair< MSVehicle *const, SUMOReal > &	rLead,
		const std::pair< MSVehicle *const, SUMOReal > &	rFollow,
		const std::vector< MSVehicle::LaneQ > &	preb
	)			const throw () [protected]

Definition at line 534 of file MSLaneChanger.cpp.

References advan2left(), MSVehicle::getPositionOnLane(), LCA_BLOCKEDBY_FOLLOWER, LCA_BLOCKEDBY_LEADER, myCandi, myChanger, overlapWithHopped(), setIsSafeChange(), setOverlap(), and veh().

Referenced by change().

                                                                                {
    // Try to change to the left-lane, if there is one. If this lane isn't
    // an allowed one, cancel the try. Otherwise, check some conditions.
    // If they are simultaniously fulfilled, a change is possible.

    // no left lane, overlapping or left lane not allowed -> exit
    ChangerIt target = myCandi + 1;
    if (target == myChanger.end()) {
        return 0;
    }
    if (!target->lane->allowsVehicleClass(veh(myCandi)->getVehicleType().getVehicleClass())) {
        return 0;
    }
    int blocked = overlapWithHopped(target)
                  ? target->hoppedVeh->getPositionOnLane()<veh(myCandi)->getPositionOnLane()
                  ? LCA_BLOCKEDBY_FOLLOWER
                  : LCA_BLOCKEDBY_LEADER
                  : 0;
    setOverlap(rLead, rFollow, blocked);
    setIsSafeChange(rLead, rFollow, target, blocked);
    return blocked
           |
           advan2left(leader, rLead, rFollow,
                      blocked, preb);
}

int MSLaneChanger::change2right	(	const std::pair< MSVehicle *const, SUMOReal > &	leader,
		const std::pair< MSVehicle *const, SUMOReal > &	rLead,
		const std::pair< MSVehicle *const, SUMOReal > &	rFollow,
		const std::vector< MSVehicle::LaneQ > &	preb
	)			const throw () [protected]

Definition at line 502 of file MSLaneChanger.cpp.

References advan2right(), MSVehicle::getPositionOnLane(), LCA_BLOCKEDBY_FOLLOWER, LCA_BLOCKEDBY_LEADER, myCandi, myChanger, overlapWithHopped(), setIsSafeChange(), setOverlap(), and veh().

Referenced by change().

                                                                                 {
    // Try to change to the right-lane if there is one. If this lane isn't
    // an allowed one, cancel the try. Otherwise, check some conditions. If
    // they are simultaniously fulfilled, a change is possible.

    // no right lane -> exit
    if (myCandi == myChanger.begin()) {
        return 0;
    }

    ChangerIt target = myCandi - 1;
    if (!target->lane->allowsVehicleClass(veh(myCandi)->getVehicleType().getVehicleClass())) {
        return 0;
    }
    int blocked = overlapWithHopped(target)
                  ? target->hoppedVeh->getPositionOnLane()<veh(myCandi)->getPositionOnLane()
                  ? LCA_BLOCKEDBY_FOLLOWER
                  : LCA_BLOCKEDBY_LEADER
                  : 0;
    setOverlap(rLead, rFollow, blocked);
    setIsSafeChange(rLead, rFollow, target, blocked);
    return blocked
           |
           advan2right(leader, rLead, rFollow,
                       blocked, preb);
}

MSLaneChanger::ChangerIt MSLaneChanger::findCandidate

(

)

[protected]

Find current candidate. If there is none, myChanger.end() is returned.

Definition at line 476 of file MSLaneChanger.cpp.

References max, myChanger, and veh().

Referenced by change().

                             {
    // Find the vehicle in myChanger with the smallest position. If there
    // is no vehicle in myChanger (shouldn't happen) , return
    // myChanger.end().
    ChangerIt max = myChanger.end();
    for (ChangerIt ce = myChanger.begin(); ce != myChanger.end(); ++ce) {
        if (veh(ce) == 0) {
            continue;
        }
        if (max == myChanger.end()) {
            max = ce;
            continue;
        }
        assert(veh(ce)  != 0);
        assert(veh(max) != 0);
        if (veh(max)->getPositionOnLane() < veh(ce)->getPositionOnLane()) {
            max = ce;
        }
    }
    assert(max != myChanger.end());
    assert(veh(max) != 0);
    return max;
}

std::pair< MSVehicle *const, SUMOReal > MSLaneChanger::getRealFollower

(

const ChangerIt &

target

)

const throw () [protected]

Definition at line 380 of file MSLaneChanger.cpp.

References MSVehicleType::getLength(), MSVehicle::getPositionOnLane(), MSVehicle::getSpeed(), MSVehicle::getVehicleType(), MIN2(), myCandi, SPEED2DIST, SUMOReal, and veh().

Referenced by getRealLeftFollower(), and getRealRightFollower().

                                                                    {
    MSVehicle* neighFollow = veh(target);
    // check whether the hopped vehicle got the follower
    if (target->hoppedVeh!=0) {
        SUMOReal hoppedPos = target->hoppedVeh->getPositionOnLane();
        if (hoppedPos<=veh(myCandi)->getPositionOnLane() &&
                (neighFollow==0 || neighFollow->getPositionOnLane()>hoppedPos)) {

            neighFollow = target->hoppedVeh;
        }
    }
    if (neighFollow==0) {
        SUMOReal speed = target->lane->getMaxSpeed();
        // in order to look back, we'd need the minimum braking ability of vehicles in the net...
        // we'll assume it to be 4m/s^2
        // !!!revisit
        SUMOReal dist = speed * speed * SUMOReal(1./2.*4.) + SPEED2DIST(speed);
        dist = MIN2(dist, (SUMOReal) 500.);
        MSVehicle *candi = veh(myCandi);
        SUMOReal seen = candi->getPositionOnLane()-candi->getVehicleType().getLength();
        return target->lane->getFollowerOnConsecutive(dist, seen, candi->getSpeed(), candi->getPositionOnLane() - candi->getVehicleType().getLength());
    } else {
        MSVehicle *candi = veh(myCandi);
        return std::pair<MSVehicle * const, SUMOReal>(neighFollow,
                candi->getPositionOnLane()-candi->getVehicleType().getLength()-neighFollow->getPositionOnLane());
    }
}

std::pair< MSVehicle *const, SUMOReal > MSLaneChanger::getRealLeader

(

const ChangerIt &

target

)

const throw () [protected]

Definition at line 323 of file MSLaneChanger.cpp.

References MSCFModel::brakeGap(), MSVehicle::getBestLanesContinuation(), MSVehicle::getCarFollowModel(), MSLane::getPartialOccupator(), MSLane::getPartialOccupatorEnd(), MSVehicle::getPositionOnLane(), MSVehicle::getSpeed(), myCandi, SUMOReal, and veh().

Referenced by getRealLeftLeader(), and getRealRightLeader().

                                                                  {
    // get the leading vehicle on the lane to change to
    MSVehicle* neighLead = target->lead;
    // check whether the hopped vehicle got the leader
    if (target->hoppedVeh!=0) {
        SUMOReal hoppedPos = target->hoppedVeh->getPositionOnLane();
        if (hoppedPos>veh(myCandi)->getPositionOnLane() &&
                (neighLead==0 || neighLead->getPositionOnLane()>hoppedPos)) {

            neighLead = target->hoppedVeh;
        }
    }
    if (neighLead==0) {
        MSLane* targetLane = target->lane;
        MSVehicle *predP = targetLane->getPartialOccupator();
        if (predP!=0) {
            return std::pair<MSVehicle *, SUMOReal>(predP, targetLane->getPartialOccupatorEnd() - veh(myCandi)->getPositionOnLane());
        }
        const std::vector<MSLane*> &bestLaneConts = veh(myCandi)->getBestLanesContinuation(myCandi->lane);
        SUMOReal seen = myCandi->lane->getLength() - veh(myCandi)->getPositionOnLane();
        SUMOReal speed = veh(myCandi)->getSpeed();
        SUMOReal dist = veh(myCandi)->getCarFollowModel().brakeGap(speed);
        if (seen>dist) {
            return std::pair<MSVehicle * const, SUMOReal>(0, -1);
        }
        return target->lane->getLeaderOnConsecutive(dist, seen, speed, *veh(myCandi), bestLaneConts);
    } else {
        MSVehicle *candi = veh(myCandi);
        return std::pair<MSVehicle * const, SUMOReal>(neighLead,
                neighLead->getPositionOnLane()-neighLead->getVehicleType().getLength()-candi->getPositionOnLane());
    }
}

std::pair< MSVehicle *const, SUMOReal > MSLaneChanger::getRealLeftFollower

(

)

const throw () [protected]

Definition at line 421 of file MSLaneChanger.cpp.

References getRealFollower(), myCandi, and myChanger.

Referenced by change().

                                                 {
    // there is no left lane
    if ((myCandi+1) == myChanger.end()) {
        return std::pair<MSVehicle *, SUMOReal>(0, -1);
    }
    ChangerIt target = myCandi + 1;
    return getRealFollower(target);
}

std::pair< MSVehicle *const, SUMOReal > MSLaneChanger::getRealLeftLeader

(

)

const throw () [protected]

Definition at line 369 of file MSLaneChanger.cpp.

References getRealLeader(), myCandi, and myChanger.

Referenced by change().

                                               {
    // there is no left lane
    if ((myCandi+1) == myChanger.end()) {
        return std::pair<MSVehicle *, SUMOReal>(0, -1);
    }
    ChangerIt target = myCandi + 1;
    return getRealLeader(target);
}

std::pair< MSVehicle *const, SUMOReal > MSLaneChanger::getRealRightFollower

(

)

const throw () [protected]

Definition at line 410 of file MSLaneChanger.cpp.

References getRealFollower(), myCandi, and myChanger.

Referenced by change().

                                                  {
    // there is no right lane
    if (myCandi == myChanger.begin()) {
        return std::pair<MSVehicle *, SUMOReal>(0, -1);
    }
    ChangerIt target = myCandi - 1;
    return getRealFollower(target);
}

std::pair< MSVehicle *const, SUMOReal > MSLaneChanger::getRealRightLeader

(

)

const throw () [protected]

Definition at line 358 of file MSLaneChanger.cpp.

References getRealLeader(), myCandi, and myChanger.

Referenced by change().

                                                {
    // there is no right lane
    if (myCandi == myChanger.begin()) {
        return std::pair<MSVehicle *, SUMOReal>(0, -1);
    }
    ChangerIt target = myCandi - 1;
    return getRealLeader(target);
}

std::pair< MSVehicle *const, SUMOReal > MSLaneChanger::getRealThisLeader

(

const ChangerIt &

target

)

const throw () [protected]

Definition at line 287 of file MSLaneChanger.cpp.

References MSVehicle::getBestLanesContinuation(), MSLane::getLastVehicle(), MSVehicleType::getLength(), MSLane::getPartialOccupator(), MSLane::getPartialOccupatorEnd(), MSVehicle::getPositionOnLane(), MSVehicle::getVehicleType(), MSLane::isLinkEnd(), MAX2(), myCandi, MSLane::succLinkSec(), SUMOReal, and veh().

Referenced by change().

                                                                      {
    // get the leading vehicle on the lane to change to
    MSVehicle* leader = target->lead;
    if (leader==0) {
        MSLane* targetLane = target->lane;
        MSVehicle *predP = targetLane->getPartialOccupator();
        if (predP!=0) {
            return std::pair<MSVehicle *, SUMOReal>(predP, targetLane->getPartialOccupatorEnd() - veh(myCandi)->getPositionOnLane());
        }
        const std::vector<MSLane*> &bestLaneConts = veh(myCandi)->getBestLanesContinuation();
        MSLinkCont::const_iterator link = targetLane->succLinkSec(*veh(myCandi), 1, *targetLane, bestLaneConts);
        if (targetLane->isLinkEnd(link)) {
            return std::pair<MSVehicle *, SUMOReal>(0, -1);
        }
        MSLane *nextLane = (*link)->getLane();
        if (nextLane==0) {
            return std::pair<MSVehicle *, SUMOReal>(0, -1);
        }
        leader = nextLane->getLastVehicle();
        if (leader==0) {
            return std::pair<MSVehicle *, SUMOReal>(0, -1);
        }
        SUMOReal gap =
            leader->getPositionOnLane()-leader->getVehicleType().getLength()
            +
            (myCandi->lane->getLength()-veh(myCandi)->getPositionOnLane());
        return std::pair<MSVehicle * const, SUMOReal>(leader, MAX2((SUMOReal) 0, gap));
    } else {
        MSVehicle *candi = veh(myCandi);
        SUMOReal gap = leader->getPositionOnLane()-leader->getVehicleType().getLength()-candi->getPositionOnLane();
        return std::pair<MSVehicle * const, SUMOReal>(leader, MAX2((SUMOReal) 0, gap));
    }
}

void MSLaneChanger::initChanger

(

)

[protected]

Initialize the changer before looping over all vehicles.

Definition at line 87 of file MSLaneChanger.cpp.

References myChanger.

Referenced by laneChange().

                           {
    // Prepare myChanger with a safe state.
    for (ChangerIt ce = myChanger.begin(); ce != myChanger.end(); ++ce) {
        ce->lead = 0;
        ce->hoppedVeh = 0;
        ce->lastBlocked = 0;
        ce->dens = 0;

        MSLane::VehCont& vehicles = ce->lane->myVehicles;
        if (vehicles.empty()) {
            ce->veh  = vehicles.rend();
            ce->follow = 0;
            continue;
        }
        ce->veh  = vehicles.rbegin();
        if (vehicles.size() == 1) {
            ce->follow = 0;
            continue;
        }
        ce->follow = *(vehicles.rbegin() + 1);
    }
}

void MSLaneChanger::laneChange

(

SUMOTime

t

)

Start lane-change-process for all vehicles on the edge'e lanes.

Definition at line 71 of file MSLaneChanger.cpp.

References change(), initChanger(), updateChanger(), updateLanes(), and vehInChanger().

Referenced by MSEdge::changeLanes().

                                    {
    // This is what happens in one timestep. After initialization of the
    // changer, each vehicle will try to change. After that the changer
    // nedds an update to prevent multiple changes of one vehicle.
    // Finally, the change-result has to be given back to the lanes.
    initChanger();
    while (vehInChanger()) {

        bool haveChanged = change();
        updateChanger(haveChanged);
    }
    updateLanes(t);
}

MSLaneChanger& MSLaneChanger::operator=

(

const MSLaneChanger &

)

[private]

Assignment operator.

bool MSLaneChanger::overlapWithHopped

(

ChangerIt

target

)

const throw () [inline, protected]

Returns true if candidate overlaps with a vehicle, that already changed the lane.

Definition at line 179 of file MSLaneChanger.h.

References myCandi, MSVehicle::overlap(), and veh().

Referenced by change2left(), and change2right().

                                                           {
        MSVehicle *v1 = target->hoppedVeh;
        MSVehicle *v2 = veh(myCandi);
        if (v1!=0 && v2!=0) {
            return MSVehicle::overlap(v1, v2);
        }
        return false;
    }

void MSLaneChanger::setIsSafeChange	(	const std::pair< MSVehicle *const, SUMOReal > &	neighLead,
		const std::pair< MSVehicle *const, SUMOReal > &	neighFollow,
		const ChangerIt &	target,
		int &	blocked
	)			const throw () [protected]

Definition at line 584 of file MSLaneChanger.cpp.

References MSVehicle::getCarFollowModel(), MSLane::getMaxSpeed(), MSVehicle::getSpeed(), MSCFModel::hasSafeGap(), LCA_BLOCKEDBY_FOLLOWER, LCA_BLOCKEDBY_LEADER, myCandi, and veh().

Referenced by change2left(), and change2right().

                                                                                    {
    // Check if candidate's change to target-lane will be safe, i.e. is there
    // enough back-gap to the neighFollow to drive collision-free (if there is
    // no neighFollow, keep a safe-gap to the beginning of the lane) and is
    // there enough gap for the candidate to neighLead to drive collision-
    // free (if there is no neighLead, be sure that candidate is able to slow-
    // down towards the lane end).
    MSVehicle* vehicle     = veh(myCandi);

    // check back gap
    if ((blocked&LCA_BLOCKEDBY_FOLLOWER)==0) {
        if (neighFollow.first!=0) {
            MSLane* targetLane = target->lane;
            // !!! eigentlich: vsafe braucht die Max. Geschwindigkeit beider Spuren
            if (!neighFollow.first->getCarFollowModel().hasSafeGap(neighFollow.first->getSpeed(), neighFollow.second, vehicle->getSpeed(), targetLane->getMaxSpeed())) {
                blocked |= LCA_BLOCKEDBY_FOLLOWER;
            }
        }
    }

    // check front gap
    if ((blocked&LCA_BLOCKEDBY_LEADER)==0) {
        if (neighLead.first!=0) {
            MSLane* targetLane = target->lane;
            // !!! eigentlich: vsafe braucht die Max. Geschwindigkeit beider Spuren
            if (!vehicle->getCarFollowModel().hasSafeGap(vehicle->getSpeed(), neighLead.second, neighLead.first->getSpeed(), targetLane->getMaxSpeed())) {
                blocked |= LCA_BLOCKEDBY_LEADER;
            }
        }
    }
}

void MSLaneChanger::setOverlap	(	const std::pair< MSVehicle *const, SUMOReal > &	neighLead,
		const std::pair< MSVehicle *const, SUMOReal > &	neighFollow,
		int &	blocked
	)			const throw () [protected]

Definition at line 565 of file MSLaneChanger.cpp.

References LCA_BLOCKEDBY_FOLLOWER, LCA_BLOCKEDBY_LEADER, and LCA_OVERLAPPING.

Referenced by change2left(), and change2right().

                                                      {
    // check the follower only if not already known that...
    if ((blocked&LCA_BLOCKEDBY_FOLLOWER)==0) {
        if (rFollow.first!=0&&rFollow.second<0) {
            blocked |= (LCA_BLOCKEDBY_FOLLOWER|LCA_OVERLAPPING);
        }
    }
    // check the leader only if not already known that...
    if ((blocked&LCA_BLOCKEDBY_LEADER)==0) {
        if (rLead.first!=0&&rLead.second<0) {
            blocked |= (LCA_BLOCKEDBY_LEADER|LCA_OVERLAPPING);
        }
    }
}

void MSLaneChanger::updateChanger

(

bool

vehHasChanged

)

[protected]

After the possible change, update the changer.

Definition at line 433 of file MSLaneChanger.cpp.

References myCandi, and veh().

Referenced by laneChange().

                                               {
    assert(myCandi->veh != myCandi->lane->myVehicles.rend());

    // "Push" the vehicles to the back, i.e. follower becomes vehicle,
    // vehicle becomes leader, and leader becomes predecessor of vehicle,
    // if it exists.
    if (!vehHasChanged) {
        myCandi->lead = veh(myCandi);
    }
    myCandi->veh    = myCandi->veh + 1;

    if (veh(myCandi) == 0) {
        assert(myCandi->follow == 0);
        // leader already 0.
        return;
    }
    if (myCandi->veh + 1 == myCandi->lane->myVehicles.rend()) {
        myCandi->follow = 0;
    } else {
        myCandi->follow = *(myCandi->veh + 1) ;
    }
    return;
}

void MSLaneChanger::updateLanes

(

SUMOTime

t

)

[protected]

During lane-change a temporary vehicle container is filled within the lanes (bad pratice to modify foreign members, I know). Swap this container with the real one.

Definition at line 459 of file MSLaneChanger.cpp.

References myChanger.

Referenced by laneChange().

                                     {

    // Update the lane's vehicle-container.
    // First: it is bad style to change other classes members, but for
    // this release, other attempts were too time-consuming. In a next
    // release we will change from this lane-centered design to a vehicle-
    // centered. This will solve many problems.
    // Second: this swap would be faster if vehicle-containers would have
    // been pointers, but then I had to change too much of the MSLane code.
    for (ChangerIt ce = myChanger.begin(); ce != myChanger.end(); ++ce) {

        ce->lane->swapAfterLaneChange(t);
    }
}

MSVehicle* MSLaneChanger::veh

(

ConstChangerIt

ce

)

const throw () [inline, protected]

Returns a pointer to the changer-element-iterator vehicle, or 0 if there is none.

Definition at line 115 of file MSLaneChanger.h.

Referenced by advan2left(), advan2right(), change(), change2left(), change2right(), findCandidate(), getRealFollower(), getRealLeader(), getRealThisLeader(), overlapWithHopped(), setIsSafeChange(), updateChanger(), and vehInChanger().

                                                    {
        // If ce has a valid vehicle, return it. Otherwise return 0.
        if (ce->veh != ce->lane->myVehicles.rend()) {
            return *(ce->veh);
        }
        return 0;
    }

bool MSLaneChanger::vehInChanger

(

)

const throw () [inline, protected]

Check if there is a single change-candidate in the changer. Returns true if there is one.

Definition at line 102 of file MSLaneChanger.h.

References myChanger, and veh().

Referenced by laneChange().

                                      {
        // If there is at least one valid vehicle under the veh's in myChanger
        // return true.
        for (ConstChangerIt ce = myChanger.begin(); ce != myChanger.end(); ++ce) {
            if (veh(ce) != 0) {
                return true;
            }
        }
        return false;
    }

---

Field Documentation

ChangerIt MSLaneChanger::myCandi [protected]

Change-candidate. Last of the vehicles in changer. Only this one will try to change. Every vehicle on the edge will be a candidate once in the change-process.

Definition at line 205 of file MSLaneChanger.h.

Referenced by advan2left(), advan2right(), change(), change2left(), change2right(), getRealFollower(), getRealLeader(), getRealLeftFollower(), getRealLeftLeader(), getRealRightFollower(), getRealRightLeader(), getRealThisLeader(), overlapWithHopped(), setIsSafeChange(), and updateChanger().

Changer MSLaneChanger::myChanger [protected]

Container for ChangeElemements, one for every lane in the edge.

Definition at line 200 of file MSLaneChanger.h.

Referenced by change(), change2left(), change2right(), findCandidate(), getRealLeftFollower(), getRealLeftLeader(), getRealRightFollower(), getRealRightLeader(), initChanger(), MSLaneChanger(), updateLanes(), and vehInChanger().

---

The documentation for this class was generated from the following files:

• MSLaneChanger.h
• MSLaneChanger.cpp