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-2020 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  bool isActive(const MSTrafficLightLogic* tl) const;
122 
125 
126  void switchTo(MSTLLogicControl& tlc, const std::string& programID);
127 
128  /* @brief get logic by programID. For the special case "off"
129  * instantiate an MSOffTrafficLightLogic */
131  const std::string& programID);
132 
133  /* @brief sets the state to the given string get for the special program "online"
134  * this program is instantiated only once */
136  const std::string& state);
137 
138 
139  void executeOnSwitchActions() const;
140  void addLink(MSLink* link, MSLane* lane, int pos);
141  void ignoreLinkIndex(int pos);
142 
143 
144  private:
147 
150 
152  std::map<std::string, MSTrafficLightLogic*> myVariants;
153 
155  std::map<MSLink*, LinkState> myOriginalLinkStates;
156 
158  std::vector<OnSwitchAction*> mySwitchActions;
159 
160 
161  private:
164 
167 
168 
169  };
170 
171 
172 
175 
176 
179 
180 
198  bool closeNetworkReading();
199 
200 
207  void setTrafficLightSignals(SUMOTime t) const;
208 
209 
215  std::vector<MSTrafficLightLogic*> getAllLogics() const;
216 
217 
224  TLSLogicVariants& get(const std::string& id) const;
225 
226 
233  MSTrafficLightLogic* get(const std::string& id, const std::string& programID) const;
234 
235 
241  MSTrafficLightLogic* getActive(const std::string& id) const;
242 
243 
249  std::vector<std::string> getAllTLIds() const;
250 
251 
273  bool add(const std::string& id, const std::string& programID,
274  MSTrafficLightLogic* logic, bool newDefault = true);
275 
276 
277 
282  bool knows(const std::string& id) const;
283 
284 
289  bool isActive(const MSTrafficLightLogic* tl) const;
290 
291 
300  void switchTo(const std::string& id, const std::string& programID);
301 
302 
303 
306 
316  void addWAUT(SUMOTime refTime, const std::string& id,
317  const std::string& startProg, SUMOTime period);
318 
319 
328  void addWAUTSwitch(const std::string& wautid, SUMOTime when,
329  const std::string& to);
330 
331 
343  void addWAUTJunction(const std::string& wautid, const std::string& tls,
344  const std::string& proc, bool synchron);
345 
346 
357  void closeWAUT(const std::string& wautid);
359 
360 
361 
366  void check2Switch(SUMOTime step);
367 
368 
376  std::pair<SUMOTime, MSPhaseDefinition> getPhaseDef(const std::string& tlid) const;
377 
379  void switchOffAll();
380 
383  void saveState(OutputDevice& out);
384 
386  void clearState();
387 
388 
389 
390 protected:
398  class SwitchInitCommand : public Command {
399  public:
405  SwitchInitCommand(MSTLLogicControl& p, const std::string& wautid, int index)
406  : myParent(p), myWAUTID(wautid), myIndex(index) { }
407 
408 
411 
412 
413 
416 
432  return myParent.initWautSwitch(*this);
433  }
435 
436 
437 
441  const std::string& getWAUTID() const {
442  return myWAUTID;
443  }
444 
445 
449  int& getIndex() {
450  return myIndex;
451  }
452 
453 
454  protected:
457 
459  std::string myWAUTID;
460 
462  int myIndex;
463 
464 
465  private:
468 
471 
472  };
473 
474 
475 
476 public:
484 
485 
486 protected:
490  struct WAUTSwitch {
494  std::string to;
495  };
496 
497 
501  struct WAUTJunction {
503  std::string junction;
505  std::string procedure;
507  bool synchron;
508  };
509 
510 
514  struct WAUT {
516  std::string id;
518  std::string startProg;
524  std::vector<WAUTSwitch> switches;
526  std::vector<WAUTJunction> junctions;
527  };
528 
529 
534  public:
544  bool synchron)
545  : myFrom(from), myTo(to), mySwitchSynchron(synchron), myWAUT(waut), myControl(control) { }
546 
547 
549  virtual ~WAUTSwitchProcedure() { }
550 
551 
556  virtual bool trySwitch(SUMOTime step);
557 
558 
559  protected:
570  bool isPosAtGSP(SUMOTime currentTime, const MSTrafficLightLogic& logic);
571 
578 
584  void switchToPos(SUMOTime simStep, MSTrafficLightLogic& logic, SUMOTime toTime);
585 
593  SUMOTime getGSPTime(const MSTrafficLightLogic& logic) const;
594 
600  virtual void adaptLogic(SUMOTime step) {
601  UNUSED_PARAMETER(step);
602  }
603 
604  protected:
607 
610 
613 
616 
619 
620 
621  private:
624 
627 
628  };
629 
630 
636  public:
646  bool synchron);
647 
650 
655  bool trySwitch(SUMOTime step);
656 
657  };
658 
659 
660 
666  public:
676  bool synchron);
677 
680 
681  protected:
684  void adaptLogic(SUMOTime step);
685 
686  };
687 
688 
694  public:
704  bool synchron);
705 
708 
709  protected:
715  void adaptLogic(SUMOTime step);
716 
722  void stretchLogic(SUMOTime step, SUMOTime startPos, SUMOTime allStretchTime);
723 
729  void cutLogic(SUMOTime step, SUMOTime startPos, SUMOTime allCutTime);
730 
731  protected:
735  struct StretchRange {
741  double fac;
742  };
743 
744  protected:
746  std::vector<StretchRange> myStretchRanges;
747  };
748 
749 
756  std::string junction;
763  };
764 
765 
767  std::map<std::string, WAUT*> myWAUTs;
768 
770  std::vector<WAUTSwitchProcess> myCurrentlySwitched;
771 
773  std::map<std::string, TLSLogicVariants*> myLogics;
774 
777 
778 
779 private:
782 
785 
786 };
long long int SUMOTime
Definition: SUMOTime.h:31
#define UNUSED_PARAMETER(x)
Definition: StdDefs.h:29
Base (microsim) event class.
Definition: Command.h:49
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:60
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.