Eclipse SUMO - Simulation of Urban MObility
SUMOVehicleParserHelper.cpp
Go to the documentation of this file.
1 /****************************************************************************/
2 // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3 // Copyright (C) 2008-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 /****************************************************************************/
18 // Helper methods for parsing vehicle attributes
19 /****************************************************************************/
20 
21 
22 // ===========================================================================
23 // included modules
24 // ===========================================================================
25 #include <config.h>
26 
32 #include <utils/common/ToString.h>
38 
40 
41 
42 // ===========================================================================
43 // static members
44 // ===========================================================================
45 
48 std::set<SumoXMLAttr> SUMOVehicleParserHelper::allowedJMAttrs;
49 
50 
51 // ===========================================================================
52 // method definitions
53 // ===========================================================================
54 
56 SUMOVehicleParserHelper::parseFlowAttributes(const SUMOSAXAttributes& attrs, const bool hardFail, const SUMOTime beginDefault, const SUMOTime endDefault, bool isPerson) {
57  bool ok = true;
58  bool abortCreation = true;
59  // first parse ID
60  std::string id = parseID(attrs, SUMO_TAG_FLOW);
61  // check if ID is valid
62  if (!id.empty()) {
64  return handleError(hardFail, abortCreation, "Invalid flow id '" + id + "'.");
65  }
67  return handleError(hardFail, abortCreation,
68  "At most one of '" + attrs.getName(SUMO_ATTR_PERIOD) +
69  "' and '" + attrs.getName(SUMO_ATTR_VEHSPERHOUR) +
70  "' has to be given in the definition of flow '" + id + "'.");
71  }
73  return handleError(hardFail, abortCreation,
74  "At most one of '" + attrs.getName(SUMO_ATTR_PERIOD) +
75  "' and '" + attrs.getName(SUMO_ATTR_PROB) +
76  "' has to be given in the definition of flow '" + id + "'.");
77  }
79  return handleError(hardFail, abortCreation,
80  "At most one of '" + attrs.getName(SUMO_ATTR_PROB) +
81  "' and '" + attrs.getName(SUMO_ATTR_VEHSPERHOUR) +
82  "' has to be given in the definition of flow '" + id + "'.");
83  }
87  return handleError(hardFail, abortCreation,
88  "If '" + attrs.getName(SUMO_ATTR_PERIOD) +
89  "', '" + attrs.getName(SUMO_ATTR_VEHSPERHOUR) +
90  "' or '" + attrs.getName(SUMO_ATTR_PROB) +
91  "' are given at most one of '" + attrs.getName(SUMO_ATTR_END) +
92  "' and '" + attrs.getName(SUMO_ATTR_NUMBER) +
93  "' are allowed in flow '" + id + "'.");
94  }
95  } else {
96  if (!attrs.hasAttribute(SUMO_ATTR_NUMBER)) {
97  return handleError(hardFail, abortCreation,
98  "At least one of '" + attrs.getName(SUMO_ATTR_PERIOD) +
99  "', '" + attrs.getName(SUMO_ATTR_VEHSPERHOUR) +
100  "', '" + attrs.getName(SUMO_ATTR_PROB) +
101  "', and '" + attrs.getName(SUMO_ATTR_NUMBER) +
102  "' is needed in flow '" + id + "'.");
103  }
104  }
106  ret->id = id;
107  if (isPerson) {
109  }
110  try {
111  parseCommonAttributes(attrs, hardFail, ret, "flow");
112  } catch (ProcessError&) {
113  delete ret;
114  throw;
115  }
116  // set tag
117  if (ret->routeid.empty()) {
118  ret->tag = SUMO_TAG_FLOW;
119  } else {
120  ret->tag = SUMO_TAG_ROUTEFLOW;
121  }
122  // parse repetition information
123  if (attrs.hasAttribute(SUMO_ATTR_PERIOD)) {
125  ret->repetitionOffset = attrs.getSUMOTimeReporting(SUMO_ATTR_PERIOD, id.c_str(), ok);
126  }
127  if (attrs.hasAttribute(SUMO_ATTR_VEHSPERHOUR)) {
129  const double vph = attrs.get<double>(SUMO_ATTR_VEHSPERHOUR, id.c_str(), ok);
130  if (ok && vph <= 0) {
131  delete ret;
132  return handleError(hardFail, abortCreation, "Invalid repetition rate in the definition of flow '" + id + "'.");
133  }
134  if (ok && vph != 0) {
135  ret->repetitionOffset = TIME2STEPS(3600. / vph);
136  }
137  }
140  const double vph = attrs.get<double>(SUMO_ATTR_PERSONSPERHOUR, id.c_str(), ok);
141  if (ok && vph <= 0) {
142  delete ret;
143  return handleError(hardFail, abortCreation, "Invalid repetition rate in the definition of personFlow '" + id + "'.");
144  }
145  if (ok && vph != 0) {
146  ret->repetitionOffset = TIME2STEPS(3600. / vph);
147  }
148  }
149  if (attrs.hasAttribute(SUMO_ATTR_PROB)) {
151  ret->repetitionProbability = attrs.get<double>(SUMO_ATTR_PROB, id.c_str(), ok);
152  if (ok && (ret->repetitionProbability <= 0 || ret->repetitionProbability > 1)) {
153  delete ret;
154  return handleError(hardFail, abortCreation, "Invalid repetition probability in the definition of flow '" + id + "'.");
155  }
156  }
157 
158  ret->depart = beginDefault;
159  if (attrs.hasAttribute(SUMO_ATTR_BEGIN)) {
160  ret->depart = attrs.getSUMOTimeReporting(SUMO_ATTR_BEGIN, id.c_str(), ok);
161  }
162  if (ok && ret->depart < 0) {
163  delete ret;
164  return handleError(hardFail, abortCreation, "Negative begin time in the definition of flow '" + id + "'.");
165  }
166  ret->repetitionEnd = endDefault;
167  if (ret->repetitionEnd < 0) {
169  }
170  if (attrs.hasAttribute(SUMO_ATTR_END)) {
171  ret->repetitionEnd = attrs.getSUMOTimeReporting(SUMO_ATTR_END, id.c_str(), ok);
173  } else if (!attrs.hasAttribute(SUMO_ATTR_NUMBER) &&
174  // see SUMOTIME_MAXSTRING (which differs slightly from SUMOTime_MAX)
175  (endDefault >= TIME2STEPS(9223372036854773) || endDefault < 0)) {
176  WRITE_WARNING("Undefined end for flow '" + id + "', defaulting to 24hour duration.");
177  ret->repetitionEnd = ret->depart + TIME2STEPS(24 * 3600);
178  }
179  if (ok && ret->repetitionEnd < ret->depart) {
180  delete ret;
181  return handleError(hardFail, abortCreation, "Flow '" + id + "' ends before its begin time.");
182  }
183  if (attrs.hasAttribute(SUMO_ATTR_NUMBER)) {
184  ret->repetitionNumber = attrs.get<int>(SUMO_ATTR_NUMBER, id.c_str(), ok);
186  if (ret->repetitionNumber == 0) {
187  WRITE_WARNING("Flow '" + id + "' has 0 vehicles; will skip it.");
188  } else {
189  if (ok && ret->repetitionNumber < 0) {
190  delete ret;
191  return handleError(hardFail, abortCreation, "Negative repetition number in the definition of flow '" + id + "'.");
192  }
193  if (ok && ret->repetitionOffset < 0) {
194  ret->repetitionOffset = (ret->repetitionEnd - ret->depart) / ret->repetitionNumber;
195  }
196  }
197  ret->repetitionEnd = ret->depart + ret->repetitionNumber * ret->repetitionOffset;
198  } else {
199  // interpret repetitionNumber
200  if (ok && ret->repetitionProbability > 0) {
201  ret->repetitionNumber = std::numeric_limits<int>::max();
202  } else {
203  if (ok && ret->repetitionOffset <= 0) {
204  delete ret;
205  return handleError(hardFail, abortCreation, "Invalid repetition rate in the definition of flow '" + id + "'.");
206  }
207  if (ret->repetitionEnd == SUMOTime_MAX) {
208  ret->repetitionNumber = std::numeric_limits<int>::max();
209  } else {
210  const double repLength = (double)(ret->repetitionEnd - ret->depart);
211  ret->repetitionNumber = (int)ceil(repLength / ret->repetitionOffset);
212  }
213  }
214  }
215  if (!ok) {
216  delete ret;
217  return handleError(hardFail, abortCreation, "Flow cannot be created");
218  }
219  return ret;
220  } else {
221  if (hardFail) {
222  throw ProcessError("Flow cannot be created");
223  } else {
224  return nullptr;
225  }
226  }
227 }
228 
229 
231 SUMOVehicleParserHelper::parseVehicleAttributes(const SUMOSAXAttributes& attrs, const bool hardFail, const bool optionalID, const bool skipDepart, const bool isPerson) {
232  bool ok = true;
233  std::string id, errorMsg;
234  // for certain vehicles, ID can be optional
235  if (optionalID) {
236  id = attrs.getOpt<std::string>(SUMO_ATTR_ID, nullptr, ok, "");
237  } else {
238  // parse ID
239  id = parseID(attrs, isPerson ? SUMO_TAG_PERSON : SUMO_TAG_VEHICLE);
240  }
241  // only continue if id is valid, or if is optional
242  if (optionalID || !id.empty()) {
244  ret->id = id;
245  if (isPerson) {
247  }
248  try {
249  parseCommonAttributes(attrs, hardFail, ret, "vehicle");
250  if (!skipDepart) {
251  const std::string helper = attrs.get<std::string>(SUMO_ATTR_DEPART, ret->id.c_str(), ok);
252  if (!ok || !SUMOVehicleParameter::parseDepart(helper, "vehicle", ret->id, ret->depart, ret->departProcedure, errorMsg)) {
253  throw ProcessError(errorMsg);
254  }
255  }
256  } catch (ProcessError&) {
257  delete ret;
258  if (hardFail) {
259  throw;
260  } else {
261  WRITE_ERROR(errorMsg);
262  return nullptr;
263  }
264  }
265  // set tag
266  if (isPerson) {
267  ret->tag = SUMO_TAG_PERSON;
268  } else if (ret->routeid.empty()) {
269  ret->tag = SUMO_TAG_TRIP;
270  } else {
271  ret->tag = SUMO_TAG_VEHICLE;
272  }
273  return ret;
274  } else {
275  if (hardFail) {
276  if (isPerson) {
277  throw ProcessError("Person cannot be created");
278  } else {
279  throw ProcessError("Vehicle cannot be created");
280  }
281  } else {
282  if (isPerson) {
283  WRITE_ERROR("Person cannot be created");
284  } else {
285  WRITE_ERROR("Vehicle cannot be created");
286  }
287  return nullptr;
288  }
289  }
290 }
291 
292 std::string
294  bool ok = true;
295  std::string id;
296  // first check if attrs contain an ID
297  if (attrs.hasAttribute(SUMO_ATTR_ID)) {
298  id = attrs.get<std::string>(SUMO_ATTR_ID, nullptr, ok);
300  return id;
301  } else if (id.empty()) {
302  // add extra information for empty IDs
303  WRITE_ERROR("Invalid " + toString(element) + " id '" + id + "'.");
304  } else {
305  WRITE_ERROR("Invalid " + toString(element) + " id '" + id + "'. Contains invalid characters.");
306  }
307  } else {
308  WRITE_ERROR("Attribute '" + toString(SUMO_ATTR_ID) + "' is missing in definition of " + toString(element));
309  }
310  // return empty (invalid) ID
311  return "";
312 }
313 
314 
315 void
316 SUMOVehicleParserHelper::parseCommonAttributes(const SUMOSAXAttributes& attrs, const bool hardFail, SUMOVehicleParameter* ret, std::string element) {
317  //ret->refid = attrs.getStringSecure(SUMO_ATTR_REFID, "");
318  bool ok = true;
319  bool abortCreation = true;
320  // parse route information
321  if (attrs.hasAttribute(SUMO_ATTR_ROUTE)) {
322  ret->parametersSet |= VEHPARS_ROUTE_SET; // !!! needed?
323  ret->routeid = attrs.get<std::string>(SUMO_ATTR_ROUTE, ret->id.c_str(), ok);
324  }
325  // parse type information
326  if (attrs.hasAttribute(SUMO_ATTR_TYPE)) {
327  ret->parametersSet |= VEHPARS_VTYPE_SET; // !!! needed?
328  ret->vtypeid = attrs.get<std::string>(SUMO_ATTR_TYPE, ret->id.c_str(), ok);
329  }
330  // parse line information
331  if (attrs.hasAttribute(SUMO_ATTR_LINE)) {
332  ret->parametersSet |= VEHPARS_LINE_SET; // !!! needed?
333  ret->line = attrs.get<std::string>(SUMO_ATTR_LINE, ret->id.c_str(), ok);
334  }
335  // parse zone information
336  if (attrs.hasAttribute(SUMO_ATTR_FROM_TAZ)) {
338  ret->fromTaz = attrs.get<std::string>(SUMO_ATTR_FROM_TAZ, ret->id.c_str(), ok);
339  }
340  if (attrs.hasAttribute(SUMO_ATTR_TO_TAZ)) {
342  ret->toTaz = attrs.get<std::string>(SUMO_ATTR_TO_TAZ, ret->id.c_str(), ok);
343  }
344  // parse reroute information
345  if (attrs.getOpt<bool>(SUMO_ATTR_REROUTE, nullptr, ok, false)) {
347  }
348 
349  std::string error;
350  // parse depart lane information
351  if (attrs.hasAttribute(SUMO_ATTR_DEPARTLANE)) {
352  const std::string helper = attrs.get<std::string>(SUMO_ATTR_DEPARTLANE, ret->id.c_str(), ok);
353  int lane;
355  if (SUMOVehicleParameter::parseDepartLane(helper, element, ret->id, lane, dld, error)) {
357  ret->departLane = lane;
358  ret->departLaneProcedure = dld;
359  } else {
360  handleError(hardFail, abortCreation, error);
361  }
362  }
363  // parse depart position information
364  if (attrs.hasAttribute(SUMO_ATTR_DEPARTPOS)) {
365  const std::string helper = attrs.get<std::string>(SUMO_ATTR_DEPARTPOS, ret->id.c_str(), ok);
366  double pos;
368  if (SUMOVehicleParameter::parseDepartPos(helper, element, ret->id, pos, dpd, error)) {
370  ret->departPos = pos;
371  ret->departPosProcedure = dpd;
372  } else {
373  handleError(hardFail, abortCreation, error);
374  }
375  }
376  // parse lateral depart position information
378  const std::string helper = attrs.get<std::string>(SUMO_ATTR_DEPARTPOS_LAT, ret->id.c_str(), ok);
379  double pos;
381  if (SUMOVehicleParameter::parseDepartPosLat(helper, element, ret->id, pos, dpd, error)) {
383  ret->departPosLat = pos;
384  ret->departPosLatProcedure = dpd;
385  } else {
386  handleError(hardFail, abortCreation, error);
387  }
388  }
389  // parse depart speed information
390  if (attrs.hasAttribute(SUMO_ATTR_DEPARTSPEED)) {
391  std::string helper = attrs.get<std::string>(SUMO_ATTR_DEPARTSPEED, ret->id.c_str(), ok);
392  double speed;
394  if (SUMOVehicleParameter::parseDepartSpeed(helper, element, ret->id, speed, dsd, error)) {
396  ret->departSpeed = speed;
397  ret->departSpeedProcedure = dsd;
398  } else {
399  handleError(hardFail, abortCreation, error);
400  }
401  }
402  // parse arrival lane information
403  if (attrs.hasAttribute(SUMO_ATTR_ARRIVALLANE)) {
404  std::string helper = attrs.get<std::string>(SUMO_ATTR_ARRIVALLANE, ret->id.c_str(), ok);
405  int lane;
407  if (SUMOVehicleParameter::parseArrivalLane(helper, element, ret->id, lane, ald, error)) {
409  ret->arrivalLane = lane;
410  ret->arrivalLaneProcedure = ald;
411  } else {
412  handleError(hardFail, abortCreation, error);
413  }
414  }
415  // parse arrival position information
416  if (attrs.hasAttribute(SUMO_ATTR_ARRIVALPOS)) {
417  std::string helper = attrs.get<std::string>(SUMO_ATTR_ARRIVALPOS, ret->id.c_str(), ok);
418  double pos;
420  if (SUMOVehicleParameter::parseArrivalPos(helper, element, ret->id, pos, apd, error)) {
422  ret->arrivalPos = pos;
423  ret->arrivalPosProcedure = apd;
424  } else {
425  handleError(hardFail, abortCreation, error);
426  }
427  }
428  // parse lateral arrival position information
430  std::string helper = attrs.get<std::string>(SUMO_ATTR_ARRIVALPOS_LAT, ret->id.c_str(), ok);
431  double pos;
433  if (SUMOVehicleParameter::parseArrivalPosLat(helper, element, ret->id, pos, apd, error)) {
435  ret->arrivalPosLat = pos;
436  ret->arrivalPosLatProcedure = apd;
437  } else {
438  handleError(hardFail, abortCreation, error);
439  }
440  }
441  // parse arrival speed information
443  std::string helper = attrs.get<std::string>(SUMO_ATTR_ARRIVALSPEED, ret->id.c_str(), ok);
444  double speed;
446  if (SUMOVehicleParameter::parseArrivalSpeed(helper, element, ret->id, speed, asd, error)) {
448  ret->arrivalSpeed = speed;
449  ret->arrivalSpeedProcedure = asd;
450  } else {
451  handleError(hardFail, abortCreation, error);
452  }
453  }
454  // parse color
455  if (attrs.hasAttribute(SUMO_ATTR_COLOR)) {
457  ret->color = attrs.get<RGBColor>(SUMO_ATTR_COLOR, ret->id.c_str(), ok);
458  } else {
460  }
461  // parse person number
463  int personNumber = attrs.get<int>(SUMO_ATTR_PERSON_NUMBER, ret->id.c_str(), ok);
464  if (personNumber >= 0) {
466  ret->personNumber = personNumber;
467  } else {
468  handleError(hardFail, abortCreation, toString(SUMO_ATTR_PERSON_NUMBER) + " cannot be negative");
469  }
470  }
471  // parse container number
473  int containerNumber = attrs.get<int>(SUMO_ATTR_CONTAINER_NUMBER, ret->id.c_str(), ok);
474  if (containerNumber >= 0) {
476  ret->containerNumber = containerNumber;
477  } else {
478  handleError(hardFail, abortCreation, toString(SUMO_ATTR_CONTAINER_NUMBER) + " cannot be negative");
479  }
480  }
481  // parse individual speedFactor
482  if (attrs.hasAttribute(SUMO_ATTR_SPEEDFACTOR)) {
483  double speedFactor = attrs.get<double>(SUMO_ATTR_SPEEDFACTOR, ret->id.c_str(), ok);
484  if (speedFactor > 0) {
486  ret->speedFactor = speedFactor;
487  } else {
488  handleError(hardFail, abortCreation, toString(SUMO_ATTR_SPEEDFACTOR) + " must be positive");
489  }
490  }
491  /*/ parse via
492  if (attrs.hasAttribute(SUMO_ATTR_VIA)) {
493  ret->setParameter |= VEHPARS_VIA_SET;
494  SUMOSAXAttributes::parseStringVector(attrs.get<std::string>(SUMO_ATTR_VIA, ret->id.c_str(), ok), ret->via);
495  }
496  */
497 }
498 
499 
501 SUMOVehicleParserHelper::beginVTypeParsing(const SUMOSAXAttributes& attrs, const bool hardFail, const std::string& file) {
502  bool abortCreation = true;
503  // first obtain ID
504  std::string id = parseID(attrs, SUMO_TAG_VTYPE);
505  // check if ID is valid
506  if (!id.empty()) {
508  if (attrs.hasAttribute(SUMO_ATTR_VCLASS)) {
509  vClass = parseVehicleClass(attrs, id);
510  }
511  SUMOVTypeParameter* vtype = new SUMOVTypeParameter(id, vClass);
512  try {
513  if (attrs.hasAttribute(SUMO_ATTR_VCLASS)) {
515  }
516  if (attrs.hasAttribute(SUMO_ATTR_LENGTH)) {
517  bool ok = true;
518  double length = attrs.get<double>(SUMO_ATTR_LENGTH, vtype->id.c_str(), ok);
519  if (ok) {
520  if (length <= 0) {
521  handleError(hardFail, abortCreation, toString(SUMO_ATTR_LENGTH) + " must be greater than 0");
522  } else {
523  vtype->length = length;
525  }
526  }
527  }
528  if (attrs.hasAttribute(SUMO_ATTR_MINGAP)) {
529  bool ok = true;
530  double minGap = attrs.get<double>(SUMO_ATTR_MINGAP, vtype->id.c_str(), ok);
531  if (ok) {
532  if (minGap < 0) {
533  handleError(hardFail, abortCreation, toString(SUMO_ATTR_MINGAP) + " must be equal or greater than 0");
534  } else {
535  vtype->minGap = minGap;
537  }
538  }
539  }
540  if (attrs.hasAttribute(SUMO_ATTR_MAXSPEED)) {
541  bool ok = true;
542  double maxSpeed = attrs.get<double>(SUMO_ATTR_MAXSPEED, vtype->id.c_str(), ok);
543  if (ok) {
544  if (maxSpeed <= 0) {
545  handleError(hardFail, abortCreation, toString(SUMO_ATTR_MAXSPEED) + " must be greater than 0");
546  } else {
547  vtype->maxSpeed = maxSpeed;
549  }
550  }
551  }
552  if (attrs.hasAttribute(SUMO_ATTR_SPEEDFACTOR)) {
553  bool ok = true;
554  vtype->speedFactor.parse(attrs.get<std::string>(SUMO_ATTR_SPEEDFACTOR, vtype->id.c_str(), ok), hardFail);
555  if (ok) {
557  }
558  }
559  if (attrs.hasAttribute(SUMO_ATTR_SPEEDDEV)) {
560  bool ok = true;
561  double speedDev = attrs.get<double>(SUMO_ATTR_SPEEDDEV, vtype->id.c_str(), ok);
562  if (ok) {
563  if (speedDev < 0) {
564  handleError(hardFail, abortCreation, toString(SUMO_ATTR_SPEEDDEV) + " must be equal or greater than 0");
565  } else {
566  vtype->speedFactor.getParameter()[1] = speedDev;
568  }
569  }
570  }
571  // validate speed distribution
572  std::string error;
573  if (!vtype->speedFactor.isValid(error)) {
574  handleError(hardFail, abortCreation, "Invalid speed distribution when parsing vType '" + vtype->id + "' (" + error + ")");
575  }
577  bool ok = true;
578  double actionStepLengthSecs = attrs.get<double>(SUMO_ATTR_ACTIONSTEPLENGTH, vtype->id.c_str(), ok);
579  // processActionStepLength(...) function includes warnings
580  vtype->actionStepLength = processActionStepLength(actionStepLengthSecs);
582  }
584  bool ok = true;
585  std::string parsedEmissionClass = attrs.getOpt<std::string>(SUMO_ATTR_EMISSIONCLASS, id.c_str(), ok, "");
586  // check if emission class is correct
587  try {
588  vtype->emissionClass = PollutantsInterface::getClassByName(parsedEmissionClass);
590  } catch (...) {
591  if (hardFail) {
592  throw InvalidArgument(toString(SUMO_ATTR_EMISSIONCLASS) + " with name '" + parsedEmissionClass + "' doesn't exist.");
593  } else {
594  WRITE_ERROR(toString(SUMO_ATTR_EMISSIONCLASS) + " with name '" + parsedEmissionClass + "' doesn't exist.");
595  }
596  }
597  }
598  if (attrs.hasAttribute(SUMO_ATTR_IMPATIENCE)) {
599  // allow empty attribute because .sbx saves this only as float
600  bool okString;
601  bool okDouble;
602  if (attrs.get<std::string>(SUMO_ATTR_IMPATIENCE, vtype->id.c_str(), okString, false) == "off") {
603  vtype->impatience = -std::numeric_limits<double>::max();
604  } else {
605  double impatience = attrs.get<double>(SUMO_ATTR_IMPATIENCE, vtype->id.c_str(), okDouble);
606  if (okDouble) {
607  vtype->impatience = impatience;
609  }
610  }
611  }
612  if (attrs.hasAttribute(SUMO_ATTR_WIDTH)) {
613  bool ok = true;
614  double width = attrs.get<double>(SUMO_ATTR_WIDTH, vtype->id.c_str(), ok);
615  if (ok) {
616  if (width <= 0) {
617  handleError(hardFail, abortCreation, toString(SUMO_ATTR_WIDTH) + " must be greater than 0");
618  } else {
619  vtype->width = width;
621  }
622  }
623  }
624  if (attrs.hasAttribute(SUMO_ATTR_HEIGHT)) {
625  bool ok = true;
626  double height = attrs.get<double>(SUMO_ATTR_HEIGHT, vtype->id.c_str(), ok);
627  if (ok) {
628  if (height < 0) {
629  handleError(hardFail, abortCreation, toString(SUMO_ATTR_HEIGHT) + " must be equal or greater than 0");
630  } else {
631  vtype->height = height;
633  }
634  }
635  }
636  if (attrs.hasAttribute(SUMO_ATTR_GUISHAPE)) {
637  vtype->shape = parseGuiShape(attrs, vtype->id);
638  if (vtype->shape != SVS_UNKNOWN) {
640  }
641  }
642  if (attrs.hasAttribute(SUMO_ATTR_OSGFILE)) {
643  bool ok = true;
644  std::string osgFile = attrs.get<std::string>(SUMO_ATTR_OSGFILE, vtype->id.c_str(), ok);
645  if (ok) {
646  vtype->osgFile = osgFile;
648  }
649  }
650  if (attrs.hasAttribute(SUMO_ATTR_IMGFILE)) {
651  bool ok = true;
652  std::string imgFile = attrs.get<std::string>(SUMO_ATTR_IMGFILE, vtype->id.c_str(), ok);
653  if (ok) {
654  // check relative path
655  if ((imgFile != "") && !FileHelpers::isAbsolute(imgFile)) {
656  imgFile = FileHelpers::getConfigurationRelative(file, imgFile);
657  }
658  vtype->imgFile = imgFile;
660  }
661  }
662  if (attrs.hasAttribute(SUMO_ATTR_COLOR)) {
663  bool ok = true;
664  RGBColor color = attrs.get<RGBColor>(SUMO_ATTR_COLOR, vtype->id.c_str(), ok);
665  if (ok) {
666  vtype->color = color;
668  }
669  } else {
670  vtype->color = RGBColor::YELLOW;
671  }
672  if (attrs.hasAttribute(SUMO_ATTR_PROB)) {
673  bool ok = true;
674  double defaultProbability = attrs.get<double>(SUMO_ATTR_PROB, vtype->id.c_str(), ok);
675  if (ok) {
676  if (defaultProbability < 0) {
677  handleError(hardFail, abortCreation, toString(SUMO_ATTR_PROB) + " must be equal or greater than 0");
678  } else {
679  vtype->defaultProbability = defaultProbability;
681  }
682  }
683  }
685  bool ok = true;
686  std::string lcmS = attrs.get<std::string>(SUMO_ATTR_LANE_CHANGE_MODEL, vtype->id.c_str(), ok);
687  if (lcmS == "JE2013") {
688  WRITE_WARNING("Lane change model 'JE2013' is deprecated. Using default model instead.");
689  lcmS = "default";
690  }
691  if (SUMOXMLDefinitions::LaneChangeModels.hasString(lcmS)) {
694  } else {
695  handleError(hardFail, abortCreation, "Unknown lane change model '" + lcmS + "' when parsing vType '" + vtype->id + "'");
696  }
697  }
699  bool ok = true;
700  const std::string cfmValue = attrs.get<std::string>(SUMO_ATTR_CAR_FOLLOW_MODEL, vtype->id.c_str(), ok);
701  if (ok && SUMOXMLDefinitions::CarFollowModels.hasString(cfmValue)) {
704  } else {
705  handleError(hardFail, abortCreation, "Unknown car following model '" + cfmValue + "' when parsing vType '" + vtype->id + "'");
706  }
707  }
709  bool ok = true;
710  int personCapacity = attrs.get<int>(SUMO_ATTR_PERSON_CAPACITY, vtype->id.c_str(), ok);
711  if (ok) {
712  if (personCapacity < 0) {
713  handleError(hardFail, abortCreation, toString(SUMO_ATTR_PERSON_CAPACITY) + " must be equal or greater than 0");
714  } else {
715  vtype->personCapacity = personCapacity;
717  }
718  }
719  }
721  bool ok = true;
722  int containerCapacity = attrs.get<int>(SUMO_ATTR_CONTAINER_CAPACITY, vtype->id.c_str(), ok);
723  if (ok) {
724  if (containerCapacity < 0) {
725  handleError(hardFail, abortCreation, toString(SUMO_ATTR_CONTAINER_CAPACITY) + " must be equal or greater than 0");
726  } else {
727  vtype->containerCapacity = containerCapacity;
729  }
730  }
731  }
733  bool ok = true;
734  SUMOTime boardingDuration = attrs.getSUMOTimeReporting(SUMO_ATTR_BOARDING_DURATION, vtype->id.c_str(), ok);
735  if (ok) {
736  if (boardingDuration < 0) {
737  handleError(hardFail, abortCreation, toString(SUMO_ATTR_BOARDING_DURATION) + " must be equal or greater than 0");
738  } else {
739  vtype->boardingDuration = boardingDuration;
741  }
742  }
743  }
745  bool ok = true;
746  SUMOTime loadingDuration = attrs.getSUMOTimeReporting(SUMO_ATTR_LOADING_DURATION, vtype->id.c_str(), ok);
747  if (ok) {
748  if (loadingDuration < 0) {
749  handleError(hardFail, abortCreation, toString(SUMO_ATTR_LOADING_DURATION) + " must be equal or greater than 0");
750  } else {
751  vtype->loadingDuration = loadingDuration;
753  }
754  }
755  }
757  bool ok = true;
758  double maxSpeedLat = attrs.get<double>(SUMO_ATTR_MAXSPEED_LAT, vtype->id.c_str(), ok);
759  if (ok) {
760  if (maxSpeedLat <= 0) {
761  handleError(hardFail, abortCreation, toString(SUMO_ATTR_MAXSPEED_LAT) + " must be greater than 0");
762  } else {
763  vtype->maxSpeedLat = maxSpeedLat;
765  }
766  }
767  }
768  if (attrs.hasAttribute(SUMO_ATTR_MINGAP_LAT)) {
769  bool ok = true;
770  double minGapLat = attrs.get<double>(SUMO_ATTR_MINGAP_LAT, vtype->id.c_str(), ok);
771  if (ok) {
772  if (minGapLat < 0) {
773  handleError(hardFail, abortCreation, toString(SUMO_ATTR_MINGAP_LAT) + " must be equal or greater than 0");
774  } else {
775  vtype->minGapLat = minGapLat;
777  }
778  }
779  }
781  bool ok = true;
782  const std::string alignS = attrs.get<std::string>(SUMO_ATTR_LATALIGNMENT, vtype->id.c_str(), ok);
783  if (ok && SUMOXMLDefinitions::LateralAlignments.hasString(alignS)) {
786  } else {
787  handleError(hardFail, abortCreation, "Unknown lateral alignment '" + alignS + "' when parsing vType '" + vtype->id + "'");
788  }
789  }
791  bool ok = true;
792  const std::string angleTimesS = attrs.get<std::string>(SUMO_ATTR_MANEUVER_ANGLE_TIMES, vtype->id.c_str(), ok);
793  if (ok && parseAngleTimesMap(*vtype, angleTimesS, hardFail)) {
795  } else {
796  handleError(hardFail, abortCreation, "Invalid manoeuver angle times map for vType '" + vtype->id + "'");
797  }
798  }
799 
800  // try to parse embedded vType
801  if (!parseVTypeEmbedded(*vtype, vtype->cfModel, attrs, hardFail, true)) {
802  handleError(hardFail, abortCreation, "Invalid parsing embedded VType");
803  }
804  // try to parse Lane Change Model params
805  if (!parseLCParams(*vtype, vtype->lcModel, attrs, hardFail)) {
806  handleError(hardFail, abortCreation, "Invalid Lane Change Model Parameters");
807  }
808  // try to Junction Model params
809  if (!parseJMParams(*vtype, attrs, hardFail)) {
810  handleError(hardFail, abortCreation, "Invalid Junction Model Parameters");
811  }
812  } catch (ProcessError&) {
813  delete vtype;
814  throw;
815  }
816  if (!abortCreation) {
817  delete vtype;
818  if (hardFail) {
819  throw ProcessError();
820  } else {
821  return nullptr;
822  }
823  }
824  return vtype;
825  } else {
826  if (hardFail) {
827  throw ProcessError("VType cannot be created");
828  } else {
829  return nullptr;
830  }
831  }
832 }
833 
834 bool
835 SUMOVehicleParserHelper::parseAngleTimesMap(SUMOVTypeParameter& vtype, const std::string atm, const bool hardFail) {
836  StringTokenizer st(atm, ",");
837  std::map<int, std::pair<SUMOTime, SUMOTime>> angleTimesMap;
838  int tripletCount = 0;
839 
840  while (st.hasNext()) {
841  StringTokenizer pos(st.next());
842  if (pos.size() != 3) {
843  if (hardFail) {
844  throw ProcessError("manoeuverAngleTimes format for vType '" + vtype.id + "' " + atm + " contains an invalid triplet.");
845  } else {
846  WRITE_ERROR("manoeuverAngleTimes format for vType '" + vtype.id + "' " + atm + " contains an invalid triplet.");
847  }
848  } else {
849  try {
850  int angle = StringUtils::toInt(pos.next());
851  SUMOTime t1 = static_cast<SUMOTime>(StringUtils::toDouble(pos.next()));
852  t1 = TIME2STEPS(t1);
853  SUMOTime t2 = static_cast<SUMOTime>(StringUtils::toDouble(pos.next()));
854  t2 = TIME2STEPS(t2);
855 
856  angleTimesMap.insert((std::pair<int, std::pair<SUMOTime, SUMOTime>>(angle, std::pair< SUMOTime, SUMOTime>(t1, t2))));
857  } catch (...) {
858  WRITE_ERROR("Triplet '" + st.get(tripletCount) + "' for vType '" + vtype.id + "' manoeuverAngleTimes cannot be parsed as 'int double double'");
859  }
860  tripletCount++;
861  }
862  }
863 
864  if (angleTimesMap.size() > 0) {
865  vtype.myManoeuverAngleTimes.clear();
866  for (std::pair<int, std::pair<SUMOTime, SUMOTime>> angleTime : angleTimesMap) {
867  vtype.myManoeuverAngleTimes.insert(std::pair<int, std::pair<SUMOTime, SUMOTime>>(angleTime));
868  }
869  angleTimesMap.clear();
870  return true;
871  } else {
872  return false;
873  }
874 }
875 
876 
877 bool
878 SUMOVehicleParserHelper::parseVTypeEmbedded(SUMOVTypeParameter& into, const SumoXMLTag element, const SUMOSAXAttributes& attrs, const bool hardFail, const bool fromVType) {
879  const CFAttrMap& allowedCFM = getAllowedCFModelAttrs();
880  bool abortCreation = true;
881  CFAttrMap::const_iterator cf_it = allowedCFM.find(element);
882  // check if given CFM is allowed
883  if (cf_it == allowedCFM.end()) {
884  if (SUMOXMLDefinitions::Tags.has((int)element)) {
885  handleError(hardFail, abortCreation, "Unknown car following model " + toString(element) + " when parsing vType '" + into.id + "'");
886  } else {
887  handleError(hardFail, abortCreation, "Unknown car following model when parsing vType '" + into.id + "'");
888  }
889  return false;
890  }
891  // set car following model
892  if (!fromVType) {
893  into.cfModel = cf_it->first;
895  }
896  // set CFM values
897  bool ok = true;
898  for (const auto& it : cf_it->second) {
899  if (attrs.hasAttribute(it)) {
900  // first obtain CFM attribute in string format
901  std::string parsedCFMAttribute = attrs.get<std::string>(it, into.id.c_str(), ok);
902  // check if attribute is of type "train"
903  if (it == SUMO_ATTR_TRAIN_TYPE) {
904  // check if train value is valid
905  if (SUMOXMLDefinitions::TrainTypes.hasString(parsedCFMAttribute)) {
906  // add parsedCFMAttribute to cfParameter
907  into.cfParameter[it] = parsedCFMAttribute;
908  } else if (hardFail) {
909  throw ProcessError("Invalid train type '" + parsedCFMAttribute + "' used in Car-Following-Attribute " + toString(it));
910  } else {
911  WRITE_ERROR("Invalid train type '" + parsedCFMAttribute + "' used in Car-Following-Attribute " + toString(it));
912  }
913  } else if (it == SUMO_ATTR_CF_IDM_STEPPING) {
914  // declare a int in wich save CFM int attribute
915  int CFMIntAttribute = -1;
916  try {
917  // obtain CFM attribute in int format
918  CFMIntAttribute = StringUtils::toInt(parsedCFMAttribute);
919  } catch (...) {
920  ok = false;
921  if (hardFail) {
922  throw ProcessError("Invalid Car-Following-Model Attribute " + toString(it) + ". Cannot be parsed to int");
923  } else {
924  WRITE_ERROR("Invalid Car-Following-Model Attribute " + toString(it) + ". Cannot be parsed to int");
925  }
926  }
927  // now continue checking other properties
928  if (ok) {
929  if (CFMIntAttribute <= 0) {
930  ok = false;
931  if (hardFail) {
932  throw ProcessError("Invalid Car-Following-Model Attribute " + toString(it) + ". Must be greater than 0");
933  } else {
934  WRITE_ERROR("Invalid Car-Following-Model Attribute " + toString(it) + ". Must be greater than 0");
935  }
936  }
937  if (ok) {
938  // add parsedCFMAttribute to cfParameter
939  into.cfParameter[it] = parsedCFMAttribute;
940  }
941  }
942  } else {
943  // declare a double in wich save CFM float attribute
944  double CFMDoubleAttribute = -1;
945  try {
946  // obtain CFM attribute in double format
947  CFMDoubleAttribute = StringUtils::toDouble(parsedCFMAttribute);
948  } catch (...) {
949  ok = false;
950  if (hardFail) {
951  throw ProcessError("Invalid Car-Following-Model Attribute " + toString(it) + ". Cannot be parsed to float");
952  } else {
953  WRITE_ERROR("Invalid Car-Following-Model Attribute " + toString(it) + ". Cannot be parsed to float");
954  }
955  if (ok) {
956  // add parsedCFMAttribute to cfParameter
957  into.cfParameter[it] = parsedCFMAttribute;
958  }
959  }
960  // now continue checking other properties
961  if (ok) {
962  // check attributes of type "positiveFloatType" (> 0)
963  switch (it) {
964  case SUMO_ATTR_ACCEL:
965  case SUMO_ATTR_DECEL:
968  case SUMO_ATTR_TAU:
969  if (CFMDoubleAttribute <= 0) {
970  ok = false;
971  if (hardFail) {
972  throw ProcessError("Invalid Car-Following-Model Attribute " + toString(it) + ". Must be greater than 0");
973  } else {
974  WRITE_ERROR("Invalid Car-Following-Model Attribute " + toString(it) + ". Must be greater than 0");
975  }
976  }
977  default:
978  break;
979  }
980  // check attributes restricted to [0-1]
981  switch (it) {
982  case SUMO_ATTR_SIGMA:
983  if ((CFMDoubleAttribute < 0) || (CFMDoubleAttribute > 1)) {
984  ok = false;
985  if (hardFail) {
986  throw ProcessError("Invalid Car-Following-Model Attribute " + toString(it) + ". Only values between [0-1] are allowed");
987  } else {
988  WRITE_ERROR("Invalid Car-Following-Model Attribute " + toString(it) + ". Only values between [0-1] are allowed");
989  }
990  }
991  default:
992  break;
993  }
994  // special check for TAU attribute
995  if (it == SUMO_ATTR_TAU) {
996  // check tau in time format
997  if ((string2time(parsedCFMAttribute) < DELTA_T) && gSimulation) {
998  WRITE_WARNING("Value of tau=" + parsedCFMAttribute + " in car following model '" +
999  toString(into.cfModel) + "' lower than simulation step size may cause collisions");
1000  }
1001  }
1002  if (ok) {
1003  // add parsedCFMAttribute to cfParameter
1004  into.cfParameter[it] = parsedCFMAttribute;
1005  }
1006  }
1007  }
1008  }
1009  }
1010  return ok;
1011 }
1012 
1013 
1016  // init on first use
1017  if (allowedCFModelAttrs.size() == 0) {
1018  std::set<SumoXMLAttr> kraussParams;
1019  kraussParams.insert(SUMO_ATTR_ACCEL);
1020  kraussParams.insert(SUMO_ATTR_DECEL);
1021  kraussParams.insert(SUMO_ATTR_APPARENTDECEL);
1022  kraussParams.insert(SUMO_ATTR_EMERGENCYDECEL);
1023  kraussParams.insert(SUMO_ATTR_SIGMA);
1024  kraussParams.insert(SUMO_ATTR_TAU);
1025  allowedCFModelAttrs[SUMO_TAG_CF_KRAUSS] = kraussParams;
1028  std::set<SumoXMLAttr> allParams(kraussParams);
1029 
1030  std::set<SumoXMLAttr> kraussXParams(kraussParams);
1031  kraussXParams.insert(SUMO_ATTR_TMP1);
1032  kraussXParams.insert(SUMO_ATTR_TMP2);
1033  kraussXParams.insert(SUMO_ATTR_TMP3);
1034  kraussXParams.insert(SUMO_ATTR_TMP4);
1035  kraussXParams.insert(SUMO_ATTR_TMP5);
1036  allowedCFModelAttrs[SUMO_TAG_CF_KRAUSSX] = kraussXParams;
1037  allParams.insert(kraussXParams.begin(), kraussXParams.end());
1038 
1039  std::set<SumoXMLAttr> smartSKParams;
1040  smartSKParams.insert(SUMO_ATTR_ACCEL);
1041  smartSKParams.insert(SUMO_ATTR_DECEL);
1042  smartSKParams.insert(SUMO_ATTR_EMERGENCYDECEL);
1043  smartSKParams.insert(SUMO_ATTR_COLLISION_MINGAP_FACTOR);
1044  smartSKParams.insert(SUMO_ATTR_SIGMA);
1045  smartSKParams.insert(SUMO_ATTR_TAU);
1046  smartSKParams.insert(SUMO_ATTR_TMP1);
1047  smartSKParams.insert(SUMO_ATTR_TMP2);
1048  smartSKParams.insert(SUMO_ATTR_TMP3);
1049  smartSKParams.insert(SUMO_ATTR_TMP4);
1050  smartSKParams.insert(SUMO_ATTR_TMP5);
1051  allowedCFModelAttrs[SUMO_TAG_CF_SMART_SK] = smartSKParams;
1052  allParams.insert(smartSKParams.begin(), smartSKParams.end());
1053 
1054  std::set<SumoXMLAttr> daniel1Params;
1055  daniel1Params.insert(SUMO_ATTR_ACCEL);
1056  daniel1Params.insert(SUMO_ATTR_DECEL);
1057  daniel1Params.insert(SUMO_ATTR_EMERGENCYDECEL);
1058  daniel1Params.insert(SUMO_ATTR_COLLISION_MINGAP_FACTOR);
1059  daniel1Params.insert(SUMO_ATTR_SIGMA);
1060  daniel1Params.insert(SUMO_ATTR_TAU);
1061  daniel1Params.insert(SUMO_ATTR_TMP1);
1062  daniel1Params.insert(SUMO_ATTR_TMP2);
1063  daniel1Params.insert(SUMO_ATTR_TMP3);
1064  daniel1Params.insert(SUMO_ATTR_TMP4);
1065  daniel1Params.insert(SUMO_ATTR_TMP5);
1066  allowedCFModelAttrs[SUMO_TAG_CF_DANIEL1] = daniel1Params;
1067  allParams.insert(daniel1Params.begin(), daniel1Params.end());
1068 
1069  std::set<SumoXMLAttr> pwagParams;
1070  pwagParams.insert(SUMO_ATTR_ACCEL);
1071  pwagParams.insert(SUMO_ATTR_DECEL);
1072  pwagParams.insert(SUMO_ATTR_EMERGENCYDECEL);
1073  pwagParams.insert(SUMO_ATTR_COLLISION_MINGAP_FACTOR);
1074  pwagParams.insert(SUMO_ATTR_SIGMA);
1075  pwagParams.insert(SUMO_ATTR_TAU);
1076  pwagParams.insert(SUMO_ATTR_CF_PWAGNER2009_TAULAST);
1077  pwagParams.insert(SUMO_ATTR_CF_PWAGNER2009_APPROB);
1079  allParams.insert(pwagParams.begin(), pwagParams.end());
1080 
1081  std::set<SumoXMLAttr> idmParams;
1082  idmParams.insert(SUMO_ATTR_ACCEL);
1083  idmParams.insert(SUMO_ATTR_DECEL);
1084  idmParams.insert(SUMO_ATTR_EMERGENCYDECEL);
1085  idmParams.insert(SUMO_ATTR_COLLISION_MINGAP_FACTOR);
1086  idmParams.insert(SUMO_ATTR_TAU);
1087  idmParams.insert(SUMO_ATTR_CF_IDM_DELTA);
1088  idmParams.insert(SUMO_ATTR_CF_IDM_STEPPING);
1089  allowedCFModelAttrs[SUMO_TAG_CF_IDM] = idmParams;
1090  allParams.insert(idmParams.begin(), idmParams.end());
1091 
1092  std::set<SumoXMLAttr> idmmParams;
1093  idmmParams.insert(SUMO_ATTR_ACCEL);
1094  idmmParams.insert(SUMO_ATTR_DECEL);
1095  idmmParams.insert(SUMO_ATTR_EMERGENCYDECEL);
1096  idmmParams.insert(SUMO_ATTR_COLLISION_MINGAP_FACTOR);
1097  idmmParams.insert(SUMO_ATTR_TAU);
1098  idmmParams.insert(SUMO_ATTR_CF_IDMM_ADAPT_FACTOR);
1099  idmmParams.insert(SUMO_ATTR_CF_IDMM_ADAPT_TIME);
1100  idmmParams.insert(SUMO_ATTR_CF_IDM_STEPPING);
1101  allowedCFModelAttrs[SUMO_TAG_CF_IDMM] = idmmParams;
1102  allParams.insert(idmmParams.begin(), idmmParams.end());
1103 
1104  std::set<SumoXMLAttr> bkernerParams;
1105  bkernerParams.insert(SUMO_ATTR_ACCEL);
1106  bkernerParams.insert(SUMO_ATTR_DECEL);
1107  bkernerParams.insert(SUMO_ATTR_EMERGENCYDECEL);
1108  bkernerParams.insert(SUMO_ATTR_COLLISION_MINGAP_FACTOR);
1109  bkernerParams.insert(SUMO_ATTR_TAU);
1110  bkernerParams.insert(SUMO_ATTR_K);
1111  bkernerParams.insert(SUMO_ATTR_CF_KERNER_PHI);
1112  allowedCFModelAttrs[SUMO_TAG_CF_BKERNER] = bkernerParams;
1113  allParams.insert(bkernerParams.begin(), bkernerParams.end());
1114 
1115  std::set<SumoXMLAttr> wiedemannParams;
1116  wiedemannParams.insert(SUMO_ATTR_ACCEL);
1117  wiedemannParams.insert(SUMO_ATTR_DECEL);
1118  wiedemannParams.insert(SUMO_ATTR_EMERGENCYDECEL);
1119  wiedemannParams.insert(SUMO_ATTR_COLLISION_MINGAP_FACTOR);
1120  wiedemannParams.insert(SUMO_ATTR_CF_WIEDEMANN_SECURITY);
1121  wiedemannParams.insert(SUMO_ATTR_CF_WIEDEMANN_ESTIMATION);
1122  allowedCFModelAttrs[SUMO_TAG_CF_WIEDEMANN] = wiedemannParams;
1123  allParams.insert(wiedemannParams.begin(), wiedemannParams.end());
1124 
1125  std::set<SumoXMLAttr> w99Params;
1126  w99Params.insert(SUMO_ATTR_DECEL); // used when patching speed during lane-changing
1127  w99Params.insert(SUMO_ATTR_EMERGENCYDECEL);
1128  w99Params.insert(SUMO_ATTR_CF_W99_CC1);
1129  w99Params.insert(SUMO_ATTR_CF_W99_CC2);
1130  w99Params.insert(SUMO_ATTR_CF_W99_CC3);
1131  w99Params.insert(SUMO_ATTR_CF_W99_CC4);
1132  w99Params.insert(SUMO_ATTR_CF_W99_CC5);
1133  w99Params.insert(SUMO_ATTR_CF_W99_CC6);
1134  w99Params.insert(SUMO_ATTR_CF_W99_CC7);
1135  w99Params.insert(SUMO_ATTR_CF_W99_CC8);
1136  w99Params.insert(SUMO_ATTR_CF_W99_CC9);
1137  allowedCFModelAttrs[SUMO_TAG_CF_W99] = w99Params;
1138  allParams.insert(w99Params.begin(), w99Params.end());
1139 
1140  std::set<SumoXMLAttr> railParams;
1141  railParams.insert(SUMO_ATTR_TRAIN_TYPE);
1142  allowedCFModelAttrs[SUMO_TAG_CF_RAIL] = railParams;
1143  allParams.insert(railParams.begin(), railParams.end());
1144 
1145  std::set<SumoXMLAttr> ACCParams;
1146  ACCParams.insert(SUMO_ATTR_ACCEL);
1147  ACCParams.insert(SUMO_ATTR_DECEL);
1148  ACCParams.insert(SUMO_ATTR_EMERGENCYDECEL);
1149  ACCParams.insert(SUMO_ATTR_COLLISION_MINGAP_FACTOR);
1150  ACCParams.insert(SUMO_ATTR_TAU);
1151  ACCParams.insert(SUMO_ATTR_SC_GAIN);
1152  ACCParams.insert(SUMO_ATTR_GCC_GAIN_SPEED);
1153  ACCParams.insert(SUMO_ATTR_GCC_GAIN_SPACE);
1154  ACCParams.insert(SUMO_ATTR_GC_GAIN_SPEED);
1155  ACCParams.insert(SUMO_ATTR_GC_GAIN_SPACE);
1156  ACCParams.insert(SUMO_ATTR_CA_GAIN_SPEED);
1157  ACCParams.insert(SUMO_ATTR_CA_GAIN_SPACE);
1158  allowedCFModelAttrs[SUMO_TAG_CF_ACC] = ACCParams;
1159  allParams.insert(ACCParams.begin(), ACCParams.end());
1160 
1161  std::set<SumoXMLAttr> CACCParams;
1162  CACCParams.insert(SUMO_ATTR_ACCEL);
1163  CACCParams.insert(SUMO_ATTR_DECEL);
1164  CACCParams.insert(SUMO_ATTR_EMERGENCYDECEL);
1165  CACCParams.insert(SUMO_ATTR_COLLISION_MINGAP_FACTOR);
1166  CACCParams.insert(SUMO_ATTR_TAU);
1167  CACCParams.insert(SUMO_ATTR_SC_GAIN_CACC);
1168  CACCParams.insert(SUMO_ATTR_GCC_GAIN_GAP_CACC);
1169  CACCParams.insert(SUMO_ATTR_GCC_GAIN_GAP_DOT_CACC);
1170  CACCParams.insert(SUMO_ATTR_GC_GAIN_GAP_CACC);
1171  CACCParams.insert(SUMO_ATTR_GC_GAIN_GAP_DOT_CACC);
1172  CACCParams.insert(SUMO_ATTR_CA_GAIN_GAP_CACC);
1173  CACCParams.insert(SUMO_ATTR_CA_GAIN_GAP_DOT_CACC);
1174  CACCParams.insert(SUMO_ATTR_GCC_GAIN_SPEED);
1175  CACCParams.insert(SUMO_ATTR_GCC_GAIN_SPACE);
1176  CACCParams.insert(SUMO_ATTR_GC_GAIN_SPEED);
1177  CACCParams.insert(SUMO_ATTR_GC_GAIN_SPACE);
1178  CACCParams.insert(SUMO_ATTR_CA_GAIN_SPEED);
1179  CACCParams.insert(SUMO_ATTR_CA_GAIN_SPACE);
1180  CACCParams.insert(SUMO_ATTR_HEADWAY_TIME_CACC_TO_ACC);
1181  allowedCFModelAttrs[SUMO_TAG_CF_CACC] = CACCParams;
1182  allParams.insert(CACCParams.begin(), CACCParams.end());
1183 
1184  std::set<SumoXMLAttr> ccParams;
1185  ccParams.insert(SUMO_ATTR_ACCEL);
1186  ccParams.insert(SUMO_ATTR_DECEL);
1187  ccParams.insert(SUMO_ATTR_TAU);
1188  ccParams.insert(SUMO_ATTR_CF_CC_C1);
1189  ccParams.insert(SUMO_ATTR_CF_CC_CCDECEL);
1190  ccParams.insert(SUMO_ATTR_CF_CC_CONSTSPACING);
1191  ccParams.insert(SUMO_ATTR_CF_CC_KP);
1192  ccParams.insert(SUMO_ATTR_CF_CC_LAMBDA);
1193  ccParams.insert(SUMO_ATTR_CF_CC_OMEGAN);
1194  ccParams.insert(SUMO_ATTR_CF_CC_TAU);
1195  ccParams.insert(SUMO_ATTR_CF_CC_XI);
1196  ccParams.insert(SUMO_ATTR_CF_CC_LANES_COUNT);
1197  ccParams.insert(SUMO_ATTR_CF_CC_CCACCEL);
1198  ccParams.insert(SUMO_ATTR_CF_CC_PLOEG_KP);
1199  ccParams.insert(SUMO_ATTR_CF_CC_PLOEG_KD);
1200  ccParams.insert(SUMO_ATTR_CF_CC_PLOEG_H);
1201  ccParams.insert(SUMO_ATTR_CF_CC_FLATBED_KA);
1202  ccParams.insert(SUMO_ATTR_CF_CC_FLATBED_KV);
1203  ccParams.insert(SUMO_ATTR_CF_CC_FLATBED_KP);
1204  ccParams.insert(SUMO_ATTR_CF_CC_FLATBED_D);
1205  ccParams.insert(SUMO_ATTR_CF_CC_FLATBED_H);
1206  allowedCFModelAttrs[SUMO_TAG_CF_CC] = ccParams;
1207  allParams.insert(ccParams.begin(), ccParams.end());
1208 
1210  }
1211  return allowedCFModelAttrs;
1212 }
1213 
1214 
1215 bool
1217  if (allowedLCModelAttrs.size() == 0) {
1218  // init static map
1219  std::set<SumoXMLAttr> lc2013Params;
1220  lc2013Params.insert(SUMO_ATTR_LCA_STRATEGIC_PARAM);
1221  lc2013Params.insert(SUMO_ATTR_LCA_COOPERATIVE_PARAM);
1222  lc2013Params.insert(SUMO_ATTR_LCA_SPEEDGAIN_PARAM);
1223  lc2013Params.insert(SUMO_ATTR_LCA_KEEPRIGHT_PARAM);
1224  lc2013Params.insert(SUMO_ATTR_LCA_OPPOSITE_PARAM);
1225  lc2013Params.insert(SUMO_ATTR_LCA_LOOKAHEADLEFT);
1226  lc2013Params.insert(SUMO_ATTR_LCA_SPEEDGAINRIGHT);
1227  lc2013Params.insert(SUMO_ATTR_LCA_MAXSPEEDLATSTANDING);
1228  lc2013Params.insert(SUMO_ATTR_LCA_MAXSPEEDLATFACTOR);
1229  lc2013Params.insert(SUMO_ATTR_LCA_ASSERTIVE);
1230  lc2013Params.insert(SUMO_ATTR_LCA_OVERTAKE_RIGHT);
1231  lc2013Params.insert(SUMO_ATTR_LCA_SIGMA);
1232  lc2013Params.insert(SUMO_ATTR_LCA_EXPERIMENTAL1);
1233  allowedLCModelAttrs[LCM_LC2013] = lc2013Params;
1234 
1235  std::set<SumoXMLAttr> sl2015Params = lc2013Params;
1236  sl2015Params.insert(SUMO_ATTR_LCA_PUSHY);
1237  sl2015Params.insert(SUMO_ATTR_LCA_PUSHYGAP);
1238  sl2015Params.insert(SUMO_ATTR_LCA_SUBLANE_PARAM);
1239  sl2015Params.insert(SUMO_ATTR_LCA_IMPATIENCE);
1240  sl2015Params.insert(SUMO_ATTR_LCA_TIME_TO_IMPATIENCE);
1241  sl2015Params.insert(SUMO_ATTR_LCA_ACCEL_LAT);
1242  sl2015Params.insert(SUMO_ATTR_LCA_TURN_ALIGNMENT_DISTANCE);
1243  sl2015Params.insert(SUMO_ATTR_LCA_LANE_DISCIPLINE);
1244  allowedLCModelAttrs[LCM_SL2015] = sl2015Params;
1245 
1246  std::set<SumoXMLAttr> noParams;
1247  allowedLCModelAttrs[LCM_DK2008] = noParams;
1248 
1249  // default model may be either LC2013 or SL2015
1250  // we allow both sets (sl2015 is a superset of lc2013Params)
1251  allowedLCModelAttrs[LCM_DEFAULT] = sl2015Params;
1252  }
1253  bool ok = true;
1254  std::set<SumoXMLAttr> allowed = allowedLCModelAttrs[model];
1255  for (const auto& it : allowed) {
1256  if (attrs.hasAttribute(it)) {
1257  // first obtain CFM attribute in string format
1258  std::string parsedLCMAttribute = attrs.get<std::string>(it, into.id.c_str(), ok);
1259  // declare a double in wich save CFM attribute
1260  double LCMAttribute = -1;
1261  try {
1262  // obtain CFM attribute in double format
1263  LCMAttribute = StringUtils::toDouble(parsedLCMAttribute);
1264  } catch (...) {
1265  ok = false;
1266  if (hardFail) {
1267  throw ProcessError("Invalid Lane-Change-Model Attribute " + toString(it) + ". Cannot be parsed to float");
1268  } else {
1269  WRITE_ERROR("Invalid Lane-Change-Model Attribute " + toString(it) + ". Cannot be parsed to float");
1270  }
1271  }
1272  // now continue checking other properties
1273  if (ok) {
1274  // check attributes of type "nonNegativeFloatType" (>= 0)
1275  switch (it) {
1286  case SUMO_ATTR_LCA_SIGMA:
1287  if (LCMAttribute < 0) {
1288  ok = false;
1289  if (hardFail) {
1290  throw ProcessError("Invalid Lane-Change-Model Attribute " + toString(it) + ". Must be equal or greater than 0");
1291  } else {
1292  WRITE_ERROR("Invalid Lane-Change-Model Attribute " + toString(it) + ". Must be equal or greater than 0");
1293  }
1294  }
1295  default:
1296  break;
1297  }
1298  // check attributes of type "positiveFloatType" (> 0)
1299  switch (it) {
1302  if (LCMAttribute <= 0) {
1303  ok = false;
1304  if (hardFail) {
1305  throw ProcessError("Invalid Lane-Change-Model Attribute " + toString(it) + ". Must be greater than 0");
1306  } else {
1307  WRITE_ERROR("Invalid Lane-Change-Model Attribute " + toString(it) + ". Must be greater than 0");
1308  }
1309  }
1310  default:
1311  break;
1312  }
1313  if (ok) {
1314  // add parsedLCMAttribute to cfParameter
1315  into.lcParameter[it] = parsedLCMAttribute;
1316  }
1317  }
1318  }
1319  }
1320  return ok;
1321 }
1322 
1323 
1324 bool
1326  if (allowedJMAttrs.size() == 0) {
1327  // init static set (there is only one model)
1337  }
1338  bool ok = true;
1339  for (const auto& it : allowedJMAttrs) {
1340  if (attrs.hasAttribute(it)) {
1341  // first obtain CFM attribute in string format
1342  std::string parsedJMAttribute = attrs.get<std::string>(it, into.id.c_str(), ok);
1343  // declare a double in wich save CFM attribute
1344  double JMAttribute = -1;
1345  try {
1346  // obtain CFM attribute in double format
1347  JMAttribute = StringUtils::toDouble(parsedJMAttribute);
1348  } catch (...) {
1349  ok = false;
1350  if (hardFail) {
1351  throw ProcessError("Invalid Junction-Model Attribute " + toString(it) + ". Cannot be parsed to float");
1352  } else {
1353  WRITE_ERROR("Invalid Junction-Model Attribute " + toString(it) + ". Cannot be parsed to float");
1354  }
1355  }
1356  // now continue checking other properties (-1 is the default value)
1357  if (ok && (JMAttribute != -1)) {
1358  // special case for sigma minor
1359  if (it == SUMO_ATTR_JM_SIGMA_MINOR) {
1360  // check attributes sigma minor
1361  if ((JMAttribute < 0) || (JMAttribute > 1)) {
1362  ok = false;
1363  if (hardFail) {
1364  throw ProcessError("Invalid Junction-Model Attribute " + toString(it) + ". Only values between [0-1] are allowed");
1365  } else {
1366  WRITE_ERROR("Invalid Junction-Model Attribute " + toString(it) + ". Only values between [0-1] are allowed");
1367  }
1368  }
1369  } else {
1370  // check attributes of type "nonNegativeFloatType" (>= 0)
1371  if (JMAttribute < 0) {
1372  ok = false;
1373  if (hardFail) {
1374  throw ProcessError("Invalid Junction-Model Attribute " + toString(it) + ". Must be equal or greater than 0");
1375  } else {
1376  WRITE_ERROR("Invalid Junction-Model Attribute " + toString(it) + ". Must be equal or greater than 0");
1377  }
1378  }
1379  }
1380  if (ok) {
1381  // add parsedJMAttribute to cfParameter
1382  into.jmParameter[it] = parsedJMAttribute;
1383  }
1384  }
1385  }
1386  }
1387  return ok;
1388 }
1389 
1390 
1393  SUMOVehicleClass vclass = SVC_IGNORING;
1394  bool ok = true;
1395  std::string vclassS = attrs.getOpt<std::string>(SUMO_ATTR_VCLASS, id.c_str(), ok, "");
1396  if (vclassS == "") {
1397  return vclass;
1398  }
1399  try {
1400  const SUMOVehicleClass result = getVehicleClassID(vclassS);
1401  const std::string& realName = SumoVehicleClassStrings.getString(result);
1402  if (realName != vclassS) {
1403  WRITE_WARNING("The vehicle class '" + vclassS + "' for " + attrs.getObjectType() + " '" + id + "' is deprecated, use '" + realName + "' instead.");
1404  }
1405  return result;
1406  } catch (...) {
1407  WRITE_ERROR("The vehicle class '" + vclassS + "' for " + attrs.getObjectType() + " '" + id + "' is not known.");
1408  }
1409  return vclass;
1410 }
1411 
1412 
1414 SUMOVehicleParserHelper::parseGuiShape(const SUMOSAXAttributes& attrs, const std::string& id) {
1415  bool ok = true;
1416  std::string vclassS = attrs.getOpt<std::string>(SUMO_ATTR_GUISHAPE, id.c_str(), ok, "");
1417  if (SumoVehicleShapeStrings.hasString(vclassS)) {
1418  const SUMOVehicleShape result = SumoVehicleShapeStrings.get(vclassS);
1419  const std::string& realName = SumoVehicleShapeStrings.getString(result);
1420  if (realName != vclassS) {
1421  WRITE_WARNING("The shape '" + vclassS + "' for " + attrs.getObjectType() + " '" + id + "' is deprecated, use '" + realName + "' instead.");
1422  }
1423  return result;
1424  } else {
1425  WRITE_ERROR("The shape '" + vclassS + "' for " + attrs.getObjectType() + " '" + id + "' is not known.");
1426  return SVS_UNKNOWN;
1427  }
1428 }
1429 
1430 
1431 double
1432 SUMOVehicleParserHelper::parseWalkPos(SumoXMLAttr attr, const bool hardFail, const std::string& id, double maxPos, const std::string& val, std::mt19937* rng) {
1433  double result;
1434  std::string error;
1435  ArrivalPosDefinition proc;
1436  // only supports 'random' and 'max'
1437  if (!SUMOVehicleParameter::parseArrivalPos(val, toString(SUMO_TAG_WALK), id, result, proc, error)) {
1438  if (hardFail) {
1439  throw ProcessError(error);
1440  } else {
1441  WRITE_ERROR(error);
1442  }
1443  }
1444  if (proc == ARRIVAL_POS_RANDOM) {
1445  result = RandHelper::rand(maxPos, rng);
1446  } else if (proc == ARRIVAL_POS_CENTER) {
1447  result = maxPos / 2.;
1448  } else if (proc == ARRIVAL_POS_MAX) {
1449  result = maxPos;
1450  }
1451  return SUMOVehicleParameter::interpretEdgePos(result, maxPos, attr, id);
1452 }
1453 
1454 
1455 SUMOTime
1457  SUMOTime result = TIME2STEPS(given);
1458  if (result <= 0) {
1459  if (result < 0) {
1460  std::stringstream ss;
1461  ss << "The parameter action-step-length must be a non-negative multiple of the simulation step-length. Ignoring given value (="
1462  << STEPS2TIME(result) << " s.)";
1463  WRITE_WARNING(ss.str());
1464  }
1465  result = DELTA_T;
1466  } else if (result % DELTA_T != 0) {
1467  std::stringstream ss;
1468  result = (SUMOTime)(DELTA_T * floor(double(result) / double(DELTA_T)));
1469  result = MAX2(DELTA_T, result);
1470  if (fabs(given * 1000. - double(result)) > NUMERICAL_EPS) {
1471  ss << "The parameter action-step-length must be a non-negative multiple of the simulation step-length. Parsing given value ("
1472  << given << " s.) to the adjusted value "
1473  << STEPS2TIME(result) << " s.";
1474  WRITE_WARNING(ss.str());
1475  }
1476  }
1477  return result;
1478 }
1479 
1480 
1482 SUMOVehicleParserHelper::handleError(const bool hardFail, bool& abortCreation, const std::string& message) {
1483  if (hardFail) {
1484  abortCreation = true;
1485  throw ProcessError(message);
1486  } else {
1487  WRITE_ERROR(message);
1488  return nullptr;
1489  }
1490 }
1491 
1492 /****************************************************************************/
1493 
VTYPEPARS_LATALIGNMENT_SET
const int VTYPEPARS_LATALIGNMENT_SET
Definition: SUMOVTypeParameter.h:66
SUMOVehicleParserHelper::handleError
static SUMOVehicleParameter * handleError(const bool hardFail, bool &abortCreation, const std::string &message)
handle error loading SUMOVehicleParameter
Definition: SUMOVehicleParserHelper.cpp:1482
SUMO_ATTR_MAXSPEED
Definition: SUMOXMLDefinitions.h:441
SUMO_ATTR_OSGFILE
Definition: SUMOXMLDefinitions.h:791
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
RGBColor::DEFAULT_COLOR
static const RGBColor DEFAULT_COLOR
The default color (for vehicle types and vehicles)
Definition: RGBColor.h:203
SUMO_ATTR_CF_W99_CC8
Definition: SUMOXMLDefinitions.h:850
SUMO_ATTR_BOARDING_DURATION
Definition: SUMOXMLDefinitions.h:460
SUMO_ATTR_LCA_SPEEDGAIN_PARAM
Definition: SUMOXMLDefinitions.h:590
SUMOVehicleClass
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types.
Definition: SUMOVehicleClass.h:133
SUMOXMLDefinitions::LaneChangeModels
static StringBijection< LaneChangeModel > LaneChangeModels
lane change models
Definition: SUMOXMLDefinitions.h:1395
SUMOVTypeParameter::lcParameter
SubParams lcParameter
Lane-changing parameter.
Definition: SUMOVTypeParameter.h:284
SUMOVehicleParameter::containerNumber
int containerNumber
The static number of containers in the vehicle when it departs.
Definition: SUMOVehicleParameter.h:665
SUMO_ATTR_CF_WIEDEMANN_ESTIMATION
Definition: SUMOXMLDefinitions.h:842
ToString.h
SUMO_ATTR_DEPART
Definition: SUMOXMLDefinitions.h:431
SUMOSAXAttributes::hasAttribute
virtual bool hasAttribute(int id) const =0
Returns the information whether the named (by its enum-value) attribute is within the current list.
SUMO_ATTR_GC_GAIN_GAP_CACC
Definition: SUMOXMLDefinitions.h:573
ArrivalPosDefinition
ArrivalPosDefinition
Possible ways to choose the arrival position.
Definition: SUMOVehicleParameter.h:230
SUMO_ATTR_CF_CC_CCDECEL
Definition: SUMOXMLDefinitions.h:853
SUMOVTypeParameter::length
double length
The physical vehicle length.
Definition: SUMOVTypeParameter.h:215
SUMOVehicleParameter::parametersSet
int parametersSet
Information for the router which parameter were set, TraCI may modify this (whe changing color)
Definition: SUMOVehicleParameter.h:671
SUMO_ATTR_JM_IGNORE_KEEPCLEAR_TIME
Definition: SUMOXMLDefinitions.h:617
getVehicleClassID
SUMOVehicleClass getVehicleClassID(const std::string &name)
Returns the class id of the abstract class given by its name.
Definition: SUMOVehicleClass.cpp:200
SUMO_ATTR_IMGFILE
Definition: SUMOXMLDefinitions.h:792
VTYPEPARS_MINGAP_SET
const int VTYPEPARS_MINGAP_SET
Definition: SUMOVTypeParameter.h:46
SUMOVehicleParserHelper::allowedCFModelAttrs
static CFAttrMap allowedCFModelAttrs
allowed attrs for each known CF-model
Definition: SUMOVehicleParserHelper.h:199
WRITE_WARNING
#define WRITE_WARNING(msg)
Definition: MsgHandler.h:275
SUMO_ATTR_MINGAP_LAT
Definition: SUMOXMLDefinitions.h:444
SUMO_ATTR_CF_W99_CC2
Definition: SUMOXMLDefinitions.h:844
SUMO_ATTR_CF_IDMM_ADAPT_FACTOR
Definition: SUMOXMLDefinitions.h:838
SUMO_ATTR_CF_CC_KP
Definition: SUMOXMLDefinitions.h:855
SUMOVehicleParameter::arrivalSpeedProcedure
ArrivalSpeedDefinition arrivalSpeedProcedure
Information how the vehicle's end speed shall be chosen.
Definition: SUMOVehicleParameter.h:537
DEFAULT_PEDTYPE_ID
const std::string DEFAULT_PEDTYPE_ID
SUMO_ATTR_LATALIGNMENT
Definition: SUMOXMLDefinitions.h:443
SUMOVehicleParserHelper::parseVTypeEmbedded
static bool parseVTypeEmbedded(SUMOVTypeParameter &into, const SumoXMLTag element, const SUMOSAXAttributes &attrs, const bool hardFail, const bool fromVType=false)
Parses an element embedded in vtype definition.
Definition: SUMOVehicleParserHelper.cpp:878
SUMO_ATTR_LENGTH
Definition: SUMOXMLDefinitions.h:393
SUMOVehicleParameter::color
RGBColor color
The vehicle's color, TraCI may change this.
Definition: SUMOVehicleParameter.h:477
SUMO_ATTR_LCA_COOPERATIVE_PARAM
Definition: SUMOXMLDefinitions.h:589
SUMO_ATTR_CF_IDM_STEPPING
Definition: SUMOXMLDefinitions.h:837
ARRIVAL_POS_RANDOM
The arrival position is chosen randomly.
Definition: SUMOVehicleParameter.h:236
SUMO_TAG_CF_KRAUSS_ORIG1
Definition: SUMOXMLDefinitions.h:277
DELTA_T
SUMOTime DELTA_T
Definition: SUMOTime.cpp:36
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
Definition: SUMOXMLDefinitions.h:442
NUMERICAL_EPS
#define NUMERICAL_EPS
Definition: config.h:148
SUMO_ATTR_CF_CC_C1
Definition: SUMOXMLDefinitions.h:857
SUMOVehicleParserHelper.h
StringTokenizer::hasNext
bool hasNext()
returns the information whether further substrings exist
Definition: StringTokenizer.cpp:94
SUMOVTypeParameter::cfModel
SumoXMLTag cfModel
The enum-representation of the car-following model to use.
Definition: SUMOVTypeParameter.h:278
SUMO_ATTR_TMP2
Definition: SUMOXMLDefinitions.h:551
SUMOVehicleParameter::departSpeed
double departSpeed
(optional) The initial speed of the vehicle
Definition: SUMOVehicleParameter.h:506
LCM_DEFAULT
Definition: SUMOXMLDefinitions.h:1307
SUMO_ATTR_LINE
Definition: SUMOXMLDefinitions.h:775
LaneChangeModel
LaneChangeModel
Definition: SUMOXMLDefinitions.h:1303
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
SUMOSAXAttributes::get
T get(int attr, const char *objectid, bool &ok, bool report=true) const
Tries to read given attribute assuming it is an int.
Definition: SUMOSAXAttributes.h:492
VTYPEPARS_BOARDING_DURATION
const int VTYPEPARS_BOARDING_DURATION
Definition: SUMOVTypeParameter.h:61
SUMO_ATTR_SPEEDFACTOR
Definition: SUMOXMLDefinitions.h:454
SUMOVehicleParameter::vtypeid
std::string vtypeid
The vehicle's type id.
Definition: SUMOVehicleParameter.h:474
SUMO_TAG_CF_CACC
Definition: SUMOXMLDefinitions.h:288
VEHPARS_NUMBER_SET
const int VEHPARS_NUMBER_SET
Definition: SUMOVehicleParameter.h:51
SUMOVehicleParameter::departPosProcedure
DepartPosDefinition departPosProcedure
Information how the vehicle shall choose the departure position.
Definition: SUMOVehicleParameter.h:497
VEHPARS_FORCE_REROUTE
const int VEHPARS_FORCE_REROUTE
Definition: SUMOVehicleParameter.h:62
MsgHandler.h
SUMOVehicleParserHelper::LCAttrMap
std::map< LaneChangeModel, std::set< SumoXMLAttr > > LCAttrMap
Lane-Change-Model attributes map.
Definition: SUMOVehicleParserHelper.h:193
SUMOVTypeParameter::impatience
double impatience
The vehicle's impatience (willingness to obstruct others)
Definition: SUMOVTypeParameter.h:243
SUMOVehicleParameter::repetitionOffset
SUMOTime repetitionOffset
The time offset between vehicle reinsertions.
Definition: SUMOVehicleParameter.h:550
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
RGBColor::YELLOW
static const RGBColor YELLOW
Definition: RGBColor.h:192
SUMO_TAG_CF_RAIL
Definition: SUMOXMLDefinitions.h:289
FileHelpers::getConfigurationRelative
static std::string getConfigurationRelative(const std::string &configPath, const std::string &path)
Returns the second path as a relative path to the first file.
Definition: FileHelpers.cpp:115
SUMO_ATTR_ARRIVALPOS_LAT
Definition: SUMOXMLDefinitions.h:438
SUMO_ATTR_JM_DRIVE_AFTER_YELLOW_TIME
Definition: SUMOXMLDefinitions.h:614
SUMO_ATTR_TMP1
Definition: SUMOXMLDefinitions.h:550
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
SUMO_TAG_CF_IDMM
Definition: SUMOXMLDefinitions.h:282
SUMO_ATTR_PERIOD
Definition: SUMOXMLDefinitions.h:645
SUMOVTypeParameter::osgFile
std::string osgFile
3D model file for this class
Definition: SUMOVTypeParameter.h:270
FileHelpers.h
DepartPosLatDefinition
DepartPosLatDefinition
Definition: SUMOVehicleParameter.h:166
ArrivalPosLatDefinition
ArrivalPosLatDefinition
Possible ways to choose the departure position.
Definition: SUMOVehicleParameter.h:250
SUMO_TAG_PERSON
Definition: SUMOXMLDefinitions.h:295
SUMO_ATTR_CF_PWAGNER2009_APPROB
Definition: SUMOXMLDefinitions.h:835
VTYPEPARS_MINGAP_LAT_SET
const int VTYPEPARS_MINGAP_LAT_SET
Definition: SUMOVTypeParameter.h:67
SUMOTime
long long int SUMOTime
Definition: SUMOTime.h:34
SUMOVehicleParserHelper::allowedJMAttrs
static std::set< SumoXMLAttr > allowedJMAttrs
allowed attrs for the junction model
Definition: SUMOVehicleParserHelper.h:205
VEHPARS_ARRIVALSPEED_SET
const int VEHPARS_ARRIVALSPEED_SET
Definition: SUMOVehicleParameter.h:58
Distribution_Parameterized::isValid
bool isValid(std::string &error)
check whether the distribution is valid
Definition: Distribution_Parameterized.cpp:135
SUMOSAXAttributes::getObjectType
const std::string & getObjectType() const
return the objecttype to which these attributes belong
Definition: SUMOSAXAttributes.h:396
SUMO_ATTR_PERSONSPERHOUR
Definition: SUMOXMLDefinitions.h:787
SUMO_ATTR_LOADING_DURATION
Definition: SUMOXMLDefinitions.h:461
SUMO_TAG_CF_KRAUSS
Definition: SUMOXMLDefinitions.h:275
SUMO_ATTR_LCA_LANE_DISCIPLINE
Definition: SUMOXMLDefinitions.h:606
SUMO_ATTR_COLOR
A color information.
Definition: SUMOXMLDefinitions.h:704
ArrivalLaneDefinition
ArrivalLaneDefinition
Possible ways to choose the arrival lane.
Definition: SUMOVehicleParameter.h:214
SUMOVehicleParameter::departProcedure
DepartDefinition departProcedure
Information how the vehicle shall choose the depart time.
Definition: SUMOVehicleParameter.h:485
StringTokenizer::next
std::string next()
returns the next substring when it exists. Otherwise the behaviour is undefined
Definition: StringTokenizer.cpp:99
VTYPEPARS_OSGFILE_SET
const int VTYPEPARS_OSGFILE_SET
Definition: SUMOVTypeParameter.h:56
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_GC_GAIN_GAP_DOT_CACC
Definition: SUMOXMLDefinitions.h:574
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_ARRIVALPOS
Definition: SUMOXMLDefinitions.h:437
SUMO_ATTR_SPEEDDEV
Definition: SUMOXMLDefinitions.h:455
SUMO_ATTR_ID
Definition: SUMOXMLDefinitions.h:378
SUMOVehicleParameter
Structure representing possible vehicle parameter.
Definition: SUMOVehicleParameter.h:297
SUMO_TAG_NOTHING
invalid tag
Definition: SUMOXMLDefinitions.h:43
SUMOVTypeParameter::shape
SUMOVehicleShape shape
This class' shape.
Definition: SUMOVTypeParameter.h:267
VTYPEPARS_PROBABILITY_SET
const int VTYPEPARS_PROBABILITY_SET
Definition: SUMOVTypeParameter.h:48
SUMO_ATTR_FROM_TAZ
Definition: SUMOXMLDefinitions.h:646
SUMO_ATTR_CF_IDM_DELTA
Definition: SUMOXMLDefinitions.h:836
SUMO_ATTR_CF_CC_FLATBED_KA
Definition: SUMOXMLDefinitions.h:866
SUMO_TAG_VTYPE
description of a vehicle type
Definition: SUMOXMLDefinitions.h:121
SUMOSAXAttributes::getSUMOTimeReporting
SUMOTime getSUMOTimeReporting(int attr, const char *objectid, bool &ok, bool report=true) const
Tries to read given attribute assuming it is a SUMOTime.
Definition: SUMOSAXAttributes.cpp:63
SUMO_ATTR_LCA_MAXSPEEDLATFACTOR
Definition: SUMOXMLDefinitions.h:603
SUMO_ATTR_LCA_KEEPRIGHT_PARAM
Definition: SUMOXMLDefinitions.h:591
SUMO_ATTR_LANE_CHANGE_MODEL
Definition: SUMOXMLDefinitions.h:456
SUMO_ATTR_CF_W99_CC1
Definition: SUMOXMLDefinitions.h:843
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
SUMO_ATTR_TMP5
Definition: SUMOXMLDefinitions.h:554
SUMO_ATTR_TMP3
Definition: SUMOXMLDefinitions.h:552
SUMOVTypeParameter::containerCapacity
int containerCapacity
The container capacity of the vehicle.
Definition: SUMOVTypeParameter.h:249
SUMO_ATTR_CF_W99_CC9
Definition: SUMOXMLDefinitions.h:851
gSimulation
bool gSimulation
Definition: StdDefs.cpp:29
SumoXMLTag
SumoXMLTag
Numbers representing SUMO-XML - element names.
Definition: SUMOXMLDefinitions.h:41
SUMOVehicleParameter::depart
SUMOTime depart
Definition: SUMOVehicleParameter.h:482
VEHPARS_PROB_SET
const int VEHPARS_PROB_SET
Definition: SUMOVehicleParameter.h:54
SUMO_ATTR_CF_CC_FLATBED_KP
Definition: SUMOXMLDefinitions.h:868
SUMO_ATTR_JM_IGNORE_FOE_PROB
Definition: SUMOXMLDefinitions.h:619
VEHPARS_DEPARTSPEED_SET
const int VEHPARS_DEPARTSPEED_SET
Definition: SUMOVehicleParameter.h:49
SUMO_ATTR_LCA_EXPERIMENTAL1
Definition: SUMOXMLDefinitions.h:608
SUMO_ATTR_JM_TIMEGAP_MINOR
Definition: SUMOXMLDefinitions.h:621
SUMO_TAG_CF_IDM
Definition: SUMOXMLDefinitions.h:281
SUMO_TAG_CF_KRAUSSX
Definition: SUMOXMLDefinitions.h:278
SumoVehicleClassStrings
StringBijection< SUMOVehicleClass > SumoVehicleClassStrings(sumoVehicleClassStringInitializer, SVC_CUSTOM2, false)
VTYPEPARS_CAR_FOLLOW_MODEL
const int VTYPEPARS_CAR_FOLLOW_MODEL
Definition: SUMOVTypeParameter.h:64
SUMO_ATTR_JM_IGNORE_FOE_SPEED
Definition: SUMOXMLDefinitions.h:618
SUMOVehicleParameter::tag
SumoXMLTag tag
The vehicle tag.
Definition: SUMOVehicleParameter.h:465
SUMOVehicleParameter.h
SUMOVehicleParserHelper::parseVehicleAttributes
static SUMOVehicleParameter * parseVehicleAttributes(const SUMOSAXAttributes &attrs, const bool hardFail, const bool optionalID=false, const bool skipDepart=false, const bool isPerson=false)
Parses a vehicle's attributes.
Definition: SUMOVehicleParserHelper.cpp:231
SUMO_ATTR_BEGIN
weights: time range begin
Definition: SUMOXMLDefinitions.h:678
SVS_UNKNOWN
not defined
Definition: SUMOVehicleClass.h:52
SUMO_TAG_CF_CC
Definition: SUMOXMLDefinitions.h:290
SUMOXMLDefinitions::CarFollowModels
static StringBijection< SumoXMLTag > CarFollowModels
car following models
Definition: SUMOXMLDefinitions.h:1398
SUMO_ATTR_LCA_PUSHYGAP
Definition: SUMOXMLDefinitions.h:595
SUMO_ATTR_LCA_MAXSPEEDLATSTANDING
Definition: SUMOXMLDefinitions.h:602
MAX2
T MAX2(T a, T b)
Definition: StdDefs.h:79
VEHPARS_ARRIVALLANE_SET
const int VEHPARS_ARRIVALLANE_SET
Definition: SUMOVehicleParameter.h:56
VEHPARS_ROUTE_SET
const int VEHPARS_ROUTE_SET
Definition: SUMOVehicleParameter.h:55
SUMOVTypeParameter::parametersSet
int parametersSet
Information for the router which parameter were set.
Definition: SUMOVTypeParameter.h:307
SUMO_ATTR_PERSON_NUMBER
Definition: SUMOXMLDefinitions.h:651
VTYPEPARS_MAXSPEED_LAT_SET
const int VTYPEPARS_MAXSPEED_LAT_SET
Definition: SUMOVTypeParameter.h:65
SUMOVehicleParameter::line
std::string line
The vehicle's line (mainly for public transport)
Definition: SUMOVehicleParameter.h:561
StringTokenizer::get
std::string get(int pos) const
returns the item at the given position
Definition: StringTokenizer.cpp:124
SUMO_ATTR_LCA_SUBLANE_PARAM
Definition: SUMOXMLDefinitions.h:592
SUMOVehicleParserHelper::processActionStepLength
static SUMOTime processActionStepLength(double given)
Checks and converts given value for the action step length from seconds to miliseconds assuring it be...
Definition: SUMOVehicleParserHelper.cpp:1456
RGBColor
Definition: RGBColor.h:39
SUMO_TAG_ROUTEFLOW
a flow definition nusing a route instead of a from-to edges route (used in NETEDIT)
Definition: SUMOXMLDefinitions.h:151
SUMO_ATTR_ARRIVALSPEED
Definition: SUMOXMLDefinitions.h:439
RandHelper::rand
static double rand(std::mt19937 *rng=0)
Returns a random real number in [0, 1)
Definition: RandHelper.h:53
SUMO_ATTR_CF_W99_CC7
Definition: SUMOXMLDefinitions.h:849
SUMO_ATTR_CF_CC_CONSTSPACING
Definition: SUMOXMLDefinitions.h:854
SUMO_ATTR_APPARENTDECEL
Definition: SUMOXMLDefinitions.h:448
Distribution_Parameterized::getParameter
std::vector< double > & getParameter()
Returns the parameters of this distribution.
Definition: Distribution_Parameterized.cpp:110
SUMOVehicleParserHelper::allowedLCModelAttrs
static LCAttrMap allowedLCModelAttrs
allowed attrs for each known LC-model
Definition: SUMOVehicleParserHelper.h:202
SUMO_TAG_FLOW
a flow definitio nusing a from-to edges instead of a route (used by router)
Definition: SUMOXMLDefinitions.h:149
SUMO_ATTR_PROB
Definition: SUMOXMLDefinitions.h:629
SUMO_ATTR_DECEL
Definition: SUMOXMLDefinitions.h:446
VEHPARS_ARRIVALPOS_SET
const int VEHPARS_ARRIVALPOS_SET
Definition: SUMOVehicleParameter.h:57
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
SUMOVehicleParserHelper::beginVTypeParsing
static SUMOVTypeParameter * beginVTypeParsing(const SUMOSAXAttributes &attrs, const bool hardFail, const std::string &file)
Starts to parse a vehicle type.
Definition: SUMOVehicleParserHelper.cpp:501
SUMO_ATTR_COLLISION_MINGAP_FACTOR
Definition: SUMOXMLDefinitions.h:459
SUMO_ATTR_ACCEL
Definition: SUMOXMLDefinitions.h:445
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
SUMO_ATTR_GCC_GAIN_GAP_CACC
Definition: SUMOXMLDefinitions.h:571
SUMOVTypeParameter::height
double height
This class' height.
Definition: SUMOVTypeParameter.h:264
SUMO_TAG_CF_ACC
Definition: SUMOXMLDefinitions.h:287
PollutantsInterface.h
TIME2STEPS
#define TIME2STEPS(x)
Definition: SUMOTime.h:58
SUMO_ATTR_LCA_OPPOSITE_PARAM
Definition: SUMOXMLDefinitions.h:593
SUMO_ATTR_CF_W99_CC5
Definition: SUMOXMLDefinitions.h:847
SUMO_ATTR_CF_CC_FLATBED_H
Definition: SUMOXMLDefinitions.h:870
SUMO_ATTR_SC_GAIN_CACC
Definition: SUMOXMLDefinitions.h:570
SUMOVTypeParameter
Structure representing possible vehicle parameter.
Definition: SUMOVTypeParameter.h:86
VEHPARS_COLOR_SET
const int VEHPARS_COLOR_SET
Definition: SUMOVehicleParameter.h:45
SUMOVTypeParameter::jmParameter
SubParams jmParameter
Junction-model parameter.
Definition: SUMOVTypeParameter.h:287
StringBijection::get
T get(const std::string &str) const
Definition: StringBijection.h:97
SUMOVehicleShape
SUMOVehicleShape
Definition of vehicle classes to differ between different appearences.
Definition: SUMOVehicleClass.h:50
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
SUMOVTypeParameter::cfParameter
SubParams cfParameter
Car-following parameter.
Definition: SUMOVTypeParameter.h:281
StringTokenizer
Definition: StringTokenizer.h:61
SUMOVTypeParameter::defaultProbability
double defaultProbability
The probability when being added to a distribution without an explicit probability.
Definition: SUMOVTypeParameter.h:228
SUMO_ATTR_DEPARTPOS_LAT
Definition: SUMOXMLDefinitions.h:434
STEPS2TIME
#define STEPS2TIME(x)
Definition: SUMOTime.h:56
SVC_PASSENGER
vehicle is a passenger car (a "normal" car)
Definition: SUMOVehicleClass.h:159
SUMO_ATTR_LCA_SPEEDGAINRIGHT
Definition: SUMOXMLDefinitions.h:601
SUMO_ATTR_WIDTH
Definition: SUMOXMLDefinitions.h:386
SUMO_ATTR_DEPARTSPEED
Definition: SUMOXMLDefinitions.h:435
SUMOVehicleParameter::id
std::string id
The vehicle's id.
Definition: SUMOVehicleParameter.h:468
SUMO_ATTR_ROUTE
Definition: SUMOXMLDefinitions.h:440
SUMOVehicleParserHelper::parseCommonAttributes
static void parseCommonAttributes(const SUMOSAXAttributes &attrs, const bool hardFail, SUMOVehicleParameter *ret, std::string element)
Parses attributes common to vehicles and flows.
Definition: SUMOVehicleParserHelper.cpp:316
SUMO_ATTR_DEPARTLANE
Definition: SUMOXMLDefinitions.h:432
SUMO_ATTR_JM_DRIVE_RED_SPEED
Definition: SUMOXMLDefinitions.h:616
SUMOVehicleParameter::repetitionProbability
double repetitionProbability
The probability for emitting a vehicle per second.
Definition: SUMOVehicleParameter.h:553
VTYPEPARS_ACTIONSTEPLENGTH_SET
const int VTYPEPARS_ACTIONSTEPLENGTH_SET
Definition: SUMOVTypeParameter.h:68
SUMO_ATTR_CF_CC_PLOEG_KP
Definition: SUMOXMLDefinitions.h:863
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
SUMO_ATTR_CA_GAIN_SPEED
Definition: SUMOXMLDefinitions.h:564
SUMO_ATTR_CF_CC_LAMBDA
Definition: SUMOXMLDefinitions.h:856
SUMO_ATTR_CA_GAIN_GAP_CACC
Definition: SUMOXMLDefinitions.h:575
ProcessError
Definition: UtilExceptions.h:39
SUMO_ATTR_PERSON_CAPACITY
Definition: SUMOXMLDefinitions.h:649
SUMOVehicleParameter::arrivalPosProcedure
ArrivalPosDefinition arrivalPosProcedure
Information how the vehicle shall choose the arrival position.
Definition: SUMOVehicleParameter.h:525
SUMO_TAG_CF_KRAUSS_PLUS_SLOPE
Definition: SUMOXMLDefinitions.h:276
SUMO_ATTR_LCA_LOOKAHEADLEFT
Definition: SUMOXMLDefinitions.h:600
SUMO_ATTR_CONTAINER_NUMBER
Definition: SUMOXMLDefinitions.h:652
SUMOVTypeParameter::boardingDuration
SUMOTime boardingDuration
The time a person needs to board the vehicle.
Definition: SUMOVTypeParameter.h:252
SUMOVTypeParameter::minGap
double minGap
This class' free space in front of the vehicle itself.
Definition: SUMOVTypeParameter.h:218
SUMO_ATTR_LCA_OVERTAKE_RIGHT
Definition: SUMOXMLDefinitions.h:605
SUMOVehicleParameter::arrivalPosLat
double arrivalPosLat
(optional) The lateral position the vehicle shall arrive on
Definition: SUMOVehicleParameter.h:528
UtilExceptions.h
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
SUMO_ATTR_LCA_STRATEGIC_PARAM
Definition: SUMOXMLDefinitions.h:588
SUMOVTypeParameter::width
double width
This class' width.
Definition: SUMOVTypeParameter.h:261
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
SUMOVehicleParserHelper::parseVehicleClass
static SUMOVehicleClass parseVehicleClass(const SUMOSAXAttributes &attrs, const std::string &id)
Parses the vehicle class.
Definition: SUMOVehicleParserHelper.cpp:1392
SUMO_ATTR_JM_SIGMA_MINOR
Definition: SUMOXMLDefinitions.h:620
SUMOVTypeParameter::maxSpeedLat
double maxSpeedLat
The vehicle type's maximum lateral speed [m/s].
Definition: SUMOVTypeParameter.h:293
VEHPARS_ARRIVALPOSLAT_SET
const int VEHPARS_ARRIVALPOSLAT_SET
Definition: SUMOVehicleParameter.h:67
SUMOVTypeParameter::maxSpeed
double maxSpeed
The vehicle type's maximum speed [m/s].
Definition: SUMOVTypeParameter.h:221
SUMO_ATTR_SC_GAIN
Definition: SUMOXMLDefinitions.h:559
SUMOVTypeParameter::personCapacity
int personCapacity
The person capacity of the vehicle.
Definition: SUMOVTypeParameter.h:246
SUMOSAXAttributes::getOpt
T getOpt(int attr, const char *objectid, bool &ok, T defaultValue, bool report=true) const
Tries to read given attribute assuming it is an int.
Definition: SUMOSAXAttributes.h:518
SUMOVehicleParameter::routeid
std::string routeid
The vehicle's route id.
Definition: SUMOVehicleParameter.h:471
SUMOVehicleParameter::arrivalLane
int arrivalLane
Definition: SUMOVehicleParameter.h:516
SUMO_TAG_CF_PWAGNER2009
Definition: SUMOXMLDefinitions.h:283
VTYPEPARS_SPEEDFACTOR_SET
const int VTYPEPARS_SPEEDFACTOR_SET
Definition: SUMOVTypeParameter.h:49
SUMO_ATTR_LCA_IMPATIENCE
Definition: SUMOXMLDefinitions.h:597
SUMO_TAG_VEHICLE
description of a vehicle
Definition: SUMOXMLDefinitions.h:119
string2time
SUMOTime string2time(const std::string &r)
Definition: SUMOTime.cpp:44
VEHPARS_VPH_SET
const int VEHPARS_VPH_SET
Definition: SUMOVehicleParameter.h:53
SUMOVehicleParameter::departPosLat
double departPosLat
(optional) The lateral position the vehicle shall depart from
Definition: SUMOVehicleParameter.h:500
SUMOVehicleParserHelper::parseAngleTimesMap
static bool parseAngleTimesMap(SUMOVTypeParameter &vtype, const std::string, const bool hardFail)
Parse string containing AngleTimes triplets (angle, entry time, exit time)
Definition: SUMOVehicleParserHelper.cpp:835
SUMOVehicleParserHelper::CFAttrMap
std::map< SumoXMLTag, std::set< SumoXMLAttr > > CFAttrMap
Car-Following attributes map.
Definition: SUMOVehicleParserHelper.h:190
SUMO_ATTR_LCA_ASSERTIVE
Definition: SUMOXMLDefinitions.h:596
SUMO_TAG_CF_W99
Definition: SUMOXMLDefinitions.h:286
VEHPARS_DEPARTLANE_SET
const int VEHPARS_DEPARTLANE_SET
Definition: SUMOVehicleParameter.h:47
SUMO_ATTR_CF_CC_LANES_COUNT
Definition: SUMOXMLDefinitions.h:861
SUMO_ATTR_CF_WIEDEMANN_SECURITY
Definition: SUMOXMLDefinitions.h:841
SUMO_ATTR_CF_CC_FLATBED_D
Definition: SUMOXMLDefinitions.h:869
SUMO_ATTR_CF_CC_TAU
Definition: SUMOXMLDefinitions.h:860
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
SUMO_ATTR_GCC_GAIN_GAP_DOT_CACC
Definition: SUMOXMLDefinitions.h:572
DepartLaneDefinition
DepartLaneDefinition
Possible ways to choose a lane on depart.
Definition: SUMOVehicleParameter.h:116
SUMO_ATTR_CF_CC_XI
Definition: SUMOXMLDefinitions.h:858
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
SUMOVehicleParameter::repetitionEnd
SUMOTime repetitionEnd
The time at which the flow ends (only needed when using repetitionProbability)
Definition: SUMOVehicleParameter.h:556
SUMO_TAG_CF_WIEDEMANN
Definition: SUMOXMLDefinitions.h:285
SUMO_ATTR_JM_CROSSING_GAP
Definition: SUMOXMLDefinitions.h:613
VTYPEPARS_LOADING_DURATION
const int VTYPEPARS_LOADING_DURATION
Definition: SUMOVTypeParameter.h:63
SUMOVehicleParameter::departLane
int departLane
(optional) The lane the vehicle shall depart from (index in edge)
Definition: SUMOVehicleParameter.h:488
SumoVehicleShapeStrings
StringBijection< SUMOVehicleShape > SumoVehicleShapeStrings(sumoVehicleShapeStringInitializer, SVS_UNKNOWN, false)
SUMOVehicleParserHelper::getAllowedCFModelAttrs
static const CFAttrMap & getAllowedCFModelAttrs()
returns allowed attrs for each known CF-model (init on first use)
Definition: SUMOVehicleParserHelper.cpp:1015
SUMO_ATTR_CA_GAIN_GAP_DOT_CACC
Definition: SUMOXMLDefinitions.h:576
SUMO_ATTR_HEIGHT
Definition: SUMOXMLDefinitions.h:789
VTYPEPARS_CONTAINER_CAPACITY
const int VTYPEPARS_CONTAINER_CAPACITY
Definition: SUMOVTypeParameter.h:62
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
SUMO_ATTR_CF_PWAGNER2009_TAULAST
Definition: SUMOXMLDefinitions.h:834
SUMOVehicleParameter::departLaneProcedure
DepartLaneDefinition departLaneProcedure
Information how the vehicle shall choose the lane to depart from.
Definition: SUMOVehicleParameter.h:491
SUMOSAXAttributes::getName
virtual std::string getName(int attr) const =0
Converts the given attribute id into a man readable string.
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_TRAIN_TYPE
Definition: SUMOXMLDefinitions.h:583
SUMOVehicleParserHelper::parseFlowAttributes
static SUMOVehicleParameter * parseFlowAttributes(const SUMOSAXAttributes &attrs, const bool hardFail, const SUMOTime beginDefault, const SUMOTime endDefault, bool isPerson=false)
Parses a flow's attributes.
Definition: SUMOVehicleParserHelper.cpp:56
VEHPARS_DEPARTPOSLAT_SET
const int VEHPARS_DEPARTPOSLAT_SET
Definition: SUMOVehicleParameter.h:66
SUMO_ATTR_CF_CC_FLATBED_KV
Definition: SUMOXMLDefinitions.h:867
SUMO_ATTR_SIGMA
Definition: SUMOXMLDefinitions.h:548
SUMO_ATTR_CF_CC_PLOEG_H
Definition: SUMOXMLDefinitions.h:865
SUMOXMLDefinitions::Tags
static StringBijection< int > Tags
The names of SUMO-XML elements for use in netbuild.
Definition: SUMOXMLDefinitions.h:1359
SUMOVTypeParameter::latAlignment
LateralAlignment latAlignment
The vehicles desired lateral alignment.
Definition: SUMOVTypeParameter.h:296
SUMO_ATTR_CAR_FOLLOW_MODEL
Definition: SUMOXMLDefinitions.h:457
SUMO_ATTR_IMPATIENCE
Definition: SUMOXMLDefinitions.h:796
SUMOVTypeParameter::id
std::string id
The vehicle type's id.
Definition: SUMOVTypeParameter.h:212
SUMO_ATTR_REROUTE
Definition: SUMOXMLDefinitions.h:648
VEHPARS_CONTAINER_NUMBER_SET
const int VEHPARS_CONTAINER_NUMBER_SET
Definition: SUMOVehicleParameter.h:65
SUMOXMLDefinitions::TrainTypes
static StringBijection< TrainType > TrainTypes
train types
Definition: SUMOXMLDefinitions.h:1407
VEHPARS_DEPARTPOS_SET
const int VEHPARS_DEPARTPOS_SET
Definition: SUMOVehicleParameter.h:48
SUMO_ATTR_LCA_TIME_TO_IMPATIENCE
Definition: SUMOXMLDefinitions.h:598
InvalidArgument
Definition: UtilExceptions.h:56
SUMO_ATTR_TO_TAZ
Definition: SUMOXMLDefinitions.h:647
SUMOVehicleParserHelper::parseLCParams
static bool parseLCParams(SUMOVTypeParameter &into, LaneChangeModel model, const SUMOSAXAttributes &attrs, const bool hardFail)
Parses lane change model attributes.
Definition: SUMOVehicleParserHelper.cpp:1216
SUMO_ATTR_GUISHAPE
Definition: SUMOXMLDefinitions.h:790
VEHPARS_PERSON_NUMBER_SET
const int VEHPARS_PERSON_NUMBER_SET
Definition: SUMOVehicleParameter.h:64
SUMO_TAG_WALK
Definition: SUMOXMLDefinitions.h:298
SUMOXMLDefinitions::isValidVehicleID
static bool isValidVehicleID(const std::string &value)
whether the given string is a valid id for a vehicle or flow
Definition: SUMOXMLDefinitions.cpp:973
SUMO_ATTR_K
Definition: SUMOXMLDefinitions.h:819
SUMOVehicleParserHelper::parseJMParams
static bool parseJMParams(SUMOVTypeParameter &into, const SUMOSAXAttributes &attrs, const bool hardFail)
Parses junction model attributes.
Definition: SUMOVehicleParserHelper.cpp:1325
VEHPARS_FROM_TAZ_SET
const int VEHPARS_FROM_TAZ_SET
Definition: SUMOVehicleParameter.h:60
SUMO_TAG_CF_DANIEL1
Definition: SUMOXMLDefinitions.h:280
VTYPEPARS_PERSON_CAPACITY
const int VTYPEPARS_PERSON_CAPACITY
Definition: SUMOVTypeParameter.h:60
DepartPosDefinition
DepartPosDefinition
Possible ways to choose the departure position.
Definition: SUMOVehicleParameter.h:140
SUMOSAXAttributes.h
SUMO_ATTR_JM_DRIVE_AFTER_RED_TIME
Definition: SUMOXMLDefinitions.h:615
VTYPEPARS_HEIGHT_SET
const int VTYPEPARS_HEIGHT_SET
Definition: SUMOVTypeParameter.h:54
SUMO_ATTR_EMERGENCYDECEL
Definition: SUMOXMLDefinitions.h:447
SUMOVehicleParameter::arrivalPosLatProcedure
ArrivalPosLatDefinition arrivalPosLatProcedure
Information how the vehicle shall choose the lateral arrival position.
Definition: SUMOVehicleParameter.h:531
SUMO_ATTR_VCLASS
Definition: SUMOXMLDefinitions.h:450
SUMO_ATTR_CF_CC_PLOEG_KD
Definition: SUMOXMLDefinitions.h:864
SUMOVehicleParserHelper::parseWalkPos
static double parseWalkPos(SumoXMLAttr attr, const bool hardFail, const std::string &id, double maxPos, const std::string &val, std::mt19937 *rng=0)
parse departPos or arrivalPos for a walk
Definition: SUMOVehicleParserHelper.cpp:1432
FileHelpers::isAbsolute
static bool isAbsolute(const std::string &path)
Returns the information whether the given path is absolute.
Definition: FileHelpers.cpp:129
SUMO_TAG_CF_BKERNER
Definition: SUMOXMLDefinitions.h:284
SUMO_ATTR_GC_GAIN_SPEED
Definition: SUMOXMLDefinitions.h:562
VEHPARS_TO_TAZ_SET
const int VEHPARS_TO_TAZ_SET
Definition: SUMOVehicleParameter.h:61
SUMO_ATTR_CF_W99_CC6
Definition: SUMOXMLDefinitions.h:848
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
ARRIVAL_POS_MAX
The maximum arrival position is used.
Definition: SUMOVehicleParameter.h:240
SUMO_ATTR_MINGAP
Definition: SUMOXMLDefinitions.h:458
config.h
SUMO_ATTR_GCC_GAIN_SPACE
Definition: SUMOXMLDefinitions.h:561
SUMO_ATTR_ACTIONSTEPLENGTH
Definition: SUMOXMLDefinitions.h:449
RandHelper.h
StringTokenizer.h
SUMOVTypeParameter::loadingDuration
SUMOTime loadingDuration
The time a container needs to get loaded on the vehicle.
Definition: SUMOVTypeParameter.h:255
SUMO_ATTR_END
weights: time range end
Definition: SUMOXMLDefinitions.h:680
SUMOVTypeParameter::color
RGBColor color
The color.
Definition: SUMOVTypeParameter.h:237
SUMO_ATTR_HEADWAY_TIME_CACC_TO_ACC
Definition: SUMOXMLDefinitions.h:577
SUMO_ATTR_GC_GAIN_SPACE
Definition: SUMOXMLDefinitions.h:563
DepartSpeedDefinition
DepartSpeedDefinition
Possible ways to choose the departure speed.
Definition: SUMOVehicleParameter.h:192
SUMO_ATTR_MANEUVER_ANGLE_TIMES
Class specific timing values for vehicle manoeuvering through angle ranges.
Definition: SUMOXMLDefinitions.h:463
SUMO_ATTR_CF_W99_CC3
Definition: SUMOXMLDefinitions.h:845
VEHPARS_PERIOD_SET
const int VEHPARS_PERIOD_SET
Definition: SUMOVehicleParameter.h:52
VTYPEPARS_LENGTH_SET
const int VTYPEPARS_LENGTH_SET
Definition: SUMOVTypeParameter.h:45
SUMO_ATTR_DEPARTPOS
Definition: SUMOXMLDefinitions.h:433
SUMO_ATTR_TMP4
Definition: SUMOXMLDefinitions.h:553
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
SUMOXMLDefinitions::LateralAlignments
static StringBijection< LateralAlignment > LateralAlignments
lateral alignments
Definition: SUMOXMLDefinitions.h:1401
SUMO_TAG_CF_SMART_SK
Definition: SUMOXMLDefinitions.h:279
SUMOTime_MAX
#define SUMOTime_MAX
Definition: SUMOTime.h:35
VTYPEPARS_MANEUVER_ANGLE_TIMES_SET
const int VTYPEPARS_MANEUVER_ANGLE_TIMES_SET
Definition: SUMOVTypeParameter.h:73
SUMOVehicleParameter::speedFactor
double speedFactor
individual speedFactor (overriding distribution from vType)
Definition: SUMOVehicleParameter.h:668
Distribution_Parameterized::parse
void parse(const std::string &description, const bool hardFail)
Overwrite by parsable distribution description.
Definition: Distribution_Parameterized.cpp:57
SUMOVehicleParserHelper::parseID
static std::string parseID(const SUMOSAXAttributes &attrs, const SumoXMLTag element)
parse ID
Definition: SUMOVehicleParserHelper.cpp:293
SUMOVTypeParameter::emissionClass
SUMOEmissionClass emissionClass
The emission class of this vehicle.
Definition: SUMOVTypeParameter.h:234
SUMO_ATTR_VEHSPERHOUR
Definition: SUMOXMLDefinitions.h:786
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
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
SUMOVehicleParameter::repetitionNumber
int repetitionNumber
Definition: SUMOVehicleParameter.h:544
VEHPARS_END_SET
const int VEHPARS_END_SET
Definition: SUMOVehicleParameter.h:50
SUMOVehicleParserHelper::parseGuiShape
static SUMOVehicleShape parseGuiShape(const SUMOSAXAttributes &attrs, const std::string &id)
Parses the vehicle class.
Definition: SUMOVehicleParserHelper.cpp:1414
SumoXMLAttr
SumoXMLAttr
Numbers representing SUMO-XML - attributes.
Definition: SUMOXMLDefinitions.h:372
SVC_IGNORING
vehicles ignoring classes
Definition: SUMOVehicleClass.h:135
SUMO_ATTR_GCC_GAIN_SPEED
Definition: SUMOXMLDefinitions.h:560
SUMOVTypeParameter.h
VTYPEPARS_WIDTH_SET
const int VTYPEPARS_WIDTH_SET
Definition: SUMOVTypeParameter.h:53
SUMO_ATTR_NUMBER
Definition: SUMOXMLDefinitions.h:666
SUMOSAXAttributes
Encapsulated SAX-Attributes.
Definition: SUMOSAXAttributes.h:56
VTYPEPARS_IMPATIENCE_SET
const int VTYPEPARS_IMPATIENCE_SET
Definition: SUMOVTypeParameter.h:58
SUMO_ATTR_CA_GAIN_SPACE
Definition: SUMOXMLDefinitions.h:565
WRITE_ERROR
#define WRITE_ERROR(msg)
Definition: MsgHandler.h:283
SUMO_ATTR_LCA_SIGMA
Definition: SUMOXMLDefinitions.h:607
SUMO_ATTR_ARRIVALLANE
Definition: SUMOXMLDefinitions.h:436
SUMO_ATTR_EMISSIONCLASS
Definition: SUMOXMLDefinitions.h:795
VTYPEPARS_MAXSPEED_SET
const int VTYPEPARS_MAXSPEED_SET
Definition: SUMOVTypeParameter.h:47
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
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
LCM_DK2008
Definition: SUMOXMLDefinitions.h:1304
SUMO_TAG_TRIP
a single trip definition (used by router)
Definition: SUMOXMLDefinitions.h:145
SUMO_ATTR_LCA_PUSHY
Definition: SUMOXMLDefinitions.h:594
LCM_LC2013
Definition: SUMOXMLDefinitions.h:1305
VTYPEPARS_VEHICLECLASS_SET
const int VTYPEPARS_VEHICLECLASS_SET
Definition: SUMOVTypeParameter.h:52
SUMO_ATTR_CF_KERNER_PHI
Definition: SUMOXMLDefinitions.h:840
SUMO_ATTR_CF_CC_CCACCEL
Definition: SUMOXMLDefinitions.h:862
SUMOVehicleParameter::arrivalSpeed
double arrivalSpeed
(optional) The final speed of the vehicle (not used yet)
Definition: SUMOVehicleParameter.h:534
SUMO_ATTR_TAU
Definition: SUMOXMLDefinitions.h:549
SUMO_ATTR_CF_IDMM_ADAPT_TIME
Definition: SUMOXMLDefinitions.h:839
SUMO_ATTR_LCA_ACCEL_LAT
Definition: SUMOXMLDefinitions.h:599
SUMO_ATTR_CF_CC_OMEGAN
Definition: SUMOXMLDefinitions.h:859
SUMOVTypeParameter::minGapLat
double minGapLat
The vehicle type's minimum lateral gap [m].
Definition: SUMOVTypeParameter.h:299
SUMO_ATTR_LCA_TURN_ALIGNMENT_DISTANCE
Definition: SUMOXMLDefinitions.h:604
SUMO_ATTR_CF_W99_CC4
Definition: SUMOXMLDefinitions.h:846
LCM_SL2015
Definition: SUMOXMLDefinitions.h:1306
ArrivalSpeedDefinition
ArrivalSpeedDefinition
Possible ways to choose the arrival speed.
Definition: SUMOVehicleParameter.h:270