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