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