Eclipse SUMO - Simulation of Urban MObility
Loading...
Searching...
No Matches
MSEdge.h
Go to the documentation of this file.
1/****************************************************************************/
2// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3// Copyright (C) 2001-2024 German Aerospace Center (DLR) and others.
4// This program and the accompanying materials are made available under the
5// terms of the Eclipse Public License 2.0 which is available at
6// https://www.eclipse.org/legal/epl-2.0/
7// This Source Code may also be made available under the following Secondary
8// Licenses when the conditions for such availability set forth in the Eclipse
9// Public License 2.0 are satisfied: GNU General Public License, version 2
10// or later which is available at
11// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
12// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
13/****************************************************************************/
22// A road/street connecting two junctions
23/****************************************************************************/
24#pragma once
25#include <config.h>
26
27#include <vector>
28#include <map>
29#include <string>
30#include <iostream>
31#ifdef HAVE_FOX
33#endif
34#include <utils/common/Named.h>
38#include <utils/geom/Boundary.h>
43#include "MSNet.h"
44
45
46// ===========================================================================
47// class declarations
48// ===========================================================================
49class Boundary;
50class OutputDevice;
51class SUMOVehicle;
53class MSVehicle;
54class MSLane;
55class MSLaneChanger;
56class MSPerson;
57class MSJunction;
58class MSEdge;
59class MSTransportable;
60
61
62// ===========================================================================
63// class definitions
64// ===========================================================================
73typedef std::vector<MSEdge*> MSEdgeVector;
74typedef std::vector<const MSEdge*> ConstMSEdgeVector;
75typedef std::vector<std::pair<const MSEdge*, const MSEdge*> > MSConstEdgePairVector;
76
77class MSEdge : public Named, public Parameterised {
78private:
80 typedef std::vector<std::pair<SVCPermissions, std::shared_ptr<const std::vector<MSLane*> > > > AllowedLanesCont;
81
83 typedef std::map<const MSEdge*, AllowedLanesCont> AllowedLanesByTarget;
84
85
86public:
87 friend class MSLaneChangerSublane; // needs access to myLaneChanger
88
100 MSEdge(const std::string& id, int numericalID, const SumoXMLEdgeFunc function,
101 const std::string& streetName, const std::string& edgeType, int priority,
102 double distance);
103
104
106 virtual ~MSEdge();
107
108
114 void initialize(const std::vector<MSLane*>* lanes);
115
116
119 void recalcCache();
120
121
123 virtual void closeBuilding();
124
126 void buildLaneChanger();
127
128 /* @brief returns whether initizliaing a lane change is permitted on this edge
129 * @note Has to be called after all sucessors and predecessors have been set (after closeBuilding())
130 */
131 bool allowsLaneChanging() const;
132
135
142 MSLane* leftLane(const MSLane* const lane) const;
143
144
151 MSLane* rightLane(const MSLane* const lane) const;
152
153
161 MSLane* parallelLane(const MSLane* const lane, int offset, bool includeOpposite = true) const;
162
163
168 inline const std::vector<MSLane*>& getLanes() const {
169 return *myLanes;
170 }
171
172 inline int getNumLanes() const {
173 return (int)myLanes->size();
174 }
175
177 int getNumDrivingLanes() const;
178
180 int getVehicleNumber() const;
181
183 bool isEmpty() const;
184
186 std::vector<const SUMOVehicle*> getVehicles() const;
187
188 double getBruttoOccupancy() const;
189
191 double getFlow() const;
192
194 double getWaitingSeconds() const;
195
197 double getOccupancy() const;
198
204 inline const std::set<MSTransportable*, ComparatorNumericalIdLess>& getPersons() const {
205 return myPersons;
206 }
207
212 std::vector<MSTransportable*> getSortedPersons(SUMOTime timestep, bool includeRiding = false) const;
213
214
219 std::vector<MSTransportable*> getSortedContainers(SUMOTime timestep, bool includeRiding = false) const;
220
229 const std::vector<MSLane*>* allowedLanes(const MSEdge& destination,
230 SUMOVehicleClass vclass = SVC_IGNORING, bool ignoreTransientPermissions = false) const;
231
232
233
241 const std::vector<MSLane*>* allowedLanes(SUMOVehicleClass vclass = SVC_IGNORING) const;
242
243 inline bool isConnectedTo(const MSEdge& destination, SUMOVehicleClass vclass) const {
244 const std::vector<MSLane*>* const lanes = allowedLanes(destination, vclass);
245 return lanes != nullptr && !lanes->empty();
246 }
248
249
250
253
259 return myFunction;
260 }
261
263 inline bool isNormal() const {
265 }
266
268 inline bool isInternal() const {
270 }
271
273 inline bool isCrossing() const {
275 }
276
277
279 void checkAndRegisterBiDirEdge(const std::string& bidiID = "");
280
282 inline const MSEdge* getBidiEdge() const {
283 return myBidiEdge;
284 }
285
287 inline bool isWalkingArea() const {
289 }
290
291 inline bool isTazConnector() const {
293 }
294
295 void setOtherTazConnector(const MSEdge* edge) {
296 myOtherTazConnector = edge;
297 }
298
300 return myOtherTazConnector;
301 }
302
306 inline int getNumericalID() const {
307 return myNumericalID;
308 }
309
310
313 const std::string& getStreetName() const {
314 return myStreetName;
315 }
316
319 const std::string& getEdgeType() const {
320 return myEdgeType;
321 }
322
323 // @brief try to infer edge type for internal edges
324 void inferEdgeType();
325
328 int getPriority() const {
329 return myPriority;
330 }
331
335 double getDistance() const {
336 return myDistance;
337 }
338
341 double getDistanceAt(double pos) const;
342
343 bool hasDistance() const {
344 return myDistance != 0;
345 }
347
351 void setCrossingEdges(const std::vector<std::string>& crossingEdges) {
352 myCrossingEdges.clear();
353 myCrossingEdges.insert(myCrossingEdges.begin(), crossingEdges.begin(), crossingEdges.end());
354 }
355
359 const std::vector<std::string>& getCrossingEdges() const {
360 return myCrossingEdges;
361 }
362
363
366
372 void addSuccessor(MSEdge* edge, const MSEdge* via = nullptr);
373
374 void resetTAZ(MSJunction* junction);
375
379 int getNumSuccessors() const {
380 return (int) mySuccessors.size();
381 }
382
383
389
394 const MSConstEdgePairVector& getViaSuccessors(SUMOVehicleClass vClass = SVC_IGNORING, bool ignoreTransientPermissions = false) const;
395
396
401 int getNumPredecessors() const {
402 return (int) myPredecessors.size();
403 }
404
405
410 return myPredecessors;
411 }
412
413
415 return myFromJunction;
416 }
417
418 const MSJunction* getToJunction() const {
419 return myToJunction;
420 }
421
422
423 void setJunctions(MSJunction* from, MSJunction* to);
425
426
427
430
434 bool isVaporizing() const {
435 return myVaporizationRequests > 0;
436 }
437
438
449
450
462
463
472 double getCurrentTravelTime(const double minSpeed = NUMERICAL_EPS) const;
473
474
476 inline double getMinimumTravelTime(const SUMOVehicle* const veh) const {
478 return 0;
479 } else if (veh != 0) {
481 } else {
482 return myEmptyTraveltime;
483 }
484 }
485
486 double getTimePenalty() const {
487 return myTimePenalty;
488 }
489
497 static inline double getTravelTimeStatic(const MSEdge* const edge, const SUMOVehicle* const veh, double time) {
498 return MSNet::getInstance()->getTravelTime(edge, veh, time);
499 }
500
501 static double getTravelTimeAggregated(const MSEdge* const edge, const SUMOVehicle* const veh, double time);
502
505 double getRoutingSpeed() const;
506
507
510
530 bool insertVehicle(SUMOVehicle& v, SUMOTime time, const bool checkOnly = false, const bool forceCheck = false) const;
531
533 bool validateDepartSpeed(SUMOVehicle& v) const;
534
554 MSLane* getFreeLane(const std::vector<MSLane*>* allowed, const SUMOVehicleClass vclass, double departPos) const;
555
569 MSLane* getProbableLane(const std::vector<MSLane*>* allowed, const SUMOVehicleClass vclass, double departPos, double maxSpeed) const;
570
571
582 MSLane* getDepartLane(MSVehicle& veh) const;
583
584 /* @brief get the rightmost lane that allows the given vClass or nullptr
585 * @param[in] defaultFirst Whether the first lane should be returned if all lanes are forbidden
586 */
587 MSLane* getFirstAllowed(SUMOVehicleClass vClass, bool defaultFirst = false) const;
588
591
598
599
603 inline void setLastFailedInsertionTime(SUMOTime time) const {
605 }
607
608
610 void changeLanes(SUMOTime t) const;
611
612
614 const MSEdge* getInternalFollowingEdge(const MSEdge* followerAfterInternal, SUMOVehicleClass vClass) const;
615
616
618 double getInternalFollowingLengthTo(const MSEdge* followerAfterInternal, SUMOVehicleClass vClass) const;
619
621 const MSEdge* getNormalBefore() const;
622
624 const MSEdge* getNormalSuccessor() const;
625
627 inline bool prohibits(const SUMOVehicle* const vehicle) const {
628 if (vehicle == nullptr) {
629 return false;
630 }
631 const SUMOVehicleClass svc = vehicle->getVClass();
632 return (vehicle->ignoreTransientPermissions()
633 ? (myOriginalCombinedPermissions & svc) != svc
634 : (myCombinedPermissions & svc) != svc);
635 }
636
637 bool hasTransientPermissions() const;
638
644 inline bool restricts(const SUMOVehicle* const /* vehicle */) const {
645 return false;
646 }
647
651 }
652
656 double getWidth() const {
657 return myWidth;
658 }
659
661 const std::vector<double> getSubLaneSides() const {
662 return mySublaneSides;
663 }
664
665 void rebuildAllowedLanes(const bool onInit = false);
666
667 void rebuildAllowedTargets(const bool updateVehicles = true);
668
669
675 double getDistanceTo(const MSEdge* other, const bool doBoundaryEstimate = false) const;
676
677
679 static const Position getStopPosition(const SUMOVehicleParameter::Stop& stop);
680
681
685 inline double getLength() const {
686 return myLength;
687 }
688
689
694 double getSpeedLimit() const;
695
697 double getLengthGeometryFactor() const;
698
702 void setMaxSpeed(double val, double jamThreshold = -1);
703
707 void setFrictionCoefficient(double val) const;
708
714 double getVehicleMaxSpeed(const SUMOTrafficObject* const veh) const;
715
716
717 virtual void addTransportable(MSTransportable* t) const;
718
719 virtual void removeTransportable(MSTransportable* t) const;
720
721 inline bool isRoundabout() const {
722 return myAmRoundabout;
723 }
724
726 myAmRoundabout = true;
727 }
728
729 void markDelayed() const {
730 myAmDelayed = true;
731 }
732
733 // return whether there have been vehicles on this or the bidi edge (if there is any) at least once
734 inline bool isDelayed() const {
735 return myAmDelayed || (myBidiEdge != nullptr && myBidiEdge->myAmDelayed);
736 }
737
738 bool hasLaneChanger() const {
739 return myLaneChanger != nullptr;
740 }
741
743 bool canChangeToOpposite() const;
744
746 const MSEdge* getOppositeEdge() const;
747
749 double getMeanSpeed() const;
750
752 double getMeanFriction() const;
753
755 double getMeanSpeedBike() const;
756
758 bool hasMinorLink() const;
759
761 bool isFringe() const {
762 return myAmFringe;
763 }
764
766 bool hasChangeProhibitions(SUMOVehicleClass svc, int index) const;
767
769 virtual bool isSelected() const {
770 return false;
771 }
772
774 virtual void lock() const {}
775
777 virtual void unlock() const {};
778
780 void addWaiting(SUMOVehicle* vehicle) const;
781
783 void removeWaiting(const SUMOVehicle* vehicle) const;
784
785 /* @brief returns a vehicle that is waiting for a for a person or a container at this edge at the given position
786 * @param[in] transportable The person or container that wants to ride
787 * @param[in] position The vehicle shall be positioned in the interval [position - t, position + t], where t is some tolerance
788 */
789 SUMOVehicle* getWaitingVehicle(MSTransportable* transportable, const double position) const;
790
792 void clearState();
793
795 void updateMesoType();
796
800 static bool dictionary(const std::string& id, MSEdge* edge);
801
803 static MSEdge* dictionary(const std::string& id);
804
806 static MSEdge* dictionaryHint(const std::string& id, const int startIdx);
807
809 static const MSEdgeVector& getAllEdges();
810
812 static void clear();
813
815 static void insertIDs(std::vector<std::string>& into);
816
818
820 myMesoIgnoredVClasses = ignored;
821 }
822
823public:
826
835 static void parseEdgesList(const std::string& desc, ConstMSEdgeVector& into,
836 const std::string& rid);
837
838
845 static void parseEdgesList(const std::vector<std::string>& desc, ConstMSEdgeVector& into,
846 const std::string& rid);
848
849
856
863
864protected:
869 public:
871 explicit by_id_sorter() { }
872
874 int operator()(const MSEdge* const e1, const MSEdge* const e2) const {
875 return e1->getNumericalID() < e2->getNumericalID();
876 }
877
878 };
879
884 public:
886 explicit transportable_by_position_sorter(SUMOTime timestep): myTime(timestep) { }
887
889 int operator()(const MSTransportable* const c1, const MSTransportable* const c2) const;
890 private:
892 };
893
894
896 double getDepartPosBound(const MSVehicle& veh, bool upper = true) const;
897
898protected:
900 const int myNumericalID;
901
903 std::shared_ptr<const std::vector<MSLane*> > myLanes;
904
907
910
913
916
920 mutable std::set<int> myFailedInsertionMemory;
921
923 std::vector<std::string> myCrossingEdges;
924
927
929
932
936
938 mutable std::set<MSTransportable*, ComparatorNumericalIdLess> myPersons;
939
941 mutable std::set<MSTransportable*, ComparatorNumericalIdLess> myContainers;
942
945
949
953
958
963
967
970
972 std::string myStreetName;
973
975 std::string myEdgeType;
976
978 const int myPriority;
979
981 const double myDistance;
982
984 double myWidth;
985
987 double myLength;
988
991
994
996 mutable bool myAmDelayed;
997
1000
1003
1005 std::vector<double> mySublaneSides;
1006
1009
1011 typedef std::map< std::string, MSEdge* > DictType;
1012
1017
1022
1025
1026
1028 mutable std::map<SUMOVehicleClass, MSEdgeVector> myClassesSuccessorMap;
1029
1031 mutable std::map<SUMOVehicleClass, MSConstEdgePairVector> myClassesViaSuccessorMap;
1032 mutable std::map<SUMOVehicleClass, MSConstEdgePairVector> myOrigClassesViaSuccessorMap;
1033
1036
1038 mutable std::vector<SUMOVehicle*> myWaiting;
1039
1040#ifdef HAVE_FOX
1042 mutable FXMutex myWaitingMutex;
1043
1045 mutable FXMutex mySuccessorMutex;
1046#endif
1047
1048private:
1049
1052
1056
1059
1061 MSEdge& operator=(const MSEdge&) = delete;
1062
1063 void setBidiLanes();
1064
1065 bool isSuperposable(const MSEdge* other);
1066
1067 void addToAllowed(const SVCPermissions permissions, std::shared_ptr<const std::vector<MSLane*> > allowedLanes, AllowedLanesCont& laneCont) const;
1068};
long long int SUMOTime
Definition GUI.h:36
std::vector< const MSEdge * > ConstMSEdgeVector
Definition MSEdge.h:74
std::vector< std::pair< const MSEdge *, const MSEdge * > > MSConstEdgePairVector
Definition MSEdge.h:75
std::vector< MSEdge * > MSEdgeVector
Definition MSEdge.h:73
const SVCPermissions SVCAll
all VClasses are allowed
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_IGNORING
vehicles ignoring classes
SumoXMLEdgeFunc
Numbers representing special SUMO-XML-attribute values for representing edge functions used in netbui...
A class that stores a 2D geometrical boundary.
Definition Boundary.h:39
Sorts edges by their ids.
Definition MSEdge.h:868
by_id_sorter()
constructor
Definition MSEdge.h:871
int operator()(const MSEdge *const e1, const MSEdge *const e2) const
comparing operator
Definition MSEdge.h:874
Sorts transportables by their positions.
Definition MSEdge.h:883
transportable_by_position_sorter(SUMOTime timestep)
constructor
Definition MSEdge.h:886
int operator()(const MSTransportable *const c1, const MSTransportable *const c2) const
comparing operator
Definition MSEdge.cpp:1232
A road/street connecting two junctions.
Definition MSEdge.h:77
void setCrossingEdges(const std::vector< std::string > &crossingEdges)
Sets the crossed edge ids for a crossing edge.
Definition MSEdge.h:351
virtual void unlock() const
release exclusive access to the mesoscopic state
Definition MSEdge.h:777
std::string myStreetName
the real-world name of this edge (need not be unique)
Definition MSEdge.h:972
static const MSEdgeVector & getAllEdges()
Returns all edges with a numerical id.
Definition MSEdge.cpp:1086
SUMOVehicle * getWaitingVehicle(MSTransportable *transportable, const double position) const
Definition MSEdge.cpp:1472
virtual bool isSelected() const
whether this lane is selected in the GUI
Definition MSEdge.h:769
void addToAllowed(const SVCPermissions permissions, std::shared_ptr< const std::vector< MSLane * > > allowedLanes, AllowedLanesCont &laneCont) const
Definition MSEdge.cpp:300
void changeLanes(SUMOTime t) const
Performs lane changing on this edge.
Definition MSEdge.cpp:892
const int myPriority
the priority of the edge (used during network creation)
Definition MSEdge.h:978
double getBruttoOccupancy() const
Definition MSEdge.cpp:1609
bool isConnectedTo(const MSEdge &destination, SUMOVehicleClass vclass) const
Definition MSEdge.h:243
SVCPermissions myCombinedPermissions
The union of lane permissions for this edge.
Definition MSEdge.h:957
int getNumSuccessors() const
Returns the number of edges that may be reached from this edge.
Definition MSEdge.h:379
double getFlow() const
return flow based on meanSpead
Definition MSEdge.cpp:1596
const MSEdge * myOtherTazConnector
the other taz-connector if this edge isTazConnector, otherwise nullptr
Definition MSEdge.h:969
Boundary myBoundary
The bounding rectangle of end nodes incoming or outgoing edges for taz connectors or of my own start ...
Definition MSEdge.h:1035
double myWidth
Edge width [m].
Definition MSEdge.h:984
AllowedLanesByTarget myAllowedTargets
From target edge to lanes allowed to be used to reach it.
Definition MSEdge.h:951
bool isCrossing() const
return whether this edge is a pedestrian crossing
Definition MSEdge.h:273
MSLane * getDepartLane(MSVehicle &veh) const
Finds a depart lane for the given vehicle parameters.
Definition MSEdge.cpp:654
SUMOTime myLastFailedInsertionTime
The time of last insertion failure.
Definition MSEdge.h:915
std::set< MSTransportable *, ComparatorNumericalIdLess > myContainers
Containers on the edge.
Definition MSEdge.h:941
void setOtherTazConnector(const MSEdge *edge)
Definition MSEdge.h:295
int getPriority() const
Returns the priority of the edge.
Definition MSEdge.h:328
static void clear()
Clears the dictionary.
Definition MSEdge.cpp:1092
void inferEdgeType()
Definition MSEdge.cpp:1627
static void setMesoIgnoredVClasses(SVCPermissions ignored)
Definition MSEdge.h:819
const int myNumericalID
This edge's numerical id.
Definition MSEdge.h:900
void setJunctions(MSJunction *from, MSJunction *to)
Definition MSEdge.cpp:1319
double getMeanSpeedBike() const
get the mean speed of all bicycles on this edge
Definition MSEdge.cpp:1011
static MSEdgeVector myEdges
Static list of edges.
Definition MSEdge.h:1021
SVCPermissions getPermissions() const
Returns the combined permissions of all lanes of this edge.
Definition MSEdge.h:649
AllowedLanesCont myAllowed
Associative container from vehicle class to allowed-lanes.
Definition MSEdge.h:947
double myEmptyTraveltime
the traveltime on the empty edge (cached value for speedup)
Definition MSEdge.h:990
void updateMesoType()
update meso segment parameters
Definition MSEdge.cpp:249
bool myAmFringe
whether this edge is at the network fringe
Definition MSEdge.h:1002
static double getTravelTimeAggregated(const MSEdge *const edge, const SUMOVehicle *const veh, double time)
Definition MSEdge.cpp:1621
MSJunction * myToJunction
Definition MSEdge.h:935
void checkAndRegisterBiDirEdge(const std::string &bidiID="")
check and register the opposite superposable edge if any
Definition MSEdge.cpp:1377
virtual ~MSEdge()
Destructor.
Definition MSEdge.cpp:94
double getDepartPosBound(const MSVehicle &veh, bool upper=true) const
return upper bound for the depart position on this edge
Definition MSEdge.cpp:596
const double myDistance
the kilometrage/mileage at the start of the edge
Definition MSEdge.h:981
void setFrictionCoefficient(double val) const
Sets a new friction coefficient COF for all lanes [later to be (used by TraCI and MSCalibrator)].
void clearState()
Remove all transportables before quick-loading state.
Definition MSEdge.cpp:1677
MSLane * getDepartLaneMeso(SUMOVehicle &veh) const
consider given departLane parameter (only for validating speeds)
Definition MSEdge.cpp:643
const std::string & getStreetName() const
Returns the street name of the edge.
Definition MSEdge.h:313
bool hasTransientPermissions() const
Definition MSEdge.cpp:1671
const std::set< MSTransportable *, ComparatorNumericalIdLess > & getPersons() const
Returns this edge's persons set.
Definition MSEdge.h:204
const MSEdge * myBidiEdge
the oppositing superposable edge
Definition MSEdge.h:1051
MSLane * leftLane(const MSLane *const lane) const
Returns the lane left to the one given, 0 if the given lane is leftmost.
Definition MSEdge.cpp:450
static double getTravelTimeStatic(const MSEdge *const edge, const SUMOVehicle *const veh, double time)
Returns the travel time for the given edge.
Definition MSEdge.h:497
std::string myEdgeType
the type of the edge (optionally used during network creation)
Definition MSEdge.h:975
RailEdge< MSEdge, SUMOVehicle > * getRailwayRoutingEdge() const
Definition MSEdge.h:857
bool isWalkingArea() const
return whether this edge is walking area
Definition MSEdge.h:287
const std::vector< MSLane * > & getLanes() const
Returns this edge's lanes.
Definition MSEdge.h:168
int getNumDrivingLanes() const
return the number of lanes that permit non-weak modes if the edge allows non weak modes and the numbe...
Definition MSEdge.cpp:1514
bool isDelayed() const
Definition MSEdge.h:734
const MSEdge * getOppositeEdge() const
Returns the opposite direction edge if on exists else a nullptr.
Definition MSEdge.cpp:1340
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.
Definition MSEdge.cpp:1110
double getLengthGeometryFactor() const
return shape.length() / myLength
Definition MSEdge.cpp:1165
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...
Definition MSEdge.cpp:1243
bool isFringe() const
return whether this edge is at the fringe of the network
Definition MSEdge.h:761
std::vector< SUMOVehicle * > myWaiting
List of waiting vehicles.
Definition MSEdge.h:1038
const MSEdge * getNormalSuccessor() const
if this edge is an internal edge, return its first normal successor, otherwise the edge itself
Definition MSEdge.cpp:947
void rebuildAllowedLanes(const bool onInit=false)
Definition MSEdge.cpp:322
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.
Definition MSEdge.cpp:479
const MSEdge * getBidiEdge() const
return opposite superposable/congruent edge, if it exist and 0 else
Definition MSEdge.h:282
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...
Definition MSEdge.cpp:922
bool isNormal() const
return whether this edge is an internal edge
Definition MSEdge.h:263
bool restricts(const SUMOVehicle *const) const
Returns whether this edge has restriction parameters forbidding the given vehicle to pass it The rest...
Definition MSEdge.h:644
ReversedEdge< MSEdge, SUMOVehicle > * getReversedRoutingEdge() const
Definition MSEdge.h:850
std::vector< MSTransportable * > getSortedPersons(SUMOTime timestep, bool includeRiding=false) const
Returns this edge's persons sorted by pos.
Definition MSEdge.cpp:1206
bool isSuperposable(const MSEdge *other)
Definition MSEdge.cpp:1432
bool validateDepartSpeed(SUMOVehicle &v) const
check whether the given departSpeed is valid for this edge
Definition MSEdge.cpp:737
const std::vector< std::string > & getCrossingEdges() const
Gets the crossed edge ids.
Definition MSEdge.h:359
double getDistanceTo(const MSEdge *other, const bool doBoundaryEstimate=false) const
optimistic air distance heuristic for use in routing
Definition MSEdge.cpp:1133
void setMaxSpeed(double val, double jamThreshold=-1)
Sets a new maximum speed for all lanes (used by TraCI and MSCalibrator)
Definition MSEdge.cpp:1177
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.
Definition MSEdge.cpp:1073
MSLaneChanger * myLaneChanger
This member will do the lane-change.
Definition MSEdge.h:906
double getOccupancy() const
return mean occupancy on this edges lanes or segments
Definition MSEdge.cpp:1574
const MSConstEdgePairVector & getViaSuccessors(SUMOVehicleClass vClass=SVC_IGNORING, bool ignoreTransientPermissions=false) const
Returns the following edges with internal vias, restricted by vClass.
Definition MSEdge.cpp:1288
std::vector< MSTransportable * > getSortedContainers(SUMOTime timestep, bool includeRiding=false) const
Returns this edge's containers sorted by pos.
Definition MSEdge.cpp:1224
const SumoXMLEdgeFunc myFunction
the purpose of the edge
Definition MSEdge.h:909
MSLane * getProbableLane(const std::vector< MSLane * > *allowed, const SUMOVehicleClass vclass, double departPos, double maxSpeed) const
Finds the most probable lane allowing the vehicle class.
Definition MSEdge.cpp:558
void recalcCache()
Recalculates the cached values.
Definition MSEdge.cpp:119
double getSpeedLimit() const
Returns the speed limit of the edge @caution The speed limit of the first lane is retured; should pro...
Definition MSEdge.cpp:1158
SVCPermissions myOriginalCombinedPermissions
The original union of lane permissions for this edge (before temporary modifications)
Definition MSEdge.h:962
MSEdge & operator=(const MSEdge &)=delete
assignment operator.
bool myAmDelayed
whether this edge had a vehicle with less than max speed on it
Definition MSEdge.h:996
SVCPermissions myOriginalMinimumPermissions
The original intersection of lane permissions for this edge (before temporary modifications)
Definition MSEdge.h:960
std::map< SUMOVehicleClass, MSEdgeVector > myClassesSuccessorMap
The successors available for a given vClass.
Definition MSEdge.h:1028
SUMOTime decVaporization(SUMOTime t)
Disables vaporization.
Definition MSEdge.cpp:519
MSEdgeVector myPredecessors
The preceeding edges.
Definition MSEdge.h:931
bool hasChangeProhibitions(SUMOVehicleClass svc, int index) const
return whether this edge prohibits changing for the given vClass when starting on the given lane inde...
Definition MSEdge.cpp:1362
void rebuildAllowedTargets(const bool updateVehicles=true)
Definition MSEdge.cpp:383
bool hasLaneChanger() const
Definition MSEdge.h:738
static SVCPermissions myMesoIgnoredVClasses
Definition MSEdge.h:1023
std::vector< std::pair< SVCPermissions, std::shared_ptr< const std::vector< MSLane * > > > > AllowedLanesCont
"Map" from vehicle class to allowed lanes
Definition MSEdge.h:80
const MSJunction * getToJunction() const
Definition MSEdge.h:418
double getLength() const
return the length of the edge
Definition MSEdge.h:685
void initialize(const std::vector< MSLane * > *lanes)
Initialize the edge.
Definition MSEdge.cpp:102
bool myHaveTransientPermissions
whether transient permission changes were applied to this edge or a predecessor
Definition MSEdge.h:965
std::vector< std::string > myCrossingEdges
The crossed edges id for a crossing edge. On not crossing edges it is empty.
Definition MSEdge.h:923
virtual void closeBuilding()
Definition MSEdge.cpp:205
static SVCPermissions getMesoPermissions(SVCPermissions p, SVCPermissions ignoreIgnored=0)
Definition MSEdge.cpp:315
bool canChangeToOpposite() const
whether this edge allows changing to the opposite direction edge
Definition MSEdge.cpp:1330
std::set< int > myFailedInsertionMemory
A cache for the rejected insertion attempts. Used to assure that no further insertion attempts are ma...
Definition MSEdge.h:920
const MSJunction * getFromJunction() const
Definition MSEdge.h:414
double getMeanSpeed() const
get the mean speed
Definition MSEdge.cpp:957
static DictType myDict
Static dictionary to associate string-ids with objects.
Definition MSEdge.h:1016
std::set< MSTransportable *, ComparatorNumericalIdLess > myPersons
Persons on the edge for drawing and pushbutton.
Definition MSEdge.h:938
bool isTazConnector() const
Definition MSEdge.h:291
MSEdge(const MSEdge &)
Invalidated copy constructor.
int getNumLanes() const
Definition MSEdge.h:172
double getDistanceAt(double pos) const
Returns the kilometrage/mileage at the given offset along the edge.
Definition MSEdge.cpp:1664
MSConstEdgePairVector myViaSuccessors
Definition MSEdge.h:928
double getMinimumTravelTime(const SUMOVehicle *const veh) const
returns the minimum travel time for the given vehicle
Definition MSEdge.h:476
void setBidiLanes()
Definition MSEdge.cpp:1407
MSEdgeVector mySuccessors
The succeeding edges.
Definition MSEdge.h:926
bool isRoundabout() const
Definition MSEdge.h:721
bool isInternal() const
return whether this edge is an internal edge
Definition MSEdge.h:268
bool prohibits(const SUMOVehicle *const vehicle) const
Returns whether the vehicle (class) is not allowed on the edge.
Definition MSEdge.h:627
MSLane * rightLane(const MSLane *const lane) const
Returns the lane right to the one given, 0 if the given lane is rightmost.
Definition MSEdge.cpp:456
double getWidth() const
Returns the edges's width (sum over all lanes)
Definition MSEdge.h:656
double getCurrentTravelTime(const double minSpeed=NUMERICAL_EPS) const
Computes and returns the current travel time for this edge.
Definition MSEdge.cpp:1031
std::map< SUMOVehicleClass, MSConstEdgePairVector > myOrigClassesViaSuccessorMap
Definition MSEdge.h:1032
AllowedLanesByTarget myOrigAllowedTargets
Definition MSEdge.h:952
int getNumericalID() const
Returns the numerical id of the edge.
Definition MSEdge.h:306
void resetTAZ(MSJunction *junction)
Definition MSEdge.cpp:182
bool isVaporizing() const
Returns whether vehicles on this edge shall be vaporized.
Definition MSEdge.h:434
bool insertVehicle(SUMOVehicle &v, SUMOTime time, const bool checkOnly=false, const bool forceCheck=false) const
Tries to insert the given vehicle into the network.
Definition MSEdge.cpp:775
static const Position getStopPosition(const SUMOVehicleParameter::Stop &stop)
return the coordinates of the center of the given stop
Definition MSEdge.cpp:1152
void addWaiting(SUMOVehicle *vehicle) const
Adds a vehicle to the list of waiting vehicles.
Definition MSEdge.cpp:1451
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.
Definition MSEdge.cpp:462
ReversedEdge< MSEdge, SUMOVehicle > * myReversedRoutingEdge
a reversed version for backward routing
Definition MSEdge.h:1054
double getTimePenalty() const
Definition MSEdge.h:486
const std::string & getEdgeType() const
Returns the type of the edge.
Definition MSEdge.h:319
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....
Definition MSEdge.cpp:1047
std::vector< const SUMOVehicle * > getVehicles() const
return vehicles on this edges lanes or segments
Definition MSEdge.cpp:1495
const std::vector< double > getSubLaneSides() const
Returns the right side offsets of this edge's sublanes.
Definition MSEdge.h:661
static void insertIDs(std::vector< std::string > &into)
Inserts IDs of all known edges into the given vector.
Definition MSEdge.cpp:1102
const MSEdge * getOtherTazConnector() const
Definition MSEdge.h:299
double getVehicleMaxSpeed(const SUMOTrafficObject *const veh) const
Returns the maximum speed the vehicle may use on this edge.
Definition MSEdge.cpp:1170
SUMOTime incVaporization(SUMOTime t)
Enables vaporization.
Definition MSEdge.cpp:512
MSJunction * myFromJunction
the junctions for this edge
Definition MSEdge.h:934
double getMeanFriction() const
get the mean friction over the lanes
Definition MSEdge.cpp:998
std::map< std::string, MSEdge * > DictType
definition of the static dictionary type
Definition MSEdge.h:1011
bool hasMinorLink() const
whether any lane has a minor link
Definition MSEdge.cpp:1350
std::map< SUMOVehicleClass, MSConstEdgePairVector > myClassesViaSuccessorMap
The successors available for a given vClass.
Definition MSEdge.h:1031
const MSEdge * getNormalBefore() const
if this edge is an internal edge, return its first normal predecessor, otherwise the edge itself
Definition MSEdge.cpp:937
int getVehicleNumber() const
return total number of vehicles on this edges lanes or segments
Definition MSEdge.cpp:1532
void markDelayed() const
Definition MSEdge.h:729
const MSEdgeVector & getPredecessors() const
Definition MSEdge.h:409
virtual void removeTransportable(MSTransportable *t) const
Definition MSEdge.cpp:1197
SUMOTime getLastFailedInsertionTime() const
Returns the last time a vehicle could not be inserted.
Definition MSEdge.h:595
SumoXMLEdgeFunc getFunction() const
Returns the edge type (SumoXMLEdgeFunc)
Definition MSEdge.h:258
bool allowsLaneChanging() const
Definition MSEdge.cpp:278
bool isEmpty() const
whether this edge has no vehicles
Definition MSEdge.cpp:1538
const MSEdge * getInternalFollowingEdge(const MSEdge *followerAfterInternal, SUMOVehicleClass vClass) const
Definition MSEdge.cpp:900
void buildLaneChanger()
Has to be called after all sucessors and predecessors have been set (after closeBuilding())
Definition MSEdge.cpp:258
double getRoutingSpeed() const
Returns the averaged speed used by the routing device.
Definition MSEdge.cpp:1041
virtual void lock() const
grant exclusive access to the mesoscopic state
Definition MSEdge.h:774
void removeWaiting(const SUMOVehicle *vehicle) const
Removes a vehicle from the list of waiting vehicles.
Definition MSEdge.cpp:1460
bool hasDistance() const
Definition MSEdge.h:343
MSLane * getFirstAllowed(SUMOVehicleClass vClass, bool defaultFirst=false) const
Definition MSEdge.cpp:726
std::vector< double > mySublaneSides
the right side for each sublane on this edge
Definition MSEdge.h:1005
const MSEdgeVector & getSuccessors(SUMOVehicleClass vClass=SVC_IGNORING) const
Returns the following edges, restricted by vClass.
Definition MSEdge.cpp:1258
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,...
Definition MSEdge.h:903
AllowedLanesCont myOrigAllowed
Definition MSEdge.h:948
double getWaitingSeconds() const
return accumated waiting time for all vehicles on this edges lanes or segments
Definition MSEdge.cpp:1558
int myVaporizationRequests
Vaporizer counter.
Definition MSEdge.h:912
int getNumPredecessors() const
Returns the number of edges this edge is connected to.
Definition MSEdge.h:401
double myTimePenalty
flat penalty when computing traveltime
Definition MSEdge.h:993
SVCPermissions myMinimumPermissions
The intersection of lane permissions for this edge.
Definition MSEdge.h:955
MSLane * getFreeLane(const std::vector< MSLane * > *allowed, const SUMOVehicleClass vclass, double departPos) const
Finds the emptiest lane allowing the vehicle class.
Definition MSEdge.cpp:526
std::map< const MSEdge *, AllowedLanesCont > AllowedLanesByTarget
Succeeding edges (keys) and allowed lanes to reach these edges (values).
Definition MSEdge.h:83
void markAsRoundabout()
Definition MSEdge.h:725
bool myAmRoundabout
whether this edge belongs to a roundabout
Definition MSEdge.h:999
virtual void addTransportable(MSTransportable *t) const
Definition MSEdge.cpp:1188
double getDistance() const
Returns the kilometrage/mileage encoding at the start of the edge (negative values encode descending ...
Definition MSEdge.h:335
void setLastFailedInsertionTime(SUMOTime time) const
Sets the last time a vehicle could not be inserted.
Definition MSEdge.h:603
RailEdge< MSEdge, SUMOVehicle > * myRailwayRoutingEdge
Definition MSEdge.h:1055
double myLength
the length of the edge (cached value for speedup)
Definition MSEdge.h:987
The base class for an intersection.
Definition MSJunction.h:58
Performs lane changing of vehicles.
Performs lane changing of vehicles.
Representation of a lane in the micro simulation.
Definition MSLane.h:84
static MSNet * getInstance()
Returns the pointer to the unique instance of MSNet (singleton).
Definition MSNet.cpp:185
static double getTravelTime(const MSEdge *const e, const SUMOVehicle *const v, double t)
Returns the travel time to pass an edge.
Definition MSNet.cpp:165
Representation of a vehicle in the micro simulation.
Definition MSVehicle.h:77
Base class for objects which have an id.
Definition Named.h:54
Static storage of an output device and its base (abstract) implementation.
An upper class for objects with additional parameters.
A point in 2D or 3D with translation and scaling methods.
Definition Position.h:37
the edge type representing backward edges
Definition RailEdge.h:38
the edge type representing backward edges
Representation of a vehicle, person, or container.
virtual bool ignoreTransientPermissions() const
Returns whether this object is ignoring transient permission changes (during routing)
virtual SUMOVehicleClass getVClass() const =0
Returns the object's access class.
Representation of a vehicle.
Definition SUMOVehicle.h:62
Definition of vehicle stop (position and duration)
Structure representing possible vehicle parameter.