double
MSActuatedTrafficLightLogic::gapControl() {
//intergreen times should not be lenghtend
assert((int)myPhases.size() > myStep);
double result = std::numeric_limits<double>::max();
if (!getCurrentPhaseDef().isGreenPhase()) {
return result; // end current phase
}
// Checks, if the maxDuration is kept. No phase should longer send than maxDuration.
SUMOTime actDuration = MSNet::getInstance()->getCurrentTimeStep() - myPhases[myStep]->myLastSwitch;
if (actDuration >= getCurrentPhaseDef().maxDuration) {
return result; // end current phase
}
// now the gapcontrol starts
const std::string& state = getCurrentPhaseDef().getState();
for (int i = 0; i < (int) state.size(); i++) {
if (state[i] == LINKSTATE_TL_GREEN_MAJOR || state[i] == LINKSTATE_TL_GREEN_MINOR) {
const std::vector<MSLane*>& lanes = getLanesAt(i);
for (LaneVector::const_iterator j = lanes.begin(); j != lanes.end(); j++) {
if (myInductLoops.find(*j) == myInductLoops.end()) {
continue;
}
if (!MSGlobals::gUseMesoSim) { // why not check outside the loop? (Leo)
const double actualGap = static_cast<MSInductLoop*>(myInductLoops.find(*j)->second)->getTimeSinceLastDetection();
if (actualGap < myMaxGap) {
result = MIN2(result, actualGap);
}
}
}
}
}
return result;
}
// ------------ "actuated" algorithm methods
SUMOTime
MSActuatedTrafficLightLogic::duration(const double detectionGap) const {
assert(getCurrentPhaseDef().isGreenPhase());
assert((int)myPhases.size() > myStep);
const SUMOTime actDuration = MSNet::getInstance()->getCurrentTimeStep() - myPhases[myStep]->myLastSwitch;
// ensure that minimum duration is kept
SUMOTime newDuration = getCurrentPhaseDef().minDuration - actDuration;
// try to let the last detected vehicle pass the intersection (duration must be positive)
newDuration = MAX3(newDuration, TIME2STEPS(myDetectorGap - detectionGap), SUMOTime(1));
// cut the decimal places to ensure that phases always have integer duration
if (newDuration % 1000 != 0) {
const SUMOTime totalDur = newDuration + actDuration;
newDuration = (totalDur / 1000 + 1) * 1000 - actDuration;
}
// ensure that the maximum duration is not exceeded
newDuration = MIN2(newDuration, getCurrentPhaseDef().maxDuration - actDuration);
return newDuration;
}
// ------------ Switching and setting current rows
SUMOTime
MSAgentbasedTrafficLightLogic::trySwitch(bool) throw() {
assert(getCurrentPhaseDef().minDuration >=0);
assert(getCurrentPhaseDef().minDuration <= getCurrentPhaseDef().duration);
if (myPhases[myStep]->isGreenPhase()) {
// collects the data for the signal control
collectData();
// decides wheter greentime shall distributed between phases
if (tDecide <= tSinceLastDecision) {
calculateDuration();
}
}
// increment the index to the current phase
nextStep();
// set the next event
while (getCurrentPhaseDef().duration==0) {
nextStep();
}
assert(myPhases.size()>myStep);
return getCurrentPhaseDef().duration;
}
bool
MSTrafficLightLogic::setTrafficLightSignals(SUMOTime t) const {
// get the current traffic light signal combination
const std::string& state = getCurrentPhaseDef().getState();
// go through the links
for (size_t i = 0; i < myLinks.size(); i++) {
const LinkVector& currGroup = myLinks[i];
LinkState ls = (LinkState) state[i];
for (LinkVector::const_iterator j = currGroup.begin(); j != currGroup.end(); j++) {
(*j)->setTLState(ls, t);
}
}
return true;
}
void
MSAgentbasedTrafficLightLogic::collectData() throw() {
//collects the traffic data
// gets a copy of the driveMask
const std::string &state = getCurrentPhaseDef().getState();
// finds the maximum QUEUE_LENGTH_AHEAD_OF_TRAFFIC_LIGHTS_IN_VEHICLES of one phase
SUMOReal maxPerPhase = 0;
for (unsigned int i=0; i<(unsigned int) state.size(); i++) {
/* finds the maximum QUEUE_LENGTH_AHEAD_OF_TRAFFIC_LIGHTS_IN_VEHICLES
of all lanes of a bit of the drivemask, that shows green */
if (state[i]==MSLink::LINKSTATE_TL_GREEN_MAJOR||state[i]==MSLink::LINKSTATE_TL_GREEN_MINOR) {
const std::vector<MSLane*> &lanes = getLanesAt(i);
if (lanes.empty()) {
break;
}
SUMOReal maxPerBit = 0;
for (LaneVector::const_iterator j=lanes.begin(); j!=lanes.end(); j++) {
if ((*j)->getEdge().getPurpose()==MSEdge::EDGEFUNCTION_INTERNAL) {
continue;
}
/*!!!
SUMOReal tmp = currentForLane(E2::QUEUE_LENGTH_AHEAD_OF_TRAFFIC_LIGHTS_IN_VEHICLES, *j);
if (maxPerBit < tmp) {
maxPerBit = tmp;
}
E2DetectorMap::const_iterator it=myE2Detectors.find(*j);
(*it).second->resetQueueLengthAheadOfTrafficLights();
*/
}
if (maxPerPhase < maxPerBit) {
maxPerPhase = maxPerBit;
}
}
}
// if still no entry for the phase exists a new entry with an empty value is created
if (myRawDetectorData.find(myStep) == myRawDetectorData.end()) {
ValueType firstData;
myRawDetectorData[myStep] = firstData;
}
/* checks whether the number of values that are already in the dataqueue is
the same number of values taht shall be consideres in the traffic control
if both numbers are the same, the oldest value is deleted */
if (myRawDetectorData[myStep].size()== numberOfValues) {
myRawDetectorData[myStep].pop_back();
}
// adds the detectorvalue of the considered phase
myRawDetectorData[myStep].push_front(maxPerPhase);
}
// ----------- Handling of controlled links
void
MSTrafficLightLogic::addLink(MSLink* link, MSLane* lane, unsigned int pos) {
// !!! should be done within the loader (checking necessary)
myLinks.reserve(pos + 1);
while (myLinks.size() <= pos) {
myLinks.push_back(LinkVector());
}
myLinks[pos].push_back(link);
//
myLanes.reserve(pos + 1);
while (myLanes.size() <= pos) {
myLanes.push_back(LaneVector());
}
myLanes[pos].push_back(lane);
link->setTLState((LinkState) getCurrentPhaseDef().getState()[pos], MSNet::getInstance()->getCurrentTimeStep());
}
// ------------ Switching and setting current rows
SUMOTime
MSActuatedTrafficLightLogic::trySwitch() {
// checks if the actual phase should be continued
// @note any vehicles which arrived during the previous phases which are now waiting between the detector and the stop line are not
// considere here. RiLSA recommends to set minDuration in a way that lets all vehicles pass the detector
const double detectionGap = gapControl();
if (detectionGap < std::numeric_limits<double>::max()) {
return duration(detectionGap);
}
// increment the index to the current phase
myStep++;
assert(myStep <= (int)myPhases.size());
if (myStep == (int)myPhases.size()) {
myStep = 0;
}
//stores the time the phase started
myPhases[myStep]->myLastSwitch = MSNet::getInstance()->getCurrentTimeStep();
// set the next event
return getCurrentPhaseDef().minDuration;
}
bool MSSOTLPhaseTrafficLightLogic::canRelease() {
if (getCurrentPhaseElapsed() >= getCurrentPhaseDef().minDuration) {
return isThresholdPassed();
}
return false;
}
