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>
29 #include <utils/common/Command.h>
30 #include <utils/common/StdDefs.h>
32 
33 
34 // ===========================================================================
35 // class declarations
36 // ===========================================================================
38 class MSLink;
39 class MSLane;
40 class MSPhaseDefinition;
41 class OutputDevice;
42 
43 
44 // ===========================================================================
45 // class definitions
46 // ===========================================================================
60 public:
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();
388 
389 
390 
391 protected:
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 
463  int myIndex;
464 
465 
466  private:
469 
472 
473  };
474 
475 
476 
477 public:
485 
486 
487 protected:
491  struct WAUTSwitch {
495  std::string to;
496  };
497 
498 
502  struct WAUTJunction {
504  std::string junction;
506  std::string procedure;
508  bool synchron;
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 
550  virtual ~WAUTSwitchProcedure() { }
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:
736  struct StretchRange {
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 
780 private:
783 
786 
787 };
long long int SUMOTime
Definition: SUMOTime.h:32
#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:82
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.
const std::string & getWAUTID() const
Returns the WAUT-id.
MSTLLogicControl & myParent
The control to call.
int & getIndex()
Returns a reference to the index.
int myIndex
The current index within the WAUT switch table.
SwitchInitCommand & operator=(const SwitchInitCommand &)
Invalidated assignment operator.
SwitchInitCommand(MSTLLogicControl &p, const std::string &wautid, int index)
Constructor.
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)
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.
TLSLogicVariants & operator=(const TLSLogicVariants &)
Invalidated assignment operator.
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.
WAUTSwitchProcedure & operator=(const WAUTSwitchProcedure &)
Invalidated assignment operator.
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(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.
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.
MSTLLogicControl & operator=(const MSTLLogicControl &)
Invalidated assignment operator.
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.
void clearState()
Clear all tls states before quick-loading state.
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.