Line data Source code
1 : /****************************************************************************/
2 : // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3 : // Copyright (C) 2001-2024 German Aerospace Center (DLR) and others.
4 : // This program and the accompanying materials are made available under the
5 : // terms of the Eclipse Public License 2.0 which is available at
6 : // https://www.eclipse.org/legal/epl-2.0/
7 : // This Source Code may also be made available under the following Secondary
8 : // Licenses when the conditions for such availability set forth in the Eclipse
9 : // Public License 2.0 are satisfied: GNU General Public License, version 2
10 : // or later which is available at
11 : // https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
12 : // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
13 : /****************************************************************************/
14 : /// @file SUMOVTypeParameter.cpp
15 : /// @author Daniel Krajzewicz
16 : /// @author Jakob Erdmann
17 : /// @author Michael Behrisch
18 : /// @date 10.09.2009
19 : ///
20 : // Structure representing possible vehicle parameter
21 : /****************************************************************************/
22 : #include <config.h>
23 :
24 : #include <algorithm>
25 : #include <utils/vehicle/SUMOVTypeParameter.h>
26 : #include <utils/common/ToString.h>
27 : #include <utils/common/StringUtils.h>
28 : #include <utils/common/MsgHandler.h>
29 : #include <utils/iodevices/OutputDevice.h>
30 : #include <utils/options/OptionsCont.h>
31 : #include <utils/xml/SUMOXMLDefinitions.h>
32 : #include <utils/emissions/PollutantsInterface.h>
33 :
34 : #define EMPREFIX std::string("HBEFA3/")
35 : #define TTT_UNSET SUMOTime_MIN
36 :
37 : // ===========================================================================
38 : // static value definitions
39 : // ===========================================================================
40 : std::set<SumoXMLAttr> SUMOVTypeParameter::AllowedJMAttrs({
41 : SUMO_ATTR_JM_CROSSING_GAP,
42 : SUMO_ATTR_JM_DRIVE_AFTER_YELLOW_TIME,
43 : SUMO_ATTR_JM_DRIVE_AFTER_RED_TIME,
44 : SUMO_ATTR_JM_DRIVE_RED_SPEED,
45 : SUMO_ATTR_JM_IGNORE_KEEPCLEAR_TIME,
46 : SUMO_ATTR_JM_IGNORE_FOE_SPEED,
47 : SUMO_ATTR_JM_IGNORE_FOE_PROB,
48 : SUMO_ATTR_JM_IGNORE_JUNCTION_FOE_PROB,
49 : SUMO_ATTR_JM_SIGMA_MINOR,
50 : SUMO_ATTR_JM_STOPLINE_GAP,
51 : SUMO_ATTR_JM_TIMEGAP_MINOR,
52 : SUMO_ATTR_JM_STOPSIGN_WAIT,
53 : SUMO_ATTR_JM_ALLWAYSTOP_WAIT,
54 : });
55 :
56 :
57 : // ===========================================================================
58 : // member method definitions
59 : // ===========================================================================
60 :
61 718185 : SUMOVTypeParameter::VClassDefaultValues::VClassDefaultValues(SUMOVehicleClass vclass) :
62 718185 : length(getDefaultVehicleLength(vclass)),
63 718185 : minGap(2.5),
64 718185 : minGapLat(0.6),
65 718185 : maxSpeed(200. / 3.6),
66 718185 : desiredMaxSpeed(10000 / 3.6), // backward-compatibility: do not influence speeds by default
67 718185 : width(1.8),
68 718185 : height(1.5),
69 718185 : shape(SUMOVehicleShape::UNKNOWN),
70 1436370 : emissionClass(PollutantsInterface::getClassByName(EMPREFIX + "PC_G_EU4", vclass)),
71 718185 : mass(1500.),
72 718185 : speedFactor("normc", 1.0, 0.0, 0.2, 2.0),
73 718185 : personCapacity(4),
74 718185 : containerCapacity(0),
75 718185 : osgFile("car-normal-citrus.obj"),
76 718185 : carriageLength(-1),
77 718185 : locomotiveLength(-1),
78 718185 : carriageDoors(2),
79 718185 : latAlignmentProcedure(LatAlignmentDefinition::CENTER) {
80 : // update default values
81 718185 : switch (vclass) {
82 105338 : case SVC_PEDESTRIAN:
83 105338 : minGap = 0.25;
84 105338 : maxSpeed = 37.58 / 3.6; // Usain Bolt
85 105338 : desiredMaxSpeed = DEFAULT_PEDESTRIAN_SPEED;
86 105338 : width = 0.478;
87 105338 : height = 1.719;
88 105338 : shape = SUMOVehicleShape::PEDESTRIAN;
89 : osgFile = "humanResting.obj";
90 210676 : emissionClass = PollutantsInterface::getClassByName(EMPREFIX + "zero", vclass);
91 105338 : mass = 70.; // https://en.wikipedia.org/wiki/Human_body_weight for Europe
92 105338 : speedFactor.getParameter()[1] = 0.1;
93 105338 : break;
94 24 : case SVC_WHEELCHAIR:
95 24 : minGap = 0.5;
96 24 : maxSpeed = 30.0 / 3.6; // https://en.wikipedia.org/wiki/Wheelchair_racing
97 24 : desiredMaxSpeed = DEFAULT_PEDESTRIAN_SPEED;
98 24 : width = 0.8;
99 24 : height = 1.5;
100 24 : shape = SUMOVehicleShape::PEDESTRIAN;
101 : osgFile = "humanResting.obj";
102 48 : emissionClass = PollutantsInterface::getClassByName(EMPREFIX + "zero", vclass);
103 24 : mass = 90.; //
104 24 : speedFactor.getParameter()[1] = 0.1;
105 24 : break;
106 53529 : case SVC_BICYCLE:
107 53529 : minGap = 0.5;
108 53529 : minGapLat = 0.35;
109 53529 : maxSpeed = 50. / 3.6;
110 53529 : desiredMaxSpeed = DEFAULT_BICYCLE_SPEED;
111 53529 : width = 0.65;
112 53529 : height = 1.7;
113 53529 : shape = SUMOVehicleShape::BICYCLE;
114 53529 : personCapacity = 1;
115 107058 : emissionClass = PollutantsInterface::getClassByName(EMPREFIX + "zero", vclass);
116 53529 : mass = 10.;
117 53529 : speedFactor.getParameter()[1] = 0.1;
118 53529 : latAlignmentProcedure = LatAlignmentDefinition::RIGHT;
119 53529 : break;
120 24 : case SVC_SCOOTER:
121 24 : minGap = 0.5;
122 24 : minGapLat = 0.35;
123 24 : maxSpeed = 25 / 3.6;
124 24 : desiredMaxSpeed = DEFAULT_BICYCLE_SPEED;
125 24 : width = 0.5;
126 24 : height = 1.7;
127 24 : shape = SUMOVehicleShape::SCOOTER;
128 24 : personCapacity = 1;
129 48 : emissionClass = PollutantsInterface::getClassByName(EMPREFIX + "zero", vclass);
130 24 : mass = 10.;
131 24 : speedFactor.getParameter()[1] = 0.1;
132 24 : latAlignmentProcedure = LatAlignmentDefinition::RIGHT;
133 24 : break;
134 118 : case SVC_MOPED:
135 118 : maxSpeed = 60. / 3.6;
136 118 : width = 0.78;
137 118 : height = 1.7;
138 118 : shape = SUMOVehicleShape::MOPED;
139 118 : personCapacity = 1;
140 236 : emissionClass = PollutantsInterface::getClassByName(EMPREFIX + "LDV_G_EU6", vclass);
141 118 : mass = 80.;
142 118 : speedFactor.getParameter()[1] = 0.1;
143 118 : break;
144 139 : case SVC_MOTORCYCLE:
145 139 : width = 0.9;
146 139 : height = 1.5;
147 139 : shape = SUMOVehicleShape::MOTORCYCLE;
148 139 : personCapacity = 1;
149 278 : emissionClass = PollutantsInterface::getClassByName(EMPREFIX + "LDV_G_EU6", vclass);
150 139 : mass = 200.;
151 139 : speedFactor.getParameter()[1] = 0.1;
152 139 : break;
153 481 : case SVC_TRUCK:
154 481 : maxSpeed = 130. / 3.6;
155 481 : width = 2.4;
156 481 : height = 2.4;
157 481 : shape = SUMOVehicleShape::TRUCK;
158 : osgFile = "car-microcargo-citrus.obj";
159 481 : personCapacity = 2;
160 481 : containerCapacity = 1;
161 962 : emissionClass = PollutantsInterface::getClassByName(EMPREFIX + "HDV", vclass);
162 481 : mass = 12000.;
163 481 : speedFactor.getParameter()[1] = 0.05;
164 481 : break;
165 58 : case SVC_TRAILER:
166 58 : maxSpeed = 130. / 3.6;
167 58 : width = 2.55;
168 58 : height = 4.;
169 58 : shape = SUMOVehicleShape::TRUCK_1TRAILER;
170 : osgFile = "car-microcargo-citrus.obj";
171 58 : personCapacity = 2;
172 58 : containerCapacity = 2;
173 116 : emissionClass = PollutantsInterface::getClassByName(EMPREFIX + "HDV", vclass);
174 58 : mass = 15000.;
175 58 : speedFactor.getParameter()[1] = 0.05;
176 58 : break;
177 961 : case SVC_BUS:
178 961 : maxSpeed = 100. / 3.6;
179 961 : width = 2.5;
180 961 : height = 3.4;
181 961 : shape = SUMOVehicleShape::BUS;
182 : osgFile = "car-minibus-citrus.obj";
183 961 : personCapacity = 85;
184 1922 : emissionClass = PollutantsInterface::getClassByName(EMPREFIX + "Bus", vclass);
185 961 : mass = 7500.;
186 961 : break;
187 41 : case SVC_COACH:
188 41 : maxSpeed = 100. / 3.6;
189 41 : width = 2.6;
190 41 : height = 4.;
191 41 : shape = SUMOVehicleShape::BUS_COACH;
192 : osgFile = "car-minibus-citrus.obj";
193 41 : personCapacity = 70;
194 82 : emissionClass = PollutantsInterface::getClassByName(EMPREFIX + "Coach", vclass);
195 41 : mass = 12000.;
196 41 : speedFactor.getParameter()[1] = 0.05;
197 41 : break;
198 180 : case SVC_TRAM:
199 180 : maxSpeed = 80. / 3.6;
200 180 : width = 2.4;
201 180 : height = 3.2;
202 180 : shape = SUMOVehicleShape::RAIL_CAR;
203 : osgFile = "tram.obj";
204 180 : personCapacity = 120;
205 360 : emissionClass = PollutantsInterface::getClassByName(EMPREFIX + "zero", vclass);
206 180 : mass = 37900.;
207 180 : break;
208 568 : case SVC_RAIL_URBAN:
209 : case SVC_SUBWAY:
210 568 : maxSpeed = 100. / 3.6;
211 568 : minGap = 5;
212 568 : width = 3.0;
213 568 : height = 3.6;
214 568 : shape = SUMOVehicleShape::RAIL_CAR;
215 568 : personCapacity = 300;
216 1136 : emissionClass = PollutantsInterface::getClassByName(EMPREFIX + "zero", vclass);
217 568 : mass = 59000.;
218 568 : break;
219 54711 : case SVC_RAIL:
220 54711 : maxSpeed = 160. / 3.6;
221 54711 : minGap = 5;
222 54711 : width = 2.84;
223 54711 : height = 3.75;
224 54711 : shape = SUMOVehicleShape::RAIL;
225 54711 : personCapacity = 434;
226 : // slight understatement (-:
227 109422 : emissionClass = PollutantsInterface::getClassByName(EMPREFIX + "HDV_D_EU0", vclass);
228 54711 : mass = 79500.; // only locomotive
229 54711 : break;
230 24 : case SVC_RAIL_ELECTRIC:
231 24 : maxSpeed = 220. / 3.6;
232 24 : minGap = 5;
233 24 : width = 2.95;
234 24 : height = 3.89;
235 24 : shape = SUMOVehicleShape::RAIL;
236 24 : personCapacity = 425;
237 48 : emissionClass = PollutantsInterface::getClassByName(EMPREFIX + "zero", vclass);
238 24 : mass = 83000.; // only locomotive
239 24 : break;
240 24 : case SVC_RAIL_FAST:
241 24 : maxSpeed = 330. / 3.6;
242 24 : minGap = 5;
243 24 : width = 2.95;
244 24 : height = 3.89;
245 24 : shape = SUMOVehicleShape::RAIL;
246 24 : personCapacity = 425;
247 48 : emissionClass = PollutantsInterface::getClassByName(EMPREFIX + "zero", vclass);
248 24 : mass = 409000.;
249 24 : break;
250 99 : case SVC_DELIVERY:
251 99 : width = 2.16;
252 99 : height = 2.86;
253 99 : shape = SUMOVehicleShape::DELIVERY;
254 99 : personCapacity = 2;
255 198 : emissionClass = PollutantsInterface::getClassByName(EMPREFIX + "LDV", vclass);
256 99 : mass = 5000.;
257 99 : speedFactor.getParameter()[1] = 0.05;
258 99 : break;
259 233 : case SVC_EMERGENCY:
260 233 : width = 2.16;
261 233 : height = 2.86;
262 233 : shape = SUMOVehicleShape::DELIVERY;
263 233 : personCapacity = 2;
264 466 : emissionClass = PollutantsInterface::getClassByName(EMPREFIX + "LDV", vclass);
265 233 : mass = 5000.;
266 233 : break;
267 399181 : case SVC_PRIVATE:
268 : case SVC_VIP:
269 : case SVC_PASSENGER:
270 : case SVC_HOV:
271 : case SVC_CUSTOM1:
272 : case SVC_CUSTOM2:
273 399181 : shape = SUMOVehicleShape::PASSENGER;
274 399181 : speedFactor.getParameter()[1] = 0.1;
275 399181 : break;
276 53552 : case SVC_TAXI:
277 53552 : shape = SUMOVehicleShape::TAXI;
278 53552 : speedFactor.getParameter()[1] = 0.05;
279 53552 : break;
280 24 : case SVC_E_VEHICLE:
281 24 : shape = SUMOVehicleShape::E_VEHICLE;
282 48 : emissionClass = PollutantsInterface::getClassByName(EMPREFIX + "zero", vclass);
283 24 : speedFactor.getParameter()[1] = 0.1;
284 24 : break;
285 42963 : case SVC_CONTAINER:
286 42963 : width = 2.5908;
287 42963 : break;
288 24 : case SVC_DRONE:
289 24 : width = 0.5;
290 24 : break;
291 24 : case SVC_AIRCRAFT:
292 : // Airbus A380
293 24 : shape = SUMOVehicleShape::AIRCRAFT;
294 24 : width = 79.8;
295 24 : break;
296 294 : case SVC_SHIP:
297 294 : width = 4;
298 294 : maxSpeed = 8 / 1.94; // 8 knots
299 294 : height = 4;
300 294 : shape = SUMOVehicleShape::SHIP;
301 : // slight understatement (-:
302 588 : emissionClass = PollutantsInterface::getClassByName(EMPREFIX + "HDV_D_EU0", vclass);
303 294 : mass = 100000.;
304 294 : speedFactor.getParameter()[1] = 0.1;
305 294 : break;
306 : default:
307 : break;
308 : }
309 718185 : }
310 :
311 :
312 0 : SUMOVTypeParameter::VClassDefaultValues::VClassDefaultValues() :
313 0 : speedFactor("normc", 1.0, 0.0, 0.2, 2.0) {}
314 :
315 373147 : SUMOVTypeParameter::SUMOVTypeParameter(const std::string& vtid, const SUMOVehicleClass vclass)
316 373147 : : id(vtid),
317 373147 : actionStepLength(0),
318 373147 : defaultProbability(DEFAULT_VEH_PROB),
319 373147 : speedFactor("normc", 1.0, 0.0, 0.2, 2.0),
320 746294 : emissionClass(PollutantsInterface::getClassByName(EMPREFIX + "PC_G_EU4", vclass)),
321 373147 : color(RGBColor::DEFAULT_COLOR),
322 373147 : vehicleClass(vclass),
323 373147 : impatience(0.0),
324 373147 : personCapacity(4),
325 373147 : containerCapacity(0),
326 373147 : boardingDuration(500),
327 373147 : loadingDuration(90000),
328 373147 : scale(1),
329 373147 : width(1.8),
330 373147 : height(1.5),
331 373147 : shape(SUMOVehicleShape::UNKNOWN),
332 373147 : osgFile("car-normal-citrus.obj"),
333 373147 : cfModel(SUMO_TAG_CF_KRAUSS),
334 373147 : lcModel(LaneChangeModel::DEFAULT),
335 373147 : maxSpeedLat(1.0),
336 373147 : latAlignmentOffset(0.0),
337 373147 : latAlignmentProcedure(LatAlignmentDefinition::CENTER),
338 373147 : carriageLength(-1),
339 373147 : locomotiveLength(-1),
340 373147 : carriageGap(1),
341 373147 : carriageDoors(2),
342 373147 : timeToTeleport(TTT_UNSET),
343 373147 : timeToTeleportBidi(TTT_UNSET),
344 373147 : speedFactorPremature(-1),
345 373147 : frontSeatPos(1.7),
346 373147 : seatingWidth(-1),
347 373147 : boardingFactor(1),
348 373147 : parametersSet(0),
349 373147 : saved(false),
350 373147 : onlyReferenced(false) {
351 373147 : const OptionsCont& oc = OptionsCont::getOptions();
352 746294 : if (oc.exists("carfollow.model")) {
353 : // check for valid value has been performed in MSFrame
354 642880 : cfModel = SUMOXMLDefinitions::CarFollowModels.get(oc.getString("carfollow.model"));
355 : }
356 : // obtain default values depending of vclass
357 373147 : VClassDefaultValues defaultValues(vclass);
358 : // overwrite SUMOVTypeParameter with VClassDefaultValues
359 373147 : length = defaultValues.length;
360 373147 : minGap = defaultValues.minGap;
361 373147 : minGapLat = defaultValues.minGapLat;
362 373147 : maxSpeed = defaultValues.maxSpeed;
363 373147 : desiredMaxSpeed = defaultValues.desiredMaxSpeed;
364 373147 : width = defaultValues.width;
365 373147 : height = defaultValues.height;
366 373147 : shape = defaultValues.shape;
367 373147 : emissionClass = defaultValues.emissionClass;
368 373147 : mass = defaultValues.mass;
369 : speedFactor = defaultValues.speedFactor;
370 373147 : personCapacity = defaultValues.personCapacity;
371 373147 : containerCapacity = defaultValues.containerCapacity;
372 : osgFile = defaultValues.osgFile;
373 373147 : carriageLength = defaultValues.carriageLength;
374 373147 : locomotiveLength = defaultValues.locomotiveLength;
375 373147 : carriageDoors = defaultValues.carriageDoors;
376 373147 : latAlignmentProcedure = defaultValues.latAlignmentProcedure;
377 : // check if default speeddev was defined
378 746294 : if (oc.exists("default.speeddev")) {
379 321440 : const double defaultSpeedDev = oc.getFloat("default.speeddev");
380 321440 : if (defaultSpeedDev >= 0) {
381 200555 : speedFactor.getParameter()[1] = defaultSpeedDev;
382 : }
383 : } else {
384 51707 : speedFactor.getParameter()[1] = -1;
385 : }
386 373147 : setManoeuverAngleTimes(vclass);
387 373147 : }
388 :
389 : void
390 373147 : SUMOVTypeParameter::setManoeuverAngleTimes(const SUMOVehicleClass vclass) {
391 :
392 : myManoeuverAngleTimes.clear();
393 : /**
394 : * Defaults assume: approaching at angles between 0-10 and 171-180 (will never be > 180) are approaching a space roughly parallel to the road
395 : * approaching at angles between 11-80 are approaching an acute angled space that is easiest to drive straight in
396 : * approaching at angles between 81-110 are approaching a space at approximately right angles to the road so the driver has a choice
397 : * approaching at angles between 111 and 170 are approaching an obtuse angled space that is easiest to drive past and reverse in
398 : * More (or less) granular angle ranges can be used - configurable as a vType parameter
399 : */
400 373147 : switch (vclass) {
401 133330 : case SVC_PASSENGER:
402 : case SVC_HOV:
403 : case SVC_TAXI:
404 : case SVC_E_VEHICLE:
405 133330 : myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(10, std::pair< SUMOTime, SUMOTime>(3000, 4000))); // straight in but potentially needing parallel parking
406 133330 : myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(80, std::pair< SUMOTime, SUMOTime>(1000, 11000))); // straight in
407 133330 : myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(110, std::pair< SUMOTime, SUMOTime>(11000, 2000))); // optional forwards/backwards
408 133330 : myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(170, std::pair< SUMOTime, SUMOTime>(8000, 3000))); // backwards into obtuse space
409 133330 : myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(181, std::pair< SUMOTime, SUMOTime>(3000, 4000))); // straight in but potentially needing parallel parking
410 133330 : break;
411 1640 : case SVC_TRUCK:
412 : case SVC_TRAILER:
413 : case SVC_BUS:
414 : case SVC_COACH:
415 : case SVC_DELIVERY:
416 1640 : myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(10, std::pair< SUMOTime, SUMOTime>(6000, 8000))); // straight in but potentially needing parallel parking
417 1640 : myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(80, std::pair< SUMOTime, SUMOTime>(2000, 21000))); // straight in
418 1640 : myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(110, std::pair< SUMOTime, SUMOTime>(21000, 2000))); // optional forwards/backwards
419 1640 : myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(170, std::pair< SUMOTime, SUMOTime>(14000, 5000))); // backwards into obtuse space
420 1640 : myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(181, std::pair< SUMOTime, SUMOTime>(6000, 8000))); // straight in but potentially needing parallel parking
421 1640 : break;
422 133118 : case SVC_PEDESTRIAN:
423 : case SVC_MOPED:
424 : case SVC_BICYCLE:
425 133118 : myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(181, std::pair< SUMOTime, SUMOTime>(1000, 1000))); // no dependence on angle
426 133118 : break;
427 105059 : default:
428 105059 : myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(10, std::pair< SUMOTime, SUMOTime>(3000, 4000))); // straight in but potentially needing parallel parking
429 105059 : myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(80, std::pair< SUMOTime, SUMOTime>(1000, 11000))); // straight in
430 105059 : myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(110, std::pair< SUMOTime, SUMOTime>(11000, 2000))); // optional forwards/backwards
431 105059 : myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(170, std::pair< SUMOTime, SUMOTime>(8000, 3000))); // backwards into obtuse space
432 105059 : myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(181, std::pair< SUMOTime, SUMOTime>(3000, 4000))); // straight in but potentially needing parallel parking
433 105059 : break;
434 : }
435 373147 : }
436 :
437 : void
438 13348 : SUMOVTypeParameter::write(OutputDevice& dev) const {
439 : // first check if vehicle type can be written
440 13348 : if (onlyReferenced) {
441 : return;
442 : }
443 : // open vehicle tag
444 2777 : dev.openTag(SUMO_TAG_VTYPE);
445 : // write ID (always needed)
446 2777 : dev.writeAttr(SUMO_ATTR_ID, id);
447 : // write parameters depending if is set
448 2777 : if (wasSet(VTYPEPARS_LENGTH_SET)) {
449 783 : dev.writeAttr(SUMO_ATTR_LENGTH, length);
450 : }
451 2777 : if (wasSet(VTYPEPARS_MINGAP_SET)) {
452 677 : dev.writeAttr(SUMO_ATTR_MINGAP, minGap);
453 : }
454 2777 : if (wasSet(VTYPEPARS_MAXSPEED_SET)) {
455 717 : dev.writeAttr(SUMO_ATTR_MAXSPEED, maxSpeed);
456 : }
457 2777 : if (wasSet(VTYPEPARS_DESIRED_MAXSPEED_SET)) {
458 0 : dev.writeAttr(SUMO_ATTR_DESIRED_MAXSPEED, desiredMaxSpeed);
459 : }
460 2777 : if (wasSet(VTYPEPARS_PROBABILITY_SET)) {
461 92 : dev.writeAttr(SUMO_ATTR_PROB, defaultProbability);
462 : }
463 2777 : if (wasSet(VTYPEPARS_SPEEDFACTOR_SET)) {
464 428 : dev.writeAttr(SUMO_ATTR_SPEEDFACTOR, speedFactor);
465 : }
466 2777 : if (wasSet(VTYPEPARS_ACTIONSTEPLENGTH_SET)) {
467 : // Note: action step length is only exposed in seconds to the user
468 210 : dev.writeAttr(SUMO_ATTR_ACTIONSTEPLENGTH, STEPS2TIME(actionStepLength));
469 : }
470 2777 : if (wasSet(VTYPEPARS_VEHICLECLASS_SET)) {
471 932 : dev.writeAttr(SUMO_ATTR_VCLASS, toString(vehicleClass));
472 : }
473 2777 : if (wasSet(VTYPEPARS_EMISSIONCLASS_SET)) {
474 96 : dev.writeAttr(SUMO_ATTR_EMISSIONCLASS, PollutantsInterface::getName(emissionClass));
475 : }
476 2777 : if (wasSet(VTYPEPARS_MASS_SET)) {
477 0 : dev.writeAttr(SUMO_ATTR_MASS, mass);
478 : }
479 2777 : if (wasSet(VTYPEPARS_IMPATIENCE_SET)) {
480 32 : if (impatience == -std::numeric_limits<double>::max()) {
481 : dev.writeAttr(SUMO_ATTR_IMPATIENCE, "off");
482 : } else {
483 32 : dev.writeAttr(SUMO_ATTR_IMPATIENCE, impatience);
484 : }
485 : }
486 2777 : if (wasSet(VTYPEPARS_SHAPE_SET)) {
487 102 : dev.writeAttr(SUMO_ATTR_GUISHAPE, getVehicleShapeName(shape));
488 : }
489 2777 : if (wasSet(VTYPEPARS_WIDTH_SET)) {
490 40 : dev.writeAttr(SUMO_ATTR_WIDTH, width);
491 : }
492 2777 : if (wasSet(VTYPEPARS_HEIGHT_SET)) {
493 0 : dev.writeAttr(SUMO_ATTR_HEIGHT, height);
494 : }
495 2777 : if (wasSet(VTYPEPARS_COLOR_SET)) {
496 396 : dev.writeAttr(SUMO_ATTR_COLOR, color);
497 : }
498 2777 : if (wasSet(VTYPEPARS_OSGFILE_SET)) {
499 0 : dev.writeAttr(SUMO_ATTR_OSGFILE, osgFile);
500 : }
501 2777 : if (wasSet(VTYPEPARS_IMGFILE_SET)) {
502 0 : dev.writeAttr(SUMO_ATTR_IMGFILE, imgFile);
503 : }
504 2777 : if (wasSet(VTYPEPARS_PERSON_CAPACITY)) {
505 0 : dev.writeAttr(SUMO_ATTR_PERSON_CAPACITY, personCapacity);
506 : }
507 2777 : if (wasSet(VTYPEPARS_CONTAINER_CAPACITY)) {
508 0 : dev.writeAttr(SUMO_ATTR_CONTAINER_CAPACITY, containerCapacity);
509 : }
510 2777 : if (wasSet(VTYPEPARS_BOARDING_DURATION)) {
511 16 : dev.writeAttr(SUMO_ATTR_BOARDING_DURATION, time2string(boardingDuration));
512 : }
513 2777 : if (wasSet(VTYPEPARS_LOADING_DURATION)) {
514 16 : dev.writeAttr(SUMO_ATTR_LOADING_DURATION, time2string(loadingDuration));
515 : }
516 2777 : if (wasSet(VTYPEPARS_MAXSPEED_LAT_SET)) {
517 8 : dev.writeAttr(SUMO_ATTR_MAXSPEED_LAT, maxSpeedLat);
518 : }
519 2777 : if (wasSet(VTYPEPARS_LATALIGNMENT_SET)) {
520 8 : switch (latAlignmentProcedure) {
521 0 : case LatAlignmentDefinition::GIVEN:
522 0 : dev.writeAttr(SUMO_ATTR_LATALIGNMENT, latAlignmentOffset);
523 : break;
524 : case LatAlignmentDefinition::RIGHT:
525 : dev.writeAttr(SUMO_ATTR_LATALIGNMENT, "right");
526 : break;
527 : case LatAlignmentDefinition::CENTER:
528 : dev.writeAttr(SUMO_ATTR_LATALIGNMENT, "center");
529 : break;
530 : case LatAlignmentDefinition::ARBITRARY:
531 : dev.writeAttr(SUMO_ATTR_LATALIGNMENT, "arbitrary");
532 : break;
533 : case LatAlignmentDefinition::NICE:
534 : dev.writeAttr(SUMO_ATTR_LATALIGNMENT, "nice");
535 : break;
536 : case LatAlignmentDefinition::COMPACT:
537 : dev.writeAttr(SUMO_ATTR_LATALIGNMENT, "compact");
538 : break;
539 : case LatAlignmentDefinition::LEFT:
540 : dev.writeAttr(SUMO_ATTR_LATALIGNMENT, "left");
541 : break;
542 : case LatAlignmentDefinition::DEFAULT:
543 : default:
544 : break;
545 : }
546 : }
547 2777 : if (wasSet(VTYPEPARS_MINGAP_LAT_SET)) {
548 8 : dev.writeAttr(SUMO_ATTR_MINGAP_LAT, minGapLat);
549 : }
550 2777 : if (wasSet(VTYPEPARS_MANEUVER_ANGLE_TIMES_SET)) {
551 0 : dev.writeAttr(SUMO_ATTR_MANEUVER_ANGLE_TIMES, getManoeuverAngleTimesS());
552 : }
553 2777 : if (wasSet(VTYPEPARS_SCALE_SET)) {
554 0 : dev.writeAttr(SUMO_ATTR_SCALE, scale);
555 : }
556 2777 : if (wasSet(VTYPEPARS_TTT_SET)) {
557 16 : dev.writeAttr(SUMO_ATTR_TIME_TO_TELEPORT, time2string(timeToTeleport));
558 : }
559 2777 : if (wasSet(VTYPEPARS_TTT_BIDI_SET)) {
560 0 : dev.writeAttr(SUMO_ATTR_TIME_TO_TELEPORT_BIDI, time2string(timeToTeleportBidi));
561 : }
562 2777 : if (wasSet(VTYPEPARS_SPEEDFACTOR_PREMATURE_SET)) {
563 0 : dev.writeAttr(SUMO_ATTR_SPEEDFACTOR_PREMATURE, speedFactorPremature);
564 : }
565 2777 : if (wasSet(VTYPEPARS_BOARDING_FACTOR_SET)) {
566 0 : dev.writeAttr(SUMO_ATTR_BOARDING_FACTOR, boardingFactor);
567 : }
568 2777 : if (wasSet(VTYPEPARS_LANE_CHANGE_MODEL_SET)) {
569 0 : dev.writeAttr(SUMO_ATTR_LANE_CHANGE_MODEL, lcModel);
570 : }
571 : // Write Lane Change Model parameters
572 2777 : for (const auto& lcParam : lcParameter) {
573 0 : dev.writeAttr(lcParam.first, lcParam.second);
574 : }
575 : // Write Junction Model parameter
576 2777 : for (const auto& jmParam : jmParameter) {
577 0 : dev.writeAttr(jmParam.first, jmParam.second);
578 : }
579 2777 : if (wasSet(VTYPEPARS_CAR_FOLLOW_MODEL)) {
580 52 : dev.writeAttr(SUMO_ATTR_CAR_FOLLOW_MODEL, SUMOXMLDefinitions::CarFollowModels.getString(cfModel));
581 : }
582 : // Write Car Following Model parameters
583 6037 : for (const auto& cfParam : cfParameter) {
584 3260 : dev.writeAttr(cfParam.first, cfParam.second);
585 : }
586 : // Write carriage length
587 2777 : if (wasSet(VTYPEPARS_CARRIAGE_LENGTH_SET)) {
588 0 : dev.openTag(SUMO_TAG_PARAM);
589 0 : dev.writeAttr(SUMO_ATTR_KEY, toString(SUMO_ATTR_CARRIAGE_LENGTH));
590 0 : dev.writeAttr(SUMO_ATTR_VALUE, toString(carriageLength));
591 0 : dev.closeTag();
592 : }
593 : // Write locomotive length
594 2777 : if (wasSet(VTYPEPARS_LOCOMOTIVE_LENGTH_SET)) {
595 0 : dev.openTag(SUMO_TAG_PARAM);
596 0 : dev.writeAttr(SUMO_ATTR_KEY, toString(SUMO_ATTR_LOCOMOTIVE_LENGTH));
597 0 : dev.writeAttr(SUMO_ATTR_VALUE, toString(locomotiveLength));
598 0 : dev.closeTag();
599 : }
600 : // Write carriage gap
601 2777 : if (wasSet(VTYPEPARS_CARRIAGE_GAP_SET)) {
602 0 : dev.openTag(SUMO_TAG_PARAM);
603 0 : dev.writeAttr(SUMO_ATTR_KEY, toString(SUMO_ATTR_CARRIAGE_GAP));
604 0 : dev.writeAttr(SUMO_ATTR_VALUE, toString(carriageGap));
605 0 : dev.closeTag();
606 : }
607 : // Write carriage doors
608 2777 : if (wasSet(VTYPEPARS_CARRIAGE_DOORS_SET)) {
609 0 : dev.openTag(SUMO_TAG_PARAM);
610 0 : dev.writeAttr(SUMO_ATTR_KEY, toString(SUMO_ATTR_CARRIAGE_DOORS));
611 0 : dev.writeAttr(SUMO_ATTR_VALUE, toString(carriageDoors));
612 0 : dev.closeTag();
613 : }
614 : // Write rest of parameters
615 2777 : writeParams(dev);
616 : // close tag
617 5554 : dev.closeTag();
618 : }
619 :
620 :
621 : double
622 4459909 : SUMOVTypeParameter::getCFParam(const SumoXMLAttr attr, const double defaultValue) const {
623 : if (cfParameter.count(attr)) {
624 52359 : return StringUtils::toDouble(cfParameter.find(attr)->second);
625 : } else {
626 : return defaultValue;
627 : }
628 : }
629 :
630 :
631 : std::string
632 1352 : SUMOVTypeParameter::getCFParamString(const SumoXMLAttr attr, const std::string defaultValue) const {
633 : if (cfParameter.count(attr)) {
634 : return cfParameter.find(attr)->second;
635 : } else {
636 : return defaultValue;
637 : }
638 : }
639 :
640 :
641 : double
642 80436029 : SUMOVTypeParameter::getLCParam(const SumoXMLAttr attr, const double defaultValue) const {
643 : if (lcParameter.count(attr)) {
644 332644 : return StringUtils::toDouble(lcParameter.find(attr)->second);
645 : } else {
646 : return defaultValue;
647 : }
648 : }
649 :
650 :
651 : std::string
652 67388 : SUMOVTypeParameter::getLCParamString(const SumoXMLAttr attr, const std::string& defaultValue) const {
653 : if (lcParameter.count(attr)) {
654 : return lcParameter.find(attr)->second;
655 : } else {
656 : return defaultValue;
657 : }
658 : }
659 :
660 :
661 : const SUMOVTypeParameter::SubParams&
662 140348 : SUMOVTypeParameter::getLCParams() const {
663 140348 : return lcParameter;
664 : }
665 :
666 :
667 : double
668 2489420108 : SUMOVTypeParameter::getJMParam(const SumoXMLAttr attr, const double defaultValue) const {
669 : if (jmParameter.count(attr)) {
670 18422907 : return StringUtils::toDouble(jmParameter.find(attr)->second);
671 : } else {
672 : return defaultValue;
673 : }
674 : }
675 :
676 :
677 : std::string
678 0 : SUMOVTypeParameter::getJMParamString(const SumoXMLAttr attr, const std::string defaultValue) const {
679 : if (jmParameter.count(attr)) {
680 : return jmParameter.find(attr)->second;
681 : } else {
682 : return defaultValue;
683 : }
684 : }
685 :
686 : SUMOTime
687 30 : SUMOVTypeParameter::getEntryManoeuvreTime(const int angle) const {
688 : SUMOTime last = 0;
689 90 : for (std::pair<int, std::pair<SUMOTime, SUMOTime>> angleTime : myManoeuverAngleTimes) {
690 90 : if (angle <= angleTime.first) {
691 : return (angleTime.second.first);
692 : } else {
693 : last = angleTime.second.first;
694 : }
695 : }
696 0 : return (last);
697 : }
698 :
699 : SUMOTime
700 30 : SUMOVTypeParameter::getExitManoeuvreTime(const int angle) const {
701 : SUMOTime last = 0;
702 90 : for (std::pair<int, std::pair<SUMOTime, SUMOTime>> angleTime : myManoeuverAngleTimes) {
703 90 : if (angle <= angleTime.first) {
704 : return (angleTime.second.second);
705 : } else {
706 : last = angleTime.second.second;
707 : }
708 : }
709 0 : return (last);
710 : }
711 :
712 : std::string
713 0 : SUMOVTypeParameter::getManoeuverAngleTimesS() const {
714 0 : std::stringstream stream;
715 :
716 : stream << std::fixed << std::setprecision(1);
717 : int count = 0;
718 0 : for (std::pair<int, std::pair<SUMOTime, SUMOTime>> angleTime : myManoeuverAngleTimes) {
719 0 : if (count++ > 0) {
720 0 : stream << ",";
721 : }
722 0 : stream << toString(angleTime.first) + " " << STEPS2TIME(angleTime.second.first) << " " << STEPS2TIME(angleTime.second.second);
723 : }
724 : std::string triplets = stream.str();
725 0 : return triplets;
726 0 : }
727 :
728 :
729 : void
730 12 : SUMOVTypeParameter::cacheParamRestrictions(const std::vector<std::string>& restrictionKeys) {
731 24 : for (const std::string& key : restrictionKeys) {
732 24 : paramRestrictions.push_back(StringUtils::toDouble(getParameter(key, "0")));
733 : }
734 12 : }
735 :
736 :
737 : void
738 316028 : SUMOVTypeParameter::initRailVisualizationParameters() {
739 632056 : if (hasParameter("carriageLength")) {
740 114 : carriageLength = StringUtils::toDouble(getParameter("carriageLength"));
741 57 : parametersSet |= VTYPEPARS_CARRIAGE_LENGTH_SET;
742 : } else {
743 315971 : switch (shape) {
744 6 : case SUMOVehicleShape::BUS_FLEXIBLE:
745 6 : carriageLength = 8.25; // 16.5 overall, 2 modules http://de.wikipedia.org/wiki/Ikarus_180
746 6 : carriageGap = 0;
747 6 : break;
748 44628 : case SUMOVehicleShape::RAIL:
749 44628 : if (vehicleClass == SVC_RAIL_ELECTRIC) {
750 24 : carriageLength = 24.5;
751 24 : locomotiveLength = 19.100; // https://en.wikipedia.org/wiki/DB_Class_101
752 44604 : } else if (vehicleClass == SVC_RAIL_FAST) {
753 24 : carriageLength = 24.775; // http://de.wikipedia.org/wiki/ICE_3
754 24 : locomotiveLength = 25.835;
755 : } else {
756 44580 : carriageLength = 24.5; // http://de.wikipedia.org/wiki/UIC-Y-Wagen_%28DR%29
757 44580 : locomotiveLength = 16.4; // https://en.wikipedia.org/wiki/DB_Class_218
758 : }
759 : break;
760 530 : case SUMOVehicleShape::RAIL_CAR:
761 530 : if (vehicleClass == SVC_TRAM) {
762 125 : carriageLength = 5.71; // http://de.wikipedia.org/wiki/Bombardier_Flexity_Berlin
763 125 : locomotiveLength = 5.71;
764 405 : } else if (vehicleClass == SVC_RAIL_URBAN) {
765 357 : carriageLength = 18.4; // https://en.wikipedia.org/wiki/DBAG_Class_481
766 357 : locomotiveLength = 18.4;
767 : } else {
768 48 : carriageLength = 16.85; // 67.4m overall, 4 carriages http://de.wikipedia.org/wiki/DB-Baureihe_423
769 : }
770 : break;
771 8 : case SUMOVehicleShape::RAIL_CARGO:
772 8 : carriageLength = 13.86; // UIC 571-1 http://de.wikipedia.org/wiki/Flachwagen
773 8 : break;
774 7 : case SUMOVehicleShape::TRUCK_SEMITRAILER:
775 7 : carriageLength = 13.5;
776 7 : locomotiveLength = 2.5;
777 7 : carriageGap = 0.5;
778 7 : break;
779 81 : case SUMOVehicleShape::TRUCK_1TRAILER:
780 81 : carriageLength = 6.75;
781 81 : locomotiveLength = 2.5 + 6.75;
782 81 : carriageGap = 0.5;
783 81 : break;
784 : default:
785 : break;
786 : }
787 : }
788 632056 : if (hasParameter("locomotiveLength")) {
789 58 : locomotiveLength = StringUtils::toDouble(getParameter("locomotiveLength"));
790 29 : parametersSet |= VTYPEPARS_LOCOMOTIVE_LENGTH_SET;
791 315999 : } else if (locomotiveLength < 0) {
792 270801 : locomotiveLength = carriageLength;
793 : }
794 632056 : if (hasParameter("carriageGap")) {
795 8 : carriageGap = StringUtils::toDouble(getParameter("carriageGap"));
796 4 : parametersSet |= VTYPEPARS_CARRIAGE_GAP_SET;
797 : }
798 632056 : if (hasParameter("carriageDoors")) {
799 24 : carriageDoors = StringUtils::toInt(getParameter("carriageDoors"));
800 12 : parametersSet |= VTYPEPARS_CARRIAGE_DOORS_SET;
801 : }
802 632056 : if (hasParameter("frontSeatPos")) {
803 30 : frontSeatPos = StringUtils::toDouble(getParameter("frontSeatPos"));
804 15 : parametersSet |= VTYPEPARS_FRONT_SEAT_POS_SET;
805 : } else {
806 316013 : switch (shape) {
807 223 : case SUMOVehicleShape::SHIP:
808 223 : frontSeatPos = 5;
809 223 : break;
810 200 : case SUMOVehicleShape::DELIVERY:
811 200 : frontSeatPos = 1.2;
812 200 : break;
813 43566 : case SUMOVehicleShape::BICYCLE:
814 43566 : frontSeatPos = 0.6;
815 43566 : break;
816 262 : case SUMOVehicleShape::MOPED:
817 : case SUMOVehicleShape::MOTORCYCLE:
818 262 : frontSeatPos = 0.9;
819 262 : break;
820 889 : case SUMOVehicleShape::BUS:
821 : case SUMOVehicleShape::BUS_COACH:
822 : case SUMOVehicleShape::BUS_FLEXIBLE:
823 : case SUMOVehicleShape::BUS_TROLLEY:
824 889 : frontSeatPos = 0.5;
825 889 : break;
826 600 : case SUMOVehicleShape::TRUCK:
827 : case SUMOVehicleShape::TRUCK_1TRAILER:
828 : case SUMOVehicleShape::TRUCK_SEMITRAILER:
829 600 : frontSeatPos = 0.8;
830 600 : break;
831 : default:
832 : break;
833 : }
834 : }
835 :
836 632056 : if (hasParameter("seatingWidth")) {
837 14 : seatingWidth = StringUtils::toDouble(getParameter("seatingWidth"));
838 7 : parametersSet |= VTYPEPARS_SEATING_WIDTH_SET;
839 : }
840 316028 : }
841 :
842 :
843 : double
844 317835 : SUMOVTypeParameter::getDefaultAccel(const SUMOVehicleClass vc) {
845 317835 : switch (vc) {
846 : case SVC_PEDESTRIAN:
847 : case SVC_WHEELCHAIR:
848 : return 1.5;
849 : case SVC_BICYCLE:
850 : case SVC_SCOOTER:
851 : return 1.2;
852 139 : case SVC_MOTORCYCLE:
853 139 : return 6.;
854 : case SVC_MOPED:
855 : return 1.1;
856 493 : case SVC_TRUCK:
857 493 : return 1.3;
858 : case SVC_TRAILER:
859 : return 1.1;
860 : case SVC_BUS:
861 : return 1.2;
862 41 : case SVC_COACH:
863 41 : return 2.;
864 : case SVC_TRAM:
865 : return 1.;
866 : case SVC_RAIL_URBAN:
867 : return 1.;
868 44722 : case SVC_RAIL:
869 44722 : return 0.25;
870 48 : case SVC_RAIL_ELECTRIC:
871 : case SVC_RAIL_FAST:
872 48 : return 0.5;
873 223 : case SVC_SHIP:
874 223 : return 0.1;
875 157495 : default:
876 157495 : return 2.6;//2.9;
877 : }
878 : }
879 :
880 :
881 : double
882 719469 : SUMOVTypeParameter::getDefaultDecel(const SUMOVehicleClass vc) {
883 719469 : switch (vc) {
884 : case SVC_PEDESTRIAN:
885 : case SVC_WHEELCHAIR:
886 : return 2.;
887 : case SVC_BICYCLE:
888 : case SVC_SCOOTER:
889 : return 3.;
890 236 : case SVC_MOPED:
891 236 : return 7.;
892 278 : case SVC_MOTORCYCLE:
893 278 : return 10.;
894 2678 : case SVC_TRUCK:
895 : case SVC_TRAILER:
896 : case SVC_BUS:
897 : case SVC_COACH:
898 2678 : return 4.;
899 : case SVC_TRAM:
900 : case SVC_RAIL_URBAN:
901 : return 3.;
902 132191 : case SVC_RAIL:
903 : case SVC_RAIL_ELECTRIC:
904 : case SVC_RAIL_FAST:
905 132191 : return 1.3;
906 446 : case SVC_SHIP:
907 446 : return 0.15;
908 356310 : default:
909 356310 : return 4.5;//7.5;
910 : }
911 : }
912 :
913 :
914 : double
915 633787 : SUMOVTypeParameter::getDefaultEmergencyDecel(const SUMOVehicleClass vc, double decel, double defaultOption) {
916 633787 : if (defaultOption == VTYPEPARS_DEFAULT_EMERGENCYDECEL_DEFAULT) {
917 : double vcDecel;
918 628379 : switch (vc) {
919 : case SVC_PEDESTRIAN:
920 : case SVC_WHEELCHAIR:
921 : vcDecel = 5.;
922 : break;
923 : case SVC_BICYCLE:
924 : case SVC_SCOOTER:
925 : vcDecel = 7.;
926 : break;
927 514 : case SVC_MOPED:
928 : case SVC_MOTORCYCLE:
929 : vcDecel = 10.;
930 514 : break;
931 : case SVC_TRUCK:
932 : case SVC_TRAILER:
933 : case SVC_BUS:
934 : case SVC_COACH:
935 : case SVC_TRAM:
936 : case SVC_RAIL_URBAN:
937 : vcDecel = 7.;
938 : break;
939 : case SVC_RAIL:
940 : case SVC_RAIL_ELECTRIC:
941 : case SVC_RAIL_FAST:
942 : vcDecel = 5.;
943 : break;
944 446 : case SVC_SHIP:
945 : vcDecel = 1.;
946 446 : break;
947 310181 : default:
948 : vcDecel = 9.;
949 : }
950 : return MAX2(decel, vcDecel);
951 5408 : } else if (defaultOption == VTYPEPARS_DEFAULT_EMERGENCYDECEL_DECEL) {
952 : return decel;
953 : } else {
954 : // value already checked in MSFrame::checkOptions
955 : return MAX2(decel, defaultOption);
956 : }
957 : }
958 :
959 :
960 :
961 : double
962 307396 : SUMOVTypeParameter::getDefaultImperfection(const SUMOVehicleClass vc) {
963 307396 : switch (vc) {
964 : case SVC_TRAM:
965 : case SVC_RAIL_URBAN:
966 : case SVC_RAIL:
967 : case SVC_RAIL_ELECTRIC:
968 : case SVC_RAIL_FAST:
969 : case SVC_SHIP:
970 : return 0.;
971 263459 : default:
972 263459 : return 0.5;
973 : }
974 : }
975 :
976 : const SUMOVTypeParameter&
977 16306828 : SUMOVTypeParameter::getDefault() {
978 16312210 : static SUMOVTypeParameter defaultParams("");
979 16306828 : return defaultParams;
980 : }
981 :
982 : bool
983 1719 : SUMOVTypeParameter::parseLatAlignment(const std::string& val, double& lao, LatAlignmentDefinition& lad) {
984 : bool ok = true;
985 1719 : lao = 0.0;
986 1719 : lad = LatAlignmentDefinition::GIVEN;
987 1719 : if (val == "right") {
988 315 : lad = LatAlignmentDefinition::RIGHT;
989 1404 : } else if (val == "center") {
990 677 : lad = LatAlignmentDefinition::CENTER;
991 727 : } else if (val == "arbitrary") {
992 336 : lad = LatAlignmentDefinition::ARBITRARY;
993 391 : } else if (val == "nice") {
994 46 : lad = LatAlignmentDefinition::NICE;
995 345 : } else if (val == "compact") {
996 244 : lad = LatAlignmentDefinition::COMPACT;
997 101 : } else if (val == "left") {
998 86 : lad = LatAlignmentDefinition::LEFT;
999 : } else {
1000 : try {
1001 15 : lao = StringUtils::toDouble(val);
1002 0 : } catch (...) {
1003 : ok = false;
1004 0 : }
1005 : }
1006 1719 : return ok;
1007 : }
1008 :
1009 :
1010 : SUMOTime
1011 67049704 : SUMOVTypeParameter::getTimeToTeleport(SUMOTime defaultValue) const {
1012 67049704 : return timeToTeleport == TTT_UNSET ? defaultValue : timeToTeleport;
1013 : }
1014 :
1015 : SUMOTime
1016 67049704 : SUMOVTypeParameter::getTimeToTeleportBidi(SUMOTime defaultValue) const {
1017 67049704 : return timeToTeleportBidi == TTT_UNSET ? defaultValue : timeToTeleportBidi;
1018 : }
1019 :
1020 : /****************************************************************************/
|
