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) {
233 inductLoopPosition = length - ilpos;
237 laneInductLoopMap[lane] = loop;
266 std::map<int, std::set<MSInductLoop*> > linkToLoops;
267 std::set<int> actuatedLinks;
269 std::vector<bool> neverMajor(numLinks,
true);
271 const std::string& state = phase->getState();
272 for (
int i = 0; i < numLinks; i++) {
274 neverMajor[i] =
false;
278 std::vector<bool> oneLane(numLinks,
false);
279 std::vector<bool> turnaround(numLinks,
true);
280 for (
int i = 0; i < numLinks; i++) {
283 int numMotorized = 0;
285 if ((l->getPermissions() & motorized) != 0) {
289 if (numMotorized == 1) {
295 if (!link->isTurnaround()) {
296 turnaround[i] =
false;
305 std::set<MSInductLoop*> loops;
306 if (phase->isActuated()) {
307 const std::string& state = phase->getState();
309 std::set<int> greenLinks;
311 std::set<int> greenLinksPermissive;
313 std::map<MSInductLoop*, std::set<int> > loopLinks;
315 for (
int i = 0; i < numLinks; i++) {
317 greenLinks.insert(i);
318 actuatedLinks.insert(i);
320 if (((neverMajor[i] || turnaround[i])
323 greenLinks.insert(i);
324 if (!turnaround[i]) {
325 actuatedLinks.insert(i);
328 greenLinksPermissive.insert(i);
331#ifdef DEBUG_DETECTORS
333 std::cout <<
" phase=" << phaseIndex <<
" i=" << i <<
" state=" << state[i] <<
" green=" << greenLinks.count(i) <<
" oneLane=" << oneLane[i]
334 <<
" turn=" << turnaround[i] <<
" loopLanes=";
336 if (laneInductLoopMap.count(lane) != 0) {
337 std::cout << lane->getID() <<
" ";
344 if (laneInductLoopMap.count(lane) != 0) {
345 loopLinks[laneInductLoopMap[lane]].insert(i);
349 for (
auto& item : loopLinks) {
354 bool foundUsable =
false;
356 for (
int j : item.second) {
357 if (greenLinks.count(j) == 0 && (info.
jamThreshold <= 0 || greenLinksPermissive.count(j) == 0)) {
359#ifdef DEBUG_DETECTORS
361 std::cout <<
" phase=" << phaseIndex <<
" check1: loopLane=" << loopLane->
getID() <<
" notGreen=" << j <<
" oneLane[j]=" << oneLane[j] <<
"\n";
375 if (link->isTurnaround()) {
378 const MSLane* next = link->getLane();
379 if (laneInductLoopMap.count(next) != 0) {
381 for (
int j : loopLinks[nextLoop]) {
382 if (greenLinks.count(j) == 0) {
384#ifdef DEBUG_DETECTORS
385 if (
DEBUG_COND) std::cout <<
" phase=" << phaseIndex <<
" check2: loopLane=" << loopLane->
getID()
386 <<
" nextLane=" << next->
getID() <<
" nextLink=" << j <<
" nextState=" << state[j] <<
"\n";
396 loops.insert(item.first);
397#ifdef DEBUG_DETECTORS
399 std::cout <<
" phase=" << phaseIndex <<
" usableLoops=" << item.first->getID() <<
" links=" <<
joinToString(item.second,
" ") <<
"\n";
402 for (
int j : item.second) {
403 linkToLoops[j].insert(item.first);
407 if (loops.size() == 0) {
411#ifdef DEBUG_DETECTORS
413 std::cout <<
" phase=" << phaseIndex <<
" loops=" <<
joinNamedToString(loops,
" ") <<
"\n";
416 std::cout <<
" linkToLoops:\n";
417 for (
auto item : linkToLoops) {
418 std::cout <<
" link=" << item.first <<
" loops=" <<
joinNamedToString(item.second,
" ") <<
"\n";
422 std::vector<InductLoopInfo*> loopInfos;
426 if (loopInfo.loop == loop) {
428 loopInfo.servedPhase[phaseIndex] =
true;
433#ifdef DEBUG_DETECTORS
435 std::cout <<
"final linkToLoops:\n";
436 for (
auto item : linkToLoops) {
437 std::cout <<
" link=" << item.first <<
" loops=" <<
joinNamedToString(item.second,
" ") <<
"\n";
441 for (
int i : actuatedLinks) {
442 if (linkToLoops[i].size() == 0 &&
myLinks[i].size() > 0
443 && (
myLinks[i].front()->getLaneBefore()->getPermissions() & motorized) != 0) {
454 WRITE_ERRORF(
TL(
"Invalid link '%' given as linkMaxDur parameter for actuated tlLogic '%', program '%."), kv.first.substr(11),
getID(),
getProgramID());
464 WRITE_ERRORF(
TL(
"Invalid link '%' given as linkMinDur parameter for actuated tlLogic '%', program '%."), kv.first.substr(11),
getID(),
getProgramID());
482 step = step < 0 ?
myStep : step;
491 step = step < 0 ?
myStep : step;
500 step = step < 0 ?
myStep : step;
509 step = step < 0 ?
myStep : step;
520 for (
int i = 0; i < (int)
myPhases.size(); i++) {
522 const std::string errorSuffix =
"' for overriding attribute in phase " +
toString(i) +
" of tlLogic '" +
getID() +
"' in program '" +
getProgramID() +
"'.";
524 const std::string cond =
"minDur:" +
toString(i);
526 throw ProcessError(
"Missing condition '" + cond + errorSuffix);
530 const std::string cond =
"maxDur:" +
toString(i);
532 throw ProcessError(
"Missing condition '" + cond + errorSuffix);
536 const std::string cond =
"earliestEnd:" +
toString(i);
538 throw ProcessError(
"Missing condition '" + cond + errorSuffix);
542 const std::string cond =
"latestEnd:" +
toString(i);
544 throw ProcessError(
"Missing condition '" + cond + errorSuffix);
553 for (
int i = 0; i < (int)
myPhases.size(); i++) {
556 std::vector<int> nextPhases = phase->
nextPhases;
557 if (nextPhases.size() == 0) {
558 nextPhases.push_back((i + 1) % (int)
myPhases.size());
559 }
else if (nextPhases.size() > 1) {
562 for (
int next : nextPhases) {
563 if (next >= 0 && next < (
int)
myPhases.size()) {
579 SUMOTime result = std::numeric_limits<SUMOTime>::max();
580 for (
int pI = 0; pI < (int)
myPhases.size(); pI++) {
582 const std::string& state = phase->
getState();
583 for (
int i = 0; i < (int)state.size(); i++) {
600 for (
int i = 0; i < (int)state.size(); i++) {
603 for (
MSLane* lane : lanes) {
629 loopInfo.loop->setVisible(
false);
637 if (step >= 0 && step !=
myStep) {
642 }
else if (step < 0) {
655 const SUMOTime lastSwitch = t - spentDuration;
680 if (state[i] ==
'G' || state[i] ==
'g') {
685 if (state[i] ==
'r' || state[i] ==
'u') {
695 const int origStep =
myStep;
705#ifdef DEBUG_PHASE_SELECTION
708 <<
" trySwitch dGap=" << (detectionGap == std::numeric_limits<double>::max() ?
"inf" :
toString(detectionGap))
709 <<
" multi=" << multiTarget <<
"\n";
712 if (detectionGap < std::numeric_limits<double>::max() && !multiTarget && !
myTraCISwitch) {
729 if (linkMinDur > 0) {
732 return multiTarget ?
TIME2STEPS(1) : linkMinDur;
741 myPhases[origStep]->myLastEnd = now;
749 if (loopInfo->isJammed()) {
754 loopInfo->lastGreenTime = now;
758#ifdef DEBUG_PHASE_SELECTION
781 if (newDuration % 1000 != 0) {
782 const SUMOTime totalDur = newDuration + actDuration;
783 newDuration = (totalDur / 1000 + 1) * 1000 - actDuration;
795 double result = std::numeric_limits<double>::max();
802 if (loopInfo.lastGreenTime < loopInfo.loop->getLastDetectionTime()) {
805 loopInfo.loop->setSpecialColor(
nullptr);
816#ifdef DEBUG_PHASE_SELECTION
828 if (loopInfo->isJammed()) {
834 if (actualGap < loopInfo->maxGap && !loopInfo->isJammed()) {
835 result =
MIN2(result, actualGap);
847 int result = cands.front();
855#ifdef DEBUG_PHASE_SELECTION
858 if (currentPrio > maxPrio) {
860 maxPrio = currentPrio;
863 for (
int step : cands) {
866#ifdef DEBUG_PHASE_SELECTION
879 if (prio > maxPrio) {
880 result = cands.front();
883 +
"', starvation at e1Detector '" + loopInfo.loop->getID()
884 +
"' which cannot be reached from the default phase " +
toString(
myStep) +
".");
887#ifdef DEBUG_PHASE_SELECTION
889 std::cout <<
SIMTIME <<
" p=" <<
myStep <<
" loop=" << loopInfo.loop->getID() <<
" prio=" << prio <<
" next=" << result <<
"\n";
903 while (!
myPhases[step]->isGreenPhase()) {
904 if (
myPhases[step]->nextPhases.size() > 0 &&
myPhases[step]->nextPhases.front() >= 0) {
905 if (
myPhases[step]->nextPhases.size() > 1) {
908 step =
myPhases[step]->nextPhases.front();
910 step = (step + 1) % (
int)
myPhases.size();
912 if (step == origStep) {
929#ifdef DEBUG_PHASE_SELECTION
941#ifdef DEBUG_PHASE_SELECTION
943 std::cout <<
" loop=" << loop->
getID()
947 <<
" canExtend=" << canExtend
1001 const std::string& targetState =
myPhases[target]->getState();
1004 targetState[i] ==
'G' || targetState[i] ==
'g')) {
1017 const std::string& targetState =
myPhases[target]->getState();
1020 && (state[i] ==
'G' || state[i] ==
'g')
1021 && !(targetState[i] ==
'G' || targetState[i] ==
'g')) {
1047 const size_t bracketOpen = condition.find(
'(');
1048 if (bracketOpen != std::string::npos) {
1050 size_t bracketClose = std::string::npos;
1052 for (
size_t i = bracketOpen + 1; i < condition.size(); i++) {
1053 if (condition[i] ==
'(') {
1055 }
else if (condition[i] ==
')') {
1063 if (bracketClose == std::string::npos) {
1064 throw ProcessError(
TLF(
"Unmatched parentheses in condition %'", condition));
1066 std::string cond2 = condition;
1067 const std::string inBracket = condition.substr(bracketOpen + 1, bracketClose - bracketOpen - 1);
1069 cond2.replace(bracketOpen, bracketClose - bracketOpen + 1,
toString(bracketVal));
1073 throw ProcessError(
"Error when evaluating expression '" + condition +
"':\n " + e.what());
1078 if (tokens.size() == 0) {
1080 }
else if (tokens.size() == 1) {
1084 throw ProcessError(
"Error when evaluating expression '" + condition +
"':\n " + e.what());
1086 }
else if (tokens.size() == 2) {
1087 if (tokens[0] ==
"not") {
1091 throw ProcessError(
"Error when evaluating expression '" + condition +
"':\n " + e.what());
1096 }
else if (tokens.size() == 3) {
1100 const std::string& o = tokens[1];
1105 throw ProcessError(
"Error when evaluating expression '" + condition +
"':\n " + e.what());
1108 const int iEnd = (int)tokens.size() - 1;
1110 for (
int i = 1; i < iEnd; i++) {
1111 if (tokens[i] == o) {
1116 std::vector<std::string> newTokens(tokens.begin(), tokens.begin() + (i - 1));
1117 newTokens.push_back(
toString(val));
1118 newTokens.insert(newTokens.end(), tokens.begin() + (i + 2), tokens.end());
1121 throw ProcessError(
"Error when evaluating expression '" + condition +
"':\n " + e.what());
1126 throw ProcessError(
"Parsing expressions with " +
toString(tokens.size()) +
" elements ('" + condition +
"') is not supported");
1133 if (o ==
"=" || o ==
"==") {
1134 return (
double)(a == b);
1135 }
else if (o ==
"<") {
1136 return (
double)(a < b);
1137 }
else if (o ==
">") {
1138 return (
double)(a > b);
1139 }
else if (o ==
"<=") {
1140 return (
double)(a <= b);
1141 }
else if (o ==
">=") {
1142 return (
double)(a >= b);
1143 }
else if (o ==
"!=") {
1144 return (
double)(a != b);
1145 }
else if (o ==
"or" || o ==
"||") {
1146 return (
double)(a || b);
1147 }
else if (o ==
"and" || o ==
"&&") {
1148 return (
double)(a && b);
1149 }
else if (o ==
"+") {
1151 }
else if (o ==
"-") {
1153 }
else if (o ==
"*") {
1155 }
else if (o ==
"/") {
1161 }
else if (o ==
"%") {
1163 }
else if (o ==
"**" || o ==
"^") {
1166 throw ProcessError(
"Unsupported operator '" + o +
"' in condition '" + condition +
"'");
1174 if ((
int)args.size() != f.
nArgs) {
1177 std::vector<double> args2;
1178 for (
auto a : args) {
1183 for (
int i = 0; i < (int)args2.size(); i++) {
1190 throw ProcessError(
"Error when evaluating function '" + fun +
"' with args '" +
joinToString(args2,
",") +
"' (" + e.what() +
")");
1192 double result =
myStack.back()[
"$0"];
1200 for (
const auto& assignment : assignments) {
1202 const std::string&
id = std::get<0>(assignment);
1204 ConditionMap::iterator it = conditions.find(
id);
1205 if (it != conditions.end()) {
1207 }
else if (forbidden.find(
id) != forbidden.end()) {
1208 throw ProcessError(
TLF(
"Modifying global condition '%' is forbidden",
id));
1219 if (expr.size() == 0) {
1221 }
else if (expr[0] ==
'!') {
1223 }
else if (expr[0] ==
'-') {
1227 const size_t pos = expr.find(
':');
1228 if (pos == std::string::npos) {
1235 auto it2 =
myStack.back().find(expr);
1236 if (it2 !=
myStack.back().end()) {
1243 const std::string fun = expr.substr(0, pos);
1244 const std::string arg = expr.substr(pos + 1);
1246 return retrieveDetExpression<MSInductLoop, SUMO_TAG_INDUCTION_LOOP>(arg, expr,
true)->getTimeSinceLastDetection();
1247 }
else if (fun ==
"a") {
1249 return retrieveDetExpression<MSInductLoop, SUMO_TAG_INDUCTION_LOOP>(arg, expr,
true)->getTimeSinceLastDetection() == 0;
1251 return retrieveDetExpression<MSE2Collector, SUMO_TAG_LANE_AREA_DETECTOR>(arg, expr,
true)->getCurrentVehicleNumber();
1253 }
else if (fun ==
"g" || fun ==
"r") {
1256 if (linkIndex >= 0 && linkIndex <
myNumLinks) {
1258 if (times.empty()) {
1270 return STEPS2TIME(times[linkIndex] + currentGreen);
1279 throw ProcessError(
"Invalid link index '" + arg +
"' in expression '" + expr +
"'");
1280 }
else if (fun ==
"c") {
1284 throw ProcessError(
"Unsupported function '" + fun +
"' in expression '" + expr +
"'");
1293std::map<std::string, double>
1295 std::map<std::string, double> result;
1297 result[li.loop->getID()] = li.loop->getOccupancy() > 0 ? 1 : 0;
1300 result[loop->getID()] = loop->getOccupancy() > 0 ? 1 : 0;
1303 result[loop->getID()] = loop->getCurrentVehicleNumber();
1308std::map<std::string, double>
1310 std::map<std::string, double> result;
1316 WRITE_ERRORF(
TL(
"Error when retrieving conditions '%' for tlLogic '%' (%)"), item.first,
getID(), e.what());
1326 const std::string cond = key.substr(10);
1331 throw InvalidArgument(
"Unknown condition '" + cond +
"' for actuated traffic light '" +
getID() +
"'");
1341 if (key ==
"detector-gap" || key ==
"passing-time" || key ==
"file" || key ==
"freq" || key ==
"vTypes"
1344 throw InvalidArgument(key +
" cannot be changed dynamically for actuated traffic light '" +
getID() +
"'");
1345 }
else if (key ==
"max-gap") {
1353 const std::string laneID = key.substr(8);
1355 if (loopInfo.lane->getID() == laneID) {
1361 throw InvalidArgument(
"Invalid lane '" + laneID +
"' in key '" + key +
"' for actuated traffic light '" +
getID() +
"'");
1362 }
else if (key ==
"jam-threshold") {
1370 const std::string laneID = key.substr(14);
1372 if (loopInfo.lane->getID() == laneID) {
1378 throw InvalidArgument(
"Invalid lane '" + laneID +
"' in key '" + key +
"' for actuated traffic light '" +
getID() +
"'");
1379 }
else if (key ==
"show-detectors") {
1385 }
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)
std::string time2string(SUMOTime t)
convert SUMOTime to string
SUMOTime string2time(const std::string &r)
convert string to SUMOTime
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.
const std::vector< MSLane * > & getLanes() const
Returns this edge's lanes.
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 ...
MSEdge & getEdge() const
Returns the lane's edge.
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.
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