58 std::vector<std::string>
59 TrafficLight::getIDList() {
65 TrafficLight::getIDCount() {
66 return (
int)getIDList().size();
71 TrafficLight::getRedYellowGreenState(
const std::string& tlsID) {
76 std::vector<TraCILogic>
77 TrafficLight::getAllProgramLogics(
const std::string& tlsID) {
78 std::vector<TraCILogic> result;
81 TraCILogic l(logic->getProgramID(), (
int)logic->getLogicType(), logic->getCurrentPhaseIndex());
82 l.subParameter = logic->getParametersMap();
84 l.phases.emplace_back(
new TraCIPhase(
STEPS2TIME(phase->duration), phase->getState(),
86 phase->getNextPhases(), phase->getName()));
88 result.emplace_back(l);
94 std::vector<std::string>
95 TrafficLight::getControlledJunctions(
const std::string& tlsID) {
96 std::set<std::string> junctionIDs;
99 for (
const MSLink* l : llinks) {
100 junctionIDs.insert(l->getJunction()->getID());
103 return std::vector<std::string>(junctionIDs.begin(), junctionIDs.end());
107 std::vector<std::string>
108 TrafficLight::getControlledLanes(
const std::string& tlsID) {
109 std::vector<std::string> laneIDs;
112 for (
const MSLane* l : llanes) {
113 laneIDs.push_back(l->getID());
120 std::vector<std::vector<TraCILink> >
121 TrafficLight::getControlledLinks(
const std::string& tlsID) {
122 std::vector<std::vector<TraCILink> > result;
125 for (
int i = 0; i < (int)lanes.size(); ++i) {
126 std::vector<TraCILink> subList;
130 for (
int j = 0; j < (int)llanes.size(); ++j) {
136 subList.emplace_back(TraCILink(llanes[j]->getID(), via, to));
138 result.emplace_back(subList);
145 TrafficLight::getProgram(
const std::string& tlsID) {
151 TrafficLight::getPhase(
const std::string& tlsID) {
157 TrafficLight::getPhaseName(
const std::string& tlsID) {
163 TrafficLight::getPhaseDuration(
const std::string& tlsID) {
169 TrafficLight::getNextSwitch(
const std::string& tlsID) {
175 TrafficLight::getSpentDuration(
const std::string& tlsID) {
180 TrafficLight::getServedPersonCount(
const std::string& tlsID,
int index) {
182 if (index < 0 || active->getPhaseNumber() <= index) {
183 throw TraCIException(
"The phase index " +
toString(index) +
" is not in the allowed range [0,"
189 const std::string& state = active->
getPhases()[index]->getState();
190 for (
int i = 0; i < (int)state.size(); i++) {
192 if (link->getLane()->getEdge().isCrossing()) {
206 }
else if (link->getLaneBefore()->getEdge().isCrossing()) {
209 if (
static_cast<MSPerson*
>(person)->
getNextEdge() == link->getLaneBefore()->getEdge().getID()) {
219 std::vector<std::string>
220 TrafficLight::getBlockingVehicles(
const std::string& tlsID,
int linkIndex) {
221 std::vector<std::string> result;
224 if (linkIndex < 0 || linkIndex >= active->
getNumLinks()) {
225 throw TraCIException(
"The link index " +
toString(linkIndex) +
" is not in the allowed range [0,"
229 result.push_back(veh->getID());
234 std::vector<std::string>
235 TrafficLight::getRivalVehicles(
const std::string& tlsID,
int linkIndex) {
236 std::vector<std::string> result;
238 if (linkIndex < 0 || linkIndex >= active->
getNumLinks()) {
239 throw TraCIException(
"The link index " +
toString(linkIndex) +
" is not in the allowed range [0,"
243 result.push_back(veh->getID());
248 std::vector<std::string>
249 TrafficLight::getPriorityVehicles(
const std::string& tlsID,
int linkIndex) {
250 std::vector<std::string> result;
252 if (linkIndex < 0 || linkIndex >= active->
getNumLinks()) {
253 throw TraCIException(
"The link index " +
toString(linkIndex) +
" is not in the allowed range [0,"
257 result.push_back(veh->getID());
262 std::vector<TraCISignalConstraint>
263 TrafficLight::getConstraints(
const std::string& tlsID,
const std::string& tripId) {
264 std::vector<TraCISignalConstraint> result;
268 throw TraCIException(
"'" + tlsID +
"' is not a rail signal");
271 if (tripId !=
"" && tripId != item.first) {
275 result.push_back(buildConstraint(tlsID, item.first, c));
281 std::vector<TraCISignalConstraint>
282 TrafficLight::getConstraintsByFoe(
const std::string& foeSignal,
const std::string& foeId) {
285 std::vector<TraCISignalConstraint> result;
286 for (
const std::string& tlsID : getIDList()) {
294 && (foeId ==
"" || pc->
myTripId == foeId)) {
295 result.push_back(buildConstraint(s->
getID(), item.first, pc));
306 TrafficLight::addConstraint(
const std::string& tlsID,
const std::string& tripId,
const std::string& foeSignal,
const std::string& foeId,
const int type,
const int limit) {
312 throw TraCIException(
"'" + tlsID +
"' is not a rail signal");
315 throw TraCIException(
"'" + foeSignal +
"' is not a rail signal");
322 std::vector<TraCISignalConstraint>
323 TrafficLight::swapConstraints(
const std::string& tlsID,
const std::string& tripId,
const std::string& foeSignal,
const std::string& foeId) {
324 #ifdef DEBUG_CONSTRAINT_DEADLOCK
325 std::cout <<
"swapConstraints tlsId=" << tlsID <<
" tripId=" << tripId <<
" foeSignal=" << foeSignal <<
" foeId=" << foeId <<
"\n";
332 throw TraCIException(
"'" + tlsID +
"' is not a rail signal");
335 throw TraCIException(
"'" + foeSignal +
"' is not a rail signal");
339 if (tripId == item.first) {
356 swapParameters(swapped);
359 return findConstraintsDeadLocks(foeId, tripId, foeSignal, tlsID);
361 throw TraCIException(
"Rail signal '" + tlsID +
"' does not have a constraint for tripId '" + tripId +
"' with foeSignal '" + foeSignal +
"' and foeId '" + foeId +
"'");
366 std::vector<std::pair<std::string, std::string> >
367 TrafficLight::getSwapParams(
int constraintType) {
368 std::vector<std::pair<std::string, std::string> > result({
371 {
"arrival",
"foeArrival"}});
373 if (constraintType == MSRailSignalConstraint::ConstraintType::BIDI_PREDECESSOR) {
374 std::vector<std::pair<std::string, std::string> > special({
375 {
"busStop",
"busStop2"},
376 {
"priorStop",
"priorStop2"},
377 {
"stopArrival",
"foeStopArrival"}});
378 result.insert(result.end(), special.begin(), special.end());
387 for (
auto keys : getSwapParams(c->
getType())) {
388 swapParameters(c, keys.first, keys.second);
409 TrafficLight::swapParameters(TraCISignalConstraint& c) {
411 for (
auto keys : getSwapParams(c.type)) {
412 swapParameters(c, keys.first, keys.second);
417 TrafficLight::swapParameters(TraCISignalConstraint& c,
const std::string& key1,
const std::string& key2) {
418 auto it1 = c.param.find(key1);
419 auto it2 = c.param.find(key2);
420 const std::string value1 = it1 != c.param.end() ? it1->second :
"";
421 const std::string value2 = it2 != c.param.end() ? it2->second :
"";
423 c.param[key2] = value1;
428 c.param[key1] = value2;
436 TrafficLight::removeConstraints(
const std::string& tlsID,
const std::string& tripId,
const std::string& foeSignal,
const std::string& foeId) {
439 for (
const std::string& tlsCand : getIDList()) {
440 if (tlsID ==
"" || tlsCand == tlsID) {
445 if (tripId ==
"" || item.first == tripId) {
449 && (foeId ==
"" || pc->
myTripId == foeId)
463 TrafficLight::updateConstraints(
const std::string& vehID, std::string tripId) {
470 tripId = tripId ==
"" ? curTripId : tripId;
473 std::map<const MSRailSignal*, std::set<std::string> > onRoute;
477 for (
auto it = routeIt; it < stop.edge; it++) {
480 if (it + 1 != route.end()) {
481 const MSEdge* next = *(it + 1);
483 if (link !=
nullptr && link->
getTLLogic() !=
nullptr) {
485 onRoute[s].insert(curTripId);
490 if (stop.pars.tripId !=
"") {
491 curTripId = stop.pars.tripId;
495 for (
auto it = routeIt; it < route.end(); it++) {
498 if (it + 1 != route.end()) {
499 const MSEdge* next = *(it + 1);
501 if (link !=
nullptr && link->
getTLLogic() !=
nullptr) {
503 onRoute[s].insert(curTripId);
516 std::vector<MSRailSignalConstraint*> onVeh;
517 std::vector<std::pair<std::string, MSRailSignalConstraint*> > byVeh;
519 for (
auto item : s->getConstraints()) {
523 if (item.first == tripId) {
524 if (onRoute[s].count(tripId) == 0) {
526 onVeh.push_back(cand);
528 }
else if (pc->
myTripId == tripId) {
531 byVeh.push_back(std::make_pair(item.first, cand));
538 s->removeConstraint(tripId, c);
540 for (
auto item : byVeh) {
541 s->removeConstraint(item.first, item.second);
547 std::vector<TraCISignalConstraint>
548 TrafficLight::findConstraintsDeadLocks(
const std::string& foeId,
const std::string& tripId,
const std::string& foeSignal,
const std::string& tlsID) {
549 std::vector<TraCISignalConstraint> result;
555 std::map<std::string, TraCISignalConstraint> constraintsOnTripId;
556 std::map<std::string, TraCISignalConstraint> constrainedByFoeId;
557 std::set<std::string> foeId2Cands1;
558 std::set<std::string> foeId2Cands2;
560 for (
auto item : s->getConstraints()) {
564 if (item.first == tripId) {
568 constraintsOnTripId[pc->
myTripId] = tsc;
570 for (std::string& futureFoe2Id : getFutureTripIds(pc->
myTripId)) {
571 foeId2Cands1.insert(futureFoe2Id);
573 constraintsOnTripId[futureFoe2Id] = tsc;
578 constrainedByFoeId[item.first] = tsc;
579 foeId2Cands2.insert(item.first);
580 for (std::string& futureTripId : getFutureTripIds(item.first)) {
581 foeId2Cands2.insert(futureTripId);
583 constrainedByFoeId[futureTripId] = tsc;
590 #ifdef DEBUG_CONSTRAINT_DEADLOCK
591 std::cout <<
"findConstraintsDeadLocks foeId=" << foeId <<
" tripId=" << tripId <<
" foeSignal=" << foeSignal <<
" tlsID=" << tlsID <<
"\n";
592 std::cout <<
" foeId2Cands1=" <<
toString(foeId2Cands1) <<
"\n";
593 std::cout <<
" foeId2Cands2=" <<
toString(foeId2Cands2) <<
"\n";
595 if (foeId2Cands1.size() > 0) {
603 if (foe !=
nullptr) {
606 for (
const std::string& foeId2 : foeId2Cands1) {
609 if (foe2 !=
nullptr) {
611 const TraCISignalConstraint& c = constraintsOnTripId[foeId2];
612 bool foeAhead =
false;
614 const MSEdge* e = foe2Route[i];
623 #ifdef DEBUG_CONSTRAINT_DEADLOCK
624 std::cout <<
"findConstraintsDeadLocks foeId=" << foeId <<
" tripId=" << tripId <<
" foeSignal=" << foeSignal <<
"\n";
628 <<
" " << constraintsOnTripId[foeId2].getString() <<
"\n";
639 TraCISignalConstraint nc;
642 nc.signalId = c.foeSignal;
643 nc.foeSignal = c.signalId;
650 result.push_back(nc);
652 std::vector<TraCISignalConstraint> result2 = swapConstraints(c.signalId, c.tripId, c.foeSignal, c.foeId);
653 result.insert(result.end(), result2.begin(), result2.end());
656 const std::vector<TraCISignalConstraint>& result4 = findConstraintsDeadLocks(foeId, tripId, foeSignal, tlsID);
657 result.insert(result.end(), result4.begin(), result4.end());
665 if (foeId2Cands2.size() > 0) {
672 std::set<const MSEdge*> egoToSignal;
676 const MSEdge* e = egoRoute[i];
677 egoToSignal.insert(e);
683 for (
const std::string& foeId2 : foeId2Cands2) {
687 if (foe2 !=
nullptr) {
688 if (egoToSignal.count(foe2->
getEdge()) != 0
690 const TraCISignalConstraint& c = constrainedByFoeId[foeId2];
691 #ifdef DEBUG_CONSTRAINT_DEADLOCK
692 std::cout <<
"findConstraintsDeadLocks foeId=" << foeId <<
" tripId=" << tripId <<
" foeSignal=" << foeSignal <<
"\n";
694 <<
" " << c.getString() <<
"\n";
697 TraCISignalConstraint nc;
700 nc.signalId = c.foeSignal;
701 nc.foeSignal = c.signalId;
708 result.push_back(nc);
710 std::vector<TraCISignalConstraint> result2 = swapConstraints(c.signalId, c.tripId, c.foeSignal, c.foeId);
711 result.insert(result.end(), result2.begin(), result2.end());
714 const std::vector<TraCISignalConstraint>& result4 = findConstraintsDeadLocks(foeId, tripId, foeSignal, tlsID);
715 result.insert(result.end(), result4.begin(), result4.end());
720 }
else if (ego !=
nullptr) {
721 WRITE_WARNINGF(
TL(
"Cannot check for all deadlocks on swapConstraints because the route for vehicle '%' is not computed yet"), ego->
getID());
726 std::vector<std::string> foeIds2;
727 std::set_intersection(
728 foeId2Cands1.begin(), foeId2Cands1.end(),
729 foeId2Cands2.begin(), foeId2Cands2.end(),
730 std::back_inserter(foeIds2));
731 #ifdef DEBUG_CONSTRAINT_DEADLOCK
732 std::cout <<
"findConstraintsDeadLocks foeId=" << foeId <<
" tripId=" << tripId <<
" foeSignal=" << foeSignal <<
"\n";
733 for (
const std::string& foeId2 : foeIds2) {
734 std::cout <<
" deadlockId=" << foeId2 <<
" " << constraintsOnTripId[foeId2].getString() <<
" " << constrainedByFoeId[foeId2].getString() <<
"\n";
737 if (foeIds2.size() > 0) {
738 TraCISignalConstraint c = constrainedByFoeId[foeIds2.front()];
739 if (c.type == MSRailSignalConstraint::ConstraintType::INSERTION_PREDECESSOR) {
741 c = constraintsOnTripId[foeIds2.front()];
743 TraCISignalConstraint nc;
746 nc.signalId = c.foeSignal;
747 nc.foeSignal = c.signalId;
754 result.push_back(nc);
756 const std::vector<TraCISignalConstraint>& result2 = swapConstraints(c.signalId, c.tripId, c.foeSignal, c.foeId);
757 result.insert(result.end(), result2.begin(), result2.end());
758 if (foeIds2.size() > 1) {
760 const std::vector<TraCISignalConstraint>& result3 = findConstraintsDeadLocks(foeId, tripId, foeSignal, tlsID);
761 result.insert(result.end(), result3.begin(), result3.end());
769 TrafficLight::getVehicleByTripId(
const std::string tripOrVehID) {
781 std::vector<std::string>
782 TrafficLight::getFutureTripIds(
const std::string vehID) {
783 std::vector<std::string> result;
788 result.push_back(tripId);
791 if (stop.pars.tripId !=
"") {
792 result.push_back(stop.pars.tripId);
801 TrafficLight::getParameter(
const std::string& tlsID,
const std::string& paramName) {
804 throw TraCIException(
"'" + tlsID +
"' is not a NEMA controller");
814 TrafficLight::setRedYellowGreenState(
const std::string& tlsID,
const std::string& state) {
820 TrafficLight::setPhase(
const std::string& tlsID,
const int index) {
822 if (index < 0 || active->getPhaseNumber() <= index) {
823 throw TraCIException(
"The phase index " +
toString(index) +
" is not in the allowed range [0,"
832 TrafficLight::setPhaseName(
const std::string& tlsID,
const std::string& name) {
839 TrafficLight::setProgram(
const std::string& tlsID,
const std::string& programID) {
843 throw TraCIException(e.what());
849 TrafficLight::setPhaseDuration(
const std::string& tlsID,
const double phaseDuration) {
857 TrafficLight::setProgramLogic(
const std::string& tlsID,
const TraCILogic& logic) {
860 if (logic.currentPhaseIndex >= (
int)logic.phases.size()) {
861 throw TraCIException(
"set program: parameter index must be less than parameter phase number.");
863 std::vector<MSPhaseDefinition*> phases;
864 for (
const std::shared_ptr<libsumo::TraCIPhase>& phase : logic.phases) {
869 phases.push_back(sumoPhase);
871 if (vars.
getLogic(logic.programID) ==
nullptr) {
873 int step = logic.currentPhaseIndex;
874 const std::string basePath =
"";
880 tlsID, logic.programID, 0,
881 phases, step, nextSwitch,
882 logic.subParameter, basePath);
886 tlsID, logic.programID, 0,
887 phases, step, nextSwitch,
888 logic.subParameter, basePath);
892 tlsID, logic.programID, 0,
893 phases, step, nextSwitch,
894 logic.subParameter, basePath);
899 phases, step, nextSwitch,
903 throw TraCIException(
"Unsupported traffic light type '" +
toString(logic.type) +
"'");
906 if (!vars.
addLogic(logic.programID, tlLogic,
true,
true)) {
907 throw TraCIException(
"Could not add traffic light logic '" + logic.programID +
"'");
910 throw TraCIException(e.what());
918 tlLogic->
setPhases(phases, logic.currentPhaseIndex);
926 TrafficLight::setParameter(
const std::string& tlsID,
const std::string& paramName,
const std::string& value) {
929 throw TraCIException(
"'" + tlsID +
"' is not a NEMA controller");
937 TrafficLight::setNemaSplits(
const std::string& tlsID,
const std::vector<double>& splits) {
938 setParameter(tlsID,
"NEMA.splits",
toString(splits));
942 TrafficLight::setNemaMaxGreens(
const std::string& tlsID,
const std::vector<double>& maxGreens) {
943 setParameter(tlsID,
"NEMA.maxGreens",
toString(maxGreens));
947 TrafficLight::setNemaCycleLength(
const std::string& tlsID,
double cycleLength) {
948 setParameter(tlsID,
"NEMA.cycleLength",
toString(cycleLength));
952 TrafficLight::setNemaOffset(
const std::string& tlsID,
double offset) {
953 setParameter(tlsID,
"NEMA.offset",
toString(offset));
959 TraCISignalConstraint c;
979 std::shared_ptr<VariableWrapper>
980 TrafficLight::makeWrapper() {
981 return std::make_shared<Helper::SubscriptionWrapper>(handleVariable, mySubscriptionResults, myContextSubscriptionResults);
986 TrafficLight::handleVariable(
const std::string& objID,
const int variable, VariableWrapper* wrapper,
tcpip::Storage* paramData) {
989 return wrapper->wrapStringList(objID, variable, getIDList());
991 return wrapper->wrapInt(objID, variable, getIDCount());
993 return wrapper->wrapString(objID, variable, getRedYellowGreenState(objID));
995 return wrapper->wrapStringList(objID, variable, getControlledLanes(objID));
997 return wrapper->wrapInt(objID, variable, getPhase(objID));
999 return wrapper->wrapString(objID, variable, getPhaseName(objID));
1001 return wrapper->wrapString(objID, variable, getProgram(objID));
1003 return wrapper->wrapDouble(objID, variable, getPhaseDuration(objID));
1005 return wrapper->wrapDouble(objID, variable, getNextSwitch(objID));
1007 return wrapper->wrapDouble(objID, variable, getSpentDuration(objID));
1009 return wrapper->wrapStringList(objID, variable, getControlledJunctions(objID));
1012 return wrapper->wrapString(objID, variable, getParameter(objID, paramData->
readString()));
1015 return wrapper->wrapStringPair(objID, variable, getParameterWithKey(objID, paramData->
readString()));
std::vector< const MSEdge * > ConstMSEdgeVector
#define WRITE_WARNINGF(...)
const int VEHPARS_FORCE_REROUTE
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
#define LIBSUMO_SUBSCRIPTION_IMPLEMENTATION(CLASS, DOM)
#define LIBSUMO_GET_PARAMETER_WITH_KEY_IMPLEMENTATION(CLASS)
An actuated (adaptive) traffic light logic.
The base class for microscopic and mesoscopic vehicles.
const std::list< MSStop > & getStops() const
const SUMOVehicleParameter & getParameter() const
Returns the vehicle's parameter (including departure definition)
const MSRouteIterator & getCurrentRouteEdge() const
Returns an iterator pointing to the current edge in this vehicles route.
const MSRoute & getRoute() const
Returns the current route.
An actuated traffic light logic based on time delay of approaching vehicles.
A road/street connecting two junctions.
const std::set< MSTransportable *, ComparatorNumericalIdLess > & getPersons() const
Returns this edge's persons set.
const std::vector< MSLane * > & getLanes() const
Returns this edge's lanes.
const MSJunction * getToJunction() const
SumoXMLNodeType getType() const
return the type of this Junction
Representation of a lane in the micro simulation.
const std::vector< MSLink * > & getLinkCont() const
returns the container with all links !!!
MSEdge & getEdge() const
Returns the lane's edge.
MSLane * getViaLane() const
Returns the following inner lane.
MSLane * getLane() const
Returns the connected lane.
const MSTrafficLightLogic * getTLLogic() const
Returns the TLS index.
static MSNet * getInstance()
Returns the pointer to the unique instance of MSNet (singleton).
MSTLLogicControl & getTLSControl()
Returns the tls logics control.
MSVehicleControl & getVehicleControl()
Returns the vehicle control.
SUMOTime getCurrentTimeStep() const
Returns the current simulation step.
virtual void createTLWrapper(MSTrafficLightLogic *)
creates a wrapper for the given logic (see GUINet)
const std::string & getNextEdge() const
return the list of internal edges if this person is walking and the pedestrian model allows it
The definition of a single phase of a tls logic.
const std::string & getState() const
Returns the state within this phase.
SUMOTime maxDuration
The maximum duration of the phase.
SUMOTime minDuration
The minimum duration of the phase.
SUMOTime duration
The duration of the phase.
const std::string & getName() const
std::vector< int > nextPhases
The index of the phase that suceeds this one (or -1)
const MSRailSignal * myFoeSignal
store the foe signal (for TraCI access)
bool cleared() const
whether the constraint has been met
const std::string myTripId
id of the predecessor that must already have passed
const int myLimit
the number of passed vehicles within which tripId must have occured
A base class for constraints.
virtual void setActive(bool active)=0
ConstraintType getType() const
ConstraintType getSwappedType() const
static MSRailSignalControl & getInstance()
const std::vector< MSRailSignal * > & getSignals() const
void addConstraint(const std::string &tripId, MSRailSignalConstraint *constraint)
register constraint for signal switching
bool removeConstraint(const std::string &tripId, MSRailSignalConstraint *constraint)
remove constraint for signal switching
const std::map< std::string, std::vector< MSRailSignalConstraint * > > & getConstraints() const
const ConstMSEdgeVector & getEdges() const
A fixed traffic light logic.
void setPhases(const Phases &phases, int index)
Replaces the phases and set the phase index.
Storage for all programs of a single tls.
void switchTo(MSTLLogicControl &tlc, const std::string &programID)
void setStateInstantiatingOnline(MSTLLogicControl &tlc, const std::string &state)
std::vector< MSTrafficLightLogic * > getAllLogics() const
MSTrafficLightLogic * getLogic(const std::string &programID) const
void executeOnSwitchActions() const
bool addLogic(const std::string &programID, MSTrafficLightLogic *logic, bool netWasLoaded, bool isNewDefault=true)
Adds a logic (program). In case of an error the logic gets deleted.
MSTrafficLightLogic * getActive() const
MSTrafficLightLogic * getDefault() const
return the default program (that last used program except TRACI_PROGRAM)
A class that stores and controls tls and switching of their programs.
std::vector< std::string > getAllTLIds() const
The parent class for traffic light logics.
const LinkVector & getLinksAt(int i) const
Returns the list of links that are controlled by the signals at the given position.
virtual const MSPhaseDefinition & getCurrentPhaseDef() const =0
Returns the definition of the current phase.
std::vector< LaneVector > LaneVectorVector
Definition of a list that holds lists of lanes that do have the same attribute.
virtual int getPhaseNumber() const =0
Returns the number of phases.
virtual int getCurrentPhaseIndex() const =0
Returns the current index within the program.
std::vector< MSLane * > LaneVector
Definition of the list of arrival lanes subjected to this tls.
virtual const MSPhaseDefinition & getPhase(int givenstep) const =0
Returns the definition of the phase from the given position within the plan.
const LaneVectorVector & getLaneVectors() const
Returns the list of lists of all lanes controlled by this tls.
virtual VehicleVector getPriorityVehicles(int linkIndex)
return vehicles that approach the intersection/rail signal and have priority over vehicles that wish ...
virtual void changeStepAndDuration(MSTLLogicControl &tlcontrol, SUMOTime simStep, int step, SUMOTime stepDuration)=0
Changes the current phase and her duration.
const LinkVectorVector & getLinks() const
Returns the list of lists of all affected links.
virtual VehicleVector getBlockingVehicles(int linkIndex)
return vehicles that block the intersection/rail signal for vehicles that wish to pass the given link...
virtual VehicleVector getRivalVehicles(int linkIndex)
return vehicles that approach the intersection/rail signal and are in conflict with vehicles that wis...
TrafficLightType getLogicType() const
Returns the type of the logic.
int getNumLinks() const
return the number of controlled link indices
bool setTrafficLightSignals(SUMOTime t) const
Applies the current signal states to controlled links.
std::vector< LinkVector > LinkVectorVector
Definition of a list that holds lists of links that do have the same attribute.
std::vector< MSLink * > LinkVector
Definition of the list of links that are subjected to this tls.
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.
const MSEdge * getEdge() const
Returns the current edge.
const MSLane * getLane() const
Returns the current lane (may be nullptr)
The class responsible for building and deletion of vehicles.
std::map< std::string, SUMOVehicle * >::const_iterator constVehIt
Definition of the internal vehicles map iterator.
SUMOVehicle * getVehicle(const std::string &id) const
Returns the vehicle with the given id.
constVehIt loadedVehBegin() const
Returns the begin of the internal vehicle map.
constVehIt loadedVehEnd() const
Returns the end of the internal vehicle map.
A NEMA (adaptive) traffic light logic based on E2Detector.
Builds detectors for microsim.
const std::string & getID() const
Returns the id.
void unsetParameter(const std::string &key)
Removes a parameter.
virtual const std::string getParameter(const std::string &key, const std::string defaultValue="") const
Returns the value for a given key.
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.
void updateParameters(const Parameterised::Map &mapArg)
Adds or updates all given parameters from the map.
virtual NumericalID getNumericalID() const =0
return the numerical ID which is only for internal usage
virtual const SUMOVehicleParameter & getParameter() const =0
Returns the vehicle's parameter (including departure definition)
virtual int getRoutePosition() const =0
return index of edge within route
virtual const MSEdge * getEdge() const =0
Returns the edge the object is currently at.
virtual double getPositionOnLane() const =0
Get the object's position along the lane.
Representation of a vehicle.
virtual const MSRoute & getRoute() const =0
Returns the current route.
virtual bool hasDeparted() const =0
Returns whether this vehicle has departed.
bool wasSet(int what) const
Returns whether the given parameter was set.
static bool startsWith(const std::string &str, const std::string prefix)
Checks whether a given string starts with the prefix.
C++ TraCI client API implementation.
static MSBaseVehicle * getVehicle(const std::string &id)
static MSTLLogicControl::TLSLogicVariants & getTLS(const std::string &id)
virtual std::string readString()
virtual int readUnsignedByte()
TRACI_CONST int TRACI_ID_LIST
std::map< std::string, libsumo::SubscriptionResults > ContextSubscriptionResults
TRACI_CONST int TL_CONTROLLED_LANES
TRACI_CONST int TL_SPENT_DURATION
TRACI_CONST int TL_CONTROLLED_JUNCTIONS
std::map< std::string, libsumo::TraCIResults > SubscriptionResults
{object->{variable->value}}
TRACI_CONST int VAR_PARAMETER
TRACI_CONST int TL_NEXT_SWITCH
TRACI_CONST int VAR_PARAMETER_WITH_KEY
TRACI_CONST int TL_PHASE_DURATION
TRACI_CONST int TL_CURRENT_PHASE
TRACI_CONST int TL_RED_YELLOW_GREEN_STATE
TRACI_CONST int TL_CURRENT_PROGRAM
std::string tripId
the tripId or vehicle id of the train that is constrained