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);
125  const std::string& programID);
126  void executeOnSwitchActions() const;
127  void addLink(MSLink* link, MSLane* lane, unsigned int pos);
128 
129 
130 
131  private:
134 
136  std::map<std::string, MSTrafficLightLogic*> myVariants;
137 
139  std::map<MSLink*, LinkState> myOriginalLinkStates;
140 
142  std::vector<OnSwitchAction*> mySwitchActions;
143 
144 
145  private:
148 
151 
152 
153  };
154 
155 
156 
159 
160 
163 
164 
182  bool closeNetworkReading();
183 
184 
191  void setTrafficLightSignals(SUMOTime t) const;
192 
193 
199  std::vector<MSTrafficLightLogic*> getAllLogics() const;
200 
201 
208  TLSLogicVariants& get(const std::string& id) const;
209 
210 
217  MSTrafficLightLogic* get(const std::string& id, const std::string& programID) const;
218 
219 
225  MSTrafficLightLogic* getActive(const std::string& id) const;
226 
227 
233  std::vector<std::string> getAllTLIds() const;
234 
235 
257  bool add(const std::string& id, const std::string& programID,
258  MSTrafficLightLogic* logic, bool newDefault = true);
259 
260 
261 
266  bool knows(const std::string& id) const;
267 
268 
273  bool isActive(const MSTrafficLightLogic* tl) const;
274 
275 
284  void switchTo(const std::string& id, const std::string& programID);
285 
286 
287 
290 
299  void addWAUT(SUMOTime refTime, const std::string& id,
300  const std::string& startProg);
301 
302 
311  void addWAUTSwitch(const std::string& wautid, SUMOTime when,
312  const std::string& to);
313 
314 
326  void addWAUTJunction(const std::string& wautid, const std::string& tls,
327  const std::string& proc, bool synchron);
328 
329 
340  void closeWAUT(const std::string& wautid);
342 
343 
344 
349  void check2Switch(SUMOTime step);
350 
351 
359  std::pair<SUMOTime, MSPhaseDefinition> getPhaseDef(const std::string& tlid) const;
360 
361 
362 
363 protected:
371  class SwitchInitCommand : public Command {
372  public:
378  SwitchInitCommand(MSTLLogicControl& p, const std::string& wautid, unsigned int index)
379  : myParent(p), myWAUTID(wautid), myIndex(index) { }
380 
381 
384 
385 
386 
389 
405  return myParent.initWautSwitch(*this);
406  }
408 
409 
410 
414  const std::string& getWAUTID() const {
415  return myWAUTID;
416  }
417 
418 
422  unsigned int& getIndex() {
423  return myIndex;
424  }
425 
426 
427  protected:
430 
432  std::string myWAUTID;
433 
435  unsigned int myIndex;
436 
437 
438  private:
441 
444 
445  };
446 
447 
448 
449 public:
457 
458 
459 protected:
463  struct WAUTSwitch {
467  std::string to;
468  };
469 
470 
474  struct WAUTJunction {
476  std::string junction;
478  std::string procedure;
480  bool synchron;
481  };
482 
483 
487  struct WAUT {
489  std::string id;
491  std::string startProg;
495  std::vector<WAUTSwitch> switches;
497  std::vector<WAUTJunction> junctions;
498  };
499 
500 
505  public:
515  bool synchron)
516  : myFrom(from), myTo(to), mySwitchSynchron(synchron), myWAUT(waut), myControl(control) { }
517 
518 
520  virtual ~WAUTSwitchProcedure() { }
521 
522 
527  virtual bool trySwitch(SUMOTime step) = 0;
528 
529 
530  protected:
541  bool isPosAtGSP(SUMOTime currentTime, const MSTrafficLightLogic& logic);
542 
543 
550 
551 
557  void switchToPos(SUMOTime simStep, MSTrafficLightLogic& logic, SUMOTime toTime);
558 
559 
567  unsigned int getGSPValue(const MSTrafficLightLogic& logic) const;
568 
569 
570  protected:
573 
576 
579 
582 
585 
586 
587  private:
590 
593 
594  };
595 
596 
602  public:
612  bool synchron);
613 
614 
617 
618 
623  bool trySwitch(SUMOTime step);
624 
625 
626  private:
629 
632 
633  };
634 
635 
636 
642  public:
652  bool synchron);
653 
656 
657 
662  bool trySwitch(SUMOTime step);
663 
664 
665  protected:
668  void adaptLogic(SUMOTime step);
669 
670 
671  private:
674 
677 
678  };
679 
680 
686  public:
696  bool synchron);
697 
698 
701 
702 
707  bool trySwitch(SUMOTime step);
708 
709 
710  protected:
716  void adaptLogic(SUMOTime step);
717 
718 
724  void stretchLogic(SUMOTime step, SUMOTime startPos, SUMOTime allStretchTime);
725 
726 
732  void cutLogic(SUMOTime step, SUMOTime startPos, SUMOTime allCutTime);
733 
734 
735  protected:
746 
747  };
748 
749 
754  int getStretchAreaNo(MSTrafficLightLogic* from) const;
755 
756 
765 
766 
767  private:
770 
773 
774  };
775 
776 
783  std::string junction;
790  };
791 
792 
794  std::map<std::string, WAUT*> myWAUTs;
795 
797  std::vector<WAUTSwitchProcess> myCurrentlySwitched;
798 
800  std::map<std::string, TLSLogicVariants*> myLogics;
801 
804 
805 
806 private:
809 
812 
813 };
814 
815 
816 #endif
817 
818 /****************************************************************************/
819 
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.
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:221
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:73
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.