43 #define TRACI_PROGRAM "online"
52 myCurrentProgram(nullptr),
53 myDefaultProgram(nullptr) {
58 std::map<std::string, MSTrafficLightLogic*>::const_iterator j;
59 for (
const auto& var : myVariants) {
70 bool hadErrors =
false;
71 for (std::map<std::string, MSTrafficLightLogic*>::const_iterator j = myVariants.begin(); j != myVariants.end(); ++j) {
73 int linkNo = (int)(*j).second->getLinks().size();
74 bool hadProgramErrors =
false;
75 for (MSTrafficLightLogic::Phases::const_iterator i = phases.begin(); i != phases.end(); ++i) {
76 if ((
int)(*i)->getState().length() < linkNo) {
77 hadProgramErrors =
true;
80 if (hadProgramErrors) {
81 WRITE_ERROR(
"Mismatching phase size in tls '" + (*j).second->getID() +
"', program '" + (*j).first +
"'.");
91 myOriginalLinkStates = myCurrentProgram->collectLinkStates();
97 for (
const auto& item : myVariants) {
98 item.second->saveState(out);
106 if (myVariants.find(programID) != myVariants.end()) {
112 if (myCurrentProgram ==
nullptr) {
113 throw ProcessError(
"No initial signal plan loaded for tls '" + logic->
getID() +
"'.");
117 throw ProcessError(
"Mismatching phase size in tls '" + logic->
getID() +
"', program '" + programID +
"'.");
121 if (myVariants.size() == 0 || isNewDefault) {
122 if (myCurrentProgram !=
nullptr) {
123 myCurrentProgram->deactivateProgram();
125 myCurrentProgram = logic;
127 if (myVariants.size() == 0) {
128 myDefaultProgram = logic;
132 myVariants[programID] = logic;
133 if (myVariants.size() == 1 || isNewDefault) {
135 executeOnSwitchActions();
143 if (myVariants.find(programID) == myVariants.end()) {
146 return myVariants.find(programID)->second;
152 const std::string& programID) {
153 if (myVariants.find(programID) == myVariants.end()) {
154 if (programID ==
"off") {
158 throw ProcessError(
"Could not build an off-state for tls '" + myCurrentProgram->getID() +
"'.");
162 throw ProcessError(
"Can not switch tls '" + myCurrentProgram->getID() +
"' to program '" + programID +
"';\n The program is not known.");
165 return getLogic(programID);
171 const std::string& state) {
174 if (logic ==
nullptr) {
176 std::vector<MSPhaseDefinition*> phases;
177 phases.push_back(phase);
180 std::map<std::string, std::string>());
193 mySwitchActions.push_back(c);
197 std::vector<MSTrafficLightLogic*>
199 std::vector<MSTrafficLightLogic*> ret;
200 std::map<std::string, MSTrafficLightLogic*>::const_iterator i;
201 for (i = myVariants.begin(); i != myVariants.end(); ++i) {
202 ret.push_back((*i).second);
210 return tl == myCurrentProgram;
216 return myCurrentProgram;
221 return myDefaultProgram;
228 myCurrentProgram->deactivateProgram();
229 myCurrentProgram = getLogicInstantiatingOff(tlc, programID);
230 myCurrentProgram->activateProgram();
232 executeOnSwitchActions();
238 for (std::vector<OnSwitchAction*>::const_iterator i = mySwitchActions.begin(); i != mySwitchActions.end(); ++i) {
246 for (std::map<std::string, MSTrafficLightLogic*>::iterator i = myVariants.begin(); i != myVariants.end(); ++i) {
247 (*i).second->addLink(link, lane, pos);
253 for (std::map<std::string, MSTrafficLightLogic*>::iterator i = myVariants.begin(); i != myVariants.end(); ++i) {
254 (*i).second->ignoreLinkIndex(pos);
268 if (isPosAtGSP(step, *myFrom)) {
270 if (mySwitchSynchron) {
273 switchToPos(step, *myTo, getGSPTime(*myTo));
293 return gspTime == programTime;
301 assert(toTime >= startOfPhase);
302 return toTime - startOfPhase;
309 SUMOTime diff = getDiffToStartOfPhase(logic, toTime);
350 const SUMOTime gspTo = getGSPTime(*myTo) % myTo->getDefaultCycleTime();
351 const SUMOTime currentPosTo = myTo->getOffsetFromIndex(myTo->getCurrentPhaseIndex()) + myTo->getSpentDuration(step);
352 SUMOTime deltaToStretch = gspTo - currentPosTo;
353 if (deltaToStretch < 0) {
354 deltaToStretch += myTo->getDefaultCycleTime();
356 const int stepTo = myTo->getIndexFromOffset(gspTo);
357 const SUMOTime newdur = myTo->getPhase(stepTo).duration - getDiffToStartOfPhase(*myTo, gspTo) + deltaToStretch;
358 myTo->changeStepAndDuration(myControl, step, stepTo, newdur);
388 SUMOTime cycleTime = myTo->getDefaultCycleTime();
390 SUMOTime posAfterSyn = myTo->getPhaseIndexAtTime(step);
393 if (posAfterSyn < gspTo) {
394 deltaToCut = posAfterSyn + cycleTime - gspTo;
396 deltaToCut = posAfterSyn - gspTo;
401 assert(def.end >= def.begin);
402 deltaPossible += def.end - def.begin;
405 deltaPossible = stretchUmlaufAnz * deltaPossible;
406 if ((deltaPossible > deltaToCut) && (deltaToCut < (cycleTime / 2))) {
407 cutLogic(step, gspTo, deltaToCut);
409 SUMOTime deltaToStretch = (cycleTime - deltaToCut) % cycleTime;
410 stretchLogic(step, gspTo, deltaToStretch);
417 int actStep = myTo->getIndexFromOffset(startPos);
421 int stepOfBegin = myTo->getIndexFromOffset(def.begin);
422 if (stepOfBegin == actStep) {
423 if (def.begin < startPos) {
424 toCut = def.end - startPos;
426 toCut = def.end - def.begin;
428 toCut =
MIN2(allCutTime, toCut);
429 allCutTime = allCutTime - toCut;
432 SUMOTime remainingDur = myTo->getPhase(actStep).duration - getDiffToStartOfPhase(*myTo, startPos);
433 SUMOTime newDur = remainingDur - toCut;
434 myTo->changeStepAndDuration(myControl, step, actStep, newDur);
437 int currStep = (actStep + 1) % (
int)myTo->getPhases().size();
438 while (allCutTime > 0) {
439 for (
int i = currStep; i < (int) myTo->getPhases().size(); i++) {
440 SUMOTime beginOfPhase = myTo->getOffsetFromIndex(i);
441 SUMOTime durOfPhase = myTo->getPhase(i).duration;
442 SUMOTime endOfPhase = beginOfPhase + durOfPhase;
444 if ((beginOfPhase <= def.begin) && (endOfPhase >= def.end)) {
445 SUMOTime maxCutOfPhase =
MIN2(def.end - def.begin, allCutTime);
446 allCutTime = allCutTime - maxCutOfPhase;
447 durOfPhase = durOfPhase - maxCutOfPhase;
450 myTo->addOverridingDuration(durOfPhase);
458 int currStep = myTo->getIndexFromOffset(startPos);
459 SUMOTime durOfPhase = myTo->getPhase(currStep).duration;
460 SUMOTime remainingStretchTime = allStretchTime;
467 facSum *= stretchUmlaufAnz;
470 SUMOTime diffToStart = getDiffToStartOfPhase(*myTo, startPos);
472 SUMOTime endOfPhase = (startPos + durOfPhase - diffToStart);
473 if (def.end <= endOfPhase && def.end >= startPos) {
474 double actualfac = def.fac / facSum;
475 facSum = facSum - def.fac;
477 remainingStretchTime = allStretchTime - StretchTimeOfPhase;
481 WRITE_WARNING(
"The computed factor sum in WAUT '" + myWAUT.id +
"' at time '" +
toString(
STEPS2TIME(step)) +
"' equals zero;\n assuming an error in WAUT definition.");
484 durOfPhase = durOfPhase - diffToStart + StretchTimeOfPhase;
485 myTo->changeStepAndDuration(myControl, step, currStep, durOfPhase);
487 currStep = (currStep + 1) % (
int)myTo->getPhases().size();
489 while (remainingStretchTime > 0) {
490 for (
int i = currStep; i < (int)myTo->getPhases().size() && remainingStretchTime > 0; i++) {
491 durOfPhase = myTo->getPhase(i).duration;
492 SUMOTime beginOfPhase = myTo->getOffsetFromIndex(i);
493 SUMOTime endOfPhase = beginOfPhase + durOfPhase;
495 if ((beginOfPhase <= def.end) && (endOfPhase >= def.end)) {
496 double actualfac = def.fac / facSum;
499 durOfPhase += StretchTimeOfPhase;
500 remainingStretchTime -= StretchTimeOfPhase;
503 myTo->addOverridingDuration(durOfPhase);
519 for (std::map<std::string, TLSLogicVariants*>::const_iterator i =
myLogics.begin(); i !=
myLogics.end(); ++i) {
523 for (std::map<std::string, WAUT*>::const_iterator i =
myWAUTs.begin(); i !=
myWAUTs.end(); ++i) {
531 for (std::map<std::string, TLSLogicVariants*>::const_iterator i =
myLogics.begin(); i !=
myLogics.end(); ++i) {
532 (*i).second->getActive()->setTrafficLightSignals(t);
537 std::vector<MSTrafficLightLogic*>
539 std::vector<MSTrafficLightLogic*> ret;
540 std::map<std::string, TLSLogicVariants*>::const_iterator i;
542 std::vector<MSTrafficLightLogic*> s = (*i).second->getAllLogics();
543 copy(s.begin(), s.end(), back_inserter(ret));
550 std::map<std::string, TLSLogicVariants*>::const_iterator i =
myLogics.find(
id);
560 std::map<std::string, TLSLogicVariants*>::const_iterator i =
myLogics.find(
id);
564 return (*i).second->getLogic(programID);
568 std::vector<std::string>
570 std::vector<std::string> ret;
571 for (std::map<std::string, TLSLogicVariants*>::const_iterator i =
myLogics.begin(); i !=
myLogics.end(); ++i) {
572 ret.push_back((*i).first);
584 std::map<std::string, TLSLogicVariants*>::iterator i =
myLogics.find(
id);
592 std::map<std::string, TLSLogicVariants*>::const_iterator i =
myLogics.find(
id);
602 bool hadErrors =
false;
603 for (std::map<std::string, TLSLogicVariants*>::iterator i =
myLogics.begin(); i !=
myLogics.end(); ++i) {
604 hadErrors |= !(*i).second->checkOriginalTLS();
605 (*i).second->saveInitialStates();
614 std::map<std::string, TLSLogicVariants*>::const_iterator i =
myLogics.find(tl->
getID());
618 return (*i).second->isActive(tl);
624 std::map<std::string, TLSLogicVariants*>::const_iterator i =
myLogics.find(
id);
628 return (*i).second->getActive();
635 std::map<std::string, TLSLogicVariants*>::iterator i =
myLogics.find(
id);
638 throw ProcessError(
"Could not switch tls '" +
id +
"' to program '" + programID +
"': No such tls exists.");
640 (*i).second->switchTo(*
this, programID);
646 const std::string& startProg,
SUMOTime period) {
663 SUMOTime when,
const std::string& to) {
677 myWAUTs[wautid]->switches.push_back(s);
683 const std::string& tls,
684 const std::string& proc,
694 throw InvalidArgument(
"TLS '" + tls +
"' to switch in WAUT '" + wautid +
"' was not yet defined.");
700 myWAUTs[wautid]->junctions.push_back(j);
702 std::string initProg =
myWAUTs[wautid]->startProg;
703 std::vector<WAUTSwitch>::const_iterator first =
myWAUTs[wautid]->switches.end();
705 for (std::vector<WAUTSwitch>::const_iterator i =
myWAUTs[wautid]->switches.begin(); i !=
myWAUTs[wautid]->switches.end(); ++i) {
707 minExecTime = (*i).when;
710 if (first !=
myWAUTs[wautid]->switches.begin()) {
711 initProg = (*(first - 1)).to;
727 std::string initProg =
myWAUTs[wautid]->startProg;
729 std::vector<WAUTSwitch>::const_iterator first = w->
switches.end();
731 for (std::vector<WAUTSwitch>::const_iterator i = w->
switches.begin(); i != w->
switches.end(); ++i) {
733 minExecTime = (*i).when;
739 std::vector<WAUTSwitch>::const_iterator mbegin = w->
switches.begin();
755 const std::string& wautid = cmd.
getWAUTID();
759 for (std::vector<WAUTJunction>::iterator i =
myWAUTs[wautid]->junctions.begin(); i !=
myWAUTs[wautid]->junctions.end(); ++i) {
765 if ((*i).procedure ==
"GSP") {
767 }
else if ((*i).procedure ==
"Stretch") {
782 if (index == (
int)waut->
switches.size()) {
814 std::pair<SUMOTime, MSPhaseDefinition>
823 for (
const auto& logic :
myLogics) {
832 for (
const auto& logic :
myLogics) {
833 logic.second->saveState(out);
#define WRITE_WARNING(msg)
SUMOTime string2time(const std::string &r)
convert string to SUMOTime
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
virtual void addEvent(Command *operation, SUMOTime execTimeStep=-1)
Adds an Event.
Representation of a lane in the micro simulation.
static MSNet * getInstance()
Returns the pointer to the unique instance of MSNet (singleton).
SUMOTime getCurrentTimeStep() const
Returns the current simulation step.
MSEventControl * getBeginOfTimestepEvents()
Returns the event control for events executed at the begin of a time step.
virtual void createTLWrapper(MSTrafficLightLogic *)
creates a wrapper for the given logic (see GUINet)
A traffic lights logic which represents a tls in an off-mode.
The definition of a single phase of a tls logic.
const std::string & getState() const
Returns the state within this phase.
SUMOTime duration
The duration of the phase.
static void saveState(OutputDevice &out)
Saves the current constraint states into the given stream.
static void clearState()
Clear all constraint states before quick-loading state.
A fixed traffic light logic.
Base class for things to execute if a tls switches to a new phase.
This event-class is used to initialise a WAUT switch at a certain time.
const std::string & getWAUTID() const
Returns the WAUT-id.
int & getIndex()
Returns a reference to the index.
Storage for all programs of a single tls.
void addLink(MSLink *link, MSLane *lane, int pos)
void switchTo(MSTLLogicControl &tlc, const std::string &programID)
void addSwitchCommand(OnSwitchAction *c)
void ignoreLinkIndex(int pos)
void setStateInstantiatingOnline(MSTLLogicControl &tlc, const std::string &state)
bool checkOriginalTLS() const
Verifies traffic lights loaded from the network.
std::vector< MSTrafficLightLogic * > getAllLogics() const
void saveState(OutputDevice &out)
MSTrafficLightLogic * getLogic(const std::string &programID) const
TLSLogicVariants()
Constructor.
void executeOnSwitchActions() const
bool addLogic(const std::string &programID, MSTrafficLightLogic *logic, bool netWasLoaded, bool isNewDefault=true)
Adds a logic (program)
~TLSLogicVariants()
Destructor.
MSTrafficLightLogic * getActive() const
MSTrafficLightLogic * getDefault() const
return the default program (that last used program except TRACI_PROGRAM)
MSTrafficLightLogic * getLogicInstantiatingOff(MSTLLogicControl &tlc, const std::string &programID)
bool isActive(const MSTrafficLightLogic *tl) const
This class switches using the GSP algorithm.
~WAUTSwitchProcedure_GSP()
Destructor.
WAUTSwitchProcedure_GSP(MSTLLogicControl &control, WAUT &waut, MSTrafficLightLogic *from, MSTrafficLightLogic *to, bool synchron)
Constructor.
void adaptLogic(SUMOTime step)
Stretches the destination program's phase to which the tls was switched.
This class simply switches to the next program.
bool trySwitch(SUMOTime step)
Determines whether a switch is possible.
~WAUTSwitchProcedure_JustSwitch()
Destructor.
WAUTSwitchProcedure_JustSwitch(MSTLLogicControl &control, WAUT &waut, MSTrafficLightLogic *from, MSTrafficLightLogic *to, bool synchron)
Constructor.
This class switches using the Stretch algorithm.
~WAUTSwitchProcedure_Stretch()
Destructor.
void adaptLogic(SUMOTime step)
Determines the destination program's changes and applies them.
std::vector< StretchRange > myStretchRanges
the given Stretch-areas for the "to" program, this is 0-based indexed, while the input is 1-based
WAUTSwitchProcedure_Stretch(MSTLLogicControl &control, WAUT &waut, MSTrafficLightLogic *from, MSTrafficLightLogic *to, bool synchron)
Constructor.
void cutLogic(SUMOTime step, SUMOTime startPos, SUMOTime allCutTime)
Cuts the logic to synchronize.
void stretchLogic(SUMOTime step, SUMOTime startPos, SUMOTime allStretchTime)
Stretches the logic to synchronize.
This is the abstract base class for switching from one tls program to another.
virtual bool trySwitch(SUMOTime step)
Determines whether a switch is possible.
MSTrafficLightLogic * myTo
The program to switch the tls to.
bool isPosAtGSP(SUMOTime currentTime, const MSTrafficLightLogic &logic)
Checks, whether the position of a signal programm is at the GSP ("Good Switching Point")
SUMOTime getGSPTime(const MSTrafficLightLogic &logic) const
Returns the GSP-value.
SUMOTime getDiffToStartOfPhase(MSTrafficLightLogic &logic, SUMOTime toTime)
Returns the difference between a given time and the start of the phase.
void switchToPos(SUMOTime simStep, MSTrafficLightLogic &logic, SUMOTime toTime)
switches the given logic directly to the given position
A class that stores and controls tls and switching of their programs.
void addWAUTJunction(const std::string &wautid, const std::string &tls, const std::string &proc, bool synchron)
Adds a tls to the list of tls to be switched by the named WAUT.
std::vector< MSTrafficLightLogic * > getAllLogics() const
Returns a vector which contains all logics.
std::vector< WAUTSwitchProcess > myCurrentlySwitched
A list of currently running switching procedures.
std::pair< SUMOTime, MSPhaseDefinition > getPhaseDef(const std::string &tlid) const
return the complete phase definition for a named traffic lights logic
std::map< std::string, TLSLogicVariants * > myLogics
A map from ids to the corresponding variants.
void addWAUT(SUMOTime refTime, const std::string &id, const std::string &startProg, SUMOTime period)
Adds a WAUT definition.
std::vector< std::string > getAllTLIds() const
void switchTo(const std::string &id, const std::string &programID)
Switches the named (id) tls to the named (programID) program.
MSTrafficLightLogic * getActive(const std::string &id) const
Returns the active program of a named tls.
bool closeNetworkReading()
Lets MSTLLogicControl know that the network has been loaded.
void setTrafficLightSignals(SUMOTime t) const
Lets all running (current) tls programs apply their current signal states to links they control.
bool knows(const std::string &id) const
Returns the information whether the named tls is stored.
void saveState(OutputDevice &out)
Saves the current tls states into the given stream.
void clearState()
Clear all tls states before quick-loading state.
bool myNetWasLoaded
Information whether the net was completely loaded.
void switchOffAll()
switch all logic variants to 'off'
void addWAUTSwitch(const std::string &wautid, SUMOTime when, const std::string &to)
Adds a WAUT switch step to a previously built WAUT.
TLSLogicVariants & get(const std::string &id) const
Returns the variants of a named tls.
MSTLLogicControl()
Constructor.
SUMOTime initWautSwitch(SwitchInitCommand &cmd)
Initialises switching a WAUT.
~MSTLLogicControl()
Destructor.
void check2Switch(SUMOTime step)
Checks whether any WAUT is trying to switch a tls into another program.
std::map< std::string, WAUT * > myWAUTs
A map of ids to corresponding WAUTs.
bool isActive(const MSTrafficLightLogic *tl) const
Returns whether the given tls program is the currently active for his tls.
bool add(const std::string &id, const std::string &programID, MSTrafficLightLogic *logic, bool newDefault=true)
Adds a tls program to the container.
void closeWAUT(const std::string &wautid)
Closes loading of a WAUT.
The parent class for traffic light logics.
virtual void adaptLinkInformationFrom(const MSTrafficLightLogic &logic)
Applies information about controlled links and lanes from the given logic.
virtual const MSPhaseDefinition & getCurrentPhaseDef() const =0
Returns the definition of the current phase.
virtual int getCurrentPhaseIndex() const =0
Returns the current index within the program.
virtual const MSPhaseDefinition & getPhase(int givenstep) const =0
Returns the definition of the phase from the given position within the plan.
virtual SUMOTime getOffsetFromIndex(int index) const =0
Returns the position (start of a phase during a cycle) from of a given step.
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 int getIndexFromOffset(SUMOTime offset) const =0
Returns the step (the phasenumber) of a given position of the cycle.
SUMOTime getDefaultCycleTime() const
Returns the cycle time (in ms)
virtual void activateProgram()
called when switching programs
SUMOTime getSpentDuration(SUMOTime simStep=-1) const
Returns the duration spent in the current phase.
bool setTrafficLightSignals(SUMOTime t) const
Applies the current signal states to controlled links.
std::vector< MSPhaseDefinition * > Phases
Definition of a list of phases, being the junction logic.
const std::string & getProgramID() const
Returns this tl-logic's id.
const std::string & getID() const
Returns the id.
Static storage of an output device and its base (abstract) implementation.
virtual const std::string getParameter(const std::string &key, const std::string defaultValue="") const
Returns the value for a given key.
bool knowsParameter(const std::string &key) const
Returns whether the parameter is known.
static double toDouble(const std::string &sData)
converts a string into the double value described by it by calling the char-type converter
std::string startProg
The name of the start program.
std::vector< WAUTSwitch > switches
The list of switches to be done by the WAUT.
SUMOTime period
The period with which to repeat switches.
std::string id
The id of the WAUT.
SUMOTime refTime
The reference time (offset to the switch times)
Storage for a junction assigned to a WAUT.
std::string procedure
The procedure to switch the junction with.
bool synchron
Information whether this junction shall be switched synchron.
std::string junction
The junction name.
Storage for a WAUTs switch point.
SUMOTime when
The time the WAUT shall switch the TLS.
std::string to
The program name the WAUT shall switch the TLS to.
A definition of a stretch - Bereich.
double fac
The weight factor of a stretch/cut area.
SUMOTime end
The end of a stretch/cut area.
SUMOTime begin
The begin of a stretch/cut area.
An initialised switch process.
MSTrafficLightLogic * to
The program to switch the tls to.
std::string junction
The id of the junction to switch.
MSTrafficLightLogic * from
The current program of the tls.
WAUTSwitchProcedure * proc
The used procedure.