Eclipse SUMO - Simulation of Urban MObility
MSTLLogicControl.h
Go to the documentation of this file.
1/****************************************************************************/
2// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3// Copyright (C) 2001-2022 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 class that stores and controls tls and switching of their programs
23/****************************************************************************/
24#pragma once
25#include <config.h>
26
27#include <vector>
28#include <map>
32
33
34// ===========================================================================
35// class declarations
36// ===========================================================================
38class MSLink;
39class MSLane;
41class OutputDevice;
42
43
44// ===========================================================================
45// class definitions
46// ===========================================================================
60public:
66 public:
68 virtual ~OnSwitchAction() {};
69
70
73 virtual void execute() = 0;
74
75 };
76
77
78
86 public:
89
90
93
94
101 bool checkOriginalTLS() const;
102
103
111 bool addLogic(const std::string& programID, MSTrafficLightLogic* logic, bool netWasLoaded,
112 bool isNewDefault = true);
113
114
115
116 MSTrafficLightLogic* getLogic(const std::string& programID) const;
118 std::vector<MSTrafficLightLogic*> getAllLogics() const;
119 void saveInitialStates();
120 void saveState(OutputDevice& out);
121 bool isActive(const MSTrafficLightLogic* tl) const;
123
126
127 void switchTo(MSTLLogicControl& tlc, const std::string& programID);
128
129 /* @brief get logic by programID. For the special case "off"
130 * instantiate an MSOffTrafficLightLogic */
132 const std::string& programID);
133
134 /* @brief sets the state to the given string get for the special program "online"
135 * this program is instantiated only once */
137 const std::string& state);
138
139
140 void executeOnSwitchActions() const;
141 void addLink(MSLink* link, MSLane* lane, int pos);
142 void ignoreLinkIndex(int pos);
143
144
145 private:
148
151
153 std::map<std::string, MSTrafficLightLogic*> myVariants;
154
156 std::map<MSLink*, LinkState> myOriginalLinkStates;
157
159 std::vector<OnSwitchAction*> mySwitchActions;
160
161
162 private:
165
168
169
170 };
171
172
173
176
177
180
181
199 bool closeNetworkReading();
200
201
208 void setTrafficLightSignals(SUMOTime t) const;
209
210
216 std::vector<MSTrafficLightLogic*> getAllLogics() const;
217
218
225 TLSLogicVariants& get(const std::string& id) const;
226
227
234 MSTrafficLightLogic* get(const std::string& id, const std::string& programID) const;
235
236
242 MSTrafficLightLogic* getActive(const std::string& id) const;
243
244
250 std::vector<std::string> getAllTLIds() const;
251
252
274 bool add(const std::string& id, const std::string& programID,
275 MSTrafficLightLogic* logic, bool newDefault = true);
276
277
278
283 bool knows(const std::string& id) const;
284
285
290 bool isActive(const MSTrafficLightLogic* tl) const;
291
292
301 void switchTo(const std::string& id, const std::string& programID);
302
303
304
307
317 void addWAUT(SUMOTime refTime, const std::string& id,
318 const std::string& startProg, SUMOTime period);
319
320
329 void addWAUTSwitch(const std::string& wautid, SUMOTime when,
330 const std::string& to);
331
332
344 void addWAUTJunction(const std::string& wautid, const std::string& tls,
345 const std::string& proc, bool synchron);
346
347
358 void closeWAUT(const std::string& wautid);
360
361
362
367 void check2Switch(SUMOTime step);
368
369
377 std::pair<SUMOTime, MSPhaseDefinition> getPhaseDef(const std::string& tlid) const;
378
380 void switchOffAll();
381
384 void saveState(OutputDevice& out);
385
387 void clearState(SUMOTime time, bool quickReload = false);
388
389
390
391protected:
399 class SwitchInitCommand : public Command {
400 public:
406 SwitchInitCommand(MSTLLogicControl& p, const std::string& wautid, int index)
407 : myParent(p), myWAUTID(wautid), myIndex(index) { }
408
409
412
413
414
417
433 return myParent.initWautSwitch(*this);
434 }
436
437
438
442 const std::string& getWAUTID() const {
443 return myWAUTID;
444 }
445
446
450 int& getIndex() {
451 return myIndex;
452 }
453
454
455 protected:
458
460 std::string myWAUTID;
461
464
465
466 private:
469
472
473 };
474
475
476
477public:
485
486
487protected:
491 struct WAUTSwitch {
495 std::string to;
496 };
497
498
504 std::string junction;
506 std::string procedure;
509 };
510
511
515 struct WAUT {
517 std::string id;
519 std::string startProg;
525 std::vector<WAUTSwitch> switches;
527 std::vector<WAUTJunction> junctions;
528 };
529
530
535 public:
545 bool synchron)
546 : myFrom(from), myTo(to), mySwitchSynchron(synchron), myWAUT(waut), myControl(control) { }
547
548
551
552
557 virtual bool trySwitch(SUMOTime step);
558
559
560 protected:
571 bool isPosAtGSP(SUMOTime currentTime, const MSTrafficLightLogic& logic);
572
579
585 void switchToPos(SUMOTime simStep, MSTrafficLightLogic& logic, SUMOTime toTime);
586
594 SUMOTime getGSPTime(const MSTrafficLightLogic& logic) const;
595
601 virtual void adaptLogic(SUMOTime step) {
602 UNUSED_PARAMETER(step);
603 }
604
605 protected:
608
611
614
617
620
621
622 private:
625
628
629 };
630
631
637 public:
647 bool synchron);
648
651
656 bool trySwitch(SUMOTime step);
657
658 };
659
660
661
667 public:
677 bool synchron);
678
681
682 protected:
685 void adaptLogic(SUMOTime step);
686
687 };
688
689
695 public:
705 bool synchron);
706
709
710 protected:
716 void adaptLogic(SUMOTime step);
717
723 void stretchLogic(SUMOTime step, SUMOTime startPos, SUMOTime allStretchTime);
724
730 void cutLogic(SUMOTime step, SUMOTime startPos, SUMOTime allCutTime);
731
732 protected:
742 double fac;
743 };
744
745 protected:
747 std::vector<StretchRange> myStretchRanges;
748 };
749
750
757 std::string junction;
764 };
765
766
768 std::map<std::string, WAUT*> myWAUTs;
769
771 std::vector<WAUTSwitchProcess> myCurrentlySwitched;
772
774 std::map<std::string, TLSLogicVariants*> myLogics;
775
778
779
780private:
783
786
787};
long long int SUMOTime
Definition: GUI.h:36
#define UNUSED_PARAMETER(x)
Definition: StdDefs.h:30
Base (microsim) event class.
Definition: Command.h:50
Representation of a lane in the micro simulation.
Definition: MSLane.h:84
The definition of a single phase of a tls logic.
Base class for things to execute if a tls switches to a new phase.
virtual void execute()=0
Executes the action.
virtual ~OnSwitchAction()
Destructor.
This event-class is used to initialise a WAUT switch at a certain time.
MSTLLogicControl & myParent
The control to call.
const std::string & getWAUTID() const
Returns the WAUT-id.
SwitchInitCommand & operator=(const SwitchInitCommand &)
Invalidated assignment operator.
int myIndex
The current index within the WAUT switch table.
SwitchInitCommand(MSTLLogicControl &p, const std::string &wautid, int index)
Constructor.
int & getIndex()
Returns a reference to the index.
SwitchInitCommand(const SwitchInitCommand &)
Invalidated copy constructor.
SUMOTime execute(SUMOTime)
Begins a WAUT switch by executing the command.
std::string myWAUTID
The id of the WAUT that shall switch.
Storage for all programs of a single tls.
void addLink(MSLink *link, MSLane *lane, int pos)
void switchTo(MSTLLogicControl &tlc, const std::string &programID)
void addSwitchCommand(OnSwitchAction *c)
TLSLogicVariants & operator=(const TLSLogicVariants &)
Invalidated assignment operator.
void setStateInstantiatingOnline(MSTLLogicControl &tlc, const std::string &state)
bool checkOriginalTLS() const
Verifies traffic lights loaded from the network.
std::vector< OnSwitchAction * > mySwitchActions
The list of actions/commands to execute on switch.
std::map< MSLink *, LinkState > myOriginalLinkStates
Originally loaded link states.
TLSLogicVariants(const TLSLogicVariants &)
Invalidated copy constructor.
std::vector< MSTrafficLightLogic * > getAllLogics() const
MSTrafficLightLogic * getLogic(const std::string &programID) const
std::map< std::string, MSTrafficLightLogic * > myVariants
A map of subkeys to programs.
MSTrafficLightLogic * myDefaultProgram
The program that would be used in the absence of TraCI.
bool addLogic(const std::string &programID, MSTrafficLightLogic *logic, bool netWasLoaded, bool isNewDefault=true)
Adds a logic (program)
MSTrafficLightLogic * myCurrentProgram
The currently used program.
MSTrafficLightLogic * getActive() const
MSTrafficLightLogic * getDefault() const
return the default program (that last used program except TRACI_PROGRAM)
MSTrafficLightLogic * getLogicInstantiatingOff(MSTLLogicControl &tlc, const std::string &programID)
bool isActive(const MSTrafficLightLogic *tl) const
This class switches using the GSP algorithm.
WAUTSwitchProcedure_GSP(MSTLLogicControl &control, WAUT &waut, MSTrafficLightLogic *from, MSTrafficLightLogic *to, bool synchron)
Constructor.
void adaptLogic(SUMOTime step)
Stretches the destination program's phase to which the tls was switched.
This class simply switches to the next program.
bool trySwitch(SUMOTime step)
Determines whether a switch is possible.
WAUTSwitchProcedure_JustSwitch(MSTLLogicControl &control, WAUT &waut, MSTrafficLightLogic *from, MSTrafficLightLogic *to, bool synchron)
Constructor.
This class switches using the Stretch algorithm.
void adaptLogic(SUMOTime step)
Determines the destination program's changes and applies them.
std::vector< StretchRange > myStretchRanges
the given Stretch-areas for the "to" program, this is 0-based indexed, while the input is 1-based
WAUTSwitchProcedure_Stretch(MSTLLogicControl &control, WAUT &waut, MSTrafficLightLogic *from, MSTrafficLightLogic *to, bool synchron)
Constructor.
void cutLogic(SUMOTime step, SUMOTime startPos, SUMOTime allCutTime)
Cuts the logic to synchronize.
void stretchLogic(SUMOTime step, SUMOTime startPos, SUMOTime allStretchTime)
Stretches the logic to synchronize.
This is the abstract base class for switching from one tls program to another.
virtual bool trySwitch(SUMOTime step)
Determines whether a switch is possible.
MSTrafficLightLogic * myTo
The program to switch the tls to.
WAUTSwitchProcedure(const WAUTSwitchProcedure &)
Invalidated copy constructor.
bool isPosAtGSP(SUMOTime currentTime, const MSTrafficLightLogic &logic)
Checks, whether the position of a signal programm is at the GSP ("Good Switching Point")
bool mySwitchSynchron
Information whether to switch synchron (?)
WAUTSwitchProcedure & operator=(const WAUTSwitchProcedure &)
Invalidated assignment operator.
WAUTSwitchProcedure(MSTLLogicControl &control, WAUT &waut, MSTrafficLightLogic *from, MSTrafficLightLogic *to, bool synchron)
Constructor.
MSTLLogicControl & myControl
The control the logic belongs to.
MSTrafficLightLogic * myFrom
The current program of the tls to switch.
SUMOTime getGSPTime(const MSTrafficLightLogic &logic) const
Returns the GSP-value.
SUMOTime getDiffToStartOfPhase(MSTrafficLightLogic &logic, SUMOTime toTime)
Returns the difference between a given time and the start of the phase.
virtual void adaptLogic(SUMOTime step)
Changes the destination program's phase to which the tls was switched.
void switchToPos(SUMOTime simStep, MSTrafficLightLogic &logic, SUMOTime toTime)
switches the given logic directly to the given position
WAUT & myWAUT
The WAUT responsible for switching.
A class that stores and controls tls and switching of their programs.
void addWAUTJunction(const std::string &wautid, const std::string &tls, const std::string &proc, bool synchron)
Adds a tls to the list of tls to be switched by the named WAUT.
MSTLLogicControl & operator=(const MSTLLogicControl &)
Invalidated assignment operator.
void clearState(SUMOTime time, bool quickReload=false)
Clear all tls states before quick-loading state.
std::vector< MSTrafficLightLogic * > getAllLogics() const
Returns a vector which contains all logics.
std::vector< WAUTSwitchProcess > myCurrentlySwitched
A list of currently running switching procedures.
std::pair< SUMOTime, MSPhaseDefinition > getPhaseDef(const std::string &tlid) const
return the complete phase definition for a named traffic lights logic
std::map< std::string, TLSLogicVariants * > myLogics
A map from ids to the corresponding variants.
void addWAUT(SUMOTime refTime, const std::string &id, const std::string &startProg, SUMOTime period)
Adds a WAUT definition.
std::vector< std::string > getAllTLIds() const
void switchTo(const std::string &id, const std::string &programID)
Switches the named (id) tls to the named (programID) program.
MSTrafficLightLogic * getActive(const std::string &id) const
Returns the active program of a named tls.
bool closeNetworkReading()
Lets MSTLLogicControl know that the network has been loaded.
void setTrafficLightSignals(SUMOTime t) const
Lets all running (current) tls programs apply their current signal states to links they control.
bool knows(const std::string &id) const
Returns the information whether the named tls is stored.
MSTLLogicControl(const MSTLLogicControl &)
Invalidated copy constructor.
void saveState(OutputDevice &out)
Saves the current tls states into the given stream.
bool myNetWasLoaded
Information whether the net was completely loaded.
void switchOffAll()
switch all logic variants to 'off'
void addWAUTSwitch(const std::string &wautid, SUMOTime when, const std::string &to)
Adds a WAUT switch step to a previously built WAUT.
TLSLogicVariants & get(const std::string &id) const
Returns the variants of a named tls.
MSTLLogicControl()
Constructor.
SUMOTime initWautSwitch(SwitchInitCommand &cmd)
Initialises switching a WAUT.
~MSTLLogicControl()
Destructor.
void check2Switch(SUMOTime step)
Checks whether any WAUT is trying to switch a tls into another program.
std::map< std::string, WAUT * > myWAUTs
A map of ids to corresponding WAUTs.
bool isActive(const MSTrafficLightLogic *tl) const
Returns whether the given tls program is the currently active for his tls.
bool add(const std::string &id, const std::string &programID, MSTrafficLightLogic *logic, bool newDefault=true)
Adds a tls program to the container.
void closeWAUT(const std::string &wautid)
Closes loading of a WAUT.
The parent class for traffic light logics.
Static storage of an output device and its base (abstract) implementation.
Definition: OutputDevice.h:61
A WAUT definition.
std::string startProg
The name of the start program.
std::vector< WAUTSwitch > switches
The list of switches to be done by the WAUT.
std::vector< WAUTJunction > junctions
The list of switches assigned to the WAUT.
SUMOTime period
The period with which to repeat switches.
std::string id
The id of the WAUT.
SUMOTime refTime
The reference time (offset to the switch times)
Storage for a junction assigned to a WAUT.
std::string procedure
The procedure to switch the junction with.
bool synchron
Information whether this junction shall be switched synchron.
std::string junction
The junction name.
Storage for a WAUTs switch point.
SUMOTime when
The time the WAUT shall switch the TLS.
std::string to
The program name the WAUT shall switch the TLS to.
double fac
The weight factor of a stretch/cut area.
An initialised switch process.
MSTrafficLightLogic * to
The program to switch the tls to.
std::string junction
The id of the junction to switch.
MSTrafficLightLogic * from
The current program of the tls.
WAUTSwitchProcedure * proc
The used procedure.