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 2144767 : 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 628 : bool getsMajorGreen(int /*linkIndex*/) const override {
147 628 : 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 :
215 : /// @brief return vehicles that approach the intersection/rail signal and are in conflict with vehicles that wish to pass the given linkIndex
216 : VehicleVector getRivalVehicles(int linkIndex) override;
217 : std::string getRivalVehicleIDs() const;
218 :
219 : /// @brief return vehicles that approach the intersection/rail signal and have priority over vehicles that wish to pass the given linkIndex
220 : VehicleVector getPriorityVehicles(int linkIndex) override;
221 : std::string getPriorityVehicleIDs() const;
222 :
223 : /// @brief return information regarding active rail signal constraints for the closest approaching vehicle
224 : std::string getConstraintInfo(int linkIndex);
225 : std::string getConstraintInfo() const;
226 :
227 : std::vector<const MSDriveWay*> getBlockingDriveWays(int linkIndex) override;
228 : std::string getBlockingDriveWayIDs() const;
229 :
230 : std::string getRequestedDriveWay(int linkIndex) override;
231 : std::string getRequestedDriveWay() const;
232 :
233 : /// @brief write rail signal block output for all links and driveways
234 : void writeBlocks(OutputDevice& od, bool writeVehicles) const;
235 :
236 : /// @brief register constraint for signal switching
237 : void addConstraint(const std::string& tripId, MSRailSignalConstraint* constraint);
238 :
239 : /// @name TraCI access to constraints
240 : /// @{
241 : const std::map<std::string, std::vector<MSRailSignalConstraint*> >& getConstraints() const {
242 : return myConstraints;
243 : }
244 :
245 : /// @brief remove constraint for signal switching
246 : bool removeConstraint(const std::string& tripId, MSRailSignalConstraint* constraint);
247 : void removeConstraints();
248 : /// @}
249 :
250 : /// update driveway for extended deadlock protection
251 : void updateDriveway(int numericalID);
252 :
253 : /* @brief return whether vehicle insertion must be delayed for an oncoming train
254 : * @param[in] link The rail signal link before which the vehicle is being inserted
255 : * @param[in] veh The vehicle being inserted
256 : * @param[in] brakeBeforeSignal Whether the vehicle may brake before the signal,
257 : * Returns true if the vehicle has to brake before the signal
258 : */
259 : static bool hasInsertionConstraint(MSLink* link, const MSVehicle* veh, std::string& info, bool& isInsertionOrder);
260 :
261 : static void initDriveWays(const SUMOVehicle* ego, bool update);
262 :
263 : typedef std::pair<const SUMOVehicle* const, const MSLink::ApproachingVehicleInformation> Approaching;
264 : typedef std::map<const MSLane*, int, ComparatorNumericalIdLess> LaneVisitedMap;
265 :
266 : /* @brief retrieve driveway with the given numerical id
267 : * @note: throws exception if the driveway does not exist at this rail signal */
268 : const MSDriveWay& retrieveDriveWay(int numericalID) const;
269 :
270 : const MSDriveWay& retrieveDriveWayForVeh(int tlIndex, const SUMOVehicle* veh);
271 : const MSDriveWay& retrieveDriveWayForRoute(int tlIndex, MSRouteIterator first, MSRouteIterator end);
272 :
273 : const std::vector<MSDriveWay*> retrieveDriveWays(int tlIndex) const;
274 :
275 : /// @brief whether the given vehicle is free to drive
276 : bool constraintsAllow(const SUMOVehicle* veh, bool storeWaitRelation = false) const;
277 :
278 : bool isMovingBlock() const {
279 6686 : return myMovingBlock;
280 : }
281 :
282 : static bool storeVehicles() {
283 643083 : return myStoreVehicles;
284 : }
285 :
286 : static VehicleVector& blockingVehicles() {
287 : return myBlockingVehicles;
288 : }
289 :
290 : static std::vector<const MSDriveWay*>& blockingDriveWays() {
291 : return myBlockingDriveWays;
292 : }
293 :
294 : static VehicleVector& rivalVehicles() {
295 : return myRivalVehicles;
296 : }
297 :
298 : static VehicleVector& priorityVehicles() {
299 : return myPriorityVehicles;
300 : }
301 :
302 : /// @brief print link descriptions
303 : static std::string describeLinks(std::vector<MSLink*> links);
304 :
305 : protected:
306 :
307 : const int myNumericalID;
308 :
309 : std::string getNewDrivewayID();
310 :
311 : /* The driveways for each link
312 : */
313 5973 : struct LinkInfo {
314 : /// @brief constructor
315 : LinkInfo(MSLink* link);
316 :
317 : /// @brief Destructor
318 : ~LinkInfo();
319 :
320 : MSLink* myLink;
321 :
322 : /// @brief all driveways immediately following this link
323 : std::vector<MSDriveWay*> myDriveways;
324 :
325 : /// @brief return id for this railsignal-link
326 : std::string getID() const;
327 :
328 : /// @brief retrieve an existing Driveway or construct a new driveway based on the vehicles route
329 : MSDriveWay& getDriveWay(const SUMOVehicle*);
330 : MSDriveWay& getDriveWay(MSRouteIterator firstIt, MSRouteIterator endIt, const std::string& info = "");
331 :
332 : /// @brief try rerouting vehicle if reservation failed
333 : void reroute(SUMOVehicle* veh, const MSEdgeVector& occupied);
334 :
335 : /// @brief init LinkInfo
336 : void reset();
337 :
338 : SUMOTime myLastRerouteTime;
339 : SUMOVehicle* myLastRerouteVehicle;
340 : };
341 :
342 : /// @brief data storage for every link at this node (more than one when directly guarding a switch)
343 : std::vector<LinkInfo> myLinkInfos;
344 :
345 : protected:
346 :
347 : /** @brief The list of phases this logic uses
348 : *
349 : * This vector is always empty and only constructed because the superclass MSTrafficLightLogic requires it.
350 : */
351 : Phases myPhases;
352 :
353 : /// @brief The current phase
354 : MSPhaseDefinition myCurrentPhase;
355 :
356 : /// @brief MSTrafficLightLogic requires that the phase index changes whenever signals change their state
357 : int myPhaseIndex;
358 :
359 : /// @brief whether the signal is in moving block mode (only protects from oncoming and flanking trains)
360 : bool myMovingBlock;
361 :
362 : /// @brief map from tripId to constraint list
363 : std::map<std::string, std::vector<MSRailSignalConstraint*> > myConstraints;
364 :
365 : /// @brief running number of driveways created for this signal
366 : int myDriveWayIndex;
367 :
368 : static int myRSIndex;
369 :
370 : protected:
371 : /// @brief update vehicle lists for traci calls
372 : void storeTraCIVehicles(int linkIndex);
373 :
374 : /// @name traci result storage
375 : //@{
376 : static bool myStoreVehicles;
377 : static VehicleVector myBlockingVehicles;
378 : static VehicleVector myRivalVehicles;
379 : static VehicleVector myPriorityVehicles;
380 : static std::string myConstraintInfo;
381 : static std::vector<const MSDriveWay*> myBlockingDriveWays;
382 : static std::string myRequestedDriveWay;
383 : //@}
384 :
385 :
386 : };
|
