Eclipse SUMO - Simulation of Urban MObility
Loading...
Searching...
No Matches
MSDriveWay.h
Go to the documentation of this file.
1/****************************************************************************/
2// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3// Copyright (C) 2002-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/****************************************************************************/
18// A sequende of rail tracks (lanes) that may be used as a "set route" (Fahrstraße)
19/****************************************************************************/
20#pragma once
21#include <config.h>
22
23#include <utils/common/Named.h>
25#include <microsim/MSRoute.h>
26
27// ===========================================================================
28// class declarations
29// ===========================================================================
30class SUMOVehicle;
31class MSLane;
32class MSLink;
33class MSRailSignal;
34
35// ===========================================================================
36// class definitions
37// ===========================================================================
41class MSDriveWay : public MSMoveReminder, public Named {
42public:
43 typedef std::pair<const SUMOVehicle* const, const MSLink::ApproachingVehicleInformation> Approaching;
44 typedef std::set<const MSLane*, ComparatorNumericalIdLess> LaneSet;
45 typedef std::map<const MSLane*, int, ComparatorNumericalIdLess> LaneVisitedMap;
46
47 struct VehicleEvent {
48 VehicleEvent(SUMOTime _time, bool _isEntry, const std::string& _id, Notification _reason):
49 time(_time), isEntry(_isEntry), id(_id), reason(_reason) {}
51 bool isEntry;
52 std::string id;
54 };
55
56 /* The driveways (Fahrstrassen) for each link index of MSRailSignal
57 * Each link index has at least one driveway
58 * A driveway describes one possible route that passes the signal up to
59 * the next secure point
60 * When a signal guards a switch (indirect guard) that signal stores two
61 * or more driveways
62 */
63 MSDriveWay(const MSLink* origin, const std::string& id, bool temporary = false);
64
66 virtual ~MSDriveWay();
67
68 static void cleanup();
69
70 static void clearState();
71
72 static bool haveDriveWays() {
73 return myGlobalDriveWayIndex > 0;
74 }
75
76 bool notifyEnter(SUMOTrafficObject& veh, Notification reason, const MSLane* enteredLane);
77 bool notifyLeave(SUMOTrafficObject& veh, double lastPos, Notification reason, const MSLane* enteredLane = 0);
78 bool notifyLeaveBack(SUMOTrafficObject& veh, Notification reason, const MSLane* leftLane);
79
81 bool flankConflict(const MSDriveWay& other) const;
82
84 bool crossingConflict(const MSDriveWay& other) const;
85
87 bool bidiBlockedBy(const MSDriveWay& other) const;
88
90 bool bidiBlockedByEnd(const MSDriveWay& other) const;
91
93 bool forwardRouteConflict(std::set<const MSEdge*> forward, const MSDriveWay& other, bool secondCheck = false);
94
96 bool conflictLaneOccupied(bool store = true, const SUMOVehicle* ego = nullptr) const;
97
99 bool foeDriveWayOccupied(bool store, const SUMOVehicle* ego, MSEdgeVector& occupied) const;
100
102 bool foeDriveWayApproached() const;
103
105 bool reserve(const Approaching& closest, MSEdgeVector& occupied);
106
108 void writeBlocks(OutputDevice& od) const;
109 void writeBlockVehicles(OutputDevice& od) const;
110
111 const std::vector<const MSEdge*>& getRoute() const {
112 return myRoute;
113 }
114
115 const std::vector<const MSLane*>& getFlank() const {
116 return myFlank;
117 }
118
119 const std::vector<const MSLane*>& getBidi() const {
120 return myBidi;
121 }
122
123 const std::vector<MSLink*>& getConflictLinks() const {
124 return myConflictLinks;
125 }
126
127 int getNumericalID() const {
128 return myNumericalID;
129 }
130
131 const std::vector<VehicleEvent>& getEvents() const {
132 return myVehicleEvents;
133 }
134
135 void setEvents(const std::vector<VehicleEvent>& events) {
136 myVehicleEvents = events;
137 }
138
139 void setVehicle(const std::string& vehID) {
140 myFirstVehicle = vehID;
141 }
142
143 const std::vector<MSDriveWay*>& getFoes() const {
144 return myFoes;
145 }
146
147 const std::vector<const MSLane*>& getForward() const {
148 return myForward;
149 }
150
152 bool match(MSRouteIterator firstIt, MSRouteIterator endIt) const;
153
154 void addDWDeadlock(const std::vector<const MSDriveWay*>& deadlockFoes);
155
156 bool isDepartDriveway() const {
157 return myOrigin == nullptr;
158 };
159
160 const MSLink* getOrigin() const {
161 return myOrigin;
162 }
163
164 static void init();
165
166 static bool hasRS(const MSEdge* cur, const MSEdge* next);
167
169 static bool mustYield(const Approaching& veh, const Approaching& foe);
170
172 static MSDriveWay* buildDriveWay(const std::string& id, const MSLink* link, MSRouteIterator first, MSRouteIterator end);
173
175 static std::string getClickableTLLinkID(const MSLink* link);
176
177 static const MSDriveWay* getDepartureDriveway(const SUMOVehicle* veh);
178
179 static void writeDepatureBlocks(OutputDevice& od, bool writeVehicles);
180
182 static void saveState(OutputDevice& out);
183 static void loadState(const SUMOSAXAttributes& attrs, int tag);
184
185protected:
186
189
192
195
198
200 std::vector<const MSEdge*> myRoute;
201
204
214
215 /* @brief the actual driveway part up to the next railsignal (halting position)
216 * This must be free of other trains */
217 std::vector<const MSLane*> myForward;
218
219 /* @brief the list of bidirectional edges that can enter the forward
220 * section and which must also be free of traffic
221 * (up to the first element that could give protection) */
222 std::vector<const MSLane*> myBidi;
223
224 /* @brief the list of bidirectional edges that can enter the forward
225 * section and which might contain deadlock-relevant traffic */
226 std::vector<const MSLane*> myBidiExtended;
227
228 /* @brief the list of edges that merge with the forward section
229 * (found via backward search, up to the first element that could give protection) */
230 std::vector<const MSLane*> myFlank;
231
233 std::vector<const MSLane*> myConflictLanes;
234
235 /* The conflict links for this block
236 * Conflict resolution must be performed if vehicles are approaching the
237 * current link and any of the conflict links */
238 std::vector<MSLink*> myConflictLinks;
239
241 bool hasLinkConflict(const Approaching& closest, const MSLink* foeLink) const;
242
244 bool overlap(const MSDriveWay& other) const;
245
246 /* @brief determine route that identifies this driveway (a subset of the
247 * vehicle route)
248 * collects:
249 * myRoute
250 * myForward
251 * myBidi
252 * myProtectedBidi
253 *
254 * returns edge that is assumed to safe from oncoming-deadlock or nullptr
255 */
256 void buildRoute(const MSLink* origin, double length, MSRouteIterator next, MSRouteIterator end, LaneVisitedMap& visited, std::set<MSLink*>&);
257
258 /* @brief find switches that threaten this driveway
259 * @param[out] flankSwitches collect the switches
260 */
261 void checkFlanks(const MSLink* originLink, const std::vector<const MSLane*>& lanes, const LaneVisitedMap& visited, bool allFoes, std::set<MSLink*>& flankSwitches) const;
262
263 /* @brief find links that cross the driveway without entering it
264 * @param[out] flankSwitches collect the switches
265 */
266 void checkCrossingFlanks(MSLink* dwLink, const LaneVisitedMap& visited, std::set<MSLink*>& flankSwitches) const;
267
268 /* @brief find upstream protection from the given link
269 * @param[out] flank: the stored flank lanes
270 */
271 void findFlankProtection(MSLink* link, MSLink* origLink, std::vector<const MSLane*>& flank);
272
274 void addFoes(const MSLink* link);
275
277 void addSidings(MSDriveWay* foe, bool addToFoe = false);
278
280 void addBidiFoes(const MSRailSignal* ownSignal, bool extended);
281
283 void addParallelFoes(const MSLink* link, const MSEdge* first);
284
286 void addReversalFoes();
287
288 /* @brief build shortened driveway that ends where the foe train leaves the conflict zone of this driveway
289 * @return whether the foe has received a new entry in myFoes
290 */
291 bool buildSubFoe(MSDriveWay* foe, bool movingBlock);
292
294 void addConflictLink(const MSLink* link);
295
297 std::pair<bool, const MSDriveWay*> canUseSiding(const SUMOVehicle* ego, const MSDriveWay* foe, bool recurse = true) const;
298
299 bool isFoeOrSubFoe(const MSDriveWay* foe) const;
300
301 bool forwardEndOnRoute(const MSDriveWay* foe) const;
302
303 void addSwitchFoes(MSLink* link);
304
305 bool haveSubTrains() const;
306
307 static bool hasJoin(const SUMOVehicle* ego, const SUMOVehicle* foe);
308
309 static bool isSwitch(const MSLink* link);
310
311 void _saveState(OutputDevice& out) const;
312
314 static std::string getTLLinkID(const MSLink* link);
315
317 static std::string getJunctionLinkID(const MSLink* link);
318
320 static std::string formatVisitedMap(const LaneVisitedMap& visited);
321
323 static void appendMapIndex(LaneVisitedMap& map, const MSLane* lane);
324
325private:
326
327 struct Siding {
328 Siding(int s, int e, double l) : start(s), end(e), length(l) {}
329 // indices along route
330 int start;
331 int end;
332 double length;
333 };
334
335 std::set<SUMOVehicle*> myTrains;
336
337 std::vector<VehicleEvent> myVehicleEvents;
338 std::vector<MSDriveWay*> myFoes;
339 std::map<const MSDriveWay*, std::vector<Siding>, ComparatorIdLess> mySidings;
340 std::vector<std::set <const MSDriveWay*> > myDeadlocks;
341
342 /* @brief shortened versions of this driveway to be used as foes instead of the long original
343 * (ends as soon as the train has left a particular conflict section)
344 * they are never attached to a LinkInfo and thus never the target of the match() function */
345 std::vector<MSDriveWay*> mySubDriveWays;
346
348 std::vector<const MSEdge*> myReversals;
349
351 std::string myFirstVehicle;
352
354 static int myNumWarnings;
355 static bool myWriteVehicles;
356
358 static std::map<const MSLink*, std::vector<MSDriveWay*> > mySwitchDriveWays;
359
361 static std::map<const MSEdge*, std::vector<MSDriveWay*> > myReversalDriveWays;
362
364 static std::map<const MSEdge*, std::vector<MSDriveWay*>, ComparatorNumericalIdLess > myDepartureDriveways;
365 static std::map<const MSJunction*, int> myDepartDrivewayIndex;
367 static std::map<const MSEdge*, std::vector<MSDriveWay*> > myDepartureDrivewaysEnds;
368
370 static std::map<const MSEdge*, std::vector<MSDriveWay*>, ComparatorNumericalIdLess> myEndingDriveways;
371
373 static std::map<ConstMSEdgeVector, MSDriveWay*> myDriveWayRouteLookup;
374 static std::map<std::string, MSDriveWay*> myDriveWayLookup;
375
376};
long long int SUMOTime
Definition GUI.h:36
std::vector< MSEdge * > MSEdgeVector
Definition MSEdge.h:73
ConstMSEdgeVector::const_iterator MSRouteIterator
Definition MSRoute.h:57
void addFoes(const MSLink *link)
add all driveWays that start at the given link as foes
std::vector< MSLink * > myConflictLinks
Definition MSDriveWay.h:238
const SUMOVehicle * myActive
whether the current signal is switched green for a train approaching this block
Definition MSDriveWay.h:197
bool crossingConflict(const MSDriveWay &other) const
Wether there is a crossing conflict with the given driveway.
static std::string getJunctionLinkID(const MSLink *link)
return junctionID_junctionLinkIndex
static void clearState()
bool haveSubTrains() const
bool myIsSubDriveway
Definition MSDriveWay.h:213
std::vector< MSDriveWay * > mySubDriveWays
Definition MSDriveWay.h:345
std::vector< std::set< const MSDriveWay * > > myDeadlocks
Definition MSDriveWay.h:340
void checkFlanks(const MSLink *originLink, const std::vector< const MSLane * > &lanes, const LaneVisitedMap &visited, bool allFoes, std::set< MSLink * > &flankSwitches) const
bool myAbortedBuild
whether driveway building was aborted due to MAX_BLOCK_LENGTH
Definition MSDriveWay.h:210
bool buildSubFoe(MSDriveWay *foe, bool movingBlock)
static std::map< const MSJunction *, int > myDepartDrivewayIndex
Definition MSDriveWay.h:365
static bool hasJoin(const SUMOVehicle *ego, const SUMOVehicle *foe)
bool isDepartDriveway() const
Definition MSDriveWay.h:156
static std::string getClickableTLLinkID(const MSLink *link)
return logicID_linkIndex in a way that allows clicking in sumo-gui
double myMaxFlankLength
the maximum flank length searched while building this driveway
Definition MSDriveWay.h:194
const MSLink * myOrigin
the link that enters this driveway or nullptr for a departure driveWay
Definition MSDriveWay.h:191
bool myTerminateRoute
Definition MSDriveWay.h:208
std::vector< const MSLane * > myBidi
Definition MSDriveWay.h:222
static bool myWriteVehicles
Definition MSDriveWay.h:355
void checkCrossingFlanks(MSLink *dwLink, const LaneVisitedMap &visited, std::set< MSLink * > &flankSwitches) const
bool hasLinkConflict(const Approaching &closest, const MSLink *foeLink) const
Whether the approaching vehicle is prevent from driving by another vehicle approaching the given link...
void findFlankProtection(MSLink *link, MSLink *origLink, std::vector< const MSLane * > &flank)
std::vector< const MSLane * > myBidiExtended
Definition MSDriveWay.h:226
void addReversalFoes()
derive foe driveways that enter the bidi section by reversing
static bool hasRS(const MSEdge *cur, const MSEdge *next)
void addBidiFoes(const MSRailSignal *ownSignal, bool extended)
derive foe driveways based on myBidi or myBidiExtended
static bool haveDriveWays()
Definition MSDriveWay.h:72
void writeBlocks(OutputDevice &od) const
Write block items for this driveway.
bool notifyLeave(SUMOTrafficObject &veh, double lastPos, Notification reason, const MSLane *enteredLane=0)
Called if the vehicle leaves the reminder's lane.
std::vector< const MSLane * > myForward
Definition MSDriveWay.h:217
const std::vector< const MSLane * > & getBidi() const
Definition MSDriveWay.h:119
std::vector< const MSEdge * > myReversals
track own occurences in myReversalDriveWays for cleanup in destructor
Definition MSDriveWay.h:348
std::map< const MSDriveWay *, std::vector< Siding >, ComparatorIdLess > mySidings
Definition MSDriveWay.h:339
void writeBlockVehicles(OutputDevice &od) const
virtual ~MSDriveWay()
Destructor.
bool match(MSRouteIterator firstIt, MSRouteIterator endIt) const
whether the give route matches this driveway
static void appendMapIndex(LaneVisitedMap &map, const MSLane *lane)
append to map by map index and avoid undefined behavior
bool overlap(const MSDriveWay &other) const
Wether this driveway (route) overlaps with the given one.
void setEvents(const std::vector< VehicleEvent > &events)
Definition MSDriveWay.h:135
std::vector< const MSLane * > myFlank
Definition MSDriveWay.h:230
static std::string getTLLinkID(const MSLink *link)
return logicID_linkIndex
const std::vector< const MSLane * > & getForward() const
Definition MSDriveWay.h:147
std::vector< const MSEdge * > myRoute
list of edges for matching against train routes
Definition MSDriveWay.h:200
std::map< const MSLane *, int, ComparatorNumericalIdLess > LaneVisitedMap
Definition MSDriveWay.h:45
static void writeDepatureBlocks(OutputDevice &od, bool writeVehicles)
static std::map< ConstMSEdgeVector, MSDriveWay * > myDriveWayRouteLookup
lookup table for state loading
Definition MSDriveWay.h:373
int getNumericalID() const
Definition MSDriveWay.h:127
void buildRoute(const MSLink *origin, double length, MSRouteIterator next, MSRouteIterator end, LaneVisitedMap &visited, std::set< MSLink * > &)
static int myNumWarnings
Definition MSDriveWay.h:354
static std::map< const MSEdge *, std::vector< MSDriveWay * > > myReversalDriveWays
all driveways reversing on the given switch (used to look up flank foes)
Definition MSDriveWay.h:361
static void init()
void _saveState(OutputDevice &out) const
static std::string formatVisitedMap(const LaneVisitedMap &visited)
print link descriptions
static std::map< std::string, MSDriveWay * > myDriveWayLookup
Definition MSDriveWay.h:374
const std::vector< MSLink * > & getConflictLinks() const
Definition MSDriveWay.h:123
const std::vector< MSDriveWay * > & getFoes() const
Definition MSDriveWay.h:143
const MSLink * getOrigin() const
Definition MSDriveWay.h:160
bool flankConflict(const MSDriveWay &other) const
Wether there is a flank conflict with the given driveway.
bool conflictLaneOccupied(bool store=true, const SUMOVehicle *ego=nullptr) const
whether any of myConflictLanes is occupied (vehicles that are the target of a join must be ignored)
void addSwitchFoes(MSLink *link)
static std::map< const MSEdge *, std::vector< MSDriveWay * > > myDepartureDrivewaysEnds
all driveways that do not start at a rail signal (and are only used at departure) by end edge
Definition MSDriveWay.h:367
int myCoreSize
number of edges in myRoute where overlap with other driveways is forbidden
Definition MSDriveWay.h:203
std::pair< const SUMOVehicle *const, const MSLink::ApproachingVehicleInformation > Approaching
Definition MSDriveWay.h:43
void addConflictLink(const MSLink *link)
add symmetical conflict link for foes when building a new driveway
static void cleanup()
bool notifyLeaveBack(SUMOTrafficObject &veh, Notification reason, const MSLane *leftLane)
Called if the vehicle's back leaves the reminder's lane.
std::string myFirstVehicle
the first vehicle using this driveway
Definition MSDriveWay.h:351
int myNumericalID
global driveway index
Definition MSDriveWay.h:188
bool forwardEndOnRoute(const MSDriveWay *foe) const
bool myFoundJump
Definition MSDriveWay.h:207
static void saveState(OutputDevice &out)
Save driveway occupancy into the given stream.
static std::map< const MSEdge *, std::vector< MSDriveWay * >, ComparatorNumericalIdLess > myDepartureDriveways
all driveways that do not start at a rail signal (and are only used at departure)
Definition MSDriveWay.h:364
void setVehicle(const std::string &vehID)
Definition MSDriveWay.h:139
bool myBidiEnded
whether driveway building was aborted when no further bidi edge was found
Definition MSDriveWay.h:212
static bool mustYield(const Approaching &veh, const Approaching &foe)
Whether veh must yield to the foe train.
static const MSDriveWay * getDepartureDriveway(const SUMOVehicle *veh)
const std::vector< const MSEdge * > & getRoute() const
Definition MSDriveWay.h:111
void addSidings(MSDriveWay *foe, bool addToFoe=false)
add sidings for the given foe
bool bidiBlockedByEnd(const MSDriveWay &other) const
Wether there is a bidi conflict with the end of the given driveway.
static int myGlobalDriveWayIndex
Definition MSDriveWay.h:353
static MSDriveWay * buildDriveWay(const std::string &id, const MSLink *link, MSRouteIterator first, MSRouteIterator end)
construct a new driveway by searching along the given route until all block structures are found
bool myFoundSignal
whether this driveway ends its forward section with a rail signal (and thus comprises a full block)
Definition MSDriveWay.h:206
static std::map< const MSLink *, std::vector< MSDriveWay * > > mySwitchDriveWays
all driveways passing the given switch (used to look up flank foes)
Definition MSDriveWay.h:358
bool isFoeOrSubFoe(const MSDriveWay *foe) const
const std::vector< const MSLane * > & getFlank() const
Definition MSDriveWay.h:115
const std::vector< VehicleEvent > & getEvents() const
Definition MSDriveWay.h:131
void addDWDeadlock(const std::vector< const MSDriveWay * > &deadlockFoes)
static std::map< const MSEdge *, std::vector< MSDriveWay * >, ComparatorNumericalIdLess > myEndingDriveways
all driveways that end on the given edge
Definition MSDriveWay.h:370
bool foeDriveWayApproached() const
whether any of my Foes is being approached
static void loadState(const SUMOSAXAttributes &attrs, int tag)
bool forwardRouteConflict(std::set< const MSEdge * > forward, const MSDriveWay &other, bool secondCheck=false)
Wether the route of other passes into the forward section of this driveway.
std::pair< bool, const MSDriveWay * > canUseSiding(const SUMOVehicle *ego, const MSDriveWay *foe, bool recurse=true) const
return whether a siding can be used. If a siding exist but is occupied, also return the occupied driv...
std::vector< const MSLane * > myConflictLanes
the lanes that must be clear of trains before this signal can switch to green
Definition MSDriveWay.h:233
std::vector< MSDriveWay * > myFoes
Definition MSDriveWay.h:338
std::vector< VehicleEvent > myVehicleEvents
Definition MSDriveWay.h:337
std::set< const MSLane *, ComparatorNumericalIdLess > LaneSet
Definition MSDriveWay.h:44
static bool isSwitch(const MSLink *link)
bool notifyEnter(SUMOTrafficObject &veh, Notification reason, const MSLane *enteredLane)
Checks whether the reminder is activated by a vehicle entering the lane.
bool bidiBlockedBy(const MSDriveWay &other) const
Wether there is a bidi conflict with the given driveway.
bool reserve(const Approaching &closest, MSEdgeVector &occupied)
attempt reserve this driveway for the given vehicle
std::set< SUMOVehicle * > myTrains
Definition MSDriveWay.h:335
void addParallelFoes(const MSLink *link, const MSEdge *first)
derive foe driveways that start at the same signal
bool foeDriveWayOccupied(bool store, const SUMOVehicle *ego, MSEdgeVector &occupied) const
whether any of myFoes is occupied (vehicles that are the target of a join must be ignored)
A road/street connecting two junctions.
Definition MSEdge.h:77
Representation of a lane in the micro simulation.
Definition MSLane.h:84
Something on a lane to be noticed about vehicle movement.
Notification
Definition of a vehicle state.
A signal for rails.
Base class for objects which have an id.
Definition Named.h:54
Static storage of an output device and its base (abstract) implementation.
Encapsulated SAX-Attributes.
Representation of a vehicle, person, or container.
Representation of a vehicle.
Definition SUMOVehicle.h:62
Function-object for stable sorting of objects acting like Named without being derived (SUMOVehicle)
Definition Named.h:30
Function-object for stable sorting of objects with numerical ids.
Definition Named.h:39
Siding(int s, int e, double l)
Definition MSDriveWay.h:328
VehicleEvent(SUMOTime _time, bool _isEntry, const std::string &_id, Notification _reason)
Definition MSDriveWay.h:48