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;
186 if (!edge->isInternal()) {
190 auto it = std::find(succ.begin(), succ.end(),
this);
191 auto it2 = std::find(succVia.begin(), succVia.end(), std::make_pair(
const_cast<const MSEdge*
>(
this), (
const MSEdge*)
nullptr));
192 auto it3 = std::find(pred.begin(), pred.end(),
this);
193 if (it != succ.end()) {
197 if (it3 != pred.end()) {
207 for (
MSLink*
const link : lane->getLinkCont()) {
208 link->initParallelLinks();
209 MSLane*
const toL = link->getLane();
210 MSLane*
const viaL = link->getViaLane();
211 if (toL !=
nullptr) {
224 if (viaL !=
nullptr) {
231 lane->checkBufferType();
238 if (
myLanes->back()->getOpposite() !=
nullptr) {
283 const MSLink*
const link = lane->getLogicalPredecessorLane()->getLinkTo(lane);
284 assert(link !=
nullptr);
303 for (
auto& allowed : laneCont) {
305 allowed.first |= permissions;
309 laneCont.push_back(std::make_pair(permissions,
allowedLanes));
317 return (p | ignored) == ignored ? 0 : p;
326 bool lanesChangedPermission =
false;
334 lanesChangedPermission |= lane->hadPermissionChanges();
349 std::shared_ptr<std::vector<MSLane*> >
allowedLanes = std::make_shared<std::vector<MSLane*> >();
366 pred->myOrigAllowed = pred->myAllowed;
367 pred->myOrigAllowedTargets = pred->myAllowedTargets;
368 pred->myOrigClassesViaSuccessorMap = pred->myClassesViaSuccessorMap;
369 pred->myHaveTransientPermissions =
true;
371 pred->rebuildAllowedTargets(
false);
375 s->updatePermissions();
386 bool universalMap =
true;
387 std::shared_ptr<std::vector<MSLane*> > allLanes = std::make_shared<std::vector<MSLane*> >();
391 for (
const MSLink*
const link : lane->getLinkCont()) {
392 if (&link->getLane()->getEdge() == target) {
393 allLanes->push_back(lane);
394 combinedTargetPermissions |= link->getLane()->getPermissions();
395 if (link->getViaLane() !=
nullptr &&
396 ((lane->getPermissions() & link->getLane()->getPermissions()) != link->getViaLane()->getPermissions())) {
398 universalMap =
false;
402 if (combinedTargetPermissions == 0 || (lane->getPermissions() & combinedTargetPermissions) != lane->getPermissions()) {
403 universalMap =
false;
420 std::shared_ptr<std::vector<MSLane*> >
allowedLanes = std::make_shared<std::vector<MSLane*> >();
423 for (
const MSLink*
const link : lane->getLinkCont()) {
424 if (link->getLane()->allowsVehicleClass((
SUMOVehicleClass)vclass) && &link->getLane()->getEdge() == target && (link->getViaLane() ==
nullptr || link->getViaLane()->allowsVehicleClass((
SUMOVehicleClass)vclass))) {
435 if (updateVehicles) {
439 veh->updateBestLanes(
true);
441 lane->releaseVehicles();
463 const int resultIndex = lane->
getIndex() + offset;
464 if (resultIndex >=
getNumLanes() && includeOpposite) {
470 }
else if (resultIndex >= (
int)
myLanes->size() || resultIndex < 0) {
473 return (*
myLanes)[resultIndex];
478 const std::vector<MSLane*>*
481 AllowedLanesByTarget::const_iterator i = targets.find(&destination);
482 if (i != targets.end()) {
483 for (
const auto& allowed : i->second) {
484 if ((allowed.first & vclass) == vclass) {
485 return allowed.second.get();
493 const std::vector<MSLane*>*
500 if ((allowed.first & vclass) == vclass) {
501 return allowed.second.get();
527 if (allowed ==
nullptr) {
531 if (allowed !=
nullptr) {
532 double largestGap = 0;
533 MSLane* resByGap =
nullptr;
534 double leastOccupancy = std::numeric_limits<double>::max();
535 for (std::vector<MSLane*>::const_iterator i = allowed->begin(); i != allowed->end(); ++i) {
536 const double occupancy = (*i)->getBruttoOccupancy();
537 if (occupancy < leastOccupancy) {
539 leastOccupancy = occupancy;
541 const MSVehicle* last = (*i)->getLastFullVehicle();
543 if (lastGap > largestGap) {
544 largestGap = lastGap;
548 if (resByGap !=
nullptr) {
581 for (std::vector<MSLane*>::const_iterator i =
myLanes->begin(); i !=
myLanes->end(); ++i) {
582 MSVehicle* last = (*i)->getLastFullVehicle();
583 if (last !=
nullptr) {
635 const std::vector<MSVehicle::LaneQ>& bl = veh.
getBestLanes();
636 double bestLength = -1;
637 for (std::vector<MSVehicle::LaneQ>::const_iterator i = bl.begin(); i != bl.end(); ++i) {
638 if ((*i).length > bestLength) {
639 bestLength = (*i).length;
645 double departPos = 0;
650 std::vector<MSLane*>* bestLanes =
new std::vector<MSLane*>();
651 for (std::vector<MSVehicle::LaneQ>::const_iterator i = bl.begin(); i != bl.end(); ++i) {
652 if (((*i).length - departPos) >= bestLength) {
653 bestLanes->push_back((*i).lane);
675 for (std::vector<MSLane*>::const_iterator i =
myLanes->begin(); i !=
myLanes->end(); ++i) {
676 if ((*i)->allowsVehicleClass(vClass)) {
680 return defaultFirst && !
myLanes->empty() ?
myLanes->front() :
nullptr;
694 if (departLane !=
nullptr) {
698 vMax *= (1 + SPEED_EPS);
704 if (speedFactorParams[1] > 0.) {
708 WRITE_WARNINGF(
TL(
"Choosing new speed factor % for vehicle '%' to match departure speed % (max %)."),
731 const std::string errorMsg =
"Departure speed for vehicle '" + pars.
id +
"' is too high for the departure edge '" +
getID() +
"'.";
752 v.
getID() +
"'. Inserting at lane end instead.");
768 while (segment !=
nullptr && !result) {
770 result = segment->
hasSpaceFor(veh, time, qIdx,
true) == time;
778 result = segment->
hasSpaceFor(veh, time, qIdx,
true) == time;
791 if (insertionLane ==
nullptr) {
800 for (std::vector<MSLane*>::const_iterator i =
myLanes->begin(); i !=
myLanes->end(); ++i) {
801 const double occupancy = (*i)->getBruttoOccupancy();
811 if (insertionLane ==
nullptr) {
851 for (
const MSLink*
const link : l->getLinkCont()) {
852 if (&link->getLane()->getEdge() == followerAfterInternal) {
853 if (link->getViaLane() !=
nullptr) {
854 if (link->getViaLane()->allowsVehicleClass(vClass)) {
855 return &link->getViaLane()->getEdge();
871 assert(followerAfterInternal != 0);
876 while (edge !=
nullptr && edge->
isInternal()) {
886 const MSEdge* result =
this;
896 const MSEdge* result =
this;
907 double totalNumVehs = 0;
910 const int numVehs = segment->getCarNumber();
912 v += numVehs * segment->getMeanSpeed();
913 totalNumVehs += numVehs;
916 if (totalNumVehs == 0) {
921 int numVehs = lane->getVehicleNumber();
926 v += numVehs * lane->getMeanSpeed();
927 totalNumVehs += numVehs;
931 if (lane->getVehicleNumber() > 0) {
937 if (totalNumVehs == 0) {
941 return v / totalNumVehs;
949 f += lane->getFrictionCoefficient();
952 return f / (double)
myLanes->size();
965 double totalNumVehs = 0;
967 const int numVehs = lane->getVehicleNumber();
968 v += numVehs * lane->getMeanSpeedBike();
969 totalNumVehs += numVehs;
971 if (totalNumVehs == 0) {
974 return v / totalNumVehs;
980 assert(minSpeed > 0);
996 const DictType::iterator it =
myDict.lower_bound(
id);
997 if (it ==
myDict.end() || it->first !=
id) {
999 myDict.emplace_hint(it,
id, ptr);
1012 const DictType::iterator it =
myDict.find(
id);
1013 if (it ==
myDict.end()) {
1026 if (startIdx + 1 < (
int)
myEdges.size() &&
myEdges[startIdx + 1] !=
nullptr &&
myEdges[startIdx + 1]->getID() ==
id) {
1041 for (DictType::iterator i =
myDict.begin(); i !=
myDict.end(); ++i) {
1051 for (DictType::iterator i =
myDict.begin(); i !=
myDict.end(); ++i) {
1052 into.push_back((*i).first);
1059 const std::string& rid) {
1067 const std::string& rid) {
1068 for (std::vector<std::string>::const_iterator i = desc.begin(); i != desc.end(); ++i) {
1071 if (edge ==
nullptr) {
1072 throw ProcessError(
"The edge '" + *i +
"' within the route " + rid +
" is not known."
1073 +
"\n The route can not be build.");
1075 into.push_back(edge);
1082 assert(
this != other);
1083 if (doBoundaryEstimate) {
1095 return getLanes()[0]->getShape()[-1].distanceTo2D(other->
getLanes()[0]->getShape()[0]);
1114 return myLanes->empty() ? 1 :
getLanes()[0]->getLengthGeometryFactor();
1128 for (std::vector<MSLane*>::const_iterator i =
myLanes->begin(); i !=
myLanes->end(); ++i) {
1129 (*i)->setMaxSpeed(val,
false,
false, jamThreshold);
1147 auto it = tc.find(t);
1148 if (it != tc.end()) {
1153 std::vector<MSTransportable*>
1156 if (includeRiding) {
1157 for (std::vector<MSLane*>::const_iterator i =
myLanes->begin(); i !=
myLanes->end(); ++i) {
1159 for (MSLane::VehCont::const_iterator j = vehs.begin(); j != vehs.end(); ++j) {
1160 const std::vector<MSTransportable*>& persons = (*j)->getPersons();
1161 result.insert(result.end(), persons.begin(), persons.end());
1163 (*i)->releaseVehicles();
1171 std::vector<MSTransportable*>
1220 if ((*it)->isTazConnector()) {
1221 i->second.push_back(*it);
1223 const std::vector<MSLane*>* allowed =
allowedLanes(**it, vClass);
1224 if (allowed !=
nullptr && allowed->size() > 0) {
1225 i->second.push_back(*it);
1244 auto i = viaMap.find(vClass);
1245 if (i != viaMap.end()) {
1253 if (viaPair.first->isTazConnector()) {
1254 result.push_back(viaPair);
1256 const std::vector<MSLane*>* allowed =
allowedLanes(*viaPair.first, vClass, ignoreTransientPermissions);
1257 if (allowed !=
nullptr && allowed->size() > 0) {
1258 result.push_back(viaPair);
1279 return (!
myLanes->empty() &&
myLanes->back()->getOpposite() !=
nullptr &&
1289 if (!
myLanes->empty() &&
myLanes->back()->getOpposite() !=
nullptr) {
1290 return &(
myLanes->back()->getOpposite()->getEdge());
1300 for (
const MSLink*
const link : l->getLinkCont()) {
1301 if (!link->havePriority()) {
1315 if (l->getIndex() <= index && !l->allowsChangingRight(svc) && l->getIndex() > 0) {
1317 }
else if (l->getIndex() >= index && !l->allowsChangingLeft(svc) && l->getIndex() < (
int)(
myLanes->size() - 1)) {
1339 for (ConstMSEdgeVector::const_iterator it = candidates.begin(); it != candidates.end(); it++) {
1362 int numBidiLanes = 0;
1365 if (l1->getShape().reverse().almostSame(l2->
getShape(), POSITION_EPS * 2)) {
1366 l1->setBidiLane(l2);
1381 if (other ==
nullptr || other->
getLanes().size() !=
myLanes->size()) {
1384 std::vector<MSLane*>::const_iterator it1 =
myLanes->begin();
1385 std::vector<MSLane*>::const_reverse_iterator it2 = other->
getLanes().rbegin();
1387 if ((*it1)->getShape().reverse() != (*it2)->getShape()) {
1392 }
while (it1 !=
myLanes->end());
1412 std::vector<SUMOVehicle*>::iterator it = std::find(
myWaiting.begin(),
myWaiting.end(), vehicle);
1427 (!vehicle->hasDeparted() &&
1432 if (!vehicle->isLineStop(position) && vehicle->allowsBoarding(transportable)) {
1434 + transportable->
getID() +
"' at edge '" +
getID() +
"' position " +
toString(position) +
" cannot use waiting vehicle '"
1435 + vehicle->getID() +
"' at position " +
toString(vehicle->getPositionOnLane()) +
" because it is too far away.");
1442 std::vector<const SUMOVehicle*>
1444 std::vector<const SUMOVehicle*> result;
1447 std::vector<const MEVehicle*> segmentVehs = segment->getVehicles();
1448 result.insert(result.end(), segmentVehs.begin(), segmentVehs.end());
1452 for (
auto veh : lane->getVehiclesSecure()) {
1453 result.push_back(veh);
1455 lane->releaseVehicles();
1472 if ((l->getPermissions() & filter) != 0) {
1490 if (segment->getCarNumber() > 0) {
1496 if (lane->getVehicleNumber() > 0) {
1510 wtime += segment->getWaitingSeconds();
1514 wtime += lane->getWaitingSeconds();
1536 sum += lane->getNettoOccupancy();
1538 return sum / (double)
myLanes->size();
1550 flow += (double) segment->getCarNumber() * segment->getMeanSpeed();
1552 return 3600 * flow / (*myLanes)[0]->getLength();
1563 occ += segment->getBruttoOccupancy();
1565 return occ / (*myLanes)[0]->getLength() / (double)(
myLanes->size());
1580 if (typeBefore !=
"") {
1582 if (typeBefore == typeAfter) {
1584 }
else if (typeAfter !=
"") {
1588 if (resBefore !=
nullptr && resAfter !=
nullptr) {
1592 for (
const auto& item : *resBefore) {
1594 const double speed = item.second;
1595 const auto it = (*resAfter).find(svc);
1596 if (it != (*resAfter).end()) {
1597 const double speed2 = it->second;
1599 ?
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)
int getNumDrivingLanes() const
return the number of lanes that permit non-weak modes if the edge allows non weak modes and the numbe...
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.
bool hasChangeProhibitions(SUMOVehicleClass svc, int index) const
return whether this edge prohibits changing for the given vClass when starting on the given lane inde...
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.
MSLane * getFirstAllowed(SUMOVehicleClass vClass, bool defaultFirst=false) const
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 double gTurnaroundPenalty
(minimum) time penalty for passing a turnaround 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.
bool isTurnaround() const
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