Line data Source code
1 : /****************************************************************************/
2 : // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3 : // Copyright (C) 2001-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 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 365267 : SUMOVTypeParameter::VClassDefaultValues::VClassDefaultValues(SUMOVehicleClass vclass) :
67 365267 : length(getDefaultVehicleLength(vclass)),
68 365267 : minGap(2.5),
69 365267 : minGapLat(0.6),
70 365267 : maxSpeed(200. / 3.6),
71 365267 : desiredMaxSpeed(10000 / 3.6), // backward-compatibility: do not influence speeds by default
72 365267 : width(DEFAULT_VEH_WIDTH),
73 365267 : height(DEFAULT_VEH_HEIGHT),
74 365267 : shape(SUMOVehicleShape::UNKNOWN),
75 730534 : emissionClass(PollutantsInterface::getClassByName(EMPREFIX + "default", vclass)),
76 365267 : mass(DEFAULT_VEH_MASS),
77 365267 : speedFactor("normc", 1.0, 0.0, 0.2, 2.0),
78 365267 : personCapacity(4),
79 365267 : containerCapacity(0),
80 365267 : osgFile("car-normal-citrus.obj"),
81 365267 : carriageLength(-1),
82 365267 : locomotiveLength(-1),
83 365267 : carriageDoors(2),
84 365267 : carriageDoorWidth(1.5),
85 365267 : maxPlatformDistance(3.),
86 365267 : latAlignmentProcedure(LatAlignmentDefinition::CENTER) {
87 : // update default values
88 365267 : switch (vclass) {
89 98280 : case SVC_PEDESTRIAN:
90 98280 : minGap = 0.25;
91 98280 : maxSpeed = 37.58 / 3.6; // Usain Bolt
92 98280 : desiredMaxSpeed = DEFAULT_PEDESTRIAN_SPEED;
93 98280 : width = 0.478;
94 98280 : height = 1.719;
95 98280 : shape = SUMOVehicleShape::PEDESTRIAN;
96 : osgFile = "humanResting.obj";
97 196560 : emissionClass = PollutantsInterface::getClassByName(EMPREFIX + "zero", vclass);
98 98280 : mass = 70.; // https://en.wikipedia.org/wiki/Human_body_weight for Europe
99 98280 : 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 46391 : case SVC_BICYCLE:
114 46391 : minGap = 0.5;
115 46391 : minGapLat = 0.35;
116 46391 : maxSpeed = 50. / 3.6;
117 46391 : desiredMaxSpeed = DEFAULT_BICYCLE_SPEED;
118 46391 : width = 0.65;
119 46391 : height = 1.7;
120 46391 : shape = SUMOVehicleShape::BICYCLE;
121 46391 : personCapacity = 1;
122 92782 : emissionClass = PollutantsInterface::getClassByName(EMPREFIX + "zero", vclass);
123 46391 : mass = 10.;
124 46391 : speedFactor.setParameter(1, 0.1);
125 46391 : latAlignmentProcedure = LatAlignmentDefinition::RIGHT;
126 46391 : 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 534 : case SVC_TRUCK:
161 534 : maxSpeed = 130. / 3.6;
162 534 : width = 2.4;
163 534 : height = 2.4;
164 534 : shape = SUMOVehicleShape::TRUCK;
165 : osgFile = "car-microcargo-citrus.obj";
166 534 : personCapacity = 2;
167 534 : containerCapacity = 1;
168 1068 : emissionClass = PollutantsInterface::getClassByName(EMPREFIX + "RT_le7.5t_Euro-VI_A-C", vclass);
169 534 : mass = 4500.;
170 534 : 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 1108 : case SVC_BUS:
185 1108 : maxSpeed = 100. / 3.6;
186 1108 : width = 2.5;
187 1108 : height = 3.4;
188 1108 : shape = SUMOVehicleShape::BUS;
189 : osgFile = "car-minibus-citrus.obj";
190 1108 : 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 2216 : emissionClass = PollutantsInterface::getClassByName(EMPREFIX + "UBus_Std_gt15-18t_Euro-VI_A-C", vclass);
194 1108 : mass = 12000.;
195 1108 : break;
196 41 : case SVC_COACH:
197 41 : maxSpeed = 100. / 3.6;
198 41 : width = 2.6;
199 41 : height = 4.;
200 41 : shape = SUMOVehicleShape::BUS_COACH;
201 : osgFile = "car-minibus-citrus.obj";
202 41 : personCapacity = 70;
203 82 : emissionClass = PollutantsInterface::getClassByName(EMPREFIX + "Coach_3-Axes_gt18t_Euro-VI_A-C", vclass);
204 41 : mass = 25000.;
205 41 : speedFactor.setParameter(1, 0.05);
206 : break;
207 220 : case SVC_TRAM:
208 220 : maxSpeed = 80. / 3.6;
209 220 : width = 2.4;
210 220 : height = 3.2;
211 220 : shape = SUMOVehicleShape::RAIL_CAR;
212 : osgFile = "tram.obj";
213 220 : personCapacity = 120;
214 440 : emissionClass = PollutantsInterface::getClassByName(EMPREFIX + "zero", vclass);
215 220 : mass = 37900.;
216 220 : break;
217 624 : case SVC_RAIL_URBAN:
218 : case SVC_SUBWAY:
219 624 : maxSpeed = 100. / 3.6;
220 624 : minGap = 5;
221 624 : width = 3.0;
222 624 : height = 3.6;
223 624 : shape = SUMOVehicleShape::RAIL_CAR;
224 624 : personCapacity = 300;
225 1248 : emissionClass = PollutantsInterface::getClassByName(EMPREFIX + "zero", vclass);
226 624 : mass = 59000.;
227 624 : break;
228 48023 : case SVC_RAIL:
229 48023 : maxSpeed = 160. / 3.6;
230 48023 : minGap = 5;
231 48023 : width = 2.84;
232 48023 : height = 3.75;
233 48023 : shape = SUMOVehicleShape::RAIL;
234 48023 : personCapacity = 434;
235 : // slight understatement (-:
236 48023 : emissionClass = PollutantsInterface::getClassByName("HBEFA3/HDV_D_EU0", vclass);
237 48023 : mass = 79500.; // only locomotive
238 48023 : 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 261 : case SVC_EMERGENCY:
269 261 : width = 2.16;
270 261 : height = 2.86;
271 261 : shape = SUMOVehicleShape::DELIVERY;
272 261 : personCapacity = 2;
273 522 : emissionClass = PollutantsInterface::getClassByName(EMPREFIX + "LCV_diesel_N1-III_Euro-6ab", vclass);
274 261 : mass = 5000.;
275 261 : break;
276 74605 : case SVC_PRIVATE:
277 : case SVC_VIP:
278 : case SVC_PASSENGER:
279 : case SVC_HOV:
280 : case SVC_CUSTOM1:
281 : case SVC_CUSTOM2:
282 74605 : shape = SUMOVehicleShape::PASSENGER;
283 74605 : speedFactor.setParameter(1, 0.1);
284 : break;
285 46596 : case SVC_TAXI:
286 46596 : shape = SUMOVehicleShape::TAXI;
287 46596 : 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 41452 : case SVC_CONTAINER:
295 : // ISO Container TEU
296 41452 : width = 2.438;
297 41452 : height = 2.591;
298 41452 : 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 315 : case SVC_SHIP:
308 315 : width = 4;
309 315 : maxSpeed = 8 / 1.94; // 8 knots
310 315 : height = 4;
311 315 : shape = SUMOVehicleShape::SHIP;
312 : // slight understatement (-:
313 315 : emissionClass = PollutantsInterface::getClassByName("HBEFA3/HDV_D_EU0", vclass);
314 315 : mass = 100000.;
315 315 : speedFactor.setParameter(1, 0.1);
316 : break;
317 : default:
318 : break;
319 : }
320 365267 : }
321 :
322 :
323 0 : SUMOVTypeParameter::VClassDefaultValues::VClassDefaultValues() :
324 0 : speedFactor("normc", 1.0, 0.0, 0.2, 2.0) {}
325 :
326 339389 : SUMOVTypeParameter::SUMOVTypeParameter(const std::string& vtid, const SUMOVehicleClass vclass)
327 339389 : : id(vtid),
328 339389 : actionStepLength(0),
329 339389 : defaultProbability(DEFAULT_VEH_PROB),
330 339389 : speedFactor("normc", 1.0, 0.0, 0.2, 2.0),
331 678778 : emissionClass(PollutantsInterface::getClassByName(EMPREFIX + "default", vclass)),
332 339389 : color(RGBColor::DEFAULT_COLOR),
333 339389 : vehicleClass(vclass),
334 339389 : impatience(0.0),
335 339389 : personCapacity(4),
336 339389 : containerCapacity(0),
337 339389 : boardingDuration(500),
338 339389 : loadingDuration(90000),
339 339389 : scale(1),
340 339389 : width(1.8),
341 339389 : height(1.5),
342 339389 : shape(SUMOVehicleShape::UNKNOWN),
343 339389 : osgFile("car-normal-citrus.obj"),
344 339389 : cfModel(SUMO_TAG_CF_KRAUSS),
345 339389 : lcModel(LaneChangeModel::DEFAULT),
346 339389 : maxSpeedLat(1.0),
347 339389 : latAlignmentOffset(0.0),
348 339389 : latAlignmentProcedure(LatAlignmentDefinition::CENTER),
349 339389 : scaleVisual(1),
350 339389 : carriageLength(-1),
351 339389 : locomotiveLength(-1),
352 339389 : carriageGap(1.),
353 339389 : carriageDoors(2),
354 339389 : carriageDoorWidth(1.5),
355 339389 : maxPlatformDistance(3.),
356 339389 : timeToTeleport(TTT_UNSET),
357 339389 : timeToTeleportBidi(TTT_UNSET),
358 339389 : speedFactorPremature(-1),
359 339389 : frontSeatPos(1.7),
360 339389 : seatingWidth(-1),
361 339389 : boardingFactor(1),
362 339389 : parametersSet(0),
363 339389 : saved(false),
364 339389 : onlyReferenced(false) {
365 339389 : const OptionsCont& oc = OptionsCont::getOptions();
366 678778 : if (oc.exists("carfollow.model")) {
367 : // check for valid value has been performed in MSFrame
368 631278 : cfModel = SUMOXMLDefinitions::CarFollowModels.get(oc.getString("carfollow.model"));
369 : }
370 : // obtain default values depending of vclass
371 339389 : VClassDefaultValues defaultValues(vclass);
372 : // overwrite SUMOVTypeParameter with VClassDefaultValues
373 339389 : length = defaultValues.length;
374 339389 : minGap = defaultValues.minGap;
375 339389 : minGapLat = defaultValues.minGapLat;
376 339389 : maxSpeed = defaultValues.maxSpeed;
377 339389 : desiredMaxSpeed = defaultValues.desiredMaxSpeed;
378 339389 : width = defaultValues.width;
379 339389 : height = defaultValues.height;
380 339389 : shape = defaultValues.shape;
381 339389 : emissionClass = defaultValues.emissionClass;
382 339389 : mass = defaultValues.mass;
383 : speedFactor = defaultValues.speedFactor;
384 339389 : personCapacity = defaultValues.personCapacity;
385 339389 : containerCapacity = defaultValues.containerCapacity;
386 : osgFile = defaultValues.osgFile;
387 339389 : carriageLength = defaultValues.carriageLength;
388 339389 : locomotiveLength = defaultValues.locomotiveLength;
389 339389 : carriageDoors = defaultValues.carriageDoors;
390 339389 : latAlignmentProcedure = defaultValues.latAlignmentProcedure;
391 : // check if default speeddev was defined
392 678778 : if (oc.exists("default.speeddev")) {
393 315639 : const double defaultSpeedDev = oc.getFloat("default.speeddev");
394 315639 : if (defaultSpeedDev >= 0) {
395 218306 : speedFactor.setParameter(1, defaultSpeedDev);
396 : }
397 : } else {
398 23750 : speedFactor.setParameter(1, -1.);
399 : }
400 339389 : setManoeuverAngleTimes(vclass);
401 339389 : }
402 :
403 : void
404 339389 : 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 339389 : switch (vclass) {
415 120914 : case SVC_PASSENGER:
416 : case SVC_HOV:
417 : case SVC_TAXI:
418 : case SVC_E_VEHICLE:
419 120914 : myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(10, std::pair< SUMOTime, SUMOTime>(3000, 4000))); // straight in but potentially needing parallel parking
420 120914 : myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(80, std::pair< SUMOTime, SUMOTime>(1000, 11000))); // straight in
421 120914 : myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(110, std::pair< SUMOTime, SUMOTime>(11000, 2000))); // optional forwards/backwards
422 120914 : myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(170, std::pair< SUMOTime, SUMOTime>(8000, 3000))); // backwards into obtuse space
423 120914 : myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(181, std::pair< SUMOTime, SUMOTime>(3000, 4000))); // straight in but potentially needing parallel parking
424 120914 : break;
425 1852 : case SVC_TRUCK:
426 : case SVC_TRAILER:
427 : case SVC_BUS:
428 : case SVC_COACH:
429 : case SVC_DELIVERY:
430 1852 : myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(10, std::pair< SUMOTime, SUMOTime>(6000, 8000))); // straight in but potentially needing parallel parking
431 1852 : myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(80, std::pair< SUMOTime, SUMOTime>(2000, 21000))); // straight in
432 1852 : myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(110, std::pair< SUMOTime, SUMOTime>(21000, 2000))); // optional forwards/backwards
433 1852 : myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(170, std::pair< SUMOTime, SUMOTime>(14000, 5000))); // backwards into obtuse space
434 1852 : myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(181, std::pair< SUMOTime, SUMOTime>(6000, 8000))); // straight in but potentially needing parallel parking
435 1852 : break;
436 118911 : case SVC_PEDESTRIAN:
437 : case SVC_MOPED:
438 : case SVC_BICYCLE:
439 118911 : myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(181, std::pair< SUMOTime, SUMOTime>(1000, 1000))); // no dependence on angle
440 118911 : break;
441 97712 : default:
442 97712 : myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(10, std::pair< SUMOTime, SUMOTime>(3000, 4000))); // straight in but potentially needing parallel parking
443 97712 : myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(80, std::pair< SUMOTime, SUMOTime>(1000, 11000))); // straight in
444 97712 : myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(110, std::pair< SUMOTime, SUMOTime>(11000, 2000))); // optional forwards/backwards
445 97712 : myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(170, std::pair< SUMOTime, SUMOTime>(8000, 3000))); // backwards into obtuse space
446 97712 : myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(181, std::pair< SUMOTime, SUMOTime>(3000, 4000))); // straight in but potentially needing parallel parking
447 97712 : break;
448 : }
449 339389 : }
450 :
451 : void
452 6805 : SUMOVTypeParameter::write(OutputDevice& dev) const {
453 : // first check if vehicle type can be written
454 6805 : if (onlyReferenced) {
455 : return;
456 : }
457 : // open vehicle tag
458 3170 : dev.openTag(SUMO_TAG_VTYPE);
459 : // write ID (always needed)
460 3170 : dev.writeAttr(SUMO_ATTR_ID, id);
461 : // write parameters depending if is set
462 3170 : if (wasSet(VTYPEPARS_LENGTH_SET)) {
463 832 : dev.writeAttr(SUMO_ATTR_LENGTH, length);
464 : }
465 3170 : if (wasSet(VTYPEPARS_MINGAP_SET)) {
466 705 : dev.writeAttr(SUMO_ATTR_MINGAP, minGap);
467 : }
468 3170 : if (wasSet(VTYPEPARS_MAXSPEED_SET)) {
469 763 : dev.writeAttr(SUMO_ATTR_MAXSPEED, maxSpeed);
470 : }
471 3170 : if (wasSet(VTYPEPARS_DESIRED_MAXSPEED_SET)) {
472 0 : dev.writeAttr(SUMO_ATTR_DESIRED_MAXSPEED, desiredMaxSpeed);
473 : }
474 3170 : if (wasSet(VTYPEPARS_PROBABILITY_SET)) {
475 92 : dev.writeAttr(SUMO_ATTR_PROB, defaultProbability);
476 : }
477 3170 : if (wasSet(VTYPEPARS_SPEEDFACTOR_SET)) {
478 464 : dev.writeAttr(SUMO_ATTR_SPEEDFACTOR, speedFactor);
479 : }
480 3170 : 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 3170 : if (wasSet(VTYPEPARS_VEHICLECLASS_SET)) {
485 1414 : dev.writeAttr(SUMO_ATTR_VCLASS, toString(vehicleClass));
486 : }
487 3170 : if (wasSet(VTYPEPARS_EMISSIONCLASS_SET)) {
488 116 : dev.writeAttr(SUMO_ATTR_EMISSIONCLASS, PollutantsInterface::getName(emissionClass));
489 : }
490 3170 : if (wasSet(VTYPEPARS_MASS_SET)) {
491 10 : dev.writeAttr(SUMO_ATTR_MASS, mass);
492 : }
493 3170 : 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 3170 : if (wasSet(VTYPEPARS_SHAPE_SET)) {
501 102 : dev.writeAttr(SUMO_ATTR_GUISHAPE, getVehicleShapeName(shape));
502 : }
503 3170 : if (wasSet(VTYPEPARS_WIDTH_SET)) {
504 40 : dev.writeAttr(SUMO_ATTR_WIDTH, width);
505 : }
506 3170 : if (wasSet(VTYPEPARS_HEIGHT_SET)) {
507 0 : dev.writeAttr(SUMO_ATTR_HEIGHT, height);
508 : }
509 3170 : if (wasSet(VTYPEPARS_COLOR_SET)) {
510 426 : dev.writeAttr(SUMO_ATTR_COLOR, color);
511 : }
512 3170 : if (wasSet(VTYPEPARS_OSGFILE_SET)) {
513 0 : dev.writeAttr(SUMO_ATTR_OSGFILE, osgFile);
514 : }
515 3170 : if (wasSet(VTYPEPARS_IMGFILE_SET)) {
516 0 : dev.writeAttr(SUMO_ATTR_IMGFILE, imgFile);
517 : }
518 3170 : if (wasSet(VTYPEPARS_PERSON_CAPACITY)) {
519 0 : dev.writeAttr(SUMO_ATTR_PERSON_CAPACITY, personCapacity);
520 : }
521 3170 : if (wasSet(VTYPEPARS_CONTAINER_CAPACITY)) {
522 0 : dev.writeAttr(SUMO_ATTR_CONTAINER_CAPACITY, containerCapacity);
523 : }
524 3170 : if (wasSet(VTYPEPARS_BOARDING_DURATION)) {
525 16 : dev.writeAttr(SUMO_ATTR_BOARDING_DURATION, time2string(boardingDuration));
526 : }
527 3170 : if (wasSet(VTYPEPARS_LOADING_DURATION)) {
528 16 : dev.writeAttr(SUMO_ATTR_LOADING_DURATION, time2string(loadingDuration));
529 : }
530 3170 : if (wasSet(VTYPEPARS_MAXSPEED_LAT_SET)) {
531 8 : dev.writeAttr(SUMO_ATTR_MAXSPEED_LAT, maxSpeedLat);
532 : }
533 3170 : 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 3170 : if (wasSet(VTYPEPARS_MINGAP_LAT_SET)) {
562 8 : dev.writeAttr(SUMO_ATTR_MINGAP_LAT, minGapLat);
563 : }
564 3170 : if (wasSet(VTYPEPARS_MANEUVER_ANGLE_TIMES_SET)) {
565 0 : dev.writeAttr(SUMO_ATTR_MANEUVER_ANGLE_TIMES, getManoeuverAngleTimesS());
566 : }
567 3170 : if (wasSet(VTYPEPARS_SCALE_SET)) {
568 0 : dev.writeAttr(SUMO_ATTR_SCALE, scale);
569 : }
570 3170 : if (wasSet(VTYPEPARS_TTT_SET)) {
571 16 : dev.writeAttr(SUMO_ATTR_TIME_TO_TELEPORT, time2string(timeToTeleport));
572 : }
573 3170 : if (wasSet(VTYPEPARS_TTT_BIDI_SET)) {
574 0 : dev.writeAttr(SUMO_ATTR_TIME_TO_TELEPORT_BIDI, time2string(timeToTeleportBidi));
575 : }
576 3170 : if (wasSet(VTYPEPARS_SPEEDFACTOR_PREMATURE_SET)) {
577 0 : dev.writeAttr(SUMO_ATTR_SPEEDFACTOR_PREMATURE, speedFactorPremature);
578 : }
579 3170 : if (wasSet(VTYPEPARS_BOARDING_FACTOR_SET)) {
580 0 : dev.writeAttr(SUMO_ATTR_BOARDING_FACTOR, boardingFactor);
581 : }
582 3170 : 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 3170 : for (const auto& lcParam : lcParameter) {
587 0 : dev.writeAttr(lcParam.first, lcParam.second);
588 : }
589 : // Write Junction Model parameter
590 3170 : for (const auto& jmParam : jmParameter) {
591 0 : dev.writeAttr(jmParam.first, jmParam.second);
592 : }
593 3170 : 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 6591 : for (const auto& cfParam : cfParameter) {
598 3421 : dev.writeAttr(cfParam.first, cfParam.second);
599 : }
600 : // Write carriage length
601 3170 : 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 3170 : 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 3170 : 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 3170 : 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 3170 : writeParams(dev);
630 : // close tag
631 6340 : dev.closeTag();
632 : }
633 :
634 :
635 : double
636 4375127 : SUMOVTypeParameter::getCFParam(const SumoXMLAttr attr, const double defaultValue) const {
637 : if (cfParameter.count(attr)) {
638 54524 : return StringUtils::toDouble(cfParameter.find(attr)->second);
639 : } else {
640 : return defaultValue;
641 : }
642 : }
643 :
644 :
645 : std::string
646 450 : 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 72 : SUMOVTypeParameter::getCFValueTable(SumoXMLAttr attr) const {
657 : std::vector<double> result;
658 144 : const std::string values = getCFParamString(attr, "");
659 72 : if (!values.empty()) {
660 816 : for (std::string value : StringTokenizer(values).getVector()) {
661 672 : result.push_back(StringUtils::toDouble(value));
662 72 : }
663 : }
664 72 : return result;
665 0 : }
666 :
667 :
668 :
669 : LinearApproxHelpers::LinearApproxMap
670 623974 : SUMOVTypeParameter::getCFProfile(const SumoXMLAttr attr, const LinearApproxHelpers::LinearApproxMap& defaultProfile) const {
671 : if (cfParameter.count(attr)) {
672 36 : std::vector<double> speedTable = getCFValueTable(SUMO_ATTR_SPEED_TABLE);
673 36 : std::vector<double> valueTable = getCFValueTable(attr);
674 36 : 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 36 : } 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 372 : for (int i = 0; i < (int)speedTable.size(); i++) {
681 336 : result[speedTable[i]] = valueTable[i];
682 : }
683 : return result;
684 36 : } else {
685 : return defaultProfile;
686 : }
687 : }
688 :
689 :
690 : double
691 120668232 : SUMOVTypeParameter::getLCParam(const SumoXMLAttr attr, const double defaultValue) const {
692 : if (lcParameter.count(attr)) {
693 360271 : return StringUtils::toDouble(lcParameter.find(attr)->second);
694 : } else {
695 : return defaultValue;
696 : }
697 : }
698 :
699 :
700 : std::string
701 101758 : 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 3094515801 : SUMOVTypeParameter::getJMParam(const SumoXMLAttr attr, const double defaultValue) const {
718 : if (jmParameter.count(attr)) {
719 18536963 : 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 309643 : SUMOVTypeParameter::initRailVisualizationParameters(const std::string fileName) {
788 619286 : if (hasParameter("scaleVisual")) {
789 0 : scaleVisual = StringUtils::toDouble(getParameter("scaleVisual"));
790 : }
791 619286 : if (hasParameter("carriageLength")) {
792 134 : carriageLength = StringUtils::toDouble(getParameter("carriageLength"));
793 67 : parametersSet |= VTYPEPARS_CARRIAGE_LENGTH_SET;
794 : } else {
795 309576 : 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 43546 : case SUMOVehicleShape::RAIL:
801 43546 : if (vehicleClass == SVC_RAIL_ELECTRIC) {
802 24 : carriageLength = 24.5;
803 24 : locomotiveLength = 19.100; // https://en.wikipedia.org/wiki/DB_Class_101
804 43522 : } 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 43498 : carriageLength = 24.5; // http://de.wikipedia.org/wiki/UIC-Y-Wagen_%28DR%29
809 43498 : locomotiveLength = 16.4; // https://en.wikipedia.org/wiki/DB_Class_218
810 : }
811 : break;
812 597 : case SUMOVehicleShape::RAIL_CAR:
813 597 : if (vehicleClass == SVC_TRAM) {
814 157 : carriageLength = 5.71; // http://de.wikipedia.org/wiki/Bombardier_Flexity_Berlin
815 157 : locomotiveLength = 5.71;
816 440 : } else if (vehicleClass == SVC_RAIL_URBAN) {
817 388 : carriageLength = 18.4; // https://en.wikipedia.org/wiki/DBAG_Class_481
818 388 : 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 619286 : if (hasParameter("locomotiveLength")) {
841 62 : locomotiveLength = StringUtils::toDouble(getParameter("locomotiveLength"));
842 31 : parametersSet |= VTYPEPARS_LOCOMOTIVE_LENGTH_SET;
843 309612 : } else if (locomotiveLength < 0) {
844 265421 : locomotiveLength = carriageLength;
845 : }
846 619286 : if (hasParameter("carriageGap")) {
847 12 : carriageGap = StringUtils::toDouble(getParameter("carriageGap"));
848 6 : parametersSet |= VTYPEPARS_CARRIAGE_GAP_SET;
849 : }
850 619286 : if (hasParameter("carriageDoors")) {
851 24 : carriageDoors = StringUtils::toInt(getParameter("carriageDoors"));
852 12 : parametersSet |= VTYPEPARS_CARRIAGE_DOORS_SET;
853 : }
854 619286 : if (hasParameter("carriageDoorWidth")) {
855 0 : carriageDoorWidth = StringUtils::toDouble(getParameter("carriageDoorWidth"));
856 : }
857 619286 : if (hasParameter("maxPlatformDistance")) {
858 0 : maxPlatformDistance = StringUtils::toDouble(getParameter("maxPlatformDistance"));
859 : }
860 619286 : if (hasParameter("frontSeatPos")) {
861 30 : frontSeatPos = StringUtils::toDouble(getParameter("frontSeatPos"));
862 15 : parametersSet |= VTYPEPARS_FRONT_SEAT_POS_SET;
863 : } else {
864 309628 : 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 42106 : case SUMOVehicleShape::BICYCLE:
872 42106 : frontSeatPos = 0.6;
873 42106 : break;
874 262 : case SUMOVehicleShape::MOPED:
875 : case SUMOVehicleShape::MOTORCYCLE:
876 262 : frontSeatPos = 0.9;
877 262 : break;
878 1015 : case SUMOVehicleShape::BUS:
879 : case SUMOVehicleShape::BUS_COACH:
880 : case SUMOVehicleShape::BUS_FLEXIBLE:
881 : case SUMOVehicleShape::BUS_TROLLEY:
882 1015 : frontSeatPos = 0.5;
883 1015 : break;
884 658 : case SUMOVehicleShape::TRUCK:
885 : case SUMOVehicleShape::TRUCK_1TRAILER:
886 : case SUMOVehicleShape::TRUCK_SEMITRAILER:
887 658 : frontSeatPos = 0.8;
888 658 : break;
889 : default:
890 : break;
891 : }
892 : }
893 :
894 619286 : if (hasParameter("seatingWidth")) {
895 14 : seatingWidth = StringUtils::toDouble(getParameter("seatingWidth"));
896 7 : parametersSet |= VTYPEPARS_SEATING_WIDTH_SET;
897 : }
898 619286 : 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 309643 : }
905 :
906 :
907 : double
908 311707 : SUMOVTypeParameter::getDefaultAccel(const SUMOVehicleClass vc) {
909 311707 : 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 538 : case SVC_TRUCK:
921 538 : return 1.3;
922 : case SVC_TRAILER:
923 : return 1.1;
924 : case SVC_BUS:
925 : return 1.2;
926 41 : case SVC_COACH:
927 41 : return 2.;
928 : case SVC_TRAM:
929 : return 1.;
930 : case SVC_RAIL_URBAN:
931 : return 1.;
932 43659 : case SVC_RAIL:
933 43659 : 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 154972 : default:
940 154972 : return 2.6;//2.9;
941 : }
942 : }
943 :
944 :
945 : double
946 705912 : SUMOVTypeParameter::getDefaultDecel(const SUMOVehicleClass vc) {
947 705912 : 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 3040 : case SVC_TRUCK:
959 : case SVC_TRAILER:
960 : case SVC_BUS:
961 : case SVC_COACH:
962 3040 : return 4.;
963 : case SVC_TRAM:
964 : case SVC_RAIL_URBAN:
965 : return 3.;
966 128546 : case SVC_RAIL:
967 : case SVC_RAIL_ELECTRIC:
968 : case SVC_RAIL_FAST:
969 128546 : return 1.3;
970 450 : case SVC_SHIP:
971 450 : return 0.15;
972 351608 : default:
973 351608 : return 4.5;//7.5;
974 : }
975 : }
976 :
977 :
978 : double
979 621264 : SUMOVTypeParameter::getDefaultEmergencyDecel(const SUMOVehicleClass vc, double decel, double defaultOption) {
980 621264 : if (defaultOption == VTYPEPARS_DEFAULT_EMERGENCYDECEL_DEFAULT) {
981 : double vcDecel;
982 615776 : 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 304962 : 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 300625 : SUMOVTypeParameter::getDefaultImperfection(const SUMOVehicleClass vc) {
1027 300625 : 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 257801 : default:
1036 257801 : return 0.5;
1037 : }
1038 : }
1039 :
1040 : const SUMOVTypeParameter&
1041 16991708 : SUMOVTypeParameter::getDefault() {
1042 16997674 : static SUMOVTypeParameter defaultParams("");
1043 16991708 : return defaultParams;
1044 : }
1045 :
1046 : bool
1047 1730 : SUMOVTypeParameter::parseLatAlignment(const std::string& val, double& lao, LatAlignmentDefinition& lad) {
1048 : bool ok = true;
1049 1730 : lao = 0.0;
1050 1730 : lad = LatAlignmentDefinition::GIVEN;
1051 1730 : if (val == "right") {
1052 315 : lad = LatAlignmentDefinition::RIGHT;
1053 1415 : } else if (val == "center") {
1054 677 : lad = LatAlignmentDefinition::CENTER;
1055 738 : } else if (val == "arbitrary") {
1056 348 : 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 1730 : return ok;
1071 : }
1072 :
1073 :
1074 : SUMOTime
1075 83513483 : SUMOVTypeParameter::getTimeToTeleport(SUMOTime defaultValue) const {
1076 83513483 : return timeToTeleport == TTT_UNSET ? defaultValue : timeToTeleport;
1077 : }
1078 :
1079 : SUMOTime
1080 83513483 : SUMOVTypeParameter::getTimeToTeleportBidi(SUMOTime defaultValue) const {
1081 83513483 : return timeToTeleportBidi == TTT_UNSET ? defaultValue : timeToTeleportBidi;
1082 : }
1083 :
1084 : LinearApproxHelpers::LinearApproxMap
1085 311617 : 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 311617 : return result;
1106 : }
1107 311617 : }
1108 :
1109 : LinearApproxHelpers::LinearApproxMap
1110 311617 : 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 311617 : return result;
1130 : }
1131 : }
1132 :
1133 : /****************************************************************************/
|
