GUIInternalLane Class Reference

#include <GUIInternalLane.h>

Inheritance diagram for GUIInternalLane:

---

Detailed Description

An extended MSInternalLane. A mechanism to avoid concurrent visualisation and simulation what may cause problems when vehicles disappear is implemented using a mutex

Definition at line 57 of file GUIInternalLane.h.

interaction with MSMoveReminder
virtual void	addMoveReminder (MSMoveReminder *rem) throw ()
	Add a move-reminder to move-reminder container.
const MoveReminderCont &	getMoveReminders () const throw ()
	Return the list of this lane's move reminders.
typedef std::vector < MSMoveReminder * >	MoveReminderCont
	Definition of a container for move reminder.
Public Types
typedef std::deque< MSVehicle * >	VehCont
	Container for vehicles.
Public Member Functions
void	addIncomingLane (MSLane *lane, MSLink *viaLink)
bool	allowsVehicleClass (SUMOVehicleClass vclass) const
virtual bool	appropriate (const MSVehicle *veh)
GUILaneWrapper *	buildLaneWrapper (GUIGlObjectStorage &idStorage)
void	detectCollisions (SUMOTime timestep)
	Check if vehicles are too close.
bool	empty () const
	Returns true if there is not a single vehicle on the lane.
void	enteredByLaneChange (MSVehicle *v)
MSEdge &	getEdge () const throw ()
	Returns the lane's edge.
virtual const MSVehicle *const	getFirstVehicle () const
std::pair< MSVehicle *const, SUMOReal >	getFollowerOnConsecutive (SUMOReal dist, SUMOReal seen, SUMOReal leaderSpeed, SUMOReal backOffset) const
const std::vector < IncomingLaneInfo > &	getIncomingLanes () const
virtual MSVehicle *const	getLastVehicle () const
	returns the last vehicle
std::pair< MSVehicle *const, SUMOReal >	getLeaderOnConsecutive (SUMOReal dist, SUMOReal seen, SUMOReal leaderSpeed, const MSVehicle &veh, const std::vector< MSLane * > &bestLaneConts) const
MSLane *const	getLeftLane () const
const MSLinkCont &	getLinkCont () const
	returns the container with all links !!!
MSLane *const	getRightLane () const
	GUIInternalLane (const std::string &id, SUMOReal maxSpeed, SUMOReal length, MSEdge *const edge, unsigned int numericalID, const Position2DVector &shape, const std::vector< SUMOVehicleClass > &allowed, const std::vector< SUMOVehicleClass > &disallowed) throw ()
	Constructor.
void	init (MSEdgeControl &, std::vector< MSLane * >::const_iterator firstNeigh, std::vector< MSLane * >::const_iterator lastNeigh)
bool	isLinkEnd (MSLinkCont::iterator &i)
bool	isLinkEnd (MSLinkCont::const_iterator &i) const
void	leftByLaneChange (MSVehicle *v)
MSVehicle *	removeFirstVehicle ()
MSVehicle *	removeVehicle (MSVehicle *remVehicle)
void	setAllowedClasses (const std::vector< SUMOVehicleClass > &classes) throw ()
void	setLength (SUMOReal val) throw ()
void	setMaxSpeed (SUMOReal val) throw ()
void	setNotAllowedClasses (const std::vector< SUMOVehicleClass > &classes) throw ()
virtual MSLinkCont::const_iterator	succLinkSec (const SUMOVehicle &veh, unsigned int nRouteSuccs, const MSLane &succLinkSource, const std::vector< MSLane * > &conts) const
	~GUIInternalLane () throw ()
	Destructor.
Vehicle emission
bool	emit (MSVehicle &v) throw (ProcessError)
	Tries to emit the given vehicle.
bool	freeEmit (MSVehicle &veh, SUMOReal speed) throw ()
	Tries to emit the given vehicle on any place.
Atomar value getter
const std::vector < SUMOVehicleClass > &	getAllowedClasses () const throw ()
	Returns vehicle classes explicitely allowed on this lane.
const std::string &	getID () const throw ()
	Returns this lane's id.
SUMOReal	getLength () const throw ()
	Returns the lane's length.
SUMOReal	getMaxSpeed () const throw ()
	Returns the lane's maximum speed.
const std::vector < SUMOVehicleClass > &	getNotAllowedClasses () const throw ()
	Returns vehicle classes explicitely disallowed on this lane.
size_t	getNumericalID () const throw ()
	Returns this lane's numerical id.
const Position2DVector &	getShape () const throw ()
	Returns this lane's shape.
Current state retrieval
SUMOReal	getHarmonoise_NoiseEmissions () const throw ()
	Returns the sum of last step noise emissions.
SUMOReal	getHBEFA_CO2Emissions () const throw ()
	Returns the sum of last step CO2 emissions.
SUMOReal	getHBEFA_COEmissions () const throw ()
	Returns the sum of last step CO emissions.
SUMOReal	getHBEFA_FuelConsumption () const throw ()
	Returns the sum of last step fuel consumption.
SUMOReal	getHBEFA_HCEmissions () const throw ()
	Returns the sum of last step HC emissions.
SUMOReal	getHBEFA_NOxEmissions () const throw ()
	Returns the sum of last step NOx emissions.
SUMOReal	getHBEFA_PMxEmissions () const throw ()
	Returns the sum of last step PMx emissions.
SUMOReal	getMeanSpeed () const throw ()
	Returns the mean speed on this lane.
SUMOReal	getOccupancy () const throw ()
	Returns the occupancy of this lane during the last step.
SUMOReal	getVehLenSum () const throw ()
	Returns the sum of lengths of vehicles which were on the lane during the last step.
Handling vehicles lapping into lanes
std::pair< MSVehicle *, SUMOReal >	getLastVehicleInformation () const throw ()
	Returns the last vehicle which is still on the lane.
MSVehicle *	getPartialOccupator () const throw ()
	Returns the vehicle which laps into this lane.
SUMOReal	getPartialOccupatorEnd () const throw ()
	Returns the position of the in-lapping vehicle's end.
void	resetPartialOccupation (MSVehicle *v) throw ()
	Removes the information about a vehicle lapping into this lane.
SUMOReal	setPartialOccupation (MSVehicle *v, SUMOReal leftVehicleLength) throw ()
	Sets the information about a vehicle lapping into this lane.
Access to vehicles
unsigned int	getVehicleNumber () const throw ()
	Returns the number of vehicles on this lane.
Access to vehicles
const VehCont &	getVehiclesSecure () const throw ()
	Returns the vehicles container; locks it for microsimulation.
void	releaseVehicles () const throw ()
	Allows to use the container for microsimulation again.
Additional initialisation
void	initialize (MSLinkCont *succs)
	Delayed initialization.
Vehicle movement (longitudinal)
bool	integrateNewVehicle (SUMOTime t)
bool	moveCritical (SUMOTime t)
bool	setCritical (SUMOTime t, std::vector< MSLane * > &into)
Vehicle emission
virtual bool	isEmissionSuccess (MSVehicle *vehicle, SUMOReal speed, SUMOReal pos, bool recheckNextLanes) throw (ProcessError)
	Tries to emit the given vehicle with the given state (speed and pos).
Additional initialisation
void	setParentJunctionInformation (MSLogicJunction::InnerState *const foescont, unsigned int foesIdx) throw ()
	Sets the information where to report vehicles being on this lane to.
void	setPassPosition (SUMOReal passPos) throw ()
	Sets the position that must be free so that vehicles can pass.
Static Public Member Functions
static void	clear ()
static MSLane *	dictionary (std::string id)
	Returns the MSEdgeControl associated to the key id if exists Otherwise returns 0.
static bool	dictionary (std::string id, MSLane *lane)
	Inserts a MSLane into the static dictionary Returns true if the key id isn't already in the dictionary. Otherwise returns false.
static size_t	dictSize ()
static void	insertIDs (std::vector< std::string > &into) throw ()
Data Fields
Position2DVector	myShape
	The shape of the lane.
Protected Types
typedef std::map< std::string, MSLane * >	DictType
	definition of the tatic dictionary type
Protected Member Functions
MSVehicle *	pop (SUMOTime t)
bool	push (MSVehicle *veh)
void	swapAfterLaneChange (SUMOTime t)
	moves myTmpVehicles int myVehicles after a lane change procedure
Protected Attributes
std::vector< SUMOVehicleClass >	myAllowedClasses
	The list of allowed vehicle classes.
SUMOReal	myBackDistance
MSEdge *	myEdge
	The lane's edge, for routing only.
std::vector< MSLane * > ::const_iterator	myFirstNeigh
	The lane left to the described lane (==lastNeigh if none).
std::string	myID
	Unique ID.
std::vector< IncomingLaneInfo >	myIncomingLanes
MSVehicle *	myInlappingVehicle
	The vehicle which laps into this lane.
SUMOReal	myInlappingVehicleEnd
	End position of a vehicle which laps into this lane.
std::vector< MSLane * > ::const_iterator	myLastNeigh
	The end of this lane's edge's lane container.
SUMOReal	myLeftVehLength
	Not yet seen vehicle lengths.
SUMOReal	myLength
	Lane length [m].
MSLinkCont	myLinks
SUMOReal	myMaxSpeed
	Lane-wide speedlimit [m/s].
std::vector< SUMOVehicleClass >	myNotAllowedClasses
	The list of disallowed vehicle classes.
size_t	myNumericalID
	Unique numerical ID (set on reading by netload).
VehCont	myTmpVehicles
std::vector< MSVehicle * >	myVehBuffer
SUMOReal	myVehicleLengthSum
	The current length of all vehicles on this lane.
VehCont	myVehicles
	The lane's vehicles. The entering vehicles are inserted at the front of this container and the leaving ones leave from the back, e.g. the vehicle in front of the junction (often called first) is myVehicles.back() (if it exists). And if it is an iterator at a vehicle, ++it points to the vehicle in front. This is the interaction vehicle.
Static Protected Attributes
static DictType	myDict
	Static dictionary to associate string-ids with objects.
