void
RODFDetectorCon::writeValidationDetectors(const std::string& file,
bool includeSources,
bool singleFile, bool friendly) {
OutputDevice& out = OutputDevice::getDevice(file);
out.writeXMLHeader("additional");
for (std::vector<RODFDetector*>::const_iterator i = myDetectors.begin(); i != myDetectors.end(); ++i) {
RODFDetector* det = *i;
// write the declaration into the file
if (det->getType() != SOURCE_DETECTOR || includeSources) {
SUMOReal pos = det->getPos();
if (det->getType() == SOURCE_DETECTOR) {
pos += 1;
}
out << " <detector id=\"validation_" << StringUtils::escapeXML(det->getID()) << "\" "
<< "lane=\"" << det->getLaneID() << "\" "
<< "pos=\"" << pos << "\" "
<< "freq=\"60\" ";
if (friendly) {
out << "friendlyPos=\"x\" ";
}
if (!singleFile) {
out << "file=\"validation_det_" << StringUtils::escapeXML(det->getID()) << ".xml\"/>\n";
} else {
out << "file=\"validation_dets.xml\"/>\n";//!!!
}
}
}
out.close();
}
void
RODFDetectorCon::writeEmitters(const std::string& file,
const RODFDetectorFlows& flows,
SUMOTime startTime, SUMOTime endTime,
SUMOTime stepOffset, const RODFNet& net,
bool writeCalibrators,
bool includeUnusedRoutes,
SUMOReal scale,
int maxFollower,
bool insertionsOnly) {
// compute turn probabilities at detector
for (std::vector<RODFDetector*>::const_iterator i = myDetectors.begin(); i != myDetectors.end(); ++i) {
(*i)->computeSplitProbabilities(&net, *this, flows, startTime, endTime, stepOffset);
}
//
OutputDevice& out = OutputDevice::getDevice(file);
out.writeXMLHeader("additional");
for (std::vector<RODFDetector*>::const_iterator i = myDetectors.begin(); i != myDetectors.end(); ++i) {
RODFDetector* det = *i;
// get file name for values (emitter/calibrator definition)
std::string escapedID = StringUtils::escapeXML(det->getID());
std::string defFileName;
if (det->getType() == SOURCE_DETECTOR) {
defFileName = file;
} else if (writeCalibrators && det->getType() == BETWEEN_DETECTOR) {
defFileName = FileHelpers::getFilePath(file) + "calibrator_" + escapedID + ".def.xml";
} else {
defFileName = FileHelpers::getFilePath(file) + "other_" + escapedID + ".def.xml";
continue;
}
// try to write the definition
SUMOReal defaultSpeed = net.getEdge(det->getEdgeID())->getSpeed();
// ... compute routes' distribution over time
std::map<size_t, RandomDistributor<size_t>* > dists;
if (!insertionsOnly && flows.knows(det->getID())) {
det->buildDestinationDistribution(*this, flows, startTime, endTime, stepOffset, net, dists, maxFollower);
}
// ... write the definition
if (!det->writeEmitterDefinition(defFileName, dists, flows, startTime, endTime, stepOffset, includeUnusedRoutes, scale, insertionsOnly, defaultSpeed)) {
// skip if something failed... (!!!)
continue;
}
// ... clear temporary values
clearDists(dists);
// write the declaration into the file
if (writeCalibrators && det->getType() == BETWEEN_DETECTOR) {
out << " <calibrator id=\"calibrator_" << escapedID
<< "\" pos=\"" << det->getPos() << "\" "
<< "lane=\"" << det->getLaneID() << "\" "
<< "friendlyPos=\"x\" " // !!!
<< "file=\"" << defFileName << "\"/>\n";
}
}
out.close();
}
void
RODFDetectorCon::writeEmitterPOIs(const std::string& file,
const RODFDetectorFlows& flows) {
OutputDevice& out = OutputDevice::getDevice(file);
out.writeXMLHeader("additional");
for (std::vector<RODFDetector*>::const_iterator i = myDetectors.begin(); i != myDetectors.end(); ++i) {
RODFDetector* det = *i;
SUMOReal flow = flows.getFlowSumSecure(det->getID());
const unsigned char col = static_cast<unsigned char>(128 * flow / flows.getMaxDetectorFlow() + 128);
out.openTag(SUMO_TAG_POI).writeAttr(SUMO_ATTR_ID, StringUtils::escapeXML((*i)->getID()) + ":" + toString(flow));
switch ((*i)->getType()) {
case BETWEEN_DETECTOR:
out.writeAttr(SUMO_ATTR_TYPE, "between_detector_position").writeAttr(SUMO_ATTR_COLOR, RGBColor(0, 0, col, 255));
break;
case SOURCE_DETECTOR:
out.writeAttr(SUMO_ATTR_TYPE, "source_detector_position").writeAttr(SUMO_ATTR_COLOR, RGBColor(0, col, 0, 255));
break;
case SINK_DETECTOR:
out.writeAttr(SUMO_ATTR_TYPE, "sink_detector_position").writeAttr(SUMO_ATTR_COLOR, RGBColor(col, 0, 0, 255));
break;
case DISCARDED_DETECTOR:
out.writeAttr(SUMO_ATTR_TYPE, "discarded_detector_position").writeAttr(SUMO_ATTR_COLOR, RGBColor(51, 51, 51, 255));
break;
default:
throw 1;
}
out.writeAttr(SUMO_ATTR_LANE, (*i)->getLaneID()).writeAttr(SUMO_ATTR_POSITION, (*i)->getPos()).closeTag();
}
out.close();
}
void
RODFDetectorCon::writeEndRerouterDetectors(const std::string& file) {
OutputDevice& out = OutputDevice::getDevice(file);
out.writeXMLHeader("additional");
for (std::vector<RODFDetector*>::const_iterator i = myDetectors.begin(); i != myDetectors.end(); ++i) {
RODFDetector* det = *i;
// write the declaration into the file
if (det->getType() == SINK_DETECTOR) {
out << " <rerouter id=\"endrerouter_" << StringUtils::escapeXML(det->getID())
<< "\" edges=\"" <<
det->getLaneID() << "\" attr=\"reroute\" pos=\"0\" file=\"endrerouter_"
<< det->getID() << ".def.xml\"/>\n";
}
}
out.close();
}
void
RODFDetectorCon::writeEmitterPOIs(const std::string& file,
const RODFDetectorFlows& flows) {
OutputDevice& out = OutputDevice::getDevice(file);
out.writeXMLHeader("additional");
for (std::vector<RODFDetector*>::const_iterator i = myDetectors.begin(); i != myDetectors.end(); ++i) {
RODFDetector* det = *i;
SUMOReal flow = flows.getFlowSumSecure(det->getID());
SUMOReal col = flow / flows.getMaxDetectorFlow();
col = (SUMOReal)(col / 2. + .5);
SUMOReal r, g, b;
r = g = b = 0;
out << " <poi id=\"" << StringUtils::escapeXML((*i)->getID()) << ":" << flow;
switch ((*i)->getType()) {
case BETWEEN_DETECTOR:
out << "\" type=\"between_detector_position\" color=\"0,0," << col << "\"";
break;
case SOURCE_DETECTOR:
out << "\" type=\"source_detector_position\" color=\"0," << col << ",0\"";
break;
case SINK_DETECTOR:
out << "\" type=\"sink_detector_position\" color=\"" << col << ",0,0\"";
break;
case DISCARDED_DETECTOR:
out << "\" type=\"discarded_detector_position\" color=\".2,.2,.2\"";
break;
default:
throw 1;
}
out << " lane=\"" << (*i)->getLaneID() << "\" pos=\"" << (*i)->getPos() << "\"/>\n";
}
out.close();
}
void
RODFDetectorCon::writeSpeedTrigger(const RODFNet* const net,
const std::string& file,
const RODFDetectorFlows& flows,
SUMOTime startTime, SUMOTime endTime,
SUMOTime stepOffset) {
OutputDevice& out = OutputDevice::getDevice(file);
out.writeXMLHeader("additional");
for (std::vector<RODFDetector*>::const_iterator i = myDetectors.begin(); i != myDetectors.end(); ++i) {
RODFDetector* det = *i;
// write the declaration into the file
if (det->getType() == SINK_DETECTOR && flows.knows(det->getID())) {
std::string filename = FileHelpers::getFilePath(file) + "vss_" + det->getID() + ".def.xml";
out.openTag(SUMO_TAG_VSS).writeAttr(SUMO_ATTR_ID, StringUtils::escapeXML(det->getID())).writeAttr(SUMO_ATTR_LANES, det->getLaneID()).writeAttr(SUMO_ATTR_FILE, filename).closeTag();
SUMOReal defaultSpeed = net != 0 ? net->getEdge(det->getEdgeID())->getSpeed() : (SUMOReal) 200.;
det->writeSingleSpeedTrigger(filename, flows, startTime, endTime, stepOffset, defaultSpeed);
}
}
out.close();
}
void
RODFDetectorCon::writeSpeedTrigger(const RODFNet* const net,
const std::string& file,
const RODFDetectorFlows& flows,
SUMOTime startTime, SUMOTime endTime,
SUMOTime stepOffset) {
OutputDevice& out = OutputDevice::getDevice(file);
out.writeXMLHeader("additional");
for (std::vector<RODFDetector*>::const_iterator i = myDetectors.begin(); i != myDetectors.end(); ++i) {
RODFDetector* det = *i;
// write the declaration into the file
if (det->getType() == SINK_DETECTOR && flows.knows(det->getID())) {
std::string filename = FileHelpers::getFilePath(file) + "vss_" + det->getID() + ".def.xml";
out << " <variableSpeedSign id=\"vss_" << StringUtils::escapeXML(det->getID()) << '\"'
<< " lanes=\"" << det->getLaneID() << '\"'
<< " file=\"" << filename << "\"/>\n";
SUMOReal defaultSpeed = net != 0 ? net->getEdge(det->getEdgeID())->getSpeed() : (SUMOReal) 200.;
det->writeSingleSpeedTrigger(filename, flows, startTime, endTime, stepOffset, defaultSpeed);
}
}
out.close();
}
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
RODFDetectorCon::guessEmptyFlows(RODFDetectorFlows& flows) {
// routes must be built (we have ensured this in main)
// detector followers/prior must be build (we have ensured this in main)
//
for (std::vector<RODFDetector*>::const_iterator i = myDetectors.begin(); i != myDetectors.end(); ++i) {
RODFDetector* det = *i;
const std::set<const RODFDetector*>& prior = det->getPriorDetectors();
const std::set<const RODFDetector*>& follower = det->getFollowerDetectors();
int noFollowerWithRoutes = 0;
int noPriorWithRoutes = 0;
// count occurences of detectors with/without routes
std::set<const RODFDetector*>::const_iterator j;
for (j = prior.begin(); j != prior.end(); ++j) {
if (flows.knows((*j)->getID())) {
++noPriorWithRoutes;
}
}
for (j = follower.begin(); j != follower.end(); ++j) {
if (flows.knows((*j)->getID())) {
++noFollowerWithRoutes;
}
}
// do not process detectors which have no routes
if (!flows.knows(det->getID())) {
continue;
}
// plain case: all of the prior detectors have routes
if (noPriorWithRoutes == (int)prior.size()) {
// the number of vehicles is the sum of all vehicles on prior
continue;
}
// plain case: all of the follower detectors have routes
if (noFollowerWithRoutes == (int)follower.size()) {
// the number of vehicles is the sum of all vehicles on follower
continue;
}
}
}
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::computeRoutesFor(ROEdge* edge, RODFRouteDesc& base, int /*no*/,
bool keepUnfoundEnds,
bool keepShortestOnly,
std::vector<ROEdge*>& /*visited*/,
const RODFDetector& det, RODFRouteCont& into,
const RODFDetectorCon& detectors,
int maxFollowingLength,
std::vector<ROEdge*>& seen) const {
std::vector<RODFRouteDesc> unfoundEnds;
std::priority_queue<RODFRouteDesc, std::vector<RODFRouteDesc>, DFRouteDescByTimeComperator> toSolve;
std::map<ROEdge*, std::vector<ROEdge*> > dets2Follow;
dets2Follow[edge] = std::vector<ROEdge*>();
base.passedNo = 0;
SUMOReal minDist = OptionsCont::getOptions().getFloat("min-route-length");
toSolve.push(base);
while (!toSolve.empty()) {
RODFRouteDesc current = toSolve.top();
toSolve.pop();
ROEdge* last = *(current.edges2Pass.end() - 1);
if (hasDetector(last)) {
if (dets2Follow.find(last) == dets2Follow.end()) {
dets2Follow[last] = std::vector<ROEdge*>();
}
for (std::vector<ROEdge*>::reverse_iterator i = current.edges2Pass.rbegin() + 1; i != current.edges2Pass.rend(); ++i) {
if (hasDetector(*i)) {
dets2Follow[*i].push_back(last);
break;
}
}
}
// do not process an edge twice
if (find(seen.begin(), seen.end(), last) != seen.end() && keepShortestOnly) {
continue;
}
seen.push_back(last);
// end if the edge has no further connections
if (!hasApproached(last)) {
// ok, no further connections to follow
current.factor = 1.;
SUMOReal cdist = current.edges2Pass[0]->getFromNode()->getPosition().distanceTo(current.edges2Pass.back()->getToNode()->getPosition());
if (minDist < cdist) {
into.addRouteDesc(current);
}
continue;
}
// check for passing detectors:
// if the current last edge is not the one the detector is placed on ...
bool addNextNoFurther = false;
if (last != getDetectorEdge(det)) {
// ... if there is a detector ...
if (hasDetector(last)) {
if (!hasInBetweenDetectorsOnly(last, detectors)) {
// ... and it's not an in-between-detector
// -> let's add this edge and the following, but not any further
addNextNoFurther = true;
current.lastDetectorEdge = last;
current.duration2Last = (SUMOTime) current.duration_2;
current.distance2Last = current.distance;
current.endDetectorEdge = last;
if (hasSourceDetector(last, detectors)) {
///!!! //toDiscard.push_back(current);
}
current.factor = 1.;
SUMOReal cdist = current.edges2Pass[0]->getFromNode()->getPosition().distanceTo(current.edges2Pass.back()->getToNode()->getPosition());
if (minDist < cdist) {
into.addRouteDesc(current);
}
continue;
} else {
// ... if it's an in-between-detector
// -> mark the current route as to be continued
current.passedNo = 0;
current.duration2Last = (SUMOTime) current.duration_2;
current.distance2Last = current.distance;
current.lastDetectorEdge = last;
}
}
}
// check for highway off-ramps
if (myAmInHighwayMode) {
// if it's beside the highway...
if (last->getSpeed() < 19.4 && last != getDetectorEdge(det)) {
// ... and has more than one following edge
if (myApproachedEdges.find(last)->second.size() > 1) {
// -> let's add this edge and the following, but not any further
addNextNoFurther = true;
}
}
}
// check for missing end connections
if (!addNextNoFurther) {
// ... if this one would be processed, but already too many edge
// without a detector occured
if (current.passedNo > maxFollowingLength) {
// mark not to process any further
WRITE_WARNING("Could not close route for '" + det.getID() + "'");
unfoundEnds.push_back(current);
current.factor = 1.;
SUMOReal cdist = current.edges2Pass[0]->getFromNode()->getPosition().distanceTo(current.edges2Pass.back()->getToNode()->getPosition());
if (minDist < cdist) {
into.addRouteDesc(current);
}
continue;
}
}
// ... else: loop over the next edges
const std::vector<ROEdge*>& appr = myApproachedEdges.find(last)->second;
bool hadOne = false;
for (size_t i = 0; i < appr.size(); i++) {
if (find(current.edges2Pass.begin(), current.edges2Pass.end(), appr[i]) != current.edges2Pass.end()) {
// do not append an edge twice (do not build loops)
continue;
}
RODFRouteDesc t(current);
t.duration_2 += (appr[i]->getLength() / appr[i]->getSpeed()); //!!!
t.distance += appr[i]->getLength();
t.edges2Pass.push_back(appr[i]);
if (!addNextNoFurther) {
t.passedNo = t.passedNo + 1;
toSolve.push(t);
} else {
if (!hadOne) {
t.factor = (SUMOReal) 1. / (SUMOReal) appr.size();
SUMOReal cdist = current.edges2Pass[0]->getFromNode()->getPosition().distanceTo(current.edges2Pass.back()->getToNode()->getPosition());
if (minDist < cdist) {
into.addRouteDesc(t);
}
hadOne = true;
}
}
}
}
//
if (!keepUnfoundEnds) {
std::vector<RODFRouteDesc>::iterator i;
std::vector<const ROEdge*> lastDetEdges;
for (i = unfoundEnds.begin(); i != unfoundEnds.end(); ++i) {
if (find(lastDetEdges.begin(), lastDetEdges.end(), (*i).lastDetectorEdge) == lastDetEdges.end()) {
lastDetEdges.push_back((*i).lastDetectorEdge);
} else {
bool ok = into.removeRouteDesc(*i);
assert(ok);
}
}
} else {
// !!! patch the factors
}
while (!toSolve.empty()) {
// RODFRouteDesc d = toSolve.top();
toSolve.pop();
// delete d;
}
}
void
RODFDetectorCon::writeValidationDetectors(const std::string& file,
bool includeSources,
bool singleFile, bool friendly) {
OutputDevice& out = OutputDevice::getDevice(file);
out.writeXMLHeader("additional");
for (std::vector<RODFDetector*>::const_iterator i = myDetectors.begin(); i != myDetectors.end(); ++i) {
RODFDetector* det = *i;
// write the declaration into the file
if (det->getType() != SOURCE_DETECTOR || includeSources) {
SUMOReal pos = det->getPos();
if (det->getType() == SOURCE_DETECTOR) {
pos += 1;
}
out.openTag(SUMO_TAG_E1DETECTOR).writeAttr(SUMO_ATTR_ID, "validation_" + StringUtils::escapeXML(det->getID())).writeAttr(SUMO_ATTR_LANE, det->getLaneID());
out.writeAttr(SUMO_ATTR_POSITION, pos).writeAttr(SUMO_ATTR_FREQUENCY, 60);
if (friendly) {
out.writeAttr(SUMO_ATTR_FRIENDLY_POS, true);
}
if (!singleFile) {
out.writeAttr(SUMO_ATTR_FILE, "validation_det_" + StringUtils::escapeXML(det->getID()) + ".xml");
} else {
out.writeAttr(SUMO_ATTR_FILE, "validation_dets.xml");
}
out.closeTag();
}
}
out.close();
}
void
RODFDetectorCon::writeEndRerouterDetectors(const std::string& file) {
OutputDevice& out = OutputDevice::getDevice(file);
out.writeXMLHeader("additional");
for (std::vector<RODFDetector*>::const_iterator i = myDetectors.begin(); i != myDetectors.end(); ++i) {
RODFDetector* det = *i;
// write the declaration into the file
if (det->getType() == SINK_DETECTOR) {
out.openTag(SUMO_TAG_REROUTER).writeAttr(SUMO_ATTR_ID, "endrerouter_" + StringUtils::escapeXML(det->getID())).writeAttr(SUMO_ATTR_EDGES, det->getLaneID());
out.writeAttr(SUMO_ATTR_POSITION, SUMOReal(0)).writeAttr(SUMO_ATTR_FILE, "endrerouter_" + det->getID() + ".def.xml").closeTag();
}
}
out.close();
}
void
RODFDetectorCon::writeEmitters(const std::string& file,
const RODFDetectorFlows& flows,
SUMOTime startTime, SUMOTime endTime,
SUMOTime stepOffset, const RODFNet& net,
bool writeCalibrators,
bool includeUnusedRoutes,
SUMOReal scale,
bool insertionsOnly) {
// compute turn probabilities at detector
for (std::vector<RODFDetector*>::const_iterator i = myDetectors.begin(); i != myDetectors.end(); ++i) {
(*i)->computeSplitProbabilities(&net, *this, flows, startTime, endTime, stepOffset);
}
//
OutputDevice& out = OutputDevice::getDevice(file);
out.writeXMLHeader("additional", "additional_file.xsd");
// write vType(s)
const bool separateVTypeOutput = OptionsCont::getOptions().getString("vtype-output") != "";
OutputDevice& vTypeOut = separateVTypeOutput ? OutputDevice::getDevice(OptionsCont::getOptions().getString("vtype-output")) : out;
if (separateVTypeOutput) {
vTypeOut.writeXMLHeader("additional", "additional_file.xsd");
}
const bool forceDev = !OptionsCont::getOptions().isDefault("speeddev");
const SUMOReal speedDev = OptionsCont::getOptions().getFloat("speeddev");
if (OptionsCont::getOptions().getBool("vtype")) {
// write separate types
SUMOVTypeParameter pkwType = SUMOVTypeParameter("PKW", SVC_PASSENGER);
setSpeedFactorAndDev(pkwType, net.getMaxSpeedFactorPKW(), net.getAvgSpeedFactorPKW(), speedDev, forceDev);
pkwType.setParameter |= VTYPEPARS_VEHICLECLASS_SET;
pkwType.write(vTypeOut);
SUMOVTypeParameter lkwType = SUMOVTypeParameter("LKW", SVC_TRUCK);
setSpeedFactorAndDev(lkwType, net.getMaxSpeedFactorLKW(), net.getAvgSpeedFactorLKW(), speedDev, forceDev);
lkwType.setParameter |= VTYPEPARS_VEHICLECLASS_SET;
lkwType.write(vTypeOut);
} else {
// patch default type
SUMOVTypeParameter type = SUMOVTypeParameter(DEFAULT_VTYPE_ID, SVC_PASSENGER);
setSpeedFactorAndDev(type, MAX2(net.getMaxSpeedFactorPKW(), net.getMaxSpeedFactorLKW()), net.getAvgSpeedFactorPKW(), speedDev, forceDev);
if (type.setParameter != 0) {
type.write(vTypeOut);
}
}
for (std::vector<RODFDetector*>::const_iterator i = myDetectors.begin(); i != myDetectors.end(); ++i) {
RODFDetector* det = *i;
// get file name for values (emitter/calibrator definition)
std::string escapedID = StringUtils::escapeXML(det->getID());
std::string defFileName;
if (det->getType() == SOURCE_DETECTOR) {
defFileName = file;
} else if (writeCalibrators && det->getType() == BETWEEN_DETECTOR) {
defFileName = FileHelpers::getFilePath(file) + "calibrator_" + escapedID + ".def.xml";
} else {
defFileName = FileHelpers::getFilePath(file) + "other_" + escapedID + ".def.xml";
continue;
}
// try to write the definition
SUMOReal defaultSpeed = net.getEdge(det->getEdgeID())->getSpeed();
// ... compute routes' distribution over time
std::map<SUMOTime, RandomDistributor<int>* > dists;
if (!insertionsOnly && flows.knows(det->getID())) {
det->buildDestinationDistribution(*this, startTime, endTime, stepOffset, net, dists);
}
// ... write the definition
if (!det->writeEmitterDefinition(defFileName, dists, flows, startTime, endTime, stepOffset, includeUnusedRoutes, scale, insertionsOnly, defaultSpeed)) {
// skip if something failed... (!!!)
continue;
}
// ... clear temporary values
clearDists(dists);
// write the declaration into the file
if (writeCalibrators && det->getType() == BETWEEN_DETECTOR) {
out.openTag(SUMO_TAG_CALIBRATOR).writeAttr(SUMO_ATTR_ID, "calibrator_" + escapedID).writeAttr(SUMO_ATTR_POSITION, det->getPos());
out.writeAttr(SUMO_ATTR_LANE, det->getLaneID()).writeAttr(SUMO_ATTR_FRIENDLY_POS, true).writeAttr(SUMO_ATTR_FILE, defFileName).closeTag();
}
}
out.close();
if (separateVTypeOutput) {
vTypeOut.close();
}
}