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-2018 German Aerospace Center (DLR) and others.
4 // This program and the accompanying materials
5 // are made available under the terms of the Eclipse Public License v2.0
6 // which accompanies this distribution, and is available at
7 // http://www.eclipse.org/legal/epl-v20.html
8 // SPDX-License-Identifier: EPL-2.0
9 /****************************************************************************/
19 // A class that stores and controls tls and switching of their programs
20 /****************************************************************************/
21 #ifndef MSTLLogicControl_h
22 #define MSTLLogicControl_h
23 
24 
25 // ===========================================================================
26 // included modules
27 // ===========================================================================
28 #include <config.h>
29 
30 #include <vector>
31 #include <map>
33 #include <utils/common/Command.h>
34 
35 
36 // ===========================================================================
37 // class declarations
38 // ===========================================================================
40 class MSLink;
41 class MSLane;
42 class MSPhaseDefinition;
43 
44 
45 // ===========================================================================
46 // class definitions
47 // ===========================================================================
61 public:
67  public:
69  virtual ~OnSwitchAction() {};
70 
71 
74  virtual void execute() = 0;
75 
76  };
77 
78 
79 
87  public:
90 
91 
94 
95 
102  bool checkOriginalTLS() const;
103 
104 
112  bool addLogic(const std::string& programID, MSTrafficLightLogic* logic, bool netWasLoaded,
113  bool isNewDefault = true);
114 
115 
116 
117  MSTrafficLightLogic* getLogic(const std::string& programID) const;
118  void addSwitchCommand(OnSwitchAction* c);
119  std::vector<MSTrafficLightLogic*> getAllLogics() const;
120  void saveInitialStates();
121  bool isActive(const MSTrafficLightLogic* tl) const;
123  void switchTo(MSTLLogicControl& tlc, const std::string& programID);
124 
125  /* @brief get logic by programID. For the special case "off"
126  * instantiate an MSOffTrafficLightLogic */
127  MSTrafficLightLogic* getLogicInstantiatingOff(MSTLLogicControl& tlc,
128  const std::string& programID);
129 
130  /* @brief sets the state to the given string get for the special program "online"
131  * this program is instantiated only once */
132  void setStateInstantiatingOnline(MSTLLogicControl& tlc,
133  const std::string& state);
134 
135 
136  void executeOnSwitchActions() const;
137  void addLink(MSLink* link, MSLane* lane, int pos);
138  void ignoreLinkIndex(int pos);
139 
140 
141  private:
144 
146  std::map<std::string, MSTrafficLightLogic*> myVariants;
147 
149  std::map<MSLink*, LinkState> myOriginalLinkStates;
150 
152  std::vector<OnSwitchAction*> mySwitchActions;
153 
154 
155  private:
158 
161 
162 
163  };
164 
165 
166 
169 
170 
173 
174 
192  bool closeNetworkReading();
193 
194 
201  void setTrafficLightSignals(SUMOTime t) const;
202 
203 
209  std::vector<MSTrafficLightLogic*> getAllLogics() const;
210 
211 
218  TLSLogicVariants& get(const std::string& id) const;
219 
220 
227  MSTrafficLightLogic* get(const std::string& id, const std::string& programID) const;
228 
229 
235  MSTrafficLightLogic* getActive(const std::string& id) const;
236 
237 
243  std::vector<std::string> getAllTLIds() const;
244 
245 
267  bool add(const std::string& id, const std::string& programID,
268  MSTrafficLightLogic* logic, bool newDefault = true);
269 
270 
271 
276  bool knows(const std::string& id) const;
277 
278 
283  bool isActive(const MSTrafficLightLogic* tl) const;
284 
285 
294  void switchTo(const std::string& id, const std::string& programID);
295 
296 
297 
300 
309  void addWAUT(SUMOTime refTime, const std::string& id,
310  const std::string& startProg);
311 
312 
321  void addWAUTSwitch(const std::string& wautid, SUMOTime when,
322  const std::string& to);
323 
324 
336  void addWAUTJunction(const std::string& wautid, const std::string& tls,
337  const std::string& proc, bool synchron);
338 
339 
350  void closeWAUT(const std::string& wautid);
352 
353 
354 
359  void check2Switch(SUMOTime step);
360 
361 
369  std::pair<SUMOTime, MSPhaseDefinition> getPhaseDef(const std::string& tlid) const;
370 
372  void switchOffAll();
373 
374 
375 
376 protected:
384  class SwitchInitCommand : public Command {
385  public:
391  SwitchInitCommand(MSTLLogicControl& p, const std::string& wautid, int index)
392  : myParent(p), myWAUTID(wautid), myIndex(index) { }
393 
394 
397 
398 
399 
402 
418  return myParent.initWautSwitch(*this);
419  }
421 
422 
423 
427  const std::string& getWAUTID() const {
428  return myWAUTID;
429  }
430 
431 
435  int& getIndex() {
436  return myIndex;
437  }
438 
439 
440  protected:
443 
445  std::string myWAUTID;
446 
448  int myIndex;
449 
450 
451  private:
454 
457 
458  };
459 
460 
461 
462 public:
470 
471 
472 protected:
476  struct WAUTSwitch {
480  std::string to;
481  };
482 
483 
487  struct WAUTJunction {
489  std::string junction;
491  std::string procedure;
493  bool synchron;
494  };
495 
496 
500  struct WAUT {
502  std::string id;
504  std::string startProg;
508  std::vector<WAUTSwitch> switches;
510  std::vector<WAUTJunction> junctions;
511  };
512 
513 
518  public:
528  bool synchron)
529  : myFrom(from), myTo(to), mySwitchSynchron(synchron), myWAUT(waut), myControl(control) { }
530 
531 
533  virtual ~WAUTSwitchProcedure() { }
534 
535 
540  virtual bool trySwitch(SUMOTime step) = 0;
541 
542 
543  protected:
554  bool isPosAtGSP(SUMOTime currentTime, const MSTrafficLightLogic& logic);
555 
556 
562  SUMOTime getDiffToStartOfPhase(MSTrafficLightLogic& logic, SUMOTime toTime);
563 
564 
570  void switchToPos(SUMOTime simStep, MSTrafficLightLogic& logic, SUMOTime toTime);
571 
572 
580  int getGSPValue(const MSTrafficLightLogic& logic) const;
581 
582 
583  protected:
586 
589 
592 
595 
598 
599 
600  private:
603 
606 
607  };
608 
609 
615  public:
625  bool synchron);
626 
627 
630 
631 
636  bool trySwitch(SUMOTime step);
637 
638 
639  private:
642 
645 
646  };
647 
648 
649 
655  public:
665  bool synchron);
666 
669 
670 
675  bool trySwitch(SUMOTime step);
676 
677 
678  protected:
681  void adaptLogic(SUMOTime step);
682 
683 
684  private:
687 
690 
691  };
692 
693 
699  public:
709  bool synchron);
710 
711 
714 
715 
720  bool trySwitch(SUMOTime step);
721 
722 
723  protected:
729  void adaptLogic(SUMOTime step);
730 
731 
737  void stretchLogic(SUMOTime step, SUMOTime startPos, SUMOTime allStretchTime);
738 
739 
745  void cutLogic(SUMOTime step, SUMOTime startPos, SUMOTime allCutTime);
746 
747 
748  protected:
754  double begin;
756  double end;
758  double fac;
759 
760  };
761 
762 
767  int getStretchAreaNo(MSTrafficLightLogic* from) const;
768 
769 
777  StretchBereichDef getStretchBereichDef(MSTrafficLightLogic* from, int index) const;
778 
779 
780  private:
783 
786 
787  };
788 
789 
796  std::string junction;
803  };
804 
805 
807  std::map<std::string, WAUT*> myWAUTs;
808 
810  std::vector<WAUTSwitchProcess> myCurrentlySwitched;
811 
813  std::map<std::string, TLSLogicVariants*> myLogics;
814 
817 
818 
819 private:
822 
825 
826 };
827 
828 
829 #endif
830 
831 /****************************************************************************/
832 
double end
The end of a stretch/cut area (time, in s)
bool add(const std::string &id, const std::string &programID, MSTrafficLightLogic *logic, bool newDefault=true)
Adds a tls program to the container.
void switchOffAll()
switch all logic variants to &#39;off&#39;
long long int SUMOTime
Definition: SUMOTime.h:36
std::map< MSLink *, LinkState > myOriginalLinkStates
Originally loaded link states.
int & getIndex()
Returns a reference to the index.
std::map< std::string, TLSLogicVariants * > myLogics
A map from ids to the corresponding variants.
Storage for all programs of a single tls.
double fac
The weight factor of a stretch/cut area.
Base class for things to execute if a tls switches to a new phase.
void switchTo(const std::string &id, const std::string &programID)
Switches the named (id) tls to the named (programID) program.
std::map< std::string, MSTrafficLightLogic * > myVariants
A map of subkeys to programs.
SwitchInitCommand(MSTLLogicControl &p, const std::string &wautid, int index)
Constructor.
~MSTLLogicControl()
Destructor.
std::string myWAUTID
The id of the WAUT that shall switch.
bool isActive(const MSTrafficLightLogic *tl) const
Returns whether the given tls program is the currently active for his tls.
double begin
The begin of a stretch/cut area (time, in s)
std::string junction
The id of the junction to switch.
std::string procedure
The procedure to switch the junction with.
MSTLLogicControl & myParent
The control to call.
virtual ~OnSwitchAction()
Destructor.
MSTrafficLightLogic * myTo
The program to switch the tls to.
virtual ~WAUTSwitchProcedure()
Destructor.
MSTLLogicControl()
Constructor.
Base (microsim) event class.
Definition: Command.h:54
WAUT & myWAUT
The WAUT responsible for switching.
void closeWAUT(const std::string &wautid)
Closes loading of a WAUT.
SUMOTime initWautSwitch(SwitchInitCommand &cmd)
Initialises switching a WAUT.
bool myNetWasLoaded
Information whether the net was completely loaded.
Storage for a junction assigned to a WAUT.
A class that stores and controls tls and switching of their programs.
bool mySwitchSynchron
Information whether to switch synchron (?)
MSTLLogicControl & myControl
The control the logic belongs to.
std::pair< SUMOTime, MSPhaseDefinition > getPhaseDef(const std::string &tlid) const
return the complete phase definition for a named traffic lights logic
MSTLLogicControl & operator=(const MSTLLogicControl &)
Invalidated assignment operator.
WAUTSwitchProcedure * proc
The used procedure.
WAUTSwitchProcedure(MSTLLogicControl &control, WAUT &waut, MSTrafficLightLogic *from, MSTrafficLightLogic *to, bool synchron)
Constructor.
MSTrafficLightLogic * getActive(const std::string &id) const
Returns the active program of a named tls.
This class simply switches to the next program.
bool synchron
Information whether this junction shall be switched synchron.
MSTrafficLightLogic * to
The program to switch the tls to.
This class switches using the Stretch algorithm.
void check2Switch(SUMOTime step)
Checks whether any WAUT is trying to switch a tls into another program.
int myIndex
The current index within the WAUT switch table.
SUMOTime when
The time the WAUT shall switch the TLS.
std::vector< OnSwitchAction * > mySwitchActions
The list of actions/commands to execute on switch.
std::string startProg
The name of the start program.
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< WAUTJunction > junctions
The list of switches assigned to the WAUT.
bool knows(const std::string &id) const
Returns the information whether the named tls is stored.
std::vector< WAUTSwitchProcess > myCurrentlySwitched
A list of currently running switching procedures.
bool closeNetworkReading()
Lets MSTLLogicControl know that the network has been loaded.
An initialised switch process.
std::vector< WAUTSwitch > switches
The list of switches to be done by the WAUT.
virtual void execute()=0
Executes the action.
This event-class is used to initialise a WAUT switch at a certain time.
void addWAUT(SUMOTime refTime, const std::string &id, const std::string &startProg)
Adds a WAUT definition.
This class switches using the GSP algorithm.
SUMOTime refTime
The reference time (offset to the switch times)
This is the abstract base class for switching from one tls program to another.
const std::string & getWAUTID() const
Returns the WAUT-id.
std::string id
The id of the WAUT.
std::map< std::string, WAUT * > myWAUTs
A map of ids to corresponding WAUTs.
The parent class for traffic light logics.
Storage for a WAUTs switch point.
void addWAUTSwitch(const std::string &wautid, SUMOTime when, const std::string &to)
Adds a WAUT switch step to a previously built WAUT.
std::string to
The program name the WAUT shall switch the TLS to.
MSTrafficLightLogic * from
The current program of the tls.
std::vector< std::string > getAllTLIds() const
void setTrafficLightSignals(SUMOTime t) const
Lets all running (current) tls programs apply their current signal states to links they control...
MSTrafficLightLogic * myFrom
The current program of the tls to switch.
The definition of a single phase of a tls logic.
Representation of a lane in the micro simulation.
Definition: MSLane.h:78
SUMOTime execute(SUMOTime)
Begins a WAUT switch by executing the command.
MSTrafficLightLogic * myCurrentProgram
The currently used program.
std::vector< MSTrafficLightLogic * > getAllLogics() const
Returns a vector which contains all logics.
std::string junction
The junction name.
A WAUT definition.