bool RODFNet::isFalseSource(const RODFDetector& det, ROEdge* edge, std::vector<ROEdge*>& seen, const RODFDetectorCon& detectors) const { if (seen.size() == 1000) { // !!! WRITE_WARNING("Quitting checking for being a false source for detector '" + det.getID() + "' due to seen edge limit."); return false; } seen.push_back(edge); if (edge != getDetectorEdge(det)) { // ok, we are at one of the edges coming behind if (hasDetector(edge)) { const std::vector<std::string>& dets = myDetectorsOnEdges.find(edge)->second; for (std::vector<std::string>::const_iterator i = dets.begin(); i != dets.end(); ++i) { if (detectors.getDetector(*i).getType() == SINK_DETECTOR) { return false; } if (detectors.getDetector(*i).getType() == BETWEEN_DETECTOR) { return false; } if (detectors.getDetector(*i).getType() == SOURCE_DETECTOR) { return true; } } } else { if (myAmInHighwayMode && edge->getSpeed() < 19.) { return false; } } } if (myApproachedEdges.find(edge) == myApproachedEdges.end()) { return false; } const std::vector<ROEdge*>& appr = myApproachedEdges.find(edge)->second; bool isall = false; for (size_t i = 0; i < appr.size() && !isall; i++) { //printf("checking %s->\n", appr[i].c_str()); bool had = std::find(seen.begin(), seen.end(), appr[i]) != seen.end(); if (!had) { if (isFalseSource(det, appr[i], seen, detectors)) { isall = true; } } } return isall; }
void RODFNet::buildDetectorDependencies(RODFDetectorCon& detectors) { // !!! this will not work when several detectors are lying on the same edge on different positions buildDetectorEdgeDependencies(detectors); // for each detector, compute the lists of predecessor and following detectors std::map<std::string, ROEdge*>::const_iterator i; for (i = myDetectorEdges.begin(); i != myDetectorEdges.end(); ++i) { const RODFDetector& det = detectors.getDetector((*i).first); if (!det.hasRoutes()) { continue; } // mark current detectors std::vector<RODFDetector*> last; { const std::vector<std::string>& detNames = myDetectorsOnEdges.find((*i).second)->second; for (std::vector<std::string>::const_iterator j = detNames.begin(); j != detNames.end(); ++j) { last.push_back((RODFDetector*) &detectors.getDetector(*j)); } } // iterate over the current detector's routes const std::vector<RODFRouteDesc>& routes = det.getRouteVector(); for (std::vector<RODFRouteDesc>::const_iterator j = routes.begin(); j != routes.end(); ++j) { const std::vector<ROEdge*>& edges2Pass = (*j).edges2Pass; for (std::vector<ROEdge*>::const_iterator k = edges2Pass.begin() + 1; k != edges2Pass.end(); ++k) { if (myDetectorsOnEdges.find(*k) != myDetectorsOnEdges.end()) { const std::vector<std::string>& detNames = myDetectorsOnEdges.find(*k)->second; // ok, consecutive detector found for (std::vector<RODFDetector*>::iterator l = last.begin(); l != last.end(); ++l) { // mark as follower of current for (std::vector<std::string>::const_iterator m = detNames.begin(); m != detNames.end(); ++m) { ((RODFDetector*) &detectors.getDetector(*m))->addPriorDetector((RODFDetector*) & (*l)); (*l)->addFollowingDetector((RODFDetector*) &detectors.getDetector(*m)); } } last.clear(); for (std::vector<std::string>::const_iterator m = detNames.begin(); m != detNames.end(); ++m) { last.push_back((RODFDetector*) &detectors.getDetector(*m)); } } } } } }
void RODFNet::mesoJoin(RODFDetectorCon& detectors, RODFDetectorFlows& flows) { buildDetectorEdgeDependencies(detectors); std::map<ROEdge*, std::vector<std::string>, idComp>::iterator i; for (i = myDetectorsOnEdges.begin(); i != myDetectorsOnEdges.end(); ++i) { const std::vector<std::string>& dets = (*i).second; std::map<SUMOReal, std::vector<std::string> > cliques; // compute detector cliques for (std::vector<std::string>::const_iterator j = dets.begin(); j != dets.end(); ++j) { const RODFDetector& det = detectors.getDetector(*j); bool found = false; for (std::map<SUMOReal, std::vector<std::string> >::iterator k = cliques.begin(); !found && k != cliques.end(); ++k) { if (fabs((*k).first - det.getPos()) < 10.) { (*k).second.push_back(*j); found = true; } } if (!found) { cliques[det.getPos()] = std::vector<std::string>(); cliques[det.getPos()].push_back(*j); } } // join detector cliques for (std::map<SUMOReal, std::vector<std::string> >::iterator m = cliques.begin(); m != cliques.end(); ++m) { std::vector<std::string> clique = (*m).second; // do not join if only one if (clique.size() == 1) { continue; } std::string nid; for (std::vector<std::string>::iterator n = clique.begin(); n != clique.end(); ++n) { std::cout << *n << " "; if (n != clique.begin()) { nid = nid + "_"; } nid = nid + *n; } std::cout << ":" << nid << std::endl; flows.mesoJoin(nid, (*m).second); detectors.mesoJoin(nid, (*m).second); } } }
void RODFNet::removeEmptyDetectors(RODFDetectorCon& detectors, RODFDetectorFlows& flows) { const std::vector<RODFDetector*>& dets = detectors.getDetectors(); for (std::vector<RODFDetector*>::const_iterator i = dets.begin(); i != dets.end();) { bool remove = true; // check whether there is at least one entry with a flow larger than zero if (flows.knows((*i)->getID())) { remove = false; } if (remove) { WRITE_MESSAGE("Removed detector '" + (*i)->getID() + "' because no flows for him exist."); flows.removeFlow((*i)->getID()); detectors.removeDetector((*i)->getID()); i = dets.begin(); } else { i++; } } }
void RODFNet::revalidateFlows(const RODFDetectorCon& detectors, RODFDetectorFlows& flows, SUMOTime startTime, SUMOTime endTime, SUMOTime stepOffset) { const std::vector<RODFDetector*>& dets = detectors.getDetectors(); for (std::vector<RODFDetector*>::const_iterator i = dets.begin(); i != dets.end(); ++i) { // check whether there is at least one entry with a flow larger than zero revalidateFlows(*i, flows, startTime, endTime, stepOffset); } }
void RODFNet::buildDetectorEdgeDependencies(RODFDetectorCon& detcont) const { myDetectorsOnEdges.clear(); myDetectorEdges.clear(); const std::vector<RODFDetector*>& dets = detcont.getDetectors(); for (std::vector<RODFDetector*>::const_iterator i = dets.begin(); i != dets.end(); ++i) { ROEdge* e = getDetectorEdge(**i); myDetectorsOnEdges[e].push_back((*i)->getID()); myDetectorEdges[(*i)->getID()] = e; } }
void RODFDetector::buildDestinationDistribution(const RODFDetectorCon& detectors, SUMOTime startTime, SUMOTime endTime, SUMOTime stepOffset, const RODFNet& net, std::map<SUMOTime, RandomDistributor<int>* >& into) const { if (myRoutes == 0) { if (myType != DISCARDED_DETECTOR && myType != BETWEEN_DETECTOR) { WRITE_ERROR("Missing routes for detector '" + myID + "'."); } return; } std::vector<RODFRouteDesc>& descs = myRoutes->get(); // iterate through time (in output interval steps) for (SUMOTime time = startTime; time < endTime; time += stepOffset) { into[time] = new RandomDistributor<int>(); std::map<ROEdge*, SUMOReal> flowMap; // iterate through the routes int index = 0; for (std::vector<RODFRouteDesc>::iterator ri = descs.begin(); ri != descs.end(); ++ri, index++) { SUMOReal prob = 1.; for (ROEdgeVector::iterator j = (*ri).edges2Pass.begin(); j != (*ri).edges2Pass.end() && prob > 0;) { if (!net.hasDetector(*j)) { ++j; continue; } const RODFDetector& det = detectors.getAnyDetectorForEdge(static_cast<RODFEdge*>(*j)); const std::vector<std::map<RODFEdge*, SUMOReal> >& probs = det.getSplitProbabilities(); if (probs.size() == 0) { prob = 0; ++j; continue; } const std::map<RODFEdge*, SUMOReal>& tprobs = probs[(int)((time - startTime) / stepOffset)]; RODFEdge* splitEdge = 0; for (std::map<RODFEdge*, SUMOReal>::const_iterator k = tprobs.begin(); k != tprobs.end(); ++k) { if (find(j, (*ri).edges2Pass.end(), (*k).first) != (*ri).edges2Pass.end()) { prob *= (*k).second; splitEdge = (*k).first; break; } } if (splitEdge != 0) { j = find(j, (*ri).edges2Pass.end(), splitEdge); } else { ++j; } } into[time]->add(prob, index); (*ri).overallProb = prob; } } }
bool RODFNet::hasSourceDetector(ROEdge* edge, const RODFDetectorCon& detectors) const { assert(myDetectorsOnEdges.find(edge) != myDetectorsOnEdges.end()); const std::vector<std::string>& detIDs = myDetectorsOnEdges.find(edge)->second; std::vector<std::string>::const_iterator i; for (i = detIDs.begin(); i != detIDs.end(); ++i) { const RODFDetector& det = detectors.getDetector(*i); if (det.getType() == SOURCE_DETECTOR) { return true; } } return false; }
void RODFNet::reportEmptyDetectors(RODFDetectorCon& detectors, RODFDetectorFlows& flows) { const std::vector<RODFDetector*>& dets = detectors.getDetectors(); for (std::vector<RODFDetector*>::const_iterator i = dets.begin(); i != dets.end(); ++i) { bool remove = true; // check whether there is at least one entry with a flow larger than zero if (flows.knows((*i)->getID())) { remove = false; } if (remove) { WRITE_MESSAGE("Detector '" + (*i)->getID() + "' has no flow."); } } }
void RODFDetector::computeSplitProbabilities(const RODFNet* net, const RODFDetectorCon& detectors, const RODFDetectorFlows& flows, SUMOTime startTime, SUMOTime endTime, SUMOTime stepOffset) { if (myRoutes == 0) { return; } // compute edges to determine split probabilities const std::vector<RODFRouteDesc>& routes = myRoutes->get(); std::vector<RODFEdge*> nextDetEdges; for (std::vector<RODFRouteDesc>::const_iterator i = routes.begin(); i != routes.end(); ++i) { const RODFRouteDesc& rd = *i; bool hadSplit = false; bool hadDetectorAfterSplit = false; for (std::vector<ROEdge*>::const_iterator j = rd.edges2Pass.begin(); !hadDetectorAfterSplit && j != rd.edges2Pass.end(); ++j) { if (hadSplit && !hadDetectorAfterSplit && net->hasDetector(*j)) { hadDetectorAfterSplit = true; if (find(nextDetEdges.begin(), nextDetEdges.end(), *j) == nextDetEdges.end()) { nextDetEdges.push_back(static_cast<RODFEdge*>(*j)); } myRoute2Edge[rd.routename] = static_cast<RODFEdge*>(*j); } if ((*j)->getNoFollowing() > 1) { hadSplit = true; } } } // compute the probabilities to use a certain direction int index = 0; for (SUMOTime time = startTime; time < endTime; time += stepOffset, ++index) { mySplitProbabilities.push_back(std::map<RODFEdge*, SUMOReal>()); SUMOReal overallProb = 0; // retrieve the probabilities for (std::vector<RODFEdge*>::const_iterator i = nextDetEdges.begin(); i != nextDetEdges.end(); ++i) { SUMOReal flow = detectors.getAggFlowFor(*i, time, 60, flows); overallProb += flow; mySplitProbabilities[index][*i] = flow; } // norm probabilities if (overallProb > 0) { for (std::vector<RODFEdge*>::const_iterator i = nextDetEdges.begin(); i != nextDetEdges.end(); ++i) { mySplitProbabilities[index][*i] = mySplitProbabilities[index][*i] / overallProb; } } } }
void RODFNet::computeTypes(RODFDetectorCon& detcont, bool sourcesStrict) const { PROGRESS_BEGIN_MESSAGE("Computing detector types"); const std::vector< RODFDetector*>& dets = detcont.getDetectors(); // build needed information. first buildDetectorEdgeDependencies(detcont); // compute detector types then for (std::vector< RODFDetector*>::const_iterator i = dets.begin(); i != dets.end(); ++i) { if (isSource(**i, detcont, sourcesStrict)) { (*i)->setType(SOURCE_DETECTOR); mySourceNumber++; } if (isDestination(**i, detcont)) { (*i)->setType(SINK_DETECTOR); mySinkNumber++; } if ((*i)->getType() == TYPE_NOT_DEFINED) { (*i)->setType(BETWEEN_DETECTOR); myInBetweenNumber++; } } // recheck sources for (std::vector< RODFDetector*>::const_iterator i = dets.begin(); i != dets.end(); ++i) { if ((*i)->getType() == SOURCE_DETECTOR && isFalseSource(**i, detcont)) { (*i)->setType(DISCARDED_DETECTOR); myInvalidNumber++; mySourceNumber--; } } // print results PROGRESS_DONE_MESSAGE(); WRITE_MESSAGE("Computed detector types:"); WRITE_MESSAGE(" " + toString(mySourceNumber) + " source detectors"); WRITE_MESSAGE(" " + toString(mySinkNumber) + " sink detectors"); WRITE_MESSAGE(" " + toString(myInBetweenNumber) + " in-between detectors"); WRITE_MESSAGE(" " + toString(myInvalidNumber) + " invalid detectors"); }
/* ------------------------------------------------------------------------- * data processing methods * ----------------------------------------------------------------------- */ void readDetectors(RODFDetectorCon& detectors, OptionsCont& oc, RODFNet* optNet) { if (!oc.isSet("detector-files")) { throw ProcessError("No detector file given (use --detector-files <FILE>)."); } // read definitions stored in XML-format std::vector<std::string> files = oc.getStringVector("detector-files"); for (std::vector<std::string>::const_iterator fileIt = files.begin(); fileIt != files.end(); ++fileIt) { if (!FileHelpers::exists(*fileIt)) { throw ProcessError("Could not open detector file '" + *fileIt + "'"); } PROGRESS_BEGIN_MESSAGE("Loading detector definitions from '" + *fileIt + "'"); RODFDetectorHandler handler(optNet, oc.getBool("ignore-invalid-detectors"), detectors, *fileIt); if (XMLSubSys::runParser(handler, *fileIt)) { PROGRESS_DONE_MESSAGE(); } else { PROGRESS_FAILED_MESSAGE(); throw ProcessError(); } } if (detectors.getDetectors().empty()) { throw ProcessError("No detectors found."); } }
bool RODFNet::isDestination(const RODFDetector& det, ROEdge* edge, std::vector<ROEdge*>& seen, const RODFDetectorCon& detectors) const { if (seen.size() == 1000) { // !!! WRITE_WARNING("Quitting checking for being a destination for detector '" + det.getID() + "' due to seen edge limit."); return false; } if (edge == getDetectorEdge(det)) { // maybe there is another detector at the same edge // get the list of this/these detector(s) const std::vector<std::string>& detsOnEdge = myDetectorsOnEdges.find(edge)->second; for (std::vector<std::string>::const_iterator i = detsOnEdge.begin(); i != detsOnEdge.end(); ++i) { if ((*i) == det.getID()) { continue; } const RODFDetector& sec = detectors.getDetector(*i); if (getAbsPos(sec) > getAbsPos(det)) { // ok, there is another detector on the same edge and it is // after this one -> no destination return false; } } } if (!hasApproached(edge)) { if (edge != getDetectorEdge(det)) { if (hasDetector(edge)) { return false; } } return true; } if (edge != getDetectorEdge(det)) { // ok, we are at one of the edges coming behind if (myAmInHighwayMode) { if (edge->getSpeed() >= 19.4) { if (hasDetector(edge)) { // we are still on the highway and there is another detector return false; } } } } if (myAmInHighwayMode) { if (edge->getSpeed() < 19.4 && edge != getDetectorEdge(det)) { if (hasDetector(edge)) { return true; } if (myApproachedEdges.find(edge)->second.size() > 1) { return true; } } } if (myDetectorsOnEdges.find(edge) != myDetectorsOnEdges.end() && myDetectorEdges.find(det.getID())->second != edge) { return false; } const std::vector<ROEdge*>& appr = myApproachedEdges.find(edge)->second; bool isall = true; size_t no = 0; seen.push_back(edge); for (size_t i = 0; i < appr.size() && isall; i++) { bool had = std::find(seen.begin(), seen.end(), appr[i]) != seen.end(); if (!had) { if (!isDestination(det, appr[i], seen, detectors)) { no++; isall = false; } } } return isall; }
bool RODFNet::isSource(const RODFDetector& det, ROEdge* edge, std::vector<ROEdge*>& seen, const RODFDetectorCon& detectors, bool strict) const { if (seen.size() == 1000) { // !!! WRITE_WARNING("Quitting checking for being a source for detector '" + det.getID() + "' due to seen edge limit."); return false; } if (edge == getDetectorEdge(det)) { // maybe there is another detector at the same edge // get the list of this/these detector(s) const std::vector<std::string>& detsOnEdge = myDetectorsOnEdges.find(edge)->second; for (std::vector<std::string>::const_iterator i = detsOnEdge.begin(); i != detsOnEdge.end(); ++i) { if ((*i) == det.getID()) { continue; } const RODFDetector& sec = detectors.getDetector(*i); if (getAbsPos(sec) < getAbsPos(det)) { // ok, there is another detector on the same edge and it is // before this one -> no source return false; } } } // it's a source if no edges are approaching the edge if (!hasApproaching(edge)) { if (edge != getDetectorEdge(det)) { if (hasDetector(edge)) { return false; } } return true; } if (edge != getDetectorEdge(det)) { // ok, we are at one of the edges in front if (myAmInHighwayMode) { if (edge->getSpeed() >= 19.4) { if (hasDetector(edge)) { // we are still on the highway and there is another detector return false; } // the next is a hack for the A100 scenario... // We have to look into further edges herein edges const std::vector<ROEdge*>& appr = myApproachingEdges.find(edge)->second; size_t noOk = 0; size_t noFalse = 0; size_t noSkipped = 0; for (size_t i = 0; i < appr.size(); i++) { if (!hasDetector(appr[i])) { noOk++; } else { noFalse++; } } if ((noFalse + noSkipped) == appr.size()) { return false; } } } } if (myAmInHighwayMode) { if (edge->getSpeed() < 19.4 && edge != getDetectorEdge(det)) { // we have left the highway already // -> the detector will be a highway source if (!hasDetector(edge)) { return true; } } } if (myDetectorsOnEdges.find(edge) != myDetectorsOnEdges.end() && myDetectorEdges.find(det.getID())->second != edge) { return false; } // let's check the edges in front const std::vector<ROEdge*>& appr = myApproachingEdges.find(edge)->second; size_t noOk = 0; size_t noFalse = 0; size_t noSkipped = 0; seen.push_back(edge); for (size_t i = 0; i < appr.size(); i++) { bool had = std::find(seen.begin(), seen.end(), appr[i]) != seen.end(); if (!had) { if (isSource(det, appr[i], seen, detectors, strict)) { noOk++; } else { noFalse++; } } else { noSkipped++; } } if (!strict) { return (noFalse + noSkipped) != appr.size(); } else { return (noOk + noSkipped) == appr.size(); } }
void RODFDetector::computeSplitProbabilities(const RODFNet* net, const RODFDetectorCon& detectors, const RODFDetectorFlows& flows, SUMOTime startTime, SUMOTime endTime, SUMOTime stepOffset) { if (myRoutes == 0) { return; } // compute edges to determine split probabilities const std::vector<RODFRouteDesc>& routes = myRoutes->get(); std::vector<RODFEdge*> nextDetEdges; std::set<ROEdge*> preSplitEdges; for (std::vector<RODFRouteDesc>::const_iterator i = routes.begin(); i != routes.end(); ++i) { const RODFRouteDesc& rd = *i; bool hadSplit = false; for (ROEdgeVector::const_iterator j = rd.edges2Pass.begin(); j != rd.edges2Pass.end(); ++j) { if (hadSplit && net->hasDetector(*j)) { if (find(nextDetEdges.begin(), nextDetEdges.end(), *j) == nextDetEdges.end()) { nextDetEdges.push_back(static_cast<RODFEdge*>(*j)); } myRoute2Edge[rd.routename] = static_cast<RODFEdge*>(*j); break; } if (!hadSplit) { preSplitEdges.insert(*j); } if ((*j)->getNumSuccessors() > 1) { hadSplit = true; } } } std::map<ROEdge*, SUMOReal> inFlows; if (OptionsCont::getOptions().getBool("respect-concurrent-inflows")) { for (std::vector<RODFEdge*>::const_iterator i = nextDetEdges.begin(); i != nextDetEdges.end(); ++i) { std::set<ROEdge*> seen(preSplitEdges); ROEdgeVector pending; pending.push_back(*i); seen.insert(*i); while (!pending.empty()) { ROEdge* e = pending.back(); pending.pop_back(); for (ROEdgeVector::const_iterator it = e->getPredecessors().begin(); it != e->getPredecessors().end(); it++) { ROEdge* e2 = *it; if (e2->getNumSuccessors() == 1 && seen.count(e2) == 0) { if (net->hasDetector(e2)) { inFlows[*i] += detectors.getAggFlowFor(e2, 0, 0, flows); } else { pending.push_back(e2); } seen.insert(e2); } } } } } // compute the probabilities to use a certain direction int index = 0; for (SUMOTime time = startTime; time < endTime; time += stepOffset, ++index) { mySplitProbabilities.push_back(std::map<RODFEdge*, SUMOReal>()); SUMOReal overallProb = 0; // retrieve the probabilities for (std::vector<RODFEdge*>::const_iterator i = nextDetEdges.begin(); i != nextDetEdges.end(); ++i) { SUMOReal flow = detectors.getAggFlowFor(*i, time, 60, flows) - inFlows[*i]; overallProb += flow; mySplitProbabilities[index][*i] = flow; } // norm probabilities if (overallProb > 0) { for (std::vector<RODFEdge*>::const_iterator i = nextDetEdges.begin(); i != nextDetEdges.end(); ++i) { mySplitProbabilities[index][*i] = mySplitProbabilities[index][*i] / overallProb; } } } }
void RODFNet::buildEdgeFlowMap(const RODFDetectorFlows& flows, const RODFDetectorCon& detectors, SUMOTime startTime, SUMOTime endTime, SUMOTime stepOffset) { std::map<ROEdge*, std::vector<std::string>, idComp>::iterator i; for (i = myDetectorsOnEdges.begin(); i != myDetectorsOnEdges.end(); ++i) { ROEdge* into = (*i).first; const std::vector<std::string>& dets = (*i).second; std::map<SUMOReal, std::vector<std::string> > cliques; std::vector<std::string>* maxClique = 0; for (std::vector<std::string>::const_iterator j = dets.begin(); j != dets.end(); ++j) { if (!flows.knows(*j)) { continue; } const RODFDetector& det = detectors.getDetector(*j); bool found = false; for (std::map<SUMOReal, std::vector<std::string> >::iterator k = cliques.begin(); !found && k != cliques.end(); ++k) { if (fabs((*k).first - det.getPos()) < 1) { (*k).second.push_back(*j); if ((*k).second.size() > maxClique->size()) { maxClique = &(*k).second; } found = true; } } if (!found) { cliques[det.getPos()].push_back(*j); maxClique = &cliques[det.getPos()]; } } if (maxClique == 0) { continue; } std::vector<FlowDef> mflows; // !!! reserve for (SUMOTime t = startTime; t < endTime; t += stepOffset) { FlowDef fd; fd.qPKW = 0; fd.qLKW = 0; fd.vLKW = 0; fd.vPKW = 0; fd.fLKW = 0; fd.isLKW = 0; mflows.push_back(fd); } for (std::vector<std::string>::iterator l = maxClique->begin(); l != maxClique->end(); ++l) { bool didWarn = false; const std::vector<FlowDef>& dflows = flows.getFlowDefs(*l); int index = 0; for (SUMOTime t = startTime; t < endTime; t += stepOffset, index++) { const FlowDef& srcFD = dflows[index]; FlowDef& fd = mflows[index]; fd.qPKW += srcFD.qPKW; fd.qLKW += srcFD.qLKW; fd.vLKW += (srcFD.vLKW / (SUMOReal) maxClique->size()); fd.vPKW += (srcFD.vPKW / (SUMOReal) maxClique->size()); fd.fLKW += (srcFD.fLKW / (SUMOReal) maxClique->size()); fd.isLKW += (srcFD.isLKW / (SUMOReal) maxClique->size()); if (!didWarn && srcFD.vPKW > 0 && srcFD.vPKW < 255 && srcFD.vPKW / 3.6 > into->getSpeed()) { WRITE_MESSAGE("Detected PKW speed higher than allowed speed at '" + (*l) + "' on '" + into->getID() + "'."); didWarn = true; } if (!didWarn && srcFD.vLKW > 0 && srcFD.vLKW < 255 && srcFD.vLKW / 3.6 > into->getSpeed()) { WRITE_MESSAGE("Detected LKW speed higher than allowed speed at '" + (*l) + "' on '" + into->getID() + "'."); didWarn = true; } } } static_cast<RODFEdge*>(into)->setFlows(mflows); } }
void RODFNet::buildRoutes(RODFDetectorCon& detcont, bool allEndFollower, bool keepUnfoundEnds, bool includeInBetween, bool keepShortestOnly, int maxFollowingLength) const { // build needed information first buildDetectorEdgeDependencies(detcont); // then build the routes std::map<ROEdge*, RODFRouteCont* > doneEdges; const std::vector< RODFDetector*>& dets = detcont.getDetectors(); for (std::vector< RODFDetector*>::const_iterator i = dets.begin(); i != dets.end(); ++i) { ROEdge* e = getDetectorEdge(**i); if (doneEdges.find(e) != doneEdges.end()) { // use previously build routes (*i)->addRoutes(new RODFRouteCont(*doneEdges[e])); continue; } std::vector<ROEdge*> seen; RODFRouteCont* routes = new RODFRouteCont(); doneEdges[e] = routes; RODFRouteDesc rd; rd.edges2Pass.push_back(e); rd.duration_2 = (e->getLength() / e->getSpeed()); //!!!; rd.endDetectorEdge = 0; rd.lastDetectorEdge = 0; rd.distance = e->getLength(); rd.distance2Last = 0; rd.duration2Last = 0; rd.overallProb = 0; std::vector<ROEdge*> visited; visited.push_back(e); computeRoutesFor(e, rd, 0, keepUnfoundEnds, keepShortestOnly, visited, **i, *routes, detcont, maxFollowingLength, seen); if (allEndFollower) { routes->addAllEndFollower(); } //!!!routes->removeIllegal(illegals); (*i)->addRoutes(routes); // add routes to in-between detectors if wished if (includeInBetween) { // go through the routes const std::vector<RODFRouteDesc>& r = routes->get(); for (std::vector<RODFRouteDesc>::const_iterator j = r.begin(); j != r.end(); ++j) { const RODFRouteDesc& mrd = *j; SUMOReal duration = mrd.duration_2; SUMOReal distance = mrd.distance; // go through each route's edges std::vector<ROEdge*>::const_iterator routeend = mrd.edges2Pass.end(); for (std::vector<ROEdge*>::const_iterator k = mrd.edges2Pass.begin(); k != routeend; ++k) { // check whether any detectors lies on the current edge if (myDetectorsOnEdges.find(*k) == myDetectorsOnEdges.end()) { duration -= (*k)->getLength() / (*k)->getSpeed(); distance -= (*k)->getLength(); continue; } // get the detectors const std::vector<std::string>& dets = myDetectorsOnEdges.find(*k)->second; // go through the detectors for (std::vector<std::string>::const_iterator l = dets.begin(); l != dets.end(); ++l) { const RODFDetector& m = detcont.getDetector(*l); if (m.getType() == BETWEEN_DETECTOR) { RODFRouteDesc nrd; copy(k, routeend, back_inserter(nrd.edges2Pass)); nrd.duration_2 = duration;//!!!; nrd.endDetectorEdge = mrd.endDetectorEdge; nrd.lastDetectorEdge = mrd.lastDetectorEdge; nrd.distance = distance; nrd.distance2Last = mrd.distance2Last; nrd.duration2Last = mrd.duration2Last; nrd.overallProb = mrd.overallProb; nrd.factor = mrd.factor; ((RODFDetector&) m).addRoute(nrd); } } duration -= (*k)->getLength() / (*k)->getSpeed(); distance -= (*k)->getLength(); } } } } }
void startComputation(RODFNet* optNet, RODFDetectorFlows& flows, RODFDetectorCon& detectors, OptionsCont& oc) { if (oc.getBool("print-absolute-flows")) { flows.printAbsolute(); } // if a network was loaded... (mode1) if (optNet != 0) { if (oc.getBool("remove-empty-detectors")) { PROGRESS_BEGIN_MESSAGE("Removing empty detectors"); optNet->removeEmptyDetectors(detectors, flows); PROGRESS_DONE_MESSAGE(); } else if (oc.getBool("report-empty-detectors")) { PROGRESS_BEGIN_MESSAGE("Scanning for empty detectors"); optNet->reportEmptyDetectors(detectors, flows); PROGRESS_DONE_MESSAGE(); } // compute the detector types (optionally) if (!detectors.detectorsHaveCompleteTypes() || oc.getBool("revalidate-detectors")) { optNet->computeTypes(detectors, oc.getBool("strict-sources")); } std::vector<RODFDetector*>::const_iterator i = detectors.getDetectors().begin(); for (; i != detectors.getDetectors().end(); ++i) { if ((*i)->getType() == SOURCE_DETECTOR) { break; } } if (i == detectors.getDetectors().end() && !oc.getBool("routes-for-all")) { throw ProcessError("No source detectors found."); } // compute routes between the detectors (optionally) if (!detectors.detectorsHaveRoutes() || oc.getBool("revalidate-routes") || oc.getBool("guess-empty-flows")) { PROGRESS_BEGIN_MESSAGE("Computing routes"); optNet->buildRoutes(detectors, oc.getBool("all-end-follower"), oc.getBool("keep-unfinished-routes"), oc.getBool("routes-for-all"), !oc.getBool("keep-longer-routes"), oc.getInt("max-search-depth")); PROGRESS_DONE_MESSAGE(); } } // check // whether the detectors are valid if (!detectors.detectorsHaveCompleteTypes()) { throw ProcessError("The detector types are not defined; use in combination with a network"); } // whether the detectors have routes if (!detectors.detectorsHaveRoutes()) { throw ProcessError("The emitters have no routes; use in combination with a network"); } // save the detectors if wished if (oc.isSet("detector-output")) { detectors.save(oc.getString("detector-output")); } // save their positions as POIs if wished if (oc.isSet("detectors-poi-output")) { detectors.saveAsPOIs(oc.getString("detectors-poi-output")); } // save the routes file if it was changed or it's wished if (detectors.detectorsHaveRoutes() && oc.isSet("routes-output")) { detectors.saveRoutes(oc.getString("routes-output")); } // guess flows if wished if (oc.getBool("guess-empty-flows")) { optNet->buildDetectorDependencies(detectors); detectors.guessEmptyFlows(flows); } const SUMOTime begin = string2time(oc.getString("begin")); const SUMOTime end = string2time(oc.getString("end")); const SUMOTime step = string2time(oc.getString("time-step")); // save emitters if wished if (oc.isSet("emitters-output") || oc.isSet("emitters-poi-output")) { optNet->buildEdgeFlowMap(flows, detectors, begin, end, step); // !!! if (oc.getBool("revalidate-flows")) { PROGRESS_BEGIN_MESSAGE("Rechecking loaded flows"); optNet->revalidateFlows(detectors, flows, begin, end, step); PROGRESS_DONE_MESSAGE(); } if (oc.isSet("emitters-output")) { PROGRESS_BEGIN_MESSAGE("Writing emitters"); detectors.writeEmitters(oc.getString("emitters-output"), flows, begin, end, step, *optNet, oc.getBool("calibrator-output"), oc.getBool("include-unused-routes"), oc.getFloat("scale"), // oc.getInt("max-search-depth"), oc.getBool("emissions-only")); PROGRESS_DONE_MESSAGE(); } if (oc.isSet("emitters-poi-output")) { PROGRESS_BEGIN_MESSAGE("Writing emitter pois"); detectors.writeEmitterPOIs(oc.getString("emitters-poi-output"), flows); PROGRESS_DONE_MESSAGE(); } } // save end speed trigger if wished if (oc.isSet("variable-speed-sign-output")) { PROGRESS_BEGIN_MESSAGE("Writing speed triggers"); detectors.writeSpeedTrigger(optNet, oc.getString("variable-speed-sign-output"), flows, begin, end, step); PROGRESS_DONE_MESSAGE(); } // save checking detectors if wished if (oc.isSet("validation-output")) { PROGRESS_BEGIN_MESSAGE("Writing validation detectors"); detectors.writeValidationDetectors(oc.getString("validation-output"), oc.getBool("validation-output.add-sources"), true, true); // !!! PROGRESS_DONE_MESSAGE(); } // build global rerouter on end if wished if (oc.isSet("end-reroute-output")) { PROGRESS_BEGIN_MESSAGE("Writing highway end rerouter"); detectors.writeEndRerouterDetectors(oc.getString("end-reroute-output")); // !!! PROGRESS_DONE_MESSAGE(); } /* // save the insertion definitions if(oc.isSet("flow-definitions")) { buildVehicleEmissions(oc.getString("flow-definitions")); } */ // }