/**
* loads the net
* The net is in this meaning made up by the net itself and the dynamic
* weights which may be supplied in a separate file
*/
void
initNet(RONet& net, ROLoader& loader, OptionsCont& oc) {
// load the net
RODUAEdgeBuilder builder(oc.getBool("weights.expand"), oc.getBool("weights.interpolate"));
loader.loadNet(net, builder);
// load the weights when wished/available
if (oc.isSet("weight-files")) {
loader.loadWeights(net, "weight-files", oc.getString("weight-attribute"), false);
}
if (oc.isSet("lane-weight-files")) {
loader.loadWeights(net, "lane-weight-files", oc.getString("weight-attribute"), true);
}
}
/**
* Computes the routes saving them
*/
void
computeRoutes(RONet& net, ROLoader& loader, OptionsCont& oc) {
// initialise the loader
loader.openRoutes(net);
// prepare the output
net.openOutput(oc);
// build the router
ROJTRRouter* router = new ROJTRRouter(oc.getBool("ignore-errors"), oc.getBool("accept-all-destinations"),
(int)(((double) net.getEdgeNumber()) * OptionsCont::getOptions().getFloat("max-edges-factor")),
oc.getBool("ignore-vclasses"), oc.getBool("allow-loops"));
RORouteDef::setUsingJTRR();
RORouterProvider provider(router, new PedestrianRouter<ROEdge, ROLane, RONode, ROVehicle>(),
new ROIntermodalRouter(RONet::adaptIntermodalRouter, 0));
loader.processRoutes(string2time(oc.getString("begin")), string2time(oc.getString("end")),
string2time(oc.getString("route-steps")), net, provider);
net.cleanup();
}
/**
* loads the net
* The net is in this meaning made up by the net itself and the dynamic
* weights which may be supplied in a separate file
*/
void
initNet(RONet &net, ROLoader &loader, OptionsCont &oc,
const std::vector<SUMOReal> &turnDefs) {
// load the net
ROJTREdgeBuilder builder;
loader.loadNet(net, builder);
// set the turn defaults
const std::map<std::string, ROEdge*> &edges = net.getEdgeMap();
for (std::map<std::string, ROEdge*>::const_iterator i=edges.begin(); i!=edges.end(); ++i) {
static_cast<ROJTREdge*>((*i).second)->setTurnDefaults(turnDefs);
}
// load the weights when wished/available
if (oc.isSet("weights")) {
loader.loadWeights(net, "weights", oc.getString("measure"), false);
}
if (oc.isSet("lane-weights")) {
loader.loadWeights(net, "lane-weights", oc.getString("measure"), true);
}
}
/**
* loads the net
* The net is in this meaning made up by the net itself and the dynamic
* weights which may be supplied in a separate file
*/
void
initNet(RONet& net, ROLoader& loader,
const std::vector<double>& turnDefs) {
// load the net
ROJTREdgeBuilder builder;
loader.loadNet(net, builder);
// set the turn defaults
for (const auto& i : net.getEdgeMap()) {
static_cast<ROJTREdge*>(i.second)->setTurnDefaults(turnDefs);
}
}
/**
* loads the net
* The net is in this meaning made up by the net itself and the dynamic
* weights which may be supplied in a separate file
*/
void
initNet(RONet& net, ROLoader& loader,
const std::vector<SUMOReal>& turnDefs) {
// load the net
ROJTREdgeBuilder builder;
loader.loadNet(net, builder);
// set the turn defaults
const std::map<std::string, ROEdge*>& edges = net.getEdgeMap();
for (std::map<std::string, ROEdge*>::const_iterator i = edges.begin(); i != edges.end(); ++i) {
static_cast<ROJTREdge*>((*i).second)->setTurnDefaults(turnDefs);
}
}
/**
* Computes the routes saving them
*/
void
computeRoutes(RONet &net, ROLoader &loader, OptionsCont &oc) {
// initialise the loader
loader.openRoutes(net);
// prepare the output
try {
net.openOutput(oc.getString("output"), false);
} catch (IOError &e) {
throw e;
}
// build the router
ROJTRRouter router(net, oc.getBool("continue-on-unbuild"),
oc.getBool("accept-all-destinations"));
// the routes are sorted - process stepwise
if (!oc.getBool("unsorted")) {
loader.processRoutesStepWise(string2time(oc.getString("begin")), string2time(oc.getString("end")), net, router);
}
// the routes are not sorted: load all and process
else {
loader.processAllRoutes(string2time(oc.getString("begin")), string2time(oc.getString("end")), net, router);
}
// end the processing
net.closeOutput();
}
/**
* Computes the routes saving them
*/
void
computeRoutes(RONet& net, ROLoader& loader, OptionsCont& oc) {
// initialise the loader
loader.openRoutes(net);
// prepare the output
const std::string& filename = oc.getString("output-file");
std::string altFilename = filename + ".alt";
const size_t len = filename.length();
if (len > 4 && filename.substr(len - 4) == ".xml") {
altFilename = filename.substr(0, len - 4) + ".alt.xml";
} else if (len > 4 && filename.substr(len - 4) == ".sbx") {
altFilename = filename.substr(0, len - 4) + ".alt.sbx";
}
net.openOutput(filename, altFilename, oc.getString("vtype-output"));
// build the router
SUMOAbstractRouter<ROEdge, ROVehicle>* router;
const std::string measure = oc.getString("weight-attribute");
const std::string routingAlgorithm = oc.getString("routing-algorithm");
if (measure == "traveltime") {
if (routingAlgorithm == "dijkstra") {
if (net.hasRestrictions()) {
router = new DijkstraRouterTT_Direct<ROEdge, ROVehicle, prohibited_withRestrictions<ROEdge, ROVehicle> >(
net.getEdgeNo(), oc.getBool("ignore-errors"), &ROEdge::getTravelTime);
} else {
router = new DijkstraRouterTT_Direct<ROEdge, ROVehicle, prohibited_noRestrictions<ROEdge, ROVehicle> >(
net.getEdgeNo(), oc.getBool("ignore-errors"), &ROEdge::getTravelTime);
}
} else if (routingAlgorithm == "astar") {
if (net.hasRestrictions()) {
router = new AStarRouterTT_Direct<ROEdge, ROVehicle, prohibited_withRestrictions<ROEdge, ROVehicle> >(
net.getEdgeNo(), oc.getBool("ignore-errors"), &ROEdge::getTravelTime);
} else {
router = new AStarRouterTT_Direct<ROEdge, ROVehicle, prohibited_noRestrictions<ROEdge, ROVehicle> >(
net.getEdgeNo(), oc.getBool("ignore-errors"), &ROEdge::getTravelTime);
}
#ifdef HAVE_INTERNAL // catchall for internal stuff
} else if (routingAlgorithm == "bulkstar") {
if (net.hasRestrictions()) {
router = new BulkStarRouterTT<ROEdge, ROVehicle, prohibited_withRestrictions<ROEdge, ROVehicle> >(
net.getEdgeNo(), oc.getBool("ignore-errors"), &ROEdge::getTravelTime, &ROEdge::getMinimumTravelTime);
} else {
router = new BulkStarRouterTT<ROEdge, ROVehicle, prohibited_noRestrictions<ROEdge, ROVehicle> >(
net.getEdgeNo(), oc.getBool("ignore-errors"), &ROEdge::getTravelTime, &ROEdge::getMinimumTravelTime);
}
} else if (routingAlgorithm == "CH") {
// defaultVehicle is only in constructor and may be safely deleted
// it is mainly needed for its maximum speed. @todo XXX make this configurable
ROVehicle defaultVehicle(SUMOVehicleParameter(), 0, net.getVehicleTypeSecure(DEFAULT_VTYPE_ID));
const SUMOTime begin = string2time(oc.getString("begin"));
const SUMOTime weightPeriod = (oc.isSet("weight-files") ?
string2time(oc.getString("weight-period")) :
std::numeric_limits<int>::max());
if (net.hasRestrictions()) {
router = new CHRouter<ROEdge, ROVehicle, prohibited_withRestrictions<ROEdge, ROVehicle> >(
net.getEdgeNo(), oc.getBool("ignore-errors"), &ROEdge::getTravelTime, &defaultVehicle, begin, weightPeriod, true);
} else {
router = new CHRouter<ROEdge, ROVehicle, prohibited_noRestrictions<ROEdge, ROVehicle> >(
net.getEdgeNo(), oc.getBool("ignore-errors"), &ROEdge::getTravelTime, &defaultVehicle, begin, weightPeriod, false);
}
} else if (routingAlgorithm == "CHWrapper") {
const SUMOTime begin = string2time(oc.getString("begin"));
const SUMOTime weightPeriod = (oc.isSet("weight-files") ?
string2time(oc.getString("weight-period")) :
std::numeric_limits<int>::max());
router = new CHRouterWrapper<ROEdge, ROVehicle, prohibited_withRestrictions<ROEdge, ROVehicle> >(
net.getEdgeNo(), oc.getBool("ignore-errors"), &ROEdge::getTravelTime, begin, weightPeriod);
#endif // have HAVE_INTERNAL
} else {
throw ProcessError("Unknown routing Algorithm '" + routingAlgorithm + "'!");
}
} else {
DijkstraRouterEffort_Direct<ROEdge, ROVehicle, prohibited_withRestrictions<ROEdge, ROVehicle> >::Operation op;
if (measure == "CO") {
op = &ROEdge::getCOEffort;
} else if (measure == "CO2") {
op = &ROEdge::getCO2Effort;
} else if (measure == "PMx") {
op = &ROEdge::getPMxEffort;
} else if (measure == "HC") {
op = &ROEdge::getHCEffort;
} else if (measure == "NOx") {
op = &ROEdge::getNOxEffort;
} else if (measure == "fuel") {
op = &ROEdge::getFuelEffort;
} else if (measure == "noise") {
op = &ROEdge::getNoiseEffort;
} else {
net.closeOutput();
throw ProcessError("Unknown measure (weight attribute '" + measure + "')!");
}
if (net.hasRestrictions()) {
router = new DijkstraRouterEffort_Direct<ROEdge, ROVehicle, prohibited_withRestrictions<ROEdge, ROVehicle> >(
net.getEdgeNo(), oc.getBool("ignore-errors"), op, &ROEdge::getTravelTime);
} else {
router = new DijkstraRouterEffort_Direct<ROEdge, ROVehicle, prohibited_noRestrictions<ROEdge, ROVehicle> >(
net.getEdgeNo(), oc.getBool("ignore-errors"), op, &ROEdge::getTravelTime);
}
}
// process route definitions
try {
if (routingAlgorithm == "bulkstar") {
#ifdef HAVE_INTERNAL // catchall for internal stuff
// need to load all routes for spatial aggregation
loader.processAllRoutesWithBulkRouter(string2time(oc.getString("begin")), string2time(oc.getString("end")), net, *router);
#endif
} else {
loader.processRoutes(string2time(oc.getString("begin")), string2time(oc.getString("end")), net, *router);
}
// end the processing
net.closeOutput();
delete router;
ROCostCalculator::cleanup();
} catch (ProcessError&) {
net.closeOutput();
delete router;
ROCostCalculator::cleanup();
throw;
}
}
/**
* Computes the routes saving them
*/
void
computeRoutes(RONet& net, ROLoader& loader, OptionsCont& oc) {
// initialise the loader
loader.openRoutes(net);
// build the router
auto ttFunction = gWeightsRandomFactor > 1 ? &ROEdge::getTravelTimeStaticRandomized : &ROEdge::getTravelTimeStatic;
SUMOAbstractRouter<ROEdge, ROVehicle>* router;
const std::string measure = oc.getString("weight-attribute");
const std::string routingAlgorithm = oc.getString("routing-algorithm");
const SUMOTime begin = string2time(oc.getString("begin"));
const SUMOTime end = string2time(oc.getString("end"));
if (measure == "traveltime") {
if (routingAlgorithm == "dijkstra") {
if (net.hasPermissions()) {
router = new DijkstraRouter<ROEdge, ROVehicle, SUMOAbstractRouterPermissions<ROEdge, ROVehicle> >(
ROEdge::getAllEdges(), oc.getBool("ignore-errors"), ttFunction);
} else {
router = new DijkstraRouter<ROEdge, ROVehicle, SUMOAbstractRouter<ROEdge, ROVehicle> >(
ROEdge::getAllEdges(), oc.getBool("ignore-errors"), ttFunction);
}
} else if (routingAlgorithm == "astar") {
if (net.hasPermissions()) {
typedef AStarRouter<ROEdge, ROVehicle, SUMOAbstractRouterPermissions<ROEdge, ROVehicle> > AStar;
std::shared_ptr<const AStar::LookupTable> lookup;
if (oc.isSet("astar.all-distances")) {
lookup = std::make_shared<const AStar::FLT>(oc.getString("astar.all-distances"), (int)ROEdge::getAllEdges().size());
} else if (oc.isSet("astar.landmark-distances")) {
CHRouterWrapper<ROEdge, ROVehicle, SUMOAbstractRouterPermissions<ROEdge, ROVehicle> > router(
ROEdge::getAllEdges(), true, &ROEdge::getTravelTimeStatic,
begin, end, std::numeric_limits<int>::max(), 1);
ROVehicle defaultVehicle(SUMOVehicleParameter(), nullptr, net.getVehicleTypeSecure(DEFAULT_VTYPE_ID), &net);
lookup = std::make_shared<const AStar::LMLT>(oc.getString("astar.landmark-distances"), ROEdge::getAllEdges(), &router, &defaultVehicle,
oc.isSet("astar.save-landmark-distances") ? oc.getString("astar.save-landmark-distances") : "", oc.getInt("routing-threads"));
}
router = new AStar(ROEdge::getAllEdges(), oc.getBool("ignore-errors"), ttFunction, lookup);
} else {
typedef AStarRouter<ROEdge, ROVehicle, SUMOAbstractRouter<ROEdge, ROVehicle> > AStar;
std::shared_ptr<const AStar::LookupTable> lookup;
if (oc.isSet("astar.all-distances")) {
lookup = std::make_shared<const AStar::FLT>(oc.getString("astar.all-distances"), (int)ROEdge::getAllEdges().size());
} else if (oc.isSet("astar.landmark-distances")) {
CHRouterWrapper<ROEdge, ROVehicle, SUMOAbstractRouter<ROEdge, ROVehicle> > router(
ROEdge::getAllEdges(), true, &ROEdge::getTravelTimeStatic,
begin, end, std::numeric_limits<int>::max(), 1);
ROVehicle defaultVehicle(SUMOVehicleParameter(), nullptr, net.getVehicleTypeSecure(DEFAULT_VTYPE_ID), &net);
lookup = std::make_shared<const AStar::LMLT>(oc.getString("astar.landmark-distances"), ROEdge::getAllEdges(), &router, &defaultVehicle,
oc.isSet("astar.save-landmark-distances") ? oc.getString("astar.save-landmark-distances") : "", oc.getInt("routing-threads"));
}
router = new AStar(ROEdge::getAllEdges(), oc.getBool("ignore-errors"), ttFunction, lookup);
}
} else if (routingAlgorithm == "CH") {
const SUMOTime weightPeriod = (oc.isSet("weight-files") ?
string2time(oc.getString("weight-period")) :
std::numeric_limits<int>::max());
if (net.hasPermissions()) {
router = new CHRouter<ROEdge, ROVehicle, SUMOAbstractRouterPermissions<ROEdge, ROVehicle> >(
ROEdge::getAllEdges(), oc.getBool("ignore-errors"), &ROEdge::getTravelTimeStatic, SVC_IGNORING, weightPeriod, true);
} else {
router = new CHRouter<ROEdge, ROVehicle, SUMOAbstractRouter<ROEdge, ROVehicle> >(
ROEdge::getAllEdges(), oc.getBool("ignore-errors"), &ROEdge::getTravelTimeStatic, SVC_IGNORING, weightPeriod, false);
}
} else if (routingAlgorithm == "CHWrapper") {
const SUMOTime weightPeriod = (oc.isSet("weight-files") ?
string2time(oc.getString("weight-period")) :
std::numeric_limits<int>::max());
router = new CHRouterWrapper<ROEdge, ROVehicle, SUMOAbstractRouterPermissions<ROEdge, ROVehicle> >(
ROEdge::getAllEdges(), oc.getBool("ignore-errors"), &ROEdge::getTravelTimeStatic,
begin, end, weightPeriod, oc.getInt("routing-threads"));
} else {
throw ProcessError("Unknown routing Algorithm '" + routingAlgorithm + "'!");
}
} else {
DijkstraRouter<ROEdge, ROVehicle, SUMOAbstractRouterPermissions<ROEdge, ROVehicle> >::Operation op;
if (measure == "CO") {
op = &ROEdge::getEmissionEffort<PollutantsInterface::CO>;
} else if (measure == "CO2") {
op = &ROEdge::getEmissionEffort<PollutantsInterface::CO2>;
} else if (measure == "PMx") {
op = &ROEdge::getEmissionEffort<PollutantsInterface::PM_X>;
} else if (measure == "HC") {
op = &ROEdge::getEmissionEffort<PollutantsInterface::HC>;
} else if (measure == "NOx") {
op = &ROEdge::getEmissionEffort<PollutantsInterface::NO_X>;
} else if (measure == "fuel") {
op = &ROEdge::getEmissionEffort<PollutantsInterface::FUEL>;
} else if (measure == "electricity") {
op = &ROEdge::getEmissionEffort<PollutantsInterface::ELEC>;
} else if (measure == "noise") {
op = &ROEdge::getNoiseEffort;
} else {
throw ProcessError("Unknown measure (weight attribute '" + measure + "')!");
}
if (net.hasPermissions()) {
router = new DijkstraRouter<ROEdge, ROVehicle, SUMOAbstractRouterPermissions<ROEdge, ROVehicle> >(
ROEdge::getAllEdges(), oc.getBool("ignore-errors"), op, ttFunction);
} else {
router = new DijkstraRouter<ROEdge, ROVehicle, SUMOAbstractRouter<ROEdge, ROVehicle> >(
ROEdge::getAllEdges(), oc.getBool("ignore-errors"), op, ttFunction);
}
}
int carWalk = 0;
for (const std::string& opt : oc.getStringVector("persontrip.transfer.car-walk")) {
if (opt == "parkingAreas") {
carWalk |= ROIntermodalRouter::Network::PARKING_AREAS;
} else if (opt == "ptStops") {
carWalk |= ROIntermodalRouter::Network::PT_STOPS;
} else if (opt == "allJunctions") {
carWalk |= ROIntermodalRouter::Network::ALL_JUNCTIONS;
}
}
RORouterProvider provider(router, new PedestrianRouter<ROEdge, ROLane, RONode, ROVehicle>(),
new ROIntermodalRouter(RONet::adaptIntermodalRouter, carWalk, routingAlgorithm));
// process route definitions
try {
net.openOutput(oc);
loader.processRoutes(begin, end, string2time(oc.getString("route-steps")), net, provider);
net.writeIntermodal(oc, provider.getIntermodalRouter());
// end the processing
net.cleanup();
} catch (ProcessError&) {
net.cleanup();
throw;
}
}