Private Attributes
MFXMutex	myLock
	The mutex used to avoid concurrent updates of the vehicle buffer.
Friends
class	GUILaneWrapper
class	MSLaneChanger
	needs access to myTmpVehicles (this maybe should be done via SUMOReal-buffering!!!)
class	MSXMLRawOut

---

Member Typedef Documentation

typedef std::map< std::string, MSLane* > MSLane::DictType [protected, inherited]

definition of the tatic dictionary type

Definition at line 647 of file MSLane.h.

typedef std::vector< MSMoveReminder* > MSLane::MoveReminderCont [inherited]

Definition of a container for move reminder.

Definition at line 133 of file MSLane.h.

typedef std::deque< MSVehicle* > MSLane::VehCont [inherited]

Container for vehicles.

Definition at line 422 of file MSLane.h.

---

Constructor & Destructor Documentation

GUIInternalLane::GUIInternalLane	(	const std::string &	id,
		SUMOReal	maxSpeed,
		SUMOReal	length,
		MSEdge *const	edge,
		unsigned int	numericalID,
		const Position2DVector &	shape,
		const std::vector< SUMOVehicleClass > &	allowed,
		const std::vector< SUMOVehicleClass > &	disallowed
	)			throw ()

Constructor.

Parameters:

[in]	id	The lane's id
[in]	maxSpeed	The speed allowed on this lane
[in]	length	The lane's length
[in]	edge	The edge this lane belongs to
[in]	numericalID	The numerical id of the lane
[in]	allowed	Vehicle classes that explicitely may drive on this lane
[in]	disallowed	Vehicle classes that are explicitaly forbidden on this lane

See also:

SUMOVehicleClass

MSLane

MSInternalLane

Definition at line 51 of file GUIInternalLane.cpp.

        : MSInternalLane(id, maxSpeed, length, edge, numericalID, shape, allowed, disallowed) {}

GUIInternalLane::~GUIInternalLane

(

)

throw ()

Destructor.

Definition at line 60 of file GUIInternalLane.cpp.

References MFXMutex::locked(), myLock, and MFXMutex::unlock().

                                          {
    // just to quit cleanly on a failure
    if (myLock.locked()) {
        myLock.unlock();
    }
}

---

Member Function Documentation

void MSLane::addIncomingLane	(	MSLane *	lane,
		MSLink *	viaLink
	)			[inherited]

Definition at line 891 of file MSLane.cpp.

References MSLane::getLength(), MSLane::IncomingLaneInfo::lane, MSLane::IncomingLaneInfo::length, MSLane::myIncomingLanes, and MSLane::IncomingLaneInfo::viaLink.

Referenced by NLSucceedingLaneBuilder::addSuccLane().

                                                     {
    IncomingLaneInfo ili;
    ili.lane = lane;
    ili.viaLink = viaLink;
    ili.length = lane->getLength();
    myIncomingLanes.push_back(ili);
}

void MSLane::addMoveReminder

(

MSMoveReminder *

rem

)

throw () [virtual, inherited]

Add a move-reminder to move-reminder container.

The move reminder will not be deleted by the lane.

Parameters:

[in]

rem

The move reminder to add

Definition at line 98 of file MSLane.cpp.

References MSLane::myMoveReminders.

                                                   {
    myMoveReminders.push_back(rem);
}

bool MSLane::allowsVehicleClass

(

SUMOVehicleClass

vclass

)

const [inherited]

Definition at line 870 of file MSLane.cpp.

References MSLane::myAllowedClasses, MSLane::myNotAllowedClasses, and SVC_UNKNOWN.

Referenced by MSEdge::getDepartLane().

                                                        {
    if (vclass==SVC_UNKNOWN) {
        return true;
    }
    if (myAllowedClasses.size()==0&&myNotAllowedClasses.size()==0) {
        return true;
    }
    if (find(myAllowedClasses.begin(), myAllowedClasses.end(), vclass)!=myAllowedClasses.end()) {
        return true;
    }
    if (myAllowedClasses.size()!=0) {
        return false;
    }
    if (find(myNotAllowedClasses.begin(), myNotAllowedClasses.end(), vclass)!=myNotAllowedClasses.end()) {
        return false;
    }
    return true;
}

bool MSLane::appropriate

(

const MSVehicle *

veh

)

[virtual, inherited]

Returns the information whether this lane may be used to continue the current route

Definition at line 686 of file MSLane.cpp.

References MSEdge::EDGEFUNCTION_INTERNAL, MSVehicle::getBestLanesContinuation(), MSEdge::getPurpose(), MSLane::myEdge, MSLane::myLinks, and MSLane::succLinkSec().

Referenced by MSVehicle::moveRegardingCritical().

                                        {
    if (myEdge->getPurpose()==MSEdge::EDGEFUNCTION_INTERNAL) {
        return true;
    }
    MSLinkCont::const_iterator link = succLinkSec(*veh, 1, *this, veh->getBestLanesContinuation());
    return (link != myLinks.end());
}

GUILaneWrapper * GUIInternalLane::buildLaneWrapper

(

GUIGlObjectStorage &

idStorage

)

[virtual]

Reimplemented from MSLane.

Definition at line 194 of file GUIInternalLane.cpp.

References MSLane::GUILaneWrapper, and MSLane::myShape.

                                                               {
    return new GUILaneWrapper(idStorage, *this, myShape);
}

void MSLane::clear

(

)

[static, inherited]

Clears the dictionary

Definition at line 636 of file MSLane.cpp.

References MSLane::myDict.

Referenced by MSNet::clearAll().

              {
    for (DictType::iterator i=myDict.begin(); i!=myDict.end(); ++i) {
        delete(*i).second;
    }
    myDict.clear();
}

void GUIInternalLane::detectCollisions

(

SUMOTime

timestep

)

[virtual]

Check if vehicles are too close.

Reimplemented from MSLane.

Definition at line 200 of file GUIInternalLane.cpp.

References MSLane::detectCollisions(), MFXMutex::lock(), myLock, and MFXMutex::unlock().

                                                   {
    myLock.lock();
    try {
        MSLane::detectCollisions(timestep);
        myLock.unlock();
    } catch (ProcessError &) {
        myLock.unlock();
        throw;
    }
}

MSLane * MSLane::dictionary

(

std::string

id

)

[static, inherited]

Returns the MSEdgeControl associated to the key id if exists Otherwise returns 0.

Definition at line 625 of file MSLane.cpp.

References MSLane::myDict.

                               {
    DictType::iterator it = myDict.find(id);
    if (it == myDict.end()) {
        // id not in myDict.
        return 0;
    }
    return it->second;
}

bool MSLane::dictionary	(	std::string	id,
		MSLane *	lane
	)			[static, inherited]

Inserts a MSLane into the static dictionary Returns true if the key id isn't already in the dictionary. Otherwise returns false.

Definition at line 613 of file MSLane.cpp.

References MSLane::myDict.

Referenced by NLHandler::addIncomingLanes(), MSVehicle::addStop(), NLSucceedingLaneBuilder::addSuccLane(), NLHandler::closeLane(), NLSucceedingLaneBuilder::closeSuccLane(), traci::TraCIServer::commandAddVehicle(), NLTriggerBuilder::getLane(), NLDetectorBuilder::getLaneChecking(), NLGeomShapeBuilder::getPointPosition(), GUISelectionLoader::loadSelection(), MSRouteHandler::myStartElement(), NLTriggerBuilder::parseAndBuildLaneSpeedTrigger(), TraCIServerAPI_Lane::processGet(), and TraCIServerAPI_Lane::processSet().

                                            {
    DictType::iterator it = myDict.find(id);
    if (it == myDict.end()) {
        // id not in myDict.
        myDict.insert(DictType::value_type(id, ptr));
        return true;
    }
    return false;
}

static size_t MSLane::dictSize

(

)

[inline, static, inherited]

Definition at line 415 of file MSLane.h.

References MSLane::myDict.

                             {
        return myDict.size();
    }

bool MSLane::emit

(

MSVehicle &

v

)

throw (ProcessError) [inherited]

Tries to emit the given vehicle.

The emission position and speed are determined in dependence to the vehicle's departure definition, first. If "isReinsertion" is set, meaning the vehicle tries to end a teleportation, then the values for the fastest emission are used (speed=max, pos=free).

Then, the vehicle is tried to be inserted into the lane using these values by a call to "isEmissionSuccess". The result of "isEmissionSuccess" is returned.

Parameters:

[in]

v

The vehicle to emit

Returns:

Whether the vehicle could be emitted

See also:

isEmissionSuccess

MSVehicle::getDepartureDefinition

MSVehicle::DepartArrivalDefinition

Definition at line 171 of file MSLane.cpp.

References DEPART_POS_DEFAULT, DEPART_POS_FREE, DEPART_POS_GIVEN, DEPART_POS_RANDOM, DEPART_POS_RANDOM_FREE, DEPART_SPEED_DEFAULT, DEPART_SPEED_GIVEN, DEPART_SPEED_MAX, DEPART_SPEED_RANDOM, SUMOVehicleParameter::departPos, SUMOVehicleParameter::departPosProcedure, SUMOVehicleParameter::departSpeed, SUMOVehicleParameter::departSpeedProcedure, MSLane::freeEmit(), MSLane::getLength(), MSLane::getMaxSpeed(), MSLane::isEmissionSuccess(), MIN2(), RandHelper::rand(), and SUMOReal.

