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