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));
}
}
}
}
}
}
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::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::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);
}
}
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
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();
}
}
}
}
}