Eclipse SUMO - Simulation of Urban MObility
RODUAFrame.cpp
Go to the documentation of this file.
1 /****************************************************************************/
2 // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3 // Copyright (C) 2001-2020 German Aerospace Center (DLR) and others.
4 // This program and the accompanying materials are made available under the
5 // terms of the Eclipse Public License 2.0 which is available at
6 // https://www.eclipse.org/legal/epl-2.0/
7 // This Source Code may also be made available under the following Secondary
8 // Licenses when the conditions for such availability set forth in the Eclipse
9 // Public License 2.0 are satisfied: GNU General Public License, version 2
10 // or later which is available at
11 // https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
12 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
13 /****************************************************************************/
20 // Sets and checks options for dua-routing
21 /****************************************************************************/
22 #include <config.h>
23 
24 #include <iostream>
25 #include <fstream>
26 #include <ctime>
28 #include <utils/options/Option.h>
31 #include <utils/common/ToString.h>
32 #include "RODUAFrame.h"
33 #include <router/ROFrame.h>
37 
38 
39 // ===========================================================================
40 // method definitions
41 // ===========================================================================
42 void
45  oc.addCallExample("-c <CONFIGURATION>", "run routing with options from file");
46 
47  // insert options sub-topics
48  SystemFrame::addConfigurationOptions(oc); // fill this subtopic, too
49  oc.addOptionSubTopic("Input");
50  oc.addOptionSubTopic("Output");
51  oc.addOptionSubTopic("Processing");
52  oc.addOptionSubTopic("Defaults");
53  oc.addOptionSubTopic("Time");
54 
55  // insert options
57  // to make the transition from --trip-files easier, but has a conflict with jtrrouter
58  oc.addSynonyme("route-files", "t", true);
60  addDUAOptions();
61  // add rand options
63 }
64 
65 
66 void
69  oc.doRegister("alternatives-output", new Option_FileName());
70  oc.addSynonyme("alternatives-output", "alternatives");
71  oc.addDescription("alternatives-output", "Output", "Write generated route alternatives to FILE");
72 
73  oc.doRegister("intermodal-network-output", new Option_FileName());
74  oc.addDescription("intermodal-network-output", "Output", "Write edge splits and connectivity to FILE");
75 
76  oc.doRegister("intermodal-weight-output", new Option_FileName());
77  oc.addDescription("intermodal-weight-output", "Output", "Write intermodal edges with lengths and travel times to FILE");
78 
79  oc.doRegister("write-trips", new Option_Bool(false));
80  oc.addDescription("write-trips", "Output", "Write trips instead of vehicles (for validating trip input)");
81 
82  oc.doRegister("write-trips.geo", new Option_Bool(false));
83  oc.addDescription("write-trips.geo", "Output", "Write trips with geo-coordinates");
84 
85  oc.doRegister("write-trips.junctions", new Option_Bool(false));
86  oc.addDescription("write-trips.junctions", "Output", "Write trips with fromJunction and toJunction");
87 
88  // register import options
89  oc.doRegister("weight-files", 'w', new Option_FileName());
90  oc.addSynonyme("weight-files", "weights");
91  oc.addDescription("weight-files", "Input", "Read network weights from FILE(s)");
92 
93  oc.doRegister("lane-weight-files", new Option_FileName());
94  oc.addDescription("lane-weight-files", "Input", "Read lane-based network weights from FILE(s)");
95 
96  oc.doRegister("weight-attribute", 'x', new Option_String("traveltime"));
97  oc.addSynonyme("weight-attribute", "measure", true);
98  oc.addDescription("weight-attribute", "Input", "Name of the xml attribute which gives the edge weight");
99 
100  // register further processing options
101  // ! The subtopic "Processing" must be initialised earlier !
102  oc.doRegister("weights.expand", new Option_Bool(false));
103  oc.addSynonyme("weights.expand", "expand-weights", true);
104  oc.addDescription("weights.expand", "Processing", "Expand weights behind the simulation's end");
105 
106  oc.doRegister("weights.random-factor", new Option_Float(1.));
107  oc.addDescription("weights.random-factor", "Processing", "Edge weights for routing are dynamically disturbed by a random factor drawn uniformly from [1,FLOAT)");
108 
109  oc.doRegister("routing-algorithm", new Option_String("dijkstra"));
110  oc.addDescription("routing-algorithm", "Processing", "Select among routing algorithms ['dijkstra', 'astar', 'CH', 'CHWrapper']");
111 
112  oc.doRegister("weight-period", new Option_String("3600", "TIME"));
113  oc.addDescription("weight-period", "Processing", "Aggregation period for the given weight files; triggers rebuilding of Contraction Hierarchy");
114 
115  oc.doRegister("weights.priority-factor", new Option_Float(0));
116  oc.addDescription("weights.priority-factor", "Processing", "Consider edge priorities in addition to travel times, weighted by factor");
117 
118  oc.doRegister("astar.all-distances", new Option_FileName());
119  oc.addDescription("astar.all-distances", "Processing", "Initialize lookup table for astar from the given file (generated by marouter --all-pairs-output)");
120 
121  oc.doRegister("astar.landmark-distances", new Option_FileName());
122  oc.addDescription("astar.landmark-distances", "Processing", "Initialize lookup table for astar ALT-variant from the given file");
123 
124  oc.doRegister("astar.save-landmark-distances", new Option_FileName());
125  oc.addDescription("astar.save-landmark-distances", "Processing", "Save lookup table for astar ALT-variant to the given file");
126 }
127 
128 
129 void
132  // register Gawron's DUE-settings
133  oc.doRegister("gawron.beta", new Option_Float(double(0.3)));
134  oc.addSynonyme("gawron.beta", "gBeta", true);
135  oc.addDescription("gawron.beta", "Processing", "Use FLOAT as Gawron's beta");
136 
137  oc.doRegister("gawron.a", new Option_Float(double(0.05)));
138  oc.addSynonyme("gawron.a", "gA", true);
139  oc.addDescription("gawron.a", "Processing", "Use FLOAT as Gawron's a");
140 
141  oc.doRegister("exit-times", new Option_Bool(false));
142  oc.addDescription("exit-times", "Output", "Write exit times (weights) for each edge");
143 
144  oc.doRegister("keep-all-routes", new Option_Bool(false));
145  oc.addDescription("keep-all-routes", "Processing", "Save routes with near zero probability");
146 
147  oc.doRegister("skip-new-routes", new Option_Bool(false));
148  oc.addDescription("skip-new-routes", "Processing", "Only reuse routes from input, do not calculate new ones");
149 
150  oc.doRegister("ptline-routing", new Option_Bool(false));
151  oc.addDescription("ptline-routing", "Processing", "Route all public transport input");
152 
153  oc.doRegister("logit", new Option_Bool(false)); // deprecated
154  oc.addDescription("logit", "Processing", "Use c-logit model (deprecated in favor of --route-choice-method logit)");
155 
156  oc.doRegister("route-choice-method", new Option_String("gawron"));
157  oc.addDescription("route-choice-method", "Processing", "Choose a route choice method: gawron, logit, or lohse");
158 
159  oc.doRegister("logit.beta", new Option_Float(double(-1)));
160  oc.addSynonyme("logit.beta", "lBeta", true);
161  oc.addDescription("logit.beta", "Processing", "Use FLOAT as logit's beta");
162 
163  oc.doRegister("logit.gamma", new Option_Float(double(1)));
164  oc.addSynonyme("logit.gamma", "lGamma", true);
165  oc.addDescription("logit.gamma", "Processing", "Use FLOAT as logit's gamma");
166 
167  oc.doRegister("logit.theta", new Option_Float(double(-1)));
168  oc.addSynonyme("logit.theta", "lTheta", true);
169  oc.addDescription("logit.theta", "Processing", "Use FLOAT as logit's theta (negative values mean auto-estimation)");
170 
171  oc.doRegister("persontrip.walkfactor", new Option_Float(double(0.75)));
172  oc.addDescription("persontrip.walkfactor", "Processing", "Use FLOAT as a factor on pedestrian maximum speed during intermodal routing");
173 
174  oc.doRegister("persontrip.transfer.car-walk", new Option_StringVector(StringVector({ "parkingAreas" })));
175  oc.addDescription("persontrip.transfer.car-walk", "Processing",
176  "Where are mode changes from car to walking allowed (possible values: 'parkingAreas', 'ptStops', 'allJunctions' and combinations)");
177 
178  oc.doRegister("persontrip.transfer.taxi-walk", new Option_StringVector());
179  oc.addDescription("persontrip.transfer.taxi-walk", "Processing", "Where taxis can drop off customers ('allJunctions, 'ptStops')");
180 
181  oc.doRegister("persontrip.transfer.walk-taxi", new Option_StringVector());
182  oc.addDescription("persontrip.transfer.walk-taxi", "Processing", "Where taxis can pick up customers ('allJunctions, 'ptStops')");
183 
184  oc.doRegister("persontrip.taxi.waiting-time", new Option_String("300", "TIME"));
185  oc.addDescription("persontrip.taxi.waiting-time", "Processing", "Estimated time for taxi pickup");
186 
187  oc.doRegister("railway.max-train-length", new Option_Float(5000.0));
188  oc.addDescription("railway.max-train-length", "Processing", "Use FLOAT as a maximum train length when initializing the railway router");
189 }
190 
191 
192 bool
195  bool ok = ROFrame::checkOptions(oc);
196 
198  std::string error;
199  if (oc.isSet("departlane") && !SUMOVehicleParameter::parseDepartLane(oc.getString("departlane"), "option", "departlane", p.departLane, p.departLaneProcedure, error)) {
200  WRITE_ERROR(error);
201  ok = false;
202  }
203  if (oc.isSet("departpos") && !SUMOVehicleParameter::parseDepartPos(oc.getString("departpos"), "option", "departpos", p.departPos, p.departPosProcedure, error)) {
204  WRITE_ERROR(error);
205  ok = false;
206  }
207  if (oc.isSet("departspeed") && !SUMOVehicleParameter::parseDepartSpeed(oc.getString("departspeed"), "option", "departspeed", p.departSpeed, p.departSpeedProcedure, error)) {
208  WRITE_ERROR(error);
209  ok = false;
210  }
211  if (oc.isSet("arrivallane") && !SUMOVehicleParameter::parseArrivalLane(oc.getString("arrivallane"), "option", "arrivallane", p.arrivalLane, p.arrivalLaneProcedure, error)) {
212  WRITE_ERROR(error);
213  ok = false;
214  }
215  if (oc.isSet("arrivalpos") && !SUMOVehicleParameter::parseArrivalPos(oc.getString("arrivalpos"), "option", "arrivalpos", p.arrivalPos, p.arrivalPosProcedure, error)) {
216  WRITE_ERROR(error);
217  ok = false;
218  }
219  if (oc.isSet("arrivalspeed") && !SUMOVehicleParameter::parseArrivalSpeed(oc.getString("arrivalspeed"), "option", "arrivalspeed", p.arrivalSpeed, p.arrivalSpeedProcedure, error)) {
220  WRITE_ERROR(error);
221  ok = false;
222  }
223 
224  if (oc.getString("routing-algorithm") != "dijkstra" && oc.getString("weight-attribute") != "traveltime") {
225  WRITE_ERROR("Routing algorithm '" + oc.getString("routing-algorithm") + "' does not support weight-attribute '" + oc.getString("weight-attribute") + "'.");
226  return false;
227  }
228  if (oc.getBool("bulk-routing") && (oc.getString("routing-algorithm") == "CH" || oc.getString("routing-algorithm") == "CHWrapper")) {
229  WRITE_ERROR("Routing algorithm '" + oc.getString("routing-algorithm") + "' does not support bulk routing.");
230  return false;
231  }
232  if (oc.isDefault("routing-algorithm") && (oc.isSet("astar.all-distances") || oc.isSet("astar.landmark-distances") || oc.isSet("astar.save-landmark-distances"))) {
233  oc.set("routing-algorithm", "astar");
234  }
235 
236  if (oc.getString("route-choice-method") != "gawron" && oc.getString("route-choice-method") != "logit") {
237  WRITE_ERROR("Invalid route choice method '" + oc.getString("route-choice-method") + "'.");
238  return false;
239  }
240  if (oc.getBool("logit")) {
241  WRITE_WARNING("The --logit option is deprecated, please use --route-choice-method logit.");
242  oc.set("route-choice-method", "logit");
243  }
244 
245  if (oc.isSet("output-file") && !oc.isSet("alternatives-output")) {
246  const std::string& filename = oc.getString("output-file");
247  const int len = (int)filename.length();
248  if (len > 4 && filename.substr(len - 4) == ".xml") {
249  oc.set("alternatives-output", filename.substr(0, len - 4) + ".alt.xml");
250  } else if (len > 4 && filename.substr(len - 3) == ".gz") {
251  oc.set("alternatives-output", filename.substr(0, len - 3) + ".alt.gz");
252  } else {
253  WRITE_WARNING("Cannot derive file name for alternatives output, skipping it.");
254  }
255  }
256  if (oc.getBool("write-trips.junctions")) {
257  if (oc.isDefault("write-trips")) {
258  oc.set("write-trips", "true");
259  } else if (!oc.getBool("write-trips")) {
260  WRITE_WARNING("Option --write-trips.junctions takes no affect when --write-trips is disabled.");
261  }
262  }
263  return ok;
264 }
265 
266 
267 /****************************************************************************/
#define WRITE_ERROR(msg)
Definition: MsgHandler.h:284
#define WRITE_WARNING(msg)
Definition: MsgHandler.h:276
std::vector< std::string > StringVector
Definition of a vector of strings.
Definition: Option.h:43
A storage for options typed value containers)
Definition: OptionsCont.h:89
void addDescription(const std::string &name, const std::string &subtopic, const std::string &description)
Adds a description for an option.
void doRegister(const std::string &name, Option *v)
Adds an option under the given name.
Definition: OptionsCont.cpp:75
bool isSet(const std::string &name, bool failOnNonExistant=true) const
Returns the information whether the named option is set.
bool set(const std::string &name, const std::string &value)
Sets the given value for the named option.
std::string getString(const std::string &name) const
Returns the string-value of the named option (only for Option_String)
void addSynonyme(const std::string &name1, const std::string &name2, bool isDeprecated=false)
Adds a synonyme for an options name (any order)
Definition: OptionsCont.cpp:96
bool isDefault(const std::string &name) const
Returns the information whether the named option has still the default value.
void addOptionSubTopic(const std::string &topic)
Adds an option subtopic.
bool getBool(const std::string &name) const
Returns the boolean-value of the named option (only for Option_Bool)
static OptionsCont & getOptions()
Retrieves the options.
Definition: OptionsCont.cpp:58
void addCallExample(const std::string &example, const std::string &desc)
Add a call example.
static void addImportOptions()
Inserts import options used by duarouter into the OptionsCont-singleton.
Definition: RODUAFrame.cpp:67
static void addDUAOptions()
Inserts dua options used by duarouter into the OptionsCont-singleton.
Definition: RODUAFrame.cpp:130
static void fillOptions()
Inserts options used by duarouter into the OptionsCont-singleton.
Definition: RODUAFrame.cpp:43
static bool checkOptions()
Checks set options from the OptionsCont-singleton for being valid for usage within duarouter.
Definition: RODUAFrame.cpp:193
static bool checkOptions(OptionsCont &oc)
Checks whether options are valid.
Definition: ROFrame.cpp:184
static void fillOptions(OptionsCont &oc)
Inserts options used by routing applications into the OptionsCont-singleton.
Definition: ROFrame.cpp:42
static void insertRandOptions()
Initialises the given options container with random number options.
Definition: RandHelper.cpp:44
Structure representing possible vehicle parameter.
int departLane
(optional) The lane the vehicle shall depart from (index in edge)
ArrivalSpeedDefinition arrivalSpeedProcedure
Information how the vehicle's end speed shall be chosen.
double departSpeed
(optional) The initial speed of the vehicle
static bool parseArrivalLane(const std::string &val, const std::string &element, const std::string &id, int &lane, ArrivalLaneDefinition &ald, std::string &error)
Validates a given arrivalLane value.
ArrivalLaneDefinition arrivalLaneProcedure
Information how the vehicle shall choose the lane to arrive on.
DepartLaneDefinition departLaneProcedure
Information how the vehicle shall choose the lane to depart from.
static bool parseDepartSpeed(const std::string &val, const std::string &element, const std::string &id, double &speed, DepartSpeedDefinition &dsd, std::string &error)
Validates a given departSpeed value.
static bool parseArrivalPos(const std::string &val, const std::string &element, const std::string &id, double &pos, ArrivalPosDefinition &apd, std::string &error)
Validates a given arrivalPos value.
static bool parseArrivalSpeed(const std::string &val, const std::string &element, const std::string &id, double &speed, ArrivalSpeedDefinition &asd, std::string &error)
Validates a given arrivalSpeed value.
double departPos
(optional) The position the vehicle shall depart from
DepartSpeedDefinition departSpeedProcedure
Information how the vehicle's initial speed shall be chosen.
double arrivalPos
(optional) The position the vehicle shall arrive on
static bool parseDepartLane(const std::string &val, const std::string &element, const std::string &id, int &lane, DepartLaneDefinition &dld, std::string &error)
Validates a given departLane value.
ArrivalPosDefinition arrivalPosProcedure
Information how the vehicle shall choose the arrival position.
double arrivalSpeed
(optional) The final speed of the vehicle (not used yet)
static bool parseDepartPos(const std::string &val, const std::string &element, const std::string &id, double &pos, DepartPosDefinition &dpd, std::string &error)
Validates a given departPos value.
DepartPosDefinition departPosProcedure
Information how the vehicle shall choose the departure position.
static void addConfigurationOptions(OptionsCont &oc)
Adds configuration options to the given container.
Definition: SystemFrame.cpp:38