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) {
248 if (allowedLanes->empty()) {
250 allowedLanes =
nullptr;
252 for (
auto& allowed : laneCont) {
253 if (*allowed.second == *allowedLanes) {
255 allowedLanes =
nullptr;
256 allowed.first |= permissions;
261 if (allowedLanes !=
nullptr) {
262 laneCont.push_back(std::make_pair(permissions, allowedLanes));
278 if (i.second != myLanes) {
284 myAllowed.push_back(std::make_pair(
SVC_IGNORING, myLanes));
287 std::vector<MSLane*>*
allowedLanes =
new std::vector<MSLane*>();
288 for (
MSLane*
const lane : *myLanes) {
289 if (lane->allowsVehicleClass(vclass)) {
290 allowedLanes->push_back(lane);
304 for (
const auto i1 : i2.second) {
310 myAllowedTargets.clear();
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;
335 addToAllowed(i.first,
new std::vector<MSLane*>(*i.second), myAllowedTargets[target]);
343 std::vector<MSLane*>*
allowedLanes =
new std::vector<MSLane*>();
344 for (
MSLane*
const lane : *myLanes) {
346 for (
const MSLink*
const link : lane->getLinkCont()) {
347 if (link->getLane()->allowsVehicleClass((
SUMOVehicleClass)vclass) && &link->getLane()->getEdge() == target) {
348 allowedLanes->push_back(lane);
353 addToAllowed(vclass, allowedLanes, myAllowedTargets[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.");
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());
double distanceTo2D(const Position &p) const
returns the euclidean distance in the x-y-plane
void laneChange(SUMOTime t)
Start lane-change-process for all vehicles on the edge'e lanes.
const SumoXMLEdgeFunc myFunction
the purpose of the edge
bool myAmDelayed
whether this edge had a vehicle with less than max speed on it
double getDepartPosBound(const MSVehicle &veh, bool upper=true) const
return upper bound for the depart position on this edge
double getBruttoOccupancy() const
Returns the brutto (including minGaps) occupancy of this lane during the last step.
MESegment * getNextSegment() const
Returns the following segment on the same edge (0 if it is the last).
double getLengthWithGap() const
Get vehicle's length including the minimum gap [m].
static double gLateralResolution
MSLane * getLogicalPredecessorLane() const
get the most likely precedecessor lane (sorted using by_connections_to_sorter). The result is cached ...
bool insertVehicle(SUMOVehicle &v, SUMOTime time, const bool checkOnly=false, const bool forceCheck=false) const
Tries to insert the given vehicle into the network.
std::set< MSTransportable * > myContainers
Containers on the edge.
MSEdge & getEdge() const
Returns the lane's edge.
Representation of a vehicle in the micro simulation.
std::string lane
The lane to stop at.
static void insertIDs(std::vector< std::string > &into)
Inserts IDs of all known edges into the given vector.
void checkAndRegisterBiDirEdge(const std::string &bidiID="")
check and register the opposite superposable edge if any
AllowedLanesByTarget myAllowedTargets
From target edge to lanes allowed to be used to reach it.
Sorts edges by their ids.
A vehicle from the mesoscopic point of view.
MESegment * getSegmentForEdge(const MSEdge &e, double pos=0)
Get the segment for a given edge at a given position.
virtual const MSVehicleType & getVehicleType() const =0
Returns the vehicle's type.
SUMOTime getMesoTLSPenalty() const
Returns the time penalty for passing a tls-controlled link (meso)
static double gMesoTLSPenalty
double getLengthGeometryFactor() const
return shape.length() / myLength
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types...
double getVehicleMaxSpeed(const SUMOTrafficObject *const veh) const
Returns the maximum speed the vehicle may use on this edge.
virtual const std::string & getID() const =0
Get the vehicle's ID.
static int dictSize()
Returns the number of edges.
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...
bool initialise(MEVehicle *veh, SUMOTime time)
Inserts (emits) vehicle into the segment.
static void readEdgeVector(std::istream &in, std::vector< const E *> &edges, const std::string &rid)
Reads an edge vector binary.
DepartLaneDefinition departLaneProcedure
Information how the vehicle shall choose the lane to depart from.
void recalcCache()
Recalculates the cached values.
This is an uncontrolled, minor link, has to stop.
const MSEdgeVector & getPredecessors() const
The base class for an intersection.
static MSEdgeVector myEdges
Static list of edges.
std::vector< std::pair< const MSEdge *, const MSEdge * > > MSConstEdgePairVector
double myTimePenalty
flat penalty when computing traveltime
int SVCPermissions
bitset where each bit declares whether a certain SVC may use this edge/lane
double getPositionOnLane() const
Get the vehicle's position along the lane.
virtual double getEdgePos(SUMOTime now) const
static double rand(std::mt19937 *rng=0)
Returns a random real number in [0, 1)
const SUMOVehicleParameter & getParameter() const
Returns the vehicle's parameter (including departure definition)
The least occupied lane is used.
The link is a 180 degree turn.
void buildSegmentsFor(const MSEdge &e, const OptionsCont &oc)
Build the segments for a given edge.
std::string time2string(SUMOTime t)
virtual ~MSEdge()
Destructor.
const std::vector< MSLane * > * allowedLanes(const MSEdge &destination, SUMOVehicleClass vclass=SVC_IGNORING) const
Get the allowed lanes to reach the destination-edge.
const std::vector< MSLane * > & getLanes() const
Returns this edge's lanes.
static MSNet * getInstance()
Returns the pointer to the unique instance of MSNet (singleton).
std::vector< double > & getParameter()
Returns the parameters of this distribution.
double getMeanSpeed() const
get the mean speed
const MSRoute & getRoute() const
Returns the current route.
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...
std::vector< double > mySublaneSides
the right side for each sublane on this edge
This is an uncontrolled, right-before-left link.
SUMOTime incVaporization(SUMOTime t)
Enables vaporization.
The lane is chosen randomly.
std::vector< const MSEdge * > ConstMSEdgeVector
void initialize(const std::vector< MSLane *> *lanes)
Initialize the edge.
const std::string & getID() const
Returns the id.
MSConstEdgePairVector myViaSuccessors
MSEdge(const std::string &id, int numericalID, const SumoXMLEdgeFunc function, const std::string &streetName, const std::string &edgeType, int priority, double distance)
Constructor.
const SVCPermissions SVCAll
all VClasses are allowed
int myVaporizationRequests
Vaporizer counter.
virtual double getChosenSpeedFactor() const =0
int operator()(const MSTransportable *const c1, const MSTransportable *const c2) const
comparing operator
double getLength() const
return the length of the edge
int size() const
Returns the number of edges to pass.
const MSJunction * getToJunction() const
std::vector< MSTransportable * > getSortedPersons(SUMOTime timestep, bool includeRiding=false) const
Returns this edge's persons sorted by pos.
The least occupied lane from best lanes.
The position is chosen randomly.
SUMOTime decVaporization(SUMOTime t)
Disables vaporization.
int getNumericalID() const
Returns the numerical id of the edge.
This is an uncontrolled, all-way stop link.
double getSpeedLimit() const
Returns the speed limit of the edge The speed limit of the first lane is retured; should probably be...
#define WRITE_WARNING(msg)
std::map< std::string, MSEdge *> DictType
definition of the static dictionary type
The car-following model and parameter.
bool isVaporizing() const
Returns whether vehicles on this edge shall be vaporized.
static OptionsCont & getOptions()
Retrieves the options.
Performs lane changing of vehicles.
LinkState getState() const
Returns the current state of the link.
bool isTLSControlled() const
double getCurrentTravelTime(const double minSpeed=NUMERICAL_EPS) const
Computes and returns the current travel time for this edge.
bool hasSpaceFor(const MEVehicle *veh, SUMOTime entryTime, bool init=false) const
Returns whether the given vehicle would still fit into the segment.
The link is a straight direction.
void addToAllowed(const SVCPermissions permissions, const std::vector< MSLane *> *allowedLanes, AllowedLanesCont &laneCont) const
Performs lane changing of vehicles.
double departSpeed
(optional) The initial speed of the vehicle
A road/street connecting two junctions.
bool insertVehicle(MSVehicle &v)
Tries to insert the given vehicle.
SUMOTime myLastFailedInsertionTime
The time of last insertion failure.
MSTransportable::Stage * getCurrentStage() const
Return the current stage.
std::map< SUMOVehicleClass, MSEdgeVector > myClassesSuccessorMap
The successors available for a given vClass.
void rebuildAllowedLanes()
const int SUMOVehicleClass_MAX
int getIndex() const
Returns the lane's index.
#define BEST_LANE_LOOKAHEAD
DepartSpeedDefinition departSpeedProcedure
Information how the vehicle's initial speed shall be chosen.
virtual void setChosenSpeedFactor(const double factor)=0
double myLength
the length of the edge (cached value for speedup)
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Representation of a vehicle.
DepartPosDefinition departPosProcedure
Information how the vehicle shall choose the departure position.
The least occupied lane from lanes which allow the continuation.
This is an uncontrolled, minor link, has to brake.
AllowedLanesCont myAllowed
Associative container from vehicle class to allowed-lanes.
A point in 2D or 3D with translation and scaling methods.
bool hasMinorLink() const
whether any lane has a minor link
const MSEdge * getOppositeEdge() const
Returns the opposite direction edge if on exists else a nullptr.
void updateBestLanes(bool forceRebuild=false, const MSLane *startLane=0)
computes the best lanes to use in order to continue the route
static void clear()
Clears the dictionary.
SVCPermissions myMinimumPermissions
The intersection of lane permissions for this edge.
void rebuildAllowedTargets(const bool updateVehicles=true)
MSEdgeVector mySuccessors
The succeeding edges.
double getDistanceTo(const MSEdge *other, const bool doBoundaryEstimate=false) const
optimistic air distance heuristic for use in routing
MSJunction * myToJunction
bool havePriority() const
Returns whether this link is a major link.
MSLaneChanger * myLaneChanger
This member will do the lane-change.
double getRoutingSpeed() const
Returns the averaged speed used by the routing device.
LinkState
The right-of-way state of a link between two lanes used when constructing a NBTrafficLightLogic, in MSLink and GNEInternalLane.
Boundary myBoundary
The bounding rectangle of end nodes incoming or outgoing edges for taz connectors or of my own start ...
MSLane * leftLane(const MSLane *const lane) const
Returns the lane left to the one given, 0 if the given lane is leftmost.
const MSEdge * getNormalBefore() const
if this edge is an internal edge, return its first normal predecessor, otherwise the edge itself ...
static SUMOTime gMesoMinorPenalty
const Position & getPosition() const
const std::string & getID() const
returns the id of the transportable
bool myAmFringe
whether this edge is at the network fringe
MSLane * getDepartLane(MSVehicle &veh) const
Finds a depart lane for the given vehicle parameters.
const MSConstEdgePairVector & getViaSuccessors(SUMOVehicleClass vClass=SVC_IGNORING) const
Returns the following edges with internal vias, restricted by vClass.
const std::vector< MSLane * > * myLanes
Container for the edge's lane; should be sorted: (right-hand-traffic) the more left the lane...
MSLane * getOpposite() const
return the opposite direction lane for lane changing or 0
double endPos
The stopping position end.
const MSEdge * myBidiEdge
the oppositing superposble edge
bool isInternal() const
return whether this edge is an internal edge
If a fixed number of random choices fails, a free position is chosen.
std::vector< MSVehicle * > VehCont
Container for vehicles.
bool isSuperposable(const MSEdge *other)
bool canChangeToOpposite()
whether this edge allows changing to the opposite direction edge
Base class for objects which have an id.
The rightmost lane the vehicle may use.
int departLane
(optional) The lane the vehicle shall depart from (index in edge)
const MSEdge * getInternalFollowingEdge(const MSEdge *followerAfterInternal) const
Definition of vehicle stop (position and duration)
const ConstMSEdgeVector & getOutgoing() const
std::vector< std::string > getVector()
return vector of strings
SVCPermissions myCombinedPermissions
The union of lane permissions for this edge.
const MSEdgeVector & getSuccessors(SUMOVehicleClass vClass=SVC_IGNORING) const
Returns the following edges, restricted by vClass.
No information given; use default.
void buildLaneChanger()
Has to be called after all sucessors and predecessors have been set (after closeBuilding()) ...
double departPos
(optional) The position the vehicle shall depart from
static bool dictionary(const std::string &id, MSLane *lane)
Static (sic!) container methods {.
double startPos
The stopping position start.
static const Position getStopPosition(const SUMOVehicleParameter::Stop &stop)
return the coordinates of the center of the given stop
Structure representing possible vehicle parameter.
Representation of a vehicle or person.
const MSVehicleType & getVehicleType() const
Returns the vehicle's type definition.
bool isTazConnector() const
std::map< SUMOVehicleClass, MSConstEdgePairVector > myClassesViaSuccessorMap
The successors available for a given vClass.
static double getAssumedSpeed(const MSEdge *edge)
return current travel speed assumption
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...
static const MSEdgeVector & getAllEdges()
Returns all edges with a numerical id.
virtual void changeLanes(SUMOTime t)
Performs lane changing on this edge.
static const T & getRandomFrom(const std::vector< T > &v, std::mt19937 *rng=0)
Returns a random element from the given vector.
virtual const SUMOVehicleParameter & getParameter() const =0
Returns the vehicle's parameter (including departure definition)
const MSJunction * getFromJunction() const
A single mesoscopic segment (cell)
double myWidth
Edge width [m].
SumoXMLEdgeFunc
Numbers representing special SUMO-XML-attribute values for representing edge functions used in netbui...
MSJunction * myFromJunction
the junctions for this edge
double getInternalFollowingLengthTo(const MSEdge *followerAfterInternal) const
returns the length of all internal edges on the junction until reaching the non-internal edge followe...
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...
static MELoop * gMesoNet
mesoscopic simulation infrastructure
double getLength() const
Get vehicle's length [m].
void setMaxSpeed(double val) const
Sets a new maximum speed for all lanes (used by TraCI and MSCalibrator)
void setJunctions(MSJunction *from, MSJunction *to)
static DictType myDict
Static dictionary to associate string-ids with objects.
Sorts transportables by their positions.
static double gMinorPenalty
time penalty for passing a minor link when routing
std::vector< std::pair< SVCPermissions, const std::vector< MSLane * > *> > AllowedLanesCont
"Map" from vehicle class to allowed lanes
MSRouteIterator begin() const
Returns the begin of the list of edges to pass.
No information given; use default.
A free position is chosen.
std::vector< MSEdge * > MSEdgeVector
Insert behind the last vehicle as close as possible to still allow the specified departSpeed. Fallback to DEPART_POS_BASE if there is no vehicle on the departLane yet.
double computeChosenSpeedDeviation(std::mt19937 *rng, const double minDev=-1.) const
Computes and returns the speed deviation.
const MSLinkCont & getLinkCont() const
returns the container with all links !!!
const std::vector< LaneQ > & getBestLanes() const
Returns the description of best lanes to use in order to continue the route.
void add(double x, double y, double z=0)
Makes the boundary include the given coordinate.
static SUMOTime gLaneChangeDuration
MSEdgeVector myPredecessors
The preceeding edges.
std::vector< MSTransportable * > getSortedContainers(SUMOTime timestep, bool includeRiding=false) const
Returns this edge's containers sorted by pos.
Representation of a lane in the micro simulation.
bool allowsLaneChanging() const
MSLane * rightLane(const MSLane *const lane) const
Returns the lane right to the one given, 0 if the given lane is rightmost.
double myEmptyTraveltime
the traveltime on the empty edge (cached value for speedup)
MSLane * getFreeLane(const std::vector< MSLane *> *allowed, const SUMOVehicleClass vclass, double departPos) const
Finds the emptiest lane allowing the vehicle class.
const Distribution_Parameterized & getSpeedFactor() const
Returns this type's speed factor.
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.
SumoXMLEdgeFunc getFunction() const
Returns the edge type (SumoXMLEdgeFunc)
vehicles ignoring classes
SUMOVehicleClass getVehicleClass() const
Get this vehicle type's vehicle class.
std::string id
The vehicle's id.
std::set< int > myFailedInsertionMemory
A cache for the rejected insertion attempts. Used to assure that no further insertion attempts are ma...
std::set< MSTransportable * > myPersons
Persons on the edge for drawing and pushbutton.