53 : myTLControl(tlcontrol), myTLLogic(tlLogic),
54 myAssumedNextSwitch(nextSwitch), myAmValid(true) {}
67 int step1 = myTLLogic->getCurrentPhaseIndex();
68 SUMOTime next = myTLLogic->trySwitch();
69 int step2 = myTLLogic->getCurrentPhaseIndex();
71 if (myTLLogic->isActive()) {
75 myTLLogic->setTrafficLightSignals(t);
80 myAssumedNextSwitch += next;
87 if (tlLogic == myTLLogic) {
89 myAssumedNextSwitch = -1;
95 if (myTLLogic->getDefaultCycleTime() ==
DELTA_T) {
111 const std::map<std::string, std::string>& parameters) :
129 if (phases.size() > 1) {
130 bool haveWarnedAboutUnusedStates =
false;
131 std::vector<bool> foundGreen(phases.front()->getState().size(),
false);
132 for (
int i = 0; i < (int)phases.size(); ++i) {
134 std::vector<int> nextPhases;
135 nextPhases.push_back((i + 1) % phases.size());
136 bool iNextDefault =
true;
137 if (phases[i]->nextPhases.size() > 0) {
138 nextPhases = phases[i]->nextPhases;
139 iNextDefault =
false;
141 for (
int iNext : nextPhases) {
142 if (iNext < 0 || iNext >= (
int)phases.size()) {
146 const std::string optionalFrom = iNextDefault ?
"" :
" from phase " +
toString(i);
147 const std::string& state1 = phases[i]->getState();
148 const std::string& state2 = phases[iNext]->getState();
149 assert(state1.size() == state2.size());
154 haveWarnedAboutUnusedStates =
true;
158 if (std::string::npos != illegal) {
163 bool haveWarned =
false;
164 for (
int j = 0; j < (int)
MIN3(state1.size(), state2.size(),
myLanes.size()) && !haveWarned; ++j) {
168 for (LaneVector::const_iterator it =
myLanes[j].begin(); it !=
myLanes[j].end(); ++it) {
172 +
" when switching" + optionalFrom +
" to phase " +
toString(iNext));
181 for (
int j = 0; j < (int)state1.size(); ++j) {
184 foundGreen[j] =
true;
189 for (
int j = 0; j < (int)foundGreen.size(); ++j) {
190 if (!foundGreen[j]) {
211 if (mustCheck && phases.size() > 0) {
213 std::set<const MSJunction*> controlledJunctions;
214 const int numLinks = (int)
myLinks.size();
215 for (
int j = 0; j < numLinks; ++j) {
216 for (
int k = 0; k < (int)
myLinks[j].size(); ++k) {
222 const std::string minor =
"gos";
223 for (
const MSJunction* junction : controlledJunctions) {
225 if (logic !=
nullptr) {
228 std::vector<int> tlIndex;
229 for (
int u = 0; u < logicSize; u++) {
231 for (
int v = 0; v < logicSize; v++) {
232 if (response.test(v)) {
235 if (tlIndex.size() == 0) {
237 tlIndex.resize(logicSize, -1);
238 for (
int j = 0; j < numLinks; ++j) {
239 for (
int k = 0; k < (int)
myLinks[j].size(); ++k) {
247 const int tlu = tlIndex[u];
248 const int tlv = tlIndex[v];
249 if (tlu >= 0 && tlv >= 0) {
252 if (minor.find(p->getState()[tlu]) != std::string::npos
253 && minor.find(p->getState()[tlv]) != std::string::npos) {
254 WRITE_ERROR(
"Program '" +
getProgramID() +
"' at tlLogic '" +
getID() +
"' is incompatible with logic at junction '" + junction->getID() +
"'"
255 +
" (mututal conflict between link indices " +
toString(u) +
"," +
toString(v)
257 +
"\n Rebuild the network with option '--tls.ignore-internal-junction-jam or include the program when building.");
285 while ((
int)
myLinks.size() <= pos) {
291 while ((
int)
myLanes.size() <= pos) {
307 std::map<MSLink*, LinkState>
309 std::map<MSLink*, LinkState> ret;
310 for (LinkVectorVector::const_iterator i1 =
myLinks.begin(); i1 !=
myLinks.end(); ++i1) {
312 for (LinkVector::const_iterator i2 = l.begin(); i2 != l.end(); ++i2) {
313 ret[*i2] = (*i2)->getState();
325 for (
int i = 0; i < (int)
myLinks.size(); i++) {
328 for (LinkVector::const_iterator j = currGroup.begin(); j != currGroup.end(); j++) {
329 (*j)->setTLState(ls, t);
338 for (LinkVectorVector::const_iterator i1 =
myLinks.begin(); i1 !=
myLinks.end(); ++i1) {
340 for (LinkVector::const_iterator i2 = l.begin(); i2 != l.end(); ++i2) {
341 assert(vals.find(*i2) != vals.end());
352 for (LinkVectorVector::const_iterator i1 =
myLinks.begin(); i1 !=
myLinks.end(); ++i1, ++index) {
354 for (LinkVector::const_iterator i2 = l.begin(); i2 != l.end(); ++i2) {
378 if (nextSwitch == -1) {
381 const SUMOTime remaining = nextSwitch - simStep;
403 const int numLinks = (int)
myLinks.size();
405 assert(numLinks <= (
int)phases.front()->getState().size());
407 std::vector<double> redDuration(numLinks, 0);
408 std::vector<double> totalRedDuration(numLinks, 0);
409 std::vector<double> penalty(numLinks, 0);
410 for (
int i = 0; i < (int)phases.size(); ++i) {
411 const std::string& state = phases[i]->getState();
412 duration += phases[i]->duration;
414 for (
int j = 0; j < numLinks; ++j) {
417 redDuration[j] +=
STEPS2TIME(phases[i]->duration);
418 totalRedDuration[j] +=
STEPS2TIME(phases[i]->duration);
419 }
else if (redDuration[j] > 0) {
420 penalty[j] += 0.5 * (redDuration[j] * redDuration[j] + redDuration[j]);
426 for (
int j = 0; j < numLinks; ++j) {
427 if (redDuration[j] > 0) {
428 penalty[j] += 0.5 * (redDuration[j] * redDuration[j] + redDuration[j]);
432 const double durationSeconds =
STEPS2TIME(duration);
433 std::set<const MSJunction*> controlledJunctions;
434 for (
int j = 0; j < numLinks; ++j) {
435 for (
int k = 0; k < (int)
myLinks[j].size(); ++k) {
439 double greenFraction = (durationSeconds - totalRedDuration[j]) / durationSeconds;
445 if (greenFraction == 0.01) {
456 for (std::set<const MSJunction*>::iterator it = controlledJunctions.begin(); it != controlledJunctions.end(); ++it) {
458 for (ConstMSEdgeVector::const_iterator it_e = incoming.begin(); it_e != incoming.end(); ++it_e) {
std::vector< const MSEdge * > ConstMSEdgeVector
#define WRITE_WARNINGF(...)
#define WRITE_WARNING(msg)
@ SVC_PEDESTRIAN
pedestrian
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_TL_GREEN_MAJOR
The link has green light, may pass.
@ LINKSTATE_TL_RED
The link has red light (must brake)
@ LINKSTATE_TL_GREEN_MINOR
The link has green light, has to brake.
#define UNUSED_PARAMETER(x)
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
A road/street connecting two junctions.
void recalcCache()
Recalculates the cached values.
const MSJunction * getFromJunction() const
const std::string & getEdgeType() const
Returns the type of the edge.
virtual void addEvent(Command *operation, SUMOTime execTimeStep=-1)
Adds an Event.
The base class for an intersection.
virtual const MSLogicJunction::LinkBits & getResponseFor(int linkIndex) const
Returns the response for the given link.
Representation of a lane in the micro simulation.
MSEdge & getEdge() const
Returns the lane's edge.
void setMesoTLSPenalty(const SUMOTime penalty)
Sets the time penalty for passing a tls-controlled link (meso)
void setTLState(LinkState state, SUMOTime t)
Sets the current tl-state.
MSLane * getLane() const
Returns the connected lane.
int getIndex() const
Returns the respond index (for visualization)
int getTLIndex() const
Returns the TLS index.
const MSLane * getLaneBefore() const
return the internalLaneBefore if it exists and the laneBefore otherwise
void setGreenFraction(const double fraction)
Sets the green fraction for passing a tls-controlled link (meso)
MSJunction * getJunction() const
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).
virtual bool isSelected(const MSTrafficLightLogic *) const
return wheter the given logic (or rather it's wrapper) is selected in the GUI
const MesoEdgeType & getMesoType(const std::string &typeID)
Returns edge type specific meso parameters if no type specific parameters have been loaded,...
SUMOTime getCurrentTimeStep() const
Returns the current simulation step.
MSEventControl * getBeginOfTimestepEvents()
Returns the event control for events executed at the begin of a time step.
bool hasInternalLinks() const
return whether the network contains internal links
The definition of a single phase of a tls logic.
const std::string & getState() const
Returns the state within this phase.
SUMOTime duration
The duration of the phase.
Storage for all programs of a single tls.
void executeOnSwitchActions() const
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.
~SwitchCommand()
Destructor.
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.
int getLinkIndex(const MSLink *const link) const
Returns the index of the given link.
void setCurrentDurationIncrement(SUMOTime delay)
Delays current phase by the given delay.
MSTrafficLightLogic(MSTLLogicControl &tlcontrol, const std::string &id, const std::string &programID, const TrafficLightType logicType, const SUMOTime delay, const std::map< std::string, std::string > ¶meters)
Constructor.
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 void deactivateProgram()
std::vector< SUMOTime > myOverridingTimes
A list of duration overrides.
void ignoreLinkIndex(int pos)
ignore pedestrian crossing index in mesosim
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
SUMOTime myDefaultCycleTime
The cycle time (without changes)
const std::string myProgramID
The id of the logic.
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
SUMOTime myCurrentDurationIncrement
A value for enlarge the current duration.
void resetLinkStates(const std::map< MSLink *, LinkState > &vals) const
Resets the states of controlled links.
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 const Phases & getPhases() const =0
Returns the phases of this tls program.
virtual void init(NLDetectorBuilder &nb)
Initialises the tls with information about incoming lanes.
const std::string & getProgramID() const
Returns this tl-logic's id.
Builds detectors for microsim.
Base class for objects which have an id.
const std::string & getID() const
Returns the id.
An upper class for objects with additional parameters.
static const std::string ALLOWED_TLS_LINKSTATES
all allowed characters for phase state
edge type specific meso parameters