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 myOtherTazConnector(nullptr),
78 myStreetName(streetName),
84 myEmptyTraveltime(0.),
87 myAmRoundabout(false),
103 myLanes = std::shared_ptr<const std::vector<MSLane*> >(lanes);
107 for (
MSLane*
const lane : *lanes) {
132 if (haveTLSPenalty || minorPenalty > 0) {
136 for (
const MSLink*
const link : l->getLinkCont()) {
137 SUMOTime linkPenalty = link->isTLSControlled() ? link->getMesoTLSPenalty() : (link->havePriority() ? 0 : minorPenalty);
138 if (minPenalty == -1) {
139 minPenalty = linkPenalty;
141 minPenalty =
MIN2(minPenalty, linkPenalty);
145 if (minPenalty > 0) {
152 const MSLink* link =
myLanes->front()->getIncomingLanes()[0].viaLink;
166 if (!edge->isInternal()) {
170 auto it = std::find(succ.begin(), succ.end(),
this);
171 auto it2 = std::find(succVia.begin(), succVia.end(), std::make_pair(
const_cast<const MSEdge*
>(
this), (
const MSEdge*)
nullptr));
172 auto it3 = std::find(pred.begin(), pred.end(),
this);
173 if (it != succ.end()) {
177 if (it3 != pred.end()) {
187 for (
MSLink*
const link : lane->getLinkCont()) {
188 link->initParallelLinks();
189 MSLane*
const toL = link->getLane();
190 MSLane*
const viaL = link->getViaLane();
191 if (toL !=
nullptr) {
204 if (viaL !=
nullptr) {
211 lane->checkBufferType();
218 if (
myLanes->back()->getOpposite() !=
nullptr) {
261 const MSLink*
const link = lane->getLogicalPredecessorLane()->getLinkTo(lane);
262 assert(link !=
nullptr);
281 for (
auto& allowed : laneCont) {
283 allowed.first |= permissions;
287 laneCont.push_back(std::make_pair(permissions,
allowedLanes));
295 return (p | ignored) == ignored ? 0 : p;
318 std::shared_ptr<std::vector<MSLane*> >
allowedLanes = std::make_shared<std::vector<MSLane*> >();
331 pred->rebuildAllowedTargets(
false);
335 s->updatePermissions();
346 bool universalMap =
true;
347 std::shared_ptr<std::vector<MSLane*> > allLanes = std::make_shared<std::vector<MSLane*> >();
351 for (
const MSLink*
const link : lane->getLinkCont()) {
352 if (&link->getLane()->getEdge() == target) {
353 allLanes->push_back(lane);
354 combinedTargetPermissions |= link->getLane()->getPermissions();
355 if (link->getViaLane() !=
nullptr &&
356 ((lane->getPermissions() & link->getLane()->getPermissions()) != link->getViaLane()->getPermissions())) {
358 universalMap =
false;
362 if (combinedTargetPermissions == 0 || (lane->getPermissions() & combinedTargetPermissions) != lane->getPermissions()) {
363 universalMap =
false;
380 std::shared_ptr<std::vector<MSLane*> >
allowedLanes = std::make_shared<std::vector<MSLane*> >();
383 for (
const MSLink*
const link : lane->getLinkCont()) {
384 if (link->getLane()->allowsVehicleClass((
SUMOVehicleClass)vclass) && &link->getLane()->getEdge() == target && (link->getViaLane() ==
nullptr || link->getViaLane()->allowsVehicleClass((
SUMOVehicleClass)vclass))) {
395 if (updateVehicles) {
399 veh->updateBestLanes(
true);
401 lane->releaseVehicles();
423 const int resultIndex = lane->
getIndex() + offset;
424 if (resultIndex >=
getNumLanes() && includeOpposite) {
430 }
else if (resultIndex >= (
int)
myLanes->size() || resultIndex < 0) {
433 return (*
myLanes)[resultIndex];
438const std::vector<MSLane*>*
440 AllowedLanesByTarget::const_iterator i =
myAllowedTargets.find(&destination);
442 for (
const auto& allowed : i->second) {
443 if ((allowed.first & vclass) == vclass) {
444 return allowed.second.get();
452const std::vector<MSLane*>*
459 if ((allowed.first & vclass) == vclass) {
460 return allowed.second.get();
486 if (allowed ==
nullptr) {
490 if (allowed !=
nullptr) {
491 double largestGap = 0;
492 MSLane* resByGap =
nullptr;
493 double leastOccupancy = std::numeric_limits<double>::max();
494 for (std::vector<MSLane*>::const_iterator i = allowed->begin(); i != allowed->end(); ++i) {
495 const double occupancy = (*i)->getBruttoOccupancy();
496 if (occupancy < leastOccupancy) {
498 leastOccupancy = occupancy;
500 const MSVehicle* last = (*i)->getLastFullVehicle();
502 if (lastGap > largestGap) {
503 largestGap = lastGap;
507 if (resByGap !=
nullptr) {
540 for (std::vector<MSLane*>::const_iterator i =
myLanes->begin(); i !=
myLanes->end(); ++i) {
541 MSVehicle* last = (*i)->getLastFullVehicle();
542 if (last !=
nullptr) {
594 const std::vector<MSVehicle::LaneQ>& bl = veh.
getBestLanes();
595 double bestLength = -1;
596 for (std::vector<MSVehicle::LaneQ>::const_iterator i = bl.begin(); i != bl.end(); ++i) {
597 if ((*i).length > bestLength) {
598 bestLength = (*i).length;
604 double departPos = 0;
609 std::vector<MSLane*>* bestLanes =
new std::vector<MSLane*>();
610 for (std::vector<MSVehicle::LaneQ>::const_iterator i = bl.begin(); i != bl.end(); ++i) {
611 if (((*i).length - departPos) >= bestLength) {
612 bestLanes->push_back((*i).lane);
621 for (std::vector<MSLane*>::const_iterator i =
myLanes->begin(); i !=
myLanes->end(); ++i) {
646 if (departLane !=
nullptr) {
650 vMax *= (1 + SPEED_EPS);
656 if (speedFactorParams[1] > 0.) {
660 WRITE_WARNINGF(
TL(
"Choosing new speed factor % for vehicle '%' to match departure speed % (max %)."),
683 const std::string errorMsg =
"Departure speed for vehicle '" + pars.
id +
"' is too high for the departure edge '" +
getID() +
"'.";
704 v.
getID() +
"'. Inserting at lane end instead.");
720 while (segment !=
nullptr && !result) {
722 result = segment->
hasSpaceFor(veh, time, qIdx,
true) == time;
730 result = segment->
hasSpaceFor(veh, time, qIdx,
true) == time;
743 if (insertionLane ==
nullptr) {
751 for (std::vector<MSLane*>::const_iterator i =
myLanes->begin(); i !=
myLanes->end(); ++i) {
752 const double occupancy = (*i)->getBruttoOccupancy();
761 if (insertionLane ==
nullptr) {
801 for (
const MSLink*
const link : l->getLinkCont()) {
802 if (&link->getLane()->getEdge() == followerAfterInternal) {
803 if (link->getViaLane() !=
nullptr) {
804 if (link->getViaLane()->allowsVehicleClass(vClass)) {
805 return &link->getViaLane()->getEdge();
821 assert(followerAfterInternal != 0);
826 while (edge !=
nullptr && edge->
isInternal()) {
836 const MSEdge* result =
this;
846 const MSEdge* result =
this;
857 double totalNumVehs = 0;
860 const int numVehs = segment->getCarNumber();
863 totalNumVehs += numVehs;
866 if (totalNumVehs == 0) {
871 int numVehs = lane->getVehicleNumber();
876 v += numVehs * lane->getMeanSpeed();
877 totalNumVehs += numVehs;
881 if (lane->getVehicleNumber() > 0) {
887 if (totalNumVehs == 0) {
891 return v / totalNumVehs;
899 f += lane->getFrictionCoefficient();
902 return f / (double)
myLanes->size();
915 double totalNumVehs = 0;
917 const int numVehs = lane->getVehicleNumber();
918 v += numVehs * lane->getMeanSpeedBike();
919 totalNumVehs += numVehs;
921 if (totalNumVehs == 0) {
924 return v / totalNumVehs;
930 assert(minSpeed > 0);
946 const DictType::iterator it =
myDict.lower_bound(
id);
947 if (it ==
myDict.end() || it->first !=
id) {
949 myDict.emplace_hint(it,
id, ptr);
962 const DictType::iterator it =
myDict.find(
id);
976 if (startIdx + 1 < (
int)
myEdges.size() &&
myEdges[startIdx + 1] !=
nullptr &&
myEdges[startIdx + 1]->getID() ==
id) {
991 for (DictType::iterator i =
myDict.begin(); i !=
myDict.end(); ++i) {
1001 for (DictType::iterator i =
myDict.begin(); i !=
myDict.end(); ++i) {
1002 into.push_back((*i).first);
1009 const std::string& rid) {
1017 const std::string& rid) {
1018 for (std::vector<std::string>::const_iterator i = desc.begin(); i != desc.end(); ++i) {
1021 if (edge ==
nullptr) {
1022 throw ProcessError(
"The edge '" + *i +
"' within the route " + rid +
" is not known."
1023 +
"\n The route can not be build.");
1025 into.push_back(edge);
1032 assert(
this != other);
1033 if (doBoundaryEstimate) {
1045 return getLanes()[0]->getShape()[-1].distanceTo2D(other->
getLanes()[0]->getShape()[0]);
1064 return myLanes->empty() ? 1 :
getLanes()[0]->getLengthGeometryFactor();
1078 for (std::vector<MSLane*>::const_iterator i =
myLanes->begin(); i !=
myLanes->end(); ++i) {
1079 (*i)->setMaxSpeed(val);
1097 auto it = tc.find(t);
1098 if (it != tc.end()) {
1103std::vector<MSTransportable*>
1106 if (includeRiding) {
1107 for (std::vector<MSLane*>::const_iterator i =
myLanes->begin(); i !=
myLanes->end(); ++i) {
1109 for (MSLane::VehCont::const_iterator j = vehs.begin(); j != vehs.end(); ++j) {
1110 const std::vector<MSTransportable*>& persons = (*j)->getPersons();
1111 result.insert(result.end(), persons.begin(), persons.end());
1113 (*i)->releaseVehicles();
1121std::vector<MSTransportable*>
1170 if ((*it)->isTazConnector()) {
1171 i->second.push_back(*it);
1173 const std::vector<MSLane*>* allowed =
allowedLanes(**it, vClass);
1174 if (allowed !=
nullptr && allowed->size() > 0) {
1175 i->second.push_back(*it);
1202 if (viaPair.first->isTazConnector()) {
1203 result.push_back(viaPair);
1205 const std::vector<MSLane*>* allowed =
allowedLanes(*viaPair.first, vClass);
1206 if (allowed !=
nullptr && allowed->size() > 0) {
1207 result.push_back(viaPair);
1228 return (!
myLanes->empty() &&
myLanes->back()->getOpposite() !=
nullptr &&
1238 if (!
myLanes->empty() &&
myLanes->back()->getOpposite() !=
nullptr) {
1239 return &(
myLanes->back()->getOpposite()->getEdge());
1249 for (
const MSLink*
const link : l->getLinkCont()) {
1250 if (!link->havePriority()) {
1274 for (ConstMSEdgeVector::const_iterator it = candidates.begin(); it != candidates.end(); it++) {
1297 int numBidiLanes = 0;
1300 if (l1->getShape().reverse().almostSame(l2->getShape(), POSITION_EPS)) {
1301 l1->setBidiLane(l2);
1316 if (other ==
nullptr || other->
getLanes().size() !=
myLanes->size()) {
1319 std::vector<MSLane*>::const_iterator it1 =
myLanes->begin();
1320 std::vector<MSLane*>::const_reverse_iterator it2 = other->
getLanes().rbegin();
1322 if ((*it1)->getShape().reverse() != (*it2)->getShape()) {
1327 }
while (it1 !=
myLanes->end());
1347 std::vector<SUMOVehicle*>::iterator it = std::find(
myWaiting.begin(),
myWaiting.end(), vehicle);
1362 (!vehicle->hasDeparted() &&
1367 if (!vehicle->isLineStop(position) && vehicle->allowsBoarding(transportable)) {
1369 + transportable->
getID() +
"' at edge '" +
getID() +
"' position " +
toString(position) +
" cannot use waiting vehicle '"
1370 + vehicle->getID() +
"' at position " +
toString(vehicle->getPositionOnLane()) +
" because it is too far away.");
1377std::vector<const SUMOVehicle*>
1379 std::vector<const SUMOVehicle*> result;
1382 std::vector<const MEVehicle*> segmentVehs = segment->getVehicles();
1383 result.insert(result.end(), segmentVehs.begin(), segmentVehs.end());
1387 for (
auto veh : lane->getVehiclesSecure()) {
1388 result.push_back(veh);
1390 lane->releaseVehicles();
1408 if (segment->getCarNumber() > 0) {
1414 if (lane->getVehicleNumber() > 0) {
1428 wtime += segment->getWaitingSeconds();
1432 wtime += lane->getWaitingSeconds();
1454 sum += lane->getNettoOccupancy();
1456 return sum / (double)
myLanes->size();
1468 flow += (double) segment->getCarNumber() * segment->getMeanSpeed();
1470 return 3600 * flow / (*myLanes)[0]->getLength();
1481 occ += segment->getBruttoOccupancy();
1483 return occ / (*myLanes)[0]->getLength() / (double)(
myLanes->size());
1498 if (typeBefore !=
"") {
1500 if (typeBefore == typeAfter) {
1502 }
else if (typeAfter !=
"") {
1506 if (resBefore !=
nullptr && resAfter !=
nullptr) {
1510 for (
const auto& item : *resBefore) {
1512 const double speed = item.second;
1513 const auto it = (*resAfter).find(svc);
1514 if (it != (*resAfter).end()) {
1515 const double speed2 = it->second;
1517 ?
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
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
int SVCPermissions
bitset where each bit declares whether a certain SVC may use this edge/lane
@ 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
The position is set by the vehroute device.
@ 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.
@ 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 MSRoute & getRoute() const
Returns the current route.
const MSVehicleType & getVehicleType() const
Returns the vehicle's type definition.
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.
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.
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)
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 std::vector< MSLane * > & getLanes() const
Returns this edge's lanes.
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)
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
const std::vector< MSLane * > * allowedLanes(const MSEdge &destination, SUMOVehicleClass vclass=SVC_IGNORING) const
Get the allowed lanes to reach the destination-edge.
double getDistanceTo(const MSEdge *other, const bool doBoundaryEstimate=false) const
optimistic air distance heuristic for use in routing
const MSConstEdgePairVector & getViaSuccessors(SUMOVehicleClass vClass=SVC_IGNORING) const
Returns the following edges with internal vias, restricted by vClass.
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.
double getOccupancy() const
return mean occupancy on this edges lanes or segments
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...
bool myAmDelayed
whether this edge had a vehicle with less than max speed on it
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
const MSJunction * getToJunction() const
double getLength() const
return the length of the edge
void initialize(const std::vector< MSLane * > *lanes)
Initialize the edge.
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...
const MSJunction * getFromJunction() const
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.
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
const std::string & getEdgeType() const
Returns the type of the edge.
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 MSEdgeVector & getPredecessors() const
virtual void removeTransportable(MSTransportable *t) const
SumoXMLEdgeFunc getFunction() const
Returns the edge type (SumoXMLEdgeFunc)
bool allowsLaneChanging() const
void setMaxSpeed(double val) const
Sets a new maximum speed for all lanes (used by TraCI and MSCalibrator)
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,...
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 & getOutgoing() const
const Position & getPosition(bool secondaryShape=false) const
const ConstMSEdgeVector & getIncoming() 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 {.
MSLane * getOpposite() const
return the neighboring opposite direction lane for lane changing or nullptr
MSEdge & getEdge() const
Returns the lane's edge.
double getWidth() const
Returns the lane's width.
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
MSStage * getCurrentStage() const
Return the current stage.
bool isPerson() const
Whether it is a person.
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 knowsParameter(const std::string &key) const
Returns whether the parameter is known.
A point in 2D or 3D with translation and scaling methods.
static double rand(SumoRNG *rng=nullptr)
Returns a random real number in [0, 1)
static const T & getRandomFrom(const std::vector< T > &v, SumoRNG *rng=nullptr)
Returns a random element from the given vector.
Representation of a vehicle, person, or container.
virtual const MSVehicleType & getVehicleType() const =0
Returns the object's "vehicle" type.
virtual double getChosenSpeedFactor() const =0
virtual const SUMOVehicleParameter & getParameter() const =0
Returns the vehicle's parameter (including departure definition)
virtual double getMaxSpeed() const =0
Returns the object's maximum speed (minimum of technical and desired maximum speed)
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.
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