57 : myCurrentProgram(0) {
62 std::map<std::string, MSTrafficLightLogic*>::const_iterator j;
63 for (std::map<std::string, MSTrafficLightLogic*>::iterator j =
myVariants.begin(); j !=
myVariants.end(); ++j) {
74 bool hadErrors =
false;
75 for (std::map<std::string, MSTrafficLightLogic*>::const_iterator j =
myVariants.begin(); j !=
myVariants.end(); ++j) {
77 int linkNo = (int)(*j).second->getLinks().size();
78 bool hadProgramErrors =
false;
79 for (MSTrafficLightLogic::Phases::const_iterator i = phases.begin(); i != phases.end(); ++i) {
80 if ((
int)(*i)->getState().length() < linkNo) {
81 hadProgramErrors =
true;
84 if (hadProgramErrors) {
85 WRITE_ERROR(
"Mismatching phase size in tls '" + (*j).second->getID() +
"', program '" + (*j).first +
"'.");
109 throw ProcessError(
"No initial signal plan loaded for tls '" + logic->
getID() +
"'.");
113 throw ProcessError(
"Mismatching phase size in tls '" + logic->
getID() +
"', program '" + programID +
"'.");
141 const std::string& programID) {
143 if (programID ==
"off") {
160 const std::string& state) {
165 std::vector<MSPhaseDefinition*> phases;
166 phases.push_back(phase);
169 std::map<std::string, std::string>());
170 addLogic(
"online", logic,
true,
true);
185 std::vector<MSTrafficLightLogic*>
187 std::vector<MSTrafficLightLogic*> ret;
188 std::map<std::string, MSTrafficLightLogic*>::const_iterator i;
190 ret.push_back((*i).second);
227 for (std::map<std::string, MSTrafficLightLogic*>::iterator i =
myVariants.begin(); i !=
myVariants.end(); ++i) {
228 (*i).second->addLink(link, lane, pos);
243 if (val.length() == 0) {
255 return gspTime == programTime;
263 assert(toTime >= startOfPhase);
264 return toTime - startOfPhase;
271 SUMOTime diff = getDiffToStartOfPhase(logic, toTime);
333 if (gspTo == cycleTimeTo) {
342 if (gspTo >= currentPosTo) {
343 deltaToStretch = (gspTo - currentPosTo);
345 deltaToStretch = (cycleTimeTo - currentPosTo + gspTo);
391 if (posAfterSyn < gspTo) {
392 deltaToCut = posAfterSyn + cycleTime - gspTo;
394 deltaToCut = posAfterSyn - gspTo;
399 for (
int i = 0; i < areasNo; i++) {
405 deltaPossible = stretchUmlaufAnz * deltaPossible;
406 if ((deltaPossible > deltaToCut) && (deltaToCut < (cycleTime / 2))) {
409 SUMOTime deltaToStretch = (cycleTime - deltaToCut) % cycleTime;
421 for (
int i = 0; i < areasNo; i++) {
426 if (stepOfBegin == actStep) {
427 if (begin < startPos) {
428 toCut = end - startPos;
432 toCut =
MIN2(allCutTime, toCut);
433 allCutTime = allCutTime - toCut;
437 SUMOTime newDur = remainingDur - toCut;
441 int currStep = (actStep + 1) % (
int)
myTo->
getPhases().size();
442 while (allCutTime > 0) {
443 for (
int i = currStep; i < (int)
myTo->
getPhases().size(); i++) {
446 SUMOTime endOfPhase = beginOfPhase + durOfPhase;
447 for (
int i = 0; i < areasNo; i++) {
451 if ((beginOfPhase <= begin) && (endOfPhase >= end)) {
453 allCutTime = allCutTime - maxCutOfPhase;
454 durOfPhase = durOfPhase - maxCutOfPhase;
467 SUMOTime remainingStretchTime = allStretchTime;
472 for (
int x = 0; x < areasNo; x++) {
476 facSum *= stretchUmlaufAnz;
480 for (
int x = 0; x < areasNo; x++) {
483 SUMOTime endOfPhase = (startPos + durOfPhase - diffToStart);
484 if (end <= endOfPhase && end >= startPos) {
485 double fac = def.
fac;
486 double actualfac = fac / facSum;
487 facSum = facSum - fac;
489 remainingStretchTime = allStretchTime - StretchTimeOfPhase;
496 durOfPhase = durOfPhase - diffToStart + StretchTimeOfPhase;
501 while (remainingStretchTime > 0) {
502 for (
int i = currStep; i < (int)
myTo->
getPhases().size() && remainingStretchTime > 0; i++) {
505 SUMOTime endOfPhase = beginOfPhase + durOfPhase;
506 for (
int j = 0; j < areasNo && remainingStretchTime > 0; j++) {
509 double fac = def.
fac;
510 if ((beginOfPhase <= end) && (endOfPhase >= end)) {
511 double actualfac = fac / facSum;
514 durOfPhase += StretchTimeOfPhase;
515 remainingStretchTime -= StretchTimeOfPhase;
554 for (std::map<std::string, TLSLogicVariants*>::const_iterator i =
myLogics.begin(); i !=
myLogics.end(); ++i) {
558 for (std::map<std::string, WAUT*>::const_iterator i =
myWAUTs.begin(); i !=
myWAUTs.end(); ++i) {
566 for (std::map<std::string, TLSLogicVariants*>::const_iterator i =
myLogics.begin(); i !=
myLogics.end(); ++i) {
567 (*i).second->getActive()->setTrafficLightSignals(t);
572 std::vector<MSTrafficLightLogic*>
574 std::vector<MSTrafficLightLogic*> ret;
575 std::map<std::string, TLSLogicVariants*>::const_iterator i;
577 std::vector<MSTrafficLightLogic*> s = (*i).second->getAllLogics();
578 copy(s.begin(), s.end(), back_inserter(ret));
585 std::map<std::string, TLSLogicVariants*>::const_iterator i =
myLogics.find(
id);
595 std::map<std::string, TLSLogicVariants*>::const_iterator i =
myLogics.find(
id);
599 return (*i).second->getLogic(programID);
603 std::vector<std::string>
605 std::vector<std::string> ret;
606 for (std::map<std::string, TLSLogicVariants*>::const_iterator i =
myLogics.begin(); i !=
myLogics.end(); ++i) {
607 ret.push_back((*i).first);
619 std::map<std::string, TLSLogicVariants*>::iterator i =
myLogics.find(
id);
627 std::map<std::string, TLSLogicVariants*>::const_iterator i =
myLogics.find(
id);
637 bool hadErrors =
false;
638 for (std::map<std::string, TLSLogicVariants*>::iterator i =
myLogics.begin(); i !=
myLogics.end(); ++i) {
639 hadErrors |= !(*i).second->checkOriginalTLS();
640 (*i).second->saveInitialStates();
649 std::map<std::string, TLSLogicVariants*>::const_iterator i =
myLogics.find(tl->
getID());
653 return (*i).second->isActive(tl);
659 std::map<std::string, TLSLogicVariants*>::const_iterator i =
myLogics.find(
id);
663 return (*i).second->getActive();
670 std::map<std::string, TLSLogicVariants*>::iterator i =
myLogics.find(
id);
673 throw ProcessError(
"Could not switch tls '" +
id +
"' to program '" + programID +
"': No such tls exists.");
675 (*i).second->switchTo(*
this, programID);
681 const std::string& startProg) {
697 SUMOTime when,
const std::string& to) {
706 s.
when = (
myWAUTs[wautid]->refTime + when) % 86400000;
707 myWAUTs[wautid]->switches.push_back(s);
713 const std::string& tls,
714 const std::string& proc,
724 throw InvalidArgument(
"TLS '" + tls +
"' to switch in WAUT '" + wautid +
"' was not yet defined.");
730 myWAUTs[wautid]->junctions.push_back(j);
732 std::string initProg =
myWAUTs[wautid]->startProg;
733 std::vector<WAUTSwitch>::const_iterator first =
myWAUTs[wautid]->switches.end();
735 for (std::vector<WAUTSwitch>::const_iterator i =
myWAUTs[wautid]->switches.begin(); i !=
myWAUTs[wautid]->switches.end(); ++i) {
737 minExecTime = (*i).when;
740 if (first !=
myWAUTs[wautid]->switches.begin()) {
741 initProg = (*(first - 1)).to;
757 std::string initProg =
myWAUTs[wautid]->startProg;
759 std::vector<WAUTSwitch>::const_iterator first = w->
switches.end();
761 for (std::vector<WAUTSwitch>::const_iterator i = w->
switches.begin(); i != w->
switches.end(); ++i) {
763 minExecTime = (*i).when;
769 std::vector<WAUTSwitch>::const_iterator mbegin = w->
switches.begin();
785 const std::string& wautid = cmd.
getWAUTID();
788 for (std::vector<WAUTJunction>::iterator i =
myWAUTs[wautid]->junctions.begin(); i !=
myWAUTs[wautid]->junctions.end(); ++i) {
794 if ((*i).procedure ==
"GSP") {
796 }
else if ((*i).procedure ==
"Stretch") {
811 if (index == static_cast<int>(
myWAUTs[wautid]->switches.size())) {
824 switchTo((*i).to->getID(), (*i).to->getProgramID());
833 std::pair<SUMOTime, MSPhaseDefinition>
842 for (std::map<std::string, TLSLogicVariants*>::const_iterator i =
myLogics.begin(); i !=
myLogics.end(); ++i) {
TLSLogicVariants()
Constructor.
double end
The end of a stretch/cut area (time, in s)
bool trySwitch(SUMOTime step)
Determines whether a switch is possible.
bool add(const std::string &id, const std::string &programID, MSTrafficLightLogic *logic, bool newDefault=true)
Adds a tls program to the container.
~WAUTSwitchProcedure_GSP()
Destructor.
virtual const MSPhaseDefinition & getCurrentPhaseDef() const =0
Returns the definition of the current phase.
const std::string & getState() const
Returns the state within this phase.
void cutLogic(SUMOTime step, SUMOTime startPos, SUMOTime allCutTime)
Cuts the logic to synchronize.
void switchOffAll()
switch all logic variants to 'off'
std::map< MSLink *, LinkState > myOriginalLinkStates
Originally loaded link states.
int & getIndex()
Returns a reference to the index.
void executeOnSwitchActions() const
std::map< std::string, TLSLogicVariants * > myLogics
A map from ids to the corresponding variants.
Storage for all programs of a single tls.
double fac
The weight factor of a stretch/cut area.
virtual SUMOTime getOffsetFromIndex(int index) const =0
Returns the position (start of a phase during a cycle) from of a given step.
Base class for things to execute if a tls switches to a new phase.
~TLSLogicVariants()
Destructor.
int getGSPValue(const MSTrafficLightLogic &logic) const
Returns the GSP-value.
void switchTo(const std::string &id, const std::string &programID)
Switches the named (id) tls to the named (programID) program.
std::map< std::string, MSTrafficLightLogic * > myVariants
A map of subkeys to programs.
~WAUTSwitchProcedure_Stretch()
Destructor.
~WAUTSwitchProcedure_JustSwitch()
Destructor.
virtual void changeStepAndDuration(MSTLLogicControl &tlcontrol, SUMOTime simStep, int step, SUMOTime stepDuration)=0
Changes the current phase and her duration.
virtual SUMOTime getPhaseIndexAtTime(SUMOTime simStep) const =0
Returns the index of the logic at the given simulation step.
~MSTLLogicControl()
Destructor.
WAUTSwitchProcedure_GSP(MSTLLogicControl &control, WAUT &waut, MSTrafficLightLogic *from, MSTrafficLightLogic *to, bool synchron)
Constructor.
A definition of a stretch - Bereich.
virtual const MSPhaseDefinition & getPhase(int givenstep) const =0
Returns the definition of the phase from the given position within the plan.
bool isActive(const MSTrafficLightLogic *tl) const
Returns whether the given tls program is the currently active for his tls.
double begin
The begin of a stretch/cut area (time, in s)
static MSNet * getInstance()
Returns the pointer to the unique instance of MSNet (singleton).
bool trySwitch(SUMOTime step)
Determines whether a switch is possible.
std::string junction
The id of the junction to switch.
std::string procedure
The procedure to switch the junction with.
MSTrafficLightLogic * myTo
The program to switch the tls to.
WAUTSwitchProcedure_Stretch(MSTLLogicControl &control, WAUT &waut, MSTrafficLightLogic *from, MSTrafficLightLogic *to, bool synchron)
Constructor.
virtual int getCurrentPhaseIndex() const =0
Returns the current index within the program.
void addLink(MSLink *link, MSLane *lane, int pos)
const std::string & getID() const
Returns the id.
MSTLLogicControl()
Constructor.
bool setTrafficLightSignals(SUMOTime t) const
Applies the current signal states to controlled links.
WAUT & myWAUT
The WAUT responsible for switching.
void closeWAUT(const std::string &wautid)
Closes loading of a WAUT.
const LinkVectorVector & getLinks() const
Returns the list of lists of all affected links.
SUMOTime initWautSwitch(SwitchInitCommand &cmd)
Initialises switching a WAUT.
bool myNetWasLoaded
Information whether the net was completely loaded.
Storage for a junction assigned to a WAUT.
#define WRITE_WARNING(msg)
A fixed traffic light logic.
A traffic lights logic which represents a tls in an off-mode.
A class that stores and controls tls and switching of their programs.
bool mySwitchSynchron
Information whether to switch synchron (?)
SUMOTime getDefaultCycleTime() const
Returns the cycle time (in ms)
MSTLLogicControl & myControl
The control the logic belongs to.
SUMOTime duration
The duration of the phase.
std::vector< MSTrafficLightLogic * > getAllLogics() const
bool addLogic(const std::string &programID, MSTrafficLightLogic *logic, bool netWasLoaded, bool isNewDefault=true)
Adds a logic (program)
void addSwitchCommand(OnSwitchAction *c)
StretchBereichDef getStretchBereichDef(MSTrafficLightLogic *from, int index) const
Returns the numbered Stretch-area for the given program.
MSTrafficLightLogic * getLogicInstantiatingOff(MSTLLogicControl &tlc, const std::string &programID)
std::pair< SUMOTime, MSPhaseDefinition > getPhaseDef(const std::string &tlid) const
return the complete phase definition for a named traffic lights logic
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
WAUTSwitchProcedure * proc
The used procedure.
void adaptLogic(SUMOTime step)
Stretches the destination program's phase to which the tls was switched.
MSTrafficLightLogic * getActive(const std::string &id) const
Returns the active program of a named tls.
This class simply switches to the next program.
bool synchron
Information whether this junction shall be switched synchron.
void adaptLogic(SUMOTime step)
Determines the destination program's changes and applies them.
virtual bool trySwitch(SUMOTime step)=0
Determines whether a switch is possible.
MSEventControl * getBeginOfTimestepEvents()
Returns the event control for events executed at the begin of a time step.
MSTrafficLightLogic * to
The program to switch the tls to.
This class switches using the Stretch algorithm.
virtual void addEvent(Command *operation, SUMOTime execTimeStep=-1)
Adds an Event.
virtual void adaptLinkInformationFrom(const MSTrafficLightLogic &logic)
Applies information about controlled links and lanes from the given logic.
SUMOTime getCurrentTimeStep() const
Returns the current simulation step.
void check2Switch(SUMOTime step)
Checks whether any WAUT is trying to switch a tls into another program.
int getStretchAreaNo(MSTrafficLightLogic *from) const
Returns the number of given Stretch-areas for the given program.
bool checkOriginalTLS() const
Verifies traffic lights loaded from the network.
std::map< MSLink *, LinkState > collectLinkStates() const
Returns the (uncontrolled) states of the controlled links.
SUMOTime when
The time the WAUT shall switch the TLS.
void stretchLogic(SUMOTime step, SUMOTime startPos, SUMOTime allStretchTime)
Stretches the logic to synchronize.
std::vector< OnSwitchAction * > mySwitchActions
The list of actions/commands to execute on switch.
void setStateInstantiatingOnline(MSTLLogicControl &tlc, const std::string &state)
bool trySwitch(SUMOTime step)
Determines whether a switch is possible.
std::string startProg
The name of the start program.
WAUTSwitchProcedure_JustSwitch(MSTLLogicControl &control, WAUT &waut, MSTrafficLightLogic *from, MSTrafficLightLogic *to, bool synchron)
Constructor.
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.
bool knows(const std::string &id) const
Returns the information whether the named tls is stored.
std::vector< WAUTSwitchProcess > myCurrentlySwitched
A list of currently running switching procedures.
std::vector< MSPhaseDefinition * > Phases
Definition of a list of phases, being the junction logic.
virtual const Phases & getPhases() const =0
Returns the phases of this tls program.
bool closeNetworkReading()
Lets MSTLLogicControl know that the network has been loaded.
const std::string & getParameter(const std::string &key, const std::string &defaultValue) const
Returns the value for a given key.
void addOverridingDuration(SUMOTime duration)
Changes the duration of the next phase.
An initialised switch process.
void switchTo(MSTLLogicControl &tlc, const std::string &programID)
static int _2int(const E *const data)
converts a char-type array into the integer value described by it
std::vector< WAUTSwitch > switches
The list of switches to be done by the WAUT.
void switchToPos(SUMOTime simStep, MSTrafficLightLogic &logic, SUMOTime toTime)
switches the given logic directly to the given position
SUMOTime getNextSwitchTime() const
Returns the assumed next switch time.
This event-class is used to initialise a WAUT switch at a certain time.
void addWAUT(SUMOTime refTime, const std::string &id, const std::string &startProg)
Adds a WAUT definition.
This class switches using the GSP algorithm.
SUMOTime getDiffToStartOfPhase(MSTrafficLightLogic &logic, SUMOTime toTime)
Returns the difference between a given time and the start of the phase.
SUMOTime refTime
The reference time (offset to the switch times)
This is the abstract base class for switching from one tls program to another.
const std::string & getWAUTID() const
Returns the WAUT-id.
std::string id
The id of the WAUT.
bool isActive(const MSTrafficLightLogic *tl) const
static double _2double(const E *const data)
converts a char-type array into the double value described by it
std::map< std::string, WAUT * > myWAUTs
A map of ids to corresponding WAUTs.
bool isPosAtGSP(SUMOTime currentTime, const MSTrafficLightLogic &logic)
Checks, whether the position of a signal programm is at the GSP ("GuenstigerUmschaltPunkt") ...
The parent class for traffic light logics.
Storage for a WAUTs switch point.
void addWAUTSwitch(const std::string &wautid, SUMOTime when, const std::string &to)
Adds a WAUT switch step to a previously built WAUT.
std::string to
The program name the WAUT shall switch the TLS to.
TLSLogicVariants & get(const std::string &id) const
Returns the variants of a named tls.
MSTrafficLightLogic * getActive() const
MSTrafficLightLogic * from
The current program of the tls.
std::vector< std::string > getAllTLIds() const
MSTrafficLightLogic * getLogic(const std::string &programID) const
void setTrafficLightSignals(SUMOTime t) const
Lets all running (current) tls programs apply their current signal states to links they control...
MSTrafficLightLogic * myFrom
The current program of the tls to switch.
Representation of a lane in the micro simulation.
The definition of a single phase of a tls logic.
MSTrafficLightLogic * myCurrentProgram
The currently used program.
std::vector< MSTrafficLightLogic * > getAllLogics() const
Returns a vector which contains all logics.
virtual int getIndexFromOffset(SUMOTime offset) const =0
Returns the step (the phasenumber) of a given position of the cycle.
std::string junction
The junction name.