SUMO - Simulation of Urban MObility
MSTrafficLightLogic.cpp
Go to the documentation of this file.
1 /****************************************************************************/
9 // The parent class for traffic light logics
10 /****************************************************************************/
11 // SUMO, Simulation of Urban MObility; see http://sumo.dlr.de/
12 // Copyright (C) 2001-2015 DLR (http://www.dlr.de/) and contributors
13 /****************************************************************************/
14 //
15 // This file is part of SUMO.
16 // SUMO is free software: you can redistribute it and/or modify
17 // it under the terms of the GNU General Public License as published by
18 // the Free Software Foundation, either version 3 of the License, or
19 // (at your option) any later version.
20 //
21 /****************************************************************************/
22 
23 
24 // ===========================================================================
25 // included modules
26 // ===========================================================================
27 #ifdef _MSC_VER
28 #include <windows_config.h>
29 #else
30 #include <config.h>
31 #endif
32 
33 #include <cassert>
34 #include <string>
35 #include <iostream>
36 #include <map>
37 #include <microsim/MSLink.h>
38 #include <microsim/MSLane.h>
39 #include "MSTrafficLightLogic.h"
41 #include "MSTLLogicControl.h"
43 
44 #ifdef CHECK_MEMORY_LEAKS
45 #include <foreign/nvwa/debug_new.h>
46 #endif // CHECK_MEMORY_LEAKS
47 
48 // ===========================================================================
49 // static value definitions
50 // ===========================================================================
52 
53 // ===========================================================================
54 // member method definitions
55 // ===========================================================================
56 /* -------------------------------------------------------------------------
57  * member method definitions
58  * ----------------------------------------------------------------------- */
60  MSTrafficLightLogic* tlLogic, SUMOTime nextSwitch)
61  : myTLControl(tlcontrol), myTLLogic(tlLogic),
62  myAssumedNextSwitch(nextSwitch), myAmValid(true) {}
63 
64 
66 
67 
68 
71  // check whether this command has been descheduled
72  if (!myAmValid) {
73  return 0;
74  }
75  //
76  const bool isActive = myTLControl.isActive(myTLLogic);
77  size_t step1 = myTLLogic->getCurrentPhaseIndex();
78  SUMOTime next = myTLLogic->trySwitch();
79  size_t step2 = myTLLogic->getCurrentPhaseIndex();
80  if (step1 != step2) {
81  if (isActive) {
82  // execute any action connected to this tls
83  const MSTLLogicControl::TLSLogicVariants& vars = myTLControl.get(myTLLogic->getID());
84  // set link priorities
85  myTLLogic->setTrafficLightSignals(t);
86  // execute switch actions
88  }
89  }
90  myAssumedNextSwitch += next;
91  return next;
92 }
93 
94 
95 void
97  if (tlLogic == myTLLogic) {
98  myAmValid = false;
99  myAssumedNextSwitch = -1;
100  }
101 }
102 
103 
104 /* -------------------------------------------------------------------------
105  * member method definitions
106  * ----------------------------------------------------------------------- */
108  const std::string& programID, SUMOTime delay, const std::map<std::string, std::string>& parameters) :
109  Named(id), Parameterised(parameters),
110  myProgramID(programID),
112  myDefaultCycleTime(0) {
113  mySwitchCommand = new SwitchCommand(tlcontrol, this, delay);
116 }
117 
118 
119 void
121  const Phases& phases = getPhases();
122  if (phases.size() > 1) {
123  bool haveWarnedAboutUnusedStates = false;
124  // warn about transistions from green to red without intermediate yellow
125  for (int i = 0; i < (int)phases.size(); ++i) {
126  const int iNext = (i + 1) % phases.size();
127  const std::string& state1 = phases[i]->getState();
128  const std::string& state2 = phases[iNext]->getState();
129  assert(state1.size() == state2.size());
130  if (!haveWarnedAboutUnusedStates && state1.size() > myLanes.size()) {
131  WRITE_WARNING("Unused states in tlLogic '" + getID()
132  + "', program '" + getProgramID() + "' in phase " + toString(i)
133  + " after tl-index " + toString((int)myLanes.size() - 1));
134  haveWarnedAboutUnusedStates = true;
135  }
136  for (int j = 0; j < (int)MIN3(state1.size(), state2.size(), myLanes.size()); ++j) {
137  if ((LinkState)state2[j] == LINKSTATE_TL_RED
138  && ((LinkState)state1[j] == LINKSTATE_TL_GREEN_MAJOR
139  || (LinkState)state1[j] == LINKSTATE_TL_GREEN_MINOR)) {
140  for (LaneVector::const_iterator it = myLanes[j].begin(); it != myLanes[j].end(); ++it) {
141  if ((*it)->getPermissions() != SVC_PEDESTRIAN) {
142  WRITE_WARNING("Missing yellow phase in tlLogic '" + getID()
143  + "', program '" + getProgramID() + "' for tl-index " + toString(j)
144  + " when switching to phase " + toString(iNext));
145  return; // one warning per program is enough
146  }
147  }
148  }
149  }
150  }
151  }
152 }
153 
154 
156  // no need to do something about mySwitchCommand here,
157  // it is handled by the event control
158 }
159 
160 
161 // ----------- Handling of controlled links
162 void
163 MSTrafficLightLogic::addLink(MSLink* link, MSLane* lane, unsigned int pos) {
164  // !!! should be done within the loader (checking necessary)
165  myLinks.reserve(pos + 1);
166  while (myLinks.size() <= pos) {
167  myLinks.push_back(LinkVector());
168  }
169  myLinks[pos].push_back(link);
170  //
171  myLanes.reserve(pos + 1);
172  while (myLanes.size() <= pos) {
173  myLanes.push_back(LaneVector());
174  }
175  myLanes[pos].push_back(lane);
176  link->setTLState((LinkState) getCurrentPhaseDef().getState()[pos], MSNet::getInstance()->getCurrentTimeStep());
177 }
178 
179 
180 void
182  myLinks = logic.myLinks;
183  myLanes = logic.myLanes;
184 }
185 
186 
187 std::map<MSLink*, LinkState>
189  std::map<MSLink*, LinkState> ret;
190  for (LinkVectorVector::const_iterator i1 = myLinks.begin(); i1 != myLinks.end(); ++i1) {
191  const LinkVector& l = (*i1);
192  for (LinkVector::const_iterator i2 = l.begin(); i2 != l.end(); ++i2) {
193  ret[*i2] = (*i2)->getState();
194  }
195  }
196  return ret;
197 }
198 
199 
200 bool
202  // get the current traffic light signal combination
203  const std::string& state = getCurrentPhaseDef().getState();
204  // go through the links
205  for (size_t i = 0; i < myLinks.size(); i++) {
206  const LinkVector& currGroup = myLinks[i];
207  LinkState ls = (LinkState) state[i];
208  for (LinkVector::const_iterator j = currGroup.begin(); j != currGroup.end(); j++) {
209  (*j)->setTLState(ls, t);
210  }
211  }
212  return true;
213 }
214 
215 
216 void
217 MSTrafficLightLogic::resetLinkStates(const std::map<MSLink*, LinkState>& vals) const {
218  for (LinkVectorVector::const_iterator i1 = myLinks.begin(); i1 != myLinks.end(); ++i1) {
219  const LinkVector& l = (*i1);
220  for (LinkVector::const_iterator i2 = l.begin(); i2 != l.end(); ++i2) {
221  assert(vals.find(*i2) != vals.end());
222  (*i2)->setTLState(vals.find(*i2)->second, MSNet::getInstance()->getCurrentTimeStep());
223  }
224  }
225 }
226 
227 
228 // ----------- Static Information Retrieval
229 int
230 MSTrafficLightLogic::getLinkIndex(const MSLink* const link) const {
231  int index = 0;
232  for (LinkVectorVector::const_iterator i1 = myLinks.begin(); i1 != myLinks.end(); ++i1, ++index) {
233  const LinkVector& l = (*i1);
234  for (LinkVector::const_iterator i2 = l.begin(); i2 != l.end(); ++i2) {
235  if ((*i2) == link) {
236  return index;
237  }
238  }
239  }
240  return -1;
241 }
242 
243 
244 
245 // ----------- Dynamic Information Retrieval
246 SUMOTime
248  return mySwitchCommand != 0 ? mySwitchCommand->getNextSwitchTime() : -1;
249 }
250 
251 
252 // ----------- Changing phases and phase durations
253 void
255  myOverridingTimes.push_back(duration);
256 }
257 
258 
259 void
262 }
263 
264 
265 /****************************************************************************/
266 
SUMOTime myCurrentDurationIncrement
A value for enlarge the current duration.
The link has green light, may pass.
void resetLinkStates(const std::map< MSLink *, LinkState > &vals) const
Resets the states of controlled links.
virtual const MSPhaseDefinition & getCurrentPhaseDef() const =0
Returns the definition of the current phase.
Builds detectors for microsim.
const std::string & getState() const
Returns the state within this phase.
bool setTrafficLightSignals(SUMOTime t) const
Applies the current signal states to controlled links.
is a pedestrian
Storage for all programs of a single tls.
std::vector< SUMOTime > myOverridingTimes
A list of duration overrides.
int getLinkIndex(const MSLink *const link) const
Returns the index of the given link.
SwitchCommand(MSTLLogicControl &tlcontrol, MSTrafficLightLogic *tlLogic, SUMOTime nextSwitch)
Constructor.
std::string myProgramID
The id of the logic.
The link has green light, has to brake.
static const LaneVector myEmptyLaneVector
An empty lane vector.
static MSNet * getInstance()
Returns the pointer to the unique instance of MSNet (singleton).
Definition: MSNet.cpp:159
MSTrafficLightLogic(MSTLLogicControl &tlcontrol, const std::string &id, const std::string &programID, SUMOTime delay, const std::map< std::string, std::string > &parameters)
Constructor.
SUMOTime getCurrentTimeStep() const
Returns the current simulation step.
Definition: MSNet.h:235
#define WRITE_WARNING(msg)
Definition: MsgHandler.h:200
LaneVectorVector myLanes
The list of LaneVectors; each vector contains the incoming lanes that belong to the same link index...
virtual ~MSTrafficLightLogic()
Destructor.
SUMOTime getNextSwitchTime() const
Returns the assumed next switch time.
A class that stores and controls tls and switching of their programs.
const std::string & getID() const
Returns the id.
Definition: Named.h:60
void deschedule(MSTrafficLightLogic *tlLogic)
Marks this swicth as invalid (if the phase duration has changed, f.e.)
Class realising the switch between the traffic light phases.
SUMOTime myDefaultCycleTime
The cycle time (without changes)
virtual void init(NLDetectorBuilder &nb)
Initialises the tls with information about incoming lanes.
MSEventControl * getBeginOfTimestepEvents()
Returns the event control for events executed at the begin of a time step.
Definition: MSNet.h:369
virtual void adaptLinkInformationFrom(const MSTrafficLightLogic &logic)
Applies information about controlled links and lanes from the given logic.
LinkState
The right-of-way state of a link between two lanes used when constructing a NBTrafficLightLogic, in MSLink and GNEInternalLane.
std::string toString(const T &t, std::streamsize accuracy=OUTPUT_ACCURACY)
Definition: ToString.h:53
An upper class for objects with additional parameters.
Definition: Parameterised.h:47
virtual SUMOTime addEvent(Command *operation, SUMOTime execTimeStep, AdaptType type)
Adds an Event.
void setCurrentDurationIncrement(SUMOTime delay)
Delays current phase by the given delay.
Base class for objects which have an id.
Definition: Named.h:45
std::vector< MSLink * > LinkVector
Definition of the list of links that participate in this tl-light.
SUMOTime getNextSwitchTime() const
Returns the assumed next switch time.
std::vector< MSPhaseDefinition * > Phases
Definition of a list of phases, being the junction logic.
virtual const Phases & getPhases() const =0
Returns the phases of this tls program.
void addOverridingDuration(SUMOTime duration)
Changes the duration of the next phase.
LinkVectorVector myLinks
The list of LinkVectors; each vector contains the links that belong to the same link index...
std::vector< MSLane * > LaneVector
Definition of the list of links that participate in this tl-light.
The link has red light (must brake)
int SUMOTime
Definition: SUMOTime.h:43
SwitchCommand * mySwitchCommand
The current switch command.
The parent class for traffic light logics.
const std::string & getProgramID() const
Returns this tl-logic's id.
void addLink(MSLink *link, MSLane *lane, unsigned int pos)
Adds a link on building.
T MIN3(T a, T b, T c)
Definition: StdDefs.h:81
Representation of a lane in the micro simulation.
Definition: MSLane.h:77
std::map< MSLink *, LinkState > collectLinkStates() const
Returns the (uncontrolled) states of the controlled links.
SUMOTime execute(SUMOTime currentTime)
Executes the regarded junction's "trySwitch"- method.