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"));
}
*/
//
}
