SUMO - Simulation of Urban MObility
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
MSTLLogicControl.h
Go to the documentation of this file.
1 /****************************************************************************/
11 // A class that stores and controls tls and switching of their programs
12 /****************************************************************************/
13 // SUMO, Simulation of Urban MObility; see http://sumo-sim.org/
14 // Copyright (C) 2001-2013 DLR (http://www.dlr.de/) and contributors
15 /****************************************************************************/
16 //
17 // This file is part of SUMO.
18 // SUMO is free software: you can redistribute it and/or modify
19 // it under the terms of the GNU General Public License as published by
20 // the Free Software Foundation, either version 3 of the License, or
21 // (at your option) any later version.
22 //
23 /****************************************************************************/
24 #ifndef MSTLLogicControl_h
25 #define MSTLLogicControl_h
26 
27 
28 // ===========================================================================
29 // included modules
30 // ===========================================================================
31 #ifdef _MSC_VER
32 #include <windows_config.h>
33 #else
34 #include <config.h>
35 #endif
36 
37 #include <vector>
38 #include <map>
39 #include "MSTrafficLightLogic.h"
41 #include <utils/common/Command.h>
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;
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 */
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 */
133  const std::string& state);
134 
135 
136  void executeOnSwitchActions() const;
137  void addLink(MSLink* link, MSLane* lane, unsigned int pos);
138 
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 
371 
372 
373 protected:
381  class SwitchInitCommand : public Command {
382  public:
388  SwitchInitCommand(MSTLLogicControl& p, const std::string& wautid, unsigned int index)
389  : myParent(p), myWAUTID(wautid), myIndex(index) { }
390 
391 
394 
395 
396 
399 
415  return myParent.initWautSwitch(*this);
416  }
418 
419 
420 
424  const std::string& getWAUTID() const {
425  return myWAUTID;
426  }
427 
428 
432  unsigned int& getIndex() {
433  return myIndex;
434  }
435 
436 
437  protected:
440 
442  std::string myWAUTID;
443 
445  unsigned int myIndex;
446 
447 
448  private:
451 
454 
455  };
456 
457 
458 
459 public:
467 
468 
469 protected:
473  struct WAUTSwitch {
477  std::string to;
478  };
479 
480 
484  struct WAUTJunction {
486  std::string junction;
488  std::string procedure;
490  bool synchron;
491  };
492 
493 
497  struct WAUT {
499  std::string id;
501  std::string startProg;
505  std::vector<WAUTSwitch> switches;
507  std::vector<WAUTJunction> junctions;
508  };
509 
510 
515  public:
525  bool synchron)
526  : myFrom(from), myTo(to), mySwitchSynchron(synchron), myWAUT(waut), myControl(control) { }
527 
528 
530  virtual ~WAUTSwitchProcedure() { }
531 
532 
537  virtual bool trySwitch(SUMOTime step) = 0;
538 
539 
540  protected:
551  bool isPosAtGSP(SUMOTime currentTime, const MSTrafficLightLogic& logic);
552 
553 
560 
561 
567  void switchToPos(SUMOTime simStep, MSTrafficLightLogic& logic, SUMOTime toTime);
568 
569 
577  unsigned int getGSPValue(const MSTrafficLightLogic& logic) const;
578 
579 
580  protected:
583 
586 
589 
592 
595 
596 
597  private:
600 
603 
604  };
605 
606 
612  public:
622  bool synchron);
623 
624 
627 
628 
633  bool trySwitch(SUMOTime step);
634 
635 
636  private:
639 
642 
643  };
644 
645 
646 
652  public:
662  bool synchron);
663 
666 
667 
672  bool trySwitch(SUMOTime step);
673 
674 
675  protected:
678  void adaptLogic(SUMOTime step);
679 
680 
681  private:
684 
687 
688  };
689 
690 
696  public:
706  bool synchron);
707 
708 
711 
712 
717  bool trySwitch(SUMOTime step);
718 
719 
720  protected:
726  void adaptLogic(SUMOTime step);
727 
728 
734  void stretchLogic(SUMOTime step, SUMOTime startPos, SUMOTime allStretchTime);
735 
736 
742  void cutLogic(SUMOTime step, SUMOTime startPos, SUMOTime allCutTime);
743 
744 
745  protected:
756 
757  };
758 
759 
764  int getStretchAreaNo(MSTrafficLightLogic* from) const;
765 
766 
775 
776 
777  private:
780 
783 
784  };
785 
786 
793  std::string junction;
800  };
801 
802 
804  std::map<std::string, WAUT*> myWAUTs;
805 
807  std::vector<WAUTSwitchProcess> myCurrentlySwitched;
808 
810  std::map<std::string, TLSLogicVariants*> myLogics;
811 
814 
815 
816 private:
819 
822 
823 };
824 
825 
826 #endif
827 
828 /****************************************************************************/
829 
bool checkOriginalTLS() const
Verifies traffic lights loaded from the network.
bool trySwitch(SUMOTime step)
Determines whether a switch is possible.
bool add(const std::string &id, const std::string &programID, MSTrafficLightLogic *logic, bool newDefault=true)
Adds a tls program to the container.
bool isActive(const MSTrafficLightLogic *tl) const
Returns whether the given tls program is the currently active for his tls.
void cutLogic(SUMOTime step, SUMOTime startPos, SUMOTime allCutTime)
Cuts the logic to synchronize.
std::map< MSLink *, LinkState > myOriginalLinkStates
Originally loaded link states.
SUMOReal end
The end of a stretch/cut area (time, in s)
std::map< std::string, TLSLogicVariants * > myLogics
A map from ids to the corresponding variants.
unsigned int getGSPValue(const MSTrafficLightLogic &logic) const
Returns the GSP-value.
Storage for all programs of a single tls.
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.
~MSTLLogicControl()
Destructor.
WAUTSwitchProcedure_GSP(MSTLLogicControl &control, WAUT &waut, MSTrafficLightLogic *from, MSTrafficLightLogic *to, bool synchron)
Constructor.
void setTrafficLightSignals(SUMOTime t) const
Lets all running (current) tls programs apply their current signal states to links they control...
std::string myWAUTID
The id of the WAUT that shall switch.
MSTrafficLightLogic * getActive(const std::string &id) const
Returns the active program of a named tls.
bool trySwitch(SUMOTime step)
Determines whether a switch is possible.
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.
WAUTSwitchProcedure_Stretch(MSTLLogicControl &control, WAUT &waut, MSTrafficLightLogic *from, MSTrafficLightLogic *to, bool synchron)
Constructor.
std::vector< std::string > getAllTLIds() const
virtual ~WAUTSwitchProcedure()
Destructor.
MSTLLogicControl()
Constructor.
Base (microsim) event class.
Definition: Command.h:61
WAUT & myWAUT
The WAUT responsible for switching.
void closeWAUT(const std::string &wautid)
Closes loading of a WAUT.
MSTrafficLightLogic * getLogic(const std::string &programID) const
SUMOTime initWautSwitch(SwitchInitCommand &cmd)
Initialises switching a WAUT.
void addLink(MSLink *link, MSLane *lane, unsigned int pos)
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.
std::vector< MSTrafficLightLogic * > getAllLogics() const
bool mySwitchSynchron
Information whether to switch synchron (?)
MSTLLogicControl & myControl
The control the logic belongs to.
bool addLogic(const std::string &programID, MSTrafficLightLogic *logic, bool netWasLoaded, bool isNewDefault=true)
Adds a logic (program)
void addSwitchCommand(OnSwitchAction *c)
MSTrafficLightLogic * getLogicInstantiatingOff(MSTLLogicControl &tlc, const std::string &programID)
bool isActive(const MSTrafficLightLogic *tl) const
MSTLLogicControl & operator=(const MSTLLogicControl &)
Invalidated assignment operator.
MSTrafficLightLogic * getActive() const
std::pair< SUMOTime, MSPhaseDefinition > getPhaseDef(const std::string &tlid) const
return the complete phase definition for a named traffic lights logic
WAUTSwitchProcedure * proc
The used procedure.
void adaptLogic(SUMOTime step)
Stretches the destination program&#39;s phase to which the tls was switched.
WAUTSwitchProcedure(MSTLLogicControl &control, WAUT &waut, MSTrafficLightLogic *from, MSTrafficLightLogic *to, bool synchron)
Constructor.
SUMOReal fac
The weight factor of a stretch/cut area.
This class simply switches to the next program.
bool synchron
Information whether this junction shall be switched synchron.
void adaptLogic(SUMOTime step)
Determines the destination program&#39;s changes and applies them.
virtual bool trySwitch(SUMOTime step)=0
Determines whether a switch is possible.
unsigned int myIndex
The current index within the WAUT switch table.
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 getStretchAreaNo(MSTrafficLightLogic *from) const
Returns the number of given Stretch-areas for the given program.
SUMOTime when
The time the WAUT shall switch the TLS.
void stretchLogic(SUMOTime step, SUMOTime startPos, SUMOTime allStretchTime)
Stretches the logic to synchronize.
SUMOReal begin
The begin of a stretch/cut area (time, in s)
std::vector< OnSwitchAction * > mySwitchActions
The list of actions/commands to execute on switch.
void setStateInstantiatingOnline(MSTLLogicControl &tlc, const std::string &state)
bool knows(const std::string &id) const
Returns the information whether the named tls is stored.
bool trySwitch(SUMOTime step)
Determines whether a switch is possible.
std::string startProg
The name of the start program.
WAUTSwitchProcedure & operator=(const WAUTSwitchProcedure &)
Invalidated assignment operator.
const std::string & getWAUTID() const
Returns the WAUT-id.
WAUTSwitchProcedure_JustSwitch(MSTLLogicControl &control, WAUT &waut, MSTrafficLightLogic *from, MSTrafficLightLogic *to, bool synchron)
Constructor.
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.
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.
WAUTSwitchProcedure_GSP & operator=(const WAUTSwitchProcedure_GSP &)
Invalidated assignment operator.
void switchTo(MSTLLogicControl &tlc, const std::string &programID)
StretchBereichDef getStretchBereichDef(MSTrafficLightLogic *from, int index) const
Returns the numbered Stretch-area for the given program.
std::vector< WAUTSwitch > switches
The list of switches to be done by the WAUT.
unsigned int & getIndex()
Returns a reference to the index.
virtual void execute()=0
Executes the action.
void switchToPos(SUMOTime simStep, MSTrafficLightLogic &logic, SUMOTime toTime)
switches the given logic directly to the given position
This event-class is used to initialise a WAUT switch at a certain time.
WAUTSwitchProcedure_Stretch & operator=(const WAUTSwitchProcedure_Stretch &)
Invalidated assignment operator.
void addWAUT(SUMOTime refTime, const std::string &id, const std::string &startProg)
Adds a WAUT definition.
This class switches using the GSP algorithm.
SUMOTime getDiffToStartOfPhase(MSTrafficLightLogic &logic, SUMOTime toTime)
Returns the difference between a given time and the start of the phase.
SUMOTime refTime
The reference time (offset to the switch times)
This is the abstract base class for switching from one tls program to another.
std::string id
The id of the WAUT.
WAUTSwitchProcedure_JustSwitch & operator=(const WAUTSwitchProcedure_JustSwitch &)
Invalidated assignment operator.
TLSLogicVariants & operator=(const TLSLogicVariants &)
Invalidated assignment operator.
std::map< std::string, WAUT * > myWAUTs
A map of ids to corresponding WAUTs.
bool isPosAtGSP(SUMOTime currentTime, const MSTrafficLightLogic &logic)
Checks, whether the position of a signal programm is at the GSP (&quot;GuenstigerUmschaltPunkt&quot;) ...
The parent class for traffic light logics.
#define SUMOReal
Definition: config.h:215
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.
std::vector< MSTrafficLightLogic * > getAllLogics() const
Returns a vector which contains all logics.
MSTrafficLightLogic * from
The current program of the tls.
SwitchInitCommand(MSTLLogicControl &p, const std::string &wautid, unsigned int index)
Constructor.
MSTrafficLightLogic * myFrom
The current program of the tls to switch.
Representation of a lane in the micro simulation.
Definition: MSLane.h:77
SUMOTime execute(SUMOTime)
Begins a WAUT switch by executing the command.
MSTrafficLightLogic * myCurrentProgram
The currently used program.
SwitchInitCommand & operator=(const SwitchInitCommand &)
Invalidated assignment operator.
std::string junction
The junction name.
A WAUT definition.