Referenced by MSEdge::emit().

                                               {
    SUMOReal pos = 0;
    SUMOReal speed = 0;
    bool patchSpeed = true; // whether the speed shall be adapted to infrastructure/traffic in front

    // determine the speed
    const SUMOVehicleParameter &pars = veh.getParameter();
    switch (pars.departSpeedProcedure) {
    case DEPART_SPEED_GIVEN:
        speed = pars.departSpeed;
        patchSpeed = false;
        break;
    case DEPART_SPEED_RANDOM:
        speed = RandHelper::rand(MIN2(veh.getMaxSpeed(), getMaxSpeed()));
        patchSpeed = true; // !!!(?)
        break;
    case DEPART_SPEED_MAX:
        speed = MIN2(veh.getMaxSpeed(), getMaxSpeed());
        patchSpeed = true; // !!!(?)
        break;
    case DEPART_SPEED_DEFAULT:
    default:
        // speed = 0 was set before
        patchSpeed = false; // !!!(?)
        break;
    }

    // determine the position
    switch (pars.departPosProcedure) {
    case DEPART_POS_GIVEN:
        if (pars.departPos >= 0.) {
            pos = pars.departPos;
        } else {
            pos = pars.departPos + getLength();
        }
        break;
    case DEPART_POS_RANDOM:
        pos = RandHelper::rand(getLength());
        break;
    case DEPART_POS_RANDOM_FREE: {
        for (unsigned int i=0; i < 10; i++) {
            // we will try some random positions ...
            pos = RandHelper::rand(getLength());
            if (isEmissionSuccess(&veh, speed, pos, patchSpeed)) {
                return true;
            }
        }
        // ... and if that doesn't work, we put the vehicle to the free position
        return freeEmit(veh, speed);
    }
    break;
    case DEPART_POS_FREE:
        return freeEmit(veh, speed);
    case DEPART_POS_DEFAULT:
    default:
        // pos = 0 was set before
        break;
    }

    // try to emit
    return isEmissionSuccess(&veh, speed, pos, patchSpeed);
}

bool MSLane::empty

(

)

const [inline, inherited]

Returns true if there is not a single vehicle on the lane.

Definition at line 382 of file MSLane.h.

References MSLane::myVehBuffer, and MSLane::myVehicles.

                       {
        assert(myVehBuffer.size()==0);
        return myVehicles.empty();
    }

void MSLane::enteredByLaneChange

(

MSVehicle *

v

)

[inherited]

Definition at line 1021 of file MSLane.cpp.

References MSVehicleType::getLength(), MSVehicle::getVehicleType(), and MSLane::myVehicleLengthSum.

                                        {
    myVehicleLengthSum += v->getVehicleType().getLength();
}

bool MSLane::freeEmit	(	MSVehicle &	veh,
		SUMOReal	speed
	)			throw () [inherited]

Tries to emit the given vehicle on any place.

Parameters:

[in]	veh	The vehicle to emit
[in]	speed	The maximum emission speed

Returns:

Whether the vehicle could be emitted

Definition at line 106 of file MSLane.cpp.

References MSVehicle::getCarFollowModel(), MSLane::getLength(), MSVehicleType::getLength(), MSLane::getPartialOccupator(), MSLane::getPartialOccupatorEnd(), MSVehicle::getPositionOnLane(), MSCFModel::getSecureGap(), MSVehicle::getSpeed(), MSCFModel::getSpeedAfterMaxDecel(), MSVehicle::getVehicleType(), MSLane::isEmissionSuccess(), MIN2(), MSLane::myVehicles, POSITION_EPS, and SUMOReal.

Referenced by MSVehicleTransfer::checkEmissions(), and MSLane::emit().

                                                        {
    bool adaptableSpeed = true;
    if (myVehicles.size()==0) {
        if (isEmissionSuccess(&veh, mspeed, 0, adaptableSpeed)) {
            return true;
        }
    } else {
        // check whether the vehicle can be put behind the last one if there is such
        MSVehicle *leader = *myVehicles.begin();
        SUMOReal leaderPos = leader->getPositionOnLane() - leader->getVehicleType().getLength();
        SUMOReal speed = mspeed;
        if (adaptableSpeed) {
            speed = leader->getSpeed();
        }
        SUMOReal frontGapNeeded = veh.getCarFollowModel().getSecureGap(speed, leader->getCarFollowModel().getSpeedAfterMaxDecel(leader->getSpeed()));
        if (leaderPos-frontGapNeeded>=0) {
            SUMOReal tspeed = MIN2(veh.getCarFollowModel().ffeV(&veh, mspeed, frontGapNeeded, leader->getSpeed()), mspeed);
            // check whether we can emit in behind the last vehicle on the lane
            if (isEmissionSuccess(&veh, tspeed, 0, adaptableSpeed)) {
                return true;
            }
        }
    }
    // go through the lane, look for free positions (starting after the last vehicle)
    MSLane::VehCont::iterator predIt = myVehicles.begin();
    while (predIt!=myVehicles.end()) {
        // get leader (may be zero) and follower
        const MSVehicle *leader = predIt!=myVehicles.end()-1 ? *(predIt+1) : getPartialOccupator();
        const MSVehicle *follower = *predIt;

        // patch speed if allowed
        SUMOReal speed = mspeed;
        if (adaptableSpeed&&leader!=0) {
            speed = MIN2(leader->getSpeed(), mspeed);
        }

        // compute the space needed to not collide with leader
        SUMOReal frontMax = getLength();
        if (leader!=0) {
            SUMOReal leaderRearPos = leader->getPositionOnLane() - leader->getVehicleType().getLength();
            if (leader == getPartialOccupator()) {
                leaderRearPos = getPartialOccupatorEnd();
            }
            frontMax = leaderRearPos - veh.getCarFollowModel().getSecureGap(speed, leader->getCarFollowModel().getSpeedAfterMaxDecel(leader->getSpeed()));
        }
        // compute the space needed to not let the follower collide
        const SUMOReal followPos = follower->getPositionOnLane();
        const SUMOReal backGapNeeded = follower->getCarFollowModel().getSecureGap(follower->getSpeed(), veh.getCarFollowModel().getSpeedAfterMaxDecel(speed));
        const SUMOReal backMin = followPos + backGapNeeded + veh.getVehicleType().getLength();

        // check whether there is enough room (given some extra space for rounding errors)
        if (frontMax>0 && backMin+POSITION_EPS<frontMax) {
            // try emit vehicle (should be always ok)
            if (isEmissionSuccess(&veh, speed, backMin+POSITION_EPS, adaptableSpeed)) {
                return true;
            }
        }
        ++predIt;
    }
    // first check at lane's begin
    return false;
}

const std::vector<SUMOVehicleClass>& MSLane::getAllowedClasses

(

)

const throw () [inline, inherited]

Returns vehicle classes explicitely allowed on this lane.

Returns:

This lane's allowed vehicle classes

Definition at line 338 of file MSLane.h.

References MSLane::myAllowedClasses.

Referenced by GUILaneWrapper::Colorer::getColorValue(), and TraCIServerAPI_Lane::processGet().

                                                                         {
        return myAllowedClasses;
    }

MSEdge& MSLane::getEdge

(

)

const throw () [inline, inherited]

Returns the lane's edge.

Returns:

This lane's edge

Definition at line 399 of file MSLane.h.

References MSLane::myEdge.

Referenced by MSVehicle::addStop(), NLDetectorBuilder::buildInductLoop(), MSVehicle::checkRewindLinkLanes(), MSEmitter::childCheckEmit(), MSCalibrator::childCheckEmit(), MSEdge::closeBuilding(), MSVehicle::enterLaneAtMove(), MS_E2_ZS_CollectorOverLanes::extendTo(), MSVehicle::getBestLanes(), MSVehicle::getBestLanesContinuation(), MSVehicle::getDistanceToPosition(), GUILaneWrapper::getEdgeLaneNumber(), GUINet::initDetectors(), MSTriggeredRerouter::Setter::isStillActive(), GUISelectionLoader::loadSelection(), GUI_E2_ZS_CollectorOverLanes::MyWrapper::MyWrapper(), MSTriggeredRerouter::Setter::notifyEnter(), NLTriggerBuilder::parseAndBuildCalibrator(), MSLCM_DK2004::patchSpeed(), traci::TraCIServer::postProcessSimulationStep(), TraCIServerAPI_Vehicle::processGet(), TraCIServerAPI_Lane::processGet(), MSVehicle::processNextStop(), TraCIServerAPI_Lane::processSet(), MSVehicle::rebuildContinuationsFor(), and MSVehicle::vsafeCriticalCont().

                                    {
        return *myEdge;
    }

const MSVehicle *const MSLane::getFirstVehicle

(

)

const [virtual, inherited]

Definition at line 731 of file MSLane.cpp.

References MSLane::myVehicles.

Referenced by MSLane::getFollowerOnConsecutive(), and MSVehicle::vsafeCriticalCont().

                                  {
    if (myVehicles.size()==0) {
        return 0;
    }
    return *(myVehicles.end()-1);
}

std::pair< MSVehicle *const, SUMOReal > MSLane::getFollowerOnConsecutive	(	SUMOReal	dist,
		SUMOReal	seen,
		SUMOReal	leaderSpeed,
		SUMOReal	backOffset
	)			const [inherited]

Definition at line 907 of file MSLane.cpp.

References MSVehicle::getCarFollowModel(), MSLane::getFirstVehicle(), MSLane::getIncomingLanes(), MSVehicle::getLane(), MSLane::getMaxSpeed(), MSVehicle::getPositionOnLane(), MSVehicle::getSpeed(), MSCFModel::hasSafeGap(), MSLane::IncomingLaneInfo::lane, MSLane::IncomingLaneInfo::length, MSLink::LINKSTATE_TL_RED, MSCFModel::maxNextSpeed(), MSLane::myIncomingLanes, SUMOReal, and MSLane::IncomingLaneInfo::viaLink.

