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