54 #define BEST_LANE_LOOKAHEAD 3000.0
69 const std::string& streetName,
70 const std::string& edgeType,
73 Named(id), myNumericalID(numericalID), myLanes(nullptr),
74 myLaneChanger(nullptr), myFunction(function), myVaporizationRequests(0),
75 myLastFailedInsertionTime(-1),
76 myFromJunction(nullptr), myToJunction(nullptr),
77 myHaveTransientPermissions(false),
78 myOtherTazConnector(nullptr),
79 myStreetName(streetName),
85 myEmptyTraveltime(0.),
88 myAmRoundabout(false),
104 myLanes = std::shared_ptr<const std::vector<MSLane*> >(lanes);
108 for (
MSLane*
const lane : *lanes) {
133 if (haveTLSPenalty || minorPenalty > 0) {
137 for (
const MSLink*
const link : l->getLinkCont()) {
138 if (link->getLane()->isWalkingArea() && link->getLaneBefore()->isNormal()) {
141 SUMOTime linkPenalty = link->isTLSControlled() ? link->getMesoTLSPenalty() : (link->havePriority() ? 0 : minorPenalty);
142 if (minPenalty == -1) {
143 minPenalty = linkPenalty;
145 minPenalty =
MIN2(minPenalty, linkPenalty);
149 if (minPenalty > 0) {
156 for (
const auto& ili :
myLanes->front()->getIncomingLanes()) {
157 double penalty =
STEPS2TIME(ili.viaLink->getMesoTLSPenalty());
158 if (!ili.viaLink->haveOffPriority()) {
167 const MSLink* link =
myLanes->front()->getIncomingLanes()[0].viaLink;
181 if (!edge->isInternal()) {
185 auto it = std::find(succ.begin(), succ.end(),
this);
186 auto it2 = std::find(succVia.begin(), succVia.end(), std::make_pair(
const_cast<const MSEdge*
>(
this), (
const MSEdge*)
nullptr));
187 auto it3 = std::find(pred.begin(), pred.end(),
this);
188 if (it != succ.end()) {
192 if (it3 != pred.end()) {
202 for (
MSLink*
const link : lane->getLinkCont()) {
203 link->initParallelLinks();
204 MSLane*
const toL = link->getLane();
205 MSLane*
const viaL = link->getViaLane();
206 if (toL !=
nullptr) {
219 if (viaL !=
nullptr) {
226 lane->checkBufferType();
233 if (
myLanes->back()->getOpposite() !=
nullptr) {
278 const MSLink*
const link = lane->getLogicalPredecessorLane()->getLinkTo(lane);
279 assert(link !=
nullptr);
298 for (
auto& allowed : laneCont) {
300 allowed.first |= permissions;
304 laneCont.push_back(std::make_pair(permissions,
allowedLanes));
312 return (p | ignored) == ignored ? 0 : p;
321 bool lanesChangedPermission =
false;
329 lanesChangedPermission |= lane->hadPermissionChanges();
344 std::shared_ptr<std::vector<MSLane*> >
allowedLanes = std::make_shared<std::vector<MSLane*> >();
361 pred->myOrigAllowed = pred->myAllowed;
362 pred->myOrigAllowedTargets = pred->myAllowedTargets;
363 pred->myOrigClassesViaSuccessorMap = pred->myClassesViaSuccessorMap;
364 pred->myHaveTransientPermissions =
true;
366 pred->rebuildAllowedTargets(
false);
370 s->updatePermissions();
381 bool universalMap =
true;
382 std::shared_ptr<std::vector<MSLane*> > allLanes = std::make_shared<std::vector<MSLane*> >();
386 for (
const MSLink*
const link : lane->getLinkCont()) {
387 if (&link->getLane()->getEdge() == target) {
388 allLanes->push_back(lane);
389 combinedTargetPermissions |= link->getLane()->getPermissions();
390 if (link->getViaLane() !=
nullptr &&
391 ((lane->getPermissions() & link->getLane()->getPermissions()) != link->getViaLane()->getPermissions())) {
393 universalMap =
false;
397 if (combinedTargetPermissions == 0 || (lane->getPermissions() & combinedTargetPermissions) != lane->getPermissions()) {
398 universalMap =
false;
415 std::shared_ptr<std::vector<MSLane*> >
allowedLanes = std::make_shared<std::vector<MSLane*> >();
418 for (
const MSLink*
const link : lane->getLinkCont()) {
419 if (link->getLane()->allowsVehicleClass((
SUMOVehicleClass)vclass) && &link->getLane()->getEdge() == target && (link->getViaLane() ==
nullptr || link->getViaLane()->allowsVehicleClass((
SUMOVehicleClass)vclass))) {
430 if (updateVehicles) {
434 veh->updateBestLanes(
true);
436 lane->releaseVehicles();
458 const int resultIndex = lane->
getIndex() + offset;
459 if (resultIndex >=
getNumLanes() && includeOpposite) {
465 }
else if (resultIndex >= (
int)
myLanes->size() || resultIndex < 0) {
468 return (*
myLanes)[resultIndex];
473 const std::vector<MSLane*>*
476 AllowedLanesByTarget::const_iterator i = targets.find(&destination);
477 if (i != targets.end()) {
478 for (
const auto& allowed : i->second) {
479 if ((allowed.first & vclass) == vclass) {
480 return allowed.second.get();
488 const std::vector<MSLane*>*
495 if ((allowed.first & vclass) == vclass) {
496 return allowed.second.get();
522 if (allowed ==
nullptr) {
526 if (allowed !=
nullptr) {
527 double largestGap = 0;
528 MSLane* resByGap =
nullptr;
529 double leastOccupancy = std::numeric_limits<double>::max();
530 for (std::vector<MSLane*>::const_iterator i = allowed->begin(); i != allowed->end(); ++i) {
531 const double occupancy = (*i)->getBruttoOccupancy();
532 if (occupancy < leastOccupancy) {
534 leastOccupancy = occupancy;
536 const MSVehicle* last = (*i)->getLastFullVehicle();
538 if (lastGap > largestGap) {
539 largestGap = lastGap;
543 if (resByGap !=
nullptr) {
576 for (std::vector<MSLane*>::const_iterator i =
myLanes->begin(); i !=
myLanes->end(); ++i) {
577 MSVehicle* last = (*i)->getLastFullVehicle();
578 if (last !=
nullptr) {
630 const std::vector<MSVehicle::LaneQ>& bl = veh.
getBestLanes();
631 double bestLength = -1;
632 for (std::vector<MSVehicle::LaneQ>::const_iterator i = bl.begin(); i != bl.end(); ++i) {
633 if ((*i).length > bestLength) {
634 bestLength = (*i).length;
640 double departPos = 0;
645 std::vector<MSLane*>* bestLanes =
new std::vector<MSLane*>();
646 for (std::vector<MSVehicle::LaneQ>::const_iterator i = bl.begin(); i != bl.end(); ++i) {
647 if (((*i).length - departPos) >= bestLength) {
648 bestLanes->push_back((*i).lane);
657 for (std::vector<MSLane*>::const_iterator i =
myLanes->begin(); i !=
myLanes->end(); ++i) {
682 if (departLane !=
nullptr) {
686 vMax *= (1 + SPEED_EPS);
692 if (speedFactorParams[1] > 0.) {
696 WRITE_WARNINGF(
TL(
"Choosing new speed factor % for vehicle '%' to match departure speed % (max %)."),
719 const std::string errorMsg =
"Departure speed for vehicle '" + pars.
id +
"' is too high for the departure edge '" +
getID() +
"'.";
740 v.
getID() +
"'. Inserting at lane end instead.");
756 while (segment !=
nullptr && !result) {
758 result = segment->
hasSpaceFor(veh, time, qIdx,
true) == time;
766 result = segment->
hasSpaceFor(veh, time, qIdx,
true) == time;
779 if (insertionLane ==
nullptr) {
788 for (std::vector<MSLane*>::const_iterator i =
myLanes->begin(); i !=
myLanes->end(); ++i) {
789 const double occupancy = (*i)->getBruttoOccupancy();
799 if (insertionLane ==
nullptr) {
839 for (
const MSLink*
const link : l->getLinkCont()) {
840 if (&link->getLane()->getEdge() == followerAfterInternal) {
841 if (link->getViaLane() !=
nullptr) {
842 if (link->getViaLane()->allowsVehicleClass(vClass)) {
843 return &link->getViaLane()->getEdge();
859 assert(followerAfterInternal != 0);
864 while (edge !=
nullptr && edge->
isInternal()) {
874 const MSEdge* result =
this;
884 const MSEdge* result =
this;
895 double totalNumVehs = 0;
898 const int numVehs = segment->getCarNumber();
900 v += numVehs * segment->getMeanSpeed();
901 totalNumVehs += numVehs;
904 if (totalNumVehs == 0) {
909 int numVehs = lane->getVehicleNumber();
914 v += numVehs * lane->getMeanSpeed();
915 totalNumVehs += numVehs;
919 if (lane->getVehicleNumber() > 0) {
925 if (totalNumVehs == 0) {
929 return v / totalNumVehs;
937 f += lane->getFrictionCoefficient();
940 return f / (double)
myLanes->size();
953 double totalNumVehs = 0;
955 const int numVehs = lane->getVehicleNumber();
956 v += numVehs * lane->getMeanSpeedBike();
957 totalNumVehs += numVehs;
959 if (totalNumVehs == 0) {
962 return v / totalNumVehs;
968 assert(minSpeed > 0);
984 const DictType::iterator it =
myDict.lower_bound(
id);
985 if (it ==
myDict.end() || it->first !=
id) {
987 myDict.emplace_hint(it,
id, ptr);
1000 const DictType::iterator it =
myDict.find(
id);
1001 if (it ==
myDict.end()) {
1014 if (startIdx + 1 < (
int)
myEdges.size() &&
myEdges[startIdx + 1] !=
nullptr &&
myEdges[startIdx + 1]->getID() ==
id) {
1029 for (DictType::iterator i =
myDict.begin(); i !=
myDict.end(); ++i) {
1039 for (DictType::iterator i =
myDict.begin(); i !=
myDict.end(); ++i) {
1040 into.push_back((*i).first);
1047 const std::string& rid) {
1055 const std::string& rid) {
1056 for (std::vector<std::string>::const_iterator i = desc.begin(); i != desc.end(); ++i) {
1059 if (edge ==
nullptr) {
1060 throw ProcessError(
"The edge '" + *i +
"' within the route " + rid +
" is not known."
1061 +
"\n The route can not be build.");
1063 into.push_back(edge);
1070 assert(
this != other);
1071 if (doBoundaryEstimate) {
1083 return getLanes()[0]->getShape()[-1].distanceTo2D(other->
getLanes()[0]->getShape()[0]);
1102 return myLanes->empty() ? 1 :
getLanes()[0]->getLengthGeometryFactor();
1116 for (std::vector<MSLane*>::const_iterator i =
myLanes->begin(); i !=
myLanes->end(); ++i) {
1117 (*i)->setMaxSpeed(val,
false,
false, jamThreshold);
1135 auto it = tc.find(t);
1136 if (it != tc.end()) {
1141 std::vector<MSTransportable*>
1144 if (includeRiding) {
1145 for (std::vector<MSLane*>::const_iterator i =
myLanes->begin(); i !=
myLanes->end(); ++i) {
1147 for (MSLane::VehCont::const_iterator j = vehs.begin(); j != vehs.end(); ++j) {
1148 const std::vector<MSTransportable*>& persons = (*j)->getPersons();
1149 result.insert(result.end(), persons.begin(), persons.end());
1151 (*i)->releaseVehicles();
1159 std::vector<MSTransportable*>
1208 if ((*it)->isTazConnector()) {
1209 i->second.push_back(*it);
1211 const std::vector<MSLane*>* allowed =
allowedLanes(**it, vClass);
1212 if (allowed !=
nullptr && allowed->size() > 0) {
1213 i->second.push_back(*it);
1232 auto i = viaMap.find(vClass);
1233 if (i != viaMap.end()) {
1241 if (viaPair.first->isTazConnector()) {
1242 result.push_back(viaPair);
1244 const std::vector<MSLane*>* allowed =
allowedLanes(*viaPair.first, vClass, ignoreTransientPermissions);
1245 if (allowed !=
nullptr && allowed->size() > 0) {
1246 result.push_back(viaPair);
1267 return (!
myLanes->empty() &&
myLanes->back()->getOpposite() !=
nullptr &&
1277 if (!
myLanes->empty() &&
myLanes->back()->getOpposite() !=
nullptr) {
1278 return &(
myLanes->back()->getOpposite()->getEdge());
1288 for (
const MSLink*
const link : l->getLinkCont()) {
1289 if (!link->havePriority()) {
1313 for (ConstMSEdgeVector::const_iterator it = candidates.begin(); it != candidates.end(); it++) {
1336 int numBidiLanes = 0;
1339 if (l1->getShape().reverse().almostSame(l2->
getShape(), POSITION_EPS * 2)) {
1340 l1->setBidiLane(l2);
1355 if (other ==
nullptr || other->
getLanes().size() !=
myLanes->size()) {
1358 std::vector<MSLane*>::const_iterator it1 =
myLanes->begin();
1359 std::vector<MSLane*>::const_reverse_iterator it2 = other->
getLanes().rbegin();
1361 if ((*it1)->getShape().reverse() != (*it2)->getShape()) {
1366 }
while (it1 !=
myLanes->end());
1386 std::vector<SUMOVehicle*>::iterator it = std::find(
myWaiting.begin(),
myWaiting.end(), vehicle);
1401 (!vehicle->hasDeparted() &&
1406 if (!vehicle->isLineStop(position) && vehicle->allowsBoarding(transportable)) {
1408 + transportable->
getID() +
"' at edge '" +
getID() +
"' position " +
toString(position) +
" cannot use waiting vehicle '"
1409 + vehicle->getID() +
"' at position " +
toString(vehicle->getPositionOnLane()) +
" because it is too far away.");
1416 std::vector<const SUMOVehicle*>
1418 std::vector<const SUMOVehicle*> result;
1421 std::vector<const MEVehicle*> segmentVehs = segment->getVehicles();
1422 result.insert(result.end(), segmentVehs.begin(), segmentVehs.end());
1426 for (
auto veh : lane->getVehiclesSecure()) {
1427 result.push_back(veh);
1429 lane->releaseVehicles();
1447 if (segment->getCarNumber() > 0) {
1453 if (lane->getVehicleNumber() > 0) {
1467 wtime += segment->getWaitingSeconds();
1471 wtime += lane->getWaitingSeconds();
1493 sum += lane->getNettoOccupancy();
1495 return sum / (double)
myLanes->size();
1507 flow += (double) segment->getCarNumber() * segment->getMeanSpeed();
1509 return 3600 * flow / (*myLanes)[0]->getLength();
1520 occ += segment->getBruttoOccupancy();
1522 return occ / (*myLanes)[0]->getLength() / (double)(
myLanes->size());
1537 if (typeBefore !=
"") {
1539 if (typeBefore == typeAfter) {
1541 }
else if (typeAfter !=
"") {
1545 if (resBefore !=
nullptr && resAfter !=
nullptr) {
1549 for (
const auto& item : *resBefore) {
1551 const double speed = item.second;
1552 const auto it = (*resAfter).find(svc);
1553 if (it != (*resAfter).end()) {
1554 const double speed2 = it->second;
1556 ?
MAX2(speed, speed2) : (speed + speed2) / 2);
#define BEST_LANE_LOOKAHEAD
std::vector< const MSEdge * > ConstMSEdgeVector
std::vector< std::pair< const MSEdge *, const MSEdge * > > MSConstEdgePairVector
std::vector< MSEdge * > MSEdgeVector
#define WRITE_WARNINGF(...)
#define WRITE_ERRORF(...)
#define WRITE_WARNING(msg)
std::string time2string(SUMOTime t, bool humanReadable)
convert SUMOTime to string (independently of global format setting)
const SVCPermissions SVCAll
all VClasses are allowed
const SUMOVehicleClass SUMOVehicleClass_MAX
long long int SVCPermissions
bitset where each bit declares whether a certain SVC may use this edge/lane
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types.
@ SVC_PRIVATE
private vehicles
@ SVC_IGNORING
vehicles ignoring classes
@ SVC_PEDESTRIAN
pedestrian
@ RANDOM
The lane is chosen randomly.
@ BEST_FREE
The least occupied lane from best lanes.
@ GIVEN
The lane is given.
@ ALLOWED_FREE
The least occupied lane from lanes which allow the continuation.
@ DEFAULT
No information given; use default.
@ FIRST_ALLOWED
The rightmost lane the vehicle may use.
@ FREE
The least occupied lane is used.
@ RANDOM
A random position is chosen.
@ GIVEN
The position is given.
@ DEFAULT
No information given; use default.
@ FREE
A free position is chosen.
@ BASE
Back-at-zero position.
@ LAST
Insert behind the last vehicle as close as possible to still allow the specified departSpeed....
@ RANDOM_FREE
If a fixed number of random choices fails, a free position is chosen.
const int VEHPARS_SPEEDFACTOR_SET
@ GIVEN
The speed is given.
@ SPLIT
The departure is triggered by a train split.
@ CONTAINER_TRIGGERED
The departure is container triggered.
@ TRIGGERED
The departure is person triggered.
@ TURN
The link is a 180 degree turn.
@ STRAIGHT
The link is a straight direction.
SumoXMLEdgeFunc
Numbers representing special SUMO-XML-attribute values for representing edge functions used in netbui...
LinkState
The right-of-way state of a link between two lanes used when constructing a NBTrafficLightLogic,...
@ LINKSTATE_ALLWAY_STOP
This is an uncontrolled, all-way stop link.
@ LINKSTATE_STOP
This is an uncontrolled, minor link, has to stop.
@ LINKSTATE_EQUAL
This is an uncontrolled, right-before-left link.
@ LINKSTATE_DEADEND
This is a dead end link.
@ LINKSTATE_MINOR
This is an uncontrolled, minor link, has to brake.
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
void add(double x, double y, double z=0)
Makes the boundary include the given coordinate.
double distanceTo2D(const Position &p) const
returns the euclidean distance in the x-y-plane
std::vector< double > & getParameter()
Returns the parameters of this distribution.
void updateSegmentsForEdge(const MSEdge &e)
Update segments after loading meso edge type parameters from additional file.
MESegment * getSegmentForEdge(const MSEdge &e, double pos=0)
Get the segment for a given edge at a given position.
A single mesoscopic segment (cell)
bool initialise(MEVehicle *veh, SUMOTime time)
Inserts (emits) vehicle into the segment.
SUMOTime hasSpaceFor(const MEVehicle *const veh, const SUMOTime entryTime, int &qIdx, const bool init=false) const
Returns whether the given vehicle would still fit into the segment.
MESegment * getNextSegment() const
Returns the following segment on the same edge (0 if it is the last).
A vehicle from the mesoscopic point of view.
const SUMOVehicleParameter & getParameter() const
Returns the vehicle's parameter (including departure definition)
double getLength() const
Returns the vehicle's length.
const MSVehicleType & getVehicleType() const
Returns the vehicle's type definition.
const MSRoute & getRoute() const
Returns the current route.
Sorts edges by their ids.
Sorts transportables by their positions.
int operator()(const MSTransportable *const c1, const MSTransportable *const c2) const
comparing operator
A road/street connecting two junctions.
static const MSEdgeVector & getAllEdges()
Returns all edges with a numerical id.
SUMOVehicle * getWaitingVehicle(MSTransportable *transportable, const double position) const
void addToAllowed(const SVCPermissions permissions, std::shared_ptr< const std::vector< MSLane * > > allowedLanes, AllowedLanesCont &laneCont) const
void changeLanes(SUMOTime t) const
Performs lane changing on this edge.
double getBruttoOccupancy() const
SVCPermissions myCombinedPermissions
The union of lane permissions for this edge.
double getFlow() const
return flow based on meanSpead
Boundary myBoundary
The bounding rectangle of end nodes incoming or outgoing edges for taz connectors or of my own start ...
double myWidth
Edge width [m].
AllowedLanesByTarget myAllowedTargets
From target edge to lanes allowed to be used to reach it.
bool isCrossing() const
return whether this edge is a pedestrian crossing
MSLane * getDepartLane(MSVehicle &veh) const
Finds a depart lane for the given vehicle parameters.
SUMOTime myLastFailedInsertionTime
The time of last insertion failure.
std::set< MSTransportable *, ComparatorNumericalIdLess > myContainers
Containers on the edge.
static void clear()
Clears the dictionary.
void setJunctions(MSJunction *from, MSJunction *to)
double getMeanSpeedBike() const
get the mean speed of all bicycles on this edge
static MSEdgeVector myEdges
Static list of edges.
AllowedLanesCont myAllowed
Associative container from vehicle class to allowed-lanes.
const MSEdgeVector & getPredecessors() const
double myEmptyTraveltime
the traveltime on the empty edge (cached value for speedup)
void updateMesoType()
update meso segment parameters
bool myAmFringe
whether this edge is at the network fringe
static double getTravelTimeAggregated(const MSEdge *const edge, const SUMOVehicle *const veh, double time)
MSJunction * myToJunction
void checkAndRegisterBiDirEdge(const std::string &bidiID="")
check and register the opposite superposable edge if any
virtual ~MSEdge()
Destructor.
double getDepartPosBound(const MSVehicle &veh, bool upper=true) const
return upper bound for the depart position on this edge
const double myDistance
the kilometrage/mileage at the start of the edge
void clearState()
Remove all transportables before quick-loading state.
MSLane * getDepartLaneMeso(SUMOVehicle &veh) const
consider given departLane parameter (only for validating speeds)
bool hasTransientPermissions() const
const MSEdge * myBidiEdge
the oppositing superposable edge
MSLane * leftLane(const MSLane *const lane) const
Returns the lane left to the one given, 0 if the given lane is leftmost.
std::string myEdgeType
the type of the edge (optionally used during network creation)
const MSEdge * getOppositeEdge() const
Returns the opposite direction edge if on exists else a nullptr.
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.
double getLengthGeometryFactor() const
return shape.length() / myLength
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...
friend class MSLaneChangerSublane
std::vector< SUMOVehicle * > myWaiting
List of waiting vehicles.
const MSEdge * getNormalSuccessor() const
if this edge is an internal edge, return its first normal successor, otherwise the edge itself
void rebuildAllowedLanes(const bool onInit=false)
const std::vector< MSLane * > * allowedLanes(const MSEdge &destination, SUMOVehicleClass vclass=SVC_IGNORING, bool ignoreTransientPermissions=false) const
Get the allowed lanes to reach the destination-edge.
double getInternalFollowingLengthTo(const MSEdge *followerAfterInternal, SUMOVehicleClass vClass) const
returns the length of all internal edges on the junction until reaching the non-internal edge followe...
bool isNormal() const
return whether this edge is an internal edge
std::vector< MSTransportable * > getSortedPersons(SUMOTime timestep, bool includeRiding=false) const
Returns this edge's persons sorted by pos.
bool isSuperposable(const MSEdge *other)
bool validateDepartSpeed(SUMOVehicle &v) const
check whether the given departSpeed is valid for this edge
double getDistanceTo(const MSEdge *other, const bool doBoundaryEstimate=false) const
optimistic air distance heuristic for use in routing
void setMaxSpeed(double val, double jamThreshold=-1)
Sets a new maximum speed for all lanes (used by TraCI and MSCalibrator)
static MSEdge * dictionaryHint(const std::string &id, const int startIdx)
Returns the MSEdge associated to the key id giving a hint with a numerical id.
MSLaneChanger * myLaneChanger
This member will do the lane-change.
const std::vector< MSLane * > & getLanes() const
Returns this edge's lanes.
double getOccupancy() const
return mean occupancy on this edges lanes or segments
const MSConstEdgePairVector & getViaSuccessors(SUMOVehicleClass vClass=SVC_IGNORING, bool ignoreTransientPermissions=false) const
Returns the following edges with internal vias, restricted by vClass.
std::vector< MSTransportable * > getSortedContainers(SUMOTime timestep, bool includeRiding=false) const
Returns this edge's containers sorted by pos.
const SumoXMLEdgeFunc myFunction
the purpose of the edge
void recalcCache()
Recalculates the cached values.
double getSpeedLimit() const
Returns the speed limit of the edge @caution The speed limit of the first lane is retured; should pro...
SVCPermissions myOriginalCombinedPermissions
The original union of lane permissions for this edge (before temporary modifications)
const MSJunction * getFromJunction() const
bool myAmDelayed
whether this edge had a vehicle with less than max speed on it
SVCPermissions myOriginalMinimumPermissions
The original intersection of lane permissions for this edge (before temporary modifications)
std::map< SUMOVehicleClass, MSEdgeVector > myClassesSuccessorMap
The successors available for a given vClass.
SUMOTime decVaporization(SUMOTime t)
Disables vaporization.
MSEdgeVector myPredecessors
The preceeding edges.
void rebuildAllowedTargets(const bool updateVehicles=true)
static SVCPermissions myMesoIgnoredVClasses
std::vector< std::pair< SVCPermissions, std::shared_ptr< const std::vector< MSLane * > > > > AllowedLanesCont
"Map" from vehicle class to allowed lanes
double getLength() const
return the length of the edge
void initialize(const std::vector< MSLane * > *lanes)
Initialize the edge.
bool myHaveTransientPermissions
whether transient permission changes were applied to this edge or a predecessor
virtual void closeBuilding()
static SVCPermissions getMesoPermissions(SVCPermissions p, SVCPermissions ignoreIgnored=0)
bool canChangeToOpposite() const
whether this edge allows changing to the opposite direction edge
std::set< int > myFailedInsertionMemory
A cache for the rejected insertion attempts. Used to assure that no further insertion attempts are ma...
double getMeanSpeed() const
get the mean speed
static DictType myDict
Static dictionary to associate string-ids with objects.
std::set< MSTransportable *, ComparatorNumericalIdLess > myPersons
Persons on the edge for drawing and pushbutton.
bool isTazConnector() const
double getDistanceAt(double pos) const
Returns the kilometrage/mileage at the given offset along the edge.
MSConstEdgePairVector myViaSuccessors
MSEdgeVector mySuccessors
The succeeding edges.
bool isInternal() const
return whether this edge is an internal edge
MSLane * rightLane(const MSLane *const lane) const
Returns the lane right to the one given, 0 if the given lane is rightmost.
double getCurrentTravelTime(const double minSpeed=NUMERICAL_EPS) const
Computes and returns the current travel time for this edge.
std::map< SUMOVehicleClass, MSConstEdgePairVector > myOrigClassesViaSuccessorMap
AllowedLanesByTarget myOrigAllowedTargets
int getNumericalID() const
Returns the numerical id of the edge.
void resetTAZ(MSJunction *junction)
bool isVaporizing() const
Returns whether vehicles on this edge shall be vaporized.
bool insertVehicle(SUMOVehicle &v, SUMOTime time, const bool checkOnly=false, const bool forceCheck=false) const
Tries to insert the given vehicle into the network.
static const Position getStopPosition(const SUMOVehicleParameter::Stop &stop)
return the coordinates of the center of the given stop
void addWaiting(SUMOVehicle *vehicle) const
Adds a vehicle to the list of waiting vehicles.
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.
ReversedEdge< MSEdge, SUMOVehicle > * myReversedRoutingEdge
a reversed version for backward routing
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< const SUMOVehicle * > getVehicles() const
return vehicles on this edges lanes or segments
static void insertIDs(std::vector< std::string > &into)
Inserts IDs of all known edges into the given vector.
double getVehicleMaxSpeed(const SUMOTrafficObject *const veh) const
Returns the maximum speed the vehicle may use on this edge.
SUMOTime incVaporization(SUMOTime t)
Enables vaporization.
MSJunction * myFromJunction
the junctions for this edge
double getMeanFriction() const
get the mean friction over the lanes
std::map< std::string, MSEdge * > DictType
definition of the static dictionary type
bool hasMinorLink() const
whether any lane has a minor link
std::map< SUMOVehicleClass, MSConstEdgePairVector > myClassesViaSuccessorMap
The successors available for a given vClass.
const MSEdge * getNormalBefore() const
if this edge is an internal edge, return its first normal predecessor, otherwise the edge itself
int getVehicleNumber() const
return total number of vehicles on this edges lanes or segments
const std::string & getEdgeType() const
Returns the type of the edge.
virtual void removeTransportable(MSTransportable *t) const
const MSJunction * getToJunction() const
SumoXMLEdgeFunc getFunction() const
Returns the edge type (SumoXMLEdgeFunc)
bool allowsLaneChanging() const
bool isEmpty() const
whether this edge has no vehicles
MSEdge(const std::string &id, int numericalID, const SumoXMLEdgeFunc function, const std::string &streetName, const std::string &edgeType, int priority, double distance)
Constructor.
const MSEdge * getInternalFollowingEdge(const MSEdge *followerAfterInternal, SUMOVehicleClass vClass) const
void buildLaneChanger()
Has to be called after all sucessors and predecessors have been set (after closeBuilding())
double getRoutingSpeed() const
Returns the averaged speed used by the routing device.
virtual void lock() const
grant exclusive access to the mesoscopic state
void removeWaiting(const SUMOVehicle *vehicle) const
Removes a vehicle from the list of waiting vehicles.
std::vector< double > mySublaneSides
the right side for each sublane on this edge
const MSEdgeVector & getSuccessors(SUMOVehicleClass vClass=SVC_IGNORING) const
Returns the following edges, restricted by vClass.
std::shared_ptr< const std::vector< MSLane * > > myLanes
Container for the edge's lane; should be sorted: (right-hand-traffic) the more left the lane,...
AllowedLanesCont myOrigAllowed
double getWaitingSeconds() const
return accumated waiting time for all vehicles on this edges lanes or segments
int myVaporizationRequests
Vaporizer counter.
double myTimePenalty
flat penalty when computing traveltime
SVCPermissions myMinimumPermissions
The intersection of lane permissions for this edge.
MSLane * getFreeLane(const std::vector< MSLane * > *allowed, const SUMOVehicleClass vclass, double departPos) const
Finds the emptiest lane allowing the vehicle class.
virtual void addTransportable(MSTransportable *t) const
RailEdge< MSEdge, SUMOVehicle > * myRailwayRoutingEdge
double myLength
the length of the edge (cached value for speedup)
static double gStopTolerance
The tolerance to apply when matching waiting persons and vehicles.
static double gMinorPenalty
(minimum) time penalty for passing a minor link when routing
static double gTLSPenalty
scaled (minimum) time penalty for passing a tls link when routing
static MELoop * gMesoNet
mesoscopic simulation infrastructure
static double gLateralResolution
static int gNumSimThreads
how many threads to use for simulation
static SUMOTime gLaneChangeDuration
static bool gUsingInternalLanes
Information whether the simulation regards internal lanes.
static int gNumThreads
how many threads to use
The base class for an intersection.
const ConstMSEdgeVector & getIncoming() const
const ConstMSEdgeVector & getOutgoing() const
const Position & getPosition(bool secondaryShape=false) const
Performs lane changing of vehicles.
void laneChange(SUMOTime t)
Start lane-change-process for all vehicles on the edge'e lanes.
Representation of a lane in the micro simulation.
bool insertVehicle(MSVehicle &v)
Tries to insert the given vehicle.
std::vector< MSVehicle * > VehCont
Container for vehicles.
double getVehicleMaxSpeed(const SUMOTrafficObject *const veh) const
Returns the lane's maximum speed, given a vehicle's speed limit adaptation.
int getIndex() const
Returns the lane's index.
double getBruttoOccupancy() const
Returns the brutto (including minGaps) occupancy of this lane during the last step.
static bool dictionary(const std::string &id, MSLane *lane)
Static (sic!) container methods {.
MSEdge & getEdge() const
Returns the lane's edge.
double getWidth() const
Returns the lane's width.
virtual const PositionVector & getShape(bool) const
LinkState getState() const
Returns the current state of the link.
bool isTLSControlled() const
bool havePriority() const
Returns whether this link is a major link.
The simulated network and simulation perfomer.
static MSNet * getInstance()
Returns the pointer to the unique instance of MSNet (singleton).
bool hasJunctionHigherSpeeds() const
return whether the network was built with higher junction speeds
const std::map< SUMOVehicleClass, double > * getRestrictions(const std::string &id) const
Returns the restrictions for an edge type If no restrictions are present, 0 is returned.
void addRestriction(const std::string &id, const SUMOVehicleClass svc, const double speed)
Adds a restriction for an edge type.
const MESegment::MesoEdgeType & getMesoType(const std::string &typeID)
Returns edge type specific meso parameters if no type specific parameters have been loaded,...
int size() const
Returns the number of edges to pass.
MSRouteIterator begin() const
Returns the begin of the list of edges to pass.
static double getAssumedSpeed(const MSEdge *edge, const SUMOVehicle *veh)
return current travel speed assumption
virtual double getEdgePos(SUMOTime now) const
bool isPerson() const
Whether it is a person.
MSStage * getCurrentStage() const
Return the current stage.
bool isWaitingFor(const SUMOVehicle *vehicle) const
Whether the transportable waits for the given vehicle in the current step.
Representation of a vehicle in the micro simulation.
void updateBestLanes(bool forceRebuild=false, const MSLane *startLane=0)
computes the best lanes to use in order to continue the route
const std::vector< LaneQ > & getBestLanes() const
Returns the description of best lanes to use in order to continue the route.
double getPositionOnLane() const
Get the vehicle's position along the lane.
The car-following model and parameter.
double getLengthWithGap() const
Get vehicle's length including the minimum gap [m].
SUMOVehicleClass getVehicleClass() const
Get this vehicle type's vehicle class.
const Distribution_Parameterized & getSpeedFactor() const
Returns this type's speed factor.
double getLength() const
Get vehicle's length [m].
double computeChosenSpeedDeviation(SumoRNG *rng, const double minDev=-1.) const
Computes and returns the speed deviation.
Base class for objects which have an id.
const std::string & getID() const
Returns the id.
bool hasParameter(const std::string &key) const
Returns whether the parameter is set.
A point in 2D or 3D with translation and scaling methods.
static const T & getRandomFrom(const std::vector< T > &v, SumoRNG *rng=nullptr)
Returns a random element from the given vector.
static double rand(SumoRNG *rng=nullptr)
Returns a random real number in [0, 1)
Representation of a vehicle, person, or container.
virtual double getChosenSpeedFactor() const =0
virtual double getMaxSpeed() const =0
Returns the object's maximum speed (minimum of technical and desired maximum speed)
virtual const MSVehicleType & getVehicleType() const =0
Returns the object's "vehicle" type.
virtual const SUMOVehicleParameter & getParameter() const =0
Returns the vehicle's parameter (including departure definition)
Representation of a vehicle.
virtual int getRouteValidity(bool update=true, bool silent=false, std::string *msgReturn=nullptr)=0
computes validity attributes for the current route
virtual void setChosenSpeedFactor(const double factor)=0
Definition of vehicle stop (position and duration)
std::string lane
The lane to stop at.
double startPos
The stopping position start.
double endPos
The stopping position end.
Structure representing possible vehicle parameter.
int departLane
(optional) The lane the vehicle shall depart from (index in edge)
double departSpeed
(optional) The initial speed of the vehicle
DepartLaneDefinition departLaneProcedure
Information how the vehicle shall choose the lane to depart from.
double departPos
(optional) The position the vehicle shall depart from
DepartSpeedDefinition departSpeedProcedure
Information how the vehicle's initial speed shall be chosen.
std::string id
The vehicle's id.
bool wasSet(int what) const
Returns whether the given parameter was set.
DepartDefinition departProcedure
Information how the vehicle shall choose the depart time.
DepartPosDefinition departPosProcedure
Information how the vehicle shall choose the departure position.
A scoped lock which only triggers on condition.
std::vector< std::string > getVector()
return vector of strings
edge type specific meso parameters