49 #ifdef CHECK_MEMORY_LEAKS 51 #endif // CHECK_MEMORY_LEAKS 61 : myCurrentProgram(0) {
66 std::map<std::string, MSTrafficLightLogic*>::const_iterator j;
67 for (std::map<std::string, MSTrafficLightLogic*>::iterator j =
myVariants.begin(); j !=
myVariants.end(); ++j) {
78 bool hadErrors =
false;
79 for (std::map<std::string, MSTrafficLightLogic*>::const_iterator j =
myVariants.begin(); j !=
myVariants.end(); ++j) {
81 unsigned int linkNo = (
unsigned int)(*j).second->getLinks().size();
82 bool hadProgramErrors =
false;
83 for (MSTrafficLightLogic::Phases::const_iterator i = phases.begin(); i != phases.end(); ++i) {
84 if ((*i)->getState().length() < linkNo) {
85 hadProgramErrors =
true;
88 if (hadProgramErrors) {
89 WRITE_ERROR(
"Mismatching phase size in tls '" + (*j).second->getID() +
"', program '" + (*j).first +
"'.");
113 throw ProcessError(
"No initial signal plan loaded for tls '" + logic->
getID() +
"'.");
117 throw ProcessError(
"Mismatching phase size in tls '" + logic->
getID() +
"', program '" + programID +
"'.");
145 const std::string& programID) {
147 if (programID ==
"off") {
164 const std::string& state) {
169 std::vector<MSPhaseDefinition*> phases;
170 phases.push_back(phase);
173 std::map<std::string, std::string>());
174 addLogic(
"online", logic,
true,
true);
189 std::vector<MSTrafficLightLogic*>
191 std::vector<MSTrafficLightLogic*> ret;
192 std::map<std::string, MSTrafficLightLogic*>::const_iterator i;
194 ret.push_back((*i).second);
231 for (std::map<std::string, MSTrafficLightLogic*>::iterator i =
myVariants.begin(); i !=
myVariants.end(); ++i) {
232 (*i).second->addLink(link, lane, pos);
247 if (val.length() == 0) {
259 return gspTime == programTime;
267 assert(toTime >= startOfPhase);
268 return toTime - startOfPhase;
275 SUMOTime diff = getDiffToStartOfPhase(logic, toTime);
337 if (gspTo == cycleTimeTo) {
346 if (gspTo >= currentPosTo) {
347 deltaToStretch = (gspTo - currentPosTo);
349 deltaToStretch = (cycleTimeTo - currentPosTo + gspTo);
395 if (posAfterSyn < gspTo) {
396 deltaToCut = posAfterSyn + cycleTime - gspTo;
398 deltaToCut = posAfterSyn - gspTo;
403 for (
int i = 0; i < areasNo; i++) {
409 deltaPossible = stretchUmlaufAnz * deltaPossible;
410 if ((deltaPossible > deltaToCut) && (deltaToCut < (cycleTime / 2))) {
413 SUMOTime deltaToStretch = (cycleTime - deltaToCut) % cycleTime;
425 for (
int i = 0; i < areasNo; i++) {
430 if (stepOfBegin == actStep) {
431 if (begin < startPos) {
432 toCut = end - startPos;
436 toCut =
MIN2(allCutTime, toCut);
437 allCutTime = allCutTime - toCut;
441 SUMOTime newDur = remainingDur - toCut;
445 int currStep = (actStep + 1) % (
int)
myTo->
getPhases().size();
446 while (allCutTime > 0) {
447 for (
int i = currStep; i < (int)
myTo->
getPhases().size(); i++) {
450 SUMOTime endOfPhase = beginOfPhase + durOfPhase;
451 for (
int i = 0; i < areasNo; i++) {
455 if ((beginOfPhase <= begin) && (endOfPhase >= end)) {
457 allCutTime = allCutTime - maxCutOfPhase;
458 durOfPhase = durOfPhase - maxCutOfPhase;
471 SUMOTime remainingStretchTime = allStretchTime;
476 for (
int x = 0; x < areasNo; x++) {
480 facSum *= stretchUmlaufAnz;
484 for (
int x = 0; x < areasNo; x++) {
487 SUMOTime endOfPhase = (startPos + durOfPhase - diffToStart);
488 if (end <= endOfPhase && end >= startPos) {
491 facSum = facSum - fac;
493 remainingStretchTime = allStretchTime - StretchTimeOfPhase;
500 durOfPhase = durOfPhase - diffToStart + StretchTimeOfPhase;
505 while (remainingStretchTime > 0) {
506 for (
unsigned int i = currStep; i <
myTo->
getPhases().size() && remainingStretchTime > 0; i++) {
509 SUMOTime endOfPhase = beginOfPhase + durOfPhase;
510 for (
int j = 0; j < areasNo && remainingStretchTime > 0; j++) {
514 if ((beginOfPhase <= end) && (endOfPhase >= end)) {
518 durOfPhase += StretchTimeOfPhase;
519 remainingStretchTime -= StretchTimeOfPhase;
558 for (std::map<std::string, TLSLogicVariants*>::const_iterator i =
myLogics.begin(); i !=
myLogics.end(); ++i) {
562 for (std::map<std::string, WAUT*>::const_iterator i =
myWAUTs.begin(); i !=
myWAUTs.end(); ++i) {
570 for (std::map<std::string, TLSLogicVariants*>::const_iterator i =
myLogics.begin(); i !=
myLogics.end(); ++i) {
571 (*i).second->getActive()->setTrafficLightSignals(t);
576 std::vector<MSTrafficLightLogic*>
578 std::vector<MSTrafficLightLogic*> ret;
579 std::map<std::string, TLSLogicVariants*>::const_iterator i;
581 std::vector<MSTrafficLightLogic*> s = (*i).second->getAllLogics();
582 copy(s.begin(), s.end(), back_inserter(ret));
589 std::map<std::string, TLSLogicVariants*>::const_iterator i =
myLogics.find(
id);
599 std::map<std::string, TLSLogicVariants*>::const_iterator i =
myLogics.find(
id);
603 return (*i).second->getLogic(programID);
607 std::vector<std::string>
609 std::vector<std::string> ret;
610 for (std::map<std::string, TLSLogicVariants*>::const_iterator i =
myLogics.begin(); i !=
myLogics.end(); ++i) {
611 ret.push_back((*i).first);
623 std::map<std::string, TLSLogicVariants*>::iterator i =
myLogics.find(
id);
631 std::map<std::string, TLSLogicVariants*>::const_iterator i =
myLogics.find(
id);
641 bool hadErrors =
false;
642 for (std::map<std::string, TLSLogicVariants*>::iterator i =
myLogics.begin(); i !=
myLogics.end(); ++i) {
643 hadErrors |= !(*i).second->checkOriginalTLS();
644 (*i).second->saveInitialStates();
653 std::map<std::string, TLSLogicVariants*>::const_iterator i =
myLogics.find(tl->
getID());
657 return (*i).second->isActive(tl);
663 std::map<std::string, TLSLogicVariants*>::const_iterator i =
myLogics.find(
id);
667 return (*i).second->getActive();
674 std::map<std::string, TLSLogicVariants*>::iterator i =
myLogics.find(
id);
677 throw ProcessError(
"Could not switch tls '" +
id +
"' to program '" + programID +
"': No such tls exists.");
679 (*i).second->switchTo(*
this, programID);
685 const std::string& startProg) {
701 SUMOTime when,
const std::string& to) {
710 s.
when = (
myWAUTs[wautid]->refTime + when) % 86400000;
711 myWAUTs[wautid]->switches.push_back(s);
717 const std::string& tls,
718 const std::string& proc,
728 throw InvalidArgument(
"TLS '" + tls +
"' to switch in WAUT '" + wautid +
"' was not yet defined.");
734 myWAUTs[wautid]->junctions.push_back(j);
736 std::string initProg =
myWAUTs[wautid]->startProg;
737 std::vector<WAUTSwitch>::const_iterator first =
myWAUTs[wautid]->switches.end();
739 for (std::vector<WAUTSwitch>::const_iterator i =
myWAUTs[wautid]->switches.begin(); i !=
myWAUTs[wautid]->switches.end(); ++i) {
741 minExecTime = (*i).when;
744 if (first !=
myWAUTs[wautid]->switches.begin()) {
745 initProg = (*(first - 1)).to;
761 std::string initProg =
myWAUTs[wautid]->startProg;
763 std::vector<WAUTSwitch>::const_iterator first = w->
switches.end();
765 for (std::vector<WAUTSwitch>::const_iterator i = w->
switches.begin(); i != w->
switches.end(); ++i) {
767 minExecTime = (*i).when;
773 std::vector<WAUTSwitch>::const_iterator mbegin = w->
switches.begin();
789 const std::string& wautid = cmd.
getWAUTID();
790 unsigned int& index = cmd.
getIndex();
792 for (std::vector<WAUTJunction>::iterator i =
myWAUTs[wautid]->junctions.begin(); i !=
myWAUTs[wautid]->junctions.end(); ++i) {
798 if ((*i).procedure ==
"GSP") {
800 }
else if ((*i).procedure ==
"Stretch") {
815 if (index == static_cast<unsigned int>(
myWAUTs[wautid]->switches.size())) {
828 switchTo((*i).to->getID(), (*i).to->getProgramID());
837 std::pair<SUMOTime, MSPhaseDefinition>
bool checkOriginalTLS() const
Verifies traffic lights loaded from the network.
TLSLogicVariants()
Constructor.
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.
bool isActive(const MSTrafficLightLogic *tl) const
Returns whether the given tls program is the currently active for his tls.
~WAUTSwitchProcedure_GSP()
Destructor.
virtual const MSPhaseDefinition & getCurrentPhaseDef() const =0
Returns the definition of the current phase.
void cutLogic(SUMOTime step, SUMOTime startPos, SUMOTime allCutTime)
Cuts the logic to synchronize.
std::map< MSLink *, LinkState > myOriginalLinkStates
Originally loaded link states.
const std::string & getState() const
Returns the state within this phase.
bool setTrafficLightSignals(SUMOTime t) const
Applies the current signal states to controlled links.
SUMOReal end
The end of a stretch/cut area (time, in s)
std::map< std::string, TLSLogicVariants * > myLogics
A map from ids to the corresponding variants.
unsigned int getGSPValue(const MSTrafficLightLogic &logic) const
Returns the GSP-value.
Storage for all programs of a single tls.
Base class for things to execute if a tls switches to a new phase.
~TLSLogicVariants()
Destructor.
void switchTo(const std::string &id, const std::string &programID)
Switches the named (id) tls to the named (programID) program.
static SUMOReal _2SUMOReal(const E *const data)
std::map< std::string, MSTrafficLightLogic * > myVariants
A map of subkeys to programs.
~WAUTSwitchProcedure_Stretch()
Destructor.
~WAUTSwitchProcedure_JustSwitch()
Destructor.
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.
void setTrafficLightSignals(SUMOTime t) const
Lets all running (current) tls programs apply their current signal states to links they control...
A definition of a stretch - Bereich.
MSTrafficLightLogic * getActive(const std::string &id) const
Returns the active program of a named tls.
virtual const MSPhaseDefinition & getPhase(int givenstep) const =0
Returns the definition of the phase from the given position within the plan.
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.
std::vector< std::string > getAllTLIds() const
virtual SUMOTime getOffsetFromIndex(unsigned int index) const =0
Returns the position (start of a phase during a cycle) from of a given step.
virtual int getCurrentPhaseIndex() const =0
Returns the current index within the program.
void addLink(MSLink *link, MSLane *lane, int pos)
MSTLLogicControl()
Constructor.
const std::string & getParameter(const std::string &key, const std::string &defaultValue) const
Returns the value for a given key.
SUMOTime getCurrentTimeStep() const
Returns the current simulation step.
WAUT & myWAUT
The WAUT responsible for switching.
void closeWAUT(const std::string &wautid)
Closes loading of a WAUT.
MSTrafficLightLogic * getLogic(const std::string &programID) const
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.
virtual void changeStepAndDuration(MSTLLogicControl &tlcontrol, SUMOTime simStep, unsigned int step, SUMOTime stepDuration)=0
Changes the current phase and her duration.
SUMOTime getNextSwitchTime() const
Returns the assumed next switch time.
A class that stores and controls tls and switching of their programs.
std::vector< MSTrafficLightLogic * > getAllLogics() const
bool mySwitchSynchron
Information whether to switch synchron (?)
const std::string & getID() const
Returns the id.
MSTLLogicControl & myControl
The control the logic belongs to.
SUMOTime duration
The duration of the phase.
bool addLogic(const std::string &programID, MSTrafficLightLogic *logic, bool netWasLoaded, bool isNewDefault=true)
Adds a logic (program)
void addSwitchCommand(OnSwitchAction *c)
MSTrafficLightLogic * getLogicInstantiatingOff(MSTLLogicControl &tlc, const std::string &programID)
bool isActive(const MSTrafficLightLogic *tl) const
virtual unsigned int getIndexFromOffset(SUMOTime offset) const =0
Returns the step (the phasenumber) of a given position of the cycle.
MSTrafficLightLogic * getActive() const
std::pair< SUMOTime, MSPhaseDefinition > getPhaseDef(const std::string &tlid) const
return the complete phase definition for a named traffic lights logic
WAUTSwitchProcedure * proc
The used procedure.
void adaptLogic(SUMOTime step)
Stretches the destination program's phase to which the tls was switched.
SUMOReal fac
The weight factor of a stretch/cut area.
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.
const LinkVectorVector & getLinks() const
Returns the list of lists of all affected links.
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 adaptLinkInformationFrom(const MSTrafficLightLogic &logic)
Applies information about controlled links and lanes from the given logic.
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.
SUMOTime when
The time the WAUT shall switch the TLS.
void stretchLogic(SUMOTime step, SUMOTime startPos, SUMOTime allStretchTime)
Stretches the logic to synchronize.
SUMOReal begin
The begin of a stretch/cut area (time, in s)
std::vector< OnSwitchAction * > mySwitchActions
The list of actions/commands to execute on switch.
std::string toString(const T &t, std::streamsize accuracy=OUTPUT_ACCURACY)
void setStateInstantiatingOnline(MSTLLogicControl &tlc, const std::string &state)
bool knows(const std::string &id) const
Returns the information whether the named tls is stored.
bool trySwitch(SUMOTime step)
Determines whether a switch is possible.
std::string startProg
The name of the start program.
virtual SUMOTime addEvent(Command *operation, SUMOTime execTimeStep, AdaptType type)
Adds an Event.
const std::string & getWAUTID() const
Returns the WAUT-id.
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.
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.
void addOverridingDuration(SUMOTime duration)
Changes the duration of the next phase.
An initialised switch process.
void switchTo(MSTLLogicControl &tlc, const std::string &programID)
StretchBereichDef getStretchBereichDef(MSTrafficLightLogic *from, int index) const
Returns the numbered Stretch-area for the given program.
static int _2int(const E *const data)
std::vector< WAUTSwitch > switches
The list of switches to be done by the WAUT.
unsigned int & getIndex()
Returns a reference to the index.
void switchToPos(SUMOTime simStep, MSTrafficLightLogic &logic, SUMOTime toTime)
switches the given logic directly to the given position
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.
void executeOnSwitchActions() const
std::string id
The id of the WAUT.
TLSLogicVariants & get(const std::string &id) const
Returns the variants of a named tls.
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.
std::vector< MSTrafficLightLogic * > getAllLogics() const
Returns a vector which contains all logics.
MSTrafficLightLogic * from
The current program of the tls.
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.
std::map< MSLink *, LinkState > collectLinkStates() const
Returns the (uncontrolled) states of the controlled links.
MSTrafficLightLogic * myCurrentProgram
The currently used program.
SUMOTime getDefaultCycleTime() const
Returns the cycle time (in ms)
std::string junction
The junction name.