Eclipse SUMO - Simulation of Urban MObility
SUMOVTypeParameter.cpp
Go to the documentation of this file.
1 /****************************************************************************/
2 // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3 // Copyright (C) 2001-2019 German Aerospace Center (DLR) and others.
4 // This program and the accompanying materials
5 // are made available under the terms of the Eclipse Public License v2.0
6 // which accompanies this distribution, and is available at
7 // http://www.eclipse.org/legal/epl-v20.html
8 // SPDX-License-Identifier: EPL-2.0
9 /****************************************************************************/
16 // Structure representing possible vehicle parameter
17 /****************************************************************************/
18 
19 
20 // ===========================================================================
21 // included modules
22 // ===========================================================================
23 #include <config.h>
24 
25 #include <algorithm>
27 #include <utils/common/ToString.h>
34 
35 #define EMPREFIX std::string("HBEFA3/")
36 
37 
38 // ===========================================================================
39 // member method definitions
40 // ===========================================================================
41 
43  length(5./*4.3*/),
44  minGap(2.5),
45  maxSpeed(200. / 3.6),
46  width(1.8),
47  height(1.5),
48  shape(SVS_UNKNOWN),
49  emissionClass(PollutantsInterface::getClassByName(EMPREFIX + "PC_G_EU4", vclass)),
50  speedFactor("normc", 1.0, 0.0, 0.2, 2.0),
51  personCapacity(4),
52  containerCapacity(0),
53  osgFile("car-normal-citrus.obj"),
54  carriageLength(-1),
55  locomotiveLength(-1) {
56  // update default values
57  switch (vclass) {
58  case SVC_PEDESTRIAN:
59  length = 0.215;
60  minGap = 0.25;
62  width = 0.478;
63  height = 1.719;
66  speedFactor.getParameter()[1] = 0.1;
67  break;
68  case SVC_BICYCLE:
69  length = 1.6;
70  minGap = 0.5;
71  maxSpeed = 20. / 3.6;
72  width = 0.65;
73  height = 1.7;
75  personCapacity = 1;
77  speedFactor.getParameter()[1] = 0.1;
78  break;
79  case SVC_MOPED:
80  length = 2.1;
81  maxSpeed = 60. / 3.6;
82  width = 0.8;
83  height = 1.7;
84  shape = SVS_MOPED;
85  personCapacity = 1;
87  speedFactor.getParameter()[1] = 0.1;
88  break;
89  case SVC_MOTORCYCLE:
90  length = 2.2;
91  width = 0.9;
92  height = 1.5;
94  personCapacity = 1;
96  speedFactor.getParameter()[1] = 0.1;
97  break;
98  case SVC_TRUCK:
99  length = 7.1;
100  maxSpeed = 130. / 3.6;
101  width = 2.4;
102  height = 2.4;
103  shape = SVS_TRUCK;
104  osgFile = "car-microcargo-citrus.obj";
105  personCapacity = 2;
106  containerCapacity = 1;
108  speedFactor.getParameter()[1] = 0.05;
109  break;
110  case SVC_TRAILER:
111  length = 16.5;
112  maxSpeed = 130. / 3.6;
113  width = 2.55;
114  height = 4.;
116  osgFile = "car-microcargo-citrus.obj";
117  personCapacity = 2;
118  containerCapacity = 2;
120  speedFactor.getParameter()[1] = 0.05;
121  break;
122  case SVC_BUS:
123  length = 12.;
124  maxSpeed = 100. / 3.6;
125  width = 2.5;
126  height = 3.4;
127  shape = SVS_BUS;
128  osgFile = "car-minibus-citrus.obj";
129  personCapacity = 85;
131  break;
132  case SVC_COACH:
133  length = 14.;
134  maxSpeed = 100. / 3.6;
135  width = 2.6;
136  height = 4.;
138  osgFile = "car-minibus-citrus.obj";
139  personCapacity = 70;
141  speedFactor.getParameter()[1] = 0.05;
142  break;
143  case SVC_TRAM:
144  length = 22.;
145  maxSpeed = 80. / 3.6;
146  width = 2.4;
147  height = 3.2;
149  carriageLength = 5.71; // http://de.wikipedia.org/wiki/Bombardier_Flexity_Berlin
150  locomotiveLength = 5.71;
151  personCapacity = 120;
153  break;
154  case SVC_RAIL_URBAN:
155  length = 36.5 * 3;
156  maxSpeed = 100. / 3.6;
157  width = 3.0;
158  height = 3.6;
160  carriageLength = 18.4; // https://en.wikipedia.org/wiki/DBAG_Class_481
161  locomotiveLength = 18.4;
162  personCapacity = 300;
164  break;
165  case SVC_RAIL:
166  length = 67.5 * 2;
167  maxSpeed = 160. / 3.6;
168  width = 2.84;
169  height = 3.75;
170  shape = SVS_RAIL;
171  carriageLength = 24.5; // http://de.wikipedia.org/wiki/UIC-Y-Wagen_%28DR%29
172  locomotiveLength = 16.4; // https://en.wikipedia.org/wiki/DB_Class_218
173  personCapacity = 434;
174  // slight understatement (-:
176  break;
177  case SVC_RAIL_ELECTRIC:
178  length = 25. * 8;
179  maxSpeed = 220. / 3.6;
180  width = 2.95;
181  height = 3.89;
182  shape = SVS_RAIL;
183  carriageLength = 24.775;
184  locomotiveLength = 19.100; // https://en.wikipedia.org/wiki/DB_Class_101
185  personCapacity = 425;
187  break;
188  case SVC_RAIL_FAST:
189  length = 25. * 8;
190  maxSpeed = 330. / 3.6;
191  width = 2.95;
192  height = 3.89;
193  shape = SVS_RAIL;
194  carriageLength = 24.775; // http://de.wikipedia.org/wiki/ICE_3
195  locomotiveLength = 25.835;
196  personCapacity = 425;
198  break;
199  case SVC_DELIVERY:
200  length = 6.5;
201  width = 2.16;
202  height = 2.86;
204  personCapacity = 2;
206  speedFactor.getParameter()[1] = 0.05;
207  break;
208  case SVC_EMERGENCY:
209  length = 6.5;
210  width = 2.16;
211  height = 2.86;
213  personCapacity = 2;
215  break;
216  case SVC_PRIVATE:
217  case SVC_VIP:
218  case SVC_PASSENGER:
219  case SVC_HOV:
220  case SVC_CUSTOM1:
221  case SVC_CUSTOM2:
223  speedFactor.getParameter()[1] = 0.1;
224  break;
225  case SVC_TAXI:
227  speedFactor.getParameter()[1] = 0.05;
228  break;
229  case SVC_E_VEHICLE:
232  speedFactor.getParameter()[1] = 0.1;
233  break;
234  case SVC_SHIP:
235  length = 17;
236  width = 4;
237  maxSpeed = 8 / 1.94; // 8 knots
238  height = 4;
239  shape = SVS_SHIP;
240  // slight understatement (-:
242  speedFactor.getParameter()[1] = 0.1;
243  break;
244  default:
245  break;
246  }
247 }
248 
249 
251  speedFactor("normc", 1.0, 0.0, 0.2, 2.0) {}
252 
253 
254 SUMOVTypeParameter::SUMOVTypeParameter(const std::string& vtid, const SUMOVehicleClass vclass) :
255  id(vtid), length(5./*4.3*/), minGap(2.5), maxSpeed(200. / 3.6),
257  speedFactor("normc", 1.0, 0.0, 0.2, 2.0),
258  emissionClass(PollutantsInterface::getClassByName(EMPREFIX + "PC_G_EU4", vclass)), color(RGBColor::DEFAULT_COLOR),
260  loadingDuration(90000), width(1.8), height(1.5), shape(SVS_UNKNOWN), osgFile("car-normal-citrus.obj"),
265  parametersSet(0), saved(false), onlyReferenced(false) {
266  const OptionsCont& oc = OptionsCont::getOptions();
267  if (oc.exists("carfollow.model")) {
268  // check for valid value has been performed in MSFrame
269  cfModel = SUMOXMLDefinitions::CarFollowModels.get(oc.getString("carfollow.model"));
270  }
271  // obtain default values depending of vclass
272  VClassDefaultValues defaultValues(vclass);
273  // overwritte SUMOVTypeParameter with VClassDefaultValues
274  length = defaultValues.length;
275  minGap = defaultValues.minGap;
276  maxSpeed = defaultValues.maxSpeed;
277  width = defaultValues.width;
278  height = defaultValues.height;
279  shape = defaultValues.shape;
280  emissionClass = defaultValues.emissionClass;
281  speedFactor = defaultValues.speedFactor;
282  personCapacity = defaultValues.personCapacity;
283  containerCapacity = defaultValues.containerCapacity;
284  osgFile = defaultValues.osgFile;
285  carriageLength = defaultValues.carriageLength;
286  locomotiveLength = defaultValues.locomotiveLength;
287  // check if default speeddev was defined
288  if (oc.exists("default.speeddev")) {
289  const double defaultSpeedDev = oc.getFloat("default.speeddev");
290  if (defaultSpeedDev >= 0) {
291  speedFactor.getParameter()[1] = defaultSpeedDev;
292  }
293  } else {
294  speedFactor.getParameter()[1] = 0;
295  }
296  setManoeuverAngleTimes(vclass);
297 }
298 
299 void
301 
302  myManoeuverAngleTimes.clear();
310  switch (vclass) {
311  case SVC_PASSENGER:
312  case SVC_HOV:
313  case SVC_TAXI:
314  case SVC_E_VEHICLE:
315  myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(10, std::pair< SUMOTime, SUMOTime>(3000, 4000))); // straight in but potentially needing parallel parking
316  myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(80, std::pair< SUMOTime, SUMOTime>(1000, 11000))); // straight in
317  myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(110, std::pair< SUMOTime, SUMOTime>(11000, 2000))); // optional forwards/backwards
318  myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(170, std::pair< SUMOTime, SUMOTime>(8000, 3000))); // backwards into obtuse space
319  myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(181, std::pair< SUMOTime, SUMOTime>(3000, 4000))); // straight in but potentially needing parallel parking
320  break;
321  case SVC_TRUCK:
322  case SVC_TRAILER:
323  case SVC_BUS:
324  case SVC_COACH:
325  case SVC_DELIVERY:
326  myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(10, std::pair< SUMOTime, SUMOTime>(6000, 8000))); // straight in but potentially needing parallel parking
327  myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(80, std::pair< SUMOTime, SUMOTime>(2000, 21000))); // straight in
328  myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(110, std::pair< SUMOTime, SUMOTime>(21000, 2000))); // optional forwards/backwards
329  myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(170, std::pair< SUMOTime, SUMOTime>(14000, 5000))); // backwards into obtuse space
330  myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(181, std::pair< SUMOTime, SUMOTime>(6000, 8000))); // straight in but potentially needing parallel parking
331  break;
332  case SVC_PEDESTRIAN:
333  case SVC_MOPED:
334  case SVC_BICYCLE:
335  myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(181, std::pair< SUMOTime, SUMOTime>(1000, 1000))); // no dependence on angle
336  break;
337  default:
338  myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(10, std::pair< SUMOTime, SUMOTime>(3000, 4000))); // straight in but potentially needing parallel parking
339  myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(80, std::pair< SUMOTime, SUMOTime>(1000, 11000))); // straight in
340  myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(110, std::pair< SUMOTime, SUMOTime>(11000, 2000))); // optional forwards/backwards
341  myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(170, std::pair< SUMOTime, SUMOTime>(8000, 3000))); // backwards into obtuse space
342  myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(181, std::pair< SUMOTime, SUMOTime>(3000, 4000))); // straight in but potentially needing parallel parking
343  break;
344  }
345 }
346 
347 void
349  // first check if vehicle type can be written
350  if (onlyReferenced) {
351  return;
352  }
353  // open vehicle tag
354  dev.openTag(SUMO_TAG_VTYPE);
355  // write ID (always needed)
356  dev.writeAttr(SUMO_ATTR_ID, id);
357  // write parametes depending if is set
360  }
363  }
366  }
369  }
372  }
374  // Note: action step length is only exposed in seconds to the user
376  }
379  }
382  }
384  if (impatience == -std::numeric_limits<double>::max()) {
385  dev.writeAttr(SUMO_ATTR_IMPATIENCE, "off");
386  } else {
388  }
389  }
392  }
395  }
398  }
401  }
404  }
407  }
410  }
413  }
416  }
419  }
422  }
425  }
428  }
431  }
434  }
435  // Write Lane Change Model parameters
436  for (const auto& i : lcParameter) {
437  dev.writeAttr(i.first, i.second);
438  }
439  // Write Junction Model parameter
440  for (const auto& i : jmParameter) {
441  dev.writeAttr(i.first, i.second);
442  }
445  }
446  // Write Car Following Model parameters
447  for (const auto& i : cfParameter) {
448  dev.writeAttr(i.first, i.second);
449  }
450  // Write rest of parameters
451  writeParams(dev);
452  // close tag
453  dev.closeTag();
454 }
455 
456 
457 double
458 SUMOVTypeParameter::getCFParam(const SumoXMLAttr attr, const double defaultValue) const {
459  if (cfParameter.count(attr)) {
460  return StringUtils::toDouble(cfParameter.find(attr)->second);
461  } else {
462  return defaultValue;
463  }
464 }
465 
466 
467 std::string
468 SUMOVTypeParameter::getCFParamString(const SumoXMLAttr attr, const std::string defaultValue) const {
469  if (cfParameter.count(attr)) {
470  return cfParameter.find(attr)->second;
471  } else {
472  return defaultValue;
473  }
474 }
475 
476 
477 double
478 SUMOVTypeParameter::getLCParam(const SumoXMLAttr attr, const double defaultValue) const {
479  if (lcParameter.count(attr)) {
480  return StringUtils::toDouble(lcParameter.find(attr)->second);
481  } else {
482  return defaultValue;
483  }
484 }
485 
486 
487 std::string
488 SUMOVTypeParameter::getLCParamString(const SumoXMLAttr attr, const std::string& defaultValue) const {
489  if (lcParameter.count(attr)) {
490  return lcParameter.find(attr)->second;
491  } else {
492  return defaultValue;
493  }
494 }
495 
496 
499  return lcParameter;
500 }
501 
502 
503 double
504 SUMOVTypeParameter::getJMParam(const SumoXMLAttr attr, const double defaultValue) const {
505  if (jmParameter.count(attr)) {
506  return StringUtils::toDouble(jmParameter.find(attr)->second);
507  } else {
508  return defaultValue;
509  }
510 }
511 
512 
513 std::string
514 SUMOVTypeParameter::getJMParamString(const SumoXMLAttr attr, const std::string defaultValue) const {
515  if (jmParameter.count(attr)) {
516  return jmParameter.find(attr)->second;
517  } else {
518  return defaultValue;
519  }
520 }
521 
522 SUMOTime
524  SUMOTime last = 0;
525  for (std::pair<int, std::pair<SUMOTime, SUMOTime>> angleTime : myManoeuverAngleTimes) {
526  if (angle <= angleTime.first) {
527  return (angleTime.second.first);
528  } else {
529  last = angleTime.second.first;
530  }
531  }
532  return (last);
533 }
534 
535 SUMOTime
537  SUMOTime last = 0;
538  for (std::pair<int, std::pair<SUMOTime, SUMOTime>> angleTime : myManoeuverAngleTimes) {
539  if (angle <= angleTime.first) {
540  return (angleTime.second.second);
541  } else {
542  last = angleTime.second.second;
543  }
544  }
545  return (last);
546 }
547 
548 std::string
550  std::stringstream stream;
551 
552  stream << std::fixed << std::setprecision(1);
553  int count = 0;
554  for (std::pair<int, std::pair<SUMOTime, SUMOTime>> angleTime : myManoeuverAngleTimes) {
555  if (count++ > 0) {
556  stream << ",";
557  }
558  stream << toString(angleTime.first) + " " << STEPS2TIME(angleTime.second.first) << " " << STEPS2TIME(angleTime.second.second);
559  }
560  std::string triplets = stream.str();
561  return triplets;
562 }
563 
564 
565 void
566 SUMOVTypeParameter::cacheParamRestrictions(const std::vector<std::string>& restrictionKeys) {
567  for (const std::string& key : restrictionKeys) {
569  }
570 }
571 
572 
573 double
575  switch (vc) {
576  case SVC_PEDESTRIAN:
577  return 1.5;
578  case SVC_BICYCLE:
579  return 1.2;
580  case SVC_MOTORCYCLE:
581  return 6.;
582  case SVC_MOPED:
583  return 1.1;
584  case SVC_TRUCK:
585  return 1.3;
586  case SVC_TRAILER:
587  return 1.1;
588  case SVC_BUS:
589  return 1.2;
590  case SVC_COACH:
591  return 2.;
592  case SVC_TRAM:
593  return 1.;
594  case SVC_RAIL_URBAN:
595  return 1.;
596  case SVC_RAIL:
597  return 0.25;
598  case SVC_RAIL_ELECTRIC:
599  case SVC_RAIL_FAST:
600  return 0.5;
601  case SVC_SHIP:
602  return 0.1;
603  default:
604  return 2.6;//2.9;
605  }
606 }
607 
608 
609 double
611  switch (vc) {
612  case SVC_PEDESTRIAN:
613  return 2.;
614  case SVC_BICYCLE:
615  return 3.;
616  case SVC_MOPED:
617  return 7.;
618  case SVC_MOTORCYCLE:
619  return 10.;
620  case SVC_TRUCK:
621  case SVC_TRAILER:
622  case SVC_BUS:
623  case SVC_COACH:
624  return 4.;
625  case SVC_TRAM:
626  case SVC_RAIL_URBAN:
627  return 3.;
628  case SVC_RAIL:
629  case SVC_RAIL_ELECTRIC:
630  case SVC_RAIL_FAST:
631  return 1.3;
632  case SVC_SHIP:
633  return 0.15;
634  default:
635  return 4.5;//7.5;
636  }
637 }
638 
639 
640 double
641 SUMOVTypeParameter::getDefaultEmergencyDecel(const SUMOVehicleClass vc, double decel, double defaultOption) {
642  if (defaultOption == VTYPEPARS_DEFAULT_EMERGENCYDECEL_DEFAULT) {
643  double vcDecel;
644  switch (vc) {
645  case SVC_PEDESTRIAN:
646  vcDecel = 5.;
647  break;
648  case SVC_BICYCLE:
649  vcDecel = 7.;
650  break;
651  case SVC_MOPED:
652  case SVC_MOTORCYCLE:
653  vcDecel = 10.;
654  break;
655  case SVC_TRUCK:
656  case SVC_TRAILER:
657  case SVC_BUS:
658  case SVC_COACH:
659  case SVC_TRAM:
660  case SVC_RAIL_URBAN:
661  vcDecel = 7.;
662  break;
663  case SVC_RAIL:
664  case SVC_RAIL_ELECTRIC:
665  case SVC_RAIL_FAST:
666  vcDecel = 5.;
667  break;
668  case SVC_SHIP:
669  vcDecel = 1.;
670  break;
671  default:
672  vcDecel = 9.;
673  }
674  return MAX2(decel, vcDecel);
675  } else if (defaultOption == VTYPEPARS_DEFAULT_EMERGENCYDECEL_DECEL) {
676  return decel;
677  } else {
678  // value already checked in MSFrame::checkOptions
679  return MAX2(decel, defaultOption);
680  }
681 }
682 
683 
684 
685 double
687  switch (vc) {
688  case SVC_TRAM:
689  case SVC_RAIL_URBAN:
690  case SVC_RAIL:
691  case SVC_RAIL_ELECTRIC:
692  case SVC_RAIL_FAST:
693  case SVC_SHIP:
694  return 0.;
695  default:
696  return 0.5;
697  }
698 }
699 
700 
701 const SUMOVTypeParameter&
703  static SUMOVTypeParameter defaultParams("");
704  return defaultParams;
705 }
706 
707 
708 /****************************************************************************/
VTYPEPARS_LATALIGNMENT_SET
const int VTYPEPARS_LATALIGNMENT_SET
Definition: SUMOVTypeParameter.h:66
SUMOVTypeParameter::SubParams
std::map< SumoXMLAttr, std::string > SubParams
sub-model parameters
Definition: SUMOVTypeParameter.h:190
SVC_RAIL_FAST
@ SVC_RAIL_FAST
vehicle that is allowed to drive on high-speed rail tracks
Definition: SUMOVehicleClass.h:192
SUMOVTypeParameter::cacheParamRestrictions
void cacheParamRestrictions(const std::vector< std::string > &restrictionKeys)
Definition: SUMOVTypeParameter.cpp:566
SUMO_ATTR_MAXSPEED
@ SUMO_ATTR_MAXSPEED
Definition: SUMOXMLDefinitions.h:441
SUMO_ATTR_OSGFILE
@ SUMO_ATTR_OSGFILE
Definition: SUMOXMLDefinitions.h:791
SUMO_ATTR_BOARDING_DURATION
@ SUMO_ATTR_BOARDING_DURATION
Definition: SUMOXMLDefinitions.h:460
SVC_PEDESTRIAN
@ SVC_PEDESTRIAN
pedestrian
Definition: SUMOVehicleClass.h:156
SUMOVehicleClass
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types.
Definition: SUMOVehicleClass.h:133
SUMOVTypeParameter::lcParameter
SubParams lcParameter
Lane-changing parameter.
Definition: SUMOVTypeParameter.h:284
ToString.h
SUMOVTypeParameter::VClassDefaultValues::carriageLength
double carriageLength
the length of train carriages
Definition: SUMOVTypeParameter.h:127
SVC_E_VEHICLE
@ SVC_E_VEHICLE
is an electric vehicle
Definition: SUMOVehicleClass.h:181
SUMOVTypeParameter::getExitManoeuvreTime
SUMOTime getExitManoeuvreTime(const int angle) const
Returns the time that will be needed for the vehicle type to execute the (exit) manoeuvre (and be blo...
Definition: SUMOVTypeParameter.cpp:536
SUMOVTypeParameter::locomotiveLength
double locomotiveLength
Definition: SUMOVTypeParameter.h:303
SUMOVTypeParameter::SUMOVTypeParameter
SUMOVTypeParameter(const std::string &vtid, const SUMOVehicleClass vc=SVC_IGNORING)
Constructor.
Definition: SUMOVTypeParameter.cpp:254
SUMOVTypeParameter::length
double length
The physical vehicle length.
Definition: SUMOVTypeParameter.h:215
SVC_EMERGENCY
@ SVC_EMERGENCY
public emergency vehicles
Definition: SUMOVehicleClass.h:143
SUMO_ATTR_IMGFILE
@ SUMO_ATTR_IMGFILE
Definition: SUMOXMLDefinitions.h:792
VTYPEPARS_MINGAP_SET
const int VTYPEPARS_MINGAP_SET
Definition: SUMOVTypeParameter.h:46
SUMO_ATTR_MINGAP_LAT
@ SUMO_ATTR_MINGAP_LAT
Definition: SUMOXMLDefinitions.h:444
SVS_MOTORCYCLE
@ SVS_MOTORCYCLE
render as a motorcycle
Definition: SUMOVehicleClass.h:60
SVC_COACH
@ SVC_COACH
vehicle is a coach
Definition: SUMOVehicleClass.h:167
SUMO_ATTR_LATALIGNMENT
@ SUMO_ATTR_LATALIGNMENT
Definition: SUMOXMLDefinitions.h:443
SUMO_ATTR_LENGTH
@ SUMO_ATTR_LENGTH
Definition: SUMOXMLDefinitions.h:393
OutputDevice
Static storage of an output device and its base (abstract) implementation.
Definition: OutputDevice.h:63
SUMOVTypeParameter::actionStepLength
SUMOTime actionStepLength
The vehicle type's default actionStepLength [ms], i.e. the interval between two control actions....
Definition: SUMOVTypeParameter.h:225
SUMO_ATTR_MAXSPEED_LAT
@ SUMO_ATTR_MAXSPEED_LAT
Definition: SUMOXMLDefinitions.h:442
SUMOVTypeParameter::VClassDefaultValues::emissionClass
SUMOEmissionClass emissionClass
The emission class of this vehicle.
Definition: SUMOVTypeParameter.h:112
SVC_CUSTOM2
@ SVC_CUSTOM2
is a user-defined type
Definition: SUMOVehicleClass.h:200
OptionsCont.h
SUMOVTypeParameter::cfModel
SumoXMLTag cfModel
The enum-representation of the car-following model to use.
Definition: SUMOVTypeParameter.h:278
LCM_DEFAULT
@ LCM_DEFAULT
Definition: SUMOXMLDefinitions.h:1307
StringUtils::toDouble
static double toDouble(const std::string &sData)
converts a string into the double value described by it by calling the char-type converter
Definition: StringUtils.cpp:345
VTYPEPARS_BOARDING_DURATION
const int VTYPEPARS_BOARDING_DURATION
Definition: SUMOVTypeParameter.h:61
SUMO_ATTR_SPEEDFACTOR
@ SUMO_ATTR_SPEEDFACTOR
Definition: SUMOXMLDefinitions.h:454
MsgHandler.h
SUMOVTypeParameter::impatience
double impatience
The vehicle's impatience (willingness to obstruct others)
Definition: SUMOVTypeParameter.h:243
LATALIGN_CENTER
@ LATALIGN_CENTER
drive in the middle
Definition: SUMOXMLDefinitions.h:1332
OptionsCont::getString
std::string getString(const std::string &name) const
Returns the string-value of the named option (only for Option_String)
Definition: OptionsCont.cpp:201
SUMOVTypeParameter::osgFile
std::string osgFile
3D model file for this class
Definition: SUMOVTypeParameter.h:270
VTYPEPARS_MINGAP_LAT_SET
const int VTYPEPARS_MINGAP_LAT_SET
Definition: SUMOVTypeParameter.h:67
SUMOTime
long long int SUMOTime
Definition: SUMOTime.h:34
OptionsCont::exists
bool exists(const std::string &name) const
Returns the information whether the named option is known.
Definition: OptionsCont.cpp:129
SUMO_ATTR_LOADING_DURATION
@ SUMO_ATTR_LOADING_DURATION
Definition: SUMOXMLDefinitions.h:461
SUMO_TAG_CF_KRAUSS
@ SUMO_TAG_CF_KRAUSS
Definition: SUMOXMLDefinitions.h:275
SVS_TRUCK
@ SVS_TRUCK
render as a transport vehicle
Definition: SUMOVehicleClass.h:76
SUMO_ATTR_COLOR
@ SUMO_ATTR_COLOR
A color information.
Definition: SUMOXMLDefinitions.h:704
SVC_BICYCLE
@ SVC_BICYCLE
vehicle is a bicycle
Definition: SUMOVehicleClass.h:179
OptionsCont::getOptions
static OptionsCont & getOptions()
Retrieves the options.
Definition: OptionsCont.cpp:57
SVC_DELIVERY
@ SVC_DELIVERY
vehicle is a small delivery vehicle
Definition: SUMOVehicleClass.h:169
SUMOVTypeParameter::saved
bool saved
Information whether this type was already saved (needed by routers)
Definition: SUMOVTypeParameter.h:310
VTYPEPARS_OSGFILE_SET
const int VTYPEPARS_OSGFILE_SET
Definition: SUMOVTypeParameter.h:56
SUMOVTypeParameter::carriageLength
double carriageLength
the length of train carriages and locomotive
Definition: SUMOVTypeParameter.h:302
VTYPEPARS_DEFAULT_EMERGENCYDECEL_DECEL
const int VTYPEPARS_DEFAULT_EMERGENCYDECEL_DECEL
Definition: SUMOVTypeParameter.h:77
SUMO_ATTR_CONTAINER_CAPACITY
@ SUMO_ATTR_CONTAINER_CAPACITY
Definition: SUMOXMLDefinitions.h:650
SUMOVTypeParameter::myManoeuverAngleTimes
std::map< int, std::pair< SUMOTime, SUMOTime > > myManoeuverAngleTimes
Map of manoeuver angles versus the times (entry, exit) to execute the manoeuver.
Definition: SUMOVTypeParameter.h:351
SUMO_ATTR_ID
@ SUMO_ATTR_ID
Definition: SUMOXMLDefinitions.h:378
SUMOVTypeParameter::shape
SUMOVehicleShape shape
This class' shape.
Definition: SUMOVTypeParameter.h:267
VTYPEPARS_PROBABILITY_SET
const int VTYPEPARS_PROBABILITY_SET
Definition: SUMOVTypeParameter.h:48
SUMOVTypeParameter::getDefaultImperfection
static double getDefaultImperfection(const SUMOVehicleClass vc=SVC_IGNORING)
Returns the default driver's imperfection (sigma or epsilon in Krauss' model) for the given vehicle c...
Definition: SUMOVTypeParameter.cpp:686
SUMO_TAG_VTYPE
@ SUMO_TAG_VTYPE
description of a vehicle type
Definition: SUMOXMLDefinitions.h:121
PollutantsInterface::getName
static std::string getName(const SUMOEmissionClass c)
Checks whether the string describes a known vehicle class.
Definition: PollutantsInterface.cpp:99
SUMOVTypeParameter::VClassDefaultValues::length
double length
The physical vehicle length.
Definition: SUMOVTypeParameter.h:94
SUMO_ATTR_LANE_CHANGE_MODEL
@ SUMO_ATTR_LANE_CHANGE_MODEL
Definition: SUMOXMLDefinitions.h:456
getVehicleShapeName
std::string getVehicleShapeName(SUMOVehicleShape id)
Returns the class name of the shape class given by its id.
Definition: SUMOVehicleClass.cpp:358
SUMOVTypeParameter::containerCapacity
int containerCapacity
The container capacity of the vehicle.
Definition: SUMOVTypeParameter.h:249
SVC_RAIL
@ SVC_RAIL
vehicle is a not electrified rail
Definition: SUMOVehicleClass.h:188
SVC_RAIL_URBAN
@ SVC_RAIL_URBAN
vehicle is a city rail
Definition: SUMOVehicleClass.h:186
SUMOVTypeParameter::getLCParams
const SubParams & getLCParams() const
Returns the LC parameter.
Definition: SUMOVTypeParameter.cpp:498
Parameterised::writeParams
void writeParams(OutputDevice &device) const
write Params in the given outputdevice
Definition: Parameterised.cpp:154
Parameterised::getParameter
const std::string getParameter(const std::string &key, const std::string &defaultValue="") const
Returns the value for a given key.
Definition: Parameterised.cpp:72
OutputDevice::closeTag
bool closeTag(const std::string &comment="")
Closes the most recently opened tag and optionally adds a comment.
Definition: OutputDevice.cpp:253
VTYPEPARS_CAR_FOLLOW_MODEL
const int VTYPEPARS_CAR_FOLLOW_MODEL
Definition: SUMOVTypeParameter.h:64
SUMOVTypeParameter::onlyReferenced
bool onlyReferenced
Information whether this is a type-stub, being only referenced but not defined (needed by routers)
Definition: SUMOVTypeParameter.h:313
SVC_PRIVATE
@ SVC_PRIVATE
private vehicles
Definition: SUMOVehicleClass.h:141
SVS_UNKNOWN
@ SVS_UNKNOWN
not defined
Definition: SUMOVehicleClass.h:52
SUMOXMLDefinitions::CarFollowModels
static StringBijection< SumoXMLTag > CarFollowModels
car following models
Definition: SUMOXMLDefinitions.h:1398
MAX2
T MAX2(T a, T b)
Definition: StdDefs.h:79
SVS_BICYCLE
@ SVS_BICYCLE
render as a bicycle
Definition: SUMOVehicleClass.h:56
SUMOVTypeParameter::wasSet
bool wasSet(int what) const
Returns whether the given parameter was set.
Definition: SUMOVTypeParameter.h:150
SUMOVTypeParameter::parametersSet
int parametersSet
Information for the router which parameter were set.
Definition: SUMOVTypeParameter.h:307
VTYPEPARS_MAXSPEED_LAT_SET
const int VTYPEPARS_MAXSPEED_LAT_SET
Definition: SUMOVTypeParameter.h:65
SVC_TRAM
@ SVC_TRAM
vehicle is a light rail
Definition: SUMOVehicleClass.h:184
OutputDevice::writeAttr
OutputDevice & writeAttr(const SumoXMLAttr attr, const T &val)
writes a named attribute
Definition: OutputDevice.h:255
RGBColor
Definition: RGBColor.h:39
SVS_DELIVERY
@ SVS_DELIVERY
automated car (with cruise controllers)
Definition: SUMOVehicleClass.h:74
Distribution_Parameterized::getParameter
std::vector< double > & getParameter()
Returns the parameters of this distribution.
Definition: Distribution_Parameterized.cpp:110
SUMO_ATTR_PROB
@ SUMO_ATTR_PROB
Definition: SUMOXMLDefinitions.h:629
VTYPEPARS_LANE_CHANGE_MODEL_SET
const int VTYPEPARS_LANE_CHANGE_MODEL_SET
Definition: SUMOVTypeParameter.h:59
SUMOVTypeParameter::imgFile
std::string imgFile
Image file for this class.
Definition: SUMOVTypeParameter.h:273
SVC_TRUCK
@ SVC_TRUCK
vehicle is a large transport vehicle
Definition: SUMOVehicleClass.h:171
SUMOVTypeParameter::getLCParamString
std::string getLCParamString(const SumoXMLAttr attr, const std::string &defaultValue) const
Returns the named value from the map, or the default if it is not contained there.
Definition: SUMOVTypeParameter.cpp:488
SVC_CUSTOM1
@ SVC_CUSTOM1
is a user-defined type
Definition: SUMOVehicleClass.h:198
SUMOVTypeParameter::VClassDefaultValues::containerCapacity
int containerCapacity
The container capacity of the vehicle.
Definition: SUMOVTypeParameter.h:121
SVS_BUS
@ SVS_BUS
render as a bus
Definition: SUMOVehicleClass.h:82
SUMOVTypeParameter::height
double height
This class' height.
Definition: SUMOVTypeParameter.h:264
PollutantsInterface.h
SUMOVTypeParameter
Structure representing possible vehicle parameter.
Definition: SUMOVTypeParameter.h:86
DEFAULT_PEDESTRIAN_SPEED
const double DEFAULT_PEDESTRIAN_SPEED
SUMOVTypeParameter::jmParameter
SubParams jmParameter
Junction-model parameter.
Definition: SUMOVTypeParameter.h:287
StringBijection::get
T get(const std::string &str) const
Definition: StringBijection.h:97
SVC_HOV
@ SVC_HOV
vehicle is a HOV
Definition: SUMOVehicleClass.h:161
SUMOVTypeParameter::getDefaultAccel
static double getDefaultAccel(const SUMOVehicleClass vc=SVC_IGNORING)
Returns the default acceleration for the given vehicle class This needs to be a function because the ...
Definition: SUMOVTypeParameter.cpp:574
SUMOVTypeParameter::cfParameter
SubParams cfParameter
Car-following parameter.
Definition: SUMOVTypeParameter.h:281
SUMOVTypeParameter::defaultProbability
double defaultProbability
The probability when being added to a distribution without an explicit probability.
Definition: SUMOVTypeParameter.h:228
SUMOVTypeParameter::VClassDefaultValues::maxSpeed
double maxSpeed
The vehicle type's maximum speed [m/s].
Definition: SUMOVTypeParameter.h:100
STEPS2TIME
#define STEPS2TIME(x)
Definition: SUMOTime.h:56
SVC_PASSENGER
@ SVC_PASSENGER
vehicle is a passenger car (a "normal" car)
Definition: SUMOVehicleClass.h:159
SUMO_ATTR_WIDTH
@ SUMO_ATTR_WIDTH
Definition: SUMOXMLDefinitions.h:386
SVC_RAIL_ELECTRIC
@ SVC_RAIL_ELECTRIC
rail vehicle that requires electrified tracks
Definition: SUMOVehicleClass.h:190
SUMOVTypeParameter::getDefaultDecel
static double getDefaultDecel(const SUMOVehicleClass vc=SVC_IGNORING)
Returns the default deceleration for the given vehicle class This needs to be a function because the ...
Definition: SUMOVTypeParameter.cpp:610
OutputDevice.h
VTYPEPARS_ACTIONSTEPLENGTH_SET
const int VTYPEPARS_ACTIONSTEPLENGTH_SET
Definition: SUMOVTypeParameter.h:68
SUMOVTypeParameter::paramRestrictions
std::vector< double > paramRestrictions
cached value of parameters which may restrict access to certain edges
Definition: SUMOVTypeParameter.h:316
SUMO_ATTR_PERSON_CAPACITY
@ SUMO_ATTR_PERSON_CAPACITY
Definition: SUMOXMLDefinitions.h:649
SUMOVTypeParameter::VClassDefaultValues::width
double width
This class' width.
Definition: SUMOVTypeParameter.h:103
SUMOVTypeParameter::boardingDuration
SUMOTime boardingDuration
The time a person needs to board the vehicle.
Definition: SUMOVTypeParameter.h:252
SUMOVTypeParameter::VClassDefaultValues::minGap
double minGap
This class' free space in front of the vehicle itself.
Definition: SUMOVTypeParameter.h:97
SUMOVTypeParameter::minGap
double minGap
This class' free space in front of the vehicle itself.
Definition: SUMOVTypeParameter.h:218
SVS_MOPED
@ SVS_MOPED
render as a moped
Definition: SUMOVehicleClass.h:58
SUMOVTypeParameter::getJMParamString
std::string getJMParamString(const SumoXMLAttr attr, const std::string defaultValue) const
Returns the named value from the map, or the default if it is not contained there.
Definition: SUMOVTypeParameter.cpp:514
SUMOVTypeParameter::width
double width
This class' width.
Definition: SUMOVTypeParameter.h:261
OptionsCont
A storage for options typed value containers)
Definition: OptionsCont.h:89
SUMOVTypeParameter::maxSpeedLat
double maxSpeedLat
The vehicle type's maximum lateral speed [m/s].
Definition: SUMOVTypeParameter.h:293
SUMOVTypeParameter::getCFParam
double getCFParam(const SumoXMLAttr attr, const double defaultValue) const
Returns the named value from the map, or the default if it is not contained there.
Definition: SUMOVTypeParameter.cpp:458
SUMOVTypeParameter::maxSpeed
double maxSpeed
The vehicle type's maximum speed [m/s].
Definition: SUMOVTypeParameter.h:221
SUMOVTypeParameter::getEntryManoeuvreTime
SUMOTime getEntryManoeuvreTime(const int angle) const
Returns the time that will be needed for the vehicle type to execute the (entry) manoeuvre (and be bl...
Definition: SUMOVTypeParameter.cpp:523
SUMOVTypeParameter::personCapacity
int personCapacity
The person capacity of the vehicle.
Definition: SUMOVTypeParameter.h:246
SUMOVTypeParameter::VClassDefaultValues::shape
SUMOVehicleShape shape
This class' shape.
Definition: SUMOVTypeParameter.h:109
VTYPEPARS_SPEEDFACTOR_SET
const int VTYPEPARS_SPEEDFACTOR_SET
Definition: SUMOVTypeParameter.h:49
SVC_VIP
@ SVC_VIP
vip vehicles
Definition: SUMOVehicleClass.h:149
SVC_SHIP
@ SVC_SHIP
is an arbitrary ship
Definition: SUMOVehicleClass.h:195
SUMOVTypeParameter::write
void write(OutputDevice &dev) const
Writes the vtype.
Definition: SUMOVTypeParameter.cpp:348
SVS_RAIL_CAR
@ SVS_RAIL_CAR
render as a (city) rail without locomotive
Definition: SUMOVehicleClass.h:92
SVS_PEDESTRIAN
@ SVS_PEDESTRIAN
render as a pedestrian
Definition: SUMOVehicleClass.h:54
SUMOVTypeParameter::speedFactor
Distribution_Parameterized speedFactor
The factor by which the maximum speed may deviate from the allowed max speed on the street.
Definition: SUMOVTypeParameter.h:231
PollutantsInterface::getClassByName
static SUMOEmissionClass getClassByName(const std::string &eClass, const SUMOVehicleClass vc=SVC_IGNORING)
Checks whether the string describes a known vehicle class.
Definition: PollutantsInterface.cpp:53
SUMOVTypeParameter::VClassDefaultValues::osgFile
std::string osgFile
3D model file for this class
Definition: SUMOVTypeParameter.h:124
VTYPEPARS_LOADING_DURATION
const int VTYPEPARS_LOADING_DURATION
Definition: SUMOVTypeParameter.h:63
OptionsCont::getFloat
double getFloat(const std::string &name) const
Returns the double-value of the named option (only for Option_Float)
Definition: OptionsCont.cpp:208
SUMOVTypeParameter::VClassDefaultValues::locomotiveLength
double locomotiveLength
the length of train locomotive
Definition: SUMOVTypeParameter.h:130
SUMO_ATTR_HEIGHT
@ SUMO_ATTR_HEIGHT
Definition: SUMOXMLDefinitions.h:789
VTYPEPARS_CONTAINER_CAPACITY
const int VTYPEPARS_CONTAINER_CAPACITY
Definition: SUMOVTypeParameter.h:62
OutputDevice::openTag
OutputDevice & openTag(const std::string &xmlElement)
Opens an XML tag.
Definition: OutputDevice.cpp:239
toString
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:47
StringUtils.h
SUMOVTypeParameter::carriageGap
double carriageGap
Definition: SUMOVTypeParameter.h:304
SUMOVTypeParameter::getLCParam
double getLCParam(const SumoXMLAttr attr, const double defaultValue) const
Returns the named value from the map, or the default if it is not contained there.
Definition: SUMOVTypeParameter.cpp:478
SUMOVTypeParameter::getDefaultEmergencyDecel
static double getDefaultEmergencyDecel(const SUMOVehicleClass vc, double decel, double defaultOption)
Returns the default emergency deceleration for the given vehicle class This needs to be a function be...
Definition: SUMOVTypeParameter.cpp:641
SVC_MOPED
@ SVC_MOPED
vehicle is a moped
Definition: SUMOVehicleClass.h:177
SUMOVTypeParameter::latAlignment
LateralAlignment latAlignment
The vehicles desired lateral alignment.
Definition: SUMOVTypeParameter.h:296
SUMO_ATTR_CAR_FOLLOW_MODEL
@ SUMO_ATTR_CAR_FOLLOW_MODEL
Definition: SUMOXMLDefinitions.h:457
SUMO_ATTR_IMPATIENCE
@ SUMO_ATTR_IMPATIENCE
Definition: SUMOXMLDefinitions.h:796
SUMOVTypeParameter::id
std::string id
The vehicle type's id.
Definition: SUMOVTypeParameter.h:212
SVC_TAXI
@ SVC_TAXI
vehicle is a taxi
Definition: SUMOVehicleClass.h:163
SUMO_ATTR_GUISHAPE
@ SUMO_ATTR_GUISHAPE
Definition: SUMOXMLDefinitions.h:790
SUMOVTypeParameter::VClassDefaultValues
struct for default values that depend of VClass
Definition: SUMOVTypeParameter.h:89
VTYPEPARS_DEFAULT_EMERGENCYDECEL_DEFAULT
const int VTYPEPARS_DEFAULT_EMERGENCYDECEL_DEFAULT
Definition: SUMOVTypeParameter.h:76
VTYPEPARS_PERSON_CAPACITY
const int VTYPEPARS_PERSON_CAPACITY
Definition: SUMOVTypeParameter.h:60
SVS_PASSENGER
@ SVS_PASSENGER
render as a passenger vehicle
Definition: SUMOVehicleClass.h:62
SVS_E_VEHICLE
@ SVS_E_VEHICLE
render as a (futuristic) e-vehicle
Definition: SUMOVehicleClass.h:96
SVS_SHIP
@ SVS_SHIP
render as a arbitrary ship
Definition: SUMOVehicleClass.h:100
VTYPEPARS_HEIGHT_SET
const int VTYPEPARS_HEIGHT_SET
Definition: SUMOVTypeParameter.h:54
SUMO_ATTR_VCLASS
@ SUMO_ATTR_VCLASS
Definition: SUMOXMLDefinitions.h:450
SUMOVTypeParameter::VClassDefaultValues::personCapacity
int personCapacity
The person capacity of the vehicle.
Definition: SUMOVTypeParameter.h:118
SUMOVTypeParameter::lcModel
LaneChangeModel lcModel
The lane-change model to use.
Definition: SUMOVTypeParameter.h:290
VTYPEPARS_IMGFILE_SET
const int VTYPEPARS_IMGFILE_SET
Definition: SUMOVTypeParameter.h:57
SUMO_ATTR_MINGAP
@ SUMO_ATTR_MINGAP
Definition: SUMOXMLDefinitions.h:458
config.h
SUMOVTypeParameter::getCFParamString
std::string getCFParamString(const SumoXMLAttr attr, const std::string defaultValue) const
Returns the named value from the map, or the default if it is not contained there.
Definition: SUMOVTypeParameter.cpp:468
EMPREFIX
#define EMPREFIX
Definition: SUMOVTypeParameter.cpp:35
PollutantsInterface
Helper methods for PHEMlight-based emission computation.
Definition: PollutantsInterface.h:51
SVC_TRAILER
@ SVC_TRAILER
vehicle is a large transport vehicle
Definition: SUMOVehicleClass.h:173
SVC_BUS
@ SVC_BUS
vehicle is a bus
Definition: SUMOVehicleClass.h:165
SUMO_ATTR_ACTIONSTEPLENGTH
@ SUMO_ATTR_ACTIONSTEPLENGTH
Definition: SUMOXMLDefinitions.h:449
SUMOVTypeParameter::setManoeuverAngleTimes
void setManoeuverAngleTimes(const SUMOVehicleClass vclass)
Initialise the default mapping between manoeuver angle and times dependant on vehicle class.
Definition: SUMOVTypeParameter.cpp:300
SUMOVTypeParameter::loadingDuration
SUMOTime loadingDuration
The time a container needs to get loaded on the vehicle.
Definition: SUMOVTypeParameter.h:255
SUMOVTypeParameter::color
RGBColor color
The color.
Definition: SUMOVTypeParameter.h:237
SVS_TRUCK_1TRAILER
@ SVS_TRUCK_1TRAILER
render as a transport vehicle with one trailer
Definition: SUMOVehicleClass.h:80
SUMO_ATTR_MANEUVER_ANGLE_TIMES
@ SUMO_ATTR_MANEUVER_ANGLE_TIMES
Class specific timing values for vehicle manoeuvering through angle ranges.
Definition: SUMOXMLDefinitions.h:463
VTYPEPARS_LENGTH_SET
const int VTYPEPARS_LENGTH_SET
Definition: SUMOVTypeParameter.h:45
VTYPEPARS_MANEUVER_ANGLE_TIMES_SET
const int VTYPEPARS_MANEUVER_ANGLE_TIMES_SET
Definition: SUMOVTypeParameter.h:73
SVC_MOTORCYCLE
@ SVC_MOTORCYCLE
vehicle is a motorcycle
Definition: SUMOVehicleClass.h:175
SUMOVTypeParameter::emissionClass
SUMOEmissionClass emissionClass
The emission class of this vehicle.
Definition: SUMOVTypeParameter.h:234
SVS_BUS_COACH
@ SVS_BUS_COACH
render as a coach
Definition: SUMOVehicleClass.h:84
VTYPEPARS_EMISSIONCLASS_SET
const int VTYPEPARS_EMISSIONCLASS_SET
Definition: SUMOVTypeParameter.h:50
VTYPEPARS_COLOR_SET
const int VTYPEPARS_COLOR_SET
Definition: SUMOVTypeParameter.h:51
VTYPEPARS_SHAPE_SET
const int VTYPEPARS_SHAPE_SET
Definition: SUMOVTypeParameter.h:55
SUMOVTypeParameter::VClassDefaultValues::height
double height
This class' height.
Definition: SUMOVTypeParameter.h:106
SumoXMLAttr
SumoXMLAttr
Numbers representing SUMO-XML - attributes.
Definition: SUMOXMLDefinitions.h:372
SUMOVTypeParameter.h
VTYPEPARS_WIDTH_SET
const int VTYPEPARS_WIDTH_SET
Definition: SUMOVTypeParameter.h:53
SUMOVTypeParameter::vehicleClass
SUMOVehicleClass vehicleClass
The vehicle's class.
Definition: SUMOVTypeParameter.h:240
VTYPEPARS_IMPATIENCE_SET
const int VTYPEPARS_IMPATIENCE_SET
Definition: SUMOVTypeParameter.h:58
DEFAULT_VEH_PROB
const double DEFAULT_VEH_PROB
SUMOVTypeParameter::getJMParam
double getJMParam(const SumoXMLAttr attr, const double defaultValue) const
Returns the named value from the map, or the default if it is not contained there.
Definition: SUMOVTypeParameter.cpp:504
SUMO_ATTR_EMISSIONCLASS
@ SUMO_ATTR_EMISSIONCLASS
Definition: SUMOXMLDefinitions.h:795
SUMOVTypeParameter::VClassDefaultValues::speedFactor
Distribution_Parameterized speedFactor
The factor by which the maximum speed may deviate from the allowed max speed on the street.
Definition: SUMOVTypeParameter.h:115
SUMOXMLDefinitions.h
VTYPEPARS_MAXSPEED_SET
const int VTYPEPARS_MAXSPEED_SET
Definition: SUMOVTypeParameter.h:47
VTYPEPARS_VEHICLECLASS_SET
const int VTYPEPARS_VEHICLECLASS_SET
Definition: SUMOVTypeParameter.h:52
SUMOVTypeParameter::getDefault
static const SUMOVTypeParameter & getDefault()
return the default parameters, this is a function due to the http://www.parashift....
Definition: SUMOVTypeParameter.cpp:702
SUMOVTypeParameter::minGapLat
double minGapLat
The vehicle type's minimum lateral gap [m].
Definition: SUMOVTypeParameter.h:299
SVS_RAIL
@ SVS_RAIL
render as a rail
Definition: SUMOVehicleClass.h:90
SUMOVTypeParameter::getManoeuverAngleTimesS
std::string getManoeuverAngleTimesS() const
Returns myManoeuverAngleTimes as a string for xml output.
Definition: SUMOVTypeParameter.cpp:549
SUMOVTypeParameter::VClassDefaultValues::VClassDefaultValues
VClassDefaultValues()
default constructor
Definition: SUMOVTypeParameter.cpp:250