58std::vector<std::string>
59TrafficLight::getIDList() {
65TrafficLight::getIDCount() {
66 return (
int)getIDList().size();
71TrafficLight::getRedYellowGreenState(
const std::string& tlsID) {
76std::vector<TraCILogic>
77TrafficLight::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);
94std::vector<std::string>
95TrafficLight::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());
107std::vector<std::string>
108TrafficLight::getControlledLanes(
const std::string& tlsID) {
109 std::vector<std::string> laneIDs;
112 for (
const MSLane* l : llanes) {
113 laneIDs.push_back(l->getID());
120std::vector<std::vector<TraCILink> >
121TrafficLight::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);
145TrafficLight::getProgram(
const std::string& tlsID) {
151TrafficLight::getPhase(
const std::string& tlsID) {
157TrafficLight::getPhaseName(
const std::string& tlsID) {
163TrafficLight::getPhaseDuration(
const std::string& tlsID) {
169TrafficLight::getNextSwitch(
const std::string& tlsID) {
174TrafficLight::getServedPersonCount(
const std::string& tlsID,
int index) {
176 if (index < 0 || active->getPhaseNumber() <= index) {
177 throw TraCIException(
"The phase index " +
toString(index) +
" is not in the allowed range [0,"
183 const std::string& state = active->
getPhases()[index]->getState();
184 for (
int i = 0; i < (int)state.size(); i++) {
186 if (link->getLane()->getEdge().isCrossing()) {
188 for (
MSTransportable* person : link->getLaneBefore()->getEdge().getPersons()) {
200 }
else if (link->getLaneBefore()->getEdge().isCrossing()) {
202 for (
MSTransportable* person : link->getLane()->getEdge().getPersons()) {
203 if (
static_cast<MSPerson*
>(person)->
getNextEdge() == link->getLaneBefore()->getEdge().getID()) {
213std::vector<std::string>
214TrafficLight::getBlockingVehicles(
const std::string& tlsID,
int linkIndex) {
215 std::vector<std::string> result;
218 if (linkIndex < 0 || linkIndex >= active->
getNumLinks()) {
219 throw TraCIException(
"The link index " +
toString(linkIndex) +
" is not in the allowed range [0,"
223 result.push_back(veh->getID());
228std::vector<std::string>
229TrafficLight::getRivalVehicles(
const std::string& tlsID,
int linkIndex) {
230 std::vector<std::string> result;
232 if (linkIndex < 0 || linkIndex >= active->
getNumLinks()) {
233 throw TraCIException(
"The link index " +
toString(linkIndex) +
" is not in the allowed range [0,"
237 result.push_back(veh->getID());
242std::vector<std::string>
243TrafficLight::getPriorityVehicles(
const std::string& tlsID,
int linkIndex) {
244 std::vector<std::string> result;
246 if (linkIndex < 0 || linkIndex >= active->
getNumLinks()) {
247 throw TraCIException(
"The link index " +
toString(linkIndex) +
" is not in the allowed range [0,"
251 result.push_back(veh->getID());
256std::vector<TraCISignalConstraint>
257TrafficLight::getConstraints(
const std::string& tlsID,
const std::string& tripId) {
258 std::vector<TraCISignalConstraint> result;
262 throw TraCIException(
"'" + tlsID +
"' is not a rail signal");
265 if (tripId !=
"" && tripId != item.first) {
269 result.push_back(buildConstraint(tlsID, item.first, c));
275std::vector<TraCISignalConstraint>
276TrafficLight::getConstraintsByFoe(
const std::string& foeSignal,
const std::string& foeId) {
279 std::vector<TraCISignalConstraint> result;
280 for (
const std::string& tlsID : getIDList()) {
288 && (foeId ==
"" || pc->
myTripId == foeId)) {
289 result.push_back(buildConstraint(s->
getID(), item.first, pc));
298std::vector<TraCISignalConstraint>
299TrafficLight::swapConstraints(
const std::string& tlsID,
const std::string& tripId,
const std::string& foeSignal,
const std::string& foeId) {
300#ifdef DEBUG_CONSTRAINT_DEADLOCK
301 std::cout <<
"swapConstraints tlsId=" << tlsID <<
" tripId=" << tripId <<
" foeSignal=" << foeSignal <<
" foeId=" << foeId <<
"\n";
308 throw TraCIException(
"'" + tlsID +
"' is not a rail signal");
311 throw TraCIException(
"'" + foeSignal +
"' is not a rail signal");
315 if (tripId == item.first) {
332 swapParameters(swapped);
335 return findConstraintsDeadLocks(foeId, tripId, foeSignal, tlsID);
337 throw TraCIException(
"Rail signal '" + tlsID +
"' does not have a constraint for tripId '" + tripId +
"' with foeSignal '" + foeSignal +
"' and foeId '" + foeId +
"'");
342std::vector<std::pair<std::string, std::string> >
343TrafficLight::getSwapParams(
int constraintType) {
344 std::vector<std::pair<std::string, std::string> > result({
347 {
"arrival",
"foeArrival"}});
350 std::vector<std::pair<std::string, std::string> > special({
351 {
"busStop",
"busStop2"},
352 {
"priorStop",
"priorStop2"},
353 {
"stopArrival",
"foeStopArrival"}});
354 result.insert(result.end(), special.begin(), special.end());
363 for (
auto keys : getSwapParams(c->
getType())) {
364 swapParameters(c, keys.first, keys.second);
385TrafficLight::swapParameters(TraCISignalConstraint& c) {
387 for (
auto keys : getSwapParams(c.type)) {
388 swapParameters(c, keys.first, keys.second);
393TrafficLight::swapParameters(TraCISignalConstraint& c,
const std::string& key1,
const std::string& key2) {
394 auto it1 = c.param.find(key1);
395 auto it2 = c.param.find(key2);
396 const std::string value1 = it1 != c.param.end() ? it1->second :
"";
397 const std::string value2 = it2 != c.param.end() ? it2->second :
"";
399 c.param[key2] = value1;
404 c.param[key1] = value2;
412TrafficLight::removeConstraints(
const std::string& tlsID,
const std::string& tripId,
const std::string& foeSignal,
const std::string& foeId) {
415 for (
const std::string& tlsCand : getIDList()) {
416 if (tlsID ==
"" || tlsCand == tlsID) {
421 if (tripId ==
"" || item.first == tripId) {
425 && (foeId ==
"" || pc->
myTripId == foeId)
439TrafficLight::updateConstraints(
const std::string& vehID, std::string tripId) {
446 tripId = tripId ==
"" ? curTripId : tripId;
449 std::map<const MSRailSignal*, std::set<std::string> > onRoute;
453 for (
auto it = routeIt; it < stop.edge; it++) {
456 if (it + 1 != route.end()) {
457 const MSEdge* next = *(it + 1);
459 if (link !=
nullptr && link->
getTLLogic() !=
nullptr) {
461 onRoute[s].insert(curTripId);
466 if (stop.pars.tripId !=
"") {
467 curTripId = stop.pars.tripId;
471 for (
auto it = routeIt; it < route.end(); it++) {
474 if (it + 1 != route.end()) {
475 const MSEdge* next = *(it + 1);
477 if (link !=
nullptr && link->
getTLLogic() !=
nullptr) {
479 onRoute[s].insert(curTripId);
492 std::vector<MSRailSignalConstraint*> onVeh;
493 std::vector<std::pair<std::string, MSRailSignalConstraint*> > byVeh;
495 for (
auto item : s->getConstraints()) {
499 if (item.first == tripId) {
500 if (onRoute[s].count(tripId) == 0) {
502 onVeh.push_back(cand);
504 }
else if (pc->
myTripId == tripId) {
507 byVeh.push_back(std::make_pair(item.first, cand));
514 s->removeConstraint(tripId, c);
516 for (
auto item : byVeh) {
517 s->removeConstraint(item.first, item.second);
523std::vector<TraCISignalConstraint>
524TrafficLight::findConstraintsDeadLocks(
const std::string& foeId,
const std::string& tripId,
const std::string& foeSignal,
const std::string& tlsID) {
525 std::vector<TraCISignalConstraint> result;
531 std::map<std::string, TraCISignalConstraint> constraintsOnTripId;
532 std::map<std::string, TraCISignalConstraint> constrainedByFoeId;
533 std::set<std::string> foeId2Cands1;
534 std::set<std::string> foeId2Cands2;
536 for (
auto item : s->getConstraints()) {
540 if (item.first == tripId) {
544 constraintsOnTripId[pc->
myTripId] = tsc;
546 for (std::string& futureFoe2Id : getFutureTripIds(pc->
myTripId)) {
547 foeId2Cands1.insert(futureFoe2Id);
549 constraintsOnTripId[futureFoe2Id] = tsc;
554 constrainedByFoeId[item.first] = tsc;
555 foeId2Cands2.insert(item.first);
556 for (std::string& futureTripId : getFutureTripIds(item.first)) {
557 foeId2Cands2.insert(futureTripId);
559 constrainedByFoeId[futureTripId] = tsc;
566#ifdef DEBUG_CONSTRAINT_DEADLOCK
567 std::cout <<
"findConstraintsDeadLocks foeId=" << foeId <<
" tripId=" << tripId <<
" foeSignal=" << foeSignal <<
" tlsID=" << tlsID <<
"\n";
568 std::cout <<
" foeId2Cands1=" <<
toString(foeId2Cands1) <<
"\n";
569 std::cout <<
" foeId2Cands2=" <<
toString(foeId2Cands2) <<
"\n";
571 if (foeId2Cands1.size() > 0) {
579 if (foe !=
nullptr) {
582 for (
const std::string& foeId2 : foeId2Cands1) {
585 if (foe2 !=
nullptr) {
587 const TraCISignalConstraint& c = constraintsOnTripId[foeId2];
588 bool foeAhead =
false;
590 const MSEdge* e = foe2Route[i];
599#ifdef DEBUG_CONSTRAINT_DEADLOCK
600 std::cout <<
"findConstraintsDeadLocks foeId=" << foeId <<
" tripId=" << tripId <<
" foeSignal=" << foeSignal <<
"\n";
604 <<
" " << constraintsOnTripId[foeId2].getString() <<
"\n";
615 TraCISignalConstraint nc;
618 nc.signalId = c.foeSignal;
619 nc.foeSignal = c.signalId;
626 result.push_back(nc);
628 std::vector<TraCISignalConstraint> result2 = swapConstraints(c.signalId, c.tripId, c.foeSignal, c.foeId);
629 result.insert(result.end(), result2.begin(), result2.end());
632 const std::vector<TraCISignalConstraint>& result4 = findConstraintsDeadLocks(foeId, tripId, foeSignal, tlsID);
633 result.insert(result.end(), result4.begin(), result4.end());
641 if (foeId2Cands2.size() > 0) {
648 std::set<const MSEdge*> egoToSignal;
652 const MSEdge* e = egoRoute[i];
653 egoToSignal.insert(e);
659 for (
const std::string& foeId2 : foeId2Cands2) {
663 if (foe2 !=
nullptr) {
664 if (egoToSignal.count(foe2->
getEdge()) != 0
666 const TraCISignalConstraint& c = constrainedByFoeId[foeId2];
667#ifdef DEBUG_CONSTRAINT_DEADLOCK
668 std::cout <<
"findConstraintsDeadLocks foeId=" << foeId <<
" tripId=" << tripId <<
" foeSignal=" << foeSignal <<
"\n";
670 <<
" " << c.getString() <<
"\n";
673 TraCISignalConstraint nc;
676 nc.signalId = c.foeSignal;
677 nc.foeSignal = c.signalId;
684 result.push_back(nc);
686 std::vector<TraCISignalConstraint> result2 = swapConstraints(c.signalId, c.tripId, c.foeSignal, c.foeId);
687 result.insert(result.end(), result2.begin(), result2.end());
690 const std::vector<TraCISignalConstraint>& result4 = findConstraintsDeadLocks(foeId, tripId, foeSignal, tlsID);
691 result.insert(result.end(), result4.begin(), result4.end());
696 }
else if (ego !=
nullptr) {
697 WRITE_WARNINGF(
TL(
"Cannot check for all deadlocks on swapConstraints because the route for vehicle '%' is not computed yet"), ego->
getID());
702 std::vector<std::string> foeIds2;
703 std::set_intersection(
704 foeId2Cands1.begin(), foeId2Cands1.end(),
705 foeId2Cands2.begin(), foeId2Cands2.end(),
706 std::back_inserter(foeIds2));
707#ifdef DEBUG_CONSTRAINT_DEADLOCK
708 std::cout <<
"findConstraintsDeadLocks foeId=" << foeId <<
" tripId=" << tripId <<
" foeSignal=" << foeSignal <<
"\n";
709 for (
const std::string& foeId2 : foeIds2) {
710 std::cout <<
" deadlockId=" << foeId2 <<
" " << constraintsOnTripId[foeId2].getString() <<
" " << constrainedByFoeId[foeId2].getString() <<
"\n";
713 if (foeIds2.size() > 0) {
714 TraCISignalConstraint c = constrainedByFoeId[foeIds2.front()];
717 c = constraintsOnTripId[foeIds2.front()];
719 TraCISignalConstraint nc;
722 nc.signalId = c.foeSignal;
723 nc.foeSignal = c.signalId;
730 result.push_back(nc);
732 const std::vector<TraCISignalConstraint>& result2 = swapConstraints(c.signalId, c.tripId, c.foeSignal, c.foeId);
733 result.insert(result.end(), result2.begin(), result2.end());
734 if (foeIds2.size() > 1) {
736 const std::vector<TraCISignalConstraint>& result3 = findConstraintsDeadLocks(foeId, tripId, foeSignal, tlsID);
737 result.insert(result.end(), result3.begin(), result3.end());
745TrafficLight::getVehicleByTripId(
const std::string tripOrVehID) {
757std::vector<std::string>
758TrafficLight::getFutureTripIds(
const std::string vehID) {
759 std::vector<std::string> result;
764 result.push_back(tripId);
767 if (stop.pars.tripId !=
"") {
768 result.push_back(stop.pars.tripId);
777TrafficLight::getParameter(
const std::string& tlsID,
const std::string& paramName) {
780 throw TraCIException(
"'" + tlsID +
"' is not a NEMA controller");
790TrafficLight::setRedYellowGreenState(
const std::string& tlsID,
const std::string& state) {
796TrafficLight::setPhase(
const std::string& tlsID,
const int index) {
798 if (index < 0 || active->getPhaseNumber() <= index) {
799 throw TraCIException(
"The phase index " +
toString(index) +
" is not in the allowed range [0,"
808TrafficLight::setPhaseName(
const std::string& tlsID,
const std::string& name) {
815TrafficLight::setProgram(
const std::string& tlsID,
const std::string& programID) {
819 throw TraCIException(e.what());
825TrafficLight::setPhaseDuration(
const std::string& tlsID,
const double phaseDuration) {
833TrafficLight::setProgramLogic(
const std::string& tlsID,
const TraCILogic& logic) {
836 if (logic.currentPhaseIndex >= (
int)logic.phases.size()) {
837 throw TraCIException(
"set program: parameter index must be less than parameter phase number.");
839 std::vector<MSPhaseDefinition*> phases;
840 for (
const std::shared_ptr<libsumo::TraCIPhase>& phase : logic.phases) {
845 phases.push_back(sumoPhase);
847 if (vars.
getLogic(logic.programID) ==
nullptr) {
849 int step = logic.currentPhaseIndex;
850 const std::string basePath =
"";
856 tlsID, logic.programID, 0,
857 phases, step, nextSwitch,
858 logic.subParameter, basePath);
862 tlsID, logic.programID, 0,
863 phases, step, nextSwitch,
864 logic.subParameter, basePath);
868 tlsID, logic.programID, 0,
869 phases, step, nextSwitch,
870 logic.subParameter, basePath);
875 phases, step, nextSwitch,
879 throw TraCIException(
"Unsupported traffic light type '" +
toString(logic.type) +
"'");
882 if (!vars.
addLogic(logic.programID, tlLogic,
true,
true)) {
883 throw TraCIException(
"Could not add traffic light logic '" + logic.programID +
"'");
886 throw TraCIException(e.what());
894 tlLogic->
setPhases(phases, logic.currentPhaseIndex);
902TrafficLight::setParameter(
const std::string& tlsID,
const std::string& paramName,
const std::string& value) {
905 throw TraCIException(
"'" + tlsID +
"' is not a NEMA controller");
913TrafficLight::setNemaSplits(
const std::string& tlsID,
const std::vector<double>& splits) {
914 setParameter(tlsID,
"NEMA.splits",
toString(splits));
918TrafficLight::setNemaMaxGreens(
const std::string& tlsID,
const std::vector<double>& maxGreens) {
919 setParameter(tlsID,
"NEMA.maxGreens",
toString(maxGreens));
923TrafficLight::setNemaCycleLength(
const std::string& tlsID,
double cycleLength) {
924 setParameter(tlsID,
"NEMA.cycleLength",
toString(cycleLength));
928TrafficLight::setNemaOffset(
const std::string& tlsID,
double offset) {
929 setParameter(tlsID,
"NEMA.offset",
toString(offset));
935 TraCISignalConstraint c;
955std::shared_ptr<VariableWrapper>
956TrafficLight::makeWrapper() {
957 return std::make_shared<Helper::SubscriptionWrapper>(handleVariable, mySubscriptionResults, myContextSubscriptionResults);
962TrafficLight::handleVariable(
const std::string& objID,
const int variable, VariableWrapper* wrapper,
tcpip::Storage* paramData) {
965 return wrapper->wrapStringList(objID, variable, getIDList());
967 return wrapper->wrapInt(objID, variable, getIDCount());
969 return wrapper->wrapString(objID, variable, getRedYellowGreenState(objID));
971 return wrapper->wrapStringList(objID, variable, getControlledLanes(objID));
973 return wrapper->wrapInt(objID, variable, getPhase(objID));
975 return wrapper->wrapString(objID, variable, getPhaseName(objID));
977 return wrapper->wrapString(objID, variable, getProgram(objID));
979 return wrapper->wrapDouble(objID, variable, getPhaseDuration(objID));
981 return wrapper->wrapDouble(objID, variable, getNextSwitch(objID));
983 return wrapper->wrapStringList(objID, variable, getControlledJunctions(objID));
986 return wrapper->wrapString(objID, variable, getParameter(objID, paramData->
readString()));
989 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 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 std::list< MSStop > & getStops() const
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.
MSEdge & getEdge() const
Returns the lane's edge.
const std::vector< MSLink * > & getLinkCont() const
returns the container with all links !!!
MSLane * getLane() const
Returns the connected lane.
MSLane * getViaLane() const
Returns the following inner 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.
SUMOTime getCurrentTimeStep() const
Returns the current simulation step.
virtual void createTLWrapper(MSTrafficLightLogic *)
creates a wrapper for the given logic (see GUINet)
MSVehicleControl & getVehicleControl()
Returns the vehicle control.
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.
SUMOTime maxDuration
The maximum duration of the phase.
SUMOTime minDuration
The minimum duration of the phase.
const std::string & getName() const
const std::string & getState() const
Returns the state within this phase.
SUMOTime duration
The duration of the phase.
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
void setActive(bool active)
const int myLimit
the number of passed vehicles within which tripId must have occured
A base class for constraints.
ConstraintType getType() const
ConstraintType getSwappedType() const
static MSRailSignalControl & getInstance()
const std::vector< MSRailSignal * > & getSignals() const
void addConstraint(const std::string &tripId, MSRailSignalConstraint *constraint)
register contraint for signal switching
const std::map< std::string, std::vector< MSRailSignalConstraint * > > & getConstraints() const
bool removeConstraint(const std::string &tripId, MSRailSignalConstraint *constraint)
remove contraint for signal switching
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 LinkVectorVector & getLinks() const
Returns the list of lists of all affected links.
std::vector< LaneVector > LaneVectorVector
Definition of a list that holds lists of lanes that do have the same attribute.
virtual const MSPhaseDefinition & getCurrentPhaseDef() const =0
Returns the definition of the current phase.
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 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.
virtual VehicleVector getBlockingVehicles(int linkIndex)
return vehicles that block the intersection/rail signal for vehicles that wish to pass the given link...
virtual const MSPhaseDefinition & getPhase(int givenstep) const =0
Returns the definition of the phase from the given position within the plan.
virtual VehicleVector getRivalVehicles(int linkIndex)
return vehicles that approach the intersection/rail signal and are in conflict with vehicles that wis...
const std::string & getProgramID() const
Returns this tl-logic's id.
TrafficLightType getLogicType() const
Returns the type of the logic.
int getNumLinks() const
return the number of controlled link indices
virtual const Phases & getPhases() const =0
Returns the phases of this tls program.
const LaneVectorVector & getLaneVectors() const
Returns the list of lists of all lanes controlled by this tls.
bool setTrafficLightSignals(SUMOTime t) const
Applies the current signal states to controlled links.
const LinkVector & getLinksAt(int i) const
Returns the list of links that are controlled by the signals at the given position.
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 void init(NLDetectorBuilder &nb)
Initialises the tls with information about incoming lanes.
The class responsible for building and deletion of vehicles.
SUMOVehicle * getVehicle(const std::string &id) const
Returns the vehicle with the given id.
std::map< std::string, SUMOVehicle * >::const_iterator constVehIt
Definition of the internal vehicles map iterator.
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 bool hasDeparted() const =0
Returns whether this vehicle has departed.
virtual const MSRoute & getRoute() const =0
Returns the current route.
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_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