Line data Source code
1 : /****************************************************************************/
2 : // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3 : // Copyright (C) 2001-2025 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/StringTokenizer.h>
29 : #include <utils/common/MsgHandler.h>
30 : #include <utils/common/FileHelpers.h>
31 : #include <utils/iodevices/OutputDevice.h>
32 : #include <utils/options/OptionsCont.h>
33 : #include <utils/xml/SUMOXMLDefinitions.h>
34 : #include <utils/emissions/PollutantsInterface.h>
35 :
36 : #define EMPREFIX std::string("HBEFA4/")
37 : #define TTT_UNSET SUMOTime_MIN
38 :
39 : // ===========================================================================
40 : // static value definitions
41 : // ===========================================================================
42 : std::set<SumoXMLAttr> SUMOVTypeParameter::AllowedJMAttrs({
43 : SUMO_ATTR_JM_CROSSING_GAP,
44 : SUMO_ATTR_JM_DRIVE_AFTER_YELLOW_TIME,
45 : SUMO_ATTR_JM_DRIVE_AFTER_RED_TIME,
46 : SUMO_ATTR_JM_DRIVE_RED_SPEED,
47 : SUMO_ATTR_JM_IGNORE_KEEPCLEAR_TIME,
48 : SUMO_ATTR_JM_IGNORE_FOE_SPEED,
49 : SUMO_ATTR_JM_IGNORE_FOE_PROB,
50 : SUMO_ATTR_JM_IGNORE_JUNCTION_FOE_PROB,
51 : SUMO_ATTR_JM_SIGMA_MINOR,
52 : SUMO_ATTR_JM_STOPLINE_GAP,
53 : SUMO_ATTR_JM_STOPLINE_GAP_MINOR,
54 : SUMO_ATTR_JM_TIMEGAP_MINOR,
55 : SUMO_ATTR_JM_EXTRA_GAP,
56 : SUMO_ATTR_JM_ADVANCE,
57 : SUMO_ATTR_JM_STOPSIGN_WAIT,
58 : SUMO_ATTR_JM_ALLWAYSTOP_WAIT,
59 : });
60 :
61 :
62 : // ===========================================================================
63 : // member method definitions
64 : // ===========================================================================
65 :
66 359442 : SUMOVTypeParameter::VClassDefaultValues::VClassDefaultValues(SUMOVehicleClass vclass) :
67 359442 : length(getDefaultVehicleLength(vclass)),
68 359442 : minGap(2.5),
69 359442 : minGapLat(0.6),
70 359442 : maxSpeed(200. / 3.6),
71 359442 : desiredMaxSpeed(10000 / 3.6), // backward-compatibility: do not influence speeds by default
72 359442 : width(DEFAULT_VEH_WIDTH),
73 359442 : height(DEFAULT_VEH_HEIGHT),
74 359442 : shape(SUMOVehicleShape::UNKNOWN),
75 718884 : emissionClass(PollutantsInterface::getClassByName(EMPREFIX + "default", vclass)),
76 359442 : mass(DEFAULT_VEH_MASS),
77 359442 : speedFactor("normc", 1.0, 0.0, 0.2, 2.0),
78 359442 : personCapacity(4),
79 359442 : containerCapacity(0),
80 359442 : osgFile("car-normal-citrus.obj"),
81 359442 : carriageLength(-1),
82 359442 : locomotiveLength(-1),
83 359442 : carriageDoors(2),
84 359442 : carriageDoorWidth(1.5),
85 359442 : maxPlatformDistance(3.),
86 359442 : latAlignmentProcedure(LatAlignmentDefinition::CENTER) {
87 : // update default values
88 359442 : switch (vclass) {
89 97408 : case SVC_PEDESTRIAN:
90 97408 : minGap = 0.25;
91 97408 : maxSpeed = 37.58 / 3.6; // Usain Bolt
92 97408 : desiredMaxSpeed = DEFAULT_PEDESTRIAN_SPEED;
93 97408 : width = 0.478;
94 97408 : height = 1.719;
95 97408 : shape = SUMOVehicleShape::PEDESTRIAN;
96 : osgFile = "humanResting.obj";
97 194816 : emissionClass = PollutantsInterface::getClassByName(EMPREFIX + "zero", vclass);
98 97408 : mass = 70.; // https://en.wikipedia.org/wiki/Human_body_weight for Europe
99 97408 : speedFactor.setParameter(1, 0.1);
100 : break;
101 79 : case SVC_WHEELCHAIR:
102 79 : minGap = 0.5;
103 79 : maxSpeed = 30.0 / 3.6; // https://en.wikipedia.org/wiki/Wheelchair_racing
104 79 : desiredMaxSpeed = DEFAULT_PEDESTRIAN_SPEED;
105 79 : width = 0.8;
106 79 : height = 1.5;
107 79 : shape = SUMOVehicleShape::PEDESTRIAN;
108 : osgFile = "humanResting.obj";
109 158 : emissionClass = PollutantsInterface::getClassByName(EMPREFIX + "zero", vclass);
110 79 : mass = 90.; //
111 79 : speedFactor.setParameter(1, 0.1);
112 : break;
113 45521 : case SVC_BICYCLE:
114 45521 : minGap = 0.5;
115 45521 : minGapLat = 0.35;
116 45521 : maxSpeed = 50. / 3.6;
117 45521 : desiredMaxSpeed = DEFAULT_BICYCLE_SPEED;
118 45521 : width = 0.65;
119 45521 : height = 1.7;
120 45521 : shape = SUMOVehicleShape::BICYCLE;
121 45521 : personCapacity = 1;
122 91042 : emissionClass = PollutantsInterface::getClassByName(EMPREFIX + "zero", vclass);
123 45521 : mass = 10.;
124 45521 : speedFactor.setParameter(1, 0.1);
125 45521 : latAlignmentProcedure = LatAlignmentDefinition::RIGHT;
126 45521 : break;
127 24 : case SVC_SCOOTER:
128 24 : minGap = 0.5;
129 24 : minGapLat = 0.35;
130 24 : maxSpeed = 25 / 3.6;
131 24 : desiredMaxSpeed = DEFAULT_BICYCLE_SPEED;
132 24 : width = 0.5;
133 24 : height = 1.7;
134 24 : shape = SUMOVehicleShape::SCOOTER;
135 24 : personCapacity = 1;
136 48 : emissionClass = PollutantsInterface::getClassByName(EMPREFIX + "zero", vclass);
137 24 : mass = 10.;
138 24 : speedFactor.setParameter(1, 0.1);
139 24 : latAlignmentProcedure = LatAlignmentDefinition::RIGHT;
140 24 : break;
141 118 : case SVC_MOPED:
142 118 : maxSpeed = 60. / 3.6;
143 118 : width = 0.78;
144 118 : height = 1.7;
145 118 : shape = SUMOVehicleShape::MOPED;
146 118 : personCapacity = 1;
147 236 : emissionClass = PollutantsInterface::getClassByName(EMPREFIX + "Moped_le50cc_Euro-2", vclass);
148 118 : mass = 80.;
149 118 : speedFactor.setParameter(1, 0.1);
150 : break;
151 139 : case SVC_MOTORCYCLE:
152 139 : width = 0.9;
153 139 : height = 1.5;
154 139 : shape = SUMOVehicleShape::MOTORCYCLE;
155 139 : personCapacity = 1;
156 278 : emissionClass = PollutantsInterface::getClassByName(EMPREFIX + "MC_4S_gt250cc_preEuro", vclass);
157 139 : mass = 200.;
158 139 : speedFactor.setParameter(1, 0.1);
159 : break;
160 533 : case SVC_TRUCK:
161 533 : maxSpeed = 130. / 3.6;
162 533 : width = 2.4;
163 533 : height = 2.4;
164 533 : shape = SUMOVehicleShape::TRUCK;
165 : osgFile = "car-microcargo-citrus.obj";
166 533 : personCapacity = 2;
167 533 : containerCapacity = 1;
168 1066 : emissionClass = PollutantsInterface::getClassByName(EMPREFIX + "RT_le7.5t_Euro-VI_A-C", vclass);
169 533 : mass = 4500.;
170 533 : speedFactor.setParameter(1, 0.05);
171 : break;
172 70 : case SVC_TRAILER:
173 70 : maxSpeed = 130. / 3.6;
174 70 : width = 2.55;
175 70 : height = 4.;
176 70 : shape = SUMOVehicleShape::TRUCK_1TRAILER;
177 : osgFile = "car-microcargo-citrus.obj";
178 70 : personCapacity = 2;
179 70 : containerCapacity = 2;
180 140 : emissionClass = PollutantsInterface::getClassByName(EMPREFIX + "TT_AT_gt34-40t_Euro-VI_A-C", vclass);
181 70 : mass = 13000.;
182 70 : speedFactor.setParameter(1, 0.05);
183 : break;
184 1098 : case SVC_BUS:
185 1098 : maxSpeed = 100. / 3.6;
186 1098 : width = 2.5;
187 1098 : height = 3.4;
188 1098 : shape = SUMOVehicleShape::BUS;
189 : osgFile = "car-minibus-citrus.obj";
190 1098 : personCapacity = 85;
191 : // the following values keep better consistency with the default bus length,
192 : // although the most frequent city bus seems to have 3 axes and >18t according to the HBEFA4 data
193 2196 : emissionClass = PollutantsInterface::getClassByName(EMPREFIX + "UBus_Std_gt15-18t_Euro-VI_A-C", vclass);
194 1098 : mass = 12000.;
195 1098 : break;
196 40 : case SVC_COACH:
197 40 : maxSpeed = 100. / 3.6;
198 40 : width = 2.6;
199 40 : height = 4.;
200 40 : shape = SUMOVehicleShape::BUS_COACH;
201 : osgFile = "car-minibus-citrus.obj";
202 40 : personCapacity = 70;
203 80 : emissionClass = PollutantsInterface::getClassByName(EMPREFIX + "Coach_3-Axes_gt18t_Euro-VI_A-C", vclass);
204 40 : mass = 25000.;
205 40 : speedFactor.setParameter(1, 0.05);
206 : break;
207 202 : case SVC_TRAM:
208 202 : maxSpeed = 80. / 3.6;
209 202 : width = 2.4;
210 202 : height = 3.2;
211 202 : shape = SUMOVehicleShape::RAIL_CAR;
212 : osgFile = "tram.obj";
213 202 : personCapacity = 120;
214 404 : emissionClass = PollutantsInterface::getClassByName(EMPREFIX + "zero", vclass);
215 202 : mass = 37900.;
216 202 : break;
217 600 : case SVC_RAIL_URBAN:
218 : case SVC_SUBWAY:
219 600 : maxSpeed = 100. / 3.6;
220 600 : minGap = 5;
221 600 : width = 3.0;
222 600 : height = 3.6;
223 600 : shape = SUMOVehicleShape::RAIL_CAR;
224 600 : personCapacity = 300;
225 1200 : emissionClass = PollutantsInterface::getClassByName(EMPREFIX + "zero", vclass);
226 600 : mass = 59000.;
227 600 : break;
228 47118 : case SVC_RAIL:
229 47118 : maxSpeed = 160. / 3.6;
230 47118 : minGap = 5;
231 47118 : width = 2.84;
232 47118 : height = 3.75;
233 47118 : shape = SUMOVehicleShape::RAIL;
234 47118 : personCapacity = 434;
235 : // slight understatement (-:
236 47118 : emissionClass = PollutantsInterface::getClassByName("HBEFA3/HDV_D_EU0", vclass);
237 47118 : mass = 79500.; // only locomotive
238 47118 : break;
239 24 : case SVC_RAIL_ELECTRIC:
240 24 : maxSpeed = 220. / 3.6;
241 24 : minGap = 5;
242 24 : width = 2.95;
243 24 : height = 3.89;
244 24 : shape = SUMOVehicleShape::RAIL;
245 24 : personCapacity = 425;
246 48 : emissionClass = PollutantsInterface::getClassByName(EMPREFIX + "zero", vclass);
247 24 : mass = 83000.; // only locomotive
248 24 : break;
249 24 : case SVC_RAIL_FAST:
250 24 : maxSpeed = 330. / 3.6;
251 24 : minGap = 5;
252 24 : width = 2.95;
253 24 : height = 3.89;
254 24 : shape = SUMOVehicleShape::RAIL;
255 24 : personCapacity = 425;
256 48 : emissionClass = PollutantsInterface::getClassByName(EMPREFIX + "zero", vclass);
257 24 : mass = 409000.;
258 24 : break;
259 99 : case SVC_DELIVERY:
260 99 : width = 2.16;
261 99 : height = 2.86;
262 99 : shape = SUMOVehicleShape::DELIVERY;
263 99 : personCapacity = 2;
264 198 : emissionClass = PollutantsInterface::getClassByName(EMPREFIX + "LCV_diesel_N1-III_Euro-6ab", vclass);
265 99 : mass = 5000.;
266 99 : speedFactor.setParameter(1, 0.05);
267 : break;
268 255 : case SVC_EMERGENCY:
269 255 : width = 2.16;
270 255 : height = 2.86;
271 255 : shape = SUMOVehicleShape::DELIVERY;
272 255 : personCapacity = 2;
273 510 : emissionClass = PollutantsInterface::getClassByName(EMPREFIX + "LCV_diesel_N1-III_Euro-6ab", vclass);
274 255 : mass = 5000.;
275 255 : break;
276 73304 : case SVC_PRIVATE:
277 : case SVC_VIP:
278 : case SVC_PASSENGER:
279 : case SVC_HOV:
280 : case SVC_CUSTOM1:
281 : case SVC_CUSTOM2:
282 73304 : shape = SUMOVehicleShape::PASSENGER;
283 73304 : speedFactor.setParameter(1, 0.1);
284 : break;
285 45691 : case SVC_TAXI:
286 45691 : shape = SUMOVehicleShape::TAXI;
287 45691 : speedFactor.setParameter(1, 0.05);
288 : break;
289 24 : case SVC_E_VEHICLE:
290 24 : shape = SUMOVehicleShape::E_VEHICLE;
291 48 : emissionClass = PollutantsInterface::getClassByName(EMPREFIX + "zero", vclass);
292 24 : speedFactor.setParameter(1, 0.1);
293 : break;
294 40623 : case SVC_CONTAINER:
295 : // ISO Container TEU
296 40623 : width = 2.438;
297 40623 : height = 2.591;
298 40623 : break;
299 24 : case SVC_DRONE:
300 24 : width = 0.5;
301 24 : break;
302 24 : case SVC_AIRCRAFT:
303 : // Airbus A380
304 24 : shape = SUMOVehicleShape::AIRCRAFT;
305 24 : width = 79.8;
306 24 : break;
307 312 : case SVC_SHIP:
308 312 : width = 4;
309 312 : maxSpeed = 8 / 1.94; // 8 knots
310 312 : height = 4;
311 312 : shape = SUMOVehicleShape::SHIP;
312 : // slight understatement (-:
313 312 : emissionClass = PollutantsInterface::getClassByName("HBEFA3/HDV_D_EU0", vclass);
314 312 : mass = 100000.;
315 312 : speedFactor.setParameter(1, 0.1);
316 : break;
317 : default:
318 : break;
319 : }
320 359442 : }
321 :
322 :
323 0 : SUMOVTypeParameter::VClassDefaultValues::VClassDefaultValues() :
324 0 : speedFactor("normc", 1.0, 0.0, 0.2, 2.0) {}
325 :
326 333564 : SUMOVTypeParameter::SUMOVTypeParameter(const std::string& vtid, const SUMOVehicleClass vclass)
327 333564 : : id(vtid),
328 333564 : actionStepLength(0),
329 333564 : defaultProbability(DEFAULT_VEH_PROB),
330 333564 : speedFactor("normc", 1.0, 0.0, 0.2, 2.0),
331 667128 : emissionClass(PollutantsInterface::getClassByName(EMPREFIX + "default", vclass)),
332 333564 : color(RGBColor::DEFAULT_COLOR),
333 333564 : vehicleClass(vclass),
334 333564 : impatience(0.0),
335 333564 : personCapacity(4),
336 333564 : containerCapacity(0),
337 333564 : boardingDuration(500),
338 333564 : loadingDuration(90000),
339 333564 : scale(1),
340 333564 : width(1.8),
341 333564 : height(1.5),
342 333564 : shape(SUMOVehicleShape::UNKNOWN),
343 333564 : osgFile("car-normal-citrus.obj"),
344 333564 : cfModel(SUMO_TAG_CF_KRAUSS),
345 333564 : lcModel(LaneChangeModel::DEFAULT),
346 333564 : maxSpeedLat(1.0),
347 333564 : latAlignmentOffset(0.0),
348 333564 : latAlignmentProcedure(LatAlignmentDefinition::CENTER),
349 333564 : scaleVisual(1),
350 333564 : carriageLength(-1),
351 333564 : locomotiveLength(-1),
352 333564 : carriageGap(1.),
353 333564 : carriageDoors(2),
354 333564 : carriageDoorWidth(1.5),
355 333564 : maxPlatformDistance(3.),
356 333564 : timeToTeleport(TTT_UNSET),
357 333564 : timeToTeleportBidi(TTT_UNSET),
358 333564 : speedFactorPremature(-1),
359 333564 : frontSeatPos(1.7),
360 333564 : seatingWidth(-1),
361 333564 : boardingFactor(1),
362 333564 : parametersSet(0),
363 333564 : saved(false),
364 333564 : onlyReferenced(false) {
365 333564 : const OptionsCont& oc = OptionsCont::getOptions();
366 667128 : if (oc.exists("carfollow.model")) {
367 : // check for valid value has been performed in MSFrame
368 620110 : cfModel = SUMOXMLDefinitions::CarFollowModels.get(oc.getString("carfollow.model"));
369 : }
370 : // obtain default values depending of vclass
371 333564 : VClassDefaultValues defaultValues(vclass);
372 : // overwrite SUMOVTypeParameter with VClassDefaultValues
373 333564 : length = defaultValues.length;
374 333564 : minGap = defaultValues.minGap;
375 333564 : minGapLat = defaultValues.minGapLat;
376 333564 : maxSpeed = defaultValues.maxSpeed;
377 333564 : desiredMaxSpeed = defaultValues.desiredMaxSpeed;
378 333564 : width = defaultValues.width;
379 333564 : height = defaultValues.height;
380 333564 : shape = defaultValues.shape;
381 333564 : emissionClass = defaultValues.emissionClass;
382 333564 : mass = defaultValues.mass;
383 : speedFactor = defaultValues.speedFactor;
384 333564 : personCapacity = defaultValues.personCapacity;
385 333564 : containerCapacity = defaultValues.containerCapacity;
386 : osgFile = defaultValues.osgFile;
387 333564 : carriageLength = defaultValues.carriageLength;
388 333564 : locomotiveLength = defaultValues.locomotiveLength;
389 333564 : carriageDoors = defaultValues.carriageDoors;
390 333564 : latAlignmentProcedure = defaultValues.latAlignmentProcedure;
391 : // check if default speeddev was defined
392 667128 : if (oc.exists("default.speeddev")) {
393 310055 : const double defaultSpeedDev = oc.getFloat("default.speeddev");
394 310055 : if (defaultSpeedDev >= 0) {
395 214138 : speedFactor.setParameter(1, defaultSpeedDev);
396 : }
397 : } else {
398 23509 : speedFactor.setParameter(1, -1.);
399 : }
400 333564 : setManoeuverAngleTimes(vclass);
401 333564 : }
402 :
403 : void
404 333564 : SUMOVTypeParameter::setManoeuverAngleTimes(const SUMOVehicleClass vclass) {
405 :
406 : myManoeuverAngleTimes.clear();
407 : /**
408 : * Defaults assume: approaching at angles between 0-10 and 171-180 (will never be > 180) are approaching a space roughly parallel to the road
409 : * approaching at angles between 11-80 are approaching an acute angled space that is easiest to drive straight in
410 : * approaching at angles between 81-110 are approaching a space at approximately right angles to the road so the driver has a choice
411 : * approaching at angles between 111 and 170 are approaching an obtuse angled space that is easiest to drive past and reverse in
412 : * More (or less) granular angle ranges can be used - configurable as a vType parameter
413 : */
414 333564 : switch (vclass) {
415 118708 : case SVC_PASSENGER:
416 : case SVC_HOV:
417 : case SVC_TAXI:
418 : case SVC_E_VEHICLE:
419 118708 : myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(10, std::pair< SUMOTime, SUMOTime>(3000, 4000))); // straight in but potentially needing parallel parking
420 118708 : myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(80, std::pair< SUMOTime, SUMOTime>(1000, 11000))); // straight in
421 118708 : myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(110, std::pair< SUMOTime, SUMOTime>(11000, 2000))); // optional forwards/backwards
422 118708 : myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(170, std::pair< SUMOTime, SUMOTime>(8000, 3000))); // backwards into obtuse space
423 118708 : myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(181, std::pair< SUMOTime, SUMOTime>(3000, 4000))); // straight in but potentially needing parallel parking
424 118708 : break;
425 1840 : case SVC_TRUCK:
426 : case SVC_TRAILER:
427 : case SVC_BUS:
428 : case SVC_COACH:
429 : case SVC_DELIVERY:
430 1840 : myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(10, std::pair< SUMOTime, SUMOTime>(6000, 8000))); // straight in but potentially needing parallel parking
431 1840 : myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(80, std::pair< SUMOTime, SUMOTime>(2000, 21000))); // straight in
432 1840 : myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(110, std::pair< SUMOTime, SUMOTime>(21000, 2000))); // optional forwards/backwards
433 1840 : myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(170, std::pair< SUMOTime, SUMOTime>(14000, 5000))); // backwards into obtuse space
434 1840 : myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(181, std::pair< SUMOTime, SUMOTime>(6000, 8000))); // straight in but potentially needing parallel parking
435 1840 : break;
436 117169 : case SVC_PEDESTRIAN:
437 : case SVC_MOPED:
438 : case SVC_BICYCLE:
439 117169 : myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(181, std::pair< SUMOTime, SUMOTime>(1000, 1000))); // no dependence on angle
440 117169 : break;
441 95847 : default:
442 95847 : myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(10, std::pair< SUMOTime, SUMOTime>(3000, 4000))); // straight in but potentially needing parallel parking
443 95847 : myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(80, std::pair< SUMOTime, SUMOTime>(1000, 11000))); // straight in
444 95847 : myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(110, std::pair< SUMOTime, SUMOTime>(11000, 2000))); // optional forwards/backwards
445 95847 : myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(170, std::pair< SUMOTime, SUMOTime>(8000, 3000))); // backwards into obtuse space
446 95847 : myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(181, std::pair< SUMOTime, SUMOTime>(3000, 4000))); // straight in but potentially needing parallel parking
447 95847 : break;
448 : }
449 333564 : }
450 :
451 : void
452 6740 : SUMOVTypeParameter::write(OutputDevice& dev) const {
453 : // first check if vehicle type can be written
454 6740 : if (onlyReferenced) {
455 : return;
456 : }
457 : // open vehicle tag
458 3161 : dev.openTag(SUMO_TAG_VTYPE);
459 : // write ID (always needed)
460 3161 : dev.writeAttr(SUMO_ATTR_ID, id);
461 : // write parameters depending if is set
462 3161 : if (wasSet(VTYPEPARS_LENGTH_SET)) {
463 829 : dev.writeAttr(SUMO_ATTR_LENGTH, length);
464 : }
465 3161 : if (wasSet(VTYPEPARS_MINGAP_SET)) {
466 705 : dev.writeAttr(SUMO_ATTR_MINGAP, minGap);
467 : }
468 3161 : if (wasSet(VTYPEPARS_MAXSPEED_SET)) {
469 763 : dev.writeAttr(SUMO_ATTR_MAXSPEED, maxSpeed);
470 : }
471 3161 : if (wasSet(VTYPEPARS_DESIRED_MAXSPEED_SET)) {
472 0 : dev.writeAttr(SUMO_ATTR_DESIRED_MAXSPEED, desiredMaxSpeed);
473 : }
474 3161 : if (wasSet(VTYPEPARS_PROBABILITY_SET)) {
475 92 : dev.writeAttr(SUMO_ATTR_PROB, defaultProbability);
476 : }
477 3161 : if (wasSet(VTYPEPARS_SPEEDFACTOR_SET)) {
478 462 : dev.writeAttr(SUMO_ATTR_SPEEDFACTOR, speedFactor);
479 : }
480 3161 : if (wasSet(VTYPEPARS_ACTIONSTEPLENGTH_SET)) {
481 : // Note: action step length is only exposed in seconds to the user
482 114 : dev.writeAttr(SUMO_ATTR_ACTIONSTEPLENGTH, STEPS2TIME(actionStepLength));
483 : }
484 3161 : if (wasSet(VTYPEPARS_VEHICLECLASS_SET)) {
485 1406 : dev.writeAttr(SUMO_ATTR_VCLASS, toString(vehicleClass));
486 : }
487 3161 : if (wasSet(VTYPEPARS_EMISSIONCLASS_SET)) {
488 116 : dev.writeAttr(SUMO_ATTR_EMISSIONCLASS, PollutantsInterface::getName(emissionClass));
489 : }
490 3161 : if (wasSet(VTYPEPARS_MASS_SET)) {
491 10 : dev.writeAttr(SUMO_ATTR_MASS, mass);
492 : }
493 3161 : if (wasSet(VTYPEPARS_IMPATIENCE_SET)) {
494 37 : if (impatience == -std::numeric_limits<double>::max()) {
495 0 : dev.writeAttr(SUMO_ATTR_IMPATIENCE, "off");
496 : } else {
497 37 : dev.writeAttr(SUMO_ATTR_IMPATIENCE, impatience);
498 : }
499 : }
500 3161 : if (wasSet(VTYPEPARS_SHAPE_SET)) {
501 102 : dev.writeAttr(SUMO_ATTR_GUISHAPE, getVehicleShapeName(shape));
502 : }
503 3161 : if (wasSet(VTYPEPARS_WIDTH_SET)) {
504 40 : dev.writeAttr(SUMO_ATTR_WIDTH, width);
505 : }
506 3161 : if (wasSet(VTYPEPARS_HEIGHT_SET)) {
507 0 : dev.writeAttr(SUMO_ATTR_HEIGHT, height);
508 : }
509 3161 : if (wasSet(VTYPEPARS_COLOR_SET)) {
510 426 : dev.writeAttr(SUMO_ATTR_COLOR, color);
511 : }
512 3161 : if (wasSet(VTYPEPARS_OSGFILE_SET)) {
513 0 : dev.writeAttr(SUMO_ATTR_OSGFILE, osgFile);
514 : }
515 3161 : if (wasSet(VTYPEPARS_IMGFILE_SET)) {
516 0 : dev.writeAttr(SUMO_ATTR_IMGFILE, imgFile);
517 : }
518 3161 : if (wasSet(VTYPEPARS_PERSON_CAPACITY)) {
519 0 : dev.writeAttr(SUMO_ATTR_PERSON_CAPACITY, personCapacity);
520 : }
521 3161 : if (wasSet(VTYPEPARS_CONTAINER_CAPACITY)) {
522 0 : dev.writeAttr(SUMO_ATTR_CONTAINER_CAPACITY, containerCapacity);
523 : }
524 3161 : if (wasSet(VTYPEPARS_BOARDING_DURATION)) {
525 16 : dev.writeAttr(SUMO_ATTR_BOARDING_DURATION, time2string(boardingDuration));
526 : }
527 3161 : if (wasSet(VTYPEPARS_LOADING_DURATION)) {
528 16 : dev.writeAttr(SUMO_ATTR_LOADING_DURATION, time2string(loadingDuration));
529 : }
530 3161 : if (wasSet(VTYPEPARS_MAXSPEED_LAT_SET)) {
531 8 : dev.writeAttr(SUMO_ATTR_MAXSPEED_LAT, maxSpeedLat);
532 : }
533 3161 : if (wasSet(VTYPEPARS_LATALIGNMENT_SET)) {
534 8 : switch (latAlignmentProcedure) {
535 0 : case LatAlignmentDefinition::GIVEN:
536 0 : dev.writeAttr(SUMO_ATTR_LATALIGNMENT, latAlignmentOffset);
537 0 : break;
538 0 : case LatAlignmentDefinition::RIGHT:
539 0 : dev.writeAttr(SUMO_ATTR_LATALIGNMENT, "right");
540 0 : break;
541 0 : case LatAlignmentDefinition::CENTER:
542 0 : dev.writeAttr(SUMO_ATTR_LATALIGNMENT, "center");
543 0 : break;
544 0 : case LatAlignmentDefinition::ARBITRARY:
545 0 : dev.writeAttr(SUMO_ATTR_LATALIGNMENT, "arbitrary");
546 0 : break;
547 0 : case LatAlignmentDefinition::NICE:
548 0 : dev.writeAttr(SUMO_ATTR_LATALIGNMENT, "nice");
549 0 : break;
550 8 : case LatAlignmentDefinition::COMPACT:
551 8 : dev.writeAttr(SUMO_ATTR_LATALIGNMENT, "compact");
552 8 : break;
553 0 : case LatAlignmentDefinition::LEFT:
554 0 : dev.writeAttr(SUMO_ATTR_LATALIGNMENT, "left");
555 0 : break;
556 : case LatAlignmentDefinition::DEFAULT:
557 : default:
558 : break;
559 : }
560 : }
561 3161 : if (wasSet(VTYPEPARS_MINGAP_LAT_SET)) {
562 8 : dev.writeAttr(SUMO_ATTR_MINGAP_LAT, minGapLat);
563 : }
564 3161 : if (wasSet(VTYPEPARS_MANEUVER_ANGLE_TIMES_SET)) {
565 0 : dev.writeAttr(SUMO_ATTR_MANEUVER_ANGLE_TIMES, getManoeuverAngleTimesS());
566 : }
567 3161 : if (wasSet(VTYPEPARS_SCALE_SET)) {
568 0 : dev.writeAttr(SUMO_ATTR_SCALE, scale);
569 : }
570 3161 : if (wasSet(VTYPEPARS_TTT_SET)) {
571 16 : dev.writeAttr(SUMO_ATTR_TIME_TO_TELEPORT, time2string(timeToTeleport));
572 : }
573 3161 : if (wasSet(VTYPEPARS_TTT_BIDI_SET)) {
574 0 : dev.writeAttr(SUMO_ATTR_TIME_TO_TELEPORT_BIDI, time2string(timeToTeleportBidi));
575 : }
576 3161 : if (wasSet(VTYPEPARS_SPEEDFACTOR_PREMATURE_SET)) {
577 0 : dev.writeAttr(SUMO_ATTR_SPEEDFACTOR_PREMATURE, speedFactorPremature);
578 : }
579 3161 : if (wasSet(VTYPEPARS_BOARDING_FACTOR_SET)) {
580 0 : dev.writeAttr(SUMO_ATTR_BOARDING_FACTOR, boardingFactor);
581 : }
582 3161 : if (wasSet(VTYPEPARS_LANE_CHANGE_MODEL_SET)) {
583 0 : dev.writeAttr(SUMO_ATTR_LANE_CHANGE_MODEL, lcModel);
584 : }
585 : // Write Lane Change Model parameters
586 3161 : for (const auto& lcParam : lcParameter) {
587 0 : dev.writeAttr(lcParam.first, lcParam.second);
588 : }
589 : // Write Junction Model parameter
590 3161 : for (const auto& jmParam : jmParameter) {
591 0 : dev.writeAttr(jmParam.first, jmParam.second);
592 : }
593 3161 : if (wasSet(VTYPEPARS_CAR_FOLLOW_MODEL)) {
594 52 : dev.writeAttr(SUMO_ATTR_CAR_FOLLOW_MODEL, SUMOXMLDefinitions::CarFollowModels.getString(cfModel));
595 : }
596 : // Write Car Following Model parameters
597 6577 : for (const auto& cfParam : cfParameter) {
598 3416 : dev.writeAttr(cfParam.first, cfParam.second);
599 : }
600 : // Write carriage length
601 3161 : if (wasSet(VTYPEPARS_CARRIAGE_LENGTH_SET)) {
602 0 : dev.openTag(SUMO_TAG_PARAM);
603 0 : dev.writeAttr(SUMO_ATTR_KEY, toString(SUMO_ATTR_CARRIAGE_LENGTH));
604 0 : dev.writeAttr(SUMO_ATTR_VALUE, toString(carriageLength));
605 0 : dev.closeTag();
606 : }
607 : // Write locomotive length
608 3161 : if (wasSet(VTYPEPARS_LOCOMOTIVE_LENGTH_SET)) {
609 0 : dev.openTag(SUMO_TAG_PARAM);
610 0 : dev.writeAttr(SUMO_ATTR_KEY, toString(SUMO_ATTR_LOCOMOTIVE_LENGTH));
611 0 : dev.writeAttr(SUMO_ATTR_VALUE, toString(locomotiveLength));
612 0 : dev.closeTag();
613 : }
614 : // Write carriage gap
615 3161 : if (wasSet(VTYPEPARS_CARRIAGE_GAP_SET)) {
616 0 : dev.openTag(SUMO_TAG_PARAM);
617 0 : dev.writeAttr(SUMO_ATTR_KEY, toString(SUMO_ATTR_CARRIAGE_GAP));
618 0 : dev.writeAttr(SUMO_ATTR_VALUE, toString(carriageGap));
619 0 : dev.closeTag();
620 : }
621 : // Write carriage doors
622 3161 : if (wasSet(VTYPEPARS_CARRIAGE_DOORS_SET)) {
623 0 : dev.openTag(SUMO_TAG_PARAM);
624 0 : dev.writeAttr(SUMO_ATTR_KEY, toString(SUMO_ATTR_CARRIAGE_DOORS));
625 0 : dev.writeAttr(SUMO_ATTR_VALUE, toString(carriageDoors));
626 0 : dev.closeTag();
627 : }
628 : // Write rest of parameters
629 3161 : writeParams(dev);
630 : // close tag
631 6322 : dev.closeTag();
632 : }
633 :
634 :
635 : double
636 4296463 : SUMOVTypeParameter::getCFParam(const SumoXMLAttr attr, const double defaultValue) const {
637 : if (cfParameter.count(attr)) {
638 53905 : return StringUtils::toDouble(cfParameter.find(attr)->second);
639 : } else {
640 : return defaultValue;
641 : }
642 : }
643 :
644 :
645 : std::string
646 422 : SUMOVTypeParameter::getCFParamString(const SumoXMLAttr attr, const std::string defaultValue) const {
647 : if (cfParameter.count(attr)) {
648 : return cfParameter.find(attr)->second;
649 : } else {
650 : return defaultValue;
651 : }
652 : }
653 :
654 :
655 : std::vector<double>
656 56 : SUMOVTypeParameter::getCFValueTable(SumoXMLAttr attr) const {
657 : std::vector<double> result;
658 112 : const std::string values = getCFParamString(attr, "");
659 56 : if (!values.empty()) {
660 576 : for (std::string value : StringTokenizer(values).getVector()) {
661 464 : result.push_back(StringUtils::toDouble(value));
662 56 : }
663 : }
664 56 : return result;
665 0 : }
666 :
667 :
668 :
669 : LinearApproxHelpers::LinearApproxMap
670 612876 : SUMOVTypeParameter::getCFProfile(const SumoXMLAttr attr, const LinearApproxHelpers::LinearApproxMap& defaultProfile) const {
671 : if (cfParameter.count(attr)) {
672 28 : std::vector<double> speedTable = getCFValueTable(SUMO_ATTR_SPEED_TABLE);
673 28 : std::vector<double> valueTable = getCFValueTable(attr);
674 28 : if (valueTable.size() == 1) {
675 0 : throw ProcessError(TLF("Invalid size of % table for vType '%' (at least 2 values are required).", toString(attr), id));
676 28 : } else if (speedTable.size() != valueTable.size()) {
677 0 : throw ProcessError(TLF("Mismatching size of speedTable (%) and % table (%) for vType '%'.", speedTable.size(), toString(attr), valueTable.size(), id));
678 : }
679 : LinearApproxHelpers::LinearApproxMap result;
680 260 : for (int i = 0; i < (int)speedTable.size(); i++) {
681 232 : result[speedTable[i]] = valueTable[i];
682 : }
683 : return result;
684 28 : } else {
685 : return defaultProfile;
686 : }
687 : }
688 :
689 :
690 : double
691 115943889 : SUMOVTypeParameter::getLCParam(const SumoXMLAttr attr, const double defaultValue) const {
692 : if (lcParameter.count(attr)) {
693 360255 : return StringUtils::toDouble(lcParameter.find(attr)->second);
694 : } else {
695 : return defaultValue;
696 : }
697 : }
698 :
699 :
700 : std::string
701 101437 : SUMOVTypeParameter::getLCParamString(const SumoXMLAttr attr, const std::string& defaultValue) const {
702 : if (lcParameter.count(attr)) {
703 : return lcParameter.find(attr)->second;
704 : } else {
705 : return defaultValue;
706 : }
707 : }
708 :
709 :
710 : const SUMOVTypeParameter::SubParams&
711 121957 : SUMOVTypeParameter::getLCParams() const {
712 121957 : return lcParameter;
713 : }
714 :
715 :
716 : double
717 3029511378 : SUMOVTypeParameter::getJMParam(const SumoXMLAttr attr, const double defaultValue) const {
718 : if (jmParameter.count(attr)) {
719 18532091 : return StringUtils::toDouble(jmParameter.find(attr)->second);
720 : } else {
721 : return defaultValue;
722 : }
723 : }
724 :
725 :
726 : std::string
727 0 : SUMOVTypeParameter::getJMParamString(const SumoXMLAttr attr, const std::string defaultValue) const {
728 : if (jmParameter.count(attr)) {
729 : return jmParameter.find(attr)->second;
730 : } else {
731 : return defaultValue;
732 : }
733 : }
734 :
735 : SUMOTime
736 30 : SUMOVTypeParameter::getEntryManoeuvreTime(const int angle) const {
737 : SUMOTime last = 0;
738 90 : for (std::pair<int, std::pair<SUMOTime, SUMOTime>> angleTime : myManoeuverAngleTimes) {
739 90 : if (angle <= angleTime.first) {
740 : return (angleTime.second.first);
741 : } else {
742 : last = angleTime.second.first;
743 : }
744 : }
745 0 : return (last);
746 : }
747 :
748 : SUMOTime
749 30 : SUMOVTypeParameter::getExitManoeuvreTime(const int angle) const {
750 : SUMOTime last = 0;
751 90 : for (std::pair<int, std::pair<SUMOTime, SUMOTime>> angleTime : myManoeuverAngleTimes) {
752 90 : if (angle <= angleTime.first) {
753 : return (angleTime.second.second);
754 : } else {
755 : last = angleTime.second.second;
756 : }
757 : }
758 0 : return (last);
759 : }
760 :
761 : std::string
762 0 : SUMOVTypeParameter::getManoeuverAngleTimesS() const {
763 0 : std::stringstream stream;
764 :
765 : stream << std::fixed << std::setprecision(1);
766 : int count = 0;
767 0 : for (std::pair<int, std::pair<SUMOTime, SUMOTime>> angleTime : myManoeuverAngleTimes) {
768 0 : if (count++ > 0) {
769 0 : stream << ",";
770 : }
771 0 : stream << toString(angleTime.first) + " " << STEPS2TIME(angleTime.second.first) << " " << STEPS2TIME(angleTime.second.second);
772 : }
773 : std::string triplets = stream.str();
774 0 : return triplets;
775 0 : }
776 :
777 :
778 : void
779 24 : SUMOVTypeParameter::cacheParamRestrictions(const std::vector<std::string>& restrictionKeys) {
780 48 : for (const std::string& key : restrictionKeys) {
781 48 : paramRestrictions.push_back(StringUtils::toDouble(getParameter(key, "0")));
782 : }
783 24 : }
784 :
785 :
786 : void
787 304136 : SUMOVTypeParameter::initRailVisualizationParameters(const std::string fileName) {
788 608272 : if (hasParameter("scaleVisual")) {
789 0 : scaleVisual = StringUtils::toDouble(getParameter("scaleVisual"));
790 : }
791 608272 : if (hasParameter("carriageLength")) {
792 134 : carriageLength = StringUtils::toDouble(getParameter("carriageLength"));
793 67 : parametersSet |= VTYPEPARS_CARRIAGE_LENGTH_SET;
794 : } else {
795 304069 : switch (shape) {
796 6 : case SUMOVehicleShape::BUS_FLEXIBLE:
797 6 : carriageLength = 8.25; // 16.5 overall, 2 modules http://de.wikipedia.org/wiki/Ikarus_180
798 6 : carriageGap = 0;
799 6 : break;
800 42685 : case SUMOVehicleShape::RAIL:
801 42685 : if (vehicleClass == SVC_RAIL_ELECTRIC) {
802 24 : carriageLength = 24.5;
803 24 : locomotiveLength = 19.100; // https://en.wikipedia.org/wiki/DB_Class_101
804 42661 : } else if (vehicleClass == SVC_RAIL_FAST) {
805 24 : carriageLength = 24.775; // http://de.wikipedia.org/wiki/ICE_3
806 24 : locomotiveLength = 25.835;
807 : } else {
808 42637 : carriageLength = 24.5; // http://de.wikipedia.org/wiki/UIC-Y-Wagen_%28DR%29
809 42637 : locomotiveLength = 16.4; // https://en.wikipedia.org/wiki/DB_Class_218
810 : }
811 : break;
812 567 : case SUMOVehicleShape::RAIL_CAR:
813 567 : if (vehicleClass == SVC_TRAM) {
814 142 : carriageLength = 5.71; // http://de.wikipedia.org/wiki/Bombardier_Flexity_Berlin
815 142 : locomotiveLength = 5.71;
816 425 : } else if (vehicleClass == SVC_RAIL_URBAN) {
817 373 : carriageLength = 18.4; // https://en.wikipedia.org/wiki/DBAG_Class_481
818 373 : locomotiveLength = 18.4;
819 : } else {
820 52 : carriageLength = 16.85; // 67.4m overall, 4 carriages http://de.wikipedia.org/wiki/DB-Baureihe_423
821 : }
822 : break;
823 8 : case SUMOVehicleShape::RAIL_CARGO:
824 8 : carriageLength = 13.86; // UIC 571-1 http://de.wikipedia.org/wiki/Flachwagen
825 8 : break;
826 7 : case SUMOVehicleShape::TRUCK_SEMITRAILER:
827 7 : carriageLength = 13.5;
828 7 : locomotiveLength = 2.5;
829 7 : carriageGap = 0.5;
830 7 : break;
831 93 : case SUMOVehicleShape::TRUCK_1TRAILER:
832 93 : carriageLength = 6.75;
833 93 : locomotiveLength = 2.5 + 6.75;
834 93 : carriageGap = 0.5;
835 93 : break;
836 : default:
837 : break;
838 : }
839 : }
840 608272 : if (hasParameter("locomotiveLength")) {
841 62 : locomotiveLength = StringUtils::toDouble(getParameter("locomotiveLength"));
842 31 : parametersSet |= VTYPEPARS_LOCOMOTIVE_LENGTH_SET;
843 304105 : } else if (locomotiveLength < 0) {
844 260805 : locomotiveLength = carriageLength;
845 : }
846 608272 : if (hasParameter("carriageGap")) {
847 12 : carriageGap = StringUtils::toDouble(getParameter("carriageGap"));
848 6 : parametersSet |= VTYPEPARS_CARRIAGE_GAP_SET;
849 : }
850 608272 : if (hasParameter("carriageDoors")) {
851 24 : carriageDoors = StringUtils::toInt(getParameter("carriageDoors"));
852 12 : parametersSet |= VTYPEPARS_CARRIAGE_DOORS_SET;
853 : }
854 608272 : if (hasParameter("carriageDoorWidth")) {
855 0 : carriageDoorWidth = StringUtils::toDouble(getParameter("carriageDoorWidth"));
856 : }
857 608272 : if (hasParameter("maxPlatformDistance")) {
858 0 : maxPlatformDistance = StringUtils::toDouble(getParameter("maxPlatformDistance"));
859 : }
860 608272 : if (hasParameter("frontSeatPos")) {
861 30 : frontSeatPos = StringUtils::toDouble(getParameter("frontSeatPos"));
862 15 : parametersSet |= VTYPEPARS_FRONT_SEAT_POS_SET;
863 : } else {
864 304121 : switch (shape) {
865 225 : case SUMOVehicleShape::SHIP:
866 225 : frontSeatPos = 5;
867 225 : break;
868 217 : case SUMOVehicleShape::DELIVERY:
869 217 : frontSeatPos = 1.2;
870 217 : break;
871 41277 : case SUMOVehicleShape::BICYCLE:
872 41277 : frontSeatPos = 0.6;
873 41277 : break;
874 262 : case SUMOVehicleShape::MOPED:
875 : case SUMOVehicleShape::MOTORCYCLE:
876 262 : frontSeatPos = 0.9;
877 262 : break;
878 1013 : case SUMOVehicleShape::BUS:
879 : case SUMOVehicleShape::BUS_COACH:
880 : case SUMOVehicleShape::BUS_FLEXIBLE:
881 : case SUMOVehicleShape::BUS_TROLLEY:
882 1013 : frontSeatPos = 0.5;
883 1013 : break;
884 657 : case SUMOVehicleShape::TRUCK:
885 : case SUMOVehicleShape::TRUCK_1TRAILER:
886 : case SUMOVehicleShape::TRUCK_SEMITRAILER:
887 657 : frontSeatPos = 0.8;
888 657 : break;
889 : default:
890 : break;
891 : }
892 : }
893 :
894 608272 : if (hasParameter("seatingWidth")) {
895 14 : seatingWidth = StringUtils::toDouble(getParameter("seatingWidth"));
896 7 : parametersSet |= VTYPEPARS_SEATING_WIDTH_SET;
897 : }
898 608272 : if (hasParameter("carriageImages")) {
899 12 : std::vector<std::string> rawFiles = StringTokenizer(getParameter("carriageImages"), ",").getVector();
900 36 : for (const std::string& f : rawFiles) {
901 60 : carriageImages.push_back(FileHelpers::checkForRelativity(f, fileName));
902 : }
903 6 : }
904 304136 : }
905 :
906 :
907 : double
908 306170 : SUMOVTypeParameter::getDefaultAccel(const SUMOVehicleClass vc) {
909 306170 : switch (vc) {
910 : case SVC_PEDESTRIAN:
911 : case SVC_WHEELCHAIR:
912 : return 1.5;
913 : case SVC_BICYCLE:
914 : case SVC_SCOOTER:
915 : return 1.2;
916 139 : case SVC_MOTORCYCLE:
917 139 : return 6.;
918 : case SVC_MOPED:
919 : return 1.1;
920 532 : case SVC_TRUCK:
921 532 : return 1.3;
922 : case SVC_TRAILER:
923 : return 1.1;
924 : case SVC_BUS:
925 : return 1.2;
926 40 : case SVC_COACH:
927 40 : return 2.;
928 : case SVC_TRAM:
929 : return 1.;
930 : case SVC_RAIL_URBAN:
931 : return 1.;
932 42798 : case SVC_RAIL:
933 42798 : return 0.25;
934 48 : case SVC_RAIL_ELECTRIC:
935 : case SVC_RAIL_FAST:
936 48 : return 0.5;
937 225 : case SVC_SHIP:
938 225 : return 0.1;
939 151990 : default:
940 151990 : return 2.6;//2.9;
941 : }
942 : }
943 :
944 :
945 : double
946 693191 : SUMOVTypeParameter::getDefaultDecel(const SUMOVehicleClass vc) {
947 693191 : switch (vc) {
948 : case SVC_PEDESTRIAN:
949 : case SVC_WHEELCHAIR:
950 : return 2.;
951 : case SVC_BICYCLE:
952 : case SVC_SCOOTER:
953 : return 3.;
954 236 : case SVC_MOPED:
955 236 : return 7.;
956 278 : case SVC_MOTORCYCLE:
957 278 : return 10.;
958 3029 : case SVC_TRUCK:
959 : case SVC_TRAILER:
960 : case SVC_BUS:
961 : case SVC_COACH:
962 3029 : return 4.;
963 : case SVC_TRAM:
964 : case SVC_RAIL_URBAN:
965 : return 3.;
966 125994 : case SVC_RAIL:
967 : case SVC_RAIL_ELECTRIC:
968 : case SVC_RAIL_FAST:
969 125994 : return 1.3;
970 450 : case SVC_SHIP:
971 450 : return 0.15;
972 344823 : default:
973 344823 : return 4.5;//7.5;
974 : }
975 : }
976 :
977 :
978 : double
979 610220 : SUMOVTypeParameter::getDefaultEmergencyDecel(const SUMOVehicleClass vc, double decel, double defaultOption) {
980 610220 : if (defaultOption == VTYPEPARS_DEFAULT_EMERGENCYDECEL_DEFAULT) {
981 : double vcDecel;
982 604732 : switch (vc) {
983 : case SVC_PEDESTRIAN:
984 : case SVC_WHEELCHAIR:
985 : vcDecel = 5.;
986 : break;
987 : case SVC_BICYCLE:
988 : case SVC_SCOOTER:
989 : vcDecel = 7.;
990 : break;
991 514 : case SVC_MOPED:
992 : case SVC_MOTORCYCLE:
993 : vcDecel = 10.;
994 514 : break;
995 : case SVC_TRUCK:
996 : case SVC_TRAILER:
997 : case SVC_BUS:
998 : case SVC_COACH:
999 : case SVC_TRAM:
1000 : case SVC_RAIL_URBAN:
1001 : vcDecel = 7.;
1002 : break;
1003 : case SVC_RAIL:
1004 : case SVC_RAIL_ELECTRIC:
1005 : case SVC_RAIL_FAST:
1006 : vcDecel = 5.;
1007 : break;
1008 450 : case SVC_SHIP:
1009 : vcDecel = 1.;
1010 450 : break;
1011 299024 : default:
1012 : vcDecel = 9.;
1013 : }
1014 : return MAX2(decel, vcDecel);
1015 5488 : } else if (defaultOption == VTYPEPARS_DEFAULT_EMERGENCYDECEL_DECEL) {
1016 : return decel;
1017 : } else {
1018 : // value already checked in MSFrame::checkOptions
1019 : return MAX2(decel, defaultOption);
1020 : }
1021 : }
1022 :
1023 :
1024 :
1025 : double
1026 295202 : SUMOVTypeParameter::getDefaultImperfection(const SUMOVehicleClass vc) {
1027 295202 : switch (vc) {
1028 : case SVC_TRAM:
1029 : case SVC_RAIL_URBAN:
1030 : case SVC_RAIL:
1031 : case SVC_RAIL_ELECTRIC:
1032 : case SVC_RAIL_FAST:
1033 : case SVC_SHIP:
1034 : return 0.;
1035 253244 : default:
1036 253244 : return 0.5;
1037 : }
1038 : }
1039 :
1040 : const SUMOVTypeParameter&
1041 16927460 : SUMOVTypeParameter::getDefault() {
1042 16933349 : static SUMOVTypeParameter defaultParams("");
1043 16927460 : return defaultParams;
1044 : }
1045 :
1046 : bool
1047 1729 : SUMOVTypeParameter::parseLatAlignment(const std::string& val, double& lao, LatAlignmentDefinition& lad) {
1048 : bool ok = true;
1049 1729 : lao = 0.0;
1050 1729 : lad = LatAlignmentDefinition::GIVEN;
1051 1729 : if (val == "right") {
1052 315 : lad = LatAlignmentDefinition::RIGHT;
1053 1414 : } else if (val == "center") {
1054 677 : lad = LatAlignmentDefinition::CENTER;
1055 737 : } else if (val == "arbitrary") {
1056 347 : lad = LatAlignmentDefinition::ARBITRARY;
1057 390 : } else if (val == "nice") {
1058 46 : lad = LatAlignmentDefinition::NICE;
1059 344 : } else if (val == "compact") {
1060 244 : lad = LatAlignmentDefinition::COMPACT;
1061 100 : } else if (val == "left") {
1062 86 : lad = LatAlignmentDefinition::LEFT;
1063 : } else {
1064 : try {
1065 14 : lao = StringUtils::toDouble(val);
1066 0 : } catch (...) {
1067 : ok = false;
1068 0 : }
1069 : }
1070 1729 : return ok;
1071 : }
1072 :
1073 :
1074 : SUMOTime
1075 80975756 : SUMOVTypeParameter::getTimeToTeleport(SUMOTime defaultValue) const {
1076 80975756 : return timeToTeleport == TTT_UNSET ? defaultValue : timeToTeleport;
1077 : }
1078 :
1079 : SUMOTime
1080 80975756 : SUMOVTypeParameter::getTimeToTeleportBidi(SUMOTime defaultValue) const {
1081 80975756 : return timeToTeleportBidi == TTT_UNSET ? defaultValue : timeToTeleportBidi;
1082 : }
1083 :
1084 : LinearApproxHelpers::LinearApproxMap
1085 306080 : SUMOVTypeParameter::getDefaultMaxAccelProfile(const SUMOVehicleClass vc, double maxAccel) {
1086 : UNUSED_PARAMETER(maxAccel);
1087 : LinearApproxHelpers::LinearApproxMap result;
1088 : std::vector<std::pair<double, double> > MaxAccelProfile;
1089 : switch (vc) {
1090 : case SVC_PEDESTRIAN:
1091 : case SVC_BICYCLE:
1092 : case SVC_MOTORCYCLE:
1093 : case SVC_MOPED:
1094 : case SVC_TRUCK:
1095 : case SVC_TRAILER:
1096 : case SVC_BUS:
1097 : case SVC_COACH:
1098 : case SVC_TRAM:
1099 : case SVC_RAIL_URBAN:
1100 : case SVC_RAIL:
1101 : case SVC_RAIL_ELECTRIC:
1102 : case SVC_RAIL_FAST:
1103 : case SVC_SHIP:
1104 : default:
1105 306080 : return result;
1106 : }
1107 306080 : }
1108 :
1109 : LinearApproxHelpers::LinearApproxMap
1110 306080 : SUMOVTypeParameter::getDefaultDesAccelProfile(const SUMOVehicleClass vc, double desAccel) {
1111 : UNUSED_PARAMETER(desAccel);
1112 : LinearApproxHelpers::LinearApproxMap result;
1113 : switch (vc) {
1114 : case SVC_PEDESTRIAN:
1115 : case SVC_BICYCLE:
1116 : case SVC_MOTORCYCLE:
1117 : case SVC_MOPED:
1118 : case SVC_TRUCK:
1119 : case SVC_TRAILER:
1120 : case SVC_BUS:
1121 : case SVC_COACH:
1122 : case SVC_TRAM:
1123 : case SVC_RAIL_URBAN:
1124 : case SVC_RAIL:
1125 : case SVC_RAIL_ELECTRIC:
1126 : case SVC_RAIL_FAST:
1127 : case SVC_SHIP:
1128 : default:
1129 306080 : return result;
1130 : }
1131 : }
1132 :
1133 : /****************************************************************************/
|
