Eclipse SUMO - Simulation of Urban MObility
SUMOVehicleParameter.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 /****************************************************************************/
17 // Structure representing possible vehicle parameter
18 /****************************************************************************/
19 
20 
21 // ===========================================================================
22 // included modules
23 // ===========================================================================
24 
25 #include <config.h>
29 #include <utils/common/ToString.h>
32 
33 #include "SUMOVehicleParameter.h"
34 
35 // ===========================================================================
36 // member method definitions
37 // ===========================================================================
38 
40  : tag(SUMO_TAG_NOTHING), vtypeid(DEFAULT_VTYPE_ID), color(RGBColor::DEFAULT_COLOR),
41  depart(-1), departProcedure(DEPART_GIVEN),
42  departLane(0), departLaneProcedure(DEPART_LANE_DEFAULT),
43  departPos(0), departPosProcedure(DEPART_POS_DEFAULT),
44  departPosLat(0), departPosLatProcedure(DEPART_POSLAT_DEFAULT),
45  departSpeed(-1), departSpeedProcedure(DEPART_SPEED_DEFAULT),
46  arrivalLane(0), arrivalLaneProcedure(ARRIVAL_LANE_DEFAULT),
47  arrivalPos(0), arrivalPosProcedure(ARRIVAL_POS_DEFAULT),
48  arrivalPosLat(0), arrivalPosLatProcedure(ARRIVAL_POSLAT_DEFAULT),
49  arrivalSpeed(-1), arrivalSpeedProcedure(ARRIVAL_SPEED_DEFAULT),
50  repetitionNumber(-1), repetitionsDone(-1), repetitionOffset(-1), repetitionProbability(-1), repetitionEnd(-1),
51  line(), fromTaz(), toTaz(), personNumber(0), containerNumber(0), parametersSet(0) {
52 }
53 
54 
56 }
57 
58 
59 bool
60 SUMOVehicleParameter::defaultOptionOverrides(const OptionsCont& oc, const std::string& optionName) const {
61  return oc.exists(optionName) && oc.isSet(optionName) && oc.getBool("defaults-override");
62 }
63 
64 
65 void
66 SUMOVehicleParameter::write(OutputDevice& dev, const OptionsCont& oc, const SumoXMLTag tag, const std::string& typeID) const {
68  if (typeID == "") {
71  }
72  } else {
73  dev.writeAttr(SUMO_ATTR_TYPE, typeID);
74  }
75  // write depart depending of tag
76  if ((tag == SUMO_TAG_FLOW) || (tag == SUMO_TAG_PERSONFLOW)) {
78  } else {
80  }
81  // optional parameter
82  // departlane
83  if (wasSet(VEHPARS_DEPARTLANE_SET) && !defaultOptionOverrides(oc, "departlane")) {
85  } else if (oc.exists("departlane") && oc.isSet("departlane")) {
86  dev.writeNonEmptyAttr(SUMO_ATTR_DEPARTLANE, oc.getString("departlane"));
87  }
88  // departpos
89  if (wasSet(VEHPARS_DEPARTPOS_SET) && !defaultOptionOverrides(oc, "departpos")) {
91  } else if (oc.exists("departpos") && oc.isSet("departpos")) {
92  dev.writeNonEmptyAttr(SUMO_ATTR_DEPARTPOS, oc.getString("departpos"));
93  }
94  // departPosLat
97  }
98 
99  // departspeed
100  if (wasSet(VEHPARS_DEPARTSPEED_SET) && !defaultOptionOverrides(oc, "departspeed")) {
102  } else if (oc.exists("departspeed") && oc.isSet("departspeed")) {
103  dev.writeNonEmptyAttr(SUMO_ATTR_DEPARTSPEED, oc.getString("departspeed"));
104  }
105  // arrivallane
106  if (wasSet(VEHPARS_ARRIVALLANE_SET) && !defaultOptionOverrides(oc, "arrivallane")) {
108  } else if (oc.exists("arrivallane") && oc.isSet("arrivallane")) {
109  dev.writeNonEmptyAttr(SUMO_ATTR_ARRIVALLANE, oc.getString("arrivallane"));
110  }
111  // arrivalpos
112  if (wasSet(VEHPARS_ARRIVALPOS_SET) && !defaultOptionOverrides(oc, "arrivalpos")) {
114  } else if (oc.exists("arrivalpos") && oc.isSet("arrivalpos")) {
115  dev.writeNonEmptyAttr(SUMO_ATTR_ARRIVALPOS, oc.getString("arrivalpos"));
116  }
117  // arrivalPosLat
120  }
121  // arrivalspeed
122  if (wasSet(VEHPARS_ARRIVALSPEED_SET) && !defaultOptionOverrides(oc, "arrivalspeed")) {
124  } else if (oc.exists("arrivalspeed") && oc.isSet("arrivalspeed")) {
125  dev.writeNonEmptyAttr(SUMO_ATTR_ARRIVALSPEED, oc.getString("arrivalspeed"));
126  }
127  // color
128  if (wasSet(VEHPARS_COLOR_SET)) {
130  }
131  // line
132  if (wasSet(VEHPARS_LINE_SET)) {
134  }
135  // from TAZ
138  }
139  // to TAZ
140  if (wasSet(VEHPARS_TO_TAZ_SET)) {
142  }
143  // person number
146  }
147  // container number
150  }
151 }
152 
153 
155  Parameterised(),
156  startPos(0),
157  endPos(0),
158  duration(0),
159  until(0),
160  triggered(false),
161  containerTriggered(false),
162  parking(false) {
163 }
164 
165 
166 void
168  dev.openTag(SUMO_TAG_STOP);
169  if (busstop != "") {
170  dev.writeAttr(SUMO_ATTR_BUS_STOP, busstop);
171  }
172  if (containerstop != "") {
173  dev.writeAttr(SUMO_ATTR_CONTAINER_STOP, containerstop);
174  }
175  if (parkingarea != "") {
176  dev.writeAttr(SUMO_ATTR_PARKING_AREA, parkingarea);
177  }
178  if (busstop == "" && containerstop == "" && parkingarea == "") {
179  dev.writeAttr(SUMO_ATTR_LANE, lane);
180  if ((parametersSet & STOP_START_SET) != 0) {
181  dev.writeAttr(SUMO_ATTR_STARTPOS, startPos);
182  }
183  if ((parametersSet & STOP_END_SET) != 0) {
184  dev.writeAttr(SUMO_ATTR_ENDPOS, endPos);
185  }
186  }
187  if (duration >= 0) {
188  dev.writeAttr(SUMO_ATTR_DURATION, time2string(duration));
189  }
190  if (until >= 0) {
192  }
193  if ((parametersSet & STOP_TRIGGER_SET) != 0) {
194  dev.writeAttr(SUMO_ATTR_TRIGGERED, triggered);
195  }
197  dev.writeAttr(SUMO_ATTR_CONTAINER_TRIGGERED, containerTriggered);
198  }
199  if ((parametersSet & STOP_PARKING_SET) != 0) {
200  dev.writeAttr(SUMO_ATTR_PARKING, parking);
201  }
202  if ((parametersSet & STOP_EXPECTED_SET) != 0) {
203  dev.writeAttr(SUMO_ATTR_EXPECTED, awaitedPersons);
204  }
206  dev.writeAttr(SUMO_ATTR_EXPECTED_CONTAINERS, awaitedContainers);
207  }
208  if ((parametersSet & STOP_TRIP_ID_SET) != 0) {
209  dev.writeAttr(SUMO_ATTR_TRIP_ID, tripId);
210  }
211  if ((parametersSet & STOP_LINE_SET) != 0) {
213  }
214  dev.closeTag();
215 }
216 
217 
218 bool
219 SUMOVehicleParameter::parseDepart(const std::string& val, const std::string& element, const std::string& id,
220  SUMOTime& depart, DepartDefinition& dd, std::string& error) {
221  if (val == "triggered") {
222  dd = DEPART_TRIGGERED;
223  } else if (val == "containerTriggered") {
225  } else if (val == "now") {
226  // only used via TraCI. depart must be set by the calling code
227  dd = DEPART_NOW;
228  } else {
229  try {
230  depart = string2time(val);
231  dd = DEPART_GIVEN;
232  if (depart < 0) {
233  error = "Negative departure time in the definition of '" + id + "'.";
234  return false;
235  }
236  } catch (...) {
237  if (id.empty()) {
238  error = "Invalid departure time for " + element + ". Must be one of (\"triggered\", \"containerTriggered\", \"now\", or a float >= 0)";
239  } else {
240  error = "Invalid departure time for " + element + " '" + id + "';\n must be one of (\"triggered\", \"containerTriggered\", \"now\", or a float >= 0)";
241  }
242  return false;
243  }
244  }
245  return true;
246 }
247 
248 
249 bool
250 SUMOVehicleParameter::parseDepartLane(const std::string& val, const std::string& element, const std::string& id,
251  int& lane, DepartLaneDefinition& dld, std::string& error) {
252  bool ok = true;
253  if (val == "random") {
254  dld = DEPART_LANE_RANDOM;
255  } else if (val == "free") {
256  dld = DEPART_LANE_FREE;
257  } else if (val == "allowed") {
259  } else if (val == "best") {
260  dld = DEPART_LANE_BEST_FREE;
261  } else if (val == "first") {
263  } else {
264  try {
265  lane = StringUtils::toInt(val);
266  dld = DEPART_LANE_GIVEN;
267  if (lane < 0) {
268  ok = false;
269  }
270  } catch (...) {
271  ok = false;
272  lane = 0;
273  }
274  }
275  if (!ok) {
276  if (id.empty()) {
277  error = "Invalid departLane definition for " + element + ". Must be one of (\"random\", \"free\", \"allowed\", \"best\", \"first\", or an int>=0)";
278  } else {
279  error = "Invalid departLane definition for " + element + " '" + id + "';\n must be one of (\"random\", \"free\", \"allowed\", \"best\", \"first\", or an int>=0)";
280  }
281  }
282  return ok;
283 }
284 
285 
286 bool
287 SUMOVehicleParameter::parseDepartPos(const std::string& val, const std::string& element, const std::string& id,
288  double& pos, DepartPosDefinition& dpd, std::string& error) {
289  bool ok = true;
290  if (val == "random") {
291  dpd = DEPART_POS_RANDOM;
292  } else if (val == "random_free") {
294  } else if (val == "free") {
295  dpd = DEPART_POS_FREE;
296  } else if (val == "base") {
297  dpd = DEPART_POS_BASE;
298  } else if (val == "last") {
299  dpd = DEPART_POS_LAST;
300  } else {
301  try {
302  pos = StringUtils::toDouble(val);
303  dpd = DEPART_POS_GIVEN;
304  } catch (...) {
305  ok = false;
306  pos = 0;
307  }
308  }
309  if (!ok) {
310  if (id.empty()) {
311  error = "Invalid departPos definition for " + element + ". Must be one of (\"random\", \"random_free\", \"free\", \"base\", \"last\" or a float)";
312  } else {
313  error = "Invalid departPos definition for " + element + " '" + id + "';\n must be one of (\"random\", \"random_free\", \"free\", \"base\", \"last\" or a float)";
314  }
315  }
316  return ok;
317 }
318 
319 
320 bool
321 SUMOVehicleParameter::parseDepartPosLat(const std::string& val, const std::string& element, const std::string& id,
322  double& pos, DepartPosLatDefinition& dpd, std::string& error) {
323  bool ok = true;
324  if (val == "random") {
325  dpd = DEPART_POSLAT_RANDOM;
326  } else if (val == "random_free") {
328  } else if (val == "free") {
329  dpd = DEPART_POSLAT_FREE;
330  } else if (val == "right") {
331  dpd = DEPART_POSLAT_RIGHT;
332  } else if (val == "center") {
333  dpd = DEPART_POSLAT_CENTER;
334  } else if (val == "left") {
335  dpd = DEPART_POSLAT_LEFT;
336  } else {
337  try {
338  pos = StringUtils::toDouble(val);
339  dpd = DEPART_POSLAT_GIVEN;
340  } catch (...) {
341  ok = false;
342  pos = 0;
343  }
344  }
345  if (!ok) {
346  if (id.empty()) {
347  error = "Invalid departPosLat definition for " + element + ". Must be one of (\"random\", \"random_free\", \"free\", \"right\", \"center\", \"left\", or a float)";
348  } else {
349  error = "Invalid departPosLat definition for " + element + " '" + id + "';\n must be one of (\"random\", \"random_free\", \"free\", \"right\", \"center\", \"left\", or a float)";
350  }
351  }
352  return ok;
353 }
354 
355 
356 bool
357 SUMOVehicleParameter::parseDepartSpeed(const std::string& val, const std::string& element, const std::string& id,
358  double& speed, DepartSpeedDefinition& dsd, std::string& error) {
359  bool ok = true;
360  if (val == "random") {
361  dsd = DEPART_SPEED_RANDOM;
362  } else if (val == "max") {
363  dsd = DEPART_SPEED_MAX;
364  } else if (val == "desired") {
365  dsd = DEPART_SPEED_DESIRED;
366  } else if (val == "speedLimit") {
367  dsd = DEPART_SPEED_LIMIT;
368  } else {
369  try {
370  speed = StringUtils::toDouble(val);
371  dsd = DEPART_SPEED_GIVEN;
372  if (speed < 0) {
373  ok = false;
374  }
375  } catch (...) {
376  ok = false;
377  speed = -1;
378  }
379  }
380  if (!ok) {
381  if (id.empty()) {
382  error = "Invalid departSpeed definition for " + element + ". Must be one of (\"random\", \"max\", or a float>=0)";
383  } else {
384  error = "Invalid departSpeed definition for " + element + " '" + id + "';\n must be one of (\"random\", \"max\", or a float>=0)";
385  }
386  }
387  return ok;
388 }
389 
390 
391 bool
392 SUMOVehicleParameter::parseArrivalLane(const std::string& val, const std::string& element, const std::string& id,
393  int& lane, ArrivalLaneDefinition& ald, std::string& error) {
394  bool ok = true;
395  if (val == "current") {
396  ald = ARRIVAL_LANE_CURRENT;
397  } else {
398  try {
399  lane = StringUtils::toInt(val);
400  ald = ARRIVAL_LANE_GIVEN;
401  if (lane < 0) {
402  ok = false;
403  }
404  } catch (...) {
405  ok = false;
406  lane = 0;
407  }
408  }
409  if (!ok) {
410  if (id.empty()) {
411  error = "Invalid arrivalLane definition for " + element + ". Must be one of (\"current\", or an int>=0)";
412  } else {
413  error = "Invalid arrivalLane definition for " + element + " '" + id + "';\n must be one of (\"current\", or an int>=0)";
414  }
415  }
416  return ok;
417 }
418 
419 
420 bool
421 SUMOVehicleParameter::parseArrivalPos(const std::string& val, const std::string& element, const std::string& id,
422  double& pos, ArrivalPosDefinition& apd, std::string& error) {
423  bool ok = true;
424  if (val == "random") {
425  apd = ARRIVAL_POS_RANDOM;
426  } else if (val == "center") {
427  apd = ARRIVAL_POS_CENTER;
428  } else if (val == "max") {
429  apd = ARRIVAL_POS_MAX;
430  } else {
431  try {
432  pos = StringUtils::toDouble(val);
433  apd = ARRIVAL_POS_GIVEN;
434  } catch (...) {
435  ok = false;
436  pos = 0;
437  }
438  }
439  if (!ok) {
440  if (id.empty()) {
441  error = "Invalid arrivalPos definition for " + element + ". Must be one of (\"random\", \"max\", or a float)";
442  } else {
443  error = "Invalid arrivalPos definition for " + element + " '" + id + "';\n must be one of (\"random\", \"max\", or a float)";
444  }
445  }
446  return ok;
447 }
448 
449 
450 bool
451 SUMOVehicleParameter::parseArrivalPosLat(const std::string& val, const std::string& element, const std::string& id,
452  double& pos, ArrivalPosLatDefinition& apd, std::string& error) {
453  bool ok = true;
454  if (val == "right") {
455  apd = ARRIVAL_POSLAT_RIGHT;
456  } else if (val == "center") {
457  apd = ARRIVAL_POSLAT_CENTER;
458  } else if (val == "left") {
459  apd = ARRIVAL_POSLAT_LEFT;
460  } else {
461  try {
462  pos = StringUtils::toDouble(val);
463  apd = ARRIVAL_POSLAT_GIVEN;
464  } catch (...) {
465  ok = false;
466  pos = 0;
467  }
468  }
469  if (!ok) {
470  if (id.empty()) {
471  error = "Invalid arrivalPosLat definition for " + element + ". Must be one of (\"right\", \"center\", \"left\", or a float)";
472  } else {
473  error = "Invalid arrivalPosLat definition for " + element + " '" + id + "';\n must be one of (\"right\", \"center\", \"left\", or a float)";
474  }
475  }
476  return ok;
477 }
478 
479 
480 bool
481 SUMOVehicleParameter::parseArrivalSpeed(const std::string& val, const std::string& element, const std::string& id,
482  double& speed, ArrivalSpeedDefinition& asd, std::string& error) {
483  bool ok = true;
484  if (val == "current") {
485  asd = ARRIVAL_SPEED_CURRENT;
486  } else {
487  try {
488  speed = StringUtils::toDouble(val);
489  if (speed < 0) {
490  ok = false;
491  }
492  asd = ARRIVAL_SPEED_GIVEN;
493  } catch (...) {
494  ok = false;
495  speed = -1;
496  }
497  }
498  if (!ok) {
499  if (id.empty()) {
500  error = "Invalid arrivalSpeed definition for " + element + ". Must be one of (\"current\", or a float>=0)";
501  } else {
502  error = "Invalid arrivalSpeed definition for " + element + " '" + id + "';\n must be one of (\"current\", or a float>=0)";
503  }
504  }
505  return ok;
506 }
507 
508 
509 double
510 SUMOVehicleParameter::interpretEdgePos(double pos, double maximumValue, SumoXMLAttr attr, const std::string& id) {
511  if (pos < 0) {
512  pos = maximumValue + pos;
513  }
514  if (pos > maximumValue) {
515  WRITE_WARNING("Invalid " + toString(attr) + " " + toString(pos) + " given for " + id + ". Using edge end instead.");
516  pos = maximumValue;
517  }
518  return pos;
519 }
520 
521 
522 bool
523 SUMOVehicleParameter::parsePersonModes(const std::string& modes, const std::string& element, const std::string& id, SVCPermissions& modeSet, std::string& error) {
524  // separte modes in different strings, and check if modes are valid
525  for (StringTokenizer st(modes); st.hasNext();) {
526  const std::string mode = st.next();
527  if (mode == "car") {
528  modeSet |= SVC_PASSENGER;
529  } else if (mode == "bicycle") {
530  modeSet |= SVC_BICYCLE;
531  } else if (mode == "public") {
532  modeSet |= SVC_BUS;
533  } else {
534  if (id.empty()) {
535  error = "Unknown person mode '" + mode + "'. Must be a combination of (\"car\", \"bicycle\" or \"public\")";
536  } else {
537  error = "Unknown person mode '" + mode + "' for " + element + " '" + id + "';\n must be a combination of (\"car\", \"bicycle\" or \"public\")";
538  }
539  return false;
540  }
541  }
542  return true;
543 }
544 
545 
546 std::string
549  return "triggered";
551  return "containerTriggered";
552  } else {
553  return time2string(depart);
554  }
555 }
556 
557 
558 std::string
560  std::string val;
561  switch (departLaneProcedure) {
562  case DEPART_LANE_GIVEN:
563  val = toString(departLane);
564  break;
565  case DEPART_LANE_RANDOM:
566  val = "random";
567  break;
568  case DEPART_LANE_FREE:
569  val = "free";
570  break;
572  val = "allowed";
573  break;
575  val = "best";
576  break;
578  val = "first";
579  break;
580  case DEPART_LANE_DEFAULT:
581  default:
582  break;
583  }
584  return val;
585 }
586 
587 
588 std::string
590  std::string val;
591  switch (departPosProcedure) {
592  case DEPART_POS_GIVEN:
593  val = toString(departPos);
594  break;
595  case DEPART_POS_RANDOM:
596  val = "random";
597  break;
599  val = "random_free";
600  break;
601  case DEPART_POS_FREE:
602  val = "free";
603  break;
604  case DEPART_POS_LAST:
605  val = "last";
606  break;
607  case DEPART_POS_BASE:
608  val = "base";
609  break;
610  case DEPART_POS_DEFAULT:
611  default:
612  break;
613  }
614  return val;
615 }
616 
617 
618 std::string
620  std::string val;
621  switch (departPosLatProcedure) {
622  case DEPART_POSLAT_GIVEN:
623  val = toString(departPos);
624  break;
626  val = "random";
627  break;
629  val = "random_free";
630  break;
631  case DEPART_POSLAT_FREE:
632  val = "free";
633  break;
634  case DEPART_POSLAT_RIGHT:
635  val = "right";
636  break;
638  val = "center";
639  break;
640  case DEPART_POSLAT_LEFT:
641  val = "left";
642  break;
644  default:
645  break;
646  }
647  return val;
648 }
649 
650 
651 std::string
653  std::string val;
654  switch (departSpeedProcedure) {
655  case DEPART_SPEED_GIVEN:
656  val = toString(departSpeed);
657  break;
658  case DEPART_SPEED_RANDOM:
659  val = "random";
660  break;
661  case DEPART_SPEED_MAX:
662  val = "max";
663  break;
665  val = "desired";
666  break;
667  case DEPART_SPEED_LIMIT:
668  val = "speedLimit";
669  break;
671  default:
672  break;
673  }
674  return val;
675 }
676 
677 
678 std::string
680  std::string val;
681  switch (arrivalLaneProcedure) {
682  case ARRIVAL_LANE_GIVEN:
683  val = toString(arrivalLane);
684  break;
686  val = "current";
687  break;
689  default:
690  break;
691  }
692  return val;
693 }
694 
695 
696 std::string
698  std::string val;
699  switch (arrivalPosProcedure) {
700  case ARRIVAL_POS_GIVEN:
701  val = toString(arrivalPos);
702  break;
703  case ARRIVAL_POS_RANDOM:
704  val = "random";
705  break;
706  case ARRIVAL_POS_CENTER:
707  val = "center";
708  break;
709  case ARRIVAL_POS_MAX:
710  val = "max";
711  break;
712  case ARRIVAL_POS_DEFAULT:
713  default:
714  break;
715  }
716  return val;
717 }
718 
719 
720 std::string
722  std::string val;
723  switch (arrivalPosLatProcedure) {
725  val = toString(arrivalPos);
726  break;
728  val = "right";
729  break;
731  val = "center";
732  break;
733  case ARRIVAL_POSLAT_LEFT:
734  val = "left";
735  break;
737  default:
738  break;
739  }
740  return val;
741 }
742 
743 
744 std::string
746  std::string val;
747  switch (arrivalSpeedProcedure) {
748  case ARRIVAL_SPEED_GIVEN:
749  val = toString(arrivalSpeed);
750  break;
752  val = "current";
753  break;
755  default:
756  break;
757  }
758  return val;
759 }
760 
761 /****************************************************************************/
OptionsCont::isSet
bool isSet(const std::string &name, bool failOnNonExistant=true) const
Returns the information whether the named option is set.
Definition: OptionsCont.cpp:136
SUMO_ATTR_TYPE
Definition: SUMOXMLDefinitions.h:382
SUMOVehicleParameter::personNumber
int personNumber
The static number of persons in the vehicle when it departs (not including boarding persons)
Definition: SUMOVehicleParameter.h:644
SUMOVehicleParameter::containerNumber
int containerNumber
The static number of containers in the vehicle when it departs.
Definition: SUMOVehicleParameter.h:647
ToString.h
ARRIVAL_POS_GIVEN
The arrival position is given.
Definition: SUMOVehicleParameter.h:228
SUMOVehicleParameter::wasSet
bool wasSet(int what) const
Returns whether the given parameter was set.
Definition: SUMOVehicleParameter.h:306
SUMO_ATTR_DEPART
Definition: SUMOXMLDefinitions.h:432
ArrivalPosDefinition
ArrivalPosDefinition
Possible ways to choose the arrival position.
Definition: SUMOVehicleParameter.h:224
SUMOVehicleParameter::parametersSet
int parametersSet
Information for the router which parameter were set, TraCI may modify this (whe changing color)
Definition: SUMOVehicleParameter.h:650
WRITE_WARNING
#define WRITE_WARNING(msg)
Definition: MsgHandler.h:239
Parameterised
An upper class for objects with additional parameters.
Definition: Parameterised.h:43
DEPART_POSLAT_RANDOM_FREE
If a fixed number of random choices fails, a free lateral position is chosen.
Definition: SUMOVehicleParameter.h:176
SUMO_ATTR_PARKING_AREA
Definition: SUMOXMLDefinitions.h:768
SUMO_ATTR_CONTAINER_STOP
Definition: SUMOXMLDefinitions.h:767
SUMOVehicleParameter::arrivalSpeedProcedure
ArrivalSpeedDefinition arrivalSpeedProcedure
Information how the vehicle's end speed shall be chosen.
Definition: SUMOVehicleParameter.h:531
ARRIVAL_SPEED_DEFAULT
No information given; use default.
Definition: SUMOVehicleParameter.h:266
SUMOVehicleParameter::color
RGBColor color
The vehicle's color, TraCI may change this.
Definition: SUMOVehicleParameter.h:471
ARRIVAL_LANE_GIVEN
The arrival lane is given.
Definition: SUMOVehicleParameter.h:212
SUMOVehicleParameter::getArrivalPos
std::string getArrivalPos() const
obtain arrival pos parameter in string format
Definition: SUMOVehicleParameter.cpp:697
OutputDevice
Static storage of an output device and its base (abstract) implementation.
Definition: OutputDevice.h:64
ARRIVAL_POS_RANDOM
The arrival position is chosen randomly.
Definition: SUMOVehicleParameter.h:230
SUMOVehicleParameter::getDepartSpeed
std::string getDepartSpeed() const
obtain depart speed parameter in string format
Definition: SUMOVehicleParameter.cpp:652
SUMO_ATTR_UNTIL
Definition: SUMOXMLDefinitions.h:666
ARRIVAL_POSLAT_GIVEN
The position is given.
Definition: SUMOVehicleParameter.h:248
OptionsCont.h
StringTokenizer::hasNext
bool hasNext()
returns the information whether further substrings exist
Definition: StringTokenizer.cpp:95
SUMOVehicleParameter::departSpeed
double departSpeed
(optional) The initial speed of the vehicle
Definition: SUMOVehicleParameter.h:500
SUMO_ATTR_LINE
Definition: SUMOXMLDefinitions.h:772
ARRIVAL_LANE_DEFAULT
No information given; use default.
Definition: SUMOVehicleParameter.h:210
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:313
SUMOVehicleParameter::defaultOptionOverrides
bool defaultOptionOverrides(const OptionsCont &oc, const std::string &optionName) const
Returns whether the defaults shall be used.
Definition: SUMOVehicleParameter.cpp:60
SUMOVehicleParameter::vtypeid
std::string vtypeid
The vehicle's type id.
Definition: SUMOVehicleParameter.h:468
SUMOVehicleParameter::departPosProcedure
DepartPosDefinition departPosProcedure
Information how the vehicle shall choose the departure position.
Definition: SUMOVehicleParameter.h:491
MsgHandler.h
SUMOVehicleParameter::parseDepartSpeed
static bool parseDepartSpeed(const std::string &val, const std::string &element, const std::string &id, double &speed, DepartSpeedDefinition &dsd, std::string &error)
Validates a given departSpeed value.
Definition: SUMOVehicleParameter.cpp:357
SUMO_ATTR_ARRIVALPOS_LAT
Definition: SUMOXMLDefinitions.h:439
DEPART_POSLAT_LEFT
At the leftmost side of the lane.
Definition: SUMOVehicleParameter.h:170
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:202
DEPART_POS_DEFAULT
No information given; use default.
Definition: SUMOVehicleParameter.h:138
SUMOVehicleParameter::parseDepartLane
static bool parseDepartLane(const std::string &val, const std::string &element, const std::string &id, int &lane, DepartLaneDefinition &dld, std::string &error)
Validates a given departLane value.
Definition: SUMOVehicleParameter.cpp:250
ARRIVAL_SPEED_CURRENT
The current speed is used.
Definition: SUMOVehicleParameter.h:270
DepartPosLatDefinition
DepartPosLatDefinition
Definition: SUMOVehicleParameter.h:160
ArrivalPosLatDefinition
ArrivalPosLatDefinition
Possible ways to choose the departure position.
Definition: SUMOVehicleParameter.h:244
DEPART_LANE_BEST_FREE
The least occupied lane from best lanes.
Definition: SUMOVehicleParameter.h:124
DEPART_POS_LAST
Insert behind the last vehicle as close as possible to still allow the specified departSpeed....
Definition: SUMOVehicleParameter.h:148
SUMOTime
long long int SUMOTime
Definition: SUMOTime.h:35
OptionsCont::exists
bool exists(const std::string &name) const
Returns the information whether the named option is known.
Definition: OptionsCont.cpp:130
DepartDefinition
DepartDefinition
Possible ways to depart.
Definition: SUMOVehicleParameter.h:94
VEHPARS_ARRIVALSPEED_SET
const int VEHPARS_ARRIVALSPEED_SET
Definition: SUMOVehicleParameter.h:59
OptionsCont::getBool
bool getBool(const std::string &name) const
Returns the boolean-value of the named option (only for Option_Bool)
Definition: OptionsCont.cpp:223
SUMO_ATTR_COLOR
A color information.
Definition: SUMOXMLDefinitions.h:701
ArrivalLaneDefinition
ArrivalLaneDefinition
Possible ways to choose the arrival lane.
Definition: SUMOVehicleParameter.h:208
SVC_BICYCLE
vehicle is a bicycle
Definition: SUMOVehicleClass.h:180
SUMOVehicleParameter::departProcedure
DepartDefinition departProcedure
Information how the vehicle shall choose the depart time.
Definition: SUMOVehicleParameter.h:479
SUMOVehicleParameter::parseArrivalPosLat
static bool parseArrivalPosLat(const std::string &val, const std::string &element, const std::string &id, double &pos, ArrivalPosLatDefinition &apd, std::string &error)
Validates a given arrivalPosLat value.
Definition: SUMOVehicleParameter.cpp:451
SUMO_ATTR_ARRIVALPOS
Definition: SUMOXMLDefinitions.h:438
SUMO_ATTR_ID
Definition: SUMOXMLDefinitions.h:379
SUMO_TAG_NOTHING
invalid tag
Definition: SUMOXMLDefinitions.h:44
SUMO_ATTR_LANE
Definition: SUMOXMLDefinitions.h:635
SUMO_ATTR_FROM_TAZ
Definition: SUMOXMLDefinitions.h:644
SUMOVehicleParameter::parsePersonModes
static bool parsePersonModes(const std::string &modes, const std::string &element, const std::string &id, SVCPermissions &modeSet, std::string &error)
Validates a given person modes value.
Definition: SUMOVehicleParameter.cpp:523
SUMO_ATTR_ENDPOS
Definition: SUMOXMLDefinitions.h:795
STOP_TRIP_ID_SET
const int STOP_TRIP_ID_SET
Definition: SUMOVehicleParameter.h:81
SUMOVehicleParameter::parseArrivalPos
static bool parseArrivalPos(const std::string &val, const std::string &element, const std::string &id, double &pos, ArrivalPosDefinition &apd, std::string &error)
Validates a given arrivalPos value.
Definition: SUMOVehicleParameter.cpp:421
SUMOVehicleParameter::SUMOVehicleParameter
SUMOVehicleParameter()
Constructor.
Definition: SUMOVehicleParameter.cpp:39
SumoXMLTag
SumoXMLTag
Numbers representing SUMO-XML - element names.
Definition: SUMOXMLDefinitions.h:42
DEPART_POSLAT_RIGHT
At the rightmost side of the lane.
Definition: SUMOVehicleParameter.h:166
SUMOVehicleParameter::depart
SUMOTime depart
Definition: SUMOVehicleParameter.h:476
STOP_START_SET
const int STOP_START_SET
Definition: SUMOVehicleParameter.h:75
SUMOVehicleParameter::Stop::Stop
Stop()
constructor
Definition: SUMOVehicleParameter.cpp:154
VEHPARS_DEPARTSPEED_SET
const int VEHPARS_DEPARTSPEED_SET
Definition: SUMOVehicleParameter.h:50
DEPART_SPEED_LIMIT
The maximum lane speed is used (speedLimit)
Definition: SUMOVehicleParameter.h:198
OutputDevice::closeTag
bool closeTag(const std::string &comment="")
Closes the most recently opened tag and optionally adds a comment.
Definition: OutputDevice.cpp:254
SUMOVehicleParameter::tag
SumoXMLTag tag
The vehicle tag.
Definition: SUMOVehicleParameter.h:459
SUMOVehicleParameter.h
SUMOVehicleParameter::getDepartPosLat
std::string getDepartPosLat() const
obtain depart pos lat parameter in string format
Definition: SUMOVehicleParameter.cpp:619
SUMO_ATTR_BEGIN
weights: time range begin
Definition: SUMOXMLDefinitions.h:675
DEPART_LANE_ALLOWED_FREE
The least occupied lane from lanes which allow the continuation.
Definition: SUMOVehicleParameter.h:122
ARRIVAL_POSLAT_DEFAULT
No information given; use default.
Definition: SUMOVehicleParameter.h:246
VEHPARS_ARRIVALLANE_SET
const int VEHPARS_ARRIVALLANE_SET
Definition: SUMOVehicleParameter.h:57
SUMO_ATTR_PERSON_NUMBER
Definition: SUMOXMLDefinitions.h:649
SUMOVehicleParameter::line
std::string line
The vehicle's line (mainly for public transport)
Definition: SUMOVehicleParameter.h:555
DEPART_POSLAT_FREE
A free lateral position is chosen.
Definition: SUMOVehicleParameter.h:174
OutputDevice::writeAttr
OutputDevice & writeAttr(const SumoXMLAttr attr, const T &val)
writes a named attribute
Definition: OutputDevice.h:256
RGBColor
Definition: RGBColor.h:40
SUMO_ATTR_ARRIVALSPEED
Definition: SUMOXMLDefinitions.h:440
SUMO_ATTR_TRIP_ID
Definition: SUMOXMLDefinitions.h:774
DEPART_LANE_RANDOM
The lane is chosen randomly.
Definition: SUMOVehicleParameter.h:118
ARRIVAL_POSLAT_RIGHT
At the rightmost side of the lane.
Definition: SUMOVehicleParameter.h:250
SUMO_TAG_FLOW
a flow definitio nusing a from-to edges instead of a route (used by router)
Definition: SUMOXMLDefinitions.h:150
VEHPARS_ARRIVALPOS_SET
const int VEHPARS_ARRIVALPOS_SET
Definition: SUMOVehicleParameter.h:58
SUMO_ATTR_STARTPOS
Definition: SUMOXMLDefinitions.h:794
SUMOVehicleParameter::arrivalLaneProcedure
ArrivalLaneDefinition arrivalLaneProcedure
Information how the vehicle shall choose the lane to arrive on.
Definition: SUMOVehicleParameter.h:513
SUMOVehicleParameter::parseDepartPosLat
static bool parseDepartPosLat(const std::string &val, const std::string &element, const std::string &id, double &pos, DepartPosLatDefinition &dpd, std::string &error)
Validates a given departPosLat value.
Definition: SUMOVehicleParameter.cpp:321
DEPART_POS_FREE
A free position is chosen.
Definition: SUMOVehicleParameter.h:144
SVCPermissions
int SVCPermissions
bitset where each bit declares whether a certain SVC may use this edge/lane
Definition: SUMOVehicleClass.h:219
SUMOVehicleParameter::getArrivalPosLat
std::string getArrivalPosLat() const
obtain arrival pos lat parameter in string format
Definition: SUMOVehicleParameter.cpp:721
DEPART_SPEED_DESIRED
The maximum lane speed is used (speedLimit * speedFactor)
Definition: SUMOVehicleParameter.h:196
SUMOVehicleParameter::getDepart
std::string getDepart() const
obtain depart parameter in string format
Definition: SUMOVehicleParameter.cpp:547
ARRIVAL_POSLAT_LEFT
At the leftmost side of the lane.
Definition: SUMOVehicleParameter.h:254
VEHPARS_COLOR_SET
const int VEHPARS_COLOR_SET
Definition: SUMOVehicleParameter.h:46
DEPART_SPEED_GIVEN
The speed is given.
Definition: SUMOVehicleParameter.h:190
SUMOVehicleParameter::parseArrivalLane
static bool parseArrivalLane(const std::string &val, const std::string &element, const std::string &id, int &lane, ArrivalLaneDefinition &ald, std::string &error)
Validates a given arrivalLane value.
Definition: SUMOVehicleParameter.cpp:392
StringTokenizer
Definition: StringTokenizer.h:62
SUMO_TAG_STOP
stop for vehicles
Definition: SUMOXMLDefinitions.h:179
DEFAULT_VTYPE_ID
const std::string DEFAULT_VTYPE_ID
SUMO_ATTR_DEPARTPOS_LAT
Definition: SUMOXMLDefinitions.h:435
ARRIVAL_POS_DEFAULT
No information given; use default.
Definition: SUMOVehicleParameter.h:226
DEPART_LANE_GIVEN
The lane is given.
Definition: SUMOVehicleParameter.h:116
SVC_PASSENGER
vehicle is a passenger car (a "normal" car)
Definition: SUMOVehicleClass.h:160
SUMO_ATTR_DEPARTSPEED
Definition: SUMOXMLDefinitions.h:436
SUMOVehicleParameter::~SUMOVehicleParameter
virtual ~SUMOVehicleParameter()
Destructor.
Definition: SUMOVehicleParameter.cpp:55
SUMO_ATTR_DEPARTLANE
Definition: SUMOXMLDefinitions.h:433
OutputDevice.h
SUMO_ATTR_TRIGGERED
Definition: SUMOXMLDefinitions.h:796
SUMOVehicleParameter::arrivalPos
double arrivalPos
(optional) The position the vehicle shall arrive on
Definition: SUMOVehicleParameter.h:516
VEHPARS_LINE_SET
const int VEHPARS_LINE_SET
Definition: SUMOVehicleParameter.h:60
SUMOVehicleParameter::fromTaz
std::string fromTaz
The vehicle's origin zone (district)
Definition: SUMOVehicleParameter.h:558
SUMOVehicleParameter::arrivalPosProcedure
ArrivalPosDefinition arrivalPosProcedure
Information how the vehicle shall choose the arrival position.
Definition: SUMOVehicleParameter.h:519
SUMO_ATTR_CONTAINER_NUMBER
Definition: SUMOXMLDefinitions.h:650
time2string
std::string time2string(SUMOTime t)
Definition: SUMOTime.cpp:65
SUMOVehicleParameter::parseArrivalSpeed
static bool parseArrivalSpeed(const std::string &val, const std::string &element, const std::string &id, double &speed, ArrivalSpeedDefinition &asd, std::string &error)
Validates a given arrivalSpeed value.
Definition: SUMOVehicleParameter.cpp:481
SUMOVehicleParameter::parseDepart
static bool parseDepart(const std::string &val, const std::string &element, const std::string &id, SUMOTime &depart, DepartDefinition &dd, std::string &error)
Validates a given depart value.
Definition: SUMOVehicleParameter.cpp:219
SUMOVehicleParameter::Stop::write
void write(OutputDevice &dev) const
Writes the stop as XML.
Definition: SUMOVehicleParameter.cpp:167
OptionsCont
A storage for options typed value containers)
Definition: OptionsCont.h:90
DEPART_TRIGGERED
The departure is person triggered.
Definition: SUMOVehicleParameter.h:98
VEHPARS_ARRIVALPOSLAT_SET
const int VEHPARS_ARRIVALPOSLAT_SET
Definition: SUMOVehicleParameter.h:68
ARRIVAL_LANE_CURRENT
The current lane shall be used.
Definition: SUMOVehicleParameter.h:214
DEPART_SPEED_RANDOM
The speed is chosen randomly.
Definition: SUMOVehicleParameter.h:192
DEPART_POS_RANDOM
The position is chosen randomly.
Definition: SUMOVehicleParameter.h:142
ARRIVAL_SPEED_GIVEN
The speed is given.
Definition: SUMOVehicleParameter.h:268
SUMOVehicleParameter::arrivalLane
int arrivalLane
Definition: SUMOVehicleParameter.h:510
SUMOVehicleParameter::getDepartPos
std::string getDepartPos() const
obtain depart pos parameter in string format
Definition: SUMOVehicleParameter.cpp:589
SUMOVehicleParameter::getDepartLane
std::string getDepartLane() const
obtain depart lane parameter in string format
Definition: SUMOVehicleParameter.cpp:559
string2time
SUMOTime string2time(const std::string &r)
Definition: SUMOTime.cpp:42
VEHPARS_DEPARTLANE_SET
const int VEHPARS_DEPARTLANE_SET
Definition: SUMOVehicleParameter.h:48
OutputDevice::writeNonEmptyAttr
OutputDevice & writeNonEmptyAttr(const SumoXMLAttr attr, const std::string &val)
writes a string attribute only if it is not the empty string and not the string "default"
Definition: OutputDevice.h:289
SUMOVehicleParameter::write
void write(OutputDevice &dev, const OptionsCont &oc, const SumoXMLTag tag=SUMO_TAG_VEHICLE, const std::string &typeID="") const
Writes the parameters as a beginning element.
Definition: SUMOVehicleParameter.cpp:66
DepartLaneDefinition
DepartLaneDefinition
Possible ways to choose a lane on depart.
Definition: SUMOVehicleParameter.h:112
SUMOVehicleParameter::departLane
int departLane
(optional) The lane the vehicle shall depart from (index in edge)
Definition: SUMOVehicleParameter.h:482
OutputDevice::openTag
OutputDevice & openTag(const std::string &xmlElement)
Opens an XML tag.
Definition: OutputDevice.cpp:240
toString
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:48
VEHPARS_VTYPE_SET
const int VEHPARS_VTYPE_SET
Definition: SUMOVehicleParameter.h:47
StringUtils.h
SUMOVehicleParameter::departLaneProcedure
DepartLaneDefinition departLaneProcedure
Information how the vehicle shall choose the lane to depart from.
Definition: SUMOVehicleParameter.h:485
StringUtils::toInt
static int toInt(const std::string &sData)
converts a string into the integer value described by it by calling the char-type converter,...
Definition: StringUtils.cpp:246
SUMO_ATTR_DURATION
Definition: SUMOXMLDefinitions.h:665
VEHPARS_DEPARTPOSLAT_SET
const int VEHPARS_DEPARTPOSLAT_SET
Definition: SUMOVehicleParameter.h:67
SUMO_ATTR_EXPECTED
Definition: SUMOXMLDefinitions.h:799
VEHPARS_CONTAINER_NUMBER_SET
const int VEHPARS_CONTAINER_NUMBER_SET
Definition: SUMOVehicleParameter.h:66
SUMO_ATTR_EXPECTED_CONTAINERS
Definition: SUMOXMLDefinitions.h:800
VEHPARS_DEPARTPOS_SET
const int VEHPARS_DEPARTPOS_SET
Definition: SUMOVehicleParameter.h:49
DEPART_POSLAT_DEFAULT
No information given; use default.
Definition: SUMOVehicleParameter.h:162
SUMO_ATTR_TO_TAZ
Definition: SUMOXMLDefinitions.h:645
VEHPARS_PERSON_NUMBER_SET
const int VEHPARS_PERSON_NUMBER_SET
Definition: SUMOVehicleParameter.h:65
VEHPARS_FROM_TAZ_SET
const int VEHPARS_FROM_TAZ_SET
Definition: SUMOVehicleParameter.h:61
DEPART_POSLAT_RANDOM
The lateral position is chosen randomly.
Definition: SUMOVehicleParameter.h:172
DEPART_POS_RANDOM_FREE
If a fixed number of random choices fails, a free position is chosen.
Definition: SUMOVehicleParameter.h:150
SUMO_ATTR_CONTAINER_TRIGGERED
Definition: SUMOXMLDefinitions.h:797
DepartPosDefinition
DepartPosDefinition
Possible ways to choose the departure position.
Definition: SUMOVehicleParameter.h:136
DEPART_GIVEN
The time is given.
Definition: SUMOVehicleParameter.h:96
ARRIVAL_POSLAT_CENTER
At the center of the lane.
Definition: SUMOVehicleParameter.h:252
SUMOVehicleParameter::arrivalPosLatProcedure
ArrivalPosLatDefinition arrivalPosLatProcedure
Information how the vehicle shall choose the lateral arrival position.
Definition: SUMOVehicleParameter.h:525
STOP_EXPECTED_SET
const int STOP_EXPECTED_SET
Definition: SUMOVehicleParameter.h:78
DEPART_SPEED_MAX
The maximum safe speed is used.
Definition: SUMOVehicleParameter.h:194
DEPART_LANE_DEFAULT
No information given; use default.
Definition: SUMOVehicleParameter.h:114
VEHPARS_TO_TAZ_SET
const int VEHPARS_TO_TAZ_SET
Definition: SUMOVehicleParameter.h:62
SUMO_ATTR_PARKING
Definition: SUMOXMLDefinitions.h:798
STOP_TRIGGER_SET
const int STOP_TRIGGER_SET
Definition: SUMOVehicleParameter.h:76
STOP_CONTAINER_TRIGGER_SET
const int STOP_CONTAINER_TRIGGER_SET
Definition: SUMOVehicleParameter.h:79
ARRIVAL_POS_MAX
The maximum arrival position is used.
Definition: SUMOVehicleParameter.h:234
config.h
DEPART_POS_BASE
Back-at-zero position.
Definition: SUMOVehicleParameter.h:146
DEPART_SPEED_DEFAULT
No information given; use default.
Definition: SUMOVehicleParameter.h:188
SUMO_TAG_PERSONFLOW
Definition: SUMOXMLDefinitions.h:300
SVC_BUS
vehicle is a bus
Definition: SUMOVehicleClass.h:166
STOP_EXPECTED_CONTAINERS_SET
const int STOP_EXPECTED_CONTAINERS_SET
Definition: SUMOVehicleParameter.h:80
STOP_PARKING_SET
const int STOP_PARKING_SET
Definition: SUMOVehicleParameter.h:77
StringTokenizer.h
DepartSpeedDefinition
DepartSpeedDefinition
Possible ways to choose the departure speed.
Definition: SUMOVehicleParameter.h:186
STOP_END_SET
const int STOP_END_SET
Definition: SUMOVehicleParameter.h:74
SUMO_ATTR_DEPARTPOS
Definition: SUMOXMLDefinitions.h:434
SUMOVehicleParameter::toTaz
std::string toTaz
The vehicle's destination zone (district)
Definition: SUMOVehicleParameter.h:561
ARRIVAL_POS_CENTER
Half the road length.
Definition: SUMOVehicleParameter.h:232
DEPART_POS_GIVEN
The position is given.
Definition: SUMOVehicleParameter.h:140
SUMOVehicleParameter::parseDepartPos
static bool parseDepartPos(const std::string &val, const std::string &element, const std::string &id, double &pos, DepartPosDefinition &dpd, std::string &error)
Validates a given departPos value.
Definition: SUMOVehicleParameter.cpp:287
SUMOVehicleParameter::departPosLatProcedure
DepartPosLatDefinition departPosLatProcedure
Information how the vehicle shall choose the lateral departure position.
Definition: SUMOVehicleParameter.h:497
DEPART_POSLAT_CENTER
At the center of the lane.
Definition: SUMOVehicleParameter.h:168
DEPART_CONTAINER_TRIGGERED
The departure is container triggered.
Definition: SUMOVehicleParameter.h:100
SUMO_ATTR_BUS_STOP
Definition: SUMOXMLDefinitions.h:766
SUMOVehicleParameter::getArrivalLane
std::string getArrivalLane() const
obtain arrival lane parameter in string format
Definition: SUMOVehicleParameter.cpp:679
SumoXMLAttr
SumoXMLAttr
Numbers representing SUMO-XML - attributes.
Definition: SUMOXMLDefinitions.h:373
SUMOVehicleParameter::getArrivalSpeed
std::string getArrivalSpeed() const
obtain arrival speed parameter in string format
Definition: SUMOVehicleParameter.cpp:745
DEPART_POSLAT_GIVEN
The position is given.
Definition: SUMOVehicleParameter.h:164
DEPART_LANE_FREE
The least occupied lane is used.
Definition: SUMOVehicleParameter.h:120
SUMO_ATTR_ARRIVALLANE
Definition: SUMOXMLDefinitions.h:437
DEPART_LANE_FIRST_ALLOWED
The rightmost lane the vehicle may use.
Definition: SUMOVehicleParameter.h:126
SUMOVehicleParameter::interpretEdgePos
static double interpretEdgePos(double pos, double maximumValue, SumoXMLAttr attr, const std::string &id)
Interprets negative edge positions and fits them onto a given edge.
Definition: SUMOVehicleParameter.cpp:510
STOP_LINE_SET
const int STOP_LINE_SET
Definition: SUMOVehicleParameter.h:82
SUMOVehicleParameter::departPos
double departPos
(optional) The position the vehicle shall depart from
Definition: SUMOVehicleParameter.h:488
SUMOVehicleParameter::departSpeedProcedure
DepartSpeedDefinition departSpeedProcedure
Information how the vehicle's initial speed shall be chosen.
Definition: SUMOVehicleParameter.h:503
DEPART_NOW
The vehicle is discarded if emission fails (not fully implemented yet)
Definition: SUMOVehicleParameter.h:102
SUMOVehicleParameter::arrivalSpeed
double arrivalSpeed
(optional) The final speed of the vehicle (not used yet)
Definition: SUMOVehicleParameter.h:528
ArrivalSpeedDefinition
ArrivalSpeedDefinition
Possible ways to choose the arrival speed.
Definition: SUMOVehicleParameter.h:264