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_ERRORF(
TL(
"Mismatching phase size in tls '%', program '%'."), (*j).second->getID(), (*j).first);
91 myOriginalLinkStates = myCurrentProgram->collectLinkStates();
97 for (
const auto& item : myVariants) {
98 item.second->saveState(out);
106 if (myVariants.find(programID) != myVariants.end()) {
113 if (myCurrentProgram ==
nullptr) {
114 const std::string
id = logic->
getID();
116 throw ProcessError(
TLF(
"No initial signal plan loaded for tls '%'.",
id));
120 const std::string
id = logic->
getID();
122 throw ProcessError(
"Mismatching phase size in tls '" +
id +
"', program '" + programID +
"'.");
126 if (myVariants.size() == 0 || isNewDefault) {
127 if (myCurrentProgram !=
nullptr) {
128 myCurrentProgram->deactivateProgram();
130 myCurrentProgram = logic;
132 if (myVariants.size() == 0) {
133 myDefaultProgram = logic;
137 myVariants[programID] = logic;
138 if (myVariants.size() == 1 || isNewDefault) {
140 executeOnSwitchActions();
148 if (myVariants.find(programID) == myVariants.end()) {
151 return myVariants.find(programID)->second;
157 if (myVariants.find(programID) == myVariants.end()) {
158 if (programID ==
"off") {
161 if (!addLogic(
"off", tlLogic,
true,
true)) {
163 throw ProcessError(
TLF(
"Could not build an off-state for tls '%'.", myCurrentProgram->getID()));
167 throw ProcessError(
"Can not switch tls '" + myCurrentProgram->getID() +
"' to program '" + programID +
"';\n The program is not known.");
170 return getLogic(programID);
176 const std::string& state) {
179 if (logic ==
nullptr) {
181 std::vector<MSPhaseDefinition*> phases;
182 phases.push_back(phase);
199 mySwitchActions.push_back(c);
203 std::vector<MSTrafficLightLogic*>
205 std::vector<MSTrafficLightLogic*> ret;
206 std::map<std::string, MSTrafficLightLogic*>::const_iterator i;
207 for (i = myVariants.begin(); i != myVariants.end(); ++i) {
208 ret.push_back((*i).second);
216 return tl == myCurrentProgram;
222 return myCurrentProgram;
227 return myDefaultProgram;
234 myCurrentProgram->deactivateProgram();
235 myCurrentProgram = getLogicInstantiatingOff(tlc, programID);
236 myCurrentProgram->activateProgram();
238 executeOnSwitchActions();
244 for (std::vector<OnSwitchAction*>::const_iterator i = mySwitchActions.begin(); i != mySwitchActions.end(); ++i) {
252 for (std::map<std::string, MSTrafficLightLogic*>::iterator i = myVariants.begin(); i != myVariants.end(); ++i) {
253 (*i).second->addLink(link, lane, pos);
259 for (std::map<std::string, MSTrafficLightLogic*>::iterator i = myVariants.begin(); i != myVariants.end(); ++i) {
260 (*i).second->ignoreLinkIndex(pos);
274 if (isPosAtGSP(step, *myFrom)) {
276 if (mySwitchSynchron) {
279 switchToPos(step, *myTo, getGSPTime(*myTo));
299 return gspTime == programTime;
307 assert(toTime >= startOfPhase);
308 return toTime - startOfPhase;
315 SUMOTime diff = getDiffToStartOfPhase(logic, toTime);
356 const SUMOTime gspTo = getGSPTime(*myTo) % myTo->getDefaultCycleTime();
357 const SUMOTime currentPosTo = myTo->getOffsetFromIndex(myTo->getCurrentPhaseIndex()) + myTo->getSpentDuration(step);
358 SUMOTime deltaToStretch = gspTo - currentPosTo;
359 if (deltaToStretch < 0) {
360 deltaToStretch += myTo->getDefaultCycleTime();
362 const int stepTo = myTo->getIndexFromOffset(gspTo);
363 const SUMOTime newdur = myTo->getPhase(stepTo).duration - getDiffToStartOfPhase(*myTo, gspTo) + deltaToStretch;
364 myTo->changeStepAndDuration(myControl, step, stepTo, newdur);
394 SUMOTime cycleTime = myTo->getDefaultCycleTime();
396 SUMOTime posAfterSyn = myTo->getPhaseIndexAtTime(step);
399 if (posAfterSyn < gspTo) {
400 deltaToCut = posAfterSyn + cycleTime - gspTo;
402 deltaToCut = posAfterSyn - gspTo;
407 assert(def.end >= def.begin);
408 deltaPossible += def.end - def.begin;
411 deltaPossible = stretchUmlaufAnz * deltaPossible;
412 if ((deltaPossible > deltaToCut) && (deltaToCut < (cycleTime / 2))) {
413 cutLogic(step, gspTo, deltaToCut);
415 SUMOTime deltaToStretch = (cycleTime - deltaToCut) % cycleTime;
416 stretchLogic(step, gspTo, deltaToStretch);
423 int actStep = myTo->getIndexFromOffset(startPos);
427 int stepOfBegin = myTo->getIndexFromOffset(def.begin);
428 if (stepOfBegin == actStep) {
429 if (def.begin < startPos) {
430 toCut = def.end - startPos;
432 toCut = def.end - def.begin;
434 toCut =
MIN2(allCutTime, toCut);
435 allCutTime = allCutTime - toCut;
438 SUMOTime remainingDur = myTo->getPhase(actStep).duration - getDiffToStartOfPhase(*myTo, startPos);
439 SUMOTime newDur = remainingDur - toCut;
440 myTo->changeStepAndDuration(myControl, step, actStep, newDur);
443 int currStep = (actStep + 1) % (
int)myTo->getPhases().size();
444 while (allCutTime > 0) {
445 for (
int i = currStep; i < (int) myTo->getPhases().size(); i++) {
446 SUMOTime beginOfPhase = myTo->getOffsetFromIndex(i);
447 SUMOTime durOfPhase = myTo->getPhase(i).duration;
448 SUMOTime endOfPhase = beginOfPhase + durOfPhase;
450 if ((beginOfPhase <= def.begin) && (endOfPhase >= def.end)) {
451 SUMOTime maxCutOfPhase =
MIN2(def.end - def.begin, allCutTime);
452 allCutTime = allCutTime - maxCutOfPhase;
453 durOfPhase = durOfPhase - maxCutOfPhase;
456 myTo->addOverridingDuration(durOfPhase);
464 int currStep = myTo->getIndexFromOffset(startPos);
465 SUMOTime durOfPhase = myTo->getPhase(currStep).duration;
466 SUMOTime remainingStretchTime = allStretchTime;
473 facSum *= stretchUmlaufAnz;
476 SUMOTime diffToStart = getDiffToStartOfPhase(*myTo, startPos);
478 SUMOTime endOfPhase = (startPos + durOfPhase - diffToStart);
479 if (def.end <= endOfPhase && def.end >= startPos) {
480 double actualfac = def.fac / facSum;
481 facSum = facSum - def.fac;
483 remainingStretchTime = allStretchTime - StretchTimeOfPhase;
490 durOfPhase = durOfPhase - diffToStart + StretchTimeOfPhase;
491 myTo->changeStepAndDuration(myControl, step, currStep, durOfPhase);
493 currStep = (currStep + 1) % (
int)myTo->getPhases().size();
495 while (remainingStretchTime > 0) {
496 for (
int i = currStep; i < (int)myTo->getPhases().size() && remainingStretchTime > 0; i++) {
497 durOfPhase = myTo->getPhase(i).duration;
498 SUMOTime beginOfPhase = myTo->getOffsetFromIndex(i);
499 SUMOTime endOfPhase = beginOfPhase + durOfPhase;
501 if ((beginOfPhase <= def.end) && (endOfPhase >= def.end)) {
502 double actualfac = def.fac / facSum;
505 durOfPhase += StretchTimeOfPhase;
506 remainingStretchTime -= StretchTimeOfPhase;
509 myTo->addOverridingDuration(durOfPhase);
525 for (std::map<std::string, TLSLogicVariants*>::const_iterator i =
myLogics.begin(); i !=
myLogics.end(); ++i) {
529 for (std::map<std::string, WAUT*>::const_iterator i =
myWAUTs.begin(); i !=
myWAUTs.end(); ++i) {
537 for (std::map<std::string, TLSLogicVariants*>::const_iterator i =
myLogics.begin(); i !=
myLogics.end(); ++i) {
538 (*i).second->getActive()->setTrafficLightSignals(t);
543 std::vector<MSTrafficLightLogic*>
545 std::vector<MSTrafficLightLogic*> ret;
546 std::map<std::string, TLSLogicVariants*>::const_iterator i;
548 std::vector<MSTrafficLightLogic*> s = (*i).second->getAllLogics();
549 copy(s.begin(), s.end(), back_inserter(ret));
556 std::map<std::string, TLSLogicVariants*>::const_iterator i =
myLogics.find(
id);
566 std::map<std::string, TLSLogicVariants*>::const_iterator i =
myLogics.find(
id);
570 return (*i).second->getLogic(programID);
574 std::vector<std::string>
576 std::vector<std::string> ret;
577 for (std::map<std::string, TLSLogicVariants*>::const_iterator i =
myLogics.begin(); i !=
myLogics.end(); ++i) {
578 ret.push_back((*i).first);
587 std::map<std::string, TLSLogicVariants*>::iterator it =
myLogics.find(
id);
606 bool hadErrors =
false;
608 hadErrors |= !it.second->checkOriginalTLS();
609 it.second->saveInitialStates();
618 std::map<std::string, TLSLogicVariants*>::const_iterator i =
myLogics.find(tl->
getID());
622 return (*i).second->isActive(tl);
628 std::map<std::string, TLSLogicVariants*>::const_iterator i =
myLogics.find(
id);
632 return (*i).second->getActive();
639 std::map<std::string, TLSLogicVariants*>::iterator i =
myLogics.find(
id);
642 throw ProcessError(
"Could not switch tls '" +
id +
"' to program '" + programID +
"': No such tls exists.");
644 (*i).second->switchTo(*
this, programID);
650 const std::string& startProg,
SUMOTime period) {
667 SUMOTime when,
const std::string& to) {
681 myWAUTs[wautid]->switches.push_back(s);
687 const std::string& tls,
688 const std::string& proc,
698 throw InvalidArgument(
"TLS '" + tls +
"' to switch in WAUT '" + wautid +
"' was not yet defined.");
704 myWAUTs[wautid]->junctions.push_back(j);
706 std::string initProg =
myWAUTs[wautid]->startProg;
707 std::vector<WAUTSwitch>::const_iterator first =
myWAUTs[wautid]->switches.end();
709 for (std::vector<WAUTSwitch>::const_iterator i =
myWAUTs[wautid]->switches.begin(); i !=
myWAUTs[wautid]->switches.end(); ++i) {
711 minExecTime = (*i).when;
714 if (first !=
myWAUTs[wautid]->switches.begin()) {
715 initProg = (*(first - 1)).to;
731 std::string initProg =
myWAUTs[wautid]->startProg;
733 std::vector<WAUTSwitch>::const_iterator first = w->
switches.end();
735 for (std::vector<WAUTSwitch>::const_iterator i = w->
switches.begin(); i != w->
switches.end(); ++i) {
737 minExecTime = (*i).when;
743 std::vector<WAUTSwitch>::const_iterator mbegin = w->
switches.begin();
759 const std::string& wautid = cmd.
getWAUTID();
763 for (std::vector<WAUTJunction>::iterator i =
myWAUTs[wautid]->junctions.begin(); i !=
myWAUTs[wautid]->junctions.end(); ++i) {
769 if ((*i).procedure ==
"GSP") {
771 }
else if ((*i).procedure ==
"Stretch") {
786 if (index == (
int)waut->
switches.size()) {
818 std::pair<SUMOTime, MSPhaseDefinition>
827 for (
const auto& logic :
myLogics) {
836 for (
const auto& logic :
myLogics) {
837 logic.second->saveState(out);
846 for (
const auto& variants :
myLogics) {
847 for (
auto& logic : variants.second->getAllLogics()) {
854 const SUMOTime cycleTime = logic->getDefaultCycleTime();
855 auto& phases = logic->getPhases();
856 SUMOTime offset = logic->getOffset();
858 offset = (time + cycleTime - (offset % cycleTime)) % cycleTime;
860 offset = (time + ((-offset) % cycleTime)) % cycleTime;
863 while (offset >= phases[step]->duration) {
864 offset -= phases[step]->duration;
867 logic->loadState(*
this, time, step, offset);
#define WRITE_WARNINGF(...)
#define WRITE_ERRORF(...)
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). In case of an error the logic gets deleted.
~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.
void clearState(SUMOTime time, bool quickReload=false)
Clear all tls states before quick-loading state.
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.
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.
bool hasParameter(const std::string &key) const
Returns whether the parameter is set.
std::map< std::string, std::string > Map
parameters map
virtual const std::string getParameter(const std::string &key, const std::string defaultValue="") const
Returns the value for a given key.
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.