Referenced by MSLane::isEmissionSuccess().

                                                                                                              {
    // ok, a vehicle has not noticed the lane about itself;
    //  iterate as long as necessary to search for an approaching one
    std::set<MSLane*> visited;
    std::vector<std::pair<MSVehicle *, SUMOReal> > possible;
    std::vector<MSLane::IncomingLaneInfo> newFound;
    std::vector<MSLane::IncomingLaneInfo> toExamine = myIncomingLanes;
    while (toExamine.size()!=0) {
        for (std::vector<MSLane::IncomingLaneInfo>::iterator i=toExamine.begin(); i!=toExamine.end(); ++i) {
            if ((*i).viaLink->getState()==MSLink::LINKSTATE_TL_RED) {
                continue;
            }
            MSLane *next = (*i).lane;
            if (next->getFirstVehicle()!=0) {
                MSVehicle * v = (MSVehicle*) next->getFirstVehicle();
                SUMOReal agap = (*i).length - v->getPositionOnLane() + backOffset;
                if (!v->getCarFollowModel().hasSafeGap(v->getCarFollowModel().maxNextSpeed(v->getSpeed()), agap, leaderSpeed, v->getLane().getMaxSpeed())) {
                    possible.push_back(std::make_pair(v, (*i).length-v->getPositionOnLane()+seen));
                }
            } else {
                if ((*i).length+seen<dist) {
                    const std::vector<MSLane::IncomingLaneInfo> &followers = next->getIncomingLanes();
                    for (std::vector<MSLane::IncomingLaneInfo>::const_iterator j=followers.begin(); j!=followers.end(); ++j) {
                        if (visited.find((*j).lane)==visited.end()) {
                            visited.insert((*j).lane);
                            MSLane::IncomingLaneInfo ili;
                            ili.lane = (*j).lane;
                            ili.length = (*j).length + (*i).length;
                            ili.viaLink = (*j).viaLink;
                            newFound.push_back(ili);
                        }
                    }
                }
            }
        }
        toExamine.clear();
        swap(newFound, toExamine);
    }
    if (possible.size()==0) {
        return std::pair<MSVehicle * const, SUMOReal>(0, -1);
    }
    sort(possible.begin(), possible.end(), by_second_sorter());
    return *(possible.begin());
}

SUMOReal MSLane::getHarmonoise_NoiseEmissions

(

)

const throw () [inherited]

Returns the sum of last step noise emissions.

Returns:

noise emissions of vehicles on this lane during the last step

Definition at line 1128 of file MSLane.cpp.

References MSLane::getVehiclesSecure(), MSLane::releaseVehicles(), HelpersHarmonoise::sum(), and SUMOReal.

Referenced by GUILaneWrapper::Colorer::getColorValue(), and TraCIServerAPI_Lane::processGet().

                                                   {
    SUMOReal ret = 0;
    const MSLane::VehCont &vehs = getVehiclesSecure();
    if (vehs.size()==0) {
        releaseVehicles();
        return 0;
    }
    for (MSLane::VehCont::const_iterator i=vehs.begin(); i!=vehs.end(); ++i) {
        SUMOReal sv = (*i)->getHarmonoise_NoiseEmissions();
        ret += (SUMOReal) pow(10., (sv/10.));
    }
    releaseVehicles();
    return HelpersHarmonoise::sum(ret);
}

SUMOReal MSLane::getHBEFA_CO2Emissions

(

)

const throw () [inherited]

Returns the sum of last step CO2 emissions.

Returns:

CO2 emissions of vehicles on this lane during the last step

Definition at line 1056 of file MSLane.cpp.

References MSLane::getVehiclesSecure(), MSLane::releaseVehicles(), and SUMOReal.

Referenced by GUILaneWrapper::getNormedHBEFA_CO2Emissions(), and TraCIServerAPI_Lane::processGet().

                                            {
    SUMOReal ret = 0;
    const MSLane::VehCont &vehs = getVehiclesSecure();
    for (MSLane::VehCont::const_iterator i=vehs.begin(); i!=vehs.end(); ++i) {
        ret += (*i)->getHBEFA_CO2Emissions();
    }
    releaseVehicles();
    return ret;
}

SUMOReal MSLane::getHBEFA_COEmissions

(

)

const throw () [inherited]

Returns the sum of last step CO emissions.

Returns:

CO emissions of vehicles on this lane during the last step

Definition at line 1068 of file MSLane.cpp.

References MSLane::getVehiclesSecure(), MSLane::releaseVehicles(), and SUMOReal.

Referenced by GUILaneWrapper::getNormedHBEFA_COEmissions(), and TraCIServerAPI_Lane::processGet().

                                           {
    SUMOReal ret = 0;
    const MSLane::VehCont &vehs = getVehiclesSecure();
    for (MSLane::VehCont::const_iterator i=vehs.begin(); i!=vehs.end(); ++i) {
        ret += (*i)->getHBEFA_COEmissions();
    }
    releaseVehicles();
    return ret;
}

SUMOReal MSLane::getHBEFA_FuelConsumption

(

)

const throw () [inherited]

Returns the sum of last step fuel consumption.

Returns:

fuel consumption of vehicles on this lane during the last step

Definition at line 1116 of file MSLane.cpp.

References MSLane::getVehiclesSecure(), MSLane::releaseVehicles(), and SUMOReal.

Referenced by GUILaneWrapper::getNormedHBEFA_FuelConsumption(), and TraCIServerAPI_Lane::processGet().

                                               {
    SUMOReal ret = 0;
    const MSLane::VehCont &vehs = getVehiclesSecure();
    for (MSLane::VehCont::const_iterator i=vehs.begin(); i!=vehs.end(); ++i) {
        ret += (*i)->getHBEFA_FuelConsumption();
    }
    releaseVehicles();
    return ret;
}

SUMOReal MSLane::getHBEFA_HCEmissions

(

)

const throw () [inherited]

Returns the sum of last step HC emissions.

Returns:

HC emissions of vehicles on this lane during the last step

Definition at line 1104 of file MSLane.cpp.

References MSLane::getVehiclesSecure(), MSLane::releaseVehicles(), and SUMOReal.

Referenced by GUILaneWrapper::getNormedHBEFA_HCEmissions(), and TraCIServerAPI_Lane::processGet().

                                           {
    SUMOReal ret = 0;
    const MSLane::VehCont &vehs = getVehiclesSecure();
    for (MSLane::VehCont::const_iterator i=vehs.begin(); i!=vehs.end(); ++i) {
        ret += (*i)->getHBEFA_HCEmissions();
    }
    releaseVehicles();
    return ret;
}

SUMOReal MSLane::getHBEFA_NOxEmissions

(

)

const throw () [inherited]

Returns the sum of last step NOx emissions.

Returns:

NOx emissions of vehicles on this lane during the last step

Definition at line 1092 of file MSLane.cpp.

References MSLane::getVehiclesSecure(), MSLane::releaseVehicles(), and SUMOReal.

Referenced by GUILaneWrapper::getNormedHBEFA_NOxEmissions(), and TraCIServerAPI_Lane::processGet().

                                            {
    SUMOReal ret = 0;
    const MSLane::VehCont &vehs = getVehiclesSecure();
    for (MSLane::VehCont::const_iterator i=vehs.begin(); i!=vehs.end(); ++i) {
        ret += (*i)->getHBEFA_NOxEmissions();
    }
    releaseVehicles();
    return ret;
}

SUMOReal MSLane::getHBEFA_PMxEmissions

(

)

const throw () [inherited]

Returns the sum of last step PMx emissions.

Returns:

PMx emissions of vehicles on this lane during the last step

Definition at line 1080 of file MSLane.cpp.

References MSLane::getVehiclesSecure(), MSLane::releaseVehicles(), and SUMOReal.

Referenced by GUILaneWrapper::getNormedHBEFA_PMxEmissions(), and TraCIServerAPI_Lane::processGet().

                                            {
    SUMOReal ret = 0;
    const MSLane::VehCont &vehs = getVehiclesSecure();
    for (MSLane::VehCont::const_iterator i=vehs.begin(); i!=vehs.end(); ++i) {
        ret += (*i)->getHBEFA_PMxEmissions();
    }
    releaseVehicles();
    return ret;
}

const std::string& MSLane::getID

(

)

const throw () [inline, inherited]

Returns this lane's id.

Returns:

This lane's id

Definition at line 298 of file MSLane.h.

References MSLane::myID.

Referenced by MSVehicle::addTraciStop(), traci::TraCIServer::commandStopNode(), NLDetectorBuilder::convUncontE2PosLength(), MSLane::detectCollisions(), MSVTypeProbe::execute(), Command_SaveTLSSwitches::execute(), GUILaneWrapper::getMicrosimID(), GUIInductLoop::MyWrapper::getParameterWindow(), GUI_E2_ZS_Collector::MyWrapper::getParameterWindow(), MSUnboundActuatedTrafficLightLogic::init(), MSAgentbasedTrafficLightLogic::init(), MSActuatedTrafficLightLogic::init(), MSLane::moveCritical(), MSCalibrator::MSCalibrator(), MSRouteHandler::myStartElement(), TraCIServerAPI_Vehicle::processGet(), TraCIServerAPI_TLS::processGet(), TraCIServerAPI_Lane::processGet(), MSVehicleControl::scheduleVehicleRemoval(), MSLane::setCritical(), and MSMeanData::writeEdge().

                                           {
        return myID;
    }

const std::vector<IncomingLaneInfo>& MSLane::getIncomingLanes

(

)

const [inline, inherited]

Definition at line 488 of file MSLane.h.

References MSLane::myIncomingLanes.

Referenced by MSVehicle::enterLaneAtEmit(), MSVehicle::enterLaneAtLaneChange(), and MSLane::getFollowerOnConsecutive().

                                                                {
        return myIncomingLanes;
    }

MSVehicle *const MSLane::getLastVehicle

(

)

const [virtual, inherited]

returns the last vehicle

Definition at line 722 of file MSLane.cpp.

References MSLane::myVehicles.

Referenced by MSVehicle::checkRewindLinkLanes(), MSLane::getLeaderOnConsecutive(), MSLaneChanger::getRealThisLeader(), and MSLane::isEmissionSuccess().

                                 {
    if (myVehicles.size()==0) {
        return 0;
    }
    return *myVehicles.begin();
}

std::pair< MSVehicle *, SUMOReal > MSLane::getLastVehicleInformation

(

)

const throw () [inherited]

Returns the last vehicle which is still on the lane.

The information about the last vehicle in this lane's que is returned. If there is no such vehicle, the information about the vehicle which laps into this lane is returned. If there is no such vehicle, the first returned member is 0.

