SUMO - Simulation of Urban MObility
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
marouter_main.cpp
Go to the documentation of this file.
1 /****************************************************************************/
10 // Main for MAROUTER
11 /****************************************************************************/
12 // SUMO, Simulation of Urban MObility; see http://sumo.dlr.de/
13 // Copyright (C) 2001-2016 DLR (http://www.dlr.de/) and contributors
14 /****************************************************************************/
15 //
16 // This file is part of SUMO.
17 // SUMO is free software: you can redistribute it and/or modify
18 // it under the terms of the GNU General Public License as published by
19 // the Free Software Foundation, either version 3 of the License, or
20 // (at your option) any later version.
21 //
22 /****************************************************************************/
23 
24 
25 // ===========================================================================
26 // included modules
27 // ===========================================================================
28 #ifdef _MSC_VER
29 #include <windows_config.h>
30 #else
31 #include <config.h>
32 #endif
33 
34 #ifdef HAVE_VERSION_H
35 #include <version.h>
36 #endif
37 
38 #include <xercesc/sax/SAXException.hpp>
39 #include <xercesc/sax/SAXParseException.hpp>
41 #include <iostream>
42 #include <string>
43 #include <limits.h>
44 #include <ctime>
45 #include <vector>
50 #include <utils/common/ToString.h>
54 #include <utils/options/Option.h>
61 #include <utils/vehicle/CHRouter.h>
63 #include <utils/xml/XMLSubSys.h>
64 #include <od/ODCell.h>
65 #include <od/ODDistrict.h>
66 #include <od/ODDistrictCont.h>
67 #include <od/ODDistrictHandler.h>
68 #include <od/ODMatrix.h>
69 #include <router/ROEdge.h>
70 #include <router/ROLoader.h>
71 #include <router/RONet.h>
72 #include <router/RORoute.h>
73 #include <router/RORoutable.h>
74 
75 #include "ROMAFrame.h"
76 #include "ROMAAssignments.h"
77 #include "ROMAEdgeBuilder.h"
78 #include "ROMARouteHandler.h"
79 #include "ROMAEdge.h"
80 
81 #ifdef CHECK_MEMORY_LEAKS
82 #include <foreign/nvwa/debug_new.h>
83 #endif // CHECK_MEMORY_LEAKS
84 
85 
86 // ===========================================================================
87 // functions
88 // ===========================================================================
89 /* -------------------------------------------------------------------------
90  * data processing methods
91  * ----------------------------------------------------------------------- */
97 void
98 initNet(RONet& net, ROLoader& loader, OptionsCont& oc) {
99  // load the net
100  ROMAEdgeBuilder builder;
101  ROEdge::setGlobalOptions(oc.getBool("weights.interpolate"));
102  loader.loadNet(net, builder);
103  // initialize the travel times
104  /* const SUMOTime begin = string2time(oc.getString("begin"));
105  const SUMOTime end = string2time(oc.getString("end"));
106  for (std::map<std::string, ROEdge*>::const_iterator i = net.getEdgeMap().begin(); i != net.getEdgeMap().end(); ++i) {
107  (*i).second->addTravelTime(STEPS2TIME(begin), STEPS2TIME(end), (*i).second->getLength() / (*i).second->getSpeed());
108  }*/
109  // load the weights when wished/available
110  if (oc.isSet("weight-files")) {
111  loader.loadWeights(net, "weight-files", oc.getString("weight-attribute"), false, oc.getBool("weights.expand"));
112  }
113  if (oc.isSet("lane-weight-files")) {
114  loader.loadWeights(net, "lane-weight-files", oc.getString("weight-attribute"), true, oc.getBool("weights.expand"));
115  }
116 }
117 
118 SUMOReal
119 getTravelTime(const ROEdge* const edge, const ROVehicle* const /* veh */, SUMOReal /* time */) {
120  return edge->getLength() / edge->getSpeed();
121 }
122 
123 
127 void
129  std::ofstream outFile(oc.getString("all-pairs-output").c_str(), std::ios::binary);
130  // build the router
132  Dijkstra router(ROEdge::getAllEdges(), oc.getBool("ignore-errors"), &getTravelTime);
133  ConstROEdgeVector into;
134  const int numInternalEdges = net.getInternalEdgeNumber();
135  const int numTotalEdges = (int)net.getEdgeNo();
136  for (int i = numInternalEdges; i < numTotalEdges; i++) {
137  const Dijkstra::EdgeInfo& ei = router.getEdgeInfo(i);
138  if (ei.edge->getFunc() != ROEdge::ET_INTERNAL) {
139  router.compute(ei.edge, 0, 0, 0, into);
140  for (int j = numInternalEdges; j < numTotalEdges; j++) {
141  FileHelpers::writeFloat(outFile, router.getEdgeInfo(j).traveltime);
142  }
143  }
144  }
145 }
146 
147 
151 void
152 writeInterval(OutputDevice& dev, const SUMOTime begin, const SUMOTime end, const RONet& net, const ROVehicle* const veh) {
154  for (std::map<std::string, ROEdge*>::const_iterator i = net.getEdgeMap().begin(); i != net.getEdgeMap().end(); ++i) {
155  ROMAEdge* edge = static_cast<ROMAEdge*>(i->second);
156  if (edge->getFunc() == ROEdge::ET_NORMAL) {
158  const SUMOReal traveltime = edge->getTravelTime(veh, STEPS2TIME(begin));
159  const SUMOReal flow = edge->getFlow(STEPS2TIME(begin));
160  dev.writeAttr("traveltime", traveltime);
161  dev.writeAttr("speed", edge->getLength() / traveltime);
162  dev.writeAttr("entered", flow);
163  dev.writeAttr("flowCapacityRatio", 100. * flow / ROMAAssignments::getCapacity(edge));
164  dev.closeTag();
165  }
166  }
167  dev.closeTag();
168 }
169 
170 
174 void
176  // build the router
178  const std::string measure = oc.getString("weight-attribute");
179  const std::string routingAlgorithm = oc.getString("routing-algorithm");
180  const SUMOTime begin = string2time(oc.getString("begin"));
181  const SUMOTime end = string2time(oc.getString("end"));
182  if (measure == "traveltime") {
183  if (routingAlgorithm == "dijkstra") {
184  if (net.hasPermissions()) {
185  if (oc.getInt("paths") > 1) {
188  } else {
190  ROEdge::getAllEdges(), oc.getBool("ignore-errors"), &ROEdge::getTravelTimeStatic);
191  }
192  } else {
193  if (oc.getInt("paths") > 1) {
196  } else {
198  ROEdge::getAllEdges(), oc.getBool("ignore-errors"), &ROEdge::getTravelTimeStatic);
199  }
200  }
201  } else if (routingAlgorithm == "astar") {
202  if (net.hasPermissions()) {
203  if (oc.getInt("paths") > 1) {
206  } else {
208  ROEdge::getAllEdges(), oc.getBool("ignore-errors"), &ROEdge::getTravelTimeStatic);
209  }
210  } else {
211  if (oc.getInt("paths") > 1) {
214  } else {
216  ROEdge::getAllEdges(), oc.getBool("ignore-errors"), &ROEdge::getTravelTimeStatic);
217  }
218  }
219  } else if (routingAlgorithm == "CH") {
220  const SUMOTime weightPeriod = (oc.isSet("weight-files") ?
221  string2time(oc.getString("weight-period")) :
223  if (net.hasPermissions()) {
225  ROEdge::getAllEdges(), oc.getBool("ignore-errors"), &ROEdge::getTravelTimeStatic, SVC_IGNORING, weightPeriod, true);
226  } else {
228  ROEdge::getAllEdges(), oc.getBool("ignore-errors"), &ROEdge::getTravelTimeStatic, SVC_IGNORING, weightPeriod, false);
229  }
230  } else if (routingAlgorithm == "CHWrapper") {
231  const SUMOTime weightPeriod = (oc.isSet("weight-files") ?
232  string2time(oc.getString("weight-period")) :
234 
236  ROEdge::getAllEdges(), oc.getBool("ignore-errors"), &ROEdge::getTravelTimeStatic, begin, weightPeriod);
237  } else {
238  throw ProcessError("Unknown routing Algorithm '" + routingAlgorithm + "'!");
239  }
240 
241  } else {
243  if (measure == "CO") {
244  op = &ROEdge::getEmissionEffort<PollutantsInterface::CO>;
245  } else if (measure == "CO2") {
246  op = &ROEdge::getEmissionEffort<PollutantsInterface::CO2>;
247  } else if (measure == "PMx") {
248  op = &ROEdge::getEmissionEffort<PollutantsInterface::PM_X>;
249  } else if (measure == "HC") {
250  op = &ROEdge::getEmissionEffort<PollutantsInterface::HC>;
251  } else if (measure == "NOx") {
252  op = &ROEdge::getEmissionEffort<PollutantsInterface::NO_X>;
253  } else if (measure == "fuel") {
254  op = &ROEdge::getEmissionEffort<PollutantsInterface::FUEL>;
255  } else if (measure == "electricity") {
256  op = &ROEdge::getEmissionEffort<PollutantsInterface::ELEC>;
257  } else if (measure == "noise") {
259  } else {
260  throw ProcessError("Unknown measure (weight attribute '" + measure + "')!");
261  }
262  if (net.hasPermissions()) {
263  if (oc.getInt("paths") > 1) {
266  } else {
268  ROEdge::getAllEdges(), oc.getBool("ignore-errors"), op, &ROEdge::getTravelTimeStatic);
269  }
270  } else {
271  if (oc.getInt("paths") > 1) {
274  } else {
276  ROEdge::getAllEdges(), oc.getBool("ignore-errors"), op, &ROEdge::getTravelTimeStatic);
277  }
278  }
279  }
280  try {
281  const RORouterProvider provider(router, 0, 0);
282  // prepare the output
283  net.openOutput(oc);
284  // process route definitions
285  if (oc.isSet("timeline")) {
286  matrix.applyCurve(matrix.parseTimeLine(oc.getStringVector("timeline"), oc.getBool("timeline.day-in-hours")));
287  }
288  matrix.sortByBeginTime();
289  ROVehicle defaultVehicle(SUMOVehicleParameter(), 0, net.getVehicleTypeSecure(DEFAULT_VTYPE_ID), &net);
290  ROMAAssignments a(begin, end, oc.getBool("additive-traffic"), oc.getFloat("weight-adaption"), net, matrix, *router);
291  a.resetFlows();
292 #ifdef HAVE_FOX
293  const int maxNumThreads = oc.getInt("routing-threads");
294  while ((int)net.getThreadPool().size() < maxNumThreads) {
295  new RONet::WorkerThread(net.getThreadPool(), provider);
296  }
297 #endif
298  const std::string assignMethod = oc.getString("assignment-method");
299  if (assignMethod == "incremental") {
300  a.incremental(oc.getInt("max-iterations"), oc.getBool("verbose"));
301  } else if (assignMethod == "SUE") {
302  a.sue(oc.getInt("max-iterations"), oc.getInt("max-inner-iterations"),
303  oc.getInt("paths"), oc.getFloat("paths.penalty"), oc.getFloat("tolerance"), oc.getString("route-choice-method"));
304  }
305  // update path costs and output
306  bool haveOutput = false;
307  OutputDevice* dev = net.getRouteOutput();
308  if (dev != 0) {
309  std::vector<std::string> tazParamKeys;
310  if (oc.isSet("taz-param")) {
311  tazParamKeys = oc.getStringVector("taz-param");
312  }
313  std::map<SUMOTime, std::string> sortedOut;
314  SUMOTime lastEnd = -1;
315  int num = 0;
316  for (std::vector<ODCell*>::const_iterator i = matrix.getCells().begin(); i != matrix.getCells().end(); ++i) {
317  const ODCell* const c = *i;
318  if (lastEnd >= 0 && lastEnd <= c->begin) {
319  for (std::map<SUMOTime, std::string>::const_iterator desc = sortedOut.begin(); desc != sortedOut.end(); ++desc) {
320  (*dev) << desc->second;
321  }
322  sortedOut.clear();
323  }
324  if (c->departures.empty()) {
325  OutputDevice_String od(dev->isBinary(), 1);
326  od.openTag(SUMO_TAG_FLOW).writeAttr(SUMO_ATTR_ID, oc.getString("prefix") + toString(num++));
329  matrix.writeDefaultAttrs(od, oc.getBool("ignore-vehicle-type"), c);
331  for (std::vector<RORoute*>::const_iterator j = c->pathsVector.begin(); j != c->pathsVector.end(); ++j) {
332  (*j)->setCosts(router->recomputeCosts((*j)->getEdgeVector(), &defaultVehicle, string2time(oc.getString("begin"))));
333  (*j)->writeXMLDefinition(od, 0, true, false);
334  }
335  od.closeTag();
336  od.closeTag();
337  sortedOut[c->begin] += od.getString();
338  } else {
339  for (std::map<SUMOTime, std::vector<std::string> >::const_iterator deps = c->departures.begin(); deps != c->departures.end(); ++deps) {
340  const std::string routeDistId = c->origin + "_" + c->destination + "_" + time2string(c->begin) + "_" + time2string(c->end);
341  for (std::vector<std::string>::const_iterator id = deps->second.begin(); id != deps->second.end(); ++id) {
342  OutputDevice_String od(dev->isBinary(), 1);
344  matrix.writeDefaultAttrs(od, oc.getBool("ignore-vehicle-type"), c);
346  for (std::vector<RORoute*>::const_iterator j = c->pathsVector.begin(); j != c->pathsVector.end(); ++j) {
347  (*j)->setCosts(router->recomputeCosts((*j)->getEdgeVector(), &defaultVehicle, string2time(oc.getString("begin"))));
348  (*j)->writeXMLDefinition(od, 0, true, false);
349  }
350  od.closeTag();
351  if (!tazParamKeys.empty()) {
352  od.openTag(SUMO_TAG_PARAM).writeAttr(SUMO_ATTR_KEY, tazParamKeys[0]).writeAttr(SUMO_ATTR_VALUE, c->origin).closeTag();
353  if (tazParamKeys.size() > 1) {
354  od.openTag(SUMO_TAG_PARAM).writeAttr(SUMO_ATTR_KEY, tazParamKeys[1]).writeAttr(SUMO_ATTR_VALUE, c->destination).closeTag();
355  }
356  }
357  od.closeTag();
358  sortedOut[deps->first] += od.getString();
359  }
360  }
361  }
362  for (std::vector<RORoute*>::const_iterator j = c->pathsVector.begin(); j != c->pathsVector.end(); ++j) {
363  delete *j;
364  }
365  if (c->end > lastEnd) {
366  lastEnd = c->end;
367  }
368  }
369  for (std::map<SUMOTime, std::string>::const_iterator desc = sortedOut.begin(); desc != sortedOut.end(); ++desc) {
370  (*dev) << desc->second;
371  }
372  haveOutput = true;
373  }
374  if (OutputDevice::createDeviceByOption("netload-output", "meandata")) {
375  if (oc.getBool("additive-traffic")) {
376  writeInterval(OutputDevice::getDeviceByOption("netload-output"), begin, end, net, a.getDefaultVehicle());
377  } else {
378  SUMOTime lastCell = 0;
379  for (std::vector<ODCell*>::const_iterator i = matrix.getCells().begin(); i != matrix.getCells().end(); ++i) {
380  if ((*i)->end > lastCell) {
381  lastCell = (*i)->end;
382  }
383  }
384  const SUMOTime interval = string2time(OptionsCont::getOptions().getString("aggregation-interval"));
385  for (SUMOTime start = begin; start < MIN2(end, lastCell); start += interval) {
386  writeInterval(OutputDevice::getDeviceByOption("netload-output"), start, start + interval, net, a.getDefaultVehicle());
387  }
388  }
389  haveOutput = true;
390  }
391  if (!haveOutput) {
392  throw ProcessError("No output file given.");
393  }
394  // end the processing
395  net.cleanup();
396  } catch (ProcessError&) {
397  for (std::vector<ODCell*>::const_iterator i = matrix.getCells().begin(); i != matrix.getCells().end(); ++i) {
398  for (std::vector<RORoute*>::const_iterator j = (*i)->pathsVector.begin(); j != (*i)->pathsVector.end(); ++j) {
399  delete *j;
400  }
401  }
402  net.cleanup();
403  throw;
404  }
405 }
406 
407 
408 /* -------------------------------------------------------------------------
409  * main
410  * ----------------------------------------------------------------------- */
411 int
412 main(int argc, char** argv) {
414  oc.setApplicationDescription("Import O/D-matrices for macroscopic traffic assignment");
415  oc.setApplicationName("marouter", "SUMO marouter Version " VERSION_STRING);
416  int ret = 0;
417  RONet* net = 0;
418  try {
419  XMLSubSys::init();
421  OptionsIO::setArgs(argc, argv);
423  if (oc.processMetaOptions(argc < 2)) {
425  return 0;
426  }
427  XMLSubSys::setValidation(oc.getString("xml-validation"), oc.getString("xml-validation.net"));
429  if (!ROMAFrame::checkOptions()) {
430  throw ProcessError();
431  }
433  // load data
434  ROLoader loader(oc, false, false);
435  net = new RONet();
436  initNet(*net, loader, oc);
437  if (oc.isSet("all-pairs-output")) {
438  computeAllPairs(*net, oc);
439  if (net->getDistricts().empty()) {
440  delete net;
442  if (ret == 0) {
443  std::cout << "Success." << std::endl;
444  }
445  return ret;
446  }
447  }
448  if (net->getDistricts().empty()) {
449  throw ProcessError("No districts loaded.");
450  }
451  // load districts
452  ODDistrictCont districts;
453  districts.makeDistricts(net->getDistricts());
454  // load the matrix
455  ODMatrix matrix(districts);
456  matrix.loadMatrix(oc);
457  ROMARouteHandler handler(matrix);
458  matrix.loadRoutes(oc, handler);
459  if (matrix.getNumLoaded() == 0) {
460  throw ProcessError("No vehicles loaded.");
461  }
462  if (MsgHandler::getErrorInstance()->wasInformed() && !oc.getBool("ignore-errors")) {
463  throw ProcessError("Loading failed.");
464  }
466  WRITE_MESSAGE(toString(matrix.getNumLoaded()) + " vehicles loaded.");
467 
468  // build routes and parse the incremental rates if the incremental method is choosen.
469  try {
470  computeRoutes(*net, oc, matrix);
471  } catch (XERCES_CPP_NAMESPACE::SAXParseException& e) {
472  WRITE_ERROR(toString(e.getLineNumber()));
473  ret = 1;
474  } catch (XERCES_CPP_NAMESPACE::SAXException& e) {
475  WRITE_ERROR(TplConvert::_2str(e.getMessage()));
476  ret = 1;
477  }
478  if (MsgHandler::getErrorInstance()->wasInformed() || ret != 0) {
479  throw ProcessError();
480  }
481  } catch (const ProcessError& e) {
482  if (std::string(e.what()) != std::string("Process Error") && std::string(e.what()) != std::string("")) {
483  WRITE_ERROR(e.what());
484  }
485  MsgHandler::getErrorInstance()->inform("Quitting (on error).", false);
486  ret = 1;
487  }
488 
489  delete net;
491  if (ret == 0) {
492  std::cout << "Success." << std::endl;
493  }
494  return ret;
495 }
496 
497 
498 
499 /****************************************************************************/
500 
Computes the shortest path through a contracted network.
Definition: CHRouter.h:74
OutputDevice & writeAttr(const SumoXMLAttr attr, const T &val)
writes a named attribute
Definition: OutputDevice.h:257
std::vector< std::string > getStringVector(const std::string &name) const
Returns the list of string-vector-value of the named option (only for Option_String) ...
bool hasPermissions() const
Definition: RONet.cpp:676
const std::vector< ODCell * > & getCells()
Definition: ODMatrix.h:244
static void init()
Initialises the xml-subsystem.
Definition: XMLSubSys.cpp:58
Computes the shortest path through a network using the Dijkstra algorithm.
static MsgHandler * getErrorInstance()
Returns the instance to add errors to.
Definition: MsgHandler.cpp:80
long long int SUMOTime
Definition: SUMOTime.h:43
OutputDevice * getRouteOutput(const bool alternative=false)
Definition: RONet.h:431
const std::map< std::string, std::pair< std::vector< std::string >, std::vector< std::string > > > & getDistricts() const
Retrieves all TAZ (districts) from the network.
Definition: RONet.h:153
void computeRoutes(RONet &net, OptionsCont &oc, ODMatrix &matrix)
static void getOptions(const bool commandLineOnly=false)
Parses the command line arguments and loads the configuration.
Definition: OptionsIO.cpp:72
SUMOReal getFlow(const SUMOReal time) const
Definition: ROMAEdge.h:93
assignment methods
SUMOReal getNumLoaded() const
Returns the number of loaded vehicles.
Definition: ODMatrix.cpp:486
static SUMOReal getNoiseEffort(const ROEdge *const edge, const ROVehicle *const veh, SUMOReal time)
Definition: ROEdge.cpp:183
static void setValidation(const std::string &validationScheme, const std::string &netValidationScheme)
Enables or disables validation.
Definition: XMLSubSys.cpp:69
Interface for building instances of duarouter-edges.
void makeDistricts(const std::map< std::string, std::pair< std::vector< std::string >, std::vector< std::string > > > &districts)
create districts from description
void setApplicationDescription(const std::string &appDesc)
Sets the application description.
bool getBool(const std::string &name) const
Returns the boolean-value of the named option (only for Option_Bool)
int main(int argc, char **argv)
SUMOReal getTravelTime(const ROEdge *const edge, const ROVehicle *const , SUMOReal)
static std::ostream & writeFloat(std::ostream &strm, SUMOReal value)
Writes a float binary.
std::string time2string(SUMOTime t)
Definition: SUMOTime.cpp:59
Computes the shortest path through a network using the A* algorithm.
Definition: AStarRouter.h:71
EdgeFunc getFunc() const
Returns the function of the edge.
Definition: ROEdge.h:190
static bool checkOptions()
Checks set options from the OptionsCont-singleton for being valid for usage within duarouter...
Definition: ROMAFrame.cpp:296
void computeAllPairs(RONet &net, OptionsCont &oc)
An internal edge which models vehicles driving across a junction. This is currently not used for rout...
Definition: ROEdge.h:97
SUMOReal getFloat(const std::string &name) const
Returns the SUMOReal-value of the named option (only for Option_Float)
std::vector< const ROEdge * > ConstROEdgeVector
Definition: ROEdge.h:62
Parser and container for routes during their loading.
std::vector< RORoute * > pathsVector
the list of paths / routes
Definition: ODCell.h:78
const std::string DEFAULT_VTYPE_ID
static void close()
Closes all of an applications subsystems.
Computes the shortest path through a network using the Dijkstra algorithm.
const std::map< std::string, ROEdge * > & getEdgeMap() const
Definition: RONet.cpp:643
static void setArgs(int argc, char **argv)
Stores the command line arguments for later parsing.
Definition: OptionsIO.cpp:65
static OptionsCont & getOptions()
Retrieves the options.
Definition: OptionsCont.cpp:69
void openOutput(const OptionsCont &options, const std::string altFilename="")
Opens the output for computed routes.
Definition: RONet.cpp:230
static void initRandGlobal(MTRand *which=0)
Reads the given random number options and initialises the random number generator in accordance...
Definition: RandHelper.cpp:68
void loadMatrix(OptionsCont &oc)
read a matrix in one of several formats
Definition: ODMatrix.cpp:532
std::string getString(const std::string &name) const
Returns the string-value of the named option (only for Option_String)
const std::string & getID() const
Returns the id.
Definition: Named.h:66
A vehicle as used by router.
Definition: ROVehicle.h:60
void cleanup()
closes the file output for computed routes and deletes associated threads if necessary ...
Definition: RONet.cpp:248
#define max(a, b)
Definition: polyfonts.c:65
A single O/D-matrix cell.
Definition: ODCell.h:58
void initNet(RONet &net, ROLoader &loader, OptionsCont &oc)
std::string origin
Name of the origin district.
Definition: ODCell.h:69
static SUMOReal getPenalizedTT(const ROEdge *const e, const ROVehicle *const v, SUMOReal t)
Returns the traveltime on an edge including penalties.
An O/D (origin/destination) matrix.
Definition: ODMatrix.h:76
The data loader.
Definition: ROLoader.h:63
bool processMetaOptions(bool missingOptions)
Checks for help and configuration output, returns whether we should exit.
#define STEPS2TIME(x)
Definition: SUMOTime.h:65
void loadRoutes(OptionsCont &oc, SUMOSAXHandler &handler)
read SUMO routes
Definition: ODMatrix.cpp:578
SUMOTime string2time(const std::string &r)
Definition: SUMOTime.cpp:46
A container for districts.
T MIN2(T a, T b)
Definition: StdDefs.h:69
SUMOReal vehicleNumber
The number of vehicles.
Definition: ODCell.h:60
std::map< SUMOTime, std::vector< std::string > > departures
mapping of departure times to departing vehicles, if already fixed
Definition: ODCell.h:81
int getEdgeNo() const
Returns the total number of edges the network contains including internal edges.
Definition: RONet.cpp:631
void writeInterval(OutputDevice &dev, const SUMOTime begin, const SUMOTime end, const RONet &net, const ROVehicle *const veh)
void sortByBeginTime()
Definition: ODMatrix.cpp:625
static SUMOReal getTravelTime(const ROEdge *const e, const ROVehicle *const v, SUMOReal t)
Returns the traveltime on an edge without penalties.
std::string toString(const T &t, std::streamsize accuracy=OUTPUT_ACCURACY)
Definition: ToString.h:55
static SUMOReal getPenalizedEffort(const ROEdge *const e, const ROVehicle *const v, SUMOReal t)
Returns the effort to pass an edge including penalties.
SUMOTime begin
The begin time this cell describes.
Definition: ODCell.h:63
virtual void loadNet(RONet &toFill, ROAbstractEdgeBuilder &eb)
Loads the network.
Definition: ROLoader.cpp:124
A basic edge for routing applications.
Definition: ROEdge.h:77
int getInternalEdgeNumber() const
Returns the number of internal edges the network contains.
Definition: RONet.cpp:637
#define VERSION_STRING
Definition: config.h:226
#define WRITE_ERROR(msg)
Definition: MsgHandler.h:206
static void fillOptions()
Inserts options used by duarouter into the OptionsCont-singleton.
Definition: ROMAFrame.cpp:57
static SUMOReal getCapacity(const ROEdge *edge)
The router's network representation.
Definition: RONet.h:76
Structure representing possible vehicle parameter.
SUMOReal getLength() const
Returns the length of the edge.
Definition: ROEdge.h:198
static OutputDevice & getDeviceByOption(const std::string &name)
Returns the device described by the option.
static const ROEdgeVector & getAllEdges()
Returns all ROEdges.
Definition: ROEdge.cpp:282
void inform(std::string msg, bool addType=true)
adds a new error to the list
Definition: MsgHandler.cpp:89
A storage for options typed value containers)
Definition: OptionsCont.h:99
void applyCurve(const Distribution_Points &ps)
Splits the stored cells dividing them on the given time line.
Definition: ODMatrix.cpp:519
static void setGlobalOptions(const bool interpolate)
Definition: ROEdge.h:427
static bool createDeviceByOption(const std::string &optionName, const std::string &rootElement="", const std::string &schemaFile="")
Creates the device using the output definition stored in the named option.
Static storage of an output device and its base (abstract) implementation.
Definition: OutputDevice.h:71
virtual SUMOReal recomputeCosts(const std::vector< const E * > &edges, const V *const v, SUMOTime msTime) const =0
std::string destination
Name of the destination district.
Definition: ODCell.h:72
bool closeTag()
Closes the most recently opened tag.
#define SUMOReal
Definition: config.h:214
SUMOVTypeParameter * getVehicleTypeSecure(const std::string &id)
Retrieves the named vehicle type.
Definition: RONet.cpp:272
SUMOReal getTravelTime(const ROVehicle *const veh, SUMOReal time) const
Returns the travel time for this edge.
Definition: ROEdge.cpp:159
A normal edge.
Definition: ROEdge.h:85
SUMOTime end
The end time this cell describes.
Definition: ODCell.h:66
int getInt(const std::string &name) const
Returns the int-value of the named option (only for Option_Integer)
void clear()
Clears information whether an error occured previously.
Definition: MsgHandler.cpp:149
#define WRITE_MESSAGE(msg)
Definition: MsgHandler.h:201
static void initOutputOptions()
Definition: MsgHandler.cpp:197
A basic edge for routing applications.
Definition: ROMAEdge.h:65
static std::string _2str(const int var)
convert int to string
Definition: TplConvert.h:57
bool loadWeights(RONet &net, const std::string &optionName, const std::string &measure, const bool useLanes, const bool boundariesOverride)
Loads the net weights.
Definition: ROLoader.cpp:268
SUMOReal getSpeed() const
Returns the speed allowed on this edge.
Definition: ROEdge.h:213
vehicles ignoring classes
OutputDevice & openTag(const std::string &xmlElement)
Opens an XML tag.
An output device that encapsulates an ofstream.
Distribution_Points parseTimeLine(const std::vector< std::string > &def, bool timelineDayInHours)
split the given timeline
Definition: ODMatrix.cpp:595
bool isSet(const std::string &name, bool failOnNonExistant=true) const
Returns the information whether the named option is set.
bool isBinary() const
Returns whether we have a binary output.
Definition: OutputDevice.h:245
Computes the shortest path through a contracted network.
static SUMOReal getTravelTimeStatic(const ROEdge *const edge, const ROVehicle *const veh, SUMOReal time)
Returns the travel time for the given edge.
Definition: ROEdge.h:383
void setApplicationName(const std::string &appName, const std::string &fullName)
Sets the application name.