SUMO - Simulation of Urban MObility
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
SUMOVehicleParserHelper.cpp
Go to the documentation of this file.
1 /****************************************************************************/
11 // Helper methods for parsing vehicle attributes
12 /****************************************************************************/
13 // SUMO, Simulation of Urban MObility; see http://sumo.dlr.de/
14 // Copyright (C) 2008-2016 DLR (http://www.dlr.de/) and contributors
15 /****************************************************************************/
16 //
17 // This file is part of SUMO.
18 // SUMO is free software: you can redistribute it and/or modify
19 // it under the terms of the GNU General Public License as published by
20 // the Free Software Foundation, either version 3 of the License, or
21 // (at your option) any later version.
22 //
23 /****************************************************************************/
24 
25 
26 // ===========================================================================
27 // included modules
28 // ===========================================================================
29 #ifdef _MSC_VER
30 #include <windows_config.h>
31 #else
32 #include <config.h>
33 #endif
34 
35 #include <utils/common/ToString.h>
43 
44 #ifdef CHECK_MEMORY_LEAKS
45 #include <foreign/nvwa/debug_new.h>
46 #endif // CHECK_MEMORY_LEAKS
47 
48 
49 // ===========================================================================
50 // static members
51 // ===========================================================================
54 
55 
56 // ===========================================================================
57 // method definitions
58 // ===========================================================================
60 SUMOVehicleParserHelper::parseFlowAttributes(const SUMOSAXAttributes& attrs, const SUMOTime beginDefault, const SUMOTime endDefault) {
61  bool ok = true;
62  std::string id = attrs.get<std::string>(SUMO_ATTR_ID, 0, ok);
64  throw ProcessError("At most one of '" + attrs.getName(SUMO_ATTR_PERIOD) +
65  "' and '" + attrs.getName(SUMO_ATTR_VEHSPERHOUR) +
66  "' has to be given in the definition of flow '" + id + "'.");
67  }
69  throw ProcessError("At most one of '" + attrs.getName(SUMO_ATTR_PERIOD) +
70  "' and '" + attrs.getName(SUMO_ATTR_PROB) +
71  "' has to be given in the definition of flow '" + id + "'.");
72  }
74  throw ProcessError("At most one of '" + attrs.getName(SUMO_ATTR_PROB) +
75  "' and '" + attrs.getName(SUMO_ATTR_VEHSPERHOUR) +
76  "' has to be given in the definition of flow '" + id + "'.");
77  }
80  throw ProcessError("If '" + attrs.getName(SUMO_ATTR_PERIOD) +
81  "', '" + attrs.getName(SUMO_ATTR_VEHSPERHOUR) +
82  "' or '" + attrs.getName(SUMO_ATTR_PROB) +
83  "' are given at most one of '" + attrs.getName(SUMO_ATTR_END) +
84  "' and '" + attrs.getName(SUMO_ATTR_NUMBER) +
85  "' are allowed in flow '" + id + "'.");
86  }
87  } else {
88  if (!attrs.hasAttribute(SUMO_ATTR_NUMBER)) {
89  throw ProcessError("At least one of '" + attrs.getName(SUMO_ATTR_PERIOD) +
90  "', '" + attrs.getName(SUMO_ATTR_VEHSPERHOUR) +
91  "', '" + attrs.getName(SUMO_ATTR_PROB) +
92  "', and '" + attrs.getName(SUMO_ATTR_NUMBER) +
93  "' is needed in flow '" + id + "'.");
94  }
95  }
97  ret->id = id;
98  try {
99  parseCommonAttributes(attrs, ret, "flow");
100  } catch (ProcessError&) {
101  delete ret;
102  throw;
103  }
104 
105  // parse repetition information
106  if (attrs.hasAttribute(SUMO_ATTR_PERIOD)) {
108  ret->repetitionOffset = attrs.getSUMOTimeReporting(SUMO_ATTR_PERIOD, id.c_str(), ok);
109  }
110  if (attrs.hasAttribute(SUMO_ATTR_VEHSPERHOUR)) {
112  const SUMOReal vph = attrs.get<SUMOReal>(SUMO_ATTR_VEHSPERHOUR, id.c_str(), ok);
113  if (ok && vph <= 0) {
114  delete ret;
115  throw ProcessError("Invalid repetition rate in the definition of flow '" + id + "'.");
116  }
117  if (ok && vph != 0) {
118  ret->repetitionOffset = TIME2STEPS(3600. / vph);
119  }
120  }
121  if (attrs.hasAttribute(SUMO_ATTR_PROB)) {
122  ret->repetitionProbability = attrs.get<SUMOReal>(SUMO_ATTR_PROB, id.c_str(), ok);
123  if (ok && (ret->repetitionProbability <= 0 || ret->repetitionProbability > 1)) {
124  delete ret;
125  throw ProcessError("Invalid repetition probability in the definition of flow '" + id + "'.");
126  }
127  }
128 
129  ret->depart = beginDefault;
130  if (attrs.hasAttribute(SUMO_ATTR_BEGIN)) {
131  ret->depart = attrs.getSUMOTimeReporting(SUMO_ATTR_BEGIN, id.c_str(), ok);
132  }
133  if (ok && ret->depart < 0) {
134  delete ret;
135  throw ProcessError("Negative begin time in the definition of flow '" + id + "'.");
136  }
137  ret->repetitionEnd = endDefault;
138  if (ret->repetitionEnd < 0) {
140  }
141  if (attrs.hasAttribute(SUMO_ATTR_END)) {
142  ret->repetitionEnd = attrs.getSUMOTimeReporting(SUMO_ATTR_END, id.c_str(), ok);
143  }
144  if (ok && ret->repetitionEnd < ret->depart) {
145  delete ret;
146  throw ProcessError("Flow '" + id + "' ends before its begin time.");
147  }
148  if (attrs.hasAttribute(SUMO_ATTR_NUMBER)) {
149  ret->repetitionNumber = attrs.get<int>(SUMO_ATTR_NUMBER, id.c_str(), ok);
151  if (ret->repetitionNumber == 0) {
152  WRITE_WARNING("Flow '" + id + "' has 0 vehicles; will skip it.");
153  } else {
154  if (ok && ret->repetitionNumber < 0) {
155  delete ret;
156  throw ProcessError("Negative repetition number in the definition of flow '" + id + "'.");
157  }
158  if (ok && ret->repetitionOffset < 0) {
159  ret->repetitionOffset = (ret->repetitionEnd - ret->depart) / ret->repetitionNumber;
160  }
161  }
162  ret->repetitionEnd = ret->depart + ret->repetitionNumber * ret->repetitionOffset;
163  } else {
164  // interpret repetitionNumber
165  if (ok && ret->repetitionProbability > 0) {
167  } else {
168  if (ok && ret->repetitionOffset <= 0) {
169  delete ret;
170  throw ProcessError("Invalid repetition rate in the definition of flow '" + id + "'.");
171  }
172  if (ret->repetitionEnd == SUMOTime_MAX) {
174  } else {
175  ret->repetitionNumber = MAX2(1, (int)(((SUMOReal)(ret->repetitionEnd - ret->depart)) / ret->repetitionOffset + 0.5));
176  }
177  }
178  }
179  if (!ok) {
180  delete ret;
181  throw ProcessError();
182  }
183  return ret;
184 }
185 
186 
189  const bool optionalID, const bool skipDepart, const bool isPerson) {
190  bool ok = true;
191  std::string id, errorMsg;
192  if (optionalID) {
193  id = attrs.getOpt<std::string>(SUMO_ATTR_ID, 0, ok, "");
194  } else {
195  id = attrs.get<std::string>(SUMO_ATTR_ID, 0, ok);
196  }
198  ret->id = id;
199  if (isPerson) {
201  }
202  try {
203  parseCommonAttributes(attrs, ret, "vehicle");
204  if (!skipDepart) {
205  const std::string helper = attrs.get<std::string>(SUMO_ATTR_DEPART, ret->id.c_str(), ok);
206  if (!ok || !SUMOVehicleParameter::parseDepart(helper, "vehicle", ret->id, ret->depart, ret->departProcedure, errorMsg)) {
207  throw ProcessError(errorMsg);
208  }
209  }
210  } catch (ProcessError&) {
211  delete ret;
212  throw;
213  }
214  return ret;
215 }
216 
217 
218 void
220  SUMOVehicleParameter* ret, std::string element) {
221  //ret->refid = attrs.getStringSecure(SUMO_ATTR_REFID, "");
222  bool ok = true;
223  // parse route information
224  if (attrs.hasAttribute(SUMO_ATTR_ROUTE)) {
225  ret->setParameter |= VEHPARS_ROUTE_SET; // !!! needed?
226  ret->routeid = attrs.get<std::string>(SUMO_ATTR_ROUTE, ret->id.c_str(), ok);
227  }
228  // parse type information
229  if (attrs.hasAttribute(SUMO_ATTR_TYPE)) {
230  ret->setParameter |= VEHPARS_VTYPE_SET; // !!! needed?
231  ret->vtypeid = attrs.get<std::string>(SUMO_ATTR_TYPE, ret->id.c_str(), ok);
232  }
233  // parse line information
234  if (attrs.hasAttribute(SUMO_ATTR_LINE)) {
235  ret->setParameter |= VEHPARS_LINE_SET; // !!! needed?
236  ret->line = attrs.get<std::string>(SUMO_ATTR_LINE, ret->id.c_str(), ok);
237  }
238  // parse zone information
239  if (attrs.hasAttribute(SUMO_ATTR_FROM_TAZ)) {
241  ret->fromTaz = attrs.get<std::string>(SUMO_ATTR_FROM_TAZ, ret->id.c_str(), ok);
242  }
243  if (attrs.hasAttribute(SUMO_ATTR_TO_TAZ)) {
245  ret->toTaz = attrs.get<std::string>(SUMO_ATTR_TO_TAZ, ret->id.c_str(), ok);
246  }
247  // parse reroute information
248  if (attrs.getOpt<bool>(SUMO_ATTR_REROUTE, 0, ok, false)) {
250  }
251 
252  std::string error;
253  // parse depart lane information
254  if (attrs.hasAttribute(SUMO_ATTR_DEPARTLANE)) {
256  const std::string helper = attrs.get<std::string>(SUMO_ATTR_DEPARTLANE, ret->id.c_str(), ok);
257  if (!SUMOVehicleParameter::parseDepartLane(helper, element, ret->id, ret->departLane, ret->departLaneProcedure, error)) {
258  throw ProcessError(error);
259  }
260  }
261  // parse depart position information
262  if (attrs.hasAttribute(SUMO_ATTR_DEPARTPOS)) {
264  const std::string helper = attrs.get<std::string>(SUMO_ATTR_DEPARTPOS, ret->id.c_str(), ok);
265  if (!SUMOVehicleParameter::parseDepartPos(helper, element, ret->id, ret->departPos, ret->departPosProcedure, error)) {
266  throw ProcessError(error);
267  }
268  }
269  // parse lateral depart position information
272  const std::string helper = attrs.get<std::string>(SUMO_ATTR_DEPARTPOS_LAT, ret->id.c_str(), ok);
273  if (!SUMOVehicleParameter::parseDepartPosLat(helper, element, ret->id, ret->departPosLat, ret->departPosLatProcedure, error)) {
274  throw ProcessError(error);
275  }
276  }
277  // parse depart speed information
278  if (attrs.hasAttribute(SUMO_ATTR_DEPARTSPEED)) {
280  std::string helper = attrs.get<std::string>(SUMO_ATTR_DEPARTSPEED, ret->id.c_str(), ok);
281  if (!SUMOVehicleParameter::parseDepartSpeed(helper, element, ret->id, ret->departSpeed, ret->departSpeedProcedure, error)) {
282  throw ProcessError(error);
283  }
284  }
285 
286  // parse arrival lane information
287  if (attrs.hasAttribute(SUMO_ATTR_ARRIVALLANE)) {
289  std::string helper = attrs.get<std::string>(SUMO_ATTR_ARRIVALLANE, ret->id.c_str(), ok);
290  if (!SUMOVehicleParameter::parseArrivalLane(helper, element, ret->id, ret->arrivalLane, ret->arrivalLaneProcedure, error)) {
291  throw ProcessError(error);
292  }
293  }
294  // parse arrival position information
295  if (attrs.hasAttribute(SUMO_ATTR_ARRIVALPOS)) {
297  std::string helper = attrs.get<std::string>(SUMO_ATTR_ARRIVALPOS, ret->id.c_str(), ok);
298  if (!SUMOVehicleParameter::parseArrivalPos(helper, element, ret->id, ret->arrivalPos, ret->arrivalPosProcedure, error)) {
299  throw ProcessError(error);
300  }
301  }
302  // parse lateral arrival position information
305  std::string helper = attrs.get<std::string>(SUMO_ATTR_ARRIVALPOS_LAT, ret->id.c_str(), ok);
306  if (!SUMOVehicleParameter::parseArrivalPosLat(helper, element, ret->id, ret->arrivalPosLat, ret->arrivalPosLatProcedure, error)) {
307  throw ProcessError(error);
308  }
309  }
310  // parse arrival speed information
313  std::string helper = attrs.get<std::string>(SUMO_ATTR_ARRIVALSPEED, ret->id.c_str(), ok);
314  if (!SUMOVehicleParameter::parseArrivalSpeed(helper, element, ret->id, ret->arrivalSpeed, ret->arrivalSpeedProcedure, error)) {
315  throw ProcessError(error);
316  }
317  }
318 
319  // parse color
320  if (attrs.hasAttribute(SUMO_ATTR_COLOR)) {
322  ret->color = attrs.get<RGBColor>(SUMO_ATTR_COLOR, ret->id.c_str(), ok);
323  } else {
325  }
326  // parse person number
329  ret->personNumber = attrs.get<int>(SUMO_ATTR_PERSON_NUMBER, ret->id.c_str(), ok);
330  }
331  // parse container number
334  ret->containerNumber = attrs.get<int>(SUMO_ATTR_CONTAINER_NUMBER, ret->id.c_str(), ok);
335  }
336 }
337 
338 
340 SUMOVehicleParserHelper::beginVTypeParsing(const SUMOSAXAttributes& attrs, const std::string& file) {
341  bool ok = true;
342  std::string id = attrs.get<std::string>(SUMO_ATTR_ID, 0, ok);
344  if (attrs.hasAttribute(SUMO_ATTR_VCLASS)) {
345  vClass = parseVehicleClass(attrs, id);
346  }
347  SUMOVTypeParameter* vtype = new SUMOVTypeParameter(id, vClass);
348  if (attrs.hasAttribute(SUMO_ATTR_VCLASS)) {
350  }
351  if (attrs.hasAttribute(SUMO_ATTR_LENGTH)) {
352  vtype->length = attrs.get<SUMOReal>(SUMO_ATTR_LENGTH, vtype->id.c_str(), ok);
354  }
355  if (attrs.hasAttribute(SUMO_ATTR_MINGAP)) {
356  vtype->minGap = attrs.get<SUMOReal>(SUMO_ATTR_MINGAP, vtype->id.c_str(), ok);
358  }
359  if (attrs.hasAttribute(SUMO_ATTR_MAXSPEED)) {
360  vtype->maxSpeed = attrs.get<SUMOReal>(SUMO_ATTR_MAXSPEED, vtype->id.c_str(), ok);
362  }
363  if (attrs.hasAttribute(SUMO_ATTR_SPEEDFACTOR)) {
364  vtype->speedFactor = attrs.get<SUMOReal>(SUMO_ATTR_SPEEDFACTOR, vtype->id.c_str(), ok);
366  }
367  if (attrs.hasAttribute(SUMO_ATTR_SPEEDDEV)) {
368  vtype->speedDev = attrs.get<SUMOReal>(SUMO_ATTR_SPEEDDEV, vtype->id.c_str(), ok);
370  }
372  vtype->emissionClass = parseEmissionClass(attrs, vtype->id);
374  }
375  if (attrs.hasAttribute(SUMO_ATTR_IMPATIENCE)) {
376  if (attrs.get<std::string>(SUMO_ATTR_IMPATIENCE, vtype->id.c_str(), ok) == "off") {
378  } else {
379  vtype->impatience = attrs.get<SUMOReal>(SUMO_ATTR_IMPATIENCE, vtype->id.c_str(), ok);
380  }
382  }
383  if (attrs.hasAttribute(SUMO_ATTR_WIDTH)) {
384  vtype->width = attrs.get<SUMOReal>(SUMO_ATTR_WIDTH, vtype->id.c_str(), ok);
386  }
387  if (attrs.hasAttribute(SUMO_ATTR_HEIGHT)) {
388  vtype->height = attrs.get<SUMOReal>(SUMO_ATTR_HEIGHT, vtype->id.c_str(), ok);
390  }
391  if (attrs.hasAttribute(SUMO_ATTR_GUISHAPE)) {
392  vtype->shape = parseGuiShape(attrs, vtype->id);
394  }
395  if (attrs.hasAttribute(SUMO_ATTR_OSGFILE)) {
396  vtype->osgFile = attrs.get<std::string>(SUMO_ATTR_OSGFILE, vtype->id.c_str(), ok);
398  }
399  if (attrs.hasAttribute(SUMO_ATTR_IMGFILE)) {
400  vtype->imgFile = attrs.get<std::string>(SUMO_ATTR_IMGFILE, vtype->id.c_str(), ok);
401  if (vtype->imgFile != "" && !FileHelpers::isAbsolute(vtype->imgFile)) {
403  }
405  }
406  if (attrs.hasAttribute(SUMO_ATTR_COLOR)) {
407  vtype->color = attrs.get<RGBColor>(SUMO_ATTR_COLOR, vtype->id.c_str(), ok);
409  } else {
410  vtype->color = RGBColor::YELLOW;
411  }
412  if (attrs.hasAttribute(SUMO_ATTR_PROB)) {
413  vtype->defaultProbability = attrs.get<SUMOReal>(SUMO_ATTR_PROB, vtype->id.c_str(), ok);
415  }
417  std::string lcmS = attrs.get<std::string>(SUMO_ATTR_LANE_CHANGE_MODEL, vtype->id.c_str(), ok);
418  if (lcmS == "JE2013") {
419  WRITE_WARNING("Lane change model 'JE2013' is deprecated. Using default model instead.");
420  lcmS = "default";
421  }
422  if (SUMOXMLDefinitions::LaneChangeModels.hasString(lcmS)) {
424  } else {
425  WRITE_ERROR("Unknown lane change model '" + lcmS + "' when parsing vtype '" + vtype->id + "'");
426  throw ProcessError();
427  }
428  }
430  const std::string cfmS = attrs.get<std::string>(SUMO_ATTR_CAR_FOLLOW_MODEL, vtype->id.c_str(), ok);
431  if (SUMOXMLDefinitions::CarFollowModels.hasString(cfmS)) {
434  } else {
435  WRITE_ERROR("Unknown car following model '" + cfmS + "' when parsing vtype '" + vtype->id + "'");
436  throw ProcessError();
437  }
438  }
440  vtype->personCapacity = attrs.get<int>(SUMO_ATTR_PERSON_CAPACITY, vtype->id.c_str(), ok);
442  }
444  vtype->containerCapacity = attrs.get<int>(SUMO_ATTR_CONTAINER_CAPACITY, vtype->id.c_str(), ok);
446  }
448  vtype->boardingDuration = attrs.getSUMOTimeReporting(SUMO_ATTR_BOARDING_DURATION, vtype->id.c_str(), ok);
450  }
452  vtype->loadingDuration = attrs.getSUMOTimeReporting(SUMO_ATTR_LOADING_DURATION, vtype->id.c_str(), ok);
454  }
456  vtype->maxSpeedLat = attrs.get<SUMOReal>(SUMO_ATTR_MAXSPEED_LAT, vtype->id.c_str(), ok);
458  }
459  if (attrs.hasAttribute(SUMO_ATTR_MINGAP_LAT)) {
460  vtype->minGapLat = attrs.get<SUMOReal>(SUMO_ATTR_MINGAP_LAT, vtype->id.c_str(), ok);
462  }
464  const std::string alignS = attrs.get<std::string>(SUMO_ATTR_LATALIGNMENT, vtype->id.c_str(), ok);
465  if (SUMOXMLDefinitions::LateralAlignments.hasString(alignS)) {
468  } else {
469  WRITE_ERROR("Unknown lateral alignment '" + alignS + "' when parsing vtype '" + vtype->id + "'");
470  throw ProcessError();
471  }
472  }
473  parseVTypeEmbedded(*vtype, vtype->cfModel, attrs, true);
474  parseLCParams(*vtype, vtype->lcModel, attrs);
475  if (!ok) {
476  delete vtype;
477  throw ProcessError();
478  }
479  return vtype;
480 }
481 
482 
483 void
485  int element, const SUMOSAXAttributes& attrs,
486  bool fromVType) {
487  const CFAttrMap& allowedAttrs = getAllowedCFModelAttrs();
488  CFAttrMap::const_iterator cf_it;
489  for (cf_it = allowedAttrs.begin(); cf_it != allowedAttrs.end(); cf_it++) {
490  if (cf_it->first == element) {
491  break;
492  }
493  }
494  if (cf_it == allowedAttrs.end()) {
495  if (SUMOXMLDefinitions::Tags.has(element)) {
496  WRITE_ERROR("Unknown cfmodel " + toString((SumoXMLTag)element) + " when parsing vtype '" + into.id + "'");
497  } else {
498  WRITE_ERROR("Unknown cfmodel when parsing vtype '" + into.id + "'");
499  }
500  throw ProcessError();
501  return;
502  }
503  if (!fromVType) {
504  into.cfModel = cf_it->first;
506  }
507  bool ok = true;
508  for (std::set<SumoXMLAttr>::const_iterator it = cf_it->second.begin(); it != cf_it->second.end(); it++) {
509  if (attrs.hasAttribute(*it)) {
510  into.cfParameter[*it] = attrs.get<SUMOReal>(*it, into.id.c_str(), ok);
511  if (*it == SUMO_ATTR_TAU && TIME2STEPS(into.cfParameter[*it]) < DELTA_T) {
512  WRITE_WARNING("Value of tau=" + toString(into.cfParameter[*it])
513  + " in car following model '" + toString(into.cfModel) + "' lower than simulation step size may cause collisions");
514  }
515  }
516  }
517  if (!ok) {
518  throw ProcessError();
519  }
520 }
521 
522 
525  // init on first use
526  if (allowedCFModelAttrs.size() == 0) {
527  std::set<SumoXMLAttr> krausParams;
528  krausParams.insert(SUMO_ATTR_ACCEL);
529  krausParams.insert(SUMO_ATTR_DECEL);
530  krausParams.insert(SUMO_ATTR_SIGMA);
531  krausParams.insert(SUMO_ATTR_TAU);
535 
536  std::set<SumoXMLAttr> smartSKParams;
537  smartSKParams.insert(SUMO_ATTR_ACCEL);
538  smartSKParams.insert(SUMO_ATTR_DECEL);
539  smartSKParams.insert(SUMO_ATTR_SIGMA);
540  smartSKParams.insert(SUMO_ATTR_TAU);
541  smartSKParams.insert(SUMO_ATTR_TMP1);
542  smartSKParams.insert(SUMO_ATTR_TMP2);
543  smartSKParams.insert(SUMO_ATTR_TMP3);
544  smartSKParams.insert(SUMO_ATTR_TMP4);
545  smartSKParams.insert(SUMO_ATTR_TMP5);
546  allowedCFModelAttrs[SUMO_TAG_CF_SMART_SK] = smartSKParams;
547 
548  std::set<SumoXMLAttr> daniel1Params;
549  daniel1Params.insert(SUMO_ATTR_ACCEL);
550  daniel1Params.insert(SUMO_ATTR_DECEL);
551  daniel1Params.insert(SUMO_ATTR_SIGMA);
552  daniel1Params.insert(SUMO_ATTR_TAU);
553  daniel1Params.insert(SUMO_ATTR_TMP1);
554  daniel1Params.insert(SUMO_ATTR_TMP2);
555  daniel1Params.insert(SUMO_ATTR_TMP3);
556  daniel1Params.insert(SUMO_ATTR_TMP4);
557  daniel1Params.insert(SUMO_ATTR_TMP5);
558  allowedCFModelAttrs[SUMO_TAG_CF_DANIEL1] = daniel1Params;
559 
560  std::set<SumoXMLAttr> pwagParams;
561  pwagParams.insert(SUMO_ATTR_ACCEL);
562  pwagParams.insert(SUMO_ATTR_DECEL);
563  pwagParams.insert(SUMO_ATTR_SIGMA);
564  pwagParams.insert(SUMO_ATTR_TAU);
565  pwagParams.insert(SUMO_ATTR_CF_PWAGNER2009_TAULAST);
566  pwagParams.insert(SUMO_ATTR_CF_PWAGNER2009_APPROB);
568 
569  std::set<SumoXMLAttr> idmParams;
570  idmParams.insert(SUMO_ATTR_ACCEL);
571  idmParams.insert(SUMO_ATTR_DECEL);
572  idmParams.insert(SUMO_ATTR_TAU);
573  idmParams.insert(SUMO_ATTR_CF_IDM_DELTA);
574  idmParams.insert(SUMO_ATTR_CF_IDM_STEPPING);
576 
577  std::set<SumoXMLAttr> idmmParams;
578  idmmParams.insert(SUMO_ATTR_ACCEL);
579  idmmParams.insert(SUMO_ATTR_DECEL);
580  idmmParams.insert(SUMO_ATTR_TAU);
581  idmmParams.insert(SUMO_ATTR_CF_IDMM_ADAPT_FACTOR);
582  idmmParams.insert(SUMO_ATTR_CF_IDMM_ADAPT_TIME);
583  idmmParams.insert(SUMO_ATTR_CF_IDM_STEPPING);
585 
586  std::set<SumoXMLAttr> bkernerParams;
587  bkernerParams.insert(SUMO_ATTR_ACCEL);
588  bkernerParams.insert(SUMO_ATTR_DECEL);
589  bkernerParams.insert(SUMO_ATTR_TAU);
590  bkernerParams.insert(SUMO_ATTR_K);
591  bkernerParams.insert(SUMO_ATTR_CF_KERNER_PHI);
592  allowedCFModelAttrs[SUMO_TAG_CF_BKERNER] = bkernerParams;
593 
594  std::set<SumoXMLAttr> wiedemannParams;
595  wiedemannParams.insert(SUMO_ATTR_ACCEL);
596  wiedemannParams.insert(SUMO_ATTR_DECEL);
597  wiedemannParams.insert(SUMO_ATTR_CF_WIEDEMANN_SECURITY);
598  wiedemannParams.insert(SUMO_ATTR_CF_WIEDEMANN_ESTIMATION);
599  allowedCFModelAttrs[SUMO_TAG_CF_WIEDEMANN] = wiedemannParams;
600  }
601  return allowedCFModelAttrs;
602 }
603 
604 
605 void
607  if (allowedLCModelAttrs.size() == 0) {
608  // init static map
609  std::set<SumoXMLAttr> lc2013Params;
610  lc2013Params.insert(SUMO_ATTR_LCA_STRATEGIC_PARAM);
611  lc2013Params.insert(SUMO_ATTR_LCA_COOPERATIVE_PARAM);
612  lc2013Params.insert(SUMO_ATTR_LCA_SPEEDGAIN_PARAM);
613  lc2013Params.insert(SUMO_ATTR_LCA_KEEPRIGHT_PARAM);
614  allowedLCModelAttrs[LCM_LC2013] = lc2013Params;
615 
616  std::set<SumoXMLAttr> sl2015Params = lc2013Params;
617  sl2015Params.insert(SUMO_ATTR_LCA_PUSHY);
618  sl2015Params.insert(SUMO_ATTR_LCA_SUBLANE_PARAM);
619  sl2015Params.insert(SUMO_ATTR_LCA_ASSERTIVE);
620  allowedLCModelAttrs[LCM_SL2015] = sl2015Params;
621 
622  std::set<SumoXMLAttr> noParams;
623  allowedLCModelAttrs[LCM_DK2008] = noParams;
624 
625  // default model may be either LC2013 or SL2013
626  // we allow both sets (sl2015 is a superset of lc2013Params)
627  allowedLCModelAttrs[LCM_DEFAULT] = sl2015Params;
628  }
629  bool ok = true;
630  std::set<SumoXMLAttr> allowed = allowedLCModelAttrs[model];
631  for (std::set<SumoXMLAttr>::const_iterator it = allowed.begin(); it != allowed.end(); it++) {
632  if (attrs.hasAttribute(*it)) {
633  into.lcParameter[*it] = attrs.get<SUMOReal>(*it, into.id.c_str(), ok);
634  }
635  }
636  if (!ok) {
637  throw ProcessError();
638  }
639 }
640 
641 
644  const std::string& id) {
646  try {
647  bool ok = true;
648  std::string vclassS = attrs.getOpt<std::string>(SUMO_ATTR_VCLASS, id.c_str(), ok, "");
649  if (vclassS == "") {
650  return vclass;
651  }
652  const SUMOVehicleClass result = getVehicleClassID(vclassS);
653  const std::string& realName = SumoVehicleClassStrings.getString(result);
654  if (realName != vclassS) {
655  WRITE_WARNING("The vehicle class '" + vclassS + "' for " + attrs.getObjectType() + " '" + id + "' is deprecated, use '" + realName + "' instead.");
656  }
657  return result;
658  } catch (...) {
659  WRITE_ERROR("The class for " + attrs.getObjectType() + " '" + id + "' is not known.");
660  }
661  return vclass;
662 }
663 
664 
667  try {
668  bool ok = true;
669  std::string eClassS = attrs.getOpt<std::string>(SUMO_ATTR_EMISSIONCLASS, id.c_str(), ok, "");
670  return PollutantsInterface::getClassByName(eClassS);
671  } catch (...) {
672  WRITE_ERROR("The emission class for " + attrs.getObjectType() + " '" + id + "' is not known.");
673  return 0;
674  }
675 }
676 
677 
679 SUMOVehicleParserHelper::parseGuiShape(const SUMOSAXAttributes& attrs, const std::string& id) {
680  bool ok = true;
681  std::string vclassS = attrs.getOpt<std::string>(SUMO_ATTR_GUISHAPE, id.c_str(), ok, "");
682  if (SumoVehicleShapeStrings.hasString(vclassS)) {
683  const SUMOVehicleShape result = SumoVehicleShapeStrings.get(vclassS);
684  const std::string& realName = SumoVehicleShapeStrings.getString(result);
685  if (realName != vclassS) {
686  WRITE_WARNING("The shape '" + vclassS + "' for " + attrs.getObjectType() + " '" + id + "' is deprecated, use '" + realName + "' instead.");
687  }
688  return result;
689  } else {
690  WRITE_ERROR("The shape '" + vclassS + "' for " + attrs.getObjectType() + " '" + id + "' is not known.");
691  return SVS_UNKNOWN;
692  }
693 }
694 
695 /****************************************************************************/
696 
SUMOVehicleClass getVehicleClassID(const std::string &name)
Returns the class id of the abstract class given by its name.
const int VTYPEPARS_MAXSPEED_SET
const int VEHPARS_TO_TAZ_SET
const int VTYPEPARS_MINGAP_SET
SUMOTime repetitionEnd
The time at which the flow ends (only needed when using repetitionProbability)
SUMOReal repetitionProbability
The probability for emitting a vehicle per second.
static StringBijection< SumoXMLTag > CarFollowModels
SumoXMLTag
Numbers representing SUMO-XML - element names.
SumoXMLTag cfModel
The enum-representation of the car-following model to use.
RGBColor color
The vehicle's color.
const int VTYPEPARS_LATALIGNMENT_SET
long long int SUMOTime
Definition: SUMOTime.h:43
const int VEHPARS_FORCE_REROUTE
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:86
static bool parseDepartSpeed(const std::string &val, const std::string &element, const std::string &id, SUMOReal &speed, DepartSpeedDefinition &dsd, std::string &error)
Validates a given departSpeed value.
int repetitionNumber
The number of times the vehicle shall be repeatedly inserted.
std::string vtypeid
The vehicle's type id.
static bool parseArrivalPos(const std::string &val, const std::string &element, const std::string &id, SUMOReal &pos, ArrivalPosDefinition &apd, std::string &error)
Validates a given arrivalPos value.
static SUMOVehicleShape parseGuiShape(const SUMOSAXAttributes &attrs, const std::string &id)
Parses the vehicle class.
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types...
StringBijection< SUMOVehicleShape > SumoVehicleShapeStrings(sumoVehicleShapeStringInitializer, SVS_UNKNOWN, false)
static void parseVTypeEmbedded(SUMOVTypeParameter &into, int element, const SUMOSAXAttributes &attrs, bool fromVType=false)
Parses an element embedded in vtype definition.
virtual std::string getName(int attr) const =0
Converts the given attribute id into a man readable string.
ArrivalLaneDefinition arrivalLaneProcedure
Information how the vehicle shall choose the lane to arrive on.
SUMOVehicleShape shape
This class' shape.
Structure representing possible vehicle parameter.
const int VTYPEPARS_MINGAP_LAT_SET
DepartLaneDefinition departLaneProcedure
Information how the vehicle shall choose the lane to depart from.
SUMOReal departSpeed
(optional) The initial speed of the vehicle
SUMOReal speedDev
The standard deviation for speed variations.
static SUMOVehicleParameter * parseVehicleAttributes(const SUMOSAXAttributes &attrs, const bool optionalID=false, const bool skipDepart=false, const bool isPerson=false)
Parses a vehicle's attributes.
SUMOReal arrivalSpeed
(optional) The final speed of the vehicle (not used yet)
int containerCapacity
The container capacity of the vehicle.
SUMOReal length
The physical vehicle length.
const int VTYPEPARS_BOARDING_DURATION
ArrivalPosLatDefinition arrivalPosLatProcedure
Information how the vehicle shall choose the lateral arrival position.
SUMOReal arrivalPos
(optional) The position the vehicle shall arrive on
T MAX2(T a, T b)
Definition: StdDefs.h:75
SUMOTime DELTA_T
Definition: SUMOTime.cpp:39
const int VEHPARS_ARRIVALLANE_SET
SUMOReal width
This class' width.
ArrivalSpeedDefinition arrivalSpeedProcedure
Information how the vehicle's end speed shall be chosen.
const int VTYPEPARS_CAR_FOLLOW_MODEL
#define TIME2STEPS(x)
Definition: SUMOTime.h:66
const int VTYPEPARS_OSGFILE_SET
const int VTYPEPARS_MAXSPEED_LAT_SET
const int VTYPEPARS_PROBABILITY_SET
virtual bool hasAttribute(int id) const =0
Returns the information whether the named (by its enum-value) attribute is within the current list...
#define WRITE_WARNING(msg)
Definition: MsgHandler.h:200
static SUMOVehicleClass parseVehicleClass(const SUMOSAXAttributes &attrs, const std::string &id)
Parses the vehicle class.
SUMOTime repetitionOffset
The time offset between vehicle reinsertions.
static void parseLCParams(SUMOVTypeParameter &into, LaneChangeModel model, const SUMOSAXAttributes &attrs)
Parses lane change model attributes.
const std::string & getObjectType() const
return the objecttype to which these attributes belong
std::string toTaz
The vehicle's destination zone (district)
const int VEHPARS_ARRIVALSPEED_SET
static const CFAttrMap & getAllowedCFModelAttrs()
LaneChangeModel
SUMOReal speedFactor
The factor by which the maximum speed may deviate from the allowed max speed on the street...
#define max(a, b)
Definition: polyfonts.c:65
DepartSpeedDefinition departSpeedProcedure
Information how the vehicle's initial speed shall be chosen.
SUMOTime boardingDuration
The time a person needs to board the vehicle.
std::string routeid
The vehicle's route id.
DepartPosDefinition departPosProcedure
Information how the vehicle shall choose the departure position.
Encapsulated SAX-Attributes.
static SUMOVehicleParameter * parseFlowAttributes(const SUMOSAXAttributes &attrs, const SUMOTime beginDefault, const SUMOTime endDefault)
Parses a flow's attributes.
const int VEHPARS_DEPARTSPEED_SET
static bool isAbsolute(const std::string &path)
Returns the information whether the given path is absolute.
std::string osgFile
3D model file for this class
int SUMOEmissionClass
static void parseCommonAttributes(const SUMOSAXAttributes &attrs, SUMOVehicleParameter *ret, std::string element)
Parses attributes common to vehicles and flows.
static const RGBColor DEFAULT_COLOR
The default color (for vehicle types and vehicles)
Definition: RGBColor.h:200
not defined
SUMOReal maxSpeedLat
The vehicle type's maximum lateral speed [m/s].
std::map< SumoXMLTag, std::set< SumoXMLAttr > > CFAttrMap
int arrivalLane
(optional) The lane the vehicle shall arrive on (not used yet)
std::string imgFile
Image file for this class.
const int VEHPARS_DEPARTPOSLAT_SET
SUMOTime depart
The vehicle's departure time.
DepartDefinition departProcedure
Information how the vehicle shall choose the depart time.
const int VEHPARS_ROUTE_SET
std::string fromTaz
The vehicle's origin zone (district)
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.
StringBijection< SUMOVehicleClass > SumoVehicleClassStrings(sumoVehicleClassStringInitializer, SVC_CUSTOM2, false)
const int VTYPEPARS_SPEEDDEVIATION_SET
const int VTYPEPARS_LOADING_DURATION
std::string toString(const T &t, std::streamsize accuracy=OUTPUT_ACCURACY)
Definition: ToString.h:55
SUMOTime getSUMOTimeReporting(int attr, const char *objectid, bool &ok, bool report=true) const
Tries to read given attribute assuming it is a SUMOTime.
const int VTYPEPARS_CONTAINER_CAPACITY
const int VEHPARS_COLOR_SET
int personNumber
The static number of persons in the vehicle when it departs (not including boarding persons) ...
static bool parseDepartPos(const std::string &val, const std::string &element, const std::string &id, SUMOReal &pos, DepartPosDefinition &dpd, std::string &error)
Validates a given departPos value.
vehicle is a passenger car (a "normal" car)
const int VEHPARS_FROM_TAZ_SET
int departLane
(optional) The lane the vehicle shall depart from (index in edge)
std::string line
The vehicle's line (mainly for public transport)
const int VTYPEPARS_SPEEDFACTOR_SET
const int VEHPARS_ARRIVALPOSLAT_SET
const int VEHPARS_LINE_SET
static bool parseArrivalSpeed(const std::string &val, const std::string &element, const std::string &id, SUMOReal &speed, ArrivalSpeedDefinition &asd, std::string &error)
Validates a given arrivalSpeed value.
#define WRITE_ERROR(msg)
Definition: MsgHandler.h:206
SUMOReal maxSpeed
The vehicle type's maximum speed [m/s].
const int VEHPARS_ARRIVALPOS_SET
int personCapacity
The person capacity of the vehicle.
int setParameter
Information for the router which parameter were set.
static StringBijection< LateralAlignment > LateralAlignments
static const RGBColor YELLOW
Definition: RGBColor.h:192
Structure representing possible vehicle parameter.
SUMOReal impatience
The vehicle's impatience (willingness to obstruct others)
SUMOReal minGapLat
The vehicle type's minimum lateral gap [m].
#define SUMOTime_MAX
Definition: SUMOTime.h:44
SUMOVehicleShape
Definition of vehicle classes to differ between different appearences.
const int VEHPARS_PERIODFREQ_SET
static SUMOEmissionClass getClassByName(const std::string &eClass, const SUMOVehicleClass vc=SVC_IGNORING)
Checks whether the string describes a known vehicle class.
const std::string DEFAULT_PEDTYPE_ID
int setParameter
Information for the router which parameter were set.
SUMOReal defaultProbability
The probability when being added to a distribution without an explicit probability.
const int VTYPEPARS_IMGFILE_SET
SubParams cfParameter
Car-following parameter.
SUMOTime loadingDuration
The time a container needs to get loaded on the vehicle.
RGBColor color
The color.
const int VEHPARS_DEPARTLANE_SET
int containerNumber
The static number of containers in the vehicle when it departs.
std::string id
The vehicle type's id.
SUMOReal departPos
(optional) The position the vehicle shall depart from
const int VTYPEPARS_PERSON_CAPACITY
static bool parseDepartPosLat(const std::string &val, const std::string &element, const std::string &id, SUMOReal &pos, DepartPosLatDefinition &dpd, std::string &error)
Validates a given departPosLat value.
LateralAlignment latAlignment
The vehicles desired lateral alignment.
static bool parseArrivalPosLat(const std::string &val, const std::string &element, const std::string &id, SUMOReal &pos, ArrivalPosLatDefinition &apd, std::string &error)
Validates a given arrivalPosLat value.
T get(const std::string &str) const
const int VEHPARS_VTYPE_SET
const int VTYPEPARS_HEIGHT_SET
static SUMOEmissionClass parseEmissionClass(const SUMOSAXAttributes &attrs, const std::string &id)
Parses the vehicle emission class.
#define SUMOReal
Definition: config.h:214
const int VTYPEPARS_WIDTH_SET
static StringBijection< int > Tags
The names of SUMO-XML elements for use in netbuild.
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.
SUMOReal arrivalPosLat
(optional) The lateral position the vehicle shall arrive on
const int VEHPARS_DEPARTPOS_SET
T get(int attr, const char *objectid, bool &ok, bool report=true) const
Tries to read given attribute assuming it is an int.
const int VEHPARS_PERSON_NUMBER_SET
LaneChangeModel lcModel
The lane-change model to use.
SUMOReal height
This class' height.
const int VTYPEPARS_LENGTH_SET
const int VTYPEPARS_VEHICLECLASS_SET
static SUMOVTypeParameter * beginVTypeParsing(const SUMOSAXAttributes &attrs, const std::string &file)
Starts to parse a vehicle type.
const int VEHPARS_CONTAINER_NUMBER_SET
SUMOReal departPosLat
(optional) The lateral position the vehicle shall depart from
A color information.
const int VTYPEPARS_EMISSIONCLASS_SET
const int VTYPEPARS_COLOR_SET
const int VTYPEPARS_SHAPE_SET
SubParams lcParameter
Lane-changing parameter.
static StringBijection< LaneChangeModel > LaneChangeModels
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.
SUMOEmissionClass emissionClass
The emission class of this vehicle.
vehicles ignoring classes
std::map< LaneChangeModel, std::set< SumoXMLAttr > > LCAttrMap
ArrivalPosDefinition arrivalPosProcedure
Information how the vehicle shall choose the arrival position.
std::string id
The vehicle's id.
const int VTYPEPARS_IMPATIENCE_SET
SUMOReal minGap
This class' free space in front of the vehicle itself.
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.
DepartPosLatDefinition departPosLatProcedure
Information how the vehicle shall choose the lateral departure position.