Returns:

Information about the last vehicle and it's back position

Definition at line 448 of file MSLane.cpp.

References MSVehicleType::getLength(), MSVehicle::getPositionOnLane(), MSVehicle::getVehicleType(), MAX2(), MSLane::myInlappingVehicle, MSLane::myInlappingVehicleEnd, MSLane::myVehicles, and SUMOReal.

Referenced by MSVehicle::vsafeCriticalCont().

                                                {
    if (myVehicles.size()!=0) {
        // the last vehicle is the one in scheduled by this lane
        MSVehicle *last = *myVehicles.begin();
        SUMOReal pos = MAX2(SUMOReal(0), last->getPositionOnLane()-last->getVehicleType().getLength());
        return std::make_pair(last, pos);
    }
    if (myInlappingVehicle!=0) {
        // the last one is a vehicle extending into this lane
        return std::make_pair(myInlappingVehicle, myInlappingVehicleEnd);
    }
    return std::make_pair<MSVehicle*, SUMOReal>(0, 0);
}

std::pair< MSVehicle *const, SUMOReal > MSLane::getLeaderOnConsecutive	(	SUMOReal	dist,
		SUMOReal	seen,
		SUMOReal	leaderSpeed,
		const MSVehicle &	veh,
		const std::vector< MSLane * > &	bestLaneConts
	)			const [inherited]

Definition at line 954 of file MSLane.cpp.

References MSCFModel::brakeGap(), MSVehicle::getCarFollowModel(), MSLane::getLastVehicle(), MSLane::getLength(), MSLane::getMaxSpeed(), MSLane::getPartialOccupator(), MSLane::getPartialOccupatorEnd(), MSVehicle::getPositionOnLane(), MSLane::isLinkEnd(), MSLink::LINKSTATE_TL_RED, and MSLane::succLinkSec().

                                                                              {
    if (seen>dist) {
        return std::pair<MSVehicle * const, SUMOReal>(0, -1);
    }
    unsigned int view = 1;
    // loop over following lanes
    const MSLane * targetLane = this;
    MSVehicle *leader = targetLane->getPartialOccupator();
    if (leader!=0) {
        return std::pair<MSVehicle * const, SUMOReal>(leader, seen-targetLane->getPartialOccupatorEnd());
    }
    const MSLane * nextLane = targetLane;
    while (true) {
        // get the next link used
        MSLinkCont::const_iterator link = targetLane->succLinkSec(veh, view, *nextLane, bestLaneConts);
        if (nextLane->isLinkEnd(link) || !(*link)->havePriority() || (*link)->getState()==MSLink::LINKSTATE_TL_RED) {
            return std::pair<MSVehicle * const, SUMOReal>(0, -1);
        }
#ifdef HAVE_INTERNAL_LANES
        bool nextInternal = false;
        nextLane = (*link)->getViaLane();
        if (nextLane==0) {
            nextLane = (*link)->getLane();
        } else {
            nextInternal = true;
        }
#else
        nextLane = (*link)->getLane();
#endif
        if (nextLane==0) {
            return std::pair<MSVehicle * const, SUMOReal>(0, -1);
        }
        MSVehicle * leader = nextLane->getLastVehicle();
        if (leader!=0) {
            return std::pair<MSVehicle * const, SUMOReal>(leader, seen+leader->getPositionOnLane()-leader->getVehicleType().getLength());
        } else {
            leader = nextLane->getPartialOccupator();
            if (leader!=0) {
                return std::pair<MSVehicle * const, SUMOReal>(leader, seen+nextLane->getPartialOccupatorEnd());
            }
        }
        if (nextLane->getMaxSpeed()<speed) {
            dist = veh.getCarFollowModel().brakeGap(nextLane->getMaxSpeed());
        }
        seen += nextLane->getLength();
        if (seen>dist) {
            return std::pair<MSVehicle * const, SUMOReal>(0, -1);
        }
#ifdef HAVE_INTERNAL_LANES
        if (!nextInternal) {
            view++;
        }
#else
        view++;
#endif
    }
}

MSLane *const MSLane::getLeftLane

(

)

const [inherited]

Definition at line 858 of file MSLane.cpp.

References MSEdge::leftLane(), and MSLane::myEdge.

                              {
    return myEdge->leftLane(this);
}

SUMOReal MSLane::getLength

(

)

const throw () [inline, inherited]

Returns the lane's length.

Returns:

This lane's length

Definition at line 330 of file MSLane.h.

References MSLane::myLength.

Referenced by MSVehicle::adaptLaneEntering2MoveReminder(), MSLane::addIncomingLane(), NLSucceedingLaneBuilder::addSuccLane(), NLDetectorBuilder::buildInductLoop(), MSVehicleTransfer::checkEmissions(), MSVehicle::checkRewindLinkLanes(), NLDetectorBuilder::convUncontE2PosLength(), MSLane::emit(), MS_E2_ZS_CollectorOverLanes::extendTo(), MSLane::freeEmit(), MSVehicle::getBestLanes(), MSVehicle::getDistanceToPosition(), TraCIDijkstraRouter< E >::getEffort(), MSLane::getLeaderOnConsecutive(), getMaxSpeedRegardingNextLanes(), GUILaneWrapper::getNormedHBEFA_CO2Emissions(), GUILaneWrapper::getNormedHBEFA_COEmissions(), GUILaneWrapper::getNormedHBEFA_FuelConsumption(), GUILaneWrapper::getNormedHBEFA_HCEmissions(), GUILaneWrapper::getNormedHBEFA_NOxEmissions(), GUILaneWrapper::getNormedHBEFA_PMxEmissions(), GUILaneWrapper::getParameterWindow(), NLGeomShapeBuilder::getPointPosition(), MSNet::EdgeWeightsProxi::getTravelTime(), MSActuatedTrafficLightLogic::init(), MSLane::isEmissionSuccess(), MSMeanData_Net::MSLaneMeanDataValues::isStillActive(), MSMeanData_HBEFA::MSLaneMeanDataValues::isStillActive(), MSMeanData_Harmonoise::MSLaneMeanDataValues::isStillActive(), MSVehicle::moveFirstChecked(), MSVehicle::moveRegardingCritical(), NLTriggerBuilder::parseAndBuildBusStop(), TraCIServerAPI_Lane::processGet(), MSVehicle::rebuildContinuationsFor(), MSVehicleControl::scheduleVehicleRemoval(), GUIVehicle::setBlinkerInformation(), MSLane::setCritical(), MSVehicle::vsafeCriticalCont(), MSLCM_DK2004::wantsChangeToLeft(), MSLCM_DK2004::wantsChangeToRight(), and MSMeanData::writeEdge().

                                       {
        return myLength;
    }

const MSLinkCont & MSLane::getLinkCont

(

)

const [inherited]

returns the container with all links !!!

Definition at line 806 of file MSLane.cpp.

References MSLane::myLinks.

Referenced by MSLinkContHelper::getConnectingLink(), GUILaneWrapper::getLinkDirection(), GUILaneWrapper::getLinkLane(), GUILaneWrapper::getLinkNumber(), GUILaneWrapper::getLinkRespondIndex(), GUILaneWrapper::getLinkState(), GUILaneWrapper::getLinkTLID(), GUILaneWrapper::getLinkTLIndex(), TraCIServerAPI_Lane::processGet(), MSVehicle::rebuildContinuationsFor(), GUIVehicle::setBlinkerInformation(), and MSVehicle::vsafeCriticalCont().

                          {
    return myLinks;
}

SUMOReal MSLane::getMaxSpeed

(

)

const throw () [inline, inherited]

Returns the lane's maximum speed.

Returns:

This lane's maximum speed

Definition at line 322 of file MSLane.h.

References MSLane::myMaxSpeed.

Referenced by MSVehicleTransfer::checkEmissions(), MSEmitter::childCheckEmit(), MSCalibrator::childCheckEmit(), traci::TraCIServer::commandAddVehicle(), MSAbstractLaneChangeModel::congested(), MSCFModel_IDM::desiredSpeed(), MSLane::emit(), GUILaneWrapper::Colorer::getColorValue(), TraCIDijkstraRouter< E >::getEffort(), MSLane::getFollowerOnConsecutive(), MSLane::getLeaderOnConsecutive(), getMaxSpeedRegardingNextLanes(), GUILaneWrapper::getParameterWindow(), MSNet::EdgeWeightsProxi::getTravelTime(), traci::TraCIServer::handleVehicleDomain(), MSLCM_DK2004::informBlocker(), MSActuatedTrafficLightLogic::init(), MSLane::isEmissionSuccess(), MSVehicle::moveRegardingCritical(), TraCIServerAPI_Lane::processGet(), GUIVehicle::setBlinkerInformation(), MSLaneChanger::setIsSafeChange(), MSVehicle::vsafeCriticalCont(), MSLCM_DK2004::wantsChangeToLeft(), and MSLCM_DK2004::wantsChangeToRight().

                                         {
        return myMaxSpeed;
    }

SUMOReal MSLane::getMeanSpeed

(

)

const throw () [inherited]

Returns the mean speed on this lane.

Returns:

The average speed of vehicles during the last step; default speed if no vehicle was on this lane

Definition at line 1040 of file MSLane.cpp.

References MSLane::getVehiclesSecure(), MSLane::myMaxSpeed, MSLane::myVehicles, MSLane::releaseVehicles(), and SUMOReal.

Referenced by TraCIServerAPI_Lane::processGet().

                                   {
    if (myVehicles.size()==0) {
        return myMaxSpeed;
    }
    SUMOReal v = 0;
    const MSLane::VehCont &vehs = getVehiclesSecure();
    for (VehCont::const_iterator i=vehs.begin(); i!=vehs.end(); ++i) {
        v += (*i)->getSpeed();
    }
    SUMOReal ret = v / (SUMOReal) myVehicles.size();
    releaseVehicles();
    return ret;
}

const MoveReminderCont& MSLane::getMoveReminders

(

)

const throw () [inline, inherited]

