43 #define TRACI_PROGRAM "online"
52 myCurrentProgram(nullptr),
53 myDefaultProgram(nullptr) {
58 std::map<std::string, MSTrafficLightLogic*>::const_iterator j;
59 for (std::map<std::string, MSTrafficLightLogic*>::iterator j = myVariants.begin(); j != myVariants.end(); ++j) {
62 for (std::vector<OnSwitchAction*>::iterator i = mySwitchActions.begin(); i != mySwitchActions.end(); ++i) {
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();
98 if (myVariants.find(programID) != myVariants.end()) {
104 if (myCurrentProgram ==
nullptr) {
105 throw ProcessError(
"No initial signal plan loaded for tls '" + logic->
getID() +
"'.");
109 throw ProcessError(
"Mismatching phase size in tls '" + logic->
getID() +
"', program '" + programID +
"'.");
113 if (myVariants.size() == 0 || isNewDefault) {
114 if (myCurrentProgram !=
nullptr) {
115 myCurrentProgram->deactivateProgram();
117 myCurrentProgram = logic;
119 if (myVariants.size() == 0) {
120 myDefaultProgram = logic;
124 myVariants[programID] = logic;
125 if (myVariants.size() == 1 || isNewDefault) {
127 executeOnSwitchActions();
135 if (myVariants.find(programID) == myVariants.end()) {
138 return myVariants.find(programID)->second;
144 const std::string& programID) {
145 if (myVariants.find(programID) == myVariants.end()) {
146 if (programID ==
"off") {
150 throw ProcessError(
"Could not build an off-state for tls '" + myCurrentProgram->getID() +
"'.");
154 throw ProcessError(
"Can not switch tls '" + myCurrentProgram->getID() +
"' to program '" + programID +
"';\n The program is not known.");
157 return getLogic(programID);
163 const std::string& state) {
166 if (logic ==
nullptr) {
168 std::vector<MSPhaseDefinition*> phases;
169 phases.push_back(phase);
172 std::map<std::string, std::string>());
185 mySwitchActions.push_back(c);
189 std::vector<MSTrafficLightLogic*>
191 std::vector<MSTrafficLightLogic*> ret;
192 std::map<std::string, MSTrafficLightLogic*>::const_iterator i;
193 for (i = myVariants.begin(); i != myVariants.end(); ++i) {
194 ret.push_back((*i).second);
202 return tl == myCurrentProgram;
208 return myCurrentProgram;
213 return myDefaultProgram;
220 myCurrentProgram->deactivateProgram();
221 myCurrentProgram = getLogicInstantiatingOff(tlc, programID);
222 myCurrentProgram->activateProgram();
224 executeOnSwitchActions();
230 for (std::vector<OnSwitchAction*>::const_iterator i = mySwitchActions.begin(); i != mySwitchActions.end(); ++i) {
238 for (std::map<std::string, MSTrafficLightLogic*>::iterator i = myVariants.begin(); i != myVariants.end(); ++i) {
239 (*i).second->addLink(link, lane, pos);
245 for (std::map<std::string, MSTrafficLightLogic*>::iterator i = myVariants.begin(); i != myVariants.end(); ++i) {
246 (*i).second->ignoreLinkIndex(pos);
260 if (isPosAtGSP(step, *myFrom)) {
262 if (mySwitchSynchron) {
265 switchToPos(step, *myTo, getGSPTime(*myTo));
285 return gspTime == programTime;
293 assert(toTime >= startOfPhase);
294 return toTime - startOfPhase;
301 SUMOTime diff = getDiffToStartOfPhase(logic, toTime);
342 const SUMOTime gspTo = getGSPTime(*myTo) % myTo->getDefaultCycleTime();
343 const SUMOTime currentPosTo = myTo->getOffsetFromIndex(myTo->getCurrentPhaseIndex()) + myTo->getSpentDuration(step);
344 SUMOTime deltaToStretch = gspTo - currentPosTo;
345 if (deltaToStretch < 0) {
346 deltaToStretch += myTo->getDefaultCycleTime();
348 const int stepTo = myTo->getIndexFromOffset(gspTo);
349 const SUMOTime newdur = myTo->getPhase(stepTo).duration - getDiffToStartOfPhase(*myTo, gspTo) + deltaToStretch;
350 myTo->changeStepAndDuration(myControl, step, stepTo, newdur);
380 SUMOTime cycleTime = myTo->getDefaultCycleTime();
382 SUMOTime posAfterSyn = myTo->getPhaseIndexAtTime(step);
385 if (posAfterSyn < gspTo) {
386 deltaToCut = posAfterSyn + cycleTime - gspTo;
388 deltaToCut = posAfterSyn - gspTo;
393 assert(def.end >= def.begin);
394 deltaPossible += def.end - def.begin;
397 deltaPossible = stretchUmlaufAnz * deltaPossible;
398 if ((deltaPossible > deltaToCut) && (deltaToCut < (cycleTime / 2))) {
399 cutLogic(step, gspTo, deltaToCut);
401 SUMOTime deltaToStretch = (cycleTime - deltaToCut) % cycleTime;
402 stretchLogic(step, gspTo, deltaToStretch);
409 int actStep = myTo->getIndexFromOffset(startPos);
413 int stepOfBegin = myTo->getIndexFromOffset(def.begin);
414 if (stepOfBegin == actStep) {
415 if (def.begin < startPos) {
416 toCut = def.end - startPos;
418 toCut = def.end - def.begin;
420 toCut =
MIN2(allCutTime, toCut);
421 allCutTime = allCutTime - toCut;
424 SUMOTime remainingDur = myTo->getPhase(actStep).duration - getDiffToStartOfPhase(*myTo, startPos);
425 SUMOTime newDur = remainingDur - toCut;
426 myTo->changeStepAndDuration(myControl, step, actStep, newDur);
429 int currStep = (actStep + 1) % (
int)myTo->getPhases().size();
430 while (allCutTime > 0) {
431 for (
int i = currStep; i < (int) myTo->getPhases().size(); i++) {
432 SUMOTime beginOfPhase = myTo->getOffsetFromIndex(i);
433 SUMOTime durOfPhase = myTo->getPhase(i).duration;
434 SUMOTime endOfPhase = beginOfPhase + durOfPhase;
436 if ((beginOfPhase <= def.begin) && (endOfPhase >= def.end)) {
437 SUMOTime maxCutOfPhase =
MIN2(def.end - def.begin, allCutTime);
438 allCutTime = allCutTime - maxCutOfPhase;
439 durOfPhase = durOfPhase - maxCutOfPhase;
442 myTo->addOverridingDuration(durOfPhase);
450 int currStep = myTo->getIndexFromOffset(startPos);
451 SUMOTime durOfPhase = myTo->getPhase(currStep).duration;
452 SUMOTime remainingStretchTime = allStretchTime;
459 facSum *= stretchUmlaufAnz;
462 SUMOTime diffToStart = getDiffToStartOfPhase(*myTo, startPos);
464 SUMOTime endOfPhase = (startPos + durOfPhase - diffToStart);
465 if (def.end <= endOfPhase && def.end >= startPos) {
466 double actualfac = def.fac / facSum;
467 facSum = facSum - def.fac;
469 remainingStretchTime = allStretchTime - StretchTimeOfPhase;
473 WRITE_WARNING(
"The computed factor sum in WAUT '" + myWAUT.id +
"' at time '" +
toString(
STEPS2TIME(step)) +
"' equals zero;\n assuming an error in WAUT definition.");
476 durOfPhase = durOfPhase - diffToStart + StretchTimeOfPhase;
477 myTo->changeStepAndDuration(myControl, step, currStep, durOfPhase);
479 currStep = (currStep + 1) % (
int)myTo->getPhases().size();
481 while (remainingStretchTime > 0) {
482 for (
int i = currStep; i < (int)myTo->getPhases().size() && remainingStretchTime > 0; i++) {
483 durOfPhase = myTo->getPhase(i).duration;
484 SUMOTime beginOfPhase = myTo->getOffsetFromIndex(i);
485 SUMOTime endOfPhase = beginOfPhase + durOfPhase;
487 if ((beginOfPhase <= def.end) && (endOfPhase >= def.end)) {
488 double actualfac = def.fac / facSum;
491 durOfPhase += StretchTimeOfPhase;
492 remainingStretchTime -= StretchTimeOfPhase;
495 myTo->addOverridingDuration(durOfPhase);
511 for (std::map<std::string, TLSLogicVariants*>::const_iterator i =
myLogics.begin(); i !=
myLogics.end(); ++i) {
515 for (std::map<std::string, WAUT*>::const_iterator i =
myWAUTs.begin(); i !=
myWAUTs.end(); ++i) {
523 for (std::map<std::string, TLSLogicVariants*>::const_iterator i =
myLogics.begin(); i !=
myLogics.end(); ++i) {
524 (*i).second->getActive()->setTrafficLightSignals(t);
529 std::vector<MSTrafficLightLogic*>
531 std::vector<MSTrafficLightLogic*> ret;
532 std::map<std::string, TLSLogicVariants*>::const_iterator i;
534 std::vector<MSTrafficLightLogic*> s = (*i).second->getAllLogics();
535 copy(s.begin(), s.end(), back_inserter(ret));
542 std::map<std::string, TLSLogicVariants*>::const_iterator i =
myLogics.find(
id);
552 std::map<std::string, TLSLogicVariants*>::const_iterator i =
myLogics.find(
id);
556 return (*i).second->getLogic(programID);
560 std::vector<std::string>
562 std::vector<std::string> ret;
563 for (std::map<std::string, TLSLogicVariants*>::const_iterator i =
myLogics.begin(); i !=
myLogics.end(); ++i) {
564 ret.push_back((*i).first);
576 std::map<std::string, TLSLogicVariants*>::iterator i =
myLogics.find(
id);
584 std::map<std::string, TLSLogicVariants*>::const_iterator i =
myLogics.find(
id);
594 bool hadErrors =
false;
595 for (std::map<std::string, TLSLogicVariants*>::iterator i =
myLogics.begin(); i !=
myLogics.end(); ++i) {
596 hadErrors |= !(*i).second->checkOriginalTLS();
597 (*i).second->saveInitialStates();
606 std::map<std::string, TLSLogicVariants*>::const_iterator i =
myLogics.find(tl->
getID());
610 return (*i).second->isActive(tl);
616 std::map<std::string, TLSLogicVariants*>::const_iterator i =
myLogics.find(
id);
620 return (*i).second->getActive();
627 std::map<std::string, TLSLogicVariants*>::iterator i =
myLogics.find(
id);
630 throw ProcessError(
"Could not switch tls '" +
id +
"' to program '" + programID +
"': No such tls exists.");
632 (*i).second->switchTo(*
this, programID);
638 const std::string& startProg,
SUMOTime period) {
655 SUMOTime when,
const std::string& to) {
669 myWAUTs[wautid]->switches.push_back(s);
675 const std::string& tls,
676 const std::string& proc,
686 throw InvalidArgument(
"TLS '" + tls +
"' to switch in WAUT '" + wautid +
"' was not yet defined.");
692 myWAUTs[wautid]->junctions.push_back(j);
694 std::string initProg =
myWAUTs[wautid]->startProg;
695 std::vector<WAUTSwitch>::const_iterator first =
myWAUTs[wautid]->switches.end();
697 for (std::vector<WAUTSwitch>::const_iterator i =
myWAUTs[wautid]->switches.begin(); i !=
myWAUTs[wautid]->switches.end(); ++i) {
699 minExecTime = (*i).when;
702 if (first !=
myWAUTs[wautid]->switches.begin()) {
703 initProg = (*(first - 1)).to;
719 std::string initProg =
myWAUTs[wautid]->startProg;
721 std::vector<WAUTSwitch>::const_iterator first = w->
switches.end();
723 for (std::vector<WAUTSwitch>::const_iterator i = w->
switches.begin(); i != w->
switches.end(); ++i) {
725 minExecTime = (*i).when;
731 std::vector<WAUTSwitch>::const_iterator mbegin = w->
switches.begin();
747 const std::string& wautid = cmd.
getWAUTID();
751 for (std::vector<WAUTJunction>::iterator i =
myWAUTs[wautid]->junctions.begin(); i !=
myWAUTs[wautid]->junctions.end(); ++i) {
757 if ((*i).procedure ==
"GSP") {
759 }
else if ((*i).procedure ==
"Stretch") {
774 if (index == (
int)waut->
switches.size()) {
806 std::pair<SUMOTime, MSPhaseDefinition>
815 for (std::map<std::string, TLSLogicVariants*>::const_iterator i =
myLogics.begin(); i !=
myLogics.end(); ++i) {
#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
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.
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.