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
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;
}
}
}
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();
}
}
/* -------------------------------------------------------------------------
* main
* ----------------------------------------------------------------------- */
int
main(int argc, char** argv) {
OptionsCont& oc = OptionsCont::getOptions();
// give some application descriptions
oc.setApplicationDescription("Builds vehicle routes for SUMO using detector values.");
oc.setApplicationName("dfrouter", "SUMO dfrouter Version " + (std::string)VERSION_STRING);
int ret = 0;
RODFNet* net = 0;
RODFDetectorCon* detectors = 0;
RODFDetectorFlows* flows = 0;
try {
// initialise the application system (messaging, xml, options)
XMLSubSys::init();
RODFFrame::fillOptions();
OptionsIO::getOptions(true, argc, argv);
if (oc.processMetaOptions(argc < 2)) {
SystemFrame::close();
return 0;
}
XMLSubSys::setValidation(oc.getBool("xml-validation"));
MsgHandler::initOutputOptions();
if (!RODFFrame::checkOptions()) {
throw ProcessError();
}
RandHelper::initRandGlobal();
// load data
ROLoader loader(oc, false, !oc.getBool("no-step-log"));
net = new RODFNet(oc.getBool("highway-mode"));
RODFEdgeBuilder builder;
loader.loadNet(*net, builder);
net->buildApproachList();
// load detectors
detectors = new RODFDetectorCon();
readDetectors(*detectors, oc, net);
// load detector values
flows = new RODFDetectorFlows(string2time(oc.getString("begin")), string2time(oc.getString("end")),
string2time(oc.getString("time-step")));
readDetectorFlows(*flows, oc, *detectors);
// build routes
startComputation(net, *flows, *detectors, oc);
} catch (const ProcessError& e) {
if (std::string(e.what()) != std::string("Process Error") && std::string(e.what()) != std::string("")) {
WRITE_ERROR(e.what());
}
MsgHandler::getErrorInstance()->inform("Quitting (on error).", false);
ret = 1;
#ifndef _DEBUG
} catch (const std::exception& e) {
if (std::string(e.what()) != std::string("")) {
WRITE_ERROR(e.what());
}
MsgHandler::getErrorInstance()->inform("Quitting (on error).", false);
ret = 1;
} catch (...) {
MsgHandler::getErrorInstance()->inform("Quitting (on unknown error).", false);
ret = 1;
#endif
}
delete net;
delete flows;
delete detectors;
SystemFrame::close();
if (ret == 0) {
std::cout << "Success." << std::endl;
}
return ret;
}