Return the list of this lane's move reminders.

Returns:

Previously added move reminder

Definition at line 148 of file MSLane.h.

References MSLane::myMoveReminders.

Referenced by MSVehicle::enterLaneAtEmit(), and MSVehicle::enterLaneAtLaneChange().

                                                                    {
        return myMoveReminders;
    }

const std::vector<SUMOVehicleClass>& MSLane::getNotAllowedClasses

(

)

const throw () [inline, inherited]

Returns vehicle classes explicitely disallowed on this lane.

Returns:

This lane's disallowed vehicle classes

Definition at line 346 of file MSLane.h.

References MSLane::myNotAllowedClasses.

Referenced by GUILaneWrapper::Colorer::getColorValue(), and TraCIServerAPI_Lane::processGet().

                                                                            {
        return myNotAllowedClasses;
    }

size_t MSLane::getNumericalID

(

)

const throw () [inline, inherited]

Returns this lane's numerical id.

Returns:

This lane's numerical id

Definition at line 306 of file MSLane.h.

References MSLane::myNumericalID.

                                          {
        return myNumericalID;
    }

SUMOReal MSLane::getOccupancy

(

)

const throw () [inherited]

Returns the occupancy of this lane during the last step.

Returns:

The occupancy during the last step

Definition at line 1028 of file MSLane.cpp.

References MSLane::myLength, and MSLane::myVehicleLengthSum.

Referenced by GUILaneWrapper::Colorer::getColorValue(), and TraCIServerAPI_Lane::processGet().

                                   {
    return myVehicleLengthSum / myLength;
}

MSVehicle* MSLane::getPartialOccupator

(

)

const throw () [inline, inherited]

Returns the vehicle which laps into this lane.

Returns:

The vehicle which laps into this lane, 0 if there is no such

Definition at line 237 of file MSLane.h.

References MSLane::myInlappingVehicle.

Referenced by MSLane::freeEmit(), MSLane::getLeaderOnConsecutive(), MSLaneChanger::getRealLeader(), MSLaneChanger::getRealThisLeader(), MSLane::isEmissionSuccess(), and MSVehicle::moveRegardingCritical().

                                                   {
        return myInlappingVehicle;
    }

SUMOReal MSLane::getPartialOccupatorEnd

(

)

const throw () [inline, inherited]

Returns the position of the in-lapping vehicle's end.

Returns:

Information about how far the vehicle laps into this lane

Definition at line 245 of file MSLane.h.

References MSLane::myInlappingVehicleEnd.

Referenced by MSLane::freeEmit(), MSLane::getLeaderOnConsecutive(), MSLaneChanger::getRealLeader(), MSLaneChanger::getRealThisLeader(), MSLane::isEmissionSuccess(), and MSVehicle::moveRegardingCritical().

                                                    {
        return myInlappingVehicleEnd;
    }

MSLane *const MSLane::getRightLane

(

)

const [inherited]

Definition at line 864 of file MSLane.cpp.

References MSLane::myEdge, and MSEdge::rightLane().

Referenced by MSVehicle::checkForLaneChanges(), traci::TraCIServer::convertCartesianToRoadMap(), traci::TraCIServer::handleVehicleDomain(), and traci::TraCIServer::postProcessSimulationStep().

                               {
    return myEdge->rightLane(this);
}

const Position2DVector& MSLane::getShape

(

)

const throw () [inline, inherited]

Returns this lane's shape.

Returns:

This lane's shape

Definition at line 314 of file MSLane.h.

References MSLane::myShape.

Referenced by NLSucceedingLaneBuilder::addSuccLane(), GUIE3Collector::MyWrapper::buildDefinition(), GUIVehicle::drawGL(), NLGeomShapeBuilder::getPointPosition(), MSVehicle::getPosition(), TraCIServerAPI_Vehicle::processGet(), TraCIServerAPI_Lane::processGet(), and ROWdrawAction_drawLane2LaneConnections().

                                                     {
        return myShape;
    }

unsigned int MSLane::getVehicleNumber

(

)

const throw () [inline, inherited]

Returns the number of vehicles on this lane.

Returns:

The number of vehicles on this lane

Definition at line 269 of file MSLane.h.

References MSLane::myVehicles.

Referenced by MSVehicle::checkRewindLinkLanes(), MSCalibrator::execute(), MSEdge::getFreeLane(), and TraCIServerAPI_Lane::processGet().

                                                  {
        return (unsigned int) myVehicles.size();
    }

const MSLane::VehCont & GUIInternalLane::getVehiclesSecure

(

)

const throw () [virtual]

Returns the vehicles container; locks it for microsimulation.

Locks "myLock" preventing usage by microsimulation.

Please note that it is necessary to release the vehicles container afterwards using "releaseVehicles".

Returns:

The vehicles on this lane

See also:

MSLane::getVehiclesSecure

Reimplemented from MSLane.

Definition at line 81 of file GUIInternalLane.cpp.

References MFXMutex::lock(), myLock, and MSLane::myVehicles.

                                                 {
    myLock.lock();
    return myVehicles;
}

SUMOReal MSLane::getVehLenSum

(

)

const throw () [inherited]

Returns the sum of lengths of vehicles which were on the lane during the last step.

Returns:

The sum of vehicle lengths of vehicles in the last step

Definition at line 1034 of file MSLane.cpp.

References MSLane::myVehicleLengthSum.

Referenced by MSVehicle::checkRewindLinkLanes(), MSVehicle::getBestLanes(), and MSVehicle::rebuildContinuationsFor().

                                   {
    return myVehicleLengthSum;
}

void MSLane::init	(	MSEdgeControl &	,
		std::vector< MSLane * >::const_iterator	firstNeigh,
		std::vector< MSLane * >::const_iterator	lastNeigh
	)			[inherited]

Definition at line 827 of file MSLane.cpp.

References MSLane::myFirstNeigh, and MSLane::myLastNeigh.

                                                                                                                     {
    myFirstNeigh = firstNeigh;
    myLastNeigh = lastNeigh;
}

void MSLane::initialize

(

MSLinkCont *

succs

)

[inherited]

Delayed initialization.

Not all lane-members are known at the time the lane is born, above all the pointers to other lanes, so we have to initialize later.

Parameters:

[in]

succs

The list of (outgoing) links

Todo:

Why are succs not const?

Definition at line 90 of file MSLane.cpp.

References MSLane::myLinks.

Referenced by NLSucceedingLaneBuilder::closeSuccLane().

                                    {
    myLinks = *links;
    delete links;
}

void MSLane::insertIDs

(

std::vector< std::string > &

into

)

throw () [static, inherited]

Definition at line 645 of file MSLane.cpp.

References MSLane::myDict.

Referenced by TraCIServerAPI_Lane::processGet().

                                                    {
    for (DictType::iterator i=myDict.begin(); i!=myDict.end(); ++i) {
        into.push_back((*i).first);
    }
}

bool GUIInternalLane::integrateNewVehicle

(

SUMOTime

t

)

[virtual]

the same as in MSLane, but locks the access for the visualisation first; the access will be granted at the end of this method

Reimplemented from MSLane.

Definition at line 180 of file GUIInternalLane.cpp.

References MSLane::integrateNewVehicle(), MFXMutex::lock(), myLock, and MFXMutex::unlock().

                                               {
    myLock.lock();
    try {
        bool ret = MSLane::integrateNewVehicle(t);
        myLock.unlock();
        return ret;
    } catch (ProcessError &) {
        myLock.unlock();
        throw;
    }
}

bool GUIInternalLane::isEmissionSuccess	(	MSVehicle *	vehicle,
		SUMOReal	speed,
		SUMOReal	pos,
		bool	recheckNextLanes
	)			throw (ProcessError) [virtual]

Tries to emit the given vehicle with the given state (speed and pos).

Locks the lock, calls MSLane::isEmissionSuccess keeping the result, unlocks the lock and returns the result.

Parameters:

[in]	vehicle	The vehicle to emit
[in]	speed	The speed with which it shall be emitted
[in]	pos	The position at which it shall be emitted
[in]	recheckNextLanes	Forces patching the speed for not being too fast on next lanes

Returns:

Whether the vehicle could be emitted

See also:

MSLane::isEmissionSuccess

Reimplemented from MSLane.

Definition at line 70 of file GUIInternalLane.cpp.

References MSLane::isEmissionSuccess(), MFXMutex::lock(), myLock, and MFXMutex::unlock().

                                                                              {
    myLock.lock();
    bool ret = MSInternalLane::isEmissionSuccess(aVehicle, speed, pos, recheckNextLanes);
    myLock.unlock();
    return ret;
}

bool MSLane::isLinkEnd

(

MSLinkCont::iterator &

i

)

[inherited]

Returns the information whether the given link shows at the end of the list of links (is not valid)

Definition at line 716 of file MSLane.cpp.

References MSLane::myLinks.

                                       {
    return i==myLinks.end();
}

bool MSLane::isLinkEnd

(

MSLinkCont::const_iterator &

i

)

const [inherited]

Returns the information whether the given link shows at the end of the list of links (is not valid)

Definition at line 710 of file MSLane.cpp.

References MSLane::myLinks.

Referenced by MSLane::getLeaderOnConsecutive(), MSLaneChanger::getRealThisLeader(), MSLane::isEmissionSuccess(), and MSVehicle::vsafeCriticalCont().

                                                   {
    return i==myLinks.end();
}

void MSLane::leftByLaneChange

(

MSVehicle *

v

)

[inherited]

Definition at line 1015 of file MSLane.cpp.

References MSVehicleType::getLength(), MSVehicle::getVehicleType(), and MSLane::myVehicleLengthSum.

                                     {
    myVehicleLengthSum -= v->getVehicleType().getLength();
}

bool GUIInternalLane::moveCritical

(

SUMOTime

t

)

[virtual]

the same as in MSLane, but locks the access for the visualisation first; the access will be granted at the end of this method

Reimplemented from MSInternalLane.

Definition at line 94 of file GUIInternalLane.cpp.

