 |
Eclipse SUMO - Simulation of Urban MObility
|
Go to the documentation of this file.
52 #define BEST_LANE_LOOKAHEAD 3000.0
66 const std::string& streetName,
67 const std::string& edgeType,
70 Named(id), myNumericalID(numericalID), myLanes(nullptr),
71 myLaneChanger(nullptr), myFunction(function), myVaporizationRequests(0),
72 myLastFailedInsertionTime(-1),
73 myFromJunction(nullptr), myToJunction(nullptr),
74 myStreetName(streetName),
80 myEmptyTraveltime(0.),
83 myAmRoundabout(false),
97 for (
auto i1 : i2.second) {
114 for (std::vector<MSLane*>::const_iterator i =
myLanes->begin(); i !=
myLanes->end(); ++i) {
117 double widthBefore = 0;
118 for (std::vector<MSLane*>::const_iterator i =
myLanes->begin(); i !=
myLanes->end(); ++i) {
119 (*i)->setRightSideOnEdge(widthBefore, (
int)
mySublaneSides.size());
124 widthBefore += (*i)->getWidth();
139 for (std::vector<MSLane*>::const_iterator i =
myLanes->begin(); i !=
myLanes->end(); ++i) {
142 for (MSLinkCont::const_iterator j = lc.begin(); j != lc.end(); ++j) {
145 if (minPenalty == -1) {
146 minPenalty = linkPenalty;
148 minPenalty =
MIN2(minPenalty, linkPenalty);
152 if (minPenalty > 0) {
156 const MSLink* link =
myLanes->front()->getIncomingLanes()[0].viaLink;
168 for (
MSLink*
const link : lane->getLinkCont()) {
169 link->initParallelLinks();
170 MSLane*
const toL = link->getLane();
171 MSLane*
const viaL = link->getViaLane();
172 if (toL !=
nullptr) {
185 if (viaL !=
nullptr) {
192 lane->checkBufferType();
227 for (std::vector<MSLane*>::const_iterator it =
myLanes->begin(); it !=
myLanes->end(); ++it) {
252 for (
auto& allowed : laneCont) {
256 allowed.first |= permissions;
262 laneCont.push_back(std::make_pair(permissions,
allowedLanes));
287 std::vector<MSLane*>*
allowedLanes =
new std::vector<MSLane*>();
289 if (lane->allowsVehicleClass(vclass)) {
304 for (
const auto i1 : i2.second) {
313 bool universalMap =
true;
314 std::vector<MSLane*>* allLanes =
new std::vector<MSLane*>();
318 for (
const MSLink*
const link : lane->getLinkCont()) {
319 if (&link->getLane()->getEdge() == target) {
320 allLanes->push_back(lane);
321 combinedTargetPermissions |= link->getLane()->getPermissions();
324 if (combinedTargetPermissions == 0 || (lane->getPermissions() & combinedTargetPermissions) != lane->getPermissions()) {
325 universalMap =
false;
343 std::vector<MSLane*>*
allowedLanes =
new std::vector<MSLane*>();
346 for (
const MSLink*
const link : lane->getLinkCont()) {
347 if (link->getLane()->allowsVehicleClass((
SUMOVehicleClass)vclass) && &link->getLane()->getEdge() == target) {
358 if (updateVehicles) {
362 veh->updateBestLanes(
true);
364 lane->releaseVehicles();
386 const int resultIndex = lane->
getIndex() + offset;
387 if (resultIndex == (
int)
myLanes->size() && includeOpposite) {
389 }
else if (resultIndex >= (
int)
myLanes->size() || resultIndex < 0) {
392 return (*
myLanes)[resultIndex];
397 const std::vector<MSLane*>*
399 AllowedLanesByTarget::const_iterator i =
myAllowedTargets.find(&destination);
401 for (
const auto& allowed : i->second) {
402 if ((allowed.first & vclass) == vclass) {
403 return allowed.second;
411 const std::vector<MSLane*>*
418 if ((allowed.first & vclass) == vclass) {
419 return allowed.second;
445 if (allowed ==
nullptr) {
449 if (allowed !=
nullptr) {
450 double largestGap = 0;
451 MSLane* resByGap =
nullptr;
452 double leastOccupancy = std::numeric_limits<double>::max();;
453 for (std::vector<MSLane*>::const_iterator i = allowed->begin(); i != allowed->end(); ++i) {
454 const double occupancy = (*i)->getBruttoOccupancy();
455 if (occupancy < leastOccupancy) {
457 leastOccupancy = occupancy;
459 const MSVehicle* last = (*i)->getLastFullVehicle();
461 if (lastGap > largestGap) {
462 largestGap = lastGap;
466 if (resByGap !=
nullptr) {
499 for (std::vector<MSLane*>::const_iterator i =
myLanes->begin(); i !=
myLanes->end(); ++i) {
500 MSVehicle* last = (*i)->getLastFullVehicle();
501 if (last !=
nullptr) {
539 const std::vector<MSVehicle::LaneQ>& bl = veh.
getBestLanes();
540 double bestLength = -1;
541 for (std::vector<MSVehicle::LaneQ>::const_iterator i = bl.begin(); i != bl.end(); ++i) {
542 if ((*i).length > bestLength) {
543 bestLength = (*i).length;
549 double departPos = 0;
554 std::vector<MSLane*>* bestLanes =
new std::vector<MSLane*>();
555 for (std::vector<MSVehicle::LaneQ>::const_iterator i = bl.begin(); i != bl.end(); ++i) {
556 if (((*i).length - departPos) >= bestLength) {
557 bestLanes->push_back((*i).lane);
566 for (std::vector<MSLane*>::const_iterator i =
myLanes->begin(); i !=
myLanes->end(); ++i) {
592 if (speedFactorParams[1] > 0.) {
600 "' is too high for the departure edge '" +
getID() +
"'.");
617 v.
getID() +
"'. Inserting at lane end instead.");
630 MEVehicle* veh = static_cast<MEVehicle*>(&v);
632 while (segment !=
nullptr && !result) {
655 if (insertionLane ==
nullptr) {
663 for (std::vector<MSLane*>::const_iterator i =
myLanes->begin(); i !=
myLanes->end(); ++i) {
664 const double occupancy = (*i)->getBruttoOccupancy();
673 if (insertionLane ==
nullptr) {
689 bool success = insertionLane->
insertVehicle(static_cast<MSVehicle&>(v));
712 for (
const MSLink*
const link : l->getLinkCont()) {
713 if (&link->getLane()->getEdge() == followerAfterInternal) {
714 if (link->getViaLane() !=
nullptr) {
715 return &link->getViaLane()->getEdge();
727 assert(followerAfterInternal != 0);
732 while (edge !=
nullptr && edge->
isInternal()) {
741 const MSEdge* result =
this;
755 const int vehNo = segment->getCarNumber();
757 v += vehNo * segment->getMeanSpeed();
765 for (std::vector<MSLane*>::const_iterator i =
myLanes->begin(); i !=
myLanes->end(); ++i) {
766 const double vehNo = (double)(*i)->getVehicleNumber();
767 v += vehNo * (*i)->getMeanSpeed();
772 if (lane->getVehicleNumber() > 0) {
788 assert(minSpeed > 0);
805 DictType::iterator it =
myDict.find(
id);
821 DictType::iterator it =
myDict.find(
id);
832 return (
int)
myDict.size();
844 for (DictType::iterator i =
myDict.begin(); i !=
myDict.end(); ++i) {
854 for (DictType::iterator i =
myDict.begin(); i !=
myDict.end(); ++i) {
855 into.push_back((*i).first);
862 const std::string& rid) {
864 std::istringstream in(desc, std::ios::binary);
877 const std::string& rid) {
878 for (std::vector<std::string>::const_iterator i = desc.begin(); i != desc.end(); ++i) {
881 if (edge ==
nullptr) {
882 throw ProcessError(
"The edge '" + *i +
"' within the route " + rid +
" is not known."
883 +
"\n The route can not be build.");
885 into.push_back(edge);
892 assert(
this != other);
893 if (doBoundaryEstimate) {
905 return getLanes()[0]->getShape()[-1].distanceTo2D(other->
getLanes()[0]->getShape()[0]);
924 return myLanes->empty() ? 1 :
getLanes()[0]->getLengthGeometryFactor();
937 for (std::vector<MSLane*>::const_iterator i =
myLanes->begin(); i !=
myLanes->end(); ++i) {
938 (*i)->setMaxSpeed(val);
945 std::vector<MSTransportable*>
949 for (std::vector<MSLane*>::const_iterator i =
myLanes->begin(); i !=
myLanes->end(); ++i) {
951 for (MSLane::VehCont::const_iterator j = vehs.begin(); j != vehs.end(); ++j) {
952 const std::vector<MSTransportable*>& persons = (*j)->getPersons();
953 result.insert(result.end(), persons.begin(), persons.end());
955 (*i)->releaseVehicles();
963 std::vector<MSTransportable*>
1003 if (MSRoutingEngine::isParallel()) {
1004 MSRoutingEngine::lock();
1014 if ((*it)->isTazConnector()) {
1015 i->second.push_back(*it);
1017 const std::vector<MSLane*>* allowed =
allowedLanes(**it, vClass);
1018 if (allowed !=
nullptr && allowed->size() > 0) {
1019 i->second.push_back(*it);
1026 if (MSRoutingEngine::isParallel()) {
1027 MSRoutingEngine::unlock();
1040 if (MSRoutingEngine::isParallel()) {
1041 MSRoutingEngine::lock();
1048 if (MSRoutingEngine::isParallel()) {
1049 MSRoutingEngine::unlock();
1058 if (viaPair.first->isTazConnector()) {
1059 result.push_back(viaPair);
1061 const std::vector<MSLane*>* allowed =
allowedLanes(*viaPair.first, vClass);
1062 if (allowed !=
nullptr && allowed->size() > 0) {
1063 result.push_back(viaPair);
1068 if (MSRoutingEngine::isParallel()) {
1069 MSRoutingEngine::unlock();
1089 return (!
myLanes->empty() &&
myLanes->back()->getOpposite() !=
nullptr &&
1097 if (!
myLanes->empty() &&
myLanes->back()->getOpposite() !=
nullptr) {
1098 return &(
myLanes->back()->getOpposite()->getEdge());
1107 for (std::vector<MSLane*>::const_iterator i =
myLanes->begin(); i !=
myLanes->end(); ++i) {
1109 for (MSLinkCont::const_iterator j = lc.begin(); j != lc.end(); ++j) {
1110 if (!(*j)->havePriority()) {
1123 WRITE_ERROR(
"Bidi-edge '" + bidiID +
"' does not exist");
1131 for (ConstMSEdgeVector::const_iterator it = candidates.begin(); it != candidates.end(); it++) {
1144 if (other ==
nullptr || other->
getLanes().size() !=
myLanes->size()) {
1147 std::vector<MSLane*>::const_iterator it1 =
myLanes->begin();
1148 std::vector<MSLane*>::const_reverse_iterator it2 = other->
getLanes().rbegin();
1150 if ((*it1)->getShape().reverse() != (*it2)->getShape()) {
1155 }
while (it1 !=
myLanes->end());
MSJunction * myFromJunction
the junctions for this edge
bool canChangeToOpposite()
whether this edge allows changing to the opposite direction edge
The car-following model and parameter.
Sorts edges by their ids.
void updateBestLanes(bool forceRebuild=false, const MSLane *startLane=0)
computes the best lanes to use in order to continue the route
double getCurrentTravelTime(const double minSpeed=NUMERICAL_EPS) const
Computes and returns the current travel time for this edge.
A vehicle from the mesoscopic point of view.
Representation of a vehicle or person.
std::vector< std::pair< SVCPermissions, const std::vector< MSLane * > * > > AllowedLanesCont
"Map" from vehicle class to allowed lanes
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types.
const MSConstEdgePairVector & getViaSuccessors(SUMOVehicleClass vClass=SVC_IGNORING) const
Returns the following edges with internal vias, restricted by vClass.
bool havePriority() const
Returns whether this link is a major link.
static bool dictionary(const std::string &id, MSLane *lane)
Static (sic!) container methods {.
const SUMOVehicleParameter & getParameter() const
Returns the vehicle's parameter (including departure definition)
bool hasMinorLink() const
whether any lane has a minor link
static DictType myDict
Static dictionary to associate string-ids with objects.
This is an uncontrolled, right-before-left link.
const MSEdgeVector & getSuccessors(SUMOVehicleClass vClass=SVC_IGNORING) const
Returns the following edges, restricted by vClass.
LinkState getState() const
Returns the current state of the link.
std::vector< std::pair< const MSEdge *, const MSEdge * > > MSConstEdgePairVector
int getNumericalID() const
Returns the numerical id of the edge.
const int SUMOVehicleClass_MAX
double getSpeedLimit() const
Returns the speed limit of the edge @caution The speed limit of the first lane is retured; should pro...
#define WRITE_WARNING(msg)
const std::vector< LaneQ > & getBestLanes() const
Returns the description of best lanes to use in order to continue the route.
virtual void setChosenSpeedFactor(const double factor)=0
Representation of a lane in the micro simulation.
Base class for objects which have an id.
double getVehicleMaxSpeed(const SUMOTrafficObject *const veh) const
Returns the maximum speed the vehicle may use on this edge.
bool isVaporizing() const
Returns whether vehicles on this edge shall be vaporized.
std::string lane
The lane to stop at.
Performs lane changing of vehicles.
std::vector< MSTransportable * > getSortedPersons(SUMOTime timestep, bool includeRiding=false) const
Returns this edge's persons sorted by pos.
virtual const SUMOVehicleParameter & getParameter() const =0
Returns the vehicle's parameter (including departure definition)
A single mesoscopic segment (cell)
The base class for an intersection.
const MSEdge * getOppositeEdge() const
Returns the opposite direction edge if on exists else a nullptr.
double distanceTo2D(const Position &p) const
returns the euclidean distance in the x-y-plane
void checkAndRegisterBiDirEdge(const std::string &bidiID="")
check and register the opposite superposable edge if any
SVCPermissions myMinimumPermissions
The intersection of lane permissions for this edge.
MSEdgeVector myPredecessors
The preceeding edges.
virtual const MSVehicleType & getVehicleType() const =0
Returns the vehicle's type.
double departSpeed
(optional) The initial speed of the vehicle
DepartPosDefinition departPosProcedure
Information how the vehicle shall choose the departure position.
static double gMinorPenalty
time penalty for passing a minor link when routing
SUMOTime myLastFailedInsertionTime
The time of last insertion failure.
virtual const std::string & getID() const =0
Get the vehicle's ID.
std::map< SUMOVehicleClass, MSEdgeVector > myClassesSuccessorMap
The successors available for a given vClass.
std::map< std::string, MSEdge * > DictType
definition of the static dictionary type
MSJunction * myToJunction
MSLaneChanger * myLaneChanger
This member will do the lane-change.
static MSLink * getConnectingLink(const MSLane &from, const MSLane &to)
Returns the link connecting both lanes Both lanes have to be non-internal; 0 may be returned if no co...
double getDepartPosBound(const MSVehicle &veh, bool upper=true) const
return upper bound for the depart position on this edge
static MSEdgeVector myEdges
Static list of edges.
bool initialise(MEVehicle *veh, SUMOTime time)
Inserts (emits) vehicle into the segment.
No information given; use default.
double myLength
the length of the edge (cached value for speedup)
bool hasSpaceFor(const MEVehicle *veh, SUMOTime entryTime, bool init=false) const
Returns whether the given vehicle would still fit into the segment.
The least occupied lane from best lanes.
std::vector< double > mySublaneSides
the right side for each sublane on this edge
bool myAmFringe
whether this edge is at the network fringe
Insert behind the last vehicle as close as possible to still allow the specified departSpeed....
Representation of a vehicle.
std::vector< MSVehicle * > VehCont
Container for vehicles.
static double getAssumedSpeed(const MSEdge *edge)
return current travel speed assumption
const MSRoute & getRoute() const
Returns the current route.
std::vector< const MSEdge * > ConstMSEdgeVector
SumoXMLEdgeFunc
Numbers representing special SUMO-XML-attribute values for representing edge functions used in netbui...
virtual ~MSEdge()
Destructor.
static OptionsCont & getOptions()
Retrieves the options.
void recalcCache()
Recalculates the cached values.
void rebuildAllowedTargets(const bool updateVehicles=true)
void setJunctions(MSJunction *from, MSJunction *to)
virtual double getEdgePos(SUMOTime now) const
Structure representing possible vehicle parameter.
double getDistanceTo(const MSEdge *other, const bool doBoundaryEstimate=false) const
optimistic air distance heuristic for use in routing
Performs lane changing of vehicles.
double getLength() const
return the length of the edge
bool isTLSControlled() const
SUMOTime decVaporization(SUMOTime t)
Disables vaporization.
double getBruttoOccupancy() const
Returns the brutto (including minGaps) occupancy of this lane during the last step.
static int dictSize()
Returns the number of edges.
static double gLateralResolution
const ConstMSEdgeVector & getOutgoing() const
The least occupied lane from lanes which allow the continuation.
bool isInternal() const
return whether this edge is an internal edge
virtual double getChosenSpeedFactor() const =0
double getLengthGeometryFactor() const
return shape.length() / myLength
MSLane * leftLane(const MSLane *const lane) const
Returns the lane left to the one given, 0 if the given lane is leftmost.
The link is a 180 degree turn.
int size() const
Returns the number of edges to pass.
const MSJunction * getFromJunction() const
LinkState
The right-of-way state of a link between two lanes used when constructing a NBTrafficLightLogic,...
static double rand(std::mt19937 *rng=0)
Returns a random real number in [0, 1)
The link is a straight direction.
The lane is chosen randomly.
std::vector< double > & getParameter()
Returns the parameters of this distribution.
double computeChosenSpeedDeviation(std::mt19937 *rng, const double minDev=-1.) const
Computes and returns the speed deviation.
static double gMesoTLSPenalty
double getPositionOnLane() const
Get the vehicle's position along the lane.
MSTransportable::Stage * getCurrentStage() const
Return the current stage.
const std::vector< MSLane * > * myLanes
Container for the edge's lane; should be sorted: (right-hand-traffic) the more left the lane,...
double getMeanSpeed() const
get the mean speed
A free position is chosen.
int SVCPermissions
bitset where each bit declares whether a certain SVC may use this edge/lane
double getLengthWithGap() const
Get vehicle's length including the minimum gap [m].
static SUMOTime gMesoMinorPenalty
bool isTazConnector() const
static bool dictionary(const std::string &id, MSEdge *edge)
Inserts edge into the static dictionary Returns true if the key id isn't already in the dictionary....
static void clear()
Clears the dictionary.
void initialize(const std::vector< MSLane * > *lanes)
Initialize the edge.
bool insertVehicle(MSVehicle &v)
Tries to insert the given vehicle.
Boundary myBoundary
The bounding rectangle of end nodes incoming or outgoing edges for taz connectors or of my own start ...
std::string id
The vehicle's id.
static const Position getStopPosition(const SUMOVehicleParameter::Stop &stop)
return the coordinates of the center of the given stop
MESegment * getSegmentForEdge(const MSEdge &e, double pos=0)
Get the segment for a given edge at a given position.
MSConstEdgePairVector myViaSuccessors
SumoXMLEdgeFunc getFunction() const
Returns the edge type (SumoXMLEdgeFunc)
AllowedLanesByTarget myAllowedTargets
From target edge to lanes allowed to be used to reach it.
A point in 2D or 3D with translation and scaling methods.
static void readEdgeVector(std::istream &in, std::vector< const E * > &edges, const std::string &rid)
Reads an edge vector binary.
void add(double x, double y, double z=0)
Makes the boundary include the given coordinate.
std::string time2string(SUMOTime t)
static const T & getRandomFrom(const std::vector< T > &v, std::mt19937 *rng=0)
Returns a random element from the given vector.
MESegment * getNextSegment() const
Returns the following segment on the same edge (0 if it is the last).
A road/street connecting two junctions.
double endPos
The stopping position end.
const MSJunction * getToJunction() const
MSLane * rightLane(const MSLane *const lane) const
Returns the lane right to the one given, 0 if the given lane is rightmost.
The position is chosen randomly.
This is an uncontrolled, minor link, has to brake.
const MSVehicleType & getVehicleType() const
Returns the vehicle's type definition.
const MSEdge * getInternalFollowingEdge(const MSEdge *followerAfterInternal) const
const std::vector< MSLane * > * allowedLanes(const MSEdge &destination, SUMOVehicleClass vclass=SVC_IGNORING) const
Get the allowed lanes to reach the destination-edge.
MSLane * getDepartLane(MSVehicle &veh) const
Finds a depart lane for the given vehicle parameters.
const MSLinkCont & getLinkCont() const
returns the container with all links !!!
double getRoutingSpeed() const
Returns the averaged speed used by the routing device.
#define BEST_LANE_LOOKAHEAD
SUMOTime getMesoTLSPenalty() const
Returns the time penalty for passing a tls-controlled link (meso)
const Position & getPosition() const
SVCPermissions myCombinedPermissions
The union of lane permissions for this edge.
const Distribution_Parameterized & getSpeedFactor() const
Returns this type's speed factor.
double getInternalFollowingLengthTo(const MSEdge *followerAfterInternal) const
returns the length of all internal edges on the junction until reaching the non-internal edge followe...
void addToAllowed(const SVCPermissions permissions, const std::vector< MSLane * > *allowedLanes, AllowedLanesCont &laneCont) const
MSLane * getOpposite() const
return the opposite direction lane for lane changing or 0
MSLane * getLogicalPredecessorLane() const
get the most likely precedecessor lane (sorted using by_connections_to_sorter). The result is cached ...
double startPos
The stopping position start.
SUMOTime incVaporization(SUMOTime t)
Enables vaporization.
MSEdge & getEdge() const
Returns the lane's edge.
int departLane
(optional) The lane the vehicle shall depart from (index in edge)
MSEdge(const std::string &id, int numericalID, const SumoXMLEdgeFunc function, const std::string &streetName, const std::string &edgeType, int priority, double distance)
Constructor.
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
bool insertVehicle(SUMOVehicle &v, SUMOTime time, const bool checkOnly=false, const bool forceCheck=false) const
Tries to insert the given vehicle into the network.
const MSEdge * myBidiEdge
the oppositing superposble edge
DepartLaneDefinition departLaneProcedure
Information how the vehicle shall choose the lane to depart from.
static MSNet * getInstance()
Returns the pointer to the unique instance of MSNet (singleton).
static MELoop * gMesoNet
mesoscopic simulation infrastructure
MSEdgeVector mySuccessors
The succeeding edges.
MSLane * getFreeLane(const std::vector< MSLane * > *allowed, const SUMOVehicleClass vclass, double departPos) const
Finds the emptiest lane allowing the vehicle class.
double getLength() const
Get vehicle's length [m].
bool allowsLaneChanging() const
double myTimePenalty
flat penalty when computing traveltime
Sorts transportables by their positions.
void setMaxSpeed(double val) const
Sets a new maximum speed for all lanes (used by TraCI and MSCalibrator)
If a fixed number of random choices fails, a free position is chosen.
const SVCPermissions SVCAll
all VClasses are allowed
std::vector< MSEdge * > MSEdgeVector
void buildSegmentsFor(const MSEdge &e, const OptionsCont &oc)
Build the segments for a given edge.
const std::string & getID() const
returns the id of the transportable
static void parseEdgesList(const std::string &desc, ConstMSEdgeVector &into, const std::string &rid)
Parses the given string assuming it contains a list of edge ids divided by spaces.
MSLane * parallelLane(const MSLane *const lane, int offset, bool includeOpposite=true) const
Returns the lane with the given offset parallel to the given lane one or 0 if it does not exist.
std::set< MSTransportable * > myContainers
Containers on the edge.
const std::vector< MSLane * > & getLanes() const
Returns this edge's lanes.
static void insertIDs(std::vector< std::string > &into)
Inserts IDs of all known edges into the given vector.
bool myAmDelayed
whether this edge had a vehicle with less than max speed on it
No information given; use default.
MSRouteIterator begin() const
Returns the begin of the list of edges to pass.
virtual void changeLanes(SUMOTime t)
Performs lane changing on this edge.
const MSEdge * getNormalBefore() const
if this edge is an internal edge, return its first normal predecessor, otherwise the edge itself
std::vector< std::string > getVector()
return vector of strings
This is an uncontrolled, all-way stop link.
double myWidth
Edge width [m].
static SUMOTime gLaneChangeDuration
SUMOVehicleClass getVehicleClass() const
Get this vehicle type's vehicle class.
void addSuccessor(MSEdge *edge, const MSEdge *via=nullptr)
Adds an edge to the list of edges which may be reached from this edge and to the incoming of the othe...
int operator()(const MSTransportable *const c1, const MSTransportable *const c2) const
comparing operator
vehicles ignoring classes
std::set< int > myFailedInsertionMemory
A cache for the rejected insertion attempts. Used to assure that no further insertion attempts are ma...
static const MSEdgeVector & getAllEdges()
Returns all edges with a numerical id.
std::set< MSTransportable * > myPersons
Persons on the edge for drawing and pushbutton.
const std::string & getID() const
Returns the id.
AllowedLanesCont myAllowed
Associative container from vehicle class to allowed-lanes.
std::map< SUMOVehicleClass, MSConstEdgePairVector > myClassesViaSuccessorMap
The successors available for a given vClass.
The least occupied lane is used.
int myVaporizationRequests
Vaporizer counter.
void buildLaneChanger()
Has to be called after all sucessors and predecessors have been set (after closeBuilding())
int getIndex() const
Returns the lane's index.
The rightmost lane the vehicle may use.
double myEmptyTraveltime
the traveltime on the empty edge (cached value for speedup)
void laneChange(SUMOTime t)
Start lane-change-process for all vehicles on the edge'e lanes.
double departPos
(optional) The position the vehicle shall depart from
DepartSpeedDefinition departSpeedProcedure
Information how the vehicle's initial speed shall be chosen.
void rebuildAllowedLanes()
Definition of vehicle stop (position and duration)
const SumoXMLEdgeFunc myFunction
the purpose of the edge
This is an uncontrolled, minor link, has to stop.
const MSEdgeVector & getPredecessors() const
Representation of a vehicle in the micro simulation.
bool isSuperposable(const MSEdge *other)
std::vector< MSTransportable * > getSortedContainers(SUMOTime timestep, bool includeRiding=false) const
Returns this edge's containers sorted by pos.