Eclipse SUMO - Simulation of Urban MObility
Loading...
Searching...
No Matches
MSFrame.cpp
Go to the documentation of this file.
1/****************************************************************************/
2// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3// Copyright (C) 2002-2023 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/****************************************************************************/
24// Sets and checks options for microsim; inits global outputs and settings
25/****************************************************************************/
26#include <config.h>
27
28#include <iostream>
29#include <iomanip>
30#include <fstream>
31#include <ctime>
42#include <microsim/MSJunction.h>
43#include <microsim/MSRoute.h>
44#include <microsim/MSNet.h>
45#include <microsim/MSLane.h>
46#include <microsim/MSGlobals.h>
52#include "MSFrame.h"
54
55
56// ===========================================================================
57// method definitions
58// ===========================================================================
59void
62 oc.addCallExample("-b 0 -e 1000 -n net.xml -r routes.xml", "start a simulation from time 0 to 1000 with given net and routes");
63 oc.addCallExample("-c munich_config.cfg", "start with a configuration file");
64 oc.addCallExample("--help", "print help");
65
66 // insert options sub-topics
67 SystemFrame::addConfigurationOptions(oc); // fill this subtopic, too
68 oc.addOptionSubTopic("Input");
69 oc.addOptionSubTopic("Output");
70 oc.addOptionSubTopic("Time");
71 oc.addOptionSubTopic("Processing");
72 oc.addOptionSubTopic("Routing");
73
74 // register configuration options
75 // register input options
76 oc.doRegister("net-file", 'n', new Option_FileName());
77 oc.addSynonyme("net-file", "net");
78 oc.addDescription("net-file", "Input", TL("Load road network description from FILE"));
79 oc.addXMLDefault("net-file", "net");
80
81 oc.doRegister("route-files", 'r', new Option_FileName());
82 oc.addSynonyme("route-files", "routes");
83 oc.addDescription("route-files", "Input", TL("Load routes descriptions from FILE(s)"));
84
85 oc.doRegister("additional-files", 'a', new Option_FileName());
86 oc.addSynonyme("additional-files", "additional");
87 oc.addDescription("additional-files", "Input", TL("Load further descriptions from FILE(s)"));
88
89 oc.doRegister("weight-files", 'w', new Option_FileName());
90 oc.addSynonyme("weight-files", "weights");
91 oc.addDescription("weight-files", "Input", TL("Load edge/lane weights for online rerouting from FILE"));
92 oc.doRegister("weight-attribute", 'x', new Option_String("traveltime"));
93 oc.addSynonyme("weight-attribute", "measure", true);
94 oc.addDescription("weight-attribute", "Input", TL("Name of the xml attribute which gives the edge weight"));
95
96 oc.doRegister("load-state", new Option_FileName());
97 oc.addDescription("load-state", "Input", TL("Loads a network state from FILE"));
98 oc.doRegister("load-state.offset", new Option_String("0", "TIME"));
99 oc.addDescription("load-state.offset", "Input", TL("Shifts all times loaded from a saved state by the given offset"));
100 oc.doRegister("load-state.remove-vehicles", new Option_StringVector(StringVector({""})));
101 oc.addDescription("load-state.remove-vehicles", "Input", TL("Removes vehicles with the given IDs from the loaded state"));
102
103 oc.doRegister("junction-taz", new Option_Bool(false));
104 oc.addDescription("junction-taz", "Input", TL("Initialize a TAZ for every junction to use attributes toJunction and fromJunction"));
105
106 // need to do this here to be able to check for network and route input options
108
109 // register output options
110 oc.doRegister("netstate-dump", new Option_FileName());
111 oc.addSynonyme("netstate-dump", "ndump");
112 oc.addSynonyme("netstate-dump", "netstate");
113 oc.addSynonyme("netstate-dump", "netstate-output");
114 oc.addDescription("netstate-dump", "Output", TL("Save complete network states into FILE"));
115 oc.doRegister("netstate-dump.empty-edges", new Option_Bool(false));
116 oc.addSynonyme("netstate-dump.empty-edges", "netstate.empty-edges");
117 oc.addSynonyme("netstate-dump.empty-edges", "netstate-output.empty-edges");
118 oc.addSynonyme("netstate-dump.empty-edges", "dump-empty-edges", true);
119 oc.addDescription("netstate-dump.empty-edges", "Output", TL("Write also empty edges completely when dumping"));
120 oc.doRegister("netstate-dump.precision", new Option_Integer(2));
121 oc.addSynonyme("netstate-dump.precision", "netstate.precision");
122 oc.addSynonyme("netstate-dump.precision", "netstate-output.precision");
123 oc.addSynonyme("netstate-dump.precision", "dump-precision", true);
124 oc.addDescription("netstate-dump.precision", "Output", TL("Write positions and speeds with the given precision (default 2)"));
125
126
127 oc.doRegister("emission-output", new Option_FileName());
128 oc.addDescription("emission-output", "Output", TL("Save the emission values of each vehicle"));
129 oc.doRegister("emission-output.precision", new Option_Integer(2));
130 oc.addDescription("emission-output.precision", "Output", TL("Write emission values with the given precision (default 2)"));
131 oc.doRegister("emission-output.geo", new Option_Bool(false));
132 oc.addDescription("emission-output.geo", "Output", TL("Save the positions in emission output using geo-coordinates (lon/lat)"));
133
134 oc.doRegister("emission-output.step-scaled", new Option_Bool(false));
135 oc.addDescription("emission-output.step-scaled", "Output", TL("Write emission values scaled to the step length rather than as per-second values"));
136
137 oc.doRegister("battery-output", new Option_FileName());
138 oc.addDescription("battery-output", "Output", TL("Save the battery values of each vehicle"));
139 oc.doRegister("battery-output.precision", new Option_Integer(2));
140 oc.addDescription("battery-output.precision", "Output", TL("Write battery values with the given precision (default 2)"));
141
142 oc.doRegister("elechybrid-output", new Option_FileName());
143 oc.addDescription("elechybrid-output", "Output", TL("Save the elecHybrid values of each vehicle"));
144 oc.doRegister("elechybrid-output.precision", new Option_Integer(2));
145 oc.addDescription("elechybrid-output.precision", "Output", TL("Write elecHybrid values with the given precision (default 2)"));
146 oc.doRegister("elechybrid-output.aggregated", new Option_Bool(false));
147 oc.addDescription("elechybrid-output.aggregated", "Output", TL("Write elecHybrid values into one aggregated file"));
148
149 oc.doRegister("chargingstations-output", new Option_FileName());
150 oc.addDescription("chargingstations-output", "Output", TL("Write data of charging stations"));
151
152 oc.doRegister("overheadwiresegments-output", new Option_FileName());
153 oc.addDescription("overheadwiresegments-output", "Output", TL("Write data of overhead wire segments"));
154
155 oc.doRegister("substations-output", new Option_FileName());
156 oc.addDescription("substations-output", "Output", TL("Write data of electrical substation stations"));
157 oc.doRegister("substations-output.precision", new Option_Integer(2));
158 oc.addDescription("substations-output.precision", "Output", TL("Write substation values with the given precision (default 2)"));
159
160 oc.doRegister("fcd-output", new Option_FileName());
161 oc.addDescription("fcd-output", "Output", TL("Save the Floating Car Data"));
162 oc.doRegister("fcd-output.geo", new Option_Bool(false));
163 oc.addDescription("fcd-output.geo", "Output", TL("Save the Floating Car Data using geo-coordinates (lon/lat)"));
164 oc.doRegister("fcd-output.signals", new Option_Bool(false));
165 oc.addDescription("fcd-output.signals", "Output", TL("Add the vehicle signal state to the FCD output (brake lights etc.)"));
166 oc.doRegister("fcd-output.distance", new Option_Bool(false));
167 oc.addDescription("fcd-output.distance", "Output", TL("Add kilometrage to the FCD output (linear referencing)"));
168 oc.doRegister("fcd-output.acceleration", new Option_Bool(false));
169 oc.addDescription("fcd-output.acceleration", "Output", TL("Add acceleration to the FCD output"));
170 oc.doRegister("fcd-output.max-leader-distance", new Option_Float(-1));
171 oc.addDescription("fcd-output.max-leader-distance", "Output", TL("Add leader vehicle information to the FCD output (within the given distance)"));
172 oc.doRegister("fcd-output.params", new Option_StringVector());
173 oc.addDescription("fcd-output.params", "Output", TL("Add generic parameter values to the FCD output"));
174 oc.doRegister("fcd-output.filter-edges.input-file", new Option_FileName());
175 oc.addDescription("fcd-output.filter-edges.input-file", "Output", TL("Restrict fcd output to the edge selection from the given input file"));
176 oc.doRegister("fcd-output.attributes", new Option_StringVector());
177 oc.addDescription("fcd-output.attributes", "Output", TL("List attributes that should be included in the FCD output"));
178 oc.doRegister("fcd-output.filter-shapes", new Option_StringVector());
179 oc.addDescription("fcd-output.filter-shapes", "Output", TL("List shape names that should be used to filter the FCD output"));
180
181 oc.doRegister("device.ssm.filter-edges.input-file", new Option_FileName());
182 oc.addDescription("device.ssm.filter-edges.input-file", "Output", TL("Restrict SSM device output to the edge selection from the given input file"));
183
184 oc.doRegister("full-output", new Option_FileName());
185 oc.addDescription("full-output", "Output", TL("Save a lot of information for each timestep (very redundant)"));
186
187 oc.doRegister("queue-output", new Option_FileName());
188 oc.addDescription("queue-output", "Output", TL("Save the vehicle queues at the junctions (experimental)"));
189 oc.doRegister("queue-output.period", new Option_String("-1", "TIME"));
190 oc.addDescription("queue-output.period", "Output", TL("Save vehicle queues with the given period"));
191
192 oc.doRegister("vtk-output", new Option_FileName());
193 oc.addDescription("vtk-output", "Output", TL("Save complete vehicle positions inclusive speed values in the VTK Format (usage: /path/out will produce /path/out_$TIMESTEP$.vtp files)"));
194 oc.doRegister("amitran-output", new Option_FileName());
195 oc.addDescription("amitran-output", "Output", TL("Save the vehicle trajectories in the Amitran format"));
196
197
198 oc.doRegister("summary-output", new Option_FileName());
199 oc.addSynonyme("summary-output", "summary");
200 oc.addDescription("summary-output", "Output", TL("Save aggregated vehicle departure info into FILE"));
201
202 oc.doRegister("summary-output.period", new Option_String("-1", "TIME"));
203 oc.addDescription("summary-output.period", "Output", TL("Save summary-output with the given period"));
204
205 oc.doRegister("person-summary-output", new Option_FileName());
206 oc.addDescription("person-summary-output", "Output", TL("Save aggregated person counts into FILE"));
207
208 oc.doRegister("tripinfo-output", new Option_FileName());
209 oc.addSynonyme("tripinfo-output", "tripinfo");
210 oc.addDescription("tripinfo-output", "Output", TL("Save single vehicle trip info into FILE"));
211
212 oc.doRegister("tripinfo-output.write-unfinished", new Option_Bool(false));
213 oc.addDescription("tripinfo-output.write-unfinished", "Output", TL("Write tripinfo output for vehicles which have not arrived at simulation end"));
214
215 oc.doRegister("tripinfo-output.write-undeparted", new Option_Bool(false));
216 oc.addDescription("tripinfo-output.write-undeparted", "Output", TL("Write tripinfo output for vehicles which have not departed at simulation end because of depart delay"));
217
218 oc.doRegister("personinfo-output", new Option_FileName());
219 oc.addSynonyme("personinfo-output", "personinfo");
220 oc.addDescription("personinfo-output", "Output", TL("Save personinfo and containerinfo to separate FILE"));
221
222 oc.doRegister("vehroute-output", new Option_FileName());
223 oc.addSynonyme("vehroute-output", "vehroutes");
224 oc.addDescription("vehroute-output", "Output", TL("Save single vehicle route info into FILE"));
225
226 oc.doRegister("vehroute-output.exit-times", new Option_Bool(false));
227 oc.addSynonyme("vehroute-output.exit-times", "vehroutes.exit-times");
228 oc.addDescription("vehroute-output.exit-times", "Output", TL("Write the exit times for all edges"));
229
230 oc.doRegister("vehroute-output.last-route", new Option_Bool(false));
231 oc.addSynonyme("vehroute-output.last-route", "vehroutes.last-route");
232 oc.addDescription("vehroute-output.last-route", "Output", TL("Write the last route only"));
233
234 oc.doRegister("vehroute-output.sorted", new Option_Bool(false));
235 oc.addSynonyme("vehroute-output.sorted", "vehroutes.sorted");
236 oc.addDescription("vehroute-output.sorted", "Output", TL("Sorts the output by departure time"));
237
238 oc.doRegister("vehroute-output.dua", new Option_Bool(false));
239 oc.addSynonyme("vehroute-output.dua", "vehroutes.dua");
240 oc.addDescription("vehroute-output.dua", "Output", TL("Write the output in the duarouter alternatives style"));
241
242 oc.doRegister("vehroute-output.cost", new Option_Bool(false));
243 oc.addDescription("vehroute-output.cost", "Output", TL("Write costs for all routes"));
244
245 oc.doRegister("vehroute-output.intended-depart", new Option_Bool(false));
246 oc.addSynonyme("vehroute-output.intended-depart", "vehroutes.intended-depart");
247 oc.addDescription("vehroute-output.intended-depart", "Output", TL("Write the output with the intended instead of the real departure time"));
248
249 oc.doRegister("vehroute-output.route-length", new Option_Bool(false));
250 oc.addSynonyme("vehroute-output.route-length", "vehroutes.route-length");
251 oc.addDescription("vehroute-output.route-length", "Output", TL("Include total route length in the output"));
252
253 oc.doRegister("vehroute-output.write-unfinished", new Option_Bool(false));
254 oc.addDescription("vehroute-output.write-unfinished", "Output", TL("Write vehroute output for vehicles which have not arrived at simulation end"));
255
256 oc.doRegister("vehroute-output.skip-ptlines", new Option_Bool(false));
257 oc.addDescription("vehroute-output.skip-ptlines", "Output", TL("Skip vehroute output for public transport vehicles"));
258
259 oc.doRegister("vehroute-output.incomplete", new Option_Bool(false));
260 oc.addDescription("vehroute-output.incomplete", "Output", TL("Include invalid routes and route stubs in vehroute output"));
261
262 oc.doRegister("vehroute-output.stop-edges", new Option_Bool(false));
263 oc.addDescription("vehroute-output.stop-edges", "Output", TL("Include information about edges between stops"));
264
265 oc.doRegister("vehroute-output.speedfactor", new Option_Bool(false));
266 oc.addDescription("vehroute-output.speedfactor", "Output", TL("Write the vehicle speedFactor (defaults to 'true' if departSpeed is written)"));
267
268 oc.doRegister("vehroute-output.internal", new Option_Bool(false));
269 oc.addDescription("vehroute-output.internal", "Output", TL("Include internal edges in the output"));
270
271 oc.doRegister("personroute-output", new Option_FileName());
272 oc.addSynonyme("personroute-output", "personroutes");
273 oc.addDescription("personroute-output", "Output", TL("Save person and container routes to separate FILE"));
274
275 oc.doRegister("link-output", new Option_FileName());
276 oc.addDescription("link-output", "Output", TL("Save links states into FILE"));
277
278 oc.doRegister("railsignal-block-output", new Option_FileName());
279 oc.addDescription("railsignal-block-output", "Output", TL("Save railsignal-blocks into FILE"));
280
281 oc.doRegister("bt-output", new Option_FileName());
282 oc.addDescription("bt-output", "Output", TL("Save bluetooth visibilities into FILE (in conjunction with device.btreceiver and device.btsender)"));
283
284 oc.doRegister("lanechange-output", new Option_FileName());
285 oc.addDescription("lanechange-output", "Output", TL("Record lane changes and their motivations for all vehicles into FILE"));
286
287 oc.doRegister("lanechange-output.started", new Option_Bool(false));
288 oc.addDescription("lanechange-output.started", "Output", TL("Record start of lane change manoeuvres"));
289
290 oc.doRegister("lanechange-output.ended", new Option_Bool(false));
291 oc.addDescription("lanechange-output.ended", "Output", TL("Record end of lane change manoeuvres"));
292
293 oc.doRegister("lanechange-output.xy", new Option_Bool(false));
294 oc.addDescription("lanechange-output.xy", "Output", TL("Record coordinates of lane change manoeuvres"));
295
296 oc.doRegister("stop-output", new Option_FileName());
297 oc.addDescription("stop-output", "Output", TL("Record stops and loading/unloading of passenger and containers for all vehicles into FILE"));
298 oc.doRegister("stop-output.write-unfinished", new Option_Bool(false));
299 oc.addDescription("stop-output.write-unfinished", "Output", TL("Write stop output for stops which have not ended at simulation end"));
300
301 oc.doRegister("collision-output", new Option_FileName());
302 oc.addDescription("collision-output", "Output", TL("Write collision information into FILE"));
303
304 oc.doRegister("edgedata-output", new Option_FileName());
305 oc.addDescription("edgedata-output", "Output", TL("Write aggregated traffic statistics for all edges into FILE"));
306 oc.doRegister("lanedata-output", new Option_FileName());
307 oc.addDescription("lanedata-output", "Output", TL("Write aggregated traffic statistics for all lanes into FILE"));
308
309 oc.doRegister("statistic-output", new Option_FileName());
310 oc.addSynonyme("statistic-output", "statistics-output");
311 oc.addDescription("statistic-output", "Output", TL("Write overall statistics into FILE"));
312
313#ifdef _DEBUG
314 oc.doRegister("movereminder-output", new Option_FileName());
315 oc.addDescription("movereminder-output", "Output", TL("Save movereminder states of selected vehicles into FILE"));
316 oc.doRegister("movereminder-output.vehicles", new Option_StringVector());
317 oc.addDescription("movereminder-output.vehicles", "Output", TL("List of vehicle ids which shall save their movereminder states"));
318#endif
319
320 oc.doRegister("save-state.times", new Option_StringVector());
321 oc.addDescription("save-state.times", "Output", TL("Use TIME[] as times at which a network state written"));
322 oc.doRegister("save-state.period", new Option_String("-1", "TIME"));
323 oc.addDescription("save-state.period", "Output", TL("save state repeatedly after TIME period"));
324 oc.doRegister("save-state.period.keep", new Option_Integer(0));
325 oc.addDescription("save-state.period.keep", "Output", TL("Keep only the last INT periodic state files"));
326 oc.doRegister("save-state.prefix", new Option_FileName(StringVector({ "state" })));
327 oc.addDescription("save-state.prefix", "Output", TL("Prefix for network states"));
328 oc.doRegister("save-state.suffix", new Option_String(".xml.gz"));
329 oc.addDescription("save-state.suffix", "Output", TL("Suffix for network states (.xml.gz or .xml)"));
330 oc.doRegister("save-state.files", new Option_FileName());
331 oc.addDescription("save-state.files", "Output", TL("Files for network states"));
332 oc.doRegister("save-state.rng", new Option_Bool(false));
333 oc.addDescription("save-state.rng", "Output", TL("Save random number generator states"));
334 oc.doRegister("save-state.transportables", new Option_Bool(false));
335 oc.addDescription("save-state.transportables", "Output", TL("Save person and container states (experimental)"));
336 oc.doRegister("save-state.constraints", new Option_Bool(false));
337 oc.addDescription("save-state.constraints", "Output", TL("Save rail signal constraints"));
338 oc.doRegister("save-state.precision", new Option_Integer(2));
339 oc.addDescription("save-state.precision", "Output", TL("Write internal state values with the given precision (default 2)"));
340
341 // register the simulation settings
342 oc.doRegister("begin", 'b', new Option_String("0", "TIME"));
343 oc.addDescription("begin", "Time", TL("Defines the begin time in seconds; The simulation starts at this time"));
344
345 oc.doRegister("end", 'e', new Option_String("-1", "TIME"));
346 oc.addDescription("end", "Time", TL("Defines the end time in seconds; The simulation ends at this time"));
347
348 oc.doRegister("step-length", new Option_String("1", "TIME"));
349 oc.addDescription("step-length", "Time", TL("Defines the step duration in seconds"));
350
351 oc.doRegister("step-method.ballistic", new Option_Bool(false));
352 oc.addDescription("step-method.ballistic", "Processing", TL("Whether to use ballistic method for the positional update of vehicles (default is a semi-implicit Euler method)."));
353
354 oc.doRegister("extrapolate-departpos", new Option_Bool(false));
355 oc.addDescription("extrapolate-departpos", "Processing", TL("Whether vehicles that depart between simulation steps should extrapolate the depart position"));
356
357 oc.doRegister("threads", new Option_Integer(1));
358 oc.addDescription("threads", "Processing", TL("Defines the number of threads for parallel simulation"));
359
360 oc.doRegister("lateral-resolution", new Option_Float(-1));
361 oc.addDescription("lateral-resolution", "Processing", TL("Defines the resolution in m when handling lateral positioning within a lane (with -1 all vehicles drive at the center of their lane"));
362
363 // register the processing options
364 oc.doRegister("route-steps", 's', new Option_String("200", "TIME"));
365 oc.addDescription("route-steps", "Processing", TL("Load routes for the next number of seconds ahead"));
366
367 oc.doRegister("no-internal-links", new Option_Bool(false));
368 oc.addDescription("no-internal-links", "Processing", TL("Disable (junction) internal links"));
369
370 oc.doRegister("ignore-junction-blocker", new Option_String("-1", "TIME"));
371 oc.addDescription("ignore-junction-blocker", "Processing", TL("Ignore vehicles which block the junction after they have been standing for SECONDS (-1 means never ignore)"));
372
373 oc.doRegister("ignore-route-errors", new Option_Bool(false));
374 oc.addDescription("ignore-route-errors", "Processing", TL("Do not check whether routes are connected"));
375
376 oc.doRegister("ignore-accidents", new Option_Bool(false));
377 oc.addDescription("ignore-accidents", "Processing", TL("Do not check whether accidents occur"));
378
379 oc.doRegister("collision.action", new Option_String("teleport"));
380 oc.addDescription("collision.action", "Processing", TL("How to deal with collisions: [none,warn,teleport,remove]"));
381
382 oc.doRegister("intermodal-collision.action", new Option_String("warn"));
383 oc.addDescription("intermodal-collision.action", "Processing", TL("How to deal with collisions between vehicle and pedestrian: [none,warn,teleport,remove]"));
384
385 oc.doRegister("collision.stoptime", new Option_String("0", "TIME"));
386 oc.addDescription("collision.stoptime", "Processing", TL("Let vehicle stop for TIME before performing collision.action (except for action 'none')"));
387
388 oc.doRegister("intermodal-collision.stoptime", new Option_String("0", "TIME"));
389 oc.addDescription("intermodal-collision.stoptime", "Processing", TL("Let vehicle stop for TIME before performing intermodal-collision.action (except for action 'none')"));
390
391 oc.doRegister("collision.check-junctions", new Option_Bool(false));
392 oc.addDescription("collision.check-junctions", "Processing", TL("Enables collisions checks on junctions"));
393
394 oc.doRegister("collision.check-junctions.mingap", new Option_Float(0));
395 oc.addDescription("collision.check-junctions.mingap", "Processing", TL("Increase or decrease sensitivity for junction collision check"));
396
397 oc.doRegister("collision.mingap-factor", new Option_Float(-1));
398 oc.addDescription("collision.mingap-factor", "Processing", TL("Sets the fraction of minGap that must be maintained to avoid collision detection. If a negative value is given, the carFollowModel parameter is used"));
399
400 oc.doRegister("max-num-vehicles", new Option_Integer(-1));
401 oc.addDescription("max-num-vehicles", "Processing", TL("Delay vehicle insertion to stay within the given maximum number"));
402
403 oc.doRegister("max-num-teleports", new Option_Integer(-1));
404 oc.addDescription("max-num-teleports", "Processing", TL("Abort the simulation if the given maximum number of teleports is exceeded"));
405
406 oc.doRegister("scale", new Option_Float(1.));
407 oc.addDescription("scale", "Processing", TL("Scale demand by the given factor (by discarding or duplicating vehicles)"));
408
409 oc.doRegister("scale-suffix", new Option_String("."));
410 oc.addDescription("scale-suffix", "Processing", TL("Suffix to be added when creating ids for cloned vehicles"));
411
412 oc.doRegister("time-to-teleport", new Option_String("300", "TIME"));
413 oc.addDescription("time-to-teleport", "Processing", TL("Specify how long a vehicle may wait until being teleported, defaults to 300, non-positive values disable teleporting"));
414
415 oc.doRegister("time-to-teleport.highways", new Option_String("0", "TIME"));
416 oc.addDescription("time-to-teleport.highways", "Processing", TL("The waiting time after which vehicles on a fast road (speed > 69km/h) are teleported if they are on a non-continuing lane"));
417
418 oc.doRegister("time-to-teleport.highways.min-speed", new Option_Float(69 / 3.6));
419 oc.addDescription("time-to-teleport.highways.min-speed", "Processing", TL("The waiting time after which vehicles on a fast road (default: speed > 69km/h) are teleported if they are on a non-continuing lane"));
420
421 oc.doRegister("time-to-teleport.disconnected", new Option_String("-1", "TIME"));
422 oc.addDescription("time-to-teleport.disconnected", "Processing", TL("The waiting time after which vehicles with a disconnected route are teleported. Negative values disable teleporting"));
423
424 oc.doRegister("time-to-teleport.remove", new Option_Bool(false));
425 oc.addDescription("time-to-teleport.remove", "Processing", TL("Whether vehicles shall be removed after waiting too long instead of being teleported"));
426
427 oc.doRegister("time-to-teleport.ride", new Option_String("-1", "TIME"));
428 oc.addDescription("time-to-teleport.ride", "Processing", TL("The waiting time after which persons / containers waiting for a pickup are teleported. Negative values disable teleporting"));
429
430 oc.doRegister("time-to-teleport.bidi", new Option_String("-1", "TIME"));
431 oc.addDescription("time-to-teleport.bidi", "Processing", TL("The waiting time after which vehicles on bidirectional edges are teleported"));
432
433 oc.doRegister("waiting-time-memory", new Option_String("100", "TIME"));
434 oc.addDescription("waiting-time-memory", "Processing", TL("Length of time interval, over which accumulated waiting time is taken into account (default is 100s.)"));
435
436 oc.doRegister("startup-wait-threshold", new Option_String("2", "TIME"));
437 oc.addDescription("startup-wait-threshold", "Processing", TL("Minimum consecutive waiting time before applying startupDelay"));
438
439 oc.doRegister("max-depart-delay", new Option_String("-1", "TIME"));
440 oc.addDescription("max-depart-delay", "Processing", TL("How long vehicles wait for departure before being skipped, defaults to -1 which means vehicles are never skipped"));
441
442 oc.doRegister("sloppy-insert", new Option_Bool(false));
443 oc.addDescription("sloppy-insert", "Processing", TL("Whether insertion on an edge shall not be repeated in same step once failed"));
444
445 oc.doRegister("eager-insert", new Option_Bool(false));
446 oc.addDescription("eager-insert", "Processing", TL("Whether each vehicle is checked separately for insertion on an edge"));
447
448 oc.doRegister("emergency-insert", new Option_Bool(false));
449 oc.addDescription("emergency-insert", "Processing", TL("Allow inserting a vehicle in a situation which requires emergency braking"));
450
451 oc.doRegister("random-depart-offset", new Option_String("0", "TIME"));
452 oc.addDescription("random-depart-offset", "Processing", TL("Each vehicle receives a random offset to its depart value drawn uniformly from [0, TIME]"));
453
454 oc.doRegister("lanechange.duration", new Option_String("0", "TIME"));
455 oc.addDescription("lanechange.duration", "Processing", TL("Duration of a lane change maneuver (default 0)"));
456
457 oc.doRegister("lanechange.overtake-right", new Option_Bool(false));
458 oc.addDescription("lanechange.overtake-right", "Processing", TL("Whether overtaking on the right on motorways is permitted"));
459
460 oc.doRegister("tls.all-off", new Option_Bool(false));
461 oc.addDescription("tls.all-off", "Processing", TL("Switches off all traffic lights."));
462
463 oc.doRegister("tls.actuated.show-detectors", new Option_Bool(false));
464 oc.addDescription("tls.actuated.show-detectors", "Processing", TL("Sets default visibility for actuation detectors"));
465
466 oc.doRegister("tls.actuated.jam-threshold", new Option_Float(-1));
467 oc.addDescription("tls.actuated.jam-threshold", "Processing", TL("Sets default jam-threshold parameter for all actuation detectors"));
468
469 oc.doRegister("tls.actuated.detector-length", new Option_Float(0));
470 oc.addDescription("tls.actuated.detector-length", "Processing", TL("Sets default detector length parameter for all actuation detectors"));
471
472 oc.doRegister("tls.delay_based.detector-range", new Option_Float(100));
473 oc.addDescription("tls.delay_based.detector-range", "Processing", TL("Sets default range for detecting delayed vehicles"));
474
475 oc.doRegister("tls.yellow.min-decel", new Option_Float(3.0));
476 oc.addDescription("tls.yellow.min-decel", "Processing", TL("Minimum deceleration when braking at yellow"));
477
478 oc.doRegister("railsignal-moving-block", new Option_Bool(false));
479 oc.addDescription("railsignal-moving-block", "Processing", TL("Let railsignals operate in moving-block mode by default"));
480
481 oc.doRegister("time-to-impatience", new Option_String("180", "TIME"));
482 oc.addDescription("time-to-impatience", "Processing", TL("Specify how long a vehicle may wait until impatience grows from 0 to 1, defaults to 300, non-positive values disable impatience growth"));
483
484 oc.doRegister("default.action-step-length", new Option_Float(0.0));
485 oc.addDescription("default.action-step-length", "Processing", TL("Length of the default interval length between action points for the car-following and lane-change models (in seconds). If not specified, the simulation step-length is used per default. Vehicle- or VType-specific settings override the default. Must be a multiple of the simulation step-length."));
486
487 oc.doRegister("default.carfollowmodel", new Option_String("Krauss"));
488 oc.addDescription("default.carfollowmodel", "Processing", TL("Select default car following model (Krauss, IDM, ...)"));
489 oc.addSynonyme("default.carfollowmodel", "carfollow.model");
490
491 oc.doRegister("default.speeddev", new Option_Float(-1));
492 oc.addDescription("default.speeddev", "Processing", TL("Select default speed deviation. A negative value implies vClass specific defaults (0.1 for the default passenger class"));
493
494 oc.doRegister("default.emergencydecel", new Option_String("default"));
495 oc.addDescription("default.emergencydecel", "Processing", TL("Select default emergencyDecel value among ('decel', 'default', FLOAT) which sets the value either to the same as the deceleration value, a vClass-class specific default or the given FLOAT in m/s^2"));
496
497 oc.doRegister("overhead-wire.solver", new Option_Bool(true));
498 oc.addDescription("overhead-wire.solver", "Processing", TL("Use Kirchhoff's laws for solving overhead wire circuit"));
499
500 oc.doRegister("overhead-wire.recuperation", new Option_Bool(true));
501 oc.addDescription("overhead-wire.recuperation", "Processing", TL("Enable recuperation from the vehicle equipped with elecHybrid device into the overhead wire."));
502
503 oc.doRegister("overhead-wire.substation-current-limits", new Option_Bool(true));
504 oc.addDescription("overhead-wire.substation-current-limits", "Processing", TL("Enable current limits of traction substation during solving the overhead wire electrical circuit."));
505
506 oc.doRegister("emergencydecel.warning-threshold", new Option_Float(1));
507 oc.addDescription("emergencydecel.warning-threshold", "Processing", TL("Sets the fraction of emergency decel capability that must be used to trigger a warning."));
508
509 oc.doRegister("parking.maneuver", new Option_Bool(false));
510 oc.addDescription("parking.maneuver", "Processing", TL("Whether parking simulation includes maneuvering time and associated lane blocking"));
511
512 oc.doRegister("use-stop-ended", new Option_Bool(false));
513 oc.addDescription("use-stop-ended", "Processing", TL("Override stop until times with stop ended times when given"));
514
515 oc.doRegister("use-stop-started", new Option_Bool(false));
516 oc.addDescription("use-stop-started", "Processing", TL("Override stop arrival times with stop started times when given"));
517
518 // pedestrian model
519 oc.doRegister("pedestrian.model", new Option_String("striping"));
520 oc.addDescription("pedestrian.model", "Processing", TL("Select among pedestrian models ['nonInteracting', 'striping', 'remote']"));
521
522 oc.doRegister("pedestrian.striping.stripe-width", new Option_Float(0.64));
523 oc.addDescription("pedestrian.striping.stripe-width", "Processing", TL("Width of parallel stripes for segmenting a sidewalk (meters) for use with model 'striping'"));
524
525 oc.doRegister("pedestrian.striping.dawdling", new Option_Float(0.2));
526 oc.addDescription("pedestrian.striping.dawdling", "Processing", TL("Factor for random slow-downs [0,1] for use with model 'striping'"));
527
528 oc.doRegister("pedestrian.striping.mingap-to-vehicle", new Option_Float(0.25));
529 oc.addDescription("pedestrian.striping.mingap-to-vehicle", "Processing", TL("Minimal gap / safety buffer (in meters) from a pedestrian to another vehicle for use with model 'striping'"));
530
531 oc.doRegister("pedestrian.striping.jamtime", new Option_String("300", "TIME"));
532 oc.addDescription("pedestrian.striping.jamtime", "Processing", TL("Time in seconds after which pedestrians start squeezing through a jam when using model 'striping' (non-positive values disable squeezing)"));
533 oc.doRegister("pedestrian.striping.jamtime.crossing", new Option_String("10", "TIME"));
534 oc.addDescription("pedestrian.striping.jamtime.crossing", "Processing", TL("Time in seconds after which pedestrians start squeezing through a jam while on a pedestrian crossing when using model 'striping' (non-positive values disable squeezing)"));
535 oc.doRegister("pedestrian.striping.jamtime.narrow", new Option_String("1", "TIME"));
536 oc.addDescription("pedestrian.striping.jamtime.narrow", "Processing", TL("Time in seconds after which pedestrians start squeezing through a jam while on a narrow lane when using model 'striping'"));
537
538 oc.doRegister("pedestrian.striping.reserve-oncoming", new Option_Float(0.0));
539 oc.addDescription("pedestrian.striping.reserve-oncoming", "Processing", TL("Fraction of stripes to reserve for oncoming pedestrians"));
540
541 oc.doRegister("pedestrian.striping.reserve-oncoming.junctions", new Option_Float(0.34));
542 oc.addDescription("pedestrian.striping.reserve-oncoming.junctions", "Processing", TL("Fraction of stripes to reserve for oncoming pedestrians on crossings and walkingareas"));
543
544 oc.doRegister("pedestrian.striping.reserve-oncoming.max", new Option_Float(1.28));
545 oc.addDescription("pedestrian.striping.reserve-oncoming.max", "Processing", TL("Maximum width in m to reserve for oncoming pedestrians"));
546
547 oc.doRegister("pedestrian.striping.legacy-departposlat", new Option_Bool(false));
548 oc.addDescription("pedestrian.striping.legacy-departposlat", "Processing", TL("Interpret departPosLat for walks in legacy style"));
549
550 oc.doRegister("pedestrian.striping.walkingarea-detail", new Option_Integer(4));
551 oc.addDescription("pedestrian.striping.walkingarea-detail", "Processing", TL("Generate INT intermediate points to smooth out lanes within the walkingarea"));
552
553 oc.doRegister("pedestrian.remote.address", new Option_String("localhost:9000"));
554 oc.addDescription("pedestrian.remote.address", "Processing", TL("The address (host:port) of the external simulation"));
555
556 oc.doRegister("ride.stop-tolerance", new Option_Float(10.));
557 oc.addDescription("ride.stop-tolerance", "Processing", TL("Tolerance to apply when matching pedestrian and vehicle positions on boarding at individual stops"));
558
559 // generic routing options
560 oc.doRegister("routing-algorithm", new Option_String("dijkstra"));
561 oc.addDescription("routing-algorithm", "Routing",
562 "Select among routing algorithms ['dijkstra', 'astar', 'CH', 'CHWrapper']");
563
564 oc.doRegister("weights.random-factor", new Option_Float(1.));
565 oc.addDescription("weights.random-factor", "Routing", TL("Edge weights for routing are dynamically disturbed by a random factor drawn uniformly from [1,FLOAT)"));
566
567 oc.doRegister("weights.minor-penalty", new Option_Float(1.5));
568 oc.addDescription("weights.minor-penalty", "Routing", TL("Apply the given time penalty when computing minimum routing costs for minor-link internal lanes"));
569
570 oc.doRegister("weights.tls-penalty", new Option_Float(0));
571 oc.addDescription("weights.tls-penalty", "Routing", TL("Apply scaled travel time penalties based on green split when computing minimum routing costs for internal lanes at traffic lights"));
572
573 oc.doRegister("weights.priority-factor", new Option_Float(0));
574 oc.addDescription("weights.priority-factor", "Routing", TL("Consider edge priorities in addition to travel times, weighted by factor"));
575
576 oc.doRegister("weights.separate-turns", new Option_Float(0));
577 oc.addDescription("weights.separate-turns", "Routing", TL("Distinguish travel time by turn direction and shift a fraction of the estimated time loss ahead of the intersection onto the internal edges"));
578
579 oc.doRegister("astar.all-distances", new Option_FileName());
580 oc.addDescription("astar.all-distances", "Routing", TL("Initialize lookup table for astar from the given file (generated by marouter --all-pairs-output)"));
581
582 oc.doRegister("astar.landmark-distances", new Option_FileName());
583 oc.addDescription("astar.landmark-distances", "Routing", TL("Initialize lookup table for astar ALT-variant from the given file"));
584
585 oc.doRegister("persontrip.walkfactor", new Option_Float(double(0.75)));
586 oc.addDescription("persontrip.walkfactor", "Routing", TL("Use FLOAT as a factor on pedestrian maximum speed during intermodal routing"));
587
588 oc.doRegister("persontrip.walk-opposite-factor", new Option_Float(1.0));
589 oc.addDescription("persontrip.walk-opposite-factor", "Processing", TL("Use FLOAT as a factor on walking speed against vehicle traffic direction"));
590
591 oc.doRegister("persontrip.transfer.car-walk", new Option_StringVector(StringVector({ "parkingAreas" })));
592 oc.addDescription("persontrip.transfer.car-walk", "Routing",
593 "Where are mode changes from car to walking allowed (possible values: 'parkingAreas', 'ptStops', 'allJunctions' and combinations)");
594
595 oc.doRegister("persontrip.transfer.taxi-walk", new Option_StringVector());
596 oc.addDescription("persontrip.transfer.taxi-walk", "Routing", TL("Where taxis can drop off customers ('allJunctions, 'ptStops')"));
597
598 oc.doRegister("persontrip.transfer.walk-taxi", new Option_StringVector());
599 oc.addDescription("persontrip.transfer.walk-taxi", "Routing", TL("Where taxis can pick up customers ('allJunctions, 'ptStops')"));
600
601 oc.doRegister("persontrip.default.group", new Option_String());
602 oc.addDescription("persontrip.default.group", "Routing", TL("When set, trips between the same origin and destination will share a taxi by default"));
603
604 oc.doRegister("persontrip.taxi.waiting-time", new Option_String("300", "TIME"));
605 oc.addDescription("persontrip.taxi.waiting-time", "Routing", TL("Estimated time for taxi pickup"));
606
607 oc.doRegister("railway.max-train-length", new Option_Float(1000.0));
608 oc.addDescription("railway.max-train-length", "Routing", TL("Use FLOAT as a maximum train length when initializing the railway router"));
609
610 oc.doRegister("replay-rerouting", new Option_Bool(false));
611 oc.addDescription("replay-rerouting", "Routing", TL("Replay exact rerouting sequence from vehroute-output"));
612
613 // devices
614 oc.addOptionSubTopic("Emissions");
615 oc.doRegister("emissions.volumetric-fuel", new Option_Bool(false));
616 oc.addDescription("emissions.volumetric-fuel", "Emissions", TL("Return fuel consumption values in (legacy) unit l instead of mg"));
617
618 oc.doRegister("phemlight-path", new Option_FileName(StringVector({ "./PHEMlight/" })));
619 oc.addDescription("phemlight-path", "Emissions", TL("Determines where to load PHEMlight definitions from"));
620
621 oc.doRegister("phemlight-year", new Option_Integer(0));
622 oc.addDescription("phemlight-year", "Emissions", TL("Enable fleet age modelling with the given reference year in PHEMlight5"));
623
624 oc.doRegister("phemlight-temperature", new Option_Float(INVALID_DOUBLE));
625 oc.addDescription("phemlight-temperature", "Emissions", TL("Set ambient temperature to correct NOx emissions in PHEMlight5"));
626
627 oc.addOptionSubTopic("Communication");
628 oc.addOptionSubTopic("Battery");
630
631 // register report options
632 oc.doRegister("duration-log.disable", new Option_Bool(false));
633 oc.addSynonyme("duration-log.disable", "no-duration-log", false);
634 oc.addDescription("duration-log.disable", "Report", TL("Disable performance reports for individual simulation steps"));
635
636 oc.doRegister("duration-log.statistics", 't', new Option_Bool(false));
637 oc.addDescription("duration-log.statistics", "Report", TL("Enable statistics on vehicle trips"));
638
639 oc.doRegister("no-step-log", new Option_Bool(false));
640 oc.addDescription("no-step-log", "Report", TL("Disable console output of current simulation step"));
641
642 oc.doRegister("step-log.period", new Option_Integer(100));
643 oc.addDescription("step-log.period", "Report", TL("Number of simulation steps between step-log outputs"));
644
645 //remote port 0 if not used
646 oc.addOptionSubTopic("TraCI Server");
647 oc.doRegister("remote-port", new Option_Integer(0));
648 oc.addDescription("remote-port", "TraCI Server", TL("Enables TraCI Server if set"));
649 oc.doRegister("num-clients", new Option_Integer(1));
650 oc.addDescription("num-clients", "TraCI Server", TL("Expected number of connecting clients"));
651
652 oc.addOptionSubTopic("Mesoscopic");
653 oc.doRegister("mesosim", new Option_Bool(false));
654 oc.addDescription("mesosim", "Mesoscopic", TL("Enables mesoscopic simulation"));
655 oc.doRegister("meso-edgelength", new Option_Float(98.0f));
656 oc.addDescription("meso-edgelength", "Mesoscopic", TL("Length of an edge segment in mesoscopic simulation"));
657 oc.doRegister("meso-tauff", new Option_String("1.13", "TIME"));
658 oc.addDescription("meso-tauff", "Mesoscopic", TL("Factor for calculating the net free-free headway time"));
659 oc.doRegister("meso-taufj", new Option_String("1.13", "TIME"));
660 oc.addDescription("meso-taufj", "Mesoscopic", TL("Factor for calculating the net free-jam headway time"));
661 oc.doRegister("meso-taujf", new Option_String("1.73", "TIME"));
662 oc.addDescription("meso-taujf", "Mesoscopic", TL("Factor for calculating the jam-free headway time"));
663 oc.doRegister("meso-taujj", new Option_String("1.4", "TIME"));
664 oc.addDescription("meso-taujj", "Mesoscopic", TL("Factor for calculating the jam-jam headway time"));
665 oc.doRegister("meso-jam-threshold", new Option_Float(-1));
666 oc.addDescription("meso-jam-threshold", "Mesoscopic",
667 "Minimum percentage of occupied space to consider a segment jammed. A negative argument causes thresholds to be computed based on edge speed and tauff (default)");
668 oc.doRegister("meso-multi-queue", new Option_Bool(true));
669 oc.addDescription("meso-multi-queue", "Mesoscopic", TL("Enable multiple queues at edge ends"));
670 oc.doRegister("meso-lane-queue", new Option_Bool(false));
671 oc.addDescription("meso-lane-queue", "Mesoscopic", TL("Enable separate queues for every lane"));
672 oc.doRegister("meso-ignore-lanes-by-vclass", new Option_StringVector(StringVector({ "pedestrian", "bicycle" })));
673 oc.addDescription("meso-ignore-lanes-by-vclass", "Mesoscopic", TL("Do not build queues (or reduce capacity) for lanes allowing only the given vclasses"));
674 oc.addSynonyme("meso-ignore-lanes-by-vclass", "meso.ignore-lanes.by-vclass");
675 oc.doRegister("meso-junction-control", new Option_Bool(false));
676 oc.addDescription("meso-junction-control", "Mesoscopic", TL("Enable mesoscopic traffic light and priority junction handling"));
677 oc.doRegister("meso-junction-control.limited", new Option_Bool(false));
678 oc.addDescription("meso-junction-control.limited", "Mesoscopic",
679 "Enable mesoscopic traffic light and priority junction handling for saturated links. This prevents faulty traffic lights from hindering flow in low-traffic situations");
680 oc.doRegister("meso-tls-penalty", new Option_Float(0));
681 oc.addDescription("meso-tls-penalty", "Mesoscopic",
682 "Apply scaled travel time penalties when driving across tls controlled junctions based on green split instead of checking actual phases");
683 oc.doRegister("meso-tls-flow-penalty", new Option_Float(0));
684 oc.addDescription("meso-tls-flow-penalty", "Mesoscopic",
685 "Apply scaled headway penalties when driving across tls controlled junctions based on green split instead of checking actual phases");
686 oc.doRegister("meso-minor-penalty", new Option_String("0", "TIME"));
687 oc.addDescription("meso-minor-penalty", "Mesoscopic",
688 "Apply fixed time penalty when driving across a minor link. When using --meso-junction-control.limited, the penalty is not applied whenever limited control is active.");
689 oc.doRegister("meso-overtaking", new Option_Bool(false));
690 oc.addDescription("meso-overtaking", "Mesoscopic", TL("Enable mesoscopic overtaking"));
691 oc.doRegister("meso-recheck", new Option_String("0", "TIME"));
692 oc.addDescription("meso-recheck", "Mesoscopic", TL("Time interval for rechecking insertion into the next segment after failure"));
693
694 // add rand options
696 oc.doRegister("thread-rngs", new Option_Integer(64));
697 oc.addDescription("thread-rngs", "Random Number",
698 "Number of pre-allocated random number generators to ensure repeatable multi-threaded simulations (should be at least the number of threads for repeatable simulations).");
699
700 // add GUI options
701 // the reason that we include them in vanilla sumo as well is to make reusing config files easy
702 oc.addOptionSubTopic("GUI Only");
703 oc.doRegister("gui-settings-file", 'g', new Option_FileName());
704 oc.addDescription("gui-settings-file", "GUI Only", TL("Load visualisation settings from FILE"));
705
706 oc.doRegister("quit-on-end", 'Q', new Option_Bool(false));
707 oc.addDescription("quit-on-end", "GUI Only", TL("Quits the GUI when the simulation stops"));
708
709 oc.doRegister("game", 'G', new Option_Bool(false));
710 oc.addDescription("game", "GUI Only", TL("Start the GUI in gaming mode"));
711
712 oc.doRegister("game.mode", new Option_String("tls"));
713 oc.addDescription("game.mode", "GUI Only", TL("Select the game type ('tls', 'drt')"));
714
715 oc.doRegister("start", 'S', new Option_Bool(false));
716 oc.addDescription("start", "GUI Only", TL("Start the simulation after loading"));
717
718 oc.doRegister("delay", 'd', new Option_Float(0.0));
719 oc.addDescription("delay", "GUI Only", TL("Use FLOAT in ms as delay between simulation steps"));
720
721 oc.doRegister("breakpoints", 'B', new Option_StringVector());
722 oc.addDescription("breakpoints", "GUI Only", TL("Use TIME[] as times when the simulation should halt"));
723
724 oc.doRegister("edgedata-files", new Option_FileName());
725 oc.addSynonyme("edgedata-files", "data-files");
726 oc.addDescription("edgedata-files", "GUI Only", TL("Load edge/lane weights for visualization from FILE"));
727
728 oc.doRegister("alternative-net-file", 'N', new Option_FileName());
729 oc.addDescription("alternative-net-file", "GUI Only", TL("Load a secondary road network for abstract visualization from FILE"));
730
731 oc.doRegister("demo", 'D', new Option_Bool(false));
732 oc.addDescription("demo", "GUI Only", TL("Restart the simulation after ending (demo mode)"));
733
734 oc.doRegister("disable-textures", 'T', new Option_Bool(false));
735 oc.addDescription("disable-textures", "GUI Only", TL("Do not load background pictures"));
736
737 oc.doRegister("registry-viewport", new Option_Bool(false));
738 oc.addDescription("registry-viewport", "GUI Only", TL("Load current viewport from registry"));
739
740 oc.doRegister("window-size", new Option_StringVector());
741 oc.addDescription("window-size", "GUI Only", TL("Create initial window with the given x,y size"));
742
743 oc.doRegister("window-pos", new Option_StringVector());
744 oc.addDescription("window-pos", "GUI Only", TL("Create initial window at the given x,y position"));
745
746 oc.doRegister("tracker-interval", new Option_String("1", "TIME"));
747 oc.addDescription("tracker-interval", "GUI Only", TL("The aggregation period for value tracker windows"));
748
749#ifdef HAVE_OSG
750 oc.doRegister("osg-view", new Option_Bool(false));
751 oc.addDescription("osg-view", "GUI Only", TL("Start with an OpenSceneGraph view instead of the regular 2D view"));
752#endif
753
754 // gui testing
755 oc.doRegister("gui-testing", new Option_Bool(false));
756 oc.addDescription("gui-testing", "GUI Only", TL("Enable overlay for screen recognition"));
757
758 // gui testing - debug
759 oc.doRegister("gui-testing-debug", new Option_Bool(false));
760 oc.addDescription("gui-testing-debug", "GUI Only", TL("Enable output messages during GUI-Testing"));
761
762 // gui testing - settings output
763 oc.doRegister("gui-testing.setting-output", new Option_FileName());
764 oc.addDescription("gui-testing.setting-output", "GUI Only", TL("Save gui settings in the given settings output file"));
765}
766
767
768void
770 // standard outputs
771 OutputDevice::createDeviceByOption("netstate-dump", "netstate", "netstate_file.xsd");
772 OutputDevice::createDeviceByOption("summary-output", "summary", "summary_file.xsd");
773 OutputDevice::createDeviceByOption("person-summary-output", "personSummary", "person_summary_file.xsd");
774 OutputDevice::createDeviceByOption("tripinfo-output", "tripinfos", "tripinfo_file.xsd");
775
776 //extended
777 OutputDevice::createDeviceByOption("fcd-output", "fcd-export", "fcd_file.xsd");
778 OutputDevice::createDeviceByOption("emission-output", "emission-export", "emission_file.xsd");
779 OutputDevice::createDeviceByOption("battery-output", "battery-export", "battery_file.xsd");
780 if (OptionsCont::getOptions().getBool("elechybrid-output.aggregated")) {
781 // RICE_TODO: Add path to elechybrid-output.aggregated xsd file
782 OutputDevice::createDeviceByOption("elechybrid-output", "elecHybrid-export-aggregated", "\" recuperationEnabled=\"" + toString(MSGlobals::gOverheadWireRecuperation));
783 }
784 //OutputDevice::createDeviceByOption("elecHybrid-output", "elecHybrid-export");
785 OutputDevice::createDeviceByOption("chargingstations-output", "chargingstations-export");
786 OutputDevice::createDeviceByOption("overheadwiresegments-output", "overheadWireSegments-export");
787 OutputDevice::createDeviceByOption("substations-output", "substations-export");
788 OutputDevice::createDeviceByOption("full-output", "full-export", "full_file.xsd");
789 OutputDevice::createDeviceByOption("queue-output", "queue-export", "queue_file.xsd");
790 OutputDevice::createDeviceByOption("amitran-output", "trajectories", "amitran/trajectories.xsd\" timeStepSize=\"" + toString(STEPS2MS(DELTA_T)));
791
792 //OutputDevice::createDeviceByOption("vtk-output", "vtk-export");
793 OutputDevice::createDeviceByOption("link-output", "link-output");
794 OutputDevice::createDeviceByOption("railsignal-block-output", "railsignal-block-output");
795 OutputDevice::createDeviceByOption("bt-output", "bt-output");
796 OutputDevice::createDeviceByOption("lanechange-output", "lanechanges");
797 OutputDevice::createDeviceByOption("stop-output", "stops", "stopinfo_file.xsd");
798 OutputDevice::createDeviceByOption("collision-output", "collisions", "collision_file.xsd");
799 OutputDevice::createDeviceByOption("statistic-output", "statistics", "statistic_file.xsd");
800
801#ifdef _DEBUG
802 OutputDevice::createDeviceByOption("movereminder-output", "movereminder-output");
803#endif
804
807}
808
809
810bool
813 bool ok = true;
814 if (!oc.isSet("net-file") && oc.isDefault("remote-port")) {
815 WRITE_ERROR(TL("No network file (-n) specified."));
816 ok = false;
817 }
818 if (oc.getFloat("scale") < 0.) {
819 WRITE_ERROR(TL("Invalid scaling factor."));
820 ok = false;
821 }
822 if (oc.getBool("vehroute-output.exit-times") && !oc.isSet("vehroute-output")) {
823 WRITE_ERROR(TL("A vehroute-output file is needed for exit times."));
824 ok = false;
825 }
826 if (oc.isSet("gui-settings-file") &&
827 oc.getString("gui-settings-file") != "" &&
828 !oc.isUsableFileList("gui-settings-file")) {
829 ok = false;
830 }
831 if (oc.getBool("demo") && oc.isDefault("start")) {
832 oc.setDefault("start", "true");
833 }
834 if (oc.getBool("demo") && oc.getBool("quit-on-end")) {
835 WRITE_ERROR(TL("You can either restart or quit on end."));
836 ok = false;
837 }
838 if (oc.getBool("meso-junction-control.limited") && !oc.getBool("meso-junction-control")) {
839 if (!oc.isDefault("meso-junction-control")) {
840 WRITE_WARNING(TL("The option 'meso-junction-control.limited' implies 'meso-junction-control'."))
841 }
842 oc.setDefault("meso-junction-control", "true");
843 }
844 if (oc.getBool("mesosim")) {
845 if (oc.isDefault("pedestrian.model")) {
846 oc.setDefault("pedestrian.model", "nonInteracting");
847 }
848 }
849 if (string2time(oc.getString("device.fcd.begin")) < 0) {
850 oc.setDefault("device.fcd.begin", oc.getString("begin"));
851 }
852 if (string2time(oc.getString("device.emissions.begin")) < 0) {
853 oc.setDefault("device.emissions.begin", oc.getString("begin"));
854 }
855 const SUMOTime begin = string2time(oc.getString("begin"));
856 const SUMOTime end = string2time(oc.getString("end"));
857 if (begin < 0) {
858 WRITE_ERROR(TL("The begin time should not be negative."));
859 ok = false;
860 }
861 // DELTA_T not yet initialized
862 const SUMOTime deltaT = MAX2((SUMOTime)1, string2time(oc.getString("step-length")));
863 if (begin < TIME2STEPS(1)) {
864 checkStepLengthMultiple(begin, " for begin", deltaT);
865 }
866 if (end != string2time("-1")) {
867 if (end < begin) {
868 WRITE_ERROR(TL("The end time should be after the begin time."));
869 ok = false;
870 }
871 }
872 if (string2time(oc.getString("step-length")) <= 0) {
873 WRITE_ERROR(TL("the minimum step-length is 0.001"));
874 ok = false;
875 }
876 const SUMOTime period = string2time(oc.getString("device.fcd.period"));
877 if (period > 0) {
878 checkStepLengthMultiple(period, " for device.fcd.period", deltaT);
879 }
880 const SUMOTime statePeriod = string2time(oc.getString("save-state.period"));
881 if (statePeriod > 0) {
882 checkStepLengthMultiple(statePeriod, " for save-state.period", deltaT);
883 }
884 for (const std::string& timeStr : oc.getStringVector("save-state.times")) {
885 try {
886 const SUMOTime saveT = string2time(timeStr);
887 if (end > 0 && saveT >= end) {
888 WRITE_WARNINGF(TL("The save-state time=% will not be used before simulation end at %."), timeStr, time2string(end));
889 } else {
890 checkStepLengthMultiple(saveT, " for save-state.times", deltaT, begin);
891 }
892 } catch (ProcessError& e) {
893 WRITE_ERROR("Invalid time '" + timeStr + "' for option 'save-state.times'. " + e.what());
894 ok = false;
895 }
896 }
897
898#ifdef _DEBUG
899 if (oc.isSet("movereminder-output.vehicles") && !oc.isSet("movereminder-output")) {
900 WRITE_ERROR(TL("option movereminder-output.vehicles requires option movereminder-output to be set"));
901 ok = false;
902 }
903#endif
904 if (oc.getBool("sloppy-insert")) {
905 WRITE_WARNING(TL("The option 'sloppy-insert' is deprecated, because it is now activated by default, see the new option 'eager-insert'."));
906 }
907 if (string2time(oc.getString("lanechange.duration")) > 0 && oc.getFloat("lateral-resolution") > 0) {
908 WRITE_ERROR(TL("Only one of the options 'lanechange.duration' or 'lateral-resolution' may be given."));
909 ok = false;
910 }
911 if (oc.getBool("mesosim") && (oc.getFloat("lateral-resolution") > 0 || string2time(oc.getString("lanechange.duration")) > 0)) {
912 WRITE_ERROR(TL("Sublane dynamics are not supported by mesoscopic simulation"));
913 ok = false;
914 }
915 if (oc.getBool("ignore-accidents")) {
916 WRITE_WARNING(TL("The option 'ignore-accidents' is deprecated. Use 'collision.action none' instead."));
917 }
918 if (oc.getBool("duration-log.statistics") && oc.isDefault("verbose")) {
919 oc.setDefault("verbose", "true");
920 }
921 if (oc.isDefault("precision") && string2time(oc.getString("step-length")) % 10 != 0) {
922 oc.setDefault("precision", "3");
923 }
924 if (oc.isDefault("tracker-interval") && !oc.isDefault("step-length")) {
925 oc.setDefault("tracker-interval", oc.getString("step-length"));
926 }
927 if (oc.getBool("tripinfo-output.write-undeparted")) {
928 if (!oc.isDefault("tripinfo-output.write-unfinished") && !oc.getBool("tripinfo-output.write-unfinished")) {
929 WRITE_WARNING(TL("The option tripinfo-output.write-undeparted implies tripinfo-output.write-unfinished."));
930 }
931 oc.setDefault("tripinfo-output.write-unfinished", "true");
932 }
933 if (oc.getInt("precision") > 2) {
934 if (oc.isDefault("netstate-dump.precision")) {
935 oc.setDefault("netstate-dump.precision", toString(oc.getInt("precision")));
936 }
937 if (oc.isDefault("emission-output.precision")) {
938 oc.setDefault("emission-output.precision", toString(oc.getInt("precision")));
939 }
940 if (oc.isDefault("battery-output.precision")) {
941 oc.setDefault("battery-output.precision", toString(oc.getInt("precision")));
942 }
943 if (oc.isDefault("elechybrid-output.precision")) {
944 oc.setDefault("elechybrid-output.precision", toString(oc.getInt("precision")));
945 }
946 if (oc.isDefault("substations-output.precision")) {
947 oc.setDefault("substations-output.precision", toString(oc.getInt("precision")));
948 }
949 }
950 if (!SUMOXMLDefinitions::CarFollowModels.hasString(oc.getString("carfollow.model"))) {
951 WRITE_ERRORF(TL("Unknown model '%' for option 'carfollow.model'."), oc.getString("carfollow.model"));
952 ok = false;
953 }
954 if (oc.isSet("default.emergencydecel")) {
955 const std::string val = oc.getString("default.emergencydecel");
956 if (val != "default" && val != "decel") {
957 try {
959 } catch (NumberFormatException&) {
960 WRITE_ERRORF(TL("Invalid value '%' for option 'default.emergencydecel'. Must be a FLOAT or 'default' or 'decel'"), val);
961 ok = false;
962 }
963 }
964 }
965 if (oc.getFloat("delay") < 0.0) {
966 WRITE_ERROR(TL("You need a non-negative delay."));
967 ok = false;
968 }
969 for (const std::string& val : oc.getStringVector("breakpoints")) {
970 try {
971 string2time(val);
972 } catch (ProcessError& e) {
973 WRITE_ERROR("Invalid time '" + val + "' for option 'breakpoints'. " + e.what());
974 ok = false;
975 }
976 }
977#ifndef HAVE_FOX
978 if (oc.getInt("threads") > 1) {
979 WRITE_ERROR(TL("Parallel simulation is only possible when compiled with Fox."));
980 ok = false;
981 }
982#endif
983 if (oc.getInt("threads") < 1) {
984 WRITE_ERROR(TL("You need at least one thread."));
985 ok = false;
986 }
987 if (oc.getInt("threads") > oc.getInt("thread-rngs")) {
988 WRITE_WARNING(TL("Number of threads exceeds number of thread-rngs. Simulation runs with the same seed may produce different results"));
989 }
990 if (oc.getString("game.mode") != "tls" && oc.getString("game.mode") != "drt") {
991 WRITE_ERROR(TL("game.mode must be one of ['tls', 'drt']"));
992 ok = false;
993 }
994
995 if (oc.isSet("persontrip.transfer.car-walk")) {
996 for (const std::string& opt : OptionsCont::getOptions().getStringVector("persontrip.transfer.car-walk")) {
997 if (opt != "parkingAreas" && opt != "ptStops" && opt != "allJunctions") {
998 WRITE_ERRORF(TL("Invalid transfer option '%'. Must be one of 'parkingAreas', 'ptStops' and 'allJunctions'"), opt);
999 ok = false;
1000 }
1001 }
1002 }
1003
1004 ok &= MSDevice::checkOptions(oc);
1005 ok &= SystemFrame::checkOptions(oc);
1006
1007 return ok;
1008}
1009
1010
1011void
1013 // pre-initialise the network
1014 // set whether empty edges shall be printed on dump
1015 MSGlobals::gOmitEmptyEdgesOnDump = !oc.getBool("netstate-dump.empty-edges");
1016 // set whether internal lanes shall be used
1017 MSGlobals::gUsingInternalLanes = !oc.getBool("no-internal-links");
1018 MSGlobals::gIgnoreJunctionBlocker = string2time(oc.getString("ignore-junction-blocker")) < 0 ?
1019 std::numeric_limits<SUMOTime>::max() : string2time(oc.getString("ignore-junction-blocker"));
1020 // set the grid lock time
1021 MSGlobals::gTimeToGridlock = string2time(oc.getString("time-to-teleport")) < 0 ? 0 : string2time(oc.getString("time-to-teleport"));
1022 MSGlobals::gTimeToImpatience = string2time(oc.getString("time-to-impatience"));
1023 MSGlobals::gTimeToGridlockHighways = string2time(oc.getString("time-to-teleport.highways")) < 0 ? 0 : string2time(oc.getString("time-to-teleport.highways"));
1024 MSGlobals::gGridlockHighwaysSpeed = oc.getFloat("time-to-teleport.highways.min-speed");
1025 MSGlobals::gTimeToTeleportDisconnected = string2time(oc.getString("time-to-teleport.disconnected"));
1026 MSGlobals::gTimeToTeleportBidi = string2time(oc.getString("time-to-teleport.bidi"));
1027 MSGlobals::gRemoveGridlocked = oc.getBool("time-to-teleport.remove");
1028 MSGlobals::gCheck4Accidents = !oc.getBool("ignore-accidents");
1029 MSGlobals::gCheckRoutes = !oc.getBool("ignore-route-errors");
1030 MSGlobals::gEmergencyInsert = oc.getBool("emergency-insert");
1031 MSGlobals::gWeightsSeparateTurns = oc.getFloat("weights.separate-turns");
1032 MSGlobals::gStartupWaitThreshold = string2time(oc.getString("startup-wait-threshold"));
1033 MSGlobals::gLaneChangeDuration = string2time(oc.getString("lanechange.duration"));
1034 MSGlobals::gLateralResolution = oc.getFloat("lateral-resolution");
1036 MSGlobals::gStateLoaded = oc.isSet("load-state");
1037 MSGlobals::gUseMesoSim = oc.getBool("mesosim");
1038 MSGlobals::gMesoLimitedJunctionControl = oc.getBool("meso-junction-control.limited");
1041 }
1042 MSGlobals::gWaitingTimeMemory = string2time(oc.getString("waiting-time-memory"));
1044 MSGlobals::gOverheadWireSolver = oc.getBool("overhead-wire.solver");
1045 MSGlobals::gOverheadWireRecuperation = oc.getBool("overhead-wire.recuperation");
1046 MSGlobals::gOverheadWireCurrentLimits = oc.getBool("overhead-wire.substation-current-limits");
1047
1049
1050 DELTA_T = string2time(oc.getString("step-length"));
1051
1052 const bool integrationMethodSet = !oc.isDefault("step-method.ballistic");
1053 const bool actionStepLengthSet = !oc.isDefault("default.action-step-length");
1054 MSGlobals::gSemiImplicitEulerUpdate = !oc.getBool("step-method.ballistic");
1055 // Init default value for gActionStepLength
1056 if (MSGlobals::gSemiImplicitEulerUpdate && actionStepLengthSet && !integrationMethodSet) {
1057 WRITE_MESSAGE(TL("Integration method was set to 'ballistic', since a default action step length was specified."));
1059 }
1060 double givenDefaultActionStepLength = oc.getFloat("default.action-step-length");
1062
1063 const std::string defaultEmergencyDecelOption = OptionsCont::getOptions().getString("default.emergencydecel");
1064 if (defaultEmergencyDecelOption == "default") {
1066 } else if (defaultEmergencyDecelOption == "decel") {
1068 } else {
1069 // value already checked in checkOptions()
1070 MSGlobals::gDefaultEmergencyDecel = StringUtils::toDouble(defaultEmergencyDecelOption);
1071 }
1072 MSGlobals::gNumSimThreads = oc.getInt("threads");
1073 MSGlobals::gNumThreads = MAX2(MSGlobals::gNumSimThreads, oc.getInt("device.rerouting.threads"));
1074
1075 MSGlobals::gEmergencyDecelWarningThreshold = oc.getFloat("emergencydecel.warning-threshold");
1076 MSGlobals::gMinorPenalty = oc.getFloat("weights.minor-penalty");
1077 MSGlobals::gTLSPenalty = oc.getFloat("weights.tls-penalty");
1078
1079 MSGlobals::gModelParkingManoeuver = oc.getBool("parking.maneuver");
1080
1081 MSGlobals::gStopTolerance = oc.getFloat("ride.stop-tolerance");
1082 MSGlobals::gTLSYellowMinDecel = oc.getFloat("tls.yellow.min-decel");
1083 MSGlobals::gUseStopEnded = oc.getBool("use-stop-ended");
1084 MSGlobals::gUseStopStarted = oc.getBool("use-stop-started");
1085
1086#ifdef _DEBUG
1087 if (oc.isSet("movereminder-output")) {
1088 MSBaseVehicle::initMoveReminderOutput(oc);
1089 }
1090#endif
1091}
1092
1093
1094/****************************************************************************/
long long int SUMOTime
Definition GUI.h:36
#define WRITE_WARNINGF(...)
Definition MsgHandler.h:271
#define WRITE_ERRORF(...)
Definition MsgHandler.h:280
#define WRITE_MESSAGE(msg)
Definition MsgHandler.h:272
#define WRITE_ERROR(msg)
Definition MsgHandler.h:279
#define WRITE_WARNING(msg)
Definition MsgHandler.h:270
#define TL(string)
Definition MsgHandler.h:287
std::vector< std::string > StringVector
Definition of a vector of strings.
Definition Option.h:42
SUMOTime DELTA_T
Definition SUMOTime.cpp:38
bool checkStepLengthMultiple(const SUMOTime t, const std::string &error, SUMOTime deltaT, SUMOTime begin)
check if given SUMOTime is multiple of the step length
Definition SUMOTime.cpp:131
SUMOTime string2time(const std::string &r)
convert string to SUMOTime
Definition SUMOTime.cpp:46
std::string time2string(SUMOTime t, bool humanReadable)
convert SUMOTime to string (independently of global format setting)
Definition SUMOTime.cpp:69
#define TIME2STEPS(x)
Definition SUMOTime.h:57
#define STEPS2MS(x)
Definition SUMOTime.h:59
const int VTYPEPARS_DEFAULT_EMERGENCYDECEL_DEFAULT
const int VTYPEPARS_DEFAULT_EMERGENCYDECEL_DECEL
const double INVALID_DOUBLE
invalid double
Definition StdDefs.h:64
T MAX2(T a, T b)
Definition StdDefs.h:82
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition ToString.h:46
static void initGlobalOptions(const OptionsCont &oc)
init global model parameters
static void init()
Static intialization.
static void insertOptions(OptionsCont &oc)
Inserts options for building devices.
Definition MSDevice.cpp:71
static bool checkOptions(OptionsCont &oc)
check device-specific options
Definition MSDevice.cpp:99
static void buildStreams()
Builds the streams used possibly by the simulation.
Definition MSFrame.cpp:769
static void setMSGlobals(OptionsCont &oc)
Sets the global microsim-options.
Definition MSFrame.cpp:1012
static void fillOptions()
Inserts options used by the simulation into the OptionsCont-singleton.
Definition MSFrame.cpp:60
static bool checkOptions()
Checks the set options.
Definition MSFrame.cpp:811
static bool gOverheadWireCurrentLimits
Definition MSGlobals.h:124
static double gStopTolerance
The tolerance to apply when matching waiting persons and vehicles.
Definition MSGlobals.h:163
static SUMOTime gTimeToTeleportDisconnected
Definition MSGlobals.h:66
static bool gModelParkingManoeuver
whether parking simulation includes manoeuver time and any associated lane blocking
Definition MSGlobals.h:157
static bool gUseMesoSim
Definition MSGlobals.h:103
static bool gUseStopStarted
Definition MSGlobals.h:131
static double gMinorPenalty
(minimum) time penalty for passing a minor link when routing
Definition MSGlobals.h:152
static SUMOTime gTimeToGridlockHighways
Definition MSGlobals.h:60
static bool gCheckRoutes
Definition MSGlobals.h:88
static double gGridlockHighwaysSpeed
Definition MSGlobals.h:63
static double gWeightsSeparateTurns
Whether turning specific weights are estimated (and how much)
Definition MSGlobals.h:172
static double gTLSPenalty
scaled (minimum) time penalty for passing a tls link when routing
Definition MSGlobals.h:154
static SUMOTime gStartupWaitThreshold
The minimum waiting time before applying startupDelay.
Definition MSGlobals.h:175
static bool gOverheadWireRecuperation
Definition MSGlobals.h:121
static bool gRemoveGridlocked
Definition MSGlobals.h:72
static double gDefaultEmergencyDecel
encoding of the string-option default.emergencydecel
Definition MSGlobals.h:127
static double gTLSYellowMinDecel
The minimum deceleration at a yellow traffic light (only overruled by emergencyDecel)
Definition MSGlobals.h:166
static SUMOTime gTimeToTeleportBidi
Definition MSGlobals.h:69
static bool gOverheadWireSolver
Definition MSGlobals.h:118
static double gLateralResolution
Definition MSGlobals.h:97
static bool gSemiImplicitEulerUpdate
Definition MSGlobals.h:53
static SUMOTime gTimeToImpatience
Definition MSGlobals.h:75
static bool gStateLoaded
Information whether a state has been loaded.
Definition MSGlobals.h:100
static bool gCheck4Accidents
Definition MSGlobals.h:85
static bool gEmergencyInsert
Definition MSGlobals.h:91
static int gNumSimThreads
how many threads to use for simulation
Definition MSGlobals.h:143
static bool gOmitEmptyEdgesOnDump
Information whether empty edges shall be written on dump.
Definition MSGlobals.h:49
static SUMOTime gIgnoreJunctionBlocker
Definition MSGlobals.h:82
static bool gSublane
whether sublane simulation is enabled (sublane model or continuous lanechanging)
Definition MSGlobals.h:160
static SUMOTime gLaneChangeDuration
Definition MSGlobals.h:94
static bool gMesoLimitedJunctionControl
Definition MSGlobals.h:106
static bool gUseStopEnded
whether the simulation should replay previous stop times
Definition MSGlobals.h:130
static SUMOTime gActionStepLength
default value for the interval between two action points for MSVehicle (defaults to DELTA_T)
Definition MSGlobals.h:115
static SUMOTime gWaitingTimeMemory
length of memory for waiting times (in millisecs)
Definition MSGlobals.h:112
static double gEmergencyDecelWarningThreshold
threshold for warning about strong deceleration
Definition MSGlobals.h:149
static bool gUsingInternalLanes
Information whether the simulation regards internal lanes.
Definition MSGlobals.h:78
static int gNumThreads
how many threads to use
Definition MSGlobals.h:146
static SUMOTime gTimeToGridlock
Definition MSGlobals.h:57
static void initCollisionOptions(const OptionsCont &oc)
Definition MSLane.cpp:4286
static void init()
Static intialization.
Definition MSStopOut.cpp: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.
bool isSet(const std::string &name, bool failOnNonExistant=true) const
Returns the information whether the named option is set.
double getFloat(const std::string &name) const
Returns the double-value of the named option (only for Option_Float)
int getInt(const std::string &name) const
Returns the int-value of the named option (only for Option_Integer)
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)
bool isDefault(const std::string &name) const
Returns the information whether the named option has still the default value.
bool setDefault(const std::string &name, const std::string &value)
Sets the given value for the named option as new default value.
void doRegister(const std::string &name, Option *o)
Adds an option under the given name.
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)
const StringVector & getStringVector(const std::string &name) const
Returns the list of string-value of the named option (only for Option_StringVector)
void addXMLDefault(const std::string &name, const std::string &xmlRoot="")
Adds an XML root element to handle by default. The special root "" denotes the default handler.
static OptionsCont & getOptions()
Retrieves the options.
bool isUsableFileList(const std::string &name) const
Checks whether the named option is usable as a file list (with at least a single file)
void addCallExample(const std::string &example, const std::string &desc)
Add a call example.
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 void insertRandOptions(OptionsCont &oc)
Initialises the given options container with random number options.
static SUMOTime processActionStepLength(double given)
Checks and converts given value for the action step length from seconds to miliseconds assuring it be...
static StringBijection< SumoXMLTag > CarFollowModels
car following models
static double toDouble(const std::string &sData)
converts a string into the double value described by it by calling the char-type converter
static bool checkOptions(OptionsCont &oc)
checks shared options and sets StdDefs
static void addConfigurationOptions(OptionsCont &oc)
Adds configuration options to the given container.
static void addReportOptions(OptionsCont &oc)
Adds reporting options to the given container.