43#define DEBUG_COND (getID()=="C")
49 "**",
"^",
"*",
"/",
"+",
"-",
"%",
50 "=",
"==",
"!=",
"<",
">",
"<=",
">=",
51 "and",
"&&",
"or",
"||",
57#define DEFAULT_MAX_GAP "3.0"
58#define DEFAULT_PASSING_TIME "1.9"
59#define DEFAULT_DETECTOR_GAP "2.0"
60#define DEFAULT_INACTIVE_THRESHOLD "180"
61#define DEFAULT_CURRENT_PRIORITY 10
63#define DEFAULT_LENGTH_WITH_GAP 7.5
64#define DEFAULT_BIKE_LENGTH_WITH_GAP (getDefaultVehicleLength(SVC_BICYCLE) + 0.5)
66#define NO_DETECTOR "NO_DETECTOR"
72 const std::string&
id,
const std::string& programID,
77 const std::string& basePath,
82 myHasMultiTarget(false),
83 myLastTrySwitchTime(0),
84 myConditions(conditions),
85 myAssignments(assignments),
86 myFunctions(functions),
88 myDetectorPrefix(id +
"_" + programID +
"_") {
101 std::set<std::string> hiddenSet(hidden.begin(), hidden.end());
103 if (hiddenSet.count(item.first) == 0) {
108 const bool showAll =
getParameter(
"show-conditions",
"") ==
"";
110 std::set<std::string> shownSet(shown.begin(), shown.end());
112 if (showAll || shownSet.count(item.first) != 0) {
118 const std::string extraIDs =
getParameter(
"extra-detectors",
"");
121 myExtraLoops.push_back(retrieveDetExpression<MSInductLoop, SUMO_TAG_INDUCTION_LOOP>(customID, extraIDs,
true));
123 myExtraE2.push_back(retrieveDetExpression<MSE2Collector, SUMO_TAG_LANE_AREA_DETECTOR>(customID, extraIDs,
true));
127 myStack.push_back(std::map<std::string, double>());
143 const int numLinks = (int)
myLinks.size();
166 std::map<const MSLane*, MSInductLoop*> laneInductLoopMap;
167 std::map<MSInductLoop*, int> inductLoopInfoMap;
168 int detEdgeIndex = -1;
169 int detLaneIndex = 0;
172 MSEdge* prevDetEdge =
nullptr;
174 for (
MSLane* lane : lanes) {
175 const std::string customID =
getParameter(lane->getID());
176 if (
noVehicles(lane->getPermissions()) && customID ==
"") {
180 if (laneInductLoopMap.find(lane) != laneInductLoopMap.end()) {
185 if (minDur == std::numeric_limits<SUMOTime>::max() && customID ==
"") {
189 double length = lane->getLength();
191 double inductLoopPosition;
193 if (&lane->getEdge() != prevDetEdge) {
196 prevDetEdge = &lane->getEdge();
200 const bool isBikeLane = (lane->getPermissions() & ~SVC_PEDESTRIAN) ==
SVC_BICYCLE;
202 if (customID ==
"") {
204 inductLoopPosition =
MIN2(
209 ilpos = length - inductLoopPosition;
210 MSLane* placementLane = lane;
211 while (ilpos < 0 && placementLane->getIncomingLanes().size() == 1
212 && placementLane->
getIncomingLanes().front().viaLink->getCorrespondingEntryLink()->getTLLogic() ==
nullptr) {
220 const double detLength =
getDouble(
"detector-length:" + lane->getID(), detDefaultLength);
228 if (loop ==
nullptr) {
232 inductLoopPosition = length - ilpos;
236 laneInductLoopMap[lane] = loop;
265 std::map<int, std::set<MSInductLoop*> > linkToLoops;
266 std::set<int> actuatedLinks;
268 std::vector<bool> neverMajor(numLinks,
true);
270 const std::string& state = phase->getState();
271 for (
int i = 0; i < numLinks; i++) {
273 neverMajor[i] =
false;
277 std::vector<bool> oneLane(numLinks,
false);
278 std::vector<bool> turnaround(numLinks,
true);
279 for (
int i = 0; i < numLinks; i++) {
282 int numMotorized = 0;
283 for (
MSLane* l : lane->getEdge().getLanes()) {
284 if ((l->getPermissions() & motorized) != 0) {
288 if (numMotorized == 1) {
294 if (!link->isTurnaround()) {
295 turnaround[i] =
false;
304 std::set<MSInductLoop*> loops;
305 if (phase->isActuated()) {
306 const std::string& state = phase->getState();
308 std::set<int> greenLinks;
310 std::set<int> greenLinksPermissive;
312 std::map<MSInductLoop*, std::set<int> > loopLinks;
314 for (
int i = 0; i < numLinks; i++) {
316 greenLinks.insert(i);
317 actuatedLinks.insert(i);
319 if (((neverMajor[i] || turnaround[i])
322 greenLinks.insert(i);
323 if (!turnaround[i]) {
324 actuatedLinks.insert(i);
327 greenLinksPermissive.insert(i);
330#ifdef DEBUG_DETECTORS
332 std::cout <<
" phase=" << phaseIndex <<
" i=" << i <<
" state=" << state[i] <<
" green=" << greenLinks.count(i) <<
" oneLane=" << oneLane[i]
333 <<
" turn=" << turnaround[i] <<
" loopLanes=";
335 if (laneInductLoopMap.count(lane) != 0) {
336 std::cout << lane->getID() <<
" ";
343 if (laneInductLoopMap.count(lane) != 0) {
344 loopLinks[laneInductLoopMap[lane]].insert(i);
348 for (
auto& item : loopLinks) {
353 bool foundUsable =
false;
355 for (
int j : item.second) {
356 if (greenLinks.count(j) == 0 && (info.
jamThreshold <= 0 || greenLinksPermissive.count(j) == 0)) {
358#ifdef DEBUG_DETECTORS
360 std::cout <<
" phase=" << phaseIndex <<
" check1: loopLane=" << loopLane->
getID() <<
" notGreen=" << j <<
" oneLane[j]=" << oneLane[j] <<
"\n";
374 if (link->isTurnaround()) {
377 const MSLane* next = link->getLane();
378 if (laneInductLoopMap.count(next) != 0) {
380 for (
int j : loopLinks[nextLoop]) {
381 if (greenLinks.count(j) == 0) {
383#ifdef DEBUG_DETECTORS
384 if (
DEBUG_COND) std::cout <<
" phase=" << phaseIndex <<
" check2: loopLane=" << loopLane->
getID()
385 <<
" nextLane=" << next->
getID() <<
" nextLink=" << j <<
" nextState=" << state[j] <<
"\n";
395 loops.insert(item.first);
396#ifdef DEBUG_DETECTORS
398 std::cout <<
" phase=" << phaseIndex <<
" usableLoops=" << item.first->getID() <<
" links=" <<
joinToString(item.second,
" ") <<
"\n";
401 for (
int j : item.second) {
402 linkToLoops[j].insert(item.first);
406 if (loops.size() == 0) {
410#ifdef DEBUG_DETECTORS
412 std::cout <<
" phase=" << phaseIndex <<
" loops=" <<
joinNamedToString(loops,
" ") <<
"\n";
415 std::cout <<
" linkToLoops:\n";
416 for (
auto item : linkToLoops) {
417 std::cout <<
" link=" << item.first <<
" loops=" <<
joinNamedToString(item.second,
" ") <<
"\n";
421 std::vector<InductLoopInfo*> loopInfos;
425 if (loopInfo.loop == loop) {
427 loopInfo.servedPhase[phaseIndex] =
true;
432#ifdef DEBUG_DETECTORS
434 std::cout <<
"final linkToLoops:\n";
435 for (
auto item : linkToLoops) {
436 std::cout <<
" link=" << item.first <<
" loops=" <<
joinNamedToString(item.second,
" ") <<
"\n";
440 for (
int i : actuatedLinks) {
441 if (linkToLoops[i].size() == 0 &&
myLinks[i].size() > 0
442 && (
myLinks[i].front()->getLaneBefore()->getPermissions() & motorized) != 0) {
453 WRITE_ERRORF(
TL(
"Invalid link '%' given as linkMaxDur parameter for actuated tlLogic '%', program '%."), kv.first.substr(11),
getID(),
getProgramID());
463 WRITE_ERRORF(
TL(
"Invalid link '%' given as linkMinDur parameter for actuated tlLogic '%', program '%."), kv.first.substr(11),
getID(),
getProgramID());
481 step = step < 0 ?
myStep : step;
490 step = step < 0 ?
myStep : step;
499 step = step < 0 ?
myStep : step;
508 step = step < 0 ?
myStep : step;
519 for (
int i = 0; i < (int)
myPhases.size(); i++) {
521 const std::string errorSuffix =
"' for overriding attribute in phase " +
toString(i) +
" of tlLogic '" +
getID() +
"' in program '" +
getProgramID() +
"'.";
523 const std::string cond =
"minDur:" +
toString(i);
525 throw ProcessError(
"Missing condition '" + cond + errorSuffix);
529 const std::string cond =
"maxDur:" +
toString(i);
531 throw ProcessError(
"Missing condition '" + cond + errorSuffix);
535 const std::string cond =
"earliestEnd:" +
toString(i);
537 throw ProcessError(
"Missing condition '" + cond + errorSuffix);
541 const std::string cond =
"latestEnd:" +
toString(i);
543 throw ProcessError(
"Missing condition '" + cond + errorSuffix);
552 for (
int i = 0; i < (int)
myPhases.size(); i++) {
555 std::vector<int> nextPhases = phase->
nextPhases;
556 if (nextPhases.size() == 0) {
557 nextPhases.push_back((i + 1) % (int)
myPhases.size());
558 }
else if (nextPhases.size() > 1) {
561 for (
int next : nextPhases) {
562 if (next >= 0 && next < (
int)
myPhases.size()) {
578 SUMOTime result = std::numeric_limits<SUMOTime>::max();
579 for (
int pI = 0; pI < (int)
myPhases.size(); pI++) {
581 const std::string& state = phase->
getState();
582 for (
int i = 0; i < (int)state.size(); i++) {
599 for (
int i = 0; i < (int)state.size(); i++) {
602 for (
MSLane* lane : lanes) {
628 loopInfo.loop->setVisible(
false);
636 if (step >= 0 && step !=
myStep) {
641 }
else if (step < 0) {
654 const SUMOTime lastSwitch = t - spentDuration;
679 if (state[i] ==
'G' || state[i] ==
'g') {
684 if (state[i] ==
'r' || state[i] ==
'u') {
694 const int origStep =
myStep;
704#ifdef DEBUG_PHASE_SELECTION
707 <<
" trySwitch dGap=" << (detectionGap == std::numeric_limits<double>::max() ?
"inf" :
toString(detectionGap))
708 <<
" multi=" << multiTarget <<
"\n";
711 if (detectionGap < std::numeric_limits<double>::max() && !multiTarget && !
myTraCISwitch) {
728 if (linkMinDur > 0) {
731 return multiTarget ?
TIME2STEPS(1) : linkMinDur;
740 myPhases[origStep]->myLastEnd = now;
748 if (loopInfo->isJammed()) {
753 loopInfo->lastGreenTime = now;
757#ifdef DEBUG_PHASE_SELECTION
780 if (newDuration % 1000 != 0) {
781 const SUMOTime totalDur = newDuration + actDuration;
782 newDuration = (totalDur / 1000 + 1) * 1000 - actDuration;
794 double result = std::numeric_limits<double>::max();
801 if (loopInfo.lastGreenTime < loopInfo.loop->getLastDetectionTime()) {
804 loopInfo.loop->setSpecialColor(
nullptr);
815#ifdef DEBUG_PHASE_SELECTION
827 if (loopInfo->isJammed()) {
833 if (actualGap < loopInfo->maxGap && !loopInfo->isJammed()) {
834 result =
MIN2(result, actualGap);
846 int result = cands.front();
854#ifdef DEBUG_PHASE_SELECTION
857 if (currentPrio > maxPrio) {
859 maxPrio = currentPrio;
862 for (
int step : cands) {
865#ifdef DEBUG_PHASE_SELECTION
878 if (prio > maxPrio) {
879 result = cands.front();
882 +
"', starvation at e1Detector '" + loopInfo.loop->getID()
883 +
"' which cannot be reached from the default phase " +
toString(
myStep) +
".");
886#ifdef DEBUG_PHASE_SELECTION
888 std::cout <<
SIMTIME <<
" p=" <<
myStep <<
" loop=" << loopInfo.loop->getID() <<
" prio=" << prio <<
" next=" << result <<
"\n";
902 while (!
myPhases[step]->isGreenPhase()) {
903 if (
myPhases[step]->nextPhases.size() > 0 &&
myPhases[step]->nextPhases.front() >= 0) {
904 if (
myPhases[step]->nextPhases.size() > 1) {
907 step =
myPhases[step]->nextPhases.front();
909 step = (step + 1) % (
int)
myPhases.size();
911 if (step == origStep) {
928#ifdef DEBUG_PHASE_SELECTION
940#ifdef DEBUG_PHASE_SELECTION
942 std::cout <<
" loop=" << loop->
getID()
946 <<
" canExtend=" << canExtend
1000 const std::string& targetState =
myPhases[target]->getState();
1003 targetState[i] ==
'G' || targetState[i] ==
'g')) {
1016 const std::string& targetState =
myPhases[target]->getState();
1019 && (state[i] ==
'G' || state[i] ==
'g')
1020 && !(targetState[i] ==
'G' || targetState[i] ==
'g')) {
1046 const size_t bracketOpen = condition.find(
'(');
1047 if (bracketOpen != std::string::npos) {
1049 size_t bracketClose = std::string::npos;
1051 for (
size_t i = bracketOpen + 1; i < condition.size(); i++) {
1052 if (condition[i] ==
'(') {
1054 }
else if (condition[i] ==
')') {
1062 if (bracketClose == std::string::npos) {
1063 throw ProcessError(
TLF(
"Unmatched parentheses in condition %'", condition));
1065 std::string cond2 = condition;
1066 const std::string inBracket = condition.substr(bracketOpen + 1, bracketClose - bracketOpen - 1);
1068 cond2.replace(bracketOpen, bracketClose - bracketOpen + 1,
toString(bracketVal));
1072 throw ProcessError(
"Error when evaluating expression '" + condition +
"':\n " + e.what());
1077 if (tokens.size() == 0) {
1079 }
else if (tokens.size() == 1) {
1083 throw ProcessError(
"Error when evaluating expression '" + condition +
"':\n " + e.what());
1085 }
else if (tokens.size() == 2) {
1086 if (tokens[0] ==
"not") {
1090 throw ProcessError(
"Error when evaluating expression '" + condition +
"':\n " + e.what());
1095 }
else if (tokens.size() == 3) {
1099 const std::string& o = tokens[1];
1104 throw ProcessError(
"Error when evaluating expression '" + condition +
"':\n " + e.what());
1107 const int iEnd = (int)tokens.size() - 1;
1109 for (
int i = 1; i < iEnd; i++) {
1110 if (tokens[i] == o) {
1115 std::vector<std::string> newTokens(tokens.begin(), tokens.begin() + (i - 1));
1116 newTokens.push_back(
toString(val));
1117 newTokens.insert(newTokens.end(), tokens.begin() + (i + 2), tokens.end());
1120 throw ProcessError(
"Error when evaluating expression '" + condition +
"':\n " + e.what());
1125 throw ProcessError(
"Parsing expressions with " +
toString(tokens.size()) +
" elements ('" + condition +
"') is not supported");
1132 if (o ==
"=" || o ==
"==") {
1133 return (
double)(a == b);
1134 }
else if (o ==
"<") {
1135 return (
double)(a < b);
1136 }
else if (o ==
">") {
1137 return (
double)(a > b);
1138 }
else if (o ==
"<=") {
1139 return (
double)(a <= b);
1140 }
else if (o ==
">=") {
1141 return (
double)(a >= b);
1142 }
else if (o ==
"!=") {
1143 return (
double)(a != b);
1144 }
else if (o ==
"or" || o ==
"||") {
1145 return (
double)(a || b);
1146 }
else if (o ==
"and" || o ==
"&&") {
1147 return (
double)(a && b);
1148 }
else if (o ==
"+") {
1150 }
else if (o ==
"-") {
1152 }
else if (o ==
"*") {
1154 }
else if (o ==
"/") {
1160 }
else if (o ==
"%") {
1162 }
else if (o ==
"**" || o ==
"^") {
1165 throw ProcessError(
"Unsupported operator '" + o +
"' in condition '" + condition +
"'");
1173 if ((
int)args.size() != f.
nArgs) {
1176 std::vector<double> args2;
1177 for (
auto a : args) {
1182 for (
int i = 0; i < (int)args2.size(); i++) {
1189 throw ProcessError(
"Error when evaluating function '" + fun +
"' with args '" +
joinToString(args2,
",") +
"' (" + e.what() +
")");
1191 double result =
myStack.back()[
"$0"];
1199 for (
const auto& assignment : assignments) {
1201 const std::string&
id = std::get<0>(assignment);
1203 ConditionMap::iterator it = conditions.find(
id);
1204 if (it != conditions.end()) {
1206 }
else if (forbidden.find(
id) != forbidden.end()) {
1207 throw ProcessError(
TLF(
"Modifying global condition '%' is forbidden",
id));
1218 if (expr.size() == 0) {
1220 }
else if (expr[0] ==
'!') {
1222 }
else if (expr[0] ==
'-') {
1226 const size_t pos = expr.find(
':');
1227 if (pos == std::string::npos) {
1234 auto it2 =
myStack.back().find(expr);
1235 if (it2 !=
myStack.back().end()) {
1242 const std::string fun = expr.substr(0, pos);
1243 const std::string arg = expr.substr(pos + 1);
1245 return retrieveDetExpression<MSInductLoop, SUMO_TAG_INDUCTION_LOOP>(arg, expr,
true)->getTimeSinceLastDetection();
1246 }
else if (fun ==
"a") {
1248 return retrieveDetExpression<MSInductLoop, SUMO_TAG_INDUCTION_LOOP>(arg, expr,
true)->getTimeSinceLastDetection() == 0;
1250 return retrieveDetExpression<MSE2Collector, SUMO_TAG_LANE_AREA_DETECTOR>(arg, expr,
true)->getCurrentVehicleNumber();
1252 }
else if (fun ==
"g" || fun ==
"r") {
1255 if (linkIndex >= 0 && linkIndex <
myNumLinks) {
1257 if (times.empty()) {
1269 return STEPS2TIME(times[linkIndex] + currentGreen);
1278 throw ProcessError(
"Invalid link index '" + arg +
"' in expression '" + expr +
"'");
1279 }
else if (fun ==
"c") {
1283 throw ProcessError(
"Unsupported function '" + fun +
"' in expression '" + expr +
"'");
1292std::map<std::string, double>
1294 std::map<std::string, double> result;
1296 result[li.loop->getID()] = li.loop->getOccupancy() > 0 ? 1 : 0;
1299 result[loop->getID()] = loop->getOccupancy() > 0 ? 1 : 0;
1302 result[loop->getID()] = loop->getCurrentVehicleNumber();
1307std::map<std::string, double>
1309 std::map<std::string, double> result;
1315 WRITE_ERRORF(
TL(
"Error when retrieving conditions '%' for tlLogic '%' (%)"), item.first,
getID(), e.what());
1325 const std::string cond = key.substr(10);
1330 throw InvalidArgument(
"Unknown condition '" + cond +
"' for actuated traffic light '" +
getID() +
"'");
1340 if (key ==
"detector-gap" || key ==
"passing-time" || key ==
"file" || key ==
"freq" || key ==
"vTypes"
1343 throw InvalidArgument(key +
" cannot be changed dynamically for actuated traffic light '" +
getID() +
"'");
1344 }
else if (key ==
"max-gap") {
1352 const std::string laneID = key.substr(8);
1354 if (loopInfo.lane->getID() == laneID) {
1360 throw InvalidArgument(
"Invalid lane '" + laneID +
"' in key '" + key +
"' for actuated traffic light '" +
getID() +
"'");
1361 }
else if (key ==
"jam-threshold") {
1369 const std::string laneID = key.substr(14);
1371 if (loopInfo.lane->getID() == laneID) {
1377 throw InvalidArgument(
"Invalid lane '" + laneID +
"' in key '" + key +
"' for actuated traffic light '" +
getID() +
"'");
1378 }
else if (key ==
"show-detectors") {
1384 }
else if (key ==
"inactive-threshold") {
#define DEFAULT_DETECTOR_GAP
#define DEFAULT_PASSING_TIME
#define DEFAULT_BIKE_LENGTH_WITH_GAP
#define DEFAULT_LENGTH_WITH_GAP
#define DEFAULT_INACTIVE_THRESHOLD
#define DEFAULT_CURRENT_PRIORITY
#define WRITE_WARNINGF(...)
#define WRITE_ERRORF(...)
#define WRITE_WARNING(msg)
SUMOTime string2time(const std::string &r)
convert string to SUMOTime
std::string time2string(SUMOTime t, bool humanReadable)
convert SUMOTime to string (independently of global format setting)
bool noVehicles(SVCPermissions permissions)
Returns whether an edge with the given permission forbids vehicles.
@ SVC_BICYCLE
vehicle is a bicycle
@ SVC_PEDESTRIAN
pedestrian
const double DEFAULT_BICYCLE_SPEED
int SVCPermissions
bitset where each bit declares whether a certain SVC may use this edge/lane
@ SUMO_TAG_INDUCTION_LOOP
alternative tag for e1 detector
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.
std::string joinNamedToString(const std::set< T *, C > &ns, const T_BETWEEN &between)
std::string joinToString(const std::vector< T > &v, const T_BETWEEN &between, std::streamsize accuracy=gPrecision)
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
static std::string checkForRelativity(const std::string &filename, const std::string &basePath)
Returns the path from a configuration so that it is accessable from the current working directory.
double myDetectorGap
The detector distance in seconds.
FunctionMap myFunctions
The loaded functions.
double myJamThreshold
The minimum continuous occupancy time to mark a detector as jammed.
double myMaxGap
The maximum gap to check in seconds.
const std::string getParameter(const std::string &key, const std::string defaultValue="") const override
try to get the value of the given parameter (including prefixed parameters)
std::vector< SwitchingRules > mySwitchingRules
~MSActuatedTrafficLightLogic()
Destructor.
std::vector< std::map< std::string, double > > myStack
The function call stack;.
double evalAtomicExpression(const std::string &expr) const
evaluate atomic expression
int getTarget(int step)
get the green phase following step
SUMOTime trySwitch() override
Switches to the next phase.
SUMOTime myLastTrySwitchTime
last time trySwitch was called
int getDetectorPriority(const InductLoopInfo &loopInfo) const
SUMOTime myFreq
The frequency for aggregating detector output.
SUMOTime getMinimumMinDuration(MSLane *lane) const
get the minimum min duration for all stretchable phases that affect the given lane
std::vector< const MSInductLoop * > myExtraLoops
extra loops for output/tracking
bool myShowDetectors
Whether the detectors shall be shown in the GUI.
std::vector< SUMOTime > myLinkMaxGreenTimes
maximum consecutive time that the given link may remain green
MSActuatedTrafficLightLogic(MSTLLogicControl &tlcontrol, const std::string &id, const std::string &programID, const SUMOTime offset, const MSSimpleTrafficLightLogic::Phases &phases, int step, SUMOTime delay, const Parameterised::Map ¶meter, const std::string &basePath, const ConditionMap &conditions=ConditionMap(), const AssignmentMap &assignments=AssignmentMap(), const FunctionMap &functions=FunctionMap())
Constructor.
void loadState(MSTLLogicControl &tlcontrol, SUMOTime t, int step, SUMOTime spentDuration) override
restores the tls state
SUMOTime getMaxDur(int step=-1) const override
AssignmentMap myAssignments
The condition assignments.
std::string myVehicleTypes
Whether detector output separates by vType.
double gapControl()
Return the minimum detection gap of all detectors if the current phase should be extended and double:...
std::vector< std::tuple< std::string, std::string, std::string > > AssignmentMap
std::set< std::string > myListedConditions
the conditions which shall be listed in GUITLLogicPhasesTrackerWindow
double evalExpression(const std::string &condition) const
evaluate custom switching condition
std::vector< SUMOTime > myLinkMinGreenTimes
minimum consecutive time that the given link must remain green
void changeStepAndDuration(MSTLLogicControl &tlcontrol, SUMOTime simStep, int step, SUMOTime stepDuration) override
Changes the current phase and her duration.
static const std::vector< std::string > OPERATOR_PRECEDENCE
void deactivateProgram() override
bool myHasMultiTarget
Whether any of the phases has multiple targets.
double myPassingTime
The passing time used in seconds.
SUMOTime getLinkMinDuration(int target) const
the minimum duratin for keeping the current phase due to linkMinDur constraints
SUMOTime getMinDur(int step=-1) const override
bool canExtendLinkGreen(int target)
whether the target phase is acceptable in light of linkMaxDur constraints
InductLoopMap myInductLoopsForPhase
A map from phase to induction loops to be used for gap control.
int decideNextPhaseCustom(bool mustSwitch)
select among candidate phases based on detector states and custom switching rules
double evalTernaryExpression(double a, const std::string &o, double b, const std::string &condition) const
evaluate atomic expression
void executeAssignments(const AssignmentMap &assignments, ConditionMap &conditions, const ConditionMap &forbidden=ConditionMap()) const
execute assignemnts of the logic or a custom function
void setShowDetectors(bool show)
bool myTraCISwitch
whether the next switch time was requested via TraCI
int getPhasePriority(int step) const
count the number of active detectors for the given step
SUMOTime duration(const double detectionGap) const
Returns the minimum duration of the current phase.
void activateProgram() override
called when switching programs
std::vector< InductLoopInfo > myInductLoops
bool maxLinkDurationReached()
whether the current phase cannot be continued due to linkMaxDur constraints
double evalCustomFunction(const std::string &fun, const std::string &arg) const
evaluate function expression
void initAttributeOverride()
initialize custom switching rules
std::map< std::string, double > getConditions() const override
return all named conditions defined for this traffic light
bool hasMajor(const std::string &state, const LaneVector &lanes) const
return whether there is a major link from the given lane in the given phase
std::vector< const MSE2Collector * > myExtraE2
SUMOTime getEarliestEnd(int step=-1) const override
std::map< std::string, Function > FunctionMap
std::map< std::string, double > getDetectorStates() const override
retrieve all detectors used by this program
void setParameter(const std::string &key, const std::string &value) override
Sets a parameter and updates internal constants.
std::vector< SUMOTime > myLinkGreenTimes
consecutive time that the given link index has been green
SUMOTime getLatestEnd(int step=-1) const override
std::vector< SUMOTime > myLinkRedTimes
Parameterised::Map ConditionMap
std::string myFile
The output file for generated detectors.
void initSwitchingRules()
ConditionMap myConditions
The custom switching conditions.
const std::string myDetectorPrefix
void init(NLDetectorBuilder &nb) override
Initialises the tls with information about incoming lanes.
int decideNextPhase()
select among candidate phases based on detector states
SUMOTime myInactiveThreshold
The time threshold to avoid starved phases.
const NamedObjectCont< MSDetectorFileOutput * > & getTypedDetectors(SumoXMLTag type) const
Returns the list of detectors of the given type.
void add(SumoXMLTag type, MSDetectorFileOutput *d, const std::string &device, SUMOTime interval, SUMOTime begin=-1)
Adds a detector/output combination into the containers.
A road/street connecting two junctions.
double getSpeedLimit() const
Returns the speed limit of the edge @caution The speed limit of the first lane is retured; should pro...
virtual void addEvent(Command *operation, SUMOTime execTimeStep=-1)
Adds an Event.
An unextended detector measuring at a fixed position on a fixed lane.
double getPosition() const
Returns the position of the detector on the lane.
virtual void setSpecialColor(const RGBColor *)
allows for special color in the gui version
double getTimeSinceLastDetection() const
Returns the time since the last vehicle left the detector.
SUMOTime getLastDetectionTime() const
return last time a vehicle was on the detector
Representation of a lane in the micro simulation.
const std::vector< IncomingLaneInfo > & getIncomingLanes() const
double getLength() const
Returns the lane's length.
MSLane * getLogicalPredecessorLane() const
get the most likely precedecessor lane (sorted using by_connections_to_sorter). The result is cached ...
const std::vector< MSLink * > & getLinkCont() const
returns the container with all links !!!
MSDetectorControl & getDetectorControl()
Returns the detector control.
static MSNet * getInstance()
Returns the pointer to the unique instance of MSNet (singleton).
MSEventControl * getBeginOfTimestepEvents()
Returns the event control for events executed at the begin of a time step.
SUMOTime getCurrentTimeStep() const
Returns the current simulation step.
The definition of a single phase of a tls logic.
SUMOTime maxDuration
The maximum duration of the phase.
LinkState getSignalState(int pos) const
Returns the state of the tls signal at the given position.
static const SUMOTime OVERRIDE_DURATION
SUMOTime latestEnd
The maximum time within the cycle for switching (for coordinated actuation)
SUMOTime minDuration
The minimum duration of the phase.
const std::string & getState() const
Returns the state within this phase.
bool isGreenPhase() const
Returns whether this phase is a pure "green" phase.
std::vector< int > nextPhases
The index of the phase that suceeds this one (or -1)
std::string finalTarget
The condition expression for switching into this phase when the active phase must end.
std::string earlyTarget
The condition expression for an early switch into this phase.
SUMOTime earliestEnd
The minimum time within the cycle for switching (for coordinated actuation)
A fixed traffic light logic.
SUMOTime getLatest() const
the maximum duration for keeping the current phase when considering 'latestEnd'
Phases myPhases
The list of phases this logic uses.
const MSPhaseDefinition & getPhase(int givenstep) const override
Returns the definition of the phase from the given position within the plan.
SUMOTime getEarliest(SUMOTime prevStart) const
the minimum duration for keeping the current phase when considering 'earliestEnd'
int myStep
The current step.
virtual const std::string getParameter(const std::string &key, const std::string defaultValue="") const override
gets a parameter
virtual void setParameter(const std::string &key, const std::string &value) override
Sets a parameter and updates internal constants.
const MSPhaseDefinition & getCurrentPhaseDef() const override
Returns the definition of the current phase.
void executeOnSwitchActions() const
A class that stores and controls tls and switching of their programs.
TLSLogicVariants & get(const std::string &id) const
Returns the variants of a named tls.
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.)
const LaneVector & getLanesAt(int i) const
Returns the list of lanes that are controlled by the signals at the given position.
std::vector< MSLane * > LaneVector
Definition of the list of arrival lanes subjected to this tls.
virtual void deactivateProgram()
SUMOTime getTimeInCycle() const
return time within the current cycle
const std::string & getProgramID() const
Returns this tl-logic's id.
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
virtual void activateProgram()
called when switching programs
bool setTrafficLightSignals(SUMOTime t) const
Applies the current signal states to controlled links.
std::vector< MSPhaseDefinition * > Phases
Definition of a list of phases, being the junction logic.
const LinkVector & getLinksAt(int i) const
Returns the list of links that are controlled by the signals at the given position.
LinkVectorVector myLinks
The list of LinkVectors; each vector contains the links that belong to the same link index.
virtual void init(NLDetectorBuilder &nb)
Initialises the tls with information about incoming lanes.
Builds detectors for microsim.
virtual MSDetectorFileOutput * createInductLoop(const std::string &id, MSLane *lane, double pos, double length, const std::string name, const std::string &vTypes, const std::string &nextEdges, int detectPersons, bool show)
Creates an instance of an e1 detector using the given values.
const std::string & getID() const
Returns the id.
T get(const std::string &id) const
Retrieves an item.
static OptionsCont & getOptions()
Retrieves the options.
std::map< std::string, std::string > Map
parameters map
double getDouble(const std::string &key, const double defaultValue) const
Returns the value for a given key converted to a double.
const Parameterised::Map & getParametersMap() const
Returns the inner key/value map.
virtual void setParameter(const std::string &key, const std::string &value)
Sets a parameter.
bool knowsParameter(const std::string &key) const
Returns whether the parameter is known.
static const RGBColor ORANGE
static const RGBColor GREEN
static const RGBColor RED
named colors
std::vector< std::string > getVector()
return vector of strings
static double toDouble(const std::string &sData)
converts a string into the double value described by it by calling the char-type converter
static bool startsWith(const std::string &str, const std::string prefix)
Checks whether a given string starts with the prefix.
static int toInt(const std::string &sData)
converts a string into the integer value described by it by calling the char-type converter,...
static bool toBool(const std::string &sData)
converts a string into the bool value described by it by calling the char-type converter
AssignmentMap assignments
std::vector< bool > servedPhase