Eclipse SUMO - Simulation of Urban MObility
MSTrafficLightLogic.cpp
Go to the documentation of this file.
1/****************************************************************************/
2// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3// Copyright (C) 2001-2022 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/****************************************************************************/
20// The parent class for traffic light logics
21/****************************************************************************/
22#include <config.h>
23
24#include <cassert>
25#include <string>
26#include <iostream>
27#include <map>
28#include <microsim/MSLink.h>
29#include <microsim/MSLane.h>
32#include <microsim/MSNet.h>
33#include <microsim/MSEdge.h>
34#include <microsim/MSGlobals.h>
35#include <mesosim/MESegment.h>
36#include "MSTLLogicControl.h"
37#include "MSTrafficLightLogic.h"
38
39
40// ===========================================================================
41// static value definitions
42// ===========================================================================
44
45
46// ===========================================================================
47// member method definitions
48// ===========================================================================
49/* -------------------------------------------------------------------------
50 * member method definitions
51 * ----------------------------------------------------------------------- */
53 MSTrafficLightLogic* tlLogic, SUMOTime nextSwitch) :
54 myTLControl(tlcontrol), myTLLogic(tlLogic),
55 myAssumedNextSwitch(nextSwitch), myAmValid(true) {
56 // higher than default command priority of 0
57 priority = 1;
58}
59
60
62
63
64
67 // check whether this command has been descheduled
68 if (!myAmValid) {
69 return 0;
70 }
71 int step1 = myTLLogic->getCurrentPhaseIndex();
72 SUMOTime next = myTLLogic->trySwitch();
73 int step2 = myTLLogic->getCurrentPhaseIndex();
74 if (step1 != step2) {
75 if (myTLLogic->isActive()) {
76 // execute any action connected to this tls
77 const MSTLLogicControl::TLSLogicVariants& vars = myTLControl.get(myTLLogic->getID());
78 // set link priorities
79 myTLLogic->setTrafficLightSignals(t);
80 // execute switch actions
82 }
83 }
84 myAssumedNextSwitch += next;
85 return next;
86}
87
88
89void
91 if (tlLogic == myTLLogic) {
92 myAmValid = false;
93 myAssumedNextSwitch = -1;
94 }
95}
96
99 if (myTLLogic->getDefaultCycleTime() == DELTA_T) {
100 // MSRailSignal
101 return newTime;
102 } else {
103 UNUSED_PARAMETER(currentTime);
104 UNUSED_PARAMETER(execTime);
105 // XXX changeStepAndDuration (computed as in NLJunctionControlBuilder::closeTrafficLightLogic
106 return newTime;
107 }
108}
109
110/* -------------------------------------------------------------------------
111 * member method definitions
112 * ----------------------------------------------------------------------- */
114 const std::string& programID, const SUMOTime offset, const TrafficLightType logicType, const SUMOTime delay,
115 const Parameterised::Map& parameters) :
116 Named(id), Parameterised(parameters),
117 myProgramID(programID),
118 myOffset(offset),
119 myLogicType(logicType),
122 myAmActive(true) {
123 mySwitchCommand = new SwitchCommand(tlcontrol, this, delay);
125}
126
127
128void
130 const Phases& phases = getPhases();
131 if (phases.size() > 0 && (MSGlobals::gUseMesoSim || MSGlobals::gTLSPenalty > 0)) {
133 }
134 if (phases.size() > 1) {
135 bool haveWarnedAboutUnusedStates = false;
136 std::vector<bool> foundGreen(phases.front()->getState().size(), false);
137 for (int i = 0; i < (int)phases.size(); ++i) {
138 // warn about unused states
139 std::vector<int> nextPhases;
140 nextPhases.push_back((i + 1) % phases.size());
141 bool iNextDefault = true;
142 if (phases[i]->nextPhases.size() > 0) {
143 nextPhases = phases[i]->nextPhases;
144 iNextDefault = false;
145 }
146 for (int iNext : nextPhases) {
147 if (iNext < 0 || iNext >= (int)phases.size()) {
148 throw ProcessError("Invalid nextPhase " + toString(iNext) + " in tlLogic '" + getID()
149 + "', program '" + getProgramID() + "' with " + toString(phases.size()) + " phases");
150 }
151 const std::string optionalFrom = iNextDefault ? "" : " from phase " + toString(i);
152 const std::string& state1 = phases[i]->getState();
153 const std::string& state2 = phases[iNext]->getState();
154 if (state1.size() != state2.size()) {
155 throw ProcessError("Mismatching phase state length in tlLogic '" + getID()
156 + "', program '" + getProgramID() + "' in phases " + toString(i) + " and " + toString(iNext));
157 }
158 if (!haveWarnedAboutUnusedStates && state1.size() > myLanes.size() + myIgnoredIndices.size()) {
159 WRITE_WARNINGF(TL("Unused states in tlLogic '%', program '%' in phase % after tl-index %"),
160 getID(), getProgramID(), i, (int)myLanes.size() - 1);
161 haveWarnedAboutUnusedStates = true;
162 }
163 // detect illegal states
164 const std::string::size_type illegal = state1.find_first_not_of(SUMOXMLDefinitions::ALLOWED_TLS_LINKSTATES);
165 if (std::string::npos != illegal) {
166 throw ProcessError("Illegal character '" + toString(state1[illegal]) + "' in tlLogic '" + getID()
167 + "', program '" + getProgramID() + "' in phase " + toString(i));
168 }
169 // warn about transitions from green to red without intermediate yellow
170 bool haveWarned = false;
171 for (int j = 0; j < (int)MIN3(state1.size(), state2.size(), myLanes.size()) && !haveWarned; ++j) {
172 if ((LinkState)state2[j] == LINKSTATE_TL_RED
173 && ((LinkState)state1[j] == LINKSTATE_TL_GREEN_MAJOR
174 || (LinkState)state1[j] == LINKSTATE_TL_GREEN_MINOR)) {
175 for (LaneVector::const_iterator it = myLanes[j].begin(); it != myLanes[j].end(); ++it) {
176 if ((*it)->getPermissions() != SVC_PEDESTRIAN) {
178 WRITE_WARNINGF(TL("Missing yellow phase in tlLogic '%', program '%' for tl-index % when switching% to phase %."),
179 getID(), getProgramID(), j, optionalFrom, iNext);
180 // one warning per program is enough
181 haveWarned = true;
182 }
183 break;
184 }
185 }
186 }
187 }
188 // warn about links that never get the green light
189 for (int j = 0; j < (int)state1.size(); ++j) {
190 LinkState ls = (LinkState)state1[j];
192 foundGreen[j] = true;
193 }
194 }
195 }
196 }
197 for (int j = 0; j < (int)foundGreen.size(); ++j) {
198 if (!foundGreen[j]) {
200 WRITE_WARNINGF(TL("Missing green phase in tlLogic '%', program '%' for tl-index %."), getID(), getProgramID(), j);
201 }
202 break;
203 }
204 }
205 }
206 // check incompatible junction logic
207 // this can happen if the network was built with a very different signal
208 // plan from the one currently being used.
209 // Connections that never had a common green phase during network building may
210 // have a symmetric response relation to avoid certain kinds of jam but this
211 // can lead to deadlock if a different program gives minor green to both
212 // connections at the same time
213 // Note: mutual conflict between 'g' and 'G' is expected for traffic_light_right_on_red
214
215 const bool mustCheck = MSNet::getInstance()->hasInternalLinks();
216 // The checks only runs for definitions from additional file and this is sufficient.
217 // The distinction is implicit because original logics are loaded earlier and at that time hasInternalLinks is always false
218 // Also, when the network has no internal links, mutual conflicts are not built by netconvert
219 //std::cout << "init tlLogic=" << getID() << " prog=" << getProgramID() << " links=" << myLinks.size() << " internal=" << MSNet::getInstance()->hasInternalLinks() << "\n";
220 if (mustCheck && phases.size() > 0) {
221 // see NBNode::tlsConflict
222 std::set<const MSJunction*> controlledJunctions;
223 const int numLinks = (int)myLinks.size();
224 for (int j = 0; j < numLinks; ++j) {
225 for (int k = 0; k < (int)myLinks[j].size(); ++k) {
226 MSLink* link = myLinks[j][k];
227 assert(link->getJunction() != nullptr);
228 controlledJunctions.insert(link->getJunction());
229 }
230 }
231 const std::string minor = "gos";
232 for (const MSJunction* junction : controlledJunctions) {
233 const MSJunctionLogic* logic = junction->getLogic();
234 if (logic != nullptr) {
235 // find symmetrical response
236 const int logicSize = logic->getLogicSize();
237 std::vector<int> tlIndex;
238 for (int u = 0; u < logicSize; u++) {
239 const MSLogicJunction::LinkBits& response = logic->getResponseFor(u);
240 for (int v = 0; v < logicSize; v++) {
241 if (response.test(v)) {
242 if (logic->getResponseFor(v).test(u)) {
243 // get tls link index for links u and v
244 if (tlIndex.size() == 0) {
245 // init tlindex for all links once
246 tlIndex.resize(logicSize, -1);
247 for (int j = 0; j < numLinks; ++j) {
248 for (int k = 0; k < (int)myLinks[j].size(); ++k) {
249 MSLink* link = myLinks[j][k];
250 if (link->getJunction() == junction) {
251 tlIndex[link->getIndex()] = link->getTLIndex();
252 }
253 }
254 }
255 }
256 const int tlu = tlIndex[u];
257 const int tlv = tlIndex[v];
258 if (tlu >= 0 && tlv >= 0) {
259 int phaseIndex = 0;
260 for (MSPhaseDefinition* p : phases) {
261 if (minor.find(p->getState()[tlu]) != std::string::npos
262 && minor.find(p->getState()[tlv]) != std::string::npos) {
263 WRITE_ERROR("Program '" + getProgramID() + "' at tlLogic '" + getID() + "' is incompatible with logic at junction '" + junction->getID() + "'"
264 + " (mututal conflict between link indices " + toString(u) + "," + toString(v)
265 + " tl indices " + toString(tlu) + "," + toString(tlv) + " phase " + toString(phaseIndex) + ")."
266 + "\n Rebuild the network with option '--tls.ignore-internal-junction-jam or include the program when building.");
267 return;
268 }
269 phaseIndex++;
270 }
271 }
272 }
273 }
274 }
275 }
276 }
277 }
278 }
279 myNumLinks = (int)myLinks.size();
280}
281
282
284 // no need to do something about mySwitchCommand here,
285 // it is handled by the event control
286}
287
288
289// ----------- Handling of controlled links
290void
292 // !!! should be done within the loader (checking necessary)
293 myLinks.reserve(pos + 1);
294 while ((int)myLinks.size() <= pos) {
295 myLinks.push_back(LinkVector());
296 }
297 myLinks[pos].push_back(link);
298 //
299 myLanes.reserve(pos + 1);
300 while ((int)myLanes.size() <= pos) {
301 myLanes.push_back(LaneVector());
302 }
303 myLanes[pos].push_back(lane);
304 link->setTLState((LinkState) getCurrentPhaseDef().getState()[pos], MSNet::getInstance()->getCurrentTimeStep());
305}
306
307
308void
310 myLinks = logic.myLinks;
311 myLanes = logic.myLanes;
313}
314
315
316std::map<MSLink*, LinkState>
318 std::map<MSLink*, LinkState> ret;
319 for (LinkVectorVector::const_iterator i1 = myLinks.begin(); i1 != myLinks.end(); ++i1) {
320 const LinkVector& l = (*i1);
321 for (LinkVector::const_iterator i2 = l.begin(); i2 != l.end(); ++i2) {
322 ret[*i2] = (*i2)->getState();
323 }
324 }
325 return ret;
326}
327
328
329bool
331 // get the current traffic light signal combination
332 const std::string& state = getCurrentPhaseDef().getState();
333 // go through the links
334 for (int i = 0; i < (int)myLinks.size(); i++) {
335 const LinkVector& currGroup = myLinks[i];
336 LinkState ls = (LinkState) state[i];
337 for (LinkVector::const_iterator j = currGroup.begin(); j != currGroup.end(); j++) {
338 (*j)->setTLState(ls, t);
339 }
340 }
341 return true;
342}
343
344
345void
346MSTrafficLightLogic::resetLinkStates(const std::map<MSLink*, LinkState>& vals) const {
347 for (LinkVectorVector::const_iterator i1 = myLinks.begin(); i1 != myLinks.end(); ++i1) {
348 const LinkVector& l = (*i1);
349 for (LinkVector::const_iterator i2 = l.begin(); i2 != l.end(); ++i2) {
350 assert(vals.find(*i2) != vals.end());
351 (*i2)->setTLState(vals.find(*i2)->second, MSNet::getInstance()->getCurrentTimeStep());
352 }
353 }
354}
355
356
357// ----------- Static Information Retrieval
358int
360 int index = 0;
361 for (LinkVectorVector::const_iterator i1 = myLinks.begin(); i1 != myLinks.end(); ++i1, ++index) {
362 const LinkVector& l = (*i1);
363 for (LinkVector::const_iterator i2 = l.begin(); i2 != l.end(); ++i2) {
364 if ((*i2) == link) {
365 return index;
366 }
367 }
368 }
369 return -1;
370}
371
372
373
374// ----------- Dynamic Information Retrieval
377 return mySwitchCommand != nullptr ? mySwitchCommand->getNextSwitchTime() : -1;
378}
379
380
383 if (simStep == -1) {
384 simStep = SIMSTEP;
385 }
386 return simStep - getCurrentPhaseDef().myLastSwitch;
387}
388
389
390// ----------- Changing phases and phase durations
391void
393 myOverridingTimes.push_back(duration);
394}
395
396
397void
400}
401
402
404 // set mesoscopic time penalties
405 const Phases& phases = getPhases();
406 const int numLinks = (int)myLinks.size();
407 // warning already given if not all states are used
408 assert(numLinks <= (int)phases.front()->getState().size());
409 SUMOTime duration = 0;
410 std::vector<double> firstRedDuration(numLinks, 0);
411 std::vector<double> redDuration(numLinks, 0);
412 std::vector<double> totalRedDuration(numLinks, 0);
413 std::vector<double> penalty(numLinks, 0);
414 for (int i = 0; i < (int)phases.size(); ++i) {
415 const std::string& state = phases[i]->getState();
416 duration += phases[i]->duration;
417 // warn about transitions from green to red without intermediate yellow
418 for (int j = 0; j < numLinks; ++j) {
419 double& red = redDuration[j];
420 if ((LinkState)state[j] == LINKSTATE_TL_RED
421 || (LinkState)state[j] == LINKSTATE_TL_REDYELLOW) {
422 red += STEPS2TIME(phases[i]->duration);
423 totalRedDuration[j] += STEPS2TIME(phases[i]->duration);
424 } else if (red > 0) {
425 if (firstRedDuration[j] == 0) {
426 // store for handling wrap-around
427 firstRedDuration[j] = red;
428 } else {
429 // vehicle may arive in any second or the red duration
430 // compute the sum over [0,red]
431 penalty[j] += 0.5 * (red * red + red);
432 }
433 red = 0;
434 }
435 }
436 }
437 // final phase and wrap-around to first phase
438 for (int j = 0; j < numLinks; ++j) {
439 double red = redDuration[j] + firstRedDuration[j];
440 if (red) {
441 penalty[j] += 0.5 * (red * red + red);
442 }
443 }
444 double tlsPenalty = MSGlobals::gTLSPenalty;
445 const double durationSeconds = STEPS2TIME(duration);
446 std::set<const MSJunction*> controlledJunctions;
447 for (int j = 0; j < numLinks; ++j) {
448 for (int k = 0; k < (int)myLinks[j].size(); ++k) {
449 MSLink* link = myLinks[j][k];
450 MSEdge& edge = link->getLaneBefore()->getEdge();
453 tlsPenalty = edgeType.tlsPenalty;
454 double greenFraction = (durationSeconds - totalRedDuration[j]) / durationSeconds;
455 if (edgeType.tlsFlowPenalty == 0) {
456 greenFraction = 1;
457 } else {
458 greenFraction = MAX2(MIN2(greenFraction / edgeType.tlsFlowPenalty, 1.0), 0.01);
459 }
460 if (greenFraction == 0.01) {
461 WRITE_WARNINGF(TL("Green fraction is only 1% for link % in tlLogic '%', program '%'."), "%", j, getID(), getProgramID());
462 }
463 link->setGreenFraction(greenFraction);
464 }
465 link->setMesoTLSPenalty(TIME2STEPS(tlsPenalty * penalty[j] / durationSeconds));
466 controlledJunctions.insert(link->getLane()->getEdge().getFromJunction()); // MSLink::myJunction is not yet initialized
467 //std::cout << " tls=" << getID() << " i=" << j << " link=" << link->getDescription() << " p=" << penalty[j] << " fr=" << firstRedDuration[j] << " r=" << redDuration[j] << " tr=" << totalRedDuration[j] << " durSecs=" << durationSeconds << " tlsPen=" << STEPS2TIME(link->getMesoTLSPenalty()) << " gF=" << myLinks[j][k]->getGreenFraction() << "\n";
468 }
469 }
470 // initialize empty-net travel times
471 // XXX refactor after merging sharps (links know their incoming edge)
472 for (std::set<const MSJunction*>::iterator it = controlledJunctions.begin(); it != controlledJunctions.end(); ++it) {
473 const ConstMSEdgeVector incoming = (*it)->getIncoming();
474 for (ConstMSEdgeVector::const_iterator it_e = incoming.begin(); it_e != incoming.end(); ++it_e) {
475 const_cast<MSEdge*>(*it_e)->recalcCache();
476 }
477 }
478
479}
480
481
482void
484 myIgnoredIndices.insert(pos);
485}
486
489 return mapTimeInCycle(SIMSTEP);
490}
491
492
495 return (t - myOffset) % myDefaultCycleTime;
496}
497
498
499bool
501 return MSNet::getInstance()->isSelected(this);
502}
503
504
505void
507 myAmActive = true;
508}
509
510
511void
513 myAmActive = false;
514}
515
516bool
518 if (linkIndex >= 0 && linkIndex < getNumLinks()) {
519 for (const MSPhaseDefinition* p : getPhases()) {
520 const std::string& s = p->getState();
521 assert(linkIndex < (int)s.size());
522 if (s[linkIndex] == LINKSTATE_TL_GREEN_MAJOR) {
523 return true;
524 }
525 }
526 }
527 return false;
528
529}
530
531
534 const MSPhaseDefinition& p = step < 0 ? getCurrentPhaseDef() : getPhase(step);
535 return p.minDuration;
536}
537
540 const MSPhaseDefinition& p = step < 0 ? getCurrentPhaseDef() : getPhase(step);
541 return p.maxDuration;
542}
543
546 const MSPhaseDefinition& p = step < 0 ? getCurrentPhaseDef() : getPhase(step);
547 return p.earliestEnd;
548}
549
552 const MSPhaseDefinition& p = step < 0 ? getCurrentPhaseDef() : getPhase(step);
553 return p.latestEnd;
554}
555
556
557void
558MSTrafficLightLogic::loadState(MSTLLogicControl& tlcontrol, SUMOTime t, int step, SUMOTime spentDuration) {
559 const SUMOTime remaining = getPhase(step).duration - spentDuration;
560 changeStepAndDuration(tlcontrol, t, step, remaining);
561 setTrafficLightSignals(t - spentDuration);
562}
563
564/****************************************************************************/
long long int SUMOTime
Definition: GUI.h:36
std::vector< const MSEdge * > ConstMSEdgeVector
Definition: MSEdge.h:74
#define WRITE_WARNINGF(...)
Definition: MsgHandler.h:266
#define WRITE_ERROR(msg)
Definition: MsgHandler.h:274
#define TL(string)
Definition: MsgHandler.h:282
SUMOTime DELTA_T
Definition: SUMOTime.cpp:37
#define STEPS2TIME(x)
Definition: SUMOTime.h:54
#define SIMSTEP
Definition: SUMOTime.h:60
#define TIME2STEPS(x)
Definition: SUMOTime.h:56
@ SVC_PEDESTRIAN
pedestrian
TrafficLightType
LinkState
The right-of-way state of a link between two lanes used when constructing a NBTrafficLightLogic,...
@ LINKSTATE_TL_REDYELLOW
The link has red light (must brake) but indicates upcoming green.
@ LINKSTATE_STOP
This is an uncontrolled, minor link, has to stop.
@ LINKSTATE_TL_GREEN_MAJOR
The link has green light, may pass.
@ LINKSTATE_TL_OFF_BLINKING
The link is controlled by a tls which is off and blinks, has to brake.
@ LINKSTATE_TL_RED
The link has red light (must brake)
@ LINKSTATE_TL_GREEN_MINOR
The link has green light, has to brake.
@ LINKSTATE_TL_OFF_NOSIGNAL
The link is controlled by a tls which is off, not blinking, may pass.
#define UNUSED_PARAMETER(x)
Definition: StdDefs.h:30
T MIN3(T a, T b, T c)
Definition: StdDefs.h:84
T MIN2(T a, T b)
Definition: StdDefs.h:71
T MAX2(T a, T b)
Definition: StdDefs.h:77
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:46
int priority
Definition: Command.h:87
A road/street connecting two junctions.
Definition: MSEdge.h:77
void recalcCache()
Recalculates the cached values.
Definition: MSEdge.cpp:118
const MSJunction * getFromJunction() const
Definition: MSEdge.h:411
const std::string & getEdgeType() const
Returns the type of the edge.
Definition: MSEdge.h:316
virtual void addEvent(Command *operation, SUMOTime execTimeStep=-1)
Adds an Event.
static bool gUseMesoSim
Definition: MSGlobals.h:103
static double gTLSPenalty
scaled (minimum) time penalty for passing a tls link when routing
Definition: MSGlobals.h:153
The base class for an intersection.
Definition: MSJunction.h:58
virtual const MSLogicJunction::LinkBits & getResponseFor(int linkIndex) const
Returns the response for the given link.
int getLogicSize() const
Representation of a lane in the micro simulation.
Definition: MSLane.h:84
MSEdge & getEdge() const
Returns the lane's edge.
Definition: MSLane.h:713
std::bitset< SUMO_MAX_CONNECTIONS > LinkBits
Container for link response and foes.
static MSNet * getInstance()
Returns the pointer to the unique instance of MSNet (singleton).
Definition: MSNet.cpp:183
virtual bool isSelected(const MSTrafficLightLogic *) const
return wheter the given logic (or rather it's wrapper) is selected in the GUI
Definition: MSNet.h:587
MSEventControl * getBeginOfTimestepEvents()
Returns the event control for events executed at the begin of a time step.
Definition: MSNet.h:472
SUMOTime getCurrentTimeStep() const
Returns the current simulation step.
Definition: MSNet.h:321
const MESegment::MesoEdgeType & getMesoType(const std::string &typeID)
Returns edge type specific meso parameters if no type specific parameters have been loaded,...
Definition: MSNet.cpp:363
bool hasInternalLinks() const
return whether the network contains internal links
Definition: MSNet.h:777
The definition of a single phase of a tls logic.
SUMOTime maxDuration
The maximum duration of the phase.
SUMOTime latestEnd
The maximum time within the cycle for switching (for coordinated actuation)
SUMOTime minDuration
The minimum duration of the phase.
SUMOTime myLastSwitch
Stores the timestep of the last on-switched of the phase.
const std::string & getState() const
Returns the state within this phase.
SUMOTime duration
The duration of the phase.
SUMOTime earliestEnd
The minimum time within the cycle for switching (for coordinated actuation)
Storage for all programs of a single tls.
A class that stores and controls tls and switching of their programs.
Class realising the switch between the traffic light phases.
void deschedule(MSTrafficLightLogic *tlLogic)
Marks this swicth as invalid (if the phase duration has changed, f.e.)
SUMOTime shiftTime(SUMOTime currentTime, SUMOTime execTime, SUMOTime newTime)
Reschedule or deschedule the command when quick-loading state.
SwitchCommand(MSTLLogicControl &tlcontrol, MSTrafficLightLogic *tlLogic, SUMOTime nextSwitch)
Constructor.
SUMOTime getNextSwitchTime() const
Returns the assumed next switch time.
SUMOTime execute(SUMOTime currentTime)
Executes the regarded junction's "trySwitch"- method.
The parent class for traffic light logics.
virtual void adaptLinkInformationFrom(const MSTrafficLightLogic &logic)
Applies information about controlled links and lanes from the given logic.
virtual const MSPhaseDefinition & getCurrentPhaseDef() const =0
Returns the definition of the current phase.
SUMOTime myOffset
the offset parameter of the current program
int getLinkIndex(const MSLink *const link) const
Returns the index of the given link.
virtual SUMOTime mapTimeInCycle(SUMOTime t) const
map the given time into the current cycle
void setCurrentDurationIncrement(SUMOTime delay)
Delays current phase by the given delay.
std::map< MSLink *, LinkState > collectLinkStates() const
Returns the (uncontrolled) states of the controlled links.
std::vector< MSLane * > LaneVector
Definition of the list of arrival lanes subjected to this tls.
virtual ~MSTrafficLightLogic()
Destructor.
virtual SUMOTime getLatestEnd(int step=-1) const
virtual void deactivateProgram()
MSTrafficLightLogic(MSTLLogicControl &tlcontrol, const std::string &id, const std::string &programID, const SUMOTime offset, const TrafficLightType logicType, const SUMOTime delay, const Parameterised::Map &parameters)
Constructor.
std::vector< SUMOTime > myOverridingTimes
A list of duration overrides.
virtual SUMOTime getMinDur(int step=-1) const
void ignoreLinkIndex(int pos)
ignore pedestrian crossing index in mesosim
virtual void changeStepAndDuration(MSTLLogicControl &tlcontrol, SUMOTime simStep, int step, SUMOTime stepDuration)=0
Changes the current phase and her duration.
static const LaneVector myEmptyLaneVector
An empty lane vector.
const TrafficLightType myLogicType
The type of the logic.
bool isSelected() const
whether this logic is selected in the GUI
virtual const MSPhaseDefinition & getPhase(int givenstep) const =0
Returns the definition of the phase from the given position within the plan.
SUMOTime myDefaultCycleTime
The cycle time (without changes)
SUMOTime getTimeInCycle() const
return time within the current cycle
const std::string & getProgramID() const
Returns this tl-logic's id.
const std::string myProgramID
The id of the logic.
TrafficLightType getLogicType() const
Returns the type of the logic.
virtual SUMOTime getEarliestEnd(int step=-1) const
LaneVectorVector myLanes
The list of LaneVectors; each vector contains the incoming lanes that belong to the same link index.
SwitchCommand * mySwitchCommand
The current switch command.
int myNumLinks
number of controlled links
int getNumLinks() const
return the number of controlled link indices
virtual const Phases & getPhases() const =0
Returns the phases of this tls program.
SUMOTime myCurrentDurationIncrement
A value for enlarge the current duration.
virtual SUMOTime getMaxDur(int step=-1) const
virtual bool getsMajorGreen(int linkIndex) const
whether the given link index ever turns 'G'
void resetLinkStates(const std::map< MSLink *, LinkState > &vals) const
Resets the states of controlled links.
virtual void loadState(MSTLLogicControl &tlcontrol, SUMOTime t, int step, SUMOTime spentDuration)
restores the tls state
virtual void activateProgram()
called when switching programs
void addOverridingDuration(SUMOTime duration)
Changes the duration of the next phase.
bool myAmActive
whether the current program is active
SUMOTime getNextSwitchTime() const
Returns the assumed next switch time.
std::set< int > myIgnoredIndices
list of indices that are ignored in mesoscopic simulatino
SUMOTime getSpentDuration(SUMOTime simStep=-1) const
Returns the duration spent in the current phase.
bool setTrafficLightSignals(SUMOTime t) const
Applies the current signal states to controlled links.
virtual void addLink(MSLink *link, MSLane *lane, int pos)
Adds a link on building.
std::vector< MSPhaseDefinition * > Phases
Definition of a list of phases, being the junction logic.
std::vector< MSLink * > LinkVector
Definition of the list of links that are subjected to this tls.
LinkVectorVector myLinks
The list of LinkVectors; each vector contains the links that belong to the same link index.
void initMesoTLSPenalties()
initialize optional meso penalties
virtual void init(NLDetectorBuilder &nb)
Initialises the tls with information about incoming lanes.
Builds detectors for microsim.
Base class for objects which have an id.
Definition: Named.h:54
const std::string & getID() const
Returns the id.
Definition: Named.h:74
An upper class for objects with additional parameters.
Definition: Parameterised.h:41
std::map< std::string, std::string > Map
parameters map
Definition: Parameterised.h:45
static const std::string ALLOWED_TLS_LINKSTATES
all allowed characters for phase state
edge type specific meso parameters
Definition: MESegment.h:55