References MFXMutex::lock(), MSInternalLane::moveCritical(), myLock, and MFXMutex::unlock().

                                        {
    myLock.lock();
    try {
        bool ret = MSInternalLane::moveCritical(t);
        myLock.unlock();
        return ret;
    } catch (ProcessError &) {
        myLock.unlock();
        throw;
    }
}

MSVehicle * GUIInternalLane::pop

(

SUMOTime

t

)

[protected, virtual]

Returns the first/front vehicle of the lane and removing it from the lane.

Reimplemented from MSLane.

Definition at line 213 of file GUIInternalLane.cpp.

References MFXMutex::lock(), myLock, MSLane::pop(), and MFXMutex::unlock().

                               {
    myLock.lock();
    try {
        MSVehicle *ret = MSLane::pop(t);
        myLock.unlock();
        return ret;
    } catch (ProcessError &) {
        myLock.unlock();
        throw;
    }
}

bool GUIInternalLane::push

(

MSVehicle *

veh

)

[protected, virtual]

the same as in MSLane, but locks the access for the visualisation first; the access will be granted at the end of this method

Reimplemented from MSLane.

Definition at line 122 of file GUIInternalLane.cpp.

References MFXMutex::lock(), myLock, MSLane::push(), and MFXMutex::unlock().

                                    {
    // Insert vehicle only if it's destination isn't reached.
    //  and it does not collide with previous
    // check whether the vehicle has ended his route
    myLock.lock();
    try {
        MSLane::push(veh);
        myLock.unlock();
        return false;
    } catch (ProcessError &) {
        myLock.unlock();
        throw;
    }
}

void GUIInternalLane::releaseVehicles

(

)

const throw () [virtual]

Allows to use the container for microsimulation again.

Unlocks "myLock" preventing usage by microsimulation.

See also:

MSLane::releaseVehicles

Reimplemented from MSLane.

Definition at line 88 of file GUIInternalLane.cpp.

References myLock, and MFXMutex::unlock().

                                               {
    myLock.unlock();
}

MSVehicle * GUIInternalLane::removeFirstVehicle

(

)

[virtual]

Reimplemented from MSLane.

Definition at line 139 of file GUIInternalLane.cpp.

References MFXMutex::lock(), myLock, MSLane::removeFirstVehicle(), and MFXMutex::unlock().

                                    {
    myLock.lock();
    try {
        MSVehicle *ret = MSLane::removeFirstVehicle();
        myLock.unlock();
        return ret;
    } catch (ProcessError &) {
        myLock.unlock();
        throw;
    }
}

MSVehicle * GUIInternalLane::removeVehicle

(

MSVehicle *

remVehicle

)

[virtual]

Reimplemented from MSLane.

Definition at line 153 of file GUIInternalLane.cpp.

References MFXMutex::lock(), myLock, MSLane::removeVehicle(), and MFXMutex::unlock().

                                                     {
    myLock.lock();
    try {
        MSVehicle *ret = MSLane::removeVehicle(remVehicle);
        myLock.unlock();
        return ret;
    } catch (ProcessError &) {
        myLock.unlock();
        throw;
    }
}

void MSLane::resetPartialOccupation

(

MSVehicle *

v

)

throw () [inherited]

Removes the information about a vehicle lapping into this lane.

Parameters:

[in]

v

The vehicle which laps into this lane

Definition at line 439 of file MSLane.cpp.

References MSLane::myInlappingVehicle, and MSLane::myInlappingVehicleEnd.

Referenced by MSVehicle::moveFirstChecked().

                                                   {
    if (v==myInlappingVehicle) {
        myInlappingVehicleEnd = 10000;
    }
    myInlappingVehicle = 0;
}

void MSLane::setAllowedClasses

(

const std::vector< SUMOVehicleClass > &

classes

)

throw () [inline, inherited]

Definition at line 468 of file MSLane.h.

References MSLane::myAllowedClasses.

Referenced by TraCIServerAPI_Lane::processSet().

                                                                               {
        myAllowedClasses = classes;
    }

bool GUIInternalLane::setCritical	(	SUMOTime	t,
		std::vector< MSLane * > &	into
	)			[virtual]

the same as in MSLane, but locks the access for the visualisation first; the access will be granted at the end of this method

Reimplemented from MSLane.

Definition at line 108 of file GUIInternalLane.cpp.

References MFXMutex::lock(), myLock, MSLane::setCritical(), and MFXMutex::unlock().

                                                                 {
    myLock.lock();
    try {
        bool ret = MSInternalLane::setCritical(t, into);
        myLock.unlock();
        return ret;
    } catch (ProcessError &) {
        myLock.unlock();
        throw;
    }
}

void MSLane::setLength

(

SUMOReal

val

)

throw () [inline, inherited]

Definition at line 391 of file MSLane.h.

References MSLane::myLength.

Referenced by TraCIServerAPI_Lane::processSet().

                                         {
        myLength = val;
    }

void MSLane::setMaxSpeed

(

SUMOReal

val

)

throw () [inline, inherited]

Definition at line 387 of file MSLane.h.

References MSLane::myMaxSpeed.

Referenced by TraCIServerAPI_Lane::processSet().

                                           {
        myMaxSpeed = val;
    }

void MSLane::setNotAllowedClasses

(

const std::vector< SUMOVehicleClass > &

classes

)

throw () [inline, inherited]

Definition at line 473 of file MSLane.h.

References MSLane::myNotAllowedClasses.

Referenced by TraCIServerAPI_Lane::processSet().

                                                                                  {
        myNotAllowedClasses = classes;
    }

void MSInternalLane::setParentJunctionInformation	(	MSLogicJunction::InnerState *const	foescont,
		unsigned int	foesIdx
	)			throw () [inherited]

Sets the information where to report vehicles being on this lane to.

In addition to a lane's normal initialization (MSLane::initialize), an internal lane needs to know which junction has to be informed about a vehicle being on the internal lane. This information is set herein.

Parameters:

[in]	foescont	The junction inner state to set information about vehicles into
[in]	foesIdx	This lane's index within this state

Definition at line 70 of file MSInternalLane.cpp.

References MSInternalLane::myFoesCont, and MSInternalLane::myFoesIndex.

                                      {
    myFoesCont = foescont;
    myFoesIndex = (int) foesIdx;
}

SUMOReal MSLane::setPartialOccupation	(	MSVehicle *	v,
		SUMOReal	leftVehicleLength
	)			throw () [inherited]

Sets the information about a vehicle lapping into this lane.

The given left length of vehicle which laps into this lane is used to determine the vehicle's end position in regard to this lane's length. This information is set into myInlappingVehicleState; additionally, the vehicle pointer is stored in myInlappingVehicle; Returns this lane's length for subtracting it from the left vehicle length.

Parameters:

[in]	v	The vehicle which laps into this lane
[in]	leftVehicleLength	The distance the vehicle laps into this lane

Returns:

This lane's length

Definition at line 427 of file MSLane.cpp.

References MSLane::myInlappingVehicle, MSLane::myInlappingVehicleEnd, and MSLane::myLength.

                                                                             {
    myInlappingVehicle = v;
    if (leftVehicleLength>myLength) {
        myInlappingVehicleEnd = 0;
    } else {
        myInlappingVehicleEnd = myLength-leftVehicleLength;
    }
    return myLength;
}

void MSInternalLane::setPassPosition

(

SUMOReal

passPos

)

throw () [inherited]

Sets the position that must be free so that vehicles can pass.

Todo:

!!! incomplete usage; check

Definition at line 78 of file MSInternalLane.cpp.

References MSInternalLane::myPassPosition.

                                                        {
    myPassPosition = passPos;
}

MSLinkCont::const_iterator MSLane::succLinkSec	(	const SUMOVehicle &	veh,
		unsigned int	nRouteSuccs,
		const MSLane &	succLinkSource,
		const std::vector< MSLane * > &	conts
	)			const [virtual, inherited]

Same as succLink, but does not throw any assertions when the succeeding link could not be found; Returns the myLinks.end() instead; Further, the number of edges to look forward may be given

Definition at line 740 of file MSLane.cpp.

References MSEdge::allowedLanes(), MSVehicleType::getVehicleClass(), SUMOVehicle::getVehicleType(), MSLane::myLinks, and SUMOVehicle::succEdge().

Referenced by MSLane::appropriate(), MSLane::getLeaderOnConsecutive(), MSLaneChanger::getRealThisLeader(), MSLane::isEmissionSuccess(), GUIVehicle::setBlinkerInformation(), and MSVehicle::vsafeCriticalCont().

                                                                                         {
    const MSEdge* nRouteEdge = veh.succEdge(nRouteSuccs);
    // check whether the vehicle tried to look beyond its route
    if (nRouteEdge==0) {
        // return end (no succeeding link) if so
        return succLinkSource.myLinks.end();
    }
    // a link may be used if
    //  1) there is a destination lane ((*link)->getLane()!=0)
    //  2) the destination lane belongs to the next edge in route ((*link)->getLane()->myEdge == nRouteEdge)
    //  3) the destination lane allows the vehicle's class ((*link)->getLane()->allowsVehicleClass(veh.getVehicleClass()))

    // at first, we'll assume we have the continuations of our route in "conts" (built in "getBestLanes")
    //  "conts" stores the best continuations of our current lane
    MSLinkCont::const_iterator link;
    if (nRouteSuccs>0&&conts.size()>=nRouteSuccs&&nRouteSuccs>0) {
        // we go through the links in our list and return the matching one
        for (link=succLinkSource.myLinks.begin(); link!=succLinkSource.myLinks.end() ; ++link) {
            if ((*link)->getLane()!=0 && (*link)->getLane()->myEdge == nRouteEdge && (*link)->getLane()->allowsVehicleClass(veh.getVehicleType().getVehicleClass())) {
                // we should use the link if it connects us to the best lane
                if ((*link)->getLane()==conts[nRouteSuccs-1]) {
                    return link;
                }
            }
        }
    }

    // ok, we were not able to use the conts for any reason
    //  we will now collect allowed links, at first
    // collect allowed links
    std::vector<MSLinkCont::const_iterator> valid;
    for (link=succLinkSource.myLinks.begin(); link!=succLinkSource.myLinks.end() ; ++link) {
        if ((*link)->getLane()!=0 && (*link)->getLane()->myEdge == nRouteEdge && (*link)->getLane()->allowsVehicleClass(veh.getVehicleType().getVehicleClass())) {
            valid.push_back(link);
        }
    }
    // if no valid link was found...
    if (valid.size()==0) {
        // ... return end (no succeeding link)
        return succLinkSource.myLinks.end();
    }
    // if there is only one valid link, let's use it...
    if (valid.size()==1) {
        return *(valid.begin());
    }
    // if the next edge is the route end, then we may return an arbitary link
    // also, if there is no allowed lane on the edge following the current one (recheck?)
    const MSEdge* nRouteEdge2 = veh.succEdge(nRouteSuccs+1);
    const std::vector<MSLane*> *next_allowed = nRouteEdge->allowedLanes(*nRouteEdge2, veh.getVehicleType().getVehicleClass());
    if (nRouteEdge2==0||next_allowed==0) {
        return *(valid.begin());
    }
    // now let's determine which link is the best
    // in fact, we do not know it, here...
    for (std::vector<MSLinkCont::const_iterator>::iterator i=valid.begin(); i!=valid.end(); ++i) {
        if (find(next_allowed->begin(), next_allowed->end(), (**i)->getLane())!=next_allowed->end()) {
            return *i;
        }
    }
    return *(valid.begin());
}

void GUIInternalLane::swapAfterLaneChange

(

SUMOTime

t

)

[protected, virtual]

moves myTmpVehicles int myVehicles after a lane change procedure

Reimplemented from MSLane.

Definition at line 167 of file GUIInternalLane.cpp.

References MFXMutex::lock(), myLock, MSLane::swapAfterLaneChange(), and MFXMutex::unlock().

                                               {
    myLock.lock();
    try {
        MSLane::swapAfterLaneChange(t);
        myLock.unlock();
    } catch (ProcessError &) {
        myLock.unlock();
        throw;
    }
}

---

Friends And Related Function Documentation

friend class GUILaneWrapper [friend, inherited]

Definition at line 75 of file MSLane.h.

Referenced by GUILane::buildLaneWrapper(), and buildLaneWrapper().

friend class MSLaneChanger [friend, inherited]

needs access to myTmpVehicles (this maybe should be done via SUMOReal-buffering!!!)

Definition at line 73 of file MSLane.h.

friend class MSXMLRawOut [friend, inherited]

Definition at line 77 of file MSLane.h.

---

Field Documentation

std::vector<SUMOVehicleClass> MSLane::myAllowedClasses [protected, inherited]

The list of allowed vehicle classes.

Definition at line 616 of file MSLane.h.

Referenced by MSLane::allowsVehicleClass(), MSLane::getAllowedClasses(), and MSLane::setAllowedClasses().

SUMOReal MSLane::myBackDistance [protected, inherited]

Definition at line 607 of file MSLane.h.

MSLane::DictType MSLane::myDict [static, protected, inherited]

Static dictionary to associate string-ids with objects.

Definition at line 650 of file MSLane.h.

Referenced by MSLane::clear(), MSLane::dictionary(), MSLane::dictSize(), and MSLane::insertIDs().

MSEdge* MSLane::myEdge [protected, inherited]

The lane's edge, for routing only.

Definition at line 597 of file MSLane.h.

Referenced by MSLane::appropriate(), MSLane::getEdge(), MSLane::getLeftLane(), GUILaneWrapper::getPurpose(), MSLane::getRightLane(), and MSLane::push().

std::vector<MSLane*>::const_iterator MSLane::myFirstNeigh [protected, inherited]

The lane left to the described lane (==lastNeigh if none).

Definition at line 634 of file MSLane.h.

Referenced by MSLane::init().

std::string MSLane::myID [protected, inherited]

Unique ID.

Definition at line 579 of file MSLane.h.

Referenced by MSLane::getID().

std::vector<IncomingLaneInfo> MSLane::myIncomingLanes [protected, inherited]

Definition at line 621 of file MSLane.h.

Referenced by MSLane::addIncomingLane(), MSLane::getFollowerOnConsecutive(), and MSLane::getIncomingLanes().

MSVehicle* MSLane::myInlappingVehicle [protected, inherited]

The vehicle which laps into this lane.

Definition at line 630 of file MSLane.h.

Referenced by MSLane::getLastVehicleInformation(), MSLane::getPartialOccupator(), MSLane::resetPartialOccupation(), and MSLane::setPartialOccupation().

SUMOReal MSLane::myInlappingVehicleEnd [protected, inherited]

End position of a vehicle which laps into this lane.

Definition at line 627 of file MSLane.h.

Referenced by MSLane::getLastVehicleInformation(), MSLane::getPartialOccupatorEnd(), MSLane::resetPartialOccupation(), and MSLane::setPartialOccupation().

std::vector<MSLane*>::const_iterator MSLane::myLastNeigh [protected, inherited]

The end of this lane's edge's lane container.

Definition at line 637 of file MSLane.h.

Referenced by MSLane::init().

SUMOReal MSLane::myLeftVehLength [protected, inherited]

Not yet seen vehicle lengths.

Definition at line 640 of file MSLane.h.

Referenced by MSLane::moveCritical().

SUMOReal MSLane::myLength [protected, inherited]

Lane length [m].

Definition at line 594 of file MSLane.h.

Referenced by MSLane::getLength(), MSLane::getOccupancy(), MSLane::moveCritical(), MSLane::setLength(), and MSLane::setPartialOccupation().

MSLinkCont MSLane::myLinks [protected, inherited]

The lane's Links to it's succeeding lanes and the default right-of-way rule, i.e. blocked or not blocked.

Definition at line 644 of file MSLane.h.

Referenced by MSLane::appropriate(), MSLane::getLinkCont(), MSLane::initialize(), MSLane::isLinkEnd(), MSLane::succLinkSec(), and MSLane::~MSLane().

MFXMutex GUIInternalLane::myLock [mutable, private]

The mutex used to avoid concurrent updates of the vehicle buffer.

Definition at line 164 of file GUIInternalLane.h.

Referenced by detectCollisions(), getVehiclesSecure(), integrateNewVehicle(), isEmissionSuccess(), moveCritical(), pop(), push(), releaseVehicles(), removeFirstVehicle(), removeVehicle(), setCritical(), swapAfterLaneChange(), and ~GUIInternalLane().

SUMOReal MSLane::myMaxSpeed [protected, inherited]

Lane-wide speedlimit [m/s].

Definition at line 600 of file MSLane.h.

Referenced by MSLane::getMaxSpeed(), MSLane::getMeanSpeed(), and MSLane::setMaxSpeed().

std::vector<SUMOVehicleClass> MSLane::myNotAllowedClasses [protected, inherited]

The list of disallowed vehicle classes.

Definition at line 619 of file MSLane.h.

Referenced by MSLane::allowsVehicleClass(), MSLane::getNotAllowedClasses(), and MSLane::setNotAllowedClasses().

size_t MSLane::myNumericalID [protected, inherited]

Unique numerical ID (set on reading by netload).

Definition at line 582 of file MSLane.h.

Referenced by MSLane::getNumericalID().

Position2DVector MSLane::myShape [inherited]

The shape of the lane.

Definition at line 457 of file MSLane.h.

Referenced by GUILane::buildLaneWrapper(), buildLaneWrapper(), and MSLane::getShape().

VehCont MSLane::myTmpVehicles [protected, inherited]

Container for lane-changing vehicles. After completion of lane-change- process, the two containers will be swapped.

Definition at line 604 of file MSLane.h.

Referenced by MSLane::swapAfterLaneChange().

std::vector<MSVehicle*> MSLane::myVehBuffer [protected, inherited]

Vehicle-buffer for vehicle that was put onto this lane by a junction. The buffer is necessary, because of competing push- and pop-operations on myVehicles during Junction::moveFirst()

Definition at line 613 of file MSLane.h.

Referenced by MSLane::empty(), MSLane::integrateNewVehicle(), and MSLane::push().

SUMOReal MSLane::myVehicleLengthSum [protected, inherited]

The current length of all vehicles on this lane.

Definition at line 624 of file MSLane.h.

Referenced by MSLane::detectCollisions(), MSLane::enteredByLaneChange(), MSLane::getOccupancy(), MSLane::getVehLenSum(), MSLane::integrateNewVehicle(), MSLane::isEmissionSuccess(), MSLane::leftByLaneChange(), MSLane::moveCritical(), MSLane::pop(), MSLane::removeFirstVehicle(), MSLane::removeVehicle(), and MSLane::setCritical().

VehCont MSLane::myVehicles [protected, inherited]

The lane's vehicles. The entering vehicles are inserted at the front of this container and the leaving ones leave from the back, e.g. the vehicle in front of the junction (often called first) is myVehicles.back() (if it exists). And if it is an iterator at a vehicle, ++it points to the vehicle in front. This is the interaction vehicle.

Definition at line 591 of file MSLane.h.

Referenced by MSLane::detectCollisions(), MSLane::empty(), GUILaneWrapper::firstWaitingTime(), MSLane::freeEmit(), MSLane::getFirstVehicle(), MSLane::getLastVehicle(), MSLane::getLastVehicleInformation(), MSLane::getMeanSpeed(), MSLane::getVehicleNumber(), MSLane::getVehiclesSecure(), GUILane::getVehiclesSecure(), getVehiclesSecure(), MSLane::integrateNewVehicle(), MSLane::isEmissionSuccess(), MSLane::moveCritical(), MSInternalLane::moveCritical(), MSLane::pop(), MSLane::removeFirstVehicle(), MSLane::removeVehicle(), MSLane::setCritical(), and MSLane::swapAfterLaneChange().

---

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

• GUIInternalLane.h
• GUIInternalLane.cpp