Line data Source code
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 : /****************************************************************************/
14 : /// @file MSRailSignal.h
15 : /// @author Melanie Weber
16 : /// @author Andreas Kendziorra
17 : /// @author Jakob Erdmann
18 : /// @date Jan 2015
19 : ///
20 : // A rail signal logic
21 : /****************************************************************************/
22 : #pragma once
23 : #include <config.h>
24 :
25 : #include <vector>
26 : #include <microsim/MSRoute.h>
27 : #include <microsim/traffic_lights/MSTrafficLightLogic.h>
28 : #include <microsim/traffic_lights/MSTLLogicControl.h>
29 :
30 :
31 : // ===========================================================================
32 : // class declarations
33 : // ===========================================================================
34 : class MSLink;
35 : class MSPhaseDefinition;
36 : class MSRailSignalConstraint;
37 : class MSDriveWay;
38 :
39 :
40 : // ===========================================================================
41 : // class definitions
42 : // ===========================================================================
43 : /**
44 : * @class MSRailSignal
45 : * @brief A signal for rails
46 : */
47 : class MSRailSignal : public MSTrafficLightLogic {
48 : public:
49 : /** @brief Constructor
50 : * @param[in] tlcontrol The tls control responsible for this tls
51 : * @param[in] id This tls' id
52 : * @param[in] programID This tls' sub-id (program id)
53 : * @param[in] parameters This tls' parameters
54 : * @param[in] delay The time to wait before the first switch
55 : */
56 : MSRailSignal(MSTLLogicControl& tlcontrol,
57 : const std::string& id, const std::string& programID, SUMOTime delay,
58 : const Parameterised::Map& parameters);
59 :
60 :
61 : /** @brief Initialises the rail signal with information about adjacent rail signals
62 : * @param[in] nb The detector builder
63 : * @exception ProcessError If something fails on initialisation
64 : */
65 : void init(NLDetectorBuilder& nb) override;
66 :
67 :
68 : /// @brief Destructor
69 : ~MSRailSignal();
70 :
71 : inline int getNumericalID() const {
72 2143902 : return myNumericalID;
73 : }
74 :
75 : /**@brief Sets a parameter and updates internal constants */
76 : void setParameter(const std::string& key, const std::string& value) override;
77 :
78 : /** @brief Adds a link on building
79 : * @param[in] link The controlled link
80 : * @param[in] lane The lane this link starts at
81 : * @param[in] pos The link's index (signal group) within this program
82 : */
83 : void addLink(MSLink* link, MSLane* lane, int pos) override;
84 :
85 : /// @name Handling of controlled links
86 : /// @{
87 :
88 : /** @brief Applies information about controlled links and lanes from the given logic
89 : * @param[in] logic The logic to use the information about controlled links/lanes from
90 : * @see MSTrafficLightLogic::adaptLinkInformationFrom
91 : */
92 : void adaptLinkInformationFrom(const MSTrafficLightLogic& logic) override;
93 : /// @}
94 :
95 :
96 : /// @name Switching and setting current rows
97 : /// @{
98 :
99 :
100 : /** @brief returns the state of the signal that actually required
101 : *
102 : * Returns the state of the rail signal that is actually required based on the
103 : * occupation of the adjoining blocks.
104 : *
105 : * @return The state actually required for this signal.
106 : */
107 :
108 : /// @brief updates the current phase of the signal and return whether it should be kept active
109 : bool updateCurrentPhase();
110 :
111 : /** @brief Switches to the next phase
112 : * @return The time of the next switch (always the next step)
113 : * @see MSTrafficLightLogic::trySwitch
114 : */
115 : SUMOTime trySwitch() override;
116 :
117 : /// @}
118 :
119 :
120 : /// @name Static Information Retrieval
121 : /// @{
122 :
123 : /** @brief Returns the number of phases
124 : * @return The number of this tls program's phases (always zero)
125 : * @see MSTrafficLightLogic::getPhaseNumber
126 : */
127 : int getPhaseNumber() const override;
128 :
129 : /** @brief Returns the phases of this tls program
130 : * @return The phases of this tls program
131 : * @see MSTrafficLightLogic::getPhases
132 : */
133 : const Phases& getPhases() const override;
134 :
135 : /** @brief Returns the definition of the phase from the given position within the plan
136 : *
137 : * Returns the current phase as there does not exist a plan of the phases.
138 : *
139 : * @param[in] givenstep The index of the phase within the plan
140 : * @return The definition of the phase at the given position
141 : * @see MSTrafficLightLogic::getPhase
142 : */
143 : const MSPhaseDefinition& getPhase(int givenstep) const override;
144 :
145 : /// @brief whether the given link index ever turns 'G'
146 629 : bool getsMajorGreen(int /*linkIndex*/) const override {
147 629 : return true;
148 : }
149 : /// @}
150 :
151 :
152 : /// @name Dynamic Information Retrieval
153 : /// @{
154 :
155 : /** @brief Returns the current index within the program
156 : * @return The index of the current phase within the tls (here, always zero will be returned)
157 : * @see MSTrafficLightLogic::getCurrentPhaseIndex
158 : */
159 : int getCurrentPhaseIndex() const override;
160 :
161 : /** @brief Returns the definition of the current phase
162 : * @return The current phase
163 : */
164 : const MSPhaseDefinition& getCurrentPhaseDef() const override;
165 : /// @}
166 :
167 :
168 : /// @name Conversion between time and phase
169 : /// @{
170 :
171 : /** @brief Returns the index of the logic at the given simulation step
172 : * @return The (estimated) index of the tls at the given simulation time step (here, always zero will be returned)
173 : * @see MSTrafficLightLogic::getPhaseIndexAtTime
174 : */
175 : SUMOTime getPhaseIndexAtTime(SUMOTime simStep) const override;
176 :
177 : /** @brief Returns the position (start of a phase during a cycle) from of a given step
178 : * @param[in] index The index of the phase to return the begin of
179 : * @return The begin time of the phase (here, always zero will be returned)
180 : * @see MSTrafficLightLogic::getOffsetFromIndex
181 : */
182 : SUMOTime getOffsetFromIndex(int index) const override;
183 :
184 : /** @brief Returns the step (the phasenumber) of a given position of the cycle
185 : * @param[in] offset The offset (time) for which the according phase shall be returned
186 : * @return The according phase (here, always zero will be returned)
187 : * @see MSTrafficLightLogic::getIndexFromOffset
188 : */
189 : int getIndexFromOffset(SUMOTime offset) const override;
190 : /// @}
191 :
192 :
193 : /// @name Changing phases and phase durations
194 : /// @{
195 :
196 : /** @brief Changes the current phase and her duration
197 : * @param[in] tlcontrol The responsible traffic lights control
198 : * @param[in] simStep The current simulation step
199 : * @param[in] step Index of the phase to use
200 : * @param[in] stepDuration The left duration of the phase
201 : * @see MSTrafficLightLogic::changeStepAndDuration
202 : */
203 0 : void changeStepAndDuration(MSTLLogicControl& tlcontrol, SUMOTime simStep, int step, SUMOTime stepDuration) override {
204 : UNUSED_PARAMETER(tlcontrol);
205 : UNUSED_PARAMETER(simStep);
206 : UNUSED_PARAMETER(step);
207 : UNUSED_PARAMETER(stepDuration);
208 0 : }
209 : /// @}
210 :
211 : /// @brief return vehicles that block the intersection/rail signal for vehicles that wish to pass the given linkIndex
212 : VehicleVector getBlockingVehicles(int linkIndex) override;
213 : std::string getBlockingVehicleIDs() const;
214 : /// @brief return vehicles that block the given driveWay
215 : static VehicleVector getBlockingVehicles(const MSDriveWay* dw);
216 :
217 : /// @brief return vehicles that approach the intersection/rail signal and are in conflict with vehicles that wish to pass the given linkIndex
218 : VehicleVector getRivalVehicles(int linkIndex) override;
219 : std::string getRivalVehicleIDs() const;
220 :
221 : /// @brief return vehicles that approach the intersection/rail signal and have priority over vehicles that wish to pass the given linkIndex
222 : VehicleVector getPriorityVehicles(int linkIndex) override;
223 : std::string getPriorityVehicleIDs() const;
224 :
225 : /// @brief return information regarding active rail signal constraints for the closest approaching vehicle
226 : std::string getConstraintInfo(int linkIndex);
227 : std::string getConstraintInfo() const;
228 :
229 : std::vector<const MSDriveWay*> getBlockingDriveWays(int linkIndex) override;
230 : std::string getBlockingDriveWayIDs() const;
231 :
232 : /// @brief return driveways that block the given driveWay
233 : static std::vector<const MSDriveWay*> getBlockingDriveWays(const MSDriveWay* dw);
234 :
235 : std::string getRequestedDriveWay(int linkIndex) override;
236 : std::string getRequestedDriveWay() const;
237 :
238 : /// @brief write rail signal block output for all links and driveways
239 : void writeBlocks(OutputDevice& od, bool writeVehicles) const;
240 :
241 : /// @brief register constraint for signal switching
242 : void addConstraint(const std::string& tripId, MSRailSignalConstraint* constraint);
243 :
244 : /// @name TraCI access to constraints
245 : /// @{
246 : const std::map<std::string, std::vector<MSRailSignalConstraint*> >& getConstraints() const {
247 : return myConstraints;
248 : }
249 :
250 : /// @brief remove constraint for signal switching
251 : bool removeConstraint(const std::string& tripId, MSRailSignalConstraint* constraint);
252 : void removeConstraints();
253 : /// @}
254 :
255 : /// update driveway for extended deadlock protection
256 : void updateDriveway(int numericalID);
257 :
258 : /* @brief return whether vehicle insertion must be delayed for an oncoming train
259 : * @param[in] link The rail signal link before which the vehicle is being inserted
260 : * @param[in] veh The vehicle being inserted
261 : * @param[in] brakeBeforeSignal Whether the vehicle may brake before the signal,
262 : * Returns true if the vehicle has to brake before the signal
263 : */
264 : static bool hasInsertionConstraint(MSLink* link, const MSVehicle* veh, std::string& info, bool& isInsertionOrder);
265 :
266 : static void initDriveWays(const SUMOVehicle* ego, bool update);
267 :
268 : typedef std::pair<const SUMOVehicle* const, const MSLink::ApproachingVehicleInformation> Approaching;
269 : typedef std::map<const MSLane*, int, ComparatorNumericalIdLess> LaneVisitedMap;
270 :
271 : /* @brief retrieve driveway with the given numerical id
272 : * @note: throws exception if the driveway does not exist at this rail signal */
273 : const MSDriveWay& retrieveDriveWay(int numericalID) const;
274 :
275 : const MSDriveWay& retrieveDriveWayForVeh(int tlIndex, const SUMOVehicle* veh);
276 : const MSDriveWay& retrieveDriveWayForRoute(int tlIndex, MSRouteIterator first, MSRouteIterator end);
277 :
278 : const std::vector<MSDriveWay*> retrieveDriveWays(int tlIndex) const;
279 :
280 : /// @brief whether the given vehicle is free to drive
281 : bool constraintsAllow(const SUMOVehicle* veh, bool storeWaitRelation = false) const;
282 :
283 : bool isMovingBlock() const {
284 6750 : return myMovingBlock;
285 : }
286 :
287 : static bool storeVehicles() {
288 645392 : return myStoreVehicles;
289 : }
290 :
291 : static VehicleVector& blockingVehicles() {
292 : return myBlockingVehicles;
293 : }
294 :
295 : static std::vector<const MSDriveWay*>& blockingDriveWays() {
296 : return myBlockingDriveWays;
297 : }
298 :
299 : static VehicleVector& rivalVehicles() {
300 : return myRivalVehicles;
301 : }
302 :
303 : static VehicleVector& priorityVehicles() {
304 : return myPriorityVehicles;
305 : }
306 :
307 : /// @brief print link descriptions
308 : static std::string describeLinks(std::vector<MSLink*> links);
309 :
310 : protected:
311 :
312 : const int myNumericalID;
313 :
314 : std::string getNewDrivewayID();
315 :
316 : /* The driveways for each link
317 : */
318 6033 : struct LinkInfo {
319 : /// @brief constructor
320 : LinkInfo(MSLink* link);
321 :
322 : /// @brief Destructor
323 : ~LinkInfo();
324 :
325 : MSLink* myLink;
326 :
327 : /// @brief all driveways immediately following this link
328 : std::vector<MSDriveWay*> myDriveways;
329 :
330 : /// @brief return id for this railsignal-link
331 : std::string getID() const;
332 :
333 : /// @brief retrieve an existing Driveway or construct a new driveway based on the vehicles route
334 : MSDriveWay& getDriveWay(const SUMOVehicle*);
335 : MSDriveWay& getDriveWay(MSRouteIterator firstIt, MSRouteIterator endIt, const std::string& info = "");
336 :
337 : /// @brief try rerouting vehicle if reservation failed
338 : void reroute(SUMOVehicle* veh, const MSEdgeVector& occupied);
339 :
340 : /// @brief init LinkInfo
341 : void reset();
342 :
343 : SUMOTime myLastRerouteTime;
344 : SUMOVehicle* myLastRerouteVehicle;
345 : };
346 :
347 : /// @brief data storage for every link at this node (more than one when directly guarding a switch)
348 : std::vector<LinkInfo> myLinkInfos;
349 :
350 : protected:
351 :
352 : /** @brief The list of phases this logic uses
353 : *
354 : * This vector is always empty and only constructed because the superclass MSTrafficLightLogic requires it.
355 : */
356 : Phases myPhases;
357 :
358 : /// @brief The current phase
359 : MSPhaseDefinition myCurrentPhase;
360 :
361 : /// @brief MSTrafficLightLogic requires that the phase index changes whenever signals change their state
362 : int myPhaseIndex;
363 :
364 : /// @brief whether the signal is in moving block mode (only protects from oncoming and flanking trains)
365 : bool myMovingBlock;
366 :
367 : /// @brief map from tripId to constraint list
368 : std::map<std::string, std::vector<MSRailSignalConstraint*> > myConstraints;
369 :
370 : /// @brief running number of driveways created for this signal
371 : int myDriveWayIndex;
372 :
373 : static int myRSIndex;
374 :
375 : protected:
376 : /// @brief update vehicle lists for traci calls
377 : void storeTraCIVehicles(int linkIndex);
378 : static void storeTraCIVehicles(const MSDriveWay* dw);
379 :
380 : /// @brief reset temporary storage for injected conflict output
381 : static void resetStored();
382 :
383 : /// @name traci result storage
384 : //@{
385 : static bool myStoreVehicles;
386 : static VehicleVector myBlockingVehicles;
387 : static VehicleVector myRivalVehicles;
388 : static VehicleVector myPriorityVehicles;
389 : static std::string myConstraintInfo;
390 : static std::vector<const MSDriveWay*> myBlockingDriveWays;
391 : static std::string myRequestedDriveWay;
392 : //@}
393 :
394 :
395 : };
|
