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.dev/sumo
3 // Copyright (C) 2008-2024 German Aerospace Center (DLR) and others.
4 // This program and the accompanying materials are made available under the
5 // terms of the Eclipse Public License 2.0 which is available at
6 // https://www.eclipse.org/legal/epl-2.0/
7 // This Source Code may also be made available under the following Secondary
8 // Licenses when the conditions for such availability set forth in the Eclipse
9 // Public License 2.0 are satisfied: GNU General Public License, version 2
10 // or later which is available at
11 // https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
12 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
13 /****************************************************************************/
23 // Helper methods for parsing vehicle attributes
24 /****************************************************************************/
25 #include <config.h>
26 
27 #include <utils/common/FileHelpers.h>
28 #include <utils/common/MsgHandler.h>
29 #include <utils/common/RandHelper.h>
30 #include <utils/common/StringTokenizer.h>
31 #include <utils/common/StringUtils.h>
32 #include <utils/common/ToString.h>
33 #include <utils/common/UtilExceptions.h>
34 #include <utils/options/OptionsCont.h>
35 #include <utils/emissions/PollutantsInterface.h>
36 #include <utils/router/IntermodalNetwork.h>
37 #include <utils/vehicle/SUMOVTypeParameter.h>
38 #include <utils/vehicle/SUMOVehicleParameter.h>
39 #include <utils/xml/SUMOSAXAttributes.h>
40 
41 #include "SUMOVehicleParserHelper.h"
42 
43 
44 // ===========================================================================
45 // static members
46 // ===========================================================================
47 
48 SUMOVehicleParserHelper::CFAttrMap SUMOVehicleParserHelper::allowedCFModelAttrs;
49 SUMOVehicleParserHelper::LCAttrMap SUMOVehicleParserHelper::allowedLCModelAttrs;
50 
51 
52 // ===========================================================================
53 // method definitions
54 // ===========================================================================
55 
56 SUMOVehicleParameter*
57 SUMOVehicleParserHelper::parseFlowAttributes(SumoXMLTag tag, const SUMOSAXAttributes& attrs, const bool hardFail, const bool needID,
58  const SUMOTime beginDefault, const SUMOTime endDefault, const bool allowInternalRoutes) {
59  // first parse ID
60  const std::string id = attrs.hasAttribute(SUMO_ATTR_ID) ? parseID(attrs, tag) : "";
61  // check if ID is valid
62  if (!needID || !id.empty()) {
63  if (needID && !SUMOXMLDefinitions::isValidVehicleID(id)) {
64  return handleVehicleError(hardFail, nullptr, "Invalid flow id '" + id + "'.");
65  }
66  // declare flags
67  const bool hasPeriod = attrs.hasAttribute(SUMO_ATTR_PERIOD);
68  const bool hasVPH = attrs.hasAttribute(SUMO_ATTR_VEHSPERHOUR);
69  const bool hasPPH = attrs.hasAttribute(SUMO_ATTR_PERSONSPERHOUR);
70  const bool hasCPH = attrs.hasAttribute(SUMO_ATTR_CONTAINERSPERHOUR);
71  const bool hasPH = attrs.hasAttribute(SUMO_ATTR_PERHOUR);
72  const bool hasXPH = hasVPH || hasPPH || hasCPH || hasPH;
73  const bool hasProb = attrs.hasAttribute(SUMO_ATTR_PROB);
74  const bool hasNumber = attrs.hasAttribute(SUMO_ATTR_NUMBER);
75  const bool hasBegin = attrs.hasAttribute(SUMO_ATTR_BEGIN);
76  const bool hasEnd = attrs.hasAttribute(SUMO_ATTR_END);
77  SumoXMLAttr PERHOUR = SUMO_ATTR_PERHOUR;
78  if (hasVPH) {
79  PERHOUR = SUMO_ATTR_VEHSPERHOUR;
80  }
81  if (hasPPH) {
82  PERHOUR = SUMO_ATTR_PERSONSPERHOUR;
83  }
84  if (hasCPH) {
85  PERHOUR = SUMO_ATTR_CONTAINERSPERHOUR;
86  }
87  if (hasXPH && !(hasVPH ^ hasPPH ^ hasCPH ^ hasPH)) {
88  return handleVehicleError(hardFail, nullptr,
89  "At most one of '" + attrs.getName(SUMO_ATTR_PERHOUR) +
90  "', '" + attrs.getName(SUMO_ATTR_VEHSPERHOUR) +
91  "', '" + attrs.getName(SUMO_ATTR_PERSONSPERHOUR) +
92  "' and '" + attrs.getName(SUMO_ATTR_CONTAINERSPERHOUR) +
93  "' has to be given in the definition of " + toString(tag) + " '" + id + "'.");
94  }
95  if (hasPeriod && hasXPH) {
96  return handleVehicleError(hardFail, nullptr,
97  "At most one of '" + attrs.getName(SUMO_ATTR_PERIOD) +
98  "' and '" + attrs.getName(PERHOUR) +
99  "' has to be given in the definition of "
100  + toString(tag) + " '" + id + "'.");
101  }
102  if (hasPeriod && hasProb) {
103  return handleVehicleError(hardFail, nullptr,
104  "At most one of '" + attrs.getName(SUMO_ATTR_PERIOD) +
105  "' and '" + attrs.getName(SUMO_ATTR_PROB) +
106  "' has to be given in the definition of "
107  + toString(tag) + " '" + id + "'.");
108  }
109  if (hasProb && hasXPH) {
110  return handleVehicleError(hardFail, nullptr,
111  "At most one of '" + attrs.getName(SUMO_ATTR_PROB) +
112  "' and '" + attrs.getName(PERHOUR) +
113  "' has to be given in the definition of "
114  + toString(tag) + " '" + id + "'.");
115  }
116  if (hasPeriod || hasXPH || hasProb) {
117  if (hasEnd && hasNumber) {
118  return handleVehicleError(hardFail, nullptr,
119  "If '" + attrs.getName(SUMO_ATTR_PERIOD) +
120  "', '" + attrs.getName(SUMO_ATTR_VEHSPERHOUR) +
121  "', '" + attrs.getName(SUMO_ATTR_PERSONSPERHOUR) +
122  "', '" + attrs.getName(SUMO_ATTR_CONTAINERSPERHOUR) +
123  "', '" + attrs.getName(SUMO_ATTR_PERHOUR) +
124  "' or '" + attrs.getName(SUMO_ATTR_PROB) +
125  "' are given at most one of '" + attrs.getName(SUMO_ATTR_END) +
126  "' and '" + attrs.getName(SUMO_ATTR_NUMBER) +
127  "' are allowed in "
128  + toString(tag) + " '" + id + "'.");
129  }
130  } else {
131  if (!hasNumber) {
132  return handleVehicleError(hardFail, nullptr,
133  "At least one of '" + attrs.getName(SUMO_ATTR_PERIOD) +
134  "', '" + attrs.getName(SUMO_ATTR_VEHSPERHOUR) +
135  "', '" + attrs.getName(SUMO_ATTR_PERSONSPERHOUR) +
136  "', '" + attrs.getName(SUMO_ATTR_CONTAINERSPERHOUR) +
137  "', '" + attrs.getName(SUMO_ATTR_PERHOUR) +
138  "', '" + attrs.getName(SUMO_ATTR_PROB) +
139  "', and '" + attrs.getName(SUMO_ATTR_NUMBER) +
140  "' is needed in "
141  + toString(tag) + " '" + id + "'.");
142  }
143  }
144  // declare flow
145  SUMOVehicleParameter* flowParameter = new SUMOVehicleParameter();
146  // set tag
147  flowParameter->tag = tag;
148  // set id
149  flowParameter->id = id;
150  if (tag == SUMO_TAG_PERSONFLOW) {
151  flowParameter->vtypeid = DEFAULT_PEDTYPE_ID;
152  }
153  if (tag == SUMO_TAG_CONTAINERFLOW) {
154  flowParameter->vtypeid = DEFAULT_CONTAINERTYPE_ID;
155  }
156  // parse common vehicle attributes
157  try {
158  parseCommonAttributes(attrs, flowParameter, tag, allowInternalRoutes);
159  } catch (ProcessError& attributeError) {
160  // check if continue handling another vehicles or stop handling
161  if (hardFail) {
162  throw ProcessError(attributeError.what());
163  } else {
164  return nullptr;
165  }
166  }
167  // parse period
168  bool poissonFlow = false;
169  if (hasPeriod) {
170  bool ok = true;
171  const std::string description = attrs.get<std::string>(SUMO_ATTR_PERIOD, id.c_str(), ok);
172  const std::string distName = description.substr(0, description.find('('));
173  if (distName == "exp") {
174  // declare rate
175  double rate = -1;
176  // parse rate
177  try {
178  rate = StringUtils::toDouble(description.substr(distName.size() + 1, description.size() - distName.size() - 2));
179  } catch (ProcessError& attributeError) {
180  // check if continue handling another vehicles or stop handling
181  if (hardFail) {
182  throw ProcessError(attributeError.what());
183  } else {
184  return nullptr;
185  }
186  }
187  if (rate <= 0) {
188  return handleVehicleError(hardFail, flowParameter, "Invalid rate parameter for exponentially distributed period in the definition of " + toString(tag) + " '" + id + "'.");
189  }
190  flowParameter->poissonRate = rate;
191  poissonFlow = true;
192  } else {
193  flowParameter->repetitionOffset = attrs.getSUMOTimeReporting(SUMO_ATTR_PERIOD, id.c_str(), ok);
194  }
195  if (!ok) {
196  return handleVehicleError(hardFail, flowParameter);
197  } else {
198  flowParameter->parametersSet |= VEHPARS_PERIOD_SET;
199  }
200  }
201  // parse vehicle/person/container/etc per hour
202  if (hasXPH) {
203  bool ok = true;
204  const double vph = attrs.get<double>(PERHOUR, id.c_str(), ok);
205  if (!ok) {
206  return handleVehicleError(hardFail, flowParameter);
207  } else if (vph <= 0) {
208  return handleVehicleError(hardFail, flowParameter, "Invalid repetition rate in the definition of " + toString(tag) + " '" + id + "'.");
209  } else {
210  if (vph != 0) {
211  flowParameter->repetitionOffset = TIME2STEPS(3600. / vph);
212  }
213  flowParameter->parametersSet |= VEHPARS_VPH_SET;
214  }
215  }
216  // parse probability
217  if (hasProb) {
218  bool ok = true;
219  flowParameter->repetitionProbability = attrs.get<double>(SUMO_ATTR_PROB, id.c_str(), ok);
220  if (!ok) {
221  return handleVehicleError(hardFail, flowParameter);
222  } else if (flowParameter->repetitionProbability <= 0 || flowParameter->repetitionProbability > 1) {
223  return handleVehicleError(hardFail, flowParameter, "Invalid repetition probability in the definition of " + toString(tag) + " '" + id + "'.");
224  } else {
225  flowParameter->parametersSet |= VEHPARS_PROB_SET;
226  }
227  }
228  // set default begin
229  flowParameter->depart = beginDefault;
230  // parse begin
231  if (hasBegin) {
232  // first get begin
233  bool ok = true;
234  const std::string begin = attrs.get<std::string>(SUMO_ATTR_BEGIN, id.c_str(), ok);
235  if (!ok) {
236  return handleVehicleError(hardFail, flowParameter);
237  } else {
238  // parse begin
239  std::string errorMsg;
240  if (!SUMOVehicleParameter::parseDepart(begin, toString(tag), id, flowParameter->depart, flowParameter->departProcedure, errorMsg, "begin")) {
241  return handleVehicleError(hardFail, flowParameter, errorMsg);
242  }
243  }
244  }
245  if (flowParameter->depart < 0) {
246  return handleVehicleError(hardFail, flowParameter, "Negative begin time in the definition of " + toString(tag) + " '" + id + "'.");
247  }
248  // set default end
249  flowParameter->repetitionEnd = endDefault;
250  if (flowParameter->repetitionEnd < 0) {
251  flowParameter->repetitionEnd = SUMOTime_MAX;
252  }
253  // parse end
254  if (hasEnd) {
255  bool ok = true;
256  flowParameter->repetitionEnd = attrs.getSUMOTimeReporting(SUMO_ATTR_END, id.c_str(), ok);
257  if (!ok) {
258  return handleVehicleError(hardFail, flowParameter);
259  } else {
260  flowParameter->parametersSet |= VEHPARS_END_SET;
261  }
262  } else if (flowParameter->departProcedure == DepartDefinition::TRIGGERED) {
263  if (!hasNumber) {
264  return handleVehicleError(hardFail, flowParameter, toString(tag) + " '" + id + "' with triggered begin must define 'number'.");
265  } else {
266  flowParameter->repetitionEnd = flowParameter->depart;
267  }
268  } else if ((endDefault == SUMOTime_MAX || endDefault < 0) && (!hasNumber || (!hasProb && !hasPeriod && !hasXPH))) {
269  WRITE_WARNINGF(TL("Undefined end for % '%', defaulting to 24hour duration."), toString(tag), id);
270  flowParameter->repetitionEnd = flowParameter->depart + TIME2STEPS(24 * 3600);
271  }
272  if (flowParameter->repetitionEnd < flowParameter->depart) {
273  std::string flow = toString(tag);
274  flow[0] = (char)::toupper((char)flow[0]);
275  return handleVehicleError(hardFail, flowParameter, flow + " '" + id + "' ends before its begin time.");
276  }
277  // parse number
278  if (hasNumber) {
279  bool ok = true;
280  flowParameter->repetitionNumber = attrs.get<int>(SUMO_ATTR_NUMBER, id.c_str(), ok);
281  if (!ok) {
282  return handleVehicleError(hardFail, flowParameter);
283  } else {
284  flowParameter->parametersSet |= VEHPARS_NUMBER_SET;
285  if (flowParameter->repetitionNumber == 0) {
286  std::string flow = toString(tag);
287  flow[0] = (char)::toupper((char)flow[0]);
288  WRITE_WARNING(flow + " '" + id + "' has no instances; will skip it.");
289  flowParameter->repetitionEnd = flowParameter->depart;
290  } else {
291  if (flowParameter->repetitionNumber < 0) {
292  return handleVehicleError(hardFail, flowParameter, "Negative repetition number in the definition of " + toString(tag) + " '" + id + "'.");
293  }
294  if (flowParameter->repetitionOffset < 0 && !hasProb) {
295  if (poissonFlow) {
296  flowParameter->repetitionEnd = SUMOTime_MAX;
297  } else {
298  flowParameter->repetitionOffset = (flowParameter->repetitionEnd - flowParameter->depart) / flowParameter->repetitionNumber;
299  }
300  }
301  }
302  }
303  } else {
304  // interpret repetitionNumber
305  if (flowParameter->repetitionProbability > 0) {
306  flowParameter->repetitionNumber = std::numeric_limits<int>::max();
307  } else {
308  if (flowParameter->repetitionOffset <= 0) {
309  if (poissonFlow) {
310  // number is random but flow has a fixed end time
311  flowParameter->repetitionNumber = std::numeric_limits<int>::max();
312  } else {
313  return handleVehicleError(hardFail, flowParameter, "Invalid repetition rate in the definition of " + toString(tag) + " '" + id + "'.");
314  }
315  } else {
316  if (flowParameter->repetitionEnd == SUMOTime_MAX) {
317  flowParameter->repetitionNumber = std::numeric_limits<int>::max();
318  } else {
319  const SUMOTime repLength = flowParameter->repetitionEnd - flowParameter->depart;
320  flowParameter->repetitionNumber = (int)ceil((double)repLength / (double)flowParameter->repetitionOffset);
321  }
322  }
323  }
324  }
325  // all ok, then return flow parameter
326  return flowParameter;
327  } else {
328  return handleVehicleError(hardFail, nullptr, toString(tag) + " cannot be created");
329  }
330 }
331 
332 
333 SUMOVehicleParameter*
334 SUMOVehicleParserHelper::parseVehicleAttributes(int element, const SUMOSAXAttributes& attrs, const bool hardFail, const bool optionalID, const bool skipDepart, const bool allowInternalRoutes) {
335  // declare vehicle ID
336  std::string id;
337  // for certain vehicles, ID can be optional
338  if (optionalID) {
339  bool ok = true;
340  id = attrs.getOpt<std::string>(SUMO_ATTR_ID, nullptr, ok, "");
341  if (!ok) {
342  return handleVehicleError(hardFail, nullptr);
343  }
344  } else {
345  // parse ID
346  id = parseID(attrs, (SumoXMLTag)element);
347  }
348  // only continue if id is valid, or if is optional
349  if (optionalID || !id.empty()) {
350  // declare vehicle parameter
351  SUMOVehicleParameter* vehicleParameter = new SUMOVehicleParameter();
352  vehicleParameter->id = id;
353  if (element == SUMO_TAG_PERSON) {
354  vehicleParameter->vtypeid = DEFAULT_PEDTYPE_ID;
355  } else if (element == SUMO_TAG_CONTAINER) {
356  vehicleParameter->vtypeid = DEFAULT_CONTAINERTYPE_ID;
357  }
358  // parse common attributes
359  try {
360  parseCommonAttributes(attrs, vehicleParameter, (SumoXMLTag)element, allowInternalRoutes);
361  } catch (ProcessError& attributeError) {
362  // check if continue handling another vehicles or stop handling
363  if (hardFail) {
364  throw ProcessError(attributeError.what());
365  } else {
366  return nullptr;
367  }
368  }
369  // check depart
370  if (!skipDepart) {
371  bool ok = true;
372  const std::string helper = attrs.get<std::string>(SUMO_ATTR_DEPART, vehicleParameter->id.c_str(), ok);
373  if (!ok) {
374  return handleVehicleError(hardFail, vehicleParameter);
375  }
376  // now parse depart
377  std::string departErrorMsg;
378  if (!SUMOVehicleParameter::parseDepart(helper, "vehicle", vehicleParameter->id, vehicleParameter->depart, vehicleParameter->departProcedure, departErrorMsg)) {
379  return handleVehicleError(hardFail, vehicleParameter, departErrorMsg);
380  }
381  }
382  // set tag
383  vehicleParameter->tag = (SumoXMLTag)element;
384  // all ok, then return vehicleParameter
385  return vehicleParameter;
386  } else {
387  return handleVehicleError(hardFail, nullptr, toString((SumoXMLTag)element) + " cannot be created");
388  }
389 }
390 
391 
392 std::string
393 SUMOVehicleParserHelper::parseID(const SUMOSAXAttributes& attrs, const SumoXMLTag element) {
394  bool ok = true;
395  std::string id;
396  // first check if attrs contain an ID
397  if (attrs.hasAttribute(SUMO_ATTR_ID)) {
398  id = attrs.get<std::string>(SUMO_ATTR_ID, nullptr, ok);
399  if (SUMOXMLDefinitions::isValidVehicleID(id)) {
400  return id;
401  } else if (id.empty()) {
402  // add extra information for empty IDs
403  WRITE_ERRORF(TL("Invalid % id '%'."), toString(element), id);
404  } else {
405  WRITE_ERRORF(TL("Invalid % id '%'. Contains invalid characters."), toString(element), id);
406  }
407  } else {
408  WRITE_ERROR("Attribute '" + toString(SUMO_ATTR_ID) + "' is missing in definition of " + toString(element));
409  }
410  // return empty (invalid) ID
411  return "";
412 }
413 
414 
415 void
416 SUMOVehicleParserHelper::parseCommonAttributes(const SUMOSAXAttributes& attrs, SUMOVehicleParameter* ret, SumoXMLTag tag, const bool allowInternalRoutes) {
417  const std::string element = toString(tag);
418  //ret->refid = attrs.getStringSecure(SUMO_ATTR_REFID, "");
419  // parse route information
420  if (attrs.hasAttribute(SUMO_ATTR_ROUTE)) {
421  bool ok = true;
422  std::string routeID = attrs.get<std::string>(SUMO_ATTR_ROUTE, ret->id.c_str(), ok);
423  if (!allowInternalRoutes && isInternalRouteID(routeID)) {
424  WRITE_WARNINGF(TL("Internal routes receive an ID starting with '!' and must not be referenced in other vehicle or flow definitions. Please remove all references to route '%' in case it is internal."), routeID);
425  }
426  ret->routeid = routeID;
427  if (ok) {
428  ret->parametersSet |= VEHPARS_ROUTE_SET; // !!! needed?
429  } else {
430  handleVehicleError(true, ret);
431  }
432  }
433  // parse type information
434  if (attrs.hasAttribute(SUMO_ATTR_TYPE)) {
435  bool ok = true;
436  ret->vtypeid = attrs.get<std::string>(SUMO_ATTR_TYPE, ret->id.c_str(), ok);
437  if (ok) {
438  ret->parametersSet |= VEHPARS_VTYPE_SET; // !!! needed?
439  } else {
440  handleVehicleError(true, ret);
441  }
442  }
443  // parse line information
444  if (attrs.hasAttribute(SUMO_ATTR_LINE)) {
445  bool ok = true;
446  ret->line = attrs.get<std::string>(SUMO_ATTR_LINE, ret->id.c_str(), ok);
447  if (ok) {
448  ret->parametersSet |= VEHPARS_LINE_SET; // !!! needed?
449  } else {
450  handleVehicleError(true, ret);
451  }
452  }
453  // parse zone information
454  if (attrs.hasAttribute(SUMO_ATTR_FROM_TAZ)) {
455  bool ok = true;
456  ret->fromTaz = attrs.get<std::string>(SUMO_ATTR_FROM_TAZ, ret->id.c_str(), ok);
457  if (ok) {
458  ret->parametersSet |= VEHPARS_FROM_TAZ_SET;
459  } else {
460  handleVehicleError(true, ret);
461  }
462  }
463  if (attrs.hasAttribute(SUMO_ATTR_TO_TAZ)) {
464  bool ok = true;
465  ret->toTaz = attrs.get<std::string>(SUMO_ATTR_TO_TAZ, ret->id.c_str(), ok);
466  if (ok) {
467  ret->parametersSet |= VEHPARS_TO_TAZ_SET;
468  } else {
469  handleVehicleError(true, ret);
470  }
471  }
472  // parse reroute information
473  if (attrs.hasAttribute(SUMO_ATTR_REROUTE)) {
474  bool ok = true;
475  if (attrs.get<bool>(SUMO_ATTR_REROUTE, ret->id.c_str(), ok)) {
476  if (ok) {
477  ret->parametersSet |= VEHPARS_FORCE_REROUTE;
478  } else {
479  handleVehicleError(true, ret);
480  }
481  }
482  }
483  // parse depart lane information
484  if (attrs.hasAttribute(SUMO_ATTR_DEPARTLANE)) {
485  bool ok = true;
486  const std::string departLaneStr = attrs.get<std::string>(SUMO_ATTR_DEPARTLANE, ret->id.c_str(), ok);
487  int lane;
488  DepartLaneDefinition dld;
489  std::string error;
490  if (SUMOVehicleParameter::parseDepartLane(departLaneStr, element, ret->id, lane, dld, error)) {
491  ret->parametersSet |= VEHPARS_DEPARTLANE_SET;
492  ret->departLane = lane;
493  ret->departLaneProcedure = dld;
494  } else {
495  handleVehicleError(true, ret, error);
496  }
497  }
498  // parse depart position information
499  if (attrs.hasAttribute(SUMO_ATTR_DEPARTPOS)) {
500  bool ok = true;
501  const std::string departPosStr = attrs.get<std::string>(SUMO_ATTR_DEPARTPOS, ret->id.c_str(), ok);
502  double pos;
503  DepartPosDefinition dpd;
504  std::string error;
505  if (SUMOVehicleParameter::parseDepartPos(departPosStr, element, ret->id, pos, dpd, error)) {
506  ret->parametersSet |= VEHPARS_DEPARTPOS_SET;
507  ret->departPos = pos;
508  ret->departPosProcedure = dpd;
509  } else {
510  handleVehicleError(true, ret, error);
511  }
512  }
513  // parse lateral depart position information
514  if (attrs.hasAttribute(SUMO_ATTR_DEPARTPOS_LAT)) {
515  bool ok = true;
516  const std::string departPosLatStr = attrs.get<std::string>(SUMO_ATTR_DEPARTPOS_LAT, ret->id.c_str(), ok);
517  double pos;
518  DepartPosLatDefinition dpd;
519  std::string error;
520  if (SUMOVehicleParameter::parseDepartPosLat(departPosLatStr, element, ret->id, pos, dpd, error)) {
521  ret->parametersSet |= VEHPARS_DEPARTPOSLAT_SET;
522  ret->departPosLat = pos;
523  ret->departPosLatProcedure = dpd;
524  } else {
525  handleVehicleError(true, ret, error);
526  }
527  }
528  // parse depart speed information
529  if (attrs.hasAttribute(SUMO_ATTR_DEPARTSPEED)) {
530  bool ok = true;
531  const std::string departSpeed = attrs.get<std::string>(SUMO_ATTR_DEPARTSPEED, ret->id.c_str(), ok);
532  double speed;
533  DepartSpeedDefinition dsd;
534  std::string error;
535  if (SUMOVehicleParameter::parseDepartSpeed(departSpeed, element, ret->id, speed, dsd, error)) {
536  ret->parametersSet |= VEHPARS_DEPARTSPEED_SET;
537  ret->departSpeed = speed;
538  ret->departSpeedProcedure = dsd;
539  } else {
540  handleVehicleError(true, ret, error);
541  }
542  }
543  // parse depart edge information
544  if (attrs.hasAttribute(SUMO_ATTR_DEPARTEDGE)) {
545  bool ok = true;
546  const std::string departEdgeStr = attrs.get<std::string>(SUMO_ATTR_DEPARTEDGE, ret->id.c_str(), ok);
547  int edgeIndex;
548  RouteIndexDefinition rid;
549  std::string error;
550  if (SUMOVehicleParameter::parseRouteIndex(departEdgeStr, element, ret->id, SUMO_ATTR_DEPARTEDGE, edgeIndex, rid, error)) {
551  ret->parametersSet |= VEHPARS_DEPARTEDGE_SET;
552  ret->departEdge = edgeIndex;
553  ret->departEdgeProcedure = rid;
554  } else {
555  handleVehicleError(true, ret, error);
556  }
557  }
558  // parse arrival lane information
559  if (attrs.hasAttribute(SUMO_ATTR_ARRIVALLANE)) {
560  bool ok = true;
561  const std::string arrivalLaneStr = attrs.get<std::string>(SUMO_ATTR_ARRIVALLANE, ret->id.c_str(), ok);
562  int lane;
563  ArrivalLaneDefinition ald;
564  std::string error;
565  if (SUMOVehicleParameter::parseArrivalLane(arrivalLaneStr, element, ret->id, lane, ald, error)) {
566  ret->parametersSet |= VEHPARS_ARRIVALLANE_SET;
567  ret->arrivalLane = lane;
568  ret->arrivalLaneProcedure = ald;
569  } else {
570  handleVehicleError(true, ret, error);
571  }
572  }
573  // parse arrival position information
574  if (attrs.hasAttribute(SUMO_ATTR_ARRIVALPOS)) {
575  bool ok = true;
576  const std::string arrivalPosStr = attrs.get<std::string>(SUMO_ATTR_ARRIVALPOS, ret->id.c_str(), ok);
577  double pos;
578  ArrivalPosDefinition apd;
579  std::string error;
580  if (SUMOVehicleParameter::parseArrivalPos(arrivalPosStr, element, ret->id, pos, apd, error)) {
581  ret->parametersSet |= VEHPARS_ARRIVALPOS_SET;
582  ret->arrivalPos = pos;
583  ret->arrivalPosProcedure = apd;
584  } else {
585  handleVehicleError(true, ret, error);
586  }
587  }
588  // parse lateral arrival position information
589  if (attrs.hasAttribute(SUMO_ATTR_ARRIVALPOS_LAT)) {
590  bool ok = true;
591  const std::string arrivalPosLatStr = attrs.get<std::string>(SUMO_ATTR_ARRIVALPOS_LAT, ret->id.c_str(), ok);
592  double pos;
593  ArrivalPosLatDefinition apd;
594  std::string error;
595  if (SUMOVehicleParameter::parseArrivalPosLat(arrivalPosLatStr, element, ret->id, pos, apd, error)) {
596  ret->parametersSet |= VEHPARS_ARRIVALPOSLAT_SET;
597  ret->arrivalPosLat = pos;
598  ret->arrivalPosLatProcedure = apd;
599  } else {
600  handleVehicleError(true, ret, error);
601  }
602  }
603  // parse arrival speed information
604  if (attrs.hasAttribute(SUMO_ATTR_ARRIVALSPEED)) {
605  bool ok = true;
606  std::string arrivalSpeedStr = attrs.get<std::string>(SUMO_ATTR_ARRIVALSPEED, ret->id.c_str(), ok);
607  double speed;
608  ArrivalSpeedDefinition asd;
609  std::string error;
610  if (SUMOVehicleParameter::parseArrivalSpeed(arrivalSpeedStr, element, ret->id, speed, asd, error)) {
611  ret->parametersSet |= VEHPARS_ARRIVALSPEED_SET;
612  ret->arrivalSpeed = speed;
613  ret->arrivalSpeedProcedure = asd;
614  } else {
615  handleVehicleError(true, ret, error);
616  }
617  }
618  // parse arrival edge information
619  if (attrs.hasAttribute(SUMO_ATTR_ARRIVALEDGE)) {
620  bool ok = true;
621  std::string arrivalEdgeStr = attrs.get<std::string>(SUMO_ATTR_ARRIVALEDGE, ret->id.c_str(), ok);
622  int edgeIndex;
623  RouteIndexDefinition rid;
624  std::string error;
625  if (SUMOVehicleParameter::parseRouteIndex(arrivalEdgeStr, element, ret->id, SUMO_ATTR_ARRIVALEDGE, edgeIndex, rid, error)) {
626  ret->parametersSet |= VEHPARS_ARRIVALEDGE_SET;
627  ret->arrivalEdge = edgeIndex;
628  ret->arrivalEdgeProcedure = rid;
629  } else {
630  handleVehicleError(true, ret, error);
631  }
632  }
633  // parse color
634  if (attrs.hasAttribute(SUMO_ATTR_COLOR)) {
635  bool ok = true;
636  ret->color = attrs.get<RGBColor>(SUMO_ATTR_COLOR, ret->id.c_str(), ok);
637  if (ok) {
638  ret->parametersSet |= VEHPARS_COLOR_SET;
639  } else {
640  handleVehicleError(true, ret, "Invalid RGBColor format");
641  }
642  } else {
643  ret->color = RGBColor::DEFAULT_COLOR;
644  }
645  // parse person number
646  if (attrs.hasAttribute(SUMO_ATTR_PERSON_NUMBER)) {
647  bool ok = true;
648  int personNumber = attrs.get<int>(SUMO_ATTR_PERSON_NUMBER, ret->id.c_str(), ok);
649  if (!ok) {
650  handleVehicleError(true, ret);
651  } else if (personNumber >= 0) {
652  ret->parametersSet |= VEHPARS_PERSON_NUMBER_SET;
653  ret->personNumber = personNumber;
654  } else {
655  handleVehicleError(true, ret, toString(SUMO_ATTR_PERSON_NUMBER) + " cannot be negative");
656  }
657  }
658  // parse container number
659  if (attrs.hasAttribute(SUMO_ATTR_CONTAINER_NUMBER)) {
660  bool ok = true;
661  int containerNumber = attrs.get<int>(SUMO_ATTR_CONTAINER_NUMBER, ret->id.c_str(), ok);
662  if (!ok) {
663  handleVehicleError(true, ret);
664  } else if (containerNumber >= 0) {
665  ret->parametersSet |= VEHPARS_CONTAINER_NUMBER_SET;
666  ret->containerNumber = containerNumber;
667  } else {
668  handleVehicleError(true, ret, toString(SUMO_ATTR_CONTAINER_NUMBER) + " cannot be negative");
669  }
670  }
671  // parse individual speedFactor
672  if (attrs.hasAttribute(SUMO_ATTR_SPEEDFACTOR)) {
673  bool ok = true;
674  double speedFactor = attrs.get<double>(SUMO_ATTR_SPEEDFACTOR, ret->id.c_str(), ok);
675  if (!ok) {
676  handleVehicleError(true, ret);
677  } else if (speedFactor > 0) {
678  ret->parametersSet |= VEHPARS_SPEEDFACTOR_SET;
679  ret->speedFactor = speedFactor;
680  } else {
681  handleVehicleError(true, ret, toString(SUMO_ATTR_SPEEDFACTOR) + " must be positive");
682  }
683  }
684  // parse insertion checks
685  if (attrs.hasAttribute(SUMO_ATTR_INSERTIONCHECKS)) {
686  ret->insertionChecks = 0;
687  bool ok = true;
688  std::vector<std::string> checks = attrs.get<std::vector<std::string> >(SUMO_ATTR_INSERTIONCHECKS, ret->id.c_str(), ok);
689  if (!ok) {
690  handleVehicleError(true, ret);
691  } else {
692  for (std::string check : checks) {
693  if (!SUMOXMLDefinitions::InsertionChecks.hasString(check)) {
694  handleVehicleError(true, ret, "Unknown value '" + check + "' in " + toString(SUMO_ATTR_INSERTIONCHECKS));
695  }
696  ret->insertionChecks |= (int)SUMOXMLDefinitions::InsertionChecks.get(check);
697  }
698  }
699  }
700  // parse parking access rights
701  if (attrs.hasAttribute(SUMO_ATTR_PARKING_BADGES)) {
702  bool ok = true;
703  std::vector<std::string> badges = attrs.get<std::vector<std::string>>(SUMO_ATTR_PARKING_BADGES, ret->id.c_str(), ok);
704  if (!ok) {
705  handleVehicleError(true, ret);
706  } else {
707  ret->parametersSet |= VEHPARS_PARKING_BADGES_SET;
708  ret->parkingBadges = badges;
709  }
710  }
711  // parse modes (transportables only)
712  ret->modes = 0;
713  if (attrs.hasAttribute(SUMO_ATTR_MODES)) {
714  bool ok = true;
715  const std::string modeString = attrs.get<std::string>(SUMO_ATTR_MODES, ret->id.c_str(), ok);
716  if (!ok) {
717  handleVehicleError(true, ret);
718  } else {
719  std::string errorMsg;
720  if (!SUMOVehicleParameter::parsePersonModes(modeString, toString(tag), ret->id, ret->modes, errorMsg)) {
721  handleVehicleError(true, ret, errorMsg);
722  }
723  }
724  }
725  // parse usable vehicle types (transportables only)
726  if (attrs.hasAttribute(SUMO_ATTR_VTYPES)) {
727  bool ok = true;
728  ret->vTypes = attrs.get<std::string>(SUMO_ATTR_VTYPES, ret->id.c_str(), ok);
729  if (!ok) {
730  handleVehicleError(true, ret);
731  }
732  }
733  // parse speed (only used by calibrators flow)
734  // also used by vehicle in saved state but this is parsed elsewhere
735  if (tag == SUMO_TAG_FLOW && attrs.hasAttribute(SUMO_ATTR_SPEED)) {
736  bool ok = true;
737  double calibratorSpeed = attrs.get<double>(SUMO_ATTR_SPEED, ret->id.c_str(), ok);
738  if (!ok) {
739  handleVehicleError(true, ret);
740  } else if (calibratorSpeed >= 0 || calibratorSpeed == -1) {
741  ret->parametersSet |= VEHPARS_CALIBRATORSPEED_SET;
742  ret->calibratorSpeed = calibratorSpeed;
743  } else {
744  handleVehicleError(true, ret, toString(SUMO_ATTR_SPEED) + " may not be negative");
745  }
746  }
747  /*/ parse via
748  if (attrs.hasAttribute(SUMO_ATTR_VIA)) {
749  ret->setParameter |= VEHPARS_VIA_SET;
750  SUMOSAXAttributes::parseStringVector(attrs.get<std::string>(SUMO_ATTR_VIA, ret->id.c_str(), ok), ret->via);
751  }
752  */
753 }
754 
755 
756 SUMOVTypeParameter*
757 SUMOVehicleParserHelper::beginVTypeParsing(const SUMOSAXAttributes& attrs, const bool hardFail, const std::string& file) {
758  // first obtain ID
759  std::string id = parseID(attrs, SUMO_TAG_VTYPE);
760  // check if ID is valid
761  if (!id.empty()) {
762  SUMOVehicleClass vClass = SVC_PASSENGER;
763  if (attrs.hasAttribute(SUMO_ATTR_VCLASS)) {
764  vClass = parseVehicleClass(attrs, id);
765  }
766  // create vType
767  SUMOVTypeParameter* vType = new SUMOVTypeParameter(id, vClass);
768  // parse attributes
769  if (attrs.hasAttribute(SUMO_ATTR_VCLASS)) {
770  vType->parametersSet |= VTYPEPARS_VEHICLECLASS_SET;
771  }
772  if (attrs.hasAttribute(SUMO_ATTR_LENGTH)) {
773  bool ok = true;
774  const double length = attrs.get<double>(SUMO_ATTR_LENGTH, vType->id.c_str(), ok);
775  if (!ok) {
776  return handleVehicleTypeError(hardFail, vType);
777  } else if (length <= 0) {
778  return handleVehicleTypeError(hardFail, vType, toString(SUMO_ATTR_LENGTH) + " must be greater than 0");
779  } else {
780  vType->length = length;
781  vType->parametersSet |= VTYPEPARS_LENGTH_SET;
782  }
783  }
784  if (attrs.hasAttribute(SUMO_ATTR_MINGAP)) {
785  bool ok = true;
786  const double minGap = attrs.get<double>(SUMO_ATTR_MINGAP, vType->id.c_str(), ok);
787  if (!ok) {
788  return handleVehicleTypeError(hardFail, vType);
789  } else if (minGap < 0) {
790  return handleVehicleTypeError(hardFail, vType, toString(SUMO_ATTR_MINGAP) + " must be equal or greater than 0");
791  } else {
792  vType->minGap = minGap;
793  vType->parametersSet |= VTYPEPARS_MINGAP_SET;
794  }
795  }
796  if (attrs.hasAttribute(SUMO_ATTR_MAXSPEED)) {
797  bool ok = true;
798  const double maxSpeed = attrs.get<double>(SUMO_ATTR_MAXSPEED, vType->id.c_str(), ok);
799  if (!ok) {
800  return handleVehicleTypeError(hardFail, vType);
801  } else if (maxSpeed <= 0) {
802  return handleVehicleTypeError(hardFail, vType, toString(SUMO_ATTR_MAXSPEED) + " must be greater than 0");
803  } else {
804  vType->maxSpeed = maxSpeed;
805  vType->parametersSet |= VTYPEPARS_MAXSPEED_SET;
806  }
807  }
808  if (attrs.hasAttribute(SUMO_ATTR_DESIRED_MAXSPEED)) {
809  bool ok = true;
810  const double desiredMaxSpeed = attrs.get<double>(SUMO_ATTR_DESIRED_MAXSPEED, vType->id.c_str(), ok);
811  if (!ok) {
812  return handleVehicleTypeError(hardFail, vType);
813  } else if (desiredMaxSpeed <= 0) {
814  return handleVehicleTypeError(hardFail, vType, toString(SUMO_ATTR_DESIRED_MAXSPEED) + " must be greater than 0");
815  } else {
816  vType->desiredMaxSpeed = desiredMaxSpeed;
817  vType->parametersSet |= VTYPEPARS_DESIRED_MAXSPEED_SET;
818  }
819  } else if (attrs.hasAttribute(SUMO_ATTR_MAXSPEED)) {
820  if (vClass == SVC_PEDESTRIAN) {
821  // backward compatibility because pedestrian maxSpeed was subject to speedFactor up to 1.14.1
822  vType->desiredMaxSpeed = vType->maxSpeed;;
823  vType->maxSpeed = MAX2(vType->maxSpeed, SUMOVTypeParameter::VClassDefaultValues(vClass).maxSpeed);
824  } else if (vClass == SVC_BICYCLE) {
825  // backward compatibility because default desired speed did not exist up to 1.14.1
826  vType->desiredMaxSpeed = MAX2(vType->maxSpeed, vType->desiredMaxSpeed);
827  }
828  }
829 
830  if (attrs.hasAttribute(SUMO_ATTR_SPEEDFACTOR)) {
831  bool ok = true;
832  vType->speedFactor.parse(attrs.get<std::string>(SUMO_ATTR_SPEEDFACTOR, vType->id.c_str(), ok), hardFail);
833  if (!ok) {
834  return handleVehicleTypeError(hardFail, vType);
835  } else {
836  vType->parametersSet |= VTYPEPARS_SPEEDFACTOR_SET;
837  }
838  }
839  if (attrs.hasAttribute(SUMO_ATTR_SPEEDDEV)) {
840  bool ok = true;
841  const double speedDev = attrs.get<double>(SUMO_ATTR_SPEEDDEV, vType->id.c_str(), ok);
842  if (!ok) {
843  return handleVehicleTypeError(hardFail, vType);
844  } else if (speedDev < 0) {
845  return handleVehicleTypeError(hardFail, vType, toString(SUMO_ATTR_SPEEDDEV) + " must be equal or greater than 0");
846  } else {
847  vType->speedFactor.getParameter()[1] = speedDev;
848  vType->parametersSet |= VTYPEPARS_SPEEDFACTOR_SET;
849  }
850  }
851  // validate speed distribution
852  const std::string& error = vType->speedFactor.isValid();
853  if (error != "") {
854  return handleVehicleTypeError(hardFail, vType, "Invalid speed distribution when parsing vType '" + vType->id + "' (" + error + ")");
855  }
856  if (attrs.hasAttribute(SUMO_ATTR_ACTIONSTEPLENGTH)) {
857  bool ok = true;
858  const double actionStepLengthSecs = attrs.get<double>(SUMO_ATTR_ACTIONSTEPLENGTH, vType->id.c_str(), ok);
859  if (!ok) {
860  return handleVehicleTypeError(hardFail, vType);
861  } else {
862  // processActionStepLength(...) function includes warnings
863  vType->actionStepLength = processActionStepLength(actionStepLengthSecs);
864  vType->parametersSet |= VTYPEPARS_ACTIONSTEPLENGTH_SET;
865  }
866  }
867  if (attrs.hasAttribute(SUMO_ATTR_EMISSIONCLASS)) {
868  bool ok = true;
869  const std::string parsedEmissionClass = attrs.getOpt<std::string>(SUMO_ATTR_EMISSIONCLASS, id.c_str(), ok, "");
870  // check if emission class is correct
871  try {
872  vType->emissionClass = PollutantsInterface::getClassByName(parsedEmissionClass);
873  vType->parametersSet |= VTYPEPARS_EMISSIONCLASS_SET;
874  } catch (...) {
875  return handleVehicleTypeError(hardFail, vType, toString(SUMO_ATTR_EMISSIONCLASS) + " with name '" + parsedEmissionClass + "' doesn't exist.");
876  }
877  }
878  if (attrs.hasAttribute(SUMO_ATTR_MASS)) {
879  bool ok = true;
880  const double mass = attrs.get<double>(SUMO_ATTR_MASS, vType->id.c_str(), ok);
881  if (!ok) {
882  return handleVehicleTypeError(hardFail, vType);
883  } else if (mass < 0) {
884  return handleVehicleTypeError(hardFail, vType, toString(SUMO_ATTR_MASS) + " must be equal or greater than 0");
885  } else {
886  vType->mass = mass;
887  vType->parametersSet |= VTYPEPARS_MASS_SET;
888  }
889  }
890  if (attrs.hasAttribute(SUMO_ATTR_IMPATIENCE)) {
891  bool ok = true;
892  const std::string impatienceStr = attrs.get<std::string>(SUMO_ATTR_IMPATIENCE, vType->id.c_str(), ok);
893  if (!ok) {
894  return handleVehicleTypeError(hardFail, vType);
895  } else if (impatienceStr == "off") {
896  vType->impatience = -std::numeric_limits<double>::max();
897  } else {
898  const double impatienceDouble = attrs.get<double>(SUMO_ATTR_IMPATIENCE, vType->id.c_str(), ok);
899  if (!ok) {
900  return handleVehicleTypeError(hardFail, vType);
901  } else {
902  vType->impatience = impatienceDouble;
903  vType->parametersSet |= VTYPEPARS_IMPATIENCE_SET;
904  }
905  }
906  }
907  if (attrs.hasAttribute(SUMO_ATTR_WIDTH)) {
908  bool ok = true;
909  const double width = attrs.get<double>(SUMO_ATTR_WIDTH, vType->id.c_str(), ok);
910  if (!ok) {
911  return handleVehicleTypeError(hardFail, vType);
912  } else if (width <= 0) {
913  return handleVehicleTypeError(hardFail, vType, toString(SUMO_ATTR_WIDTH) + " must be greater than 0");
914  } else {
915  vType->width = width;
916  vType->parametersSet |= VTYPEPARS_WIDTH_SET;
917  if (vClass == SVC_PEDESTRIAN
918  && OptionsCont::getOptions().exists("pedestrian.striping.stripe-width")
919  && OptionsCont::getOptions().getString("pedestrian.model") == "striping"
920  && OptionsCont::getOptions().getFloat("pedestrian.striping.stripe-width") < vType->width) {
921  WRITE_WARNINGF(TL("Pedestrian vType '%' width % is larger than pedestrian.striping.stripe-width and this may cause collisions with vehicles."), id, vType->width);
922  }
923  }
924  }
925  if (attrs.hasAttribute(SUMO_ATTR_HEIGHT)) {
926  bool ok = true;
927  const double height = attrs.get<double>(SUMO_ATTR_HEIGHT, vType->id.c_str(), ok);
928  if (!ok) {
929  return handleVehicleTypeError(hardFail, vType);
930  } else if (height < 0) {
931  return handleVehicleTypeError(hardFail, vType, toString(SUMO_ATTR_HEIGHT) + " must be equal or greater than 0");
932  } else {
933  vType->height = height;
934  vType->parametersSet |= VTYPEPARS_HEIGHT_SET;
935  }
936  }
937  if (attrs.hasAttribute(SUMO_ATTR_GUISHAPE)) {
938  vType->shape = parseGuiShape(attrs, vType->id);
939  if (vType->shape != SUMOVehicleShape::UNKNOWN) {
940  vType->parametersSet |= VTYPEPARS_SHAPE_SET;
941  }
942  }
943  if (attrs.hasAttribute(SUMO_ATTR_OSGFILE)) {
944  bool ok = true;
945  const std::string osgFile = attrs.get<std::string>(SUMO_ATTR_OSGFILE, vType->id.c_str(), ok);
946  if (!ok) {
947  return handleVehicleTypeError(hardFail, vType);
948  } else {
949  vType->osgFile = osgFile;
950  vType->parametersSet |= VTYPEPARS_OSGFILE_SET;
951  }
952  }
953  if (attrs.hasAttribute(SUMO_ATTR_IMGFILE)) {
954  bool ok = true;
955  std::string imgFile = attrs.get<std::string>(SUMO_ATTR_IMGFILE, vType->id.c_str(), ok);
956  if (!ok) {
957  return handleVehicleTypeError(hardFail, vType);
958  } else {
959  // check relative path
960  if ((imgFile != "") && !FileHelpers::isAbsolute(imgFile)) {
961  imgFile = FileHelpers::getConfigurationRelative(file, imgFile);
962  }
963  vType->imgFile = imgFile;
964  vType->parametersSet |= VTYPEPARS_IMGFILE_SET;
965  }
966  }
967  if (attrs.hasAttribute(SUMO_ATTR_COLOR)) {
968  bool ok = true;
969  const RGBColor color = attrs.get<RGBColor>(SUMO_ATTR_COLOR, vType->id.c_str(), ok);
970  if (!ok) {
971  return handleVehicleTypeError(hardFail, vType);
972  } else {
973  vType->color = color;
974  vType->parametersSet |= VTYPEPARS_COLOR_SET;
975  }
976  } else {
977  vType->color = RGBColor::YELLOW;
978  }
979  if (attrs.hasAttribute(SUMO_ATTR_PROB)) {
980  bool ok = true;
981  const double defaultProbability = attrs.get<double>(SUMO_ATTR_PROB, vType->id.c_str(), ok);
982  if (!ok) {
983  return handleVehicleTypeError(hardFail, vType);
984  } else if (defaultProbability < 0) {
985  return handleVehicleTypeError(hardFail, vType, toString(SUMO_ATTR_PROB) + " must be equal or greater than 0");
986  } else {
987  vType->defaultProbability = defaultProbability;
988  vType->parametersSet |= VTYPEPARS_PROBABILITY_SET;
989  }
990  }
991  if (attrs.hasAttribute(SUMO_ATTR_LANE_CHANGE_MODEL)) {
992  bool ok = true;
993  std::string lcmS = attrs.get<std::string>(SUMO_ATTR_LANE_CHANGE_MODEL, vType->id.c_str(), ok);
994  if (!ok) {
995  return handleVehicleTypeError(hardFail, vType);
996  } else if (lcmS == "JE2013") {
997  WRITE_WARNING(TL("Lane change model 'JE2013' is deprecated. Using default model instead."));
998  lcmS = "default";
999  }
1000  if (SUMOXMLDefinitions::LaneChangeModels.hasString(lcmS)) {
1001  vType->lcModel = SUMOXMLDefinitions::LaneChangeModels.get(lcmS);
1002  vType->parametersSet |= VTYPEPARS_LANE_CHANGE_MODEL_SET;
1003  } else {
1004  return handleVehicleTypeError(hardFail, vType, "Unknown lane change model '" + lcmS + "' when parsing vType '" + vType->id + "'");
1005  }
1006  }
1007  if (attrs.hasAttribute(SUMO_ATTR_CAR_FOLLOW_MODEL)) {
1008  bool ok = true;
1009  const std::string cfmValue = attrs.get<std::string>(SUMO_ATTR_CAR_FOLLOW_MODEL, vType->id.c_str(), ok);
1010  if (!ok) {
1011  return handleVehicleTypeError(hardFail, vType);
1012  } else if (SUMOXMLDefinitions::CarFollowModels.hasString(cfmValue)) {
1013  vType->cfModel = SUMOXMLDefinitions::CarFollowModels.get(cfmValue);
1014  vType->parametersSet |= VTYPEPARS_CAR_FOLLOW_MODEL;
1015  } else {
1016  return handleVehicleTypeError(hardFail, vType, "Unknown car following model '" + cfmValue + "' when parsing vType '" + vType->id + "'");
1017  }
1018  }
1019  if (attrs.hasAttribute(SUMO_ATTR_PERSON_CAPACITY)) {
1020  bool ok = true;
1021  const int personCapacity = attrs.get<int>(SUMO_ATTR_PERSON_CAPACITY, vType->id.c_str(), ok);
1022  if (!ok) {
1023  return handleVehicleTypeError(hardFail, vType);
1024  } else if (personCapacity < 0) {
1025  return handleVehicleTypeError(hardFail, vType, toString(SUMO_ATTR_PERSON_CAPACITY) + " must be equal or greater than 0");
1026  } else {
1027  vType->personCapacity = personCapacity;
1028  vType->parametersSet |= VTYPEPARS_PERSON_CAPACITY;
1029  }
1030  }
1031  if (attrs.hasAttribute(SUMO_ATTR_CONTAINER_CAPACITY)) {
1032  bool ok = true;
1033  const int containerCapacity = attrs.get<int>(SUMO_ATTR_CONTAINER_CAPACITY, vType->id.c_str(), ok);
1034  if (!ok) {
1035  return handleVehicleTypeError(hardFail, vType);
1036  } else if (containerCapacity < 0) {
1037  return handleVehicleTypeError(hardFail, vType, toString(SUMO_ATTR_CONTAINER_CAPACITY) + " must be equal or greater than 0");
1038  } else {
1039  vType->containerCapacity = containerCapacity;
1040  vType->parametersSet |= VTYPEPARS_CONTAINER_CAPACITY;
1041  }
1042  }
1043  if (attrs.hasAttribute(SUMO_ATTR_BOARDING_DURATION)) {
1044  bool ok = true;
1045  const SUMOTime boardingDuration = attrs.getSUMOTimeReporting(SUMO_ATTR_BOARDING_DURATION, vType->id.c_str(), ok);
1046  if (!ok) {
1047  return handleVehicleTypeError(hardFail, vType);
1048  } else if (boardingDuration < 0) {
1049  return handleVehicleTypeError(hardFail, vType, toString(SUMO_ATTR_BOARDING_DURATION) + " must be equal or greater than 0");
1050  } else {
1051  vType->boardingDuration = boardingDuration;
1052  vType->parametersSet |= VTYPEPARS_BOARDING_DURATION;
1053  }
1054  }
1055  if (attrs.hasAttribute(SUMO_ATTR_LOADING_DURATION)) {
1056  bool ok = true;
1057  const SUMOTime loadingDuration = attrs.getSUMOTimeReporting(SUMO_ATTR_LOADING_DURATION, vType->id.c_str(), ok);
1058  if (!ok) {
1059  return handleVehicleTypeError(hardFail, vType);
1060  } else if (loadingDuration < 0) {
1061  return handleVehicleTypeError(hardFail, vType, toString(SUMO_ATTR_LOADING_DURATION) + " must be equal or greater than 0");
1062  } else {
1063  vType->loadingDuration = loadingDuration;
1064  vType->parametersSet |= VTYPEPARS_LOADING_DURATION;
1065  }
1066  }
1067  if (attrs.hasAttribute(SUMO_ATTR_SCALE)) {
1068  bool ok = true;
1069  const double scale = attrs.get<double>(SUMO_ATTR_SCALE, id.c_str(), ok);
1070  if (!ok) {
1071  return handleVehicleTypeError(hardFail, vType);
1072  } else if (scale < 0) {
1073  return handleVehicleTypeError(hardFail, vType, toString(SUMO_ATTR_SCALE) + " may be not be negative");
1074  } else {
1075  vType->scale = scale;
1076  vType->parametersSet |= VTYPEPARS_SCALE_SET;
1077  }
1078  }
1079  if (attrs.hasAttribute(SUMO_ATTR_TIME_TO_TELEPORT)) {
1080  bool ok = true;
1081  const SUMOTime ttt = attrs.getSUMOTimeReporting(SUMO_ATTR_TIME_TO_TELEPORT, vType->id.c_str(), ok);
1082  if (!ok) {
1083  return handleVehicleTypeError(hardFail, vType);
1084  } else {
1085  vType->timeToTeleport = ttt;
1086  vType->parametersSet |= VTYPEPARS_TTT_SET;
1087  }
1088  }
1089  if (attrs.hasAttribute(SUMO_ATTR_TIME_TO_TELEPORT_BIDI)) {
1090  bool ok = true;
1091  const SUMOTime tttb = attrs.getSUMOTimeReporting(SUMO_ATTR_TIME_TO_TELEPORT_BIDI, vType->id.c_str(), ok);
1092  if (!ok) {
1093  return handleVehicleTypeError(hardFail, vType);
1094  } else {
1095  vType->timeToTeleportBidi = tttb;
1096  vType->parametersSet |= VTYPEPARS_TTT_BIDI_SET;
1097  }
1098  }
1099  if (attrs.hasAttribute(SUMO_ATTR_SPEEDFACTOR_PREMATURE)) {
1100  bool ok = true;
1101  const double sfp = attrs.get<double>(SUMO_ATTR_SPEEDFACTOR_PREMATURE, id.c_str(), ok);
1102  if (!ok) {
1103  return handleVehicleTypeError(hardFail, vType);
1104  } else {
1105  vType->speedFactorPremature = sfp;
1106  vType->parametersSet |= VTYPEPARS_SPEEDFACTOR_PREMATURE_SET;
1107  }
1108  }
1109  if (attrs.hasAttribute(SUMO_ATTR_BOARDING_FACTOR)) {
1110  bool ok = true;
1111  const double bf = attrs.get<double>(SUMO_ATTR_BOARDING_FACTOR, id.c_str(), ok);
1112  if (!ok) {
1113  return handleVehicleTypeError(hardFail, vType);
1114  } else if (bf < 0) {
1115  return handleVehicleTypeError(hardFail, vType, toString(SUMO_ATTR_BOARDING_FACTOR) + " must be equal or greater than 0");
1116  } else {
1117  vType->boardingFactor = bf;
1118  vType->parametersSet |= VTYPEPARS_BOARDING_FACTOR_SET;
1119  }
1120  }
1121  if (attrs.hasAttribute(SUMO_ATTR_MAXSPEED_LAT)) {
1122  bool ok = true;
1123  const double maxSpeedLat = attrs.get<double>(SUMO_ATTR_MAXSPEED_LAT, vType->id.c_str(), ok);
1124  if (!ok) {
1125  return handleVehicleTypeError(hardFail, vType);
1126  } else if (maxSpeedLat <= 0) {
1127  return handleVehicleTypeError(hardFail, vType, toString(SUMO_ATTR_MAXSPEED_LAT) + " must be greater than 0");
1128  } else {
1129  vType->maxSpeedLat = maxSpeedLat;
1130  vType->parametersSet |= VTYPEPARS_MAXSPEED_LAT_SET;
1131  }
1132  }
1133  if (attrs.hasAttribute(SUMO_ATTR_MINGAP_LAT)) {
1134  bool ok = true;
1135  const double minGapLat = attrs.get<double>(SUMO_ATTR_MINGAP_LAT, vType->id.c_str(), ok);
1136  if (!ok) {
1137  return handleVehicleTypeError(hardFail, vType);
1138  } else if (minGapLat < 0) {
1139  return handleVehicleTypeError(hardFail, vType, toString(SUMO_ATTR_MINGAP_LAT) + " must be equal or greater than 0");
1140  } else {
1141  vType->minGapLat = minGapLat;
1142  vType->parametersSet |= VTYPEPARS_MINGAP_LAT_SET;
1143  }
1144  }
1145  if (attrs.hasAttribute(SUMO_ATTR_LATALIGNMENT)) {
1146  bool ok = true;
1147  const std::string alignS = attrs.get<std::string>(SUMO_ATTR_LATALIGNMENT, vType->id.c_str(), ok);
1148  if (!ok) {
1149  return handleVehicleTypeError(hardFail, vType);
1150  } else {
1151  double lao;
1152  LatAlignmentDefinition lad;
1153  if (SUMOVTypeParameter::parseLatAlignment(alignS, lao, lad)) {
1154  vType->latAlignmentOffset = lao;
1155  vType->latAlignmentProcedure = lad;
1156  vType->parametersSet |= VTYPEPARS_LATALIGNMENT_SET;
1157  } else {
1158  return handleVehicleTypeError(hardFail, vType, "Unknown lateral alignment '" + alignS + "' when parsing vType '" + vType->id + "';\n must be one of (\"right\", \"center\", \"arbitrary\", \"nice\", \"compact\", \"left\" or a float)");
1159  }
1160  }
1161  }
1162  if (attrs.hasAttribute(SUMO_ATTR_MANEUVER_ANGLE_TIMES)) {
1163  bool ok = true;
1164  const std::string angleTimesS = attrs.get<std::string>(SUMO_ATTR_MANEUVER_ANGLE_TIMES, vType->id.c_str(), ok);
1165  if (!ok) {
1166  return handleVehicleTypeError(hardFail, vType);
1167  } else if (parseAngleTimesMap(vType, angleTimesS)) {
1168  vType->parametersSet |= VTYPEPARS_MANEUVER_ANGLE_TIMES_SET;
1169  } else {
1170  return handleVehicleTypeError(hardFail, vType, "Invalid manoeuver angle times map for vType '" + vType->id + "'");
1171  }
1172  }
1173  if (attrs.hasAttribute(SUMO_ATTR_PARKING_BADGES)) {
1174  bool ok = true;
1175  std::vector<std::string> badges = attrs.get<std::vector<std::string>>(SUMO_ATTR_PARKING_BADGES, vType->id.c_str(), ok);
1176  if (!ok) {
1177  return handleVehicleTypeError(hardFail, vType);
1178  } else {
1179  vType->parametersSet |= VTYPEPARS_PARKING_BADGES_SET;
1180  vType->parkingBadges = badges;
1181  }
1182  }
1183  // try to parse Car Following Model params
1184  if (!parseCFMParams(vType, vType->cfModel, attrs, false)) {
1185  return handleVehicleTypeError(hardFail, vType, "Invalid parsing embedded VType");
1186  }
1187  // try to parse Lane Change Model params
1188  if (!parseLCParams(vType, vType->lcModel, attrs)) {
1189  return handleVehicleTypeError(hardFail, vType, "Invalid Lane Change Model Parameters");
1190  }
1191  // try to Junction Model params
1192  if (!parseJMParams(vType, attrs)) {
1193  return handleVehicleTypeError(hardFail, vType, "Invalid Junction Model Parameters");
1194  }
1195  // all ok, then return vType
1196  return vType;
1197  } else {
1198  return handleVehicleTypeError(hardFail, nullptr, "VType cannot be created");
1199  }
1200 }
1201 
1202 
1203 bool
1204 SUMOVehicleParserHelper::parseAngleTimesMap(SUMOVTypeParameter* vtype, const std::string atm) {
1205  StringTokenizer st(atm, ",");
1206  std::map<int, std::pair<SUMOTime, SUMOTime>> angleTimesMap;
1207  int tripletCount = 0;
1208  while (st.hasNext()) {
1209  StringTokenizer pos(st.next());
1210  if (pos.size() != 3) {
1211  WRITE_ERRORF(TL("maneuverAngleTimes format for vType '%' % contains an invalid triplet."), vtype->id, atm);
1212  return false;
1213  } else {
1214  try {
1215  const int angle = StringUtils::toInt(pos.next());
1216  const SUMOTime t1 = string2time(pos.next());
1217  const SUMOTime t2 = string2time(pos.next());
1218  angleTimesMap[angle] = std::make_pair(t1, t2);
1219  } catch (...) {
1220  WRITE_ERRORF(TL("Triplet '%' for vType '%' maneuverAngleTimes cannot be parsed as 'int double double'"), st.get(tripletCount), vtype->id);
1221  return false;
1222  }
1223  tripletCount++;
1224  }
1225  }
1226  if (angleTimesMap.size() > 0) {
1227  vtype->myManoeuverAngleTimes.clear();
1228  for (const auto& angleTime : angleTimesMap) {
1229  vtype->myManoeuverAngleTimes.insert(angleTime);
1230  }
1231  angleTimesMap.clear();
1232  return true;
1233  } else {
1234  return false;
1235  }
1236 }
1237 
1238 
1239 bool
1240 SUMOVehicleParserHelper::parseCFMParams(SUMOVTypeParameter* into, const SumoXMLTag element, const SUMOSAXAttributes& attrs, const bool nestedCFM) {
1241  const CFAttrMap& allowedCFM = getAllowedCFModelAttrs();
1242  CFAttrMap::const_iterator cf_it = allowedCFM.find(element);
1243  // check if given CFM is allowed
1244  if (cf_it == allowedCFM.end()) {
1245  if (SUMOXMLDefinitions::Tags.has((int)element)) {
1246  WRITE_ERRORF(TL("Unknown car-following model % when parsing vType '%'"), toString(element), into->id);
1247  } else {
1248  WRITE_ERRORF(TL("Unknown car-following model when parsing vType '%'"), into->id);
1249  }
1250  return false;
1251  }
1252  // check if we're parsing a nested CFM
1253  if (nestedCFM) {
1254  into->cfModel = cf_it->first;
1255  into->parametersSet |= VTYPEPARS_CAR_FOLLOW_MODEL;
1256  }
1257  // set CFM values
1258  for (const auto& it : cf_it->second) {
1259  if (attrs.hasAttribute(it)) {
1260  // first obtain CFM attribute in string format
1261  bool ok = true;
1262  std::string parsedCFMAttribute = attrs.get<std::string>(it, into->id.c_str(), ok);
1263  // check CFM Attribute
1264  if (!ok) {
1265  return false;
1266  } else if (it == SUMO_ATTR_TRAIN_TYPE) {
1267  // check if train value is valid
1268  if (!SUMOXMLDefinitions::TrainTypes.hasString(parsedCFMAttribute)) {
1269  WRITE_ERROR("Invalid train type '" + parsedCFMAttribute + "' used in Car-Following-Attribute " + toString(it));
1270  return false;
1271  }
1272  // add parsedCFMAttribute to cfParameter
1273  into->cfParameter[it] = parsedCFMAttribute;
1274  } else if (it == SUMO_ATTR_SPEED_TABLE || it == SUMO_ATTR_TRACTION_TABLE || it == SUMO_ATTR_RESISTANCE_TABLE) {
1275  into->cfParameter[it] = parsedCFMAttribute;
1276  } else if (it == SUMO_ATTR_CF_IDM_STEPPING) {
1277  // declare a int in wich save CFM int attribute
1278  double CFMDoubleAttribute = -1;
1279  try {
1280  // obtain CFM attribute in int format
1281  CFMDoubleAttribute = StringUtils::toDouble(parsedCFMAttribute);
1282  } catch (...) {
1283  WRITE_ERRORF(TL("Invalid Car-Following-Model Attribute %. Cannot be parsed to float"), toString(it));
1284  return false;
1285  }
1286  if (CFMDoubleAttribute <= 0) {
1287  WRITE_ERRORF(TL("Invalid Car-Following-Model Attribute %. Must be greater than 0"), toString(it));
1288  return false;
1289  }
1290  // add parsedCFMAttribute to cfParameter
1291  into->cfParameter[it] = parsedCFMAttribute;
1292  } else {
1293  // declare a double in wich save CFM float attribute
1294  double CFMDoubleAttribute = -1;
1295  try {
1296  // obtain CFM attribute in double format
1297  CFMDoubleAttribute = StringUtils::toDouble(parsedCFMAttribute);
1298  } catch (...) {
1299  WRITE_ERRORF(TL("Invalid Car-Following-Model Attribute %. Cannot be parsed to float"), toString(it));
1300  return false;
1301  }
1302  // check attributes of type "positiveFloatType" (> 0)
1303  switch (it) {
1304  case SUMO_ATTR_ACCEL:
1305  case SUMO_ATTR_DECEL:
1306  case SUMO_ATTR_APPARENTDECEL:
1307  case SUMO_ATTR_EMERGENCYDECEL:
1308  case SUMO_ATTR_TAU:
1309  if (CFMDoubleAttribute <= 0) {
1310  WRITE_ERRORF(TL("Invalid Car-Following-Model Attribute %. Must be greater than 0"), toString(it));
1311  return false;
1312  }
1313  break;
1314  default:
1315  break;
1316  }
1317  // check attributes restricted to [0-1]
1318  switch (it) {
1319  case SUMO_ATTR_SIGMA:
1320  if ((CFMDoubleAttribute < 0) || (CFMDoubleAttribute > 1)) {
1321  WRITE_ERRORF(TL("Invalid Car-Following-Model Attribute %. Only values between [0-1] are allowed"), toString(it));
1322  return false;
1323  }
1324  break;
1325  default:
1326  break;
1327  }
1328  // add parsedCFMAttribute to cfParameter
1329  into->cfParameter[it] = parsedCFMAttribute;
1330  }
1331  }
1332  }
1333  // all CFM successfully parsed, then return true
1334  return true;
1335 }
1336 
1337 
1338 const SUMOVehicleParserHelper::CFAttrMap&
1339 SUMOVehicleParserHelper::getAllowedCFModelAttrs() {
1340  // init on first use
1341  if (allowedCFModelAttrs.size() == 0) {
1342  std::set<SumoXMLAttr> genericParams;
1343  genericParams.insert(SUMO_ATTR_TAU);
1344  genericParams.insert(SUMO_ATTR_ACCEL);
1345  genericParams.insert(SUMO_ATTR_DECEL);
1346  genericParams.insert(SUMO_ATTR_APPARENTDECEL);
1347  genericParams.insert(SUMO_ATTR_EMERGENCYDECEL);
1348  genericParams.insert(SUMO_ATTR_COLLISION_MINGAP_FACTOR);
1349  genericParams.insert(SUMO_ATTR_STARTUP_DELAY);
1350  // Krauss
1351  std::set<SumoXMLAttr> kraussParams(genericParams);
1352  kraussParams.insert(SUMO_ATTR_SIGMA);
1353  kraussParams.insert(SUMO_ATTR_SIGMA_STEP);
1354  allowedCFModelAttrs[SUMO_TAG_CF_KRAUSS] = kraussParams;
1355  allowedCFModelAttrs[SUMO_TAG_CF_KRAUSS_ORIG1] = kraussParams;
1356  allowedCFModelAttrs[SUMO_TAG_CF_KRAUSS_PLUS_SLOPE] = kraussParams;
1357  std::set<SumoXMLAttr> allParams(kraussParams);
1358  // KraussX
1359  std::set<SumoXMLAttr> kraussXParams(kraussParams);
1360  kraussXParams.insert(SUMO_ATTR_TMP1);
1361  kraussXParams.insert(SUMO_ATTR_TMP2);
1362  kraussXParams.insert(SUMO_ATTR_TMP3);
1363  kraussXParams.insert(SUMO_ATTR_TMP4);
1364  kraussXParams.insert(SUMO_ATTR_TMP5);
1365  allowedCFModelAttrs[SUMO_TAG_CF_KRAUSSX] = kraussXParams;
1366  allParams.insert(kraussXParams.begin(), kraussXParams.end());
1367  // SmartSK
1368  std::set<SumoXMLAttr> smartSKParams(genericParams);
1369  smartSKParams.insert(SUMO_ATTR_SIGMA);
1370  smartSKParams.insert(SUMO_ATTR_TMP1);
1371  smartSKParams.insert(SUMO_ATTR_TMP2);
1372  smartSKParams.insert(SUMO_ATTR_TMP3);
1373  smartSKParams.insert(SUMO_ATTR_TMP4);
1374  smartSKParams.insert(SUMO_ATTR_TMP5);
1375  allowedCFModelAttrs[SUMO_TAG_CF_SMART_SK] = smartSKParams;
1376  allParams.insert(smartSKParams.begin(), smartSKParams.end());
1377  // Daniel
1378  std::set<SumoXMLAttr> daniel1Params(genericParams);
1379  daniel1Params.insert(SUMO_ATTR_SIGMA);
1380  daniel1Params.insert(SUMO_ATTR_TMP1);
1381  daniel1Params.insert(SUMO_ATTR_TMP2);
1382  daniel1Params.insert(SUMO_ATTR_TMP3);
1383  daniel1Params.insert(SUMO_ATTR_TMP4);
1384  daniel1Params.insert(SUMO_ATTR_TMP5);
1385  allowedCFModelAttrs[SUMO_TAG_CF_DANIEL1] = daniel1Params;
1386  allParams.insert(daniel1Params.begin(), daniel1Params.end());
1387  // Peter Wagner
1388  std::set<SumoXMLAttr> pwagParams(genericParams);
1389  pwagParams.insert(SUMO_ATTR_SIGMA);
1390  pwagParams.insert(SUMO_ATTR_CF_PWAGNER2009_TAULAST);
1391  pwagParams.insert(SUMO_ATTR_CF_PWAGNER2009_APPROB);
1392  allowedCFModelAttrs[SUMO_TAG_CF_PWAGNER2009] = pwagParams;
1393  allParams.insert(pwagParams.begin(), pwagParams.end());
1394  // IDM params
1395  std::set<SumoXMLAttr> idmParams(genericParams);
1396  idmParams.insert(SUMO_ATTR_CF_IDM_DELTA);
1397  idmParams.insert(SUMO_ATTR_CF_IDM_STEPPING);
1398  allowedCFModelAttrs[SUMO_TAG_CF_IDM] = idmParams;
1399  allParams.insert(idmParams.begin(), idmParams.end());
1400  // EIDM
1401  std::set<SumoXMLAttr> eidmParams(genericParams);
1402  eidmParams.insert(SUMO_ATTR_CF_IDM_DELTA);
1403  eidmParams.insert(SUMO_ATTR_CF_IDM_STEPPING);
1404  eidmParams.insert(SUMO_ATTR_CF_EIDM_T_LOOK_AHEAD);
1405  eidmParams.insert(SUMO_ATTR_CF_EIDM_T_PERSISTENCE_DRIVE);
1406  eidmParams.insert(SUMO_ATTR_CF_EIDM_T_REACTION);
1407  eidmParams.insert(SUMO_ATTR_CF_EIDM_T_PERSISTENCE_ESTIMATE);
1408  eidmParams.insert(SUMO_ATTR_CF_EIDM_C_COOLNESS);
1409  eidmParams.insert(SUMO_ATTR_CF_EIDM_SIG_LEADER);
1410  eidmParams.insert(SUMO_ATTR_CF_EIDM_SIG_GAP);
1411  eidmParams.insert(SUMO_ATTR_CF_EIDM_SIG_ERROR);
1412  eidmParams.insert(SUMO_ATTR_CF_EIDM_JERK_MAX);
1413  eidmParams.insert(SUMO_ATTR_CF_EIDM_EPSILON_ACC);
1414  eidmParams.insert(SUMO_ATTR_CF_EIDM_T_ACC_MAX);
1415  eidmParams.insert(SUMO_ATTR_CF_EIDM_M_FLATNESS);
1416  eidmParams.insert(SUMO_ATTR_CF_EIDM_M_BEGIN);
1417  eidmParams.insert(SUMO_ATTR_CF_EIDM_USEVEHDYNAMICS);
1418  eidmParams.insert(SUMO_ATTR_CF_EIDM_MAX_VEH_PREVIEW);
1419  allowedCFModelAttrs[SUMO_TAG_CF_EIDM] = eidmParams;
1420  allParams.insert(eidmParams.begin(), eidmParams.end());
1421  // IDMM
1422  std::set<SumoXMLAttr> idmmParams(genericParams);
1423  idmmParams.insert(SUMO_ATTR_CF_IDMM_ADAPT_FACTOR);
1424  idmmParams.insert(SUMO_ATTR_CF_IDMM_ADAPT_TIME);
1425  idmmParams.insert(SUMO_ATTR_CF_IDM_STEPPING);
1426  allowedCFModelAttrs[SUMO_TAG_CF_IDMM] = idmmParams;
1427  allParams.insert(idmmParams.begin(), idmmParams.end());
1428  // Bieker
1429  std::set<SumoXMLAttr> bkernerParams(genericParams);
1430  bkernerParams.insert(SUMO_ATTR_K);
1431  bkernerParams.insert(SUMO_ATTR_CF_KERNER_PHI);
1432  allowedCFModelAttrs[SUMO_TAG_CF_BKERNER] = bkernerParams;
1433  allParams.insert(bkernerParams.begin(), bkernerParams.end());
1434  // Wiedemann
1435  std::set<SumoXMLAttr> wiedemannParams(genericParams);
1436  wiedemannParams.insert(SUMO_ATTR_CF_WIEDEMANN_SECURITY);
1437  wiedemannParams.insert(SUMO_ATTR_CF_WIEDEMANN_ESTIMATION);
1438  allowedCFModelAttrs[SUMO_TAG_CF_WIEDEMANN] = wiedemannParams;
1439  allParams.insert(wiedemannParams.begin(), wiedemannParams.end());
1440  // W99
1441  std::set<SumoXMLAttr> w99Params(genericParams);
1442  w99Params.insert(SUMO_ATTR_CF_W99_CC1);
1443  w99Params.insert(SUMO_ATTR_CF_W99_CC2);
1444  w99Params.insert(SUMO_ATTR_CF_W99_CC3);
1445  w99Params.insert(SUMO_ATTR_CF_W99_CC4);
1446  w99Params.insert(SUMO_ATTR_CF_W99_CC5);
1447  w99Params.insert(SUMO_ATTR_CF_W99_CC6);
1448  w99Params.insert(SUMO_ATTR_CF_W99_CC7);
1449  w99Params.insert(SUMO_ATTR_CF_W99_CC8);
1450  w99Params.insert(SUMO_ATTR_CF_W99_CC9);
1451  allowedCFModelAttrs[SUMO_TAG_CF_W99] = w99Params;
1452  allParams.insert(w99Params.begin(), w99Params.end());
1453  // Rail
1454  std::set<SumoXMLAttr> railParams(genericParams);
1455  railParams.insert(SUMO_ATTR_TRAIN_TYPE);
1456  railParams.insert(SUMO_ATTR_SPEED_TABLE);
1457  railParams.insert(SUMO_ATTR_TRACTION_TABLE);
1458  railParams.insert(SUMO_ATTR_RESISTANCE_TABLE);
1459  railParams.insert(SUMO_ATTR_MASSFACTOR);
1460  railParams.insert(SUMO_ATTR_MAXPOWER);
1461  railParams.insert(SUMO_ATTR_MAXTRACTION);
1462  railParams.insert(SUMO_ATTR_RESISTANCE_COEFFICIENT_CONSTANT);
1463  railParams.insert(SUMO_ATTR_RESISTANCE_COEFFICIENT_LINEAR);
1464  railParams.insert(SUMO_ATTR_RESISTANCE_COEFFICIENT_QUADRATIC);
1465  allowedCFModelAttrs[SUMO_TAG_CF_RAIL] = railParams;
1466  allParams.insert(railParams.begin(), railParams.end());
1467  // ACC
1468  std::set<SumoXMLAttr> ACCParams(genericParams);
1469  ACCParams.insert(SUMO_ATTR_SC_GAIN);
1470  ACCParams.insert(SUMO_ATTR_GCC_GAIN_SPEED);
1471  ACCParams.insert(SUMO_ATTR_GCC_GAIN_SPACE);
1472  ACCParams.insert(SUMO_ATTR_GC_GAIN_SPEED);
1473  ACCParams.insert(SUMO_ATTR_GC_GAIN_SPACE);
1474  ACCParams.insert(SUMO_ATTR_CA_GAIN_SPEED);
1475  ACCParams.insert(SUMO_ATTR_CA_GAIN_SPACE);
1476  ACCParams.insert(SUMO_ATTR_CA_OVERRIDE);
1477  ACCParams.insert(SUMO_ATTR_APPLYDRIVERSTATE);
1478  allowedCFModelAttrs[SUMO_TAG_CF_ACC] = ACCParams;
1479  allParams.insert(ACCParams.begin(), ACCParams.end());
1480  // CACC
1481  std::set<SumoXMLAttr> CACCParams(genericParams);
1482  CACCParams.insert(SUMO_ATTR_SC_GAIN_CACC);
1483  CACCParams.insert(SUMO_ATTR_GCC_GAIN_GAP_CACC);
1484  CACCParams.insert(SUMO_ATTR_GCC_GAIN_GAP_DOT_CACC);
1485  CACCParams.insert(SUMO_ATTR_GC_GAIN_GAP_CACC);
1486  CACCParams.insert(SUMO_ATTR_GC_GAIN_GAP_DOT_CACC);
1487  CACCParams.insert(SUMO_ATTR_CA_GAIN_GAP_CACC);
1488  CACCParams.insert(SUMO_ATTR_CA_GAIN_GAP_DOT_CACC);
1489  CACCParams.insert(SUMO_ATTR_GCC_GAIN_SPEED);
1490  CACCParams.insert(SUMO_ATTR_GCC_GAIN_SPACE);
1491  CACCParams.insert(SUMO_ATTR_GC_GAIN_SPEED);
1492  CACCParams.insert(SUMO_ATTR_GC_GAIN_SPACE);
1493  CACCParams.insert(SUMO_ATTR_CA_GAIN_SPEED);
1494  CACCParams.insert(SUMO_ATTR_CA_GAIN_SPACE);
1495  CACCParams.insert(SUMO_ATTR_CA_OVERRIDE);
1496  CACCParams.insert(SUMO_ATTR_HEADWAY_TIME_CACC_TO_ACC);
1497  CACCParams.insert(SUMO_ATTR_APPLYDRIVERSTATE);
1498  CACCParams.insert(SUMO_ATTR_SC_MIN_GAP);
1499  allowedCFModelAttrs[SUMO_TAG_CF_CACC] = CACCParams;
1500  allParams.insert(CACCParams.begin(), CACCParams.end());
1501  // CC
1502  std::set<SumoXMLAttr> ccParams(genericParams);
1503  ccParams.insert(SUMO_ATTR_CF_CC_C1);
1504  ccParams.insert(SUMO_ATTR_CF_CC_CCDECEL);
1505  ccParams.insert(SUMO_ATTR_CF_CC_CONSTSPACING);
1506  ccParams.insert(SUMO_ATTR_CF_CC_KP);
1507  ccParams.insert(SUMO_ATTR_CF_CC_LAMBDA);
1508  ccParams.insert(SUMO_ATTR_CF_CC_OMEGAN);
1509  ccParams.insert(SUMO_ATTR_CF_CC_TAU);
1510  ccParams.insert(SUMO_ATTR_CF_CC_XI);
1511  ccParams.insert(SUMO_ATTR_CF_CC_LANES_COUNT);
1512  ccParams.insert(SUMO_ATTR_CF_CC_CCACCEL);
1513  ccParams.insert(SUMO_ATTR_CF_CC_PLOEG_KP);
1514  ccParams.insert(SUMO_ATTR_CF_CC_PLOEG_KD);
1515  ccParams.insert(SUMO_ATTR_CF_CC_PLOEG_H);
1516  ccParams.insert(SUMO_ATTR_CF_CC_FLATBED_KA);
1517  ccParams.insert(SUMO_ATTR_CF_CC_FLATBED_KV);
1518  ccParams.insert(SUMO_ATTR_CF_CC_FLATBED_KP);
1519  ccParams.insert(SUMO_ATTR_CF_CC_FLATBED_D);
1520  ccParams.insert(SUMO_ATTR_CF_CC_FLATBED_H);
1521  allowedCFModelAttrs[SUMO_TAG_CF_CC] = ccParams;
1522  allParams.insert(ccParams.begin(), ccParams.end());
1523  // last element
1524  allowedCFModelAttrs[SUMO_TAG_NOTHING] = allParams;
1525  }
1526  return allowedCFModelAttrs;
1527 }
1528 
1529 
1530 bool
1531 SUMOVehicleParserHelper::parseLCParams(SUMOVTypeParameter* into, LaneChangeModel model, const SUMOSAXAttributes& attrs) {
1532  if (allowedLCModelAttrs.size() == 0) {
1533  // lc2013
1534  std::set<SumoXMLAttr> lc2013Params;
1535  lc2013Params.insert(SUMO_ATTR_LCA_STRATEGIC_PARAM);
1536  lc2013Params.insert(SUMO_ATTR_LCA_COOPERATIVE_PARAM);
1537  lc2013Params.insert(SUMO_ATTR_LCA_SPEEDGAIN_PARAM);
1538  lc2013Params.insert(SUMO_ATTR_LCA_KEEPRIGHT_PARAM);
1539  lc2013Params.insert(SUMO_ATTR_LCA_OPPOSITE_PARAM);
1540  lc2013Params.insert(SUMO_ATTR_LCA_LOOKAHEADLEFT);
1541  lc2013Params.insert(SUMO_ATTR_LCA_SPEEDGAINRIGHT);
1542  lc2013Params.insert(SUMO_ATTR_LCA_MAXSPEEDLATSTANDING);
1543  lc2013Params.insert(SUMO_ATTR_LCA_MAXSPEEDLATFACTOR);
1544  lc2013Params.insert(SUMO_ATTR_LCA_MAXDISTLATSTANDING);
1545  lc2013Params.insert(SUMO_ATTR_LCA_ASSERTIVE);
1546  lc2013Params.insert(SUMO_ATTR_LCA_SPEEDGAIN_LOOKAHEAD);
1547  lc2013Params.insert(SUMO_ATTR_LCA_COOPERATIVE_ROUNDABOUT);
1548  lc2013Params.insert(SUMO_ATTR_LCA_COOPERATIVE_SPEED);
1549  lc2013Params.insert(SUMO_ATTR_LCA_OVERTAKE_RIGHT);
1550  lc2013Params.insert(SUMO_ATTR_LCA_SIGMA);
1551  lc2013Params.insert(SUMO_ATTR_LCA_KEEPRIGHT_ACCEPTANCE_TIME);
1552  lc2013Params.insert(SUMO_ATTR_LCA_OVERTAKE_DELTASPEED_FACTOR);
1553  lc2013Params.insert(SUMO_ATTR_LCA_EXPERIMENTAL1);
1554  allowedLCModelAttrs[LaneChangeModel::LC2013] = lc2013Params;
1555  // sl2015 (extension of lc2013)
1556  std::set<SumoXMLAttr> sl2015Params = lc2013Params;
1557  sl2015Params.insert(SUMO_ATTR_LCA_PUSHY);
1558  sl2015Params.insert(SUMO_ATTR_LCA_PUSHYGAP);
1559  sl2015Params.insert(SUMO_ATTR_LCA_SUBLANE_PARAM);
1560  sl2015Params.insert(SUMO_ATTR_LCA_IMPATIENCE);
1561  sl2015Params.insert(SUMO_ATTR_LCA_TIME_TO_IMPATIENCE);
1562  sl2015Params.insert(SUMO_ATTR_LCA_ACCEL_LAT);
1563  sl2015Params.insert(SUMO_ATTR_LCA_TURN_ALIGNMENT_DISTANCE);
1564  sl2015Params.insert(SUMO_ATTR_LCA_LANE_DISCIPLINE);
1565  allowedLCModelAttrs[LaneChangeModel::SL2015] = sl2015Params;
1566  // DK2008
1567  std::set<SumoXMLAttr> noParams;
1568  allowedLCModelAttrs[LaneChangeModel::DK2008] = noParams;
1569  // default model may be either LC2013 or SL2015
1570  // we allow both sets (sl2015 is a superset of lc2013Params)
1571  allowedLCModelAttrs[LaneChangeModel::DEFAULT] = sl2015Params;
1572  }
1573  std::set<SumoXMLAttr> allowed = allowedLCModelAttrs[model];
1574  // iterate over LCM attributes
1575  for (const auto& it : allowed) {
1576  if (attrs.hasAttribute(it)) {
1577  // first obtain CFM attribute in string format
1578  bool ok = true;
1579  std::string parsedLCMAttribute = attrs.get<std::string>(it, into->id.c_str(), ok);
1580  if (!ok) {
1581  return false;
1582  }
1583  // declare a double in wich save CFM attribute
1584  double LCMAttribute = -1;
1585  try {
1586  // obtain CFM attribute in double format
1587  LCMAttribute = StringUtils::toDouble(parsedLCMAttribute);
1588  } catch (...) {
1589  WRITE_ERRORF(TL("Invalid Lane-Change-Model Attribute %. Cannot be parsed to float"), toString(it));
1590  return false;
1591  }
1592  // check attributes of type "nonNegativeFloatType" (>= 0)
1593  switch (it) {
1594  case SUMO_ATTR_LCA_PUSHYGAP:
1595  case SUMO_ATTR_LCA_MAXSPEEDLATSTANDING:
1596  case SUMO_ATTR_LCA_IMPATIENCE:
1597  case SUMO_ATTR_LCA_OVERTAKE_RIGHT:
1598  case SUMO_ATTR_LCA_ASSERTIVE:
1599  case SUMO_ATTR_LCA_LOOKAHEADLEFT:
1600  case SUMO_ATTR_LCA_SPEEDGAINRIGHT:
1601  case SUMO_ATTR_LCA_TURN_ALIGNMENT_DISTANCE:
1602  case SUMO_ATTR_LCA_TIME_TO_IMPATIENCE:
1603  case SUMO_ATTR_LCA_LANE_DISCIPLINE:
1604  case SUMO_ATTR_LCA_SIGMA:
1605  if (LCMAttribute < 0) {
1606  WRITE_ERRORF(TL("Invalid Lane-Change-Model Attribute %. Must be equal or greater than 0"), toString(it));
1607  return false;
1608  }
1609  break;
1610  default:
1611  break;
1612  }
1613  // check attributes of type "positiveFloatType" (> 0)
1614  switch (it) {
1615  case SUMO_ATTR_LCA_ACCEL_LAT:
1616  if (LCMAttribute <= 0) {
1617  WRITE_ERRORF(TL("Invalid Lane-Change-Model Attribute %. Must be greater than 0"), toString(it));
1618  return false;
1619  }
1620  break;
1621  default:
1622  break;
1623  }
1624  // check limits of attributes
1625  switch (it) {
1626  case SUMO_ATTR_LCA_OVERTAKE_DELTASPEED_FACTOR:
1627  if (LCMAttribute < -1 || LCMAttribute > 1) {
1628  WRITE_ERRORF(TL("Invalid Lane-Change-Model Attribute %. Must be between -1 and 1"), toString(it));
1629  return false;
1630  }
1631  break;
1632  default:
1633  break;
1634  }
1635  // add parsedLCMAttribute to cfParameter
1636  into->lcParameter[it] = parsedLCMAttribute;
1637  }
1638  }
1639  // all LCM parsed ok, then return true
1640  return true;
1641 }
1642 
1643 
1644 bool
1645 SUMOVehicleParserHelper::parseJMParams(SUMOVTypeParameter* into, const SUMOSAXAttributes& attrs) {
1646  for (const auto& it : SUMOVTypeParameter::AllowedJMAttrs) {
1647  if (attrs.hasAttribute(it)) {
1648  // first obtain CFM attribute in string format
1649  bool ok = true;
1650  std::string parsedJMAttribute = attrs.get<std::string>(it, into->id.c_str(), ok);
1651  if (!ok) {
1652  return false;
1653  }
1654  // declare a double in wich save CFM attribute
1655  double JMAttribute = -1;
1656  try {
1657  // obtain CFM attribute in double format
1658  JMAttribute = StringUtils::toDouble(parsedJMAttribute);
1659  } catch (...) {
1660  WRITE_ERRORF(TL("Invalid Junction-Model Attribute %. Cannot be parsed to float"), toString(it));
1661  return false;
1662  }
1663  // now continue checking other properties (-1 is the default value)
1664  if (JMAttribute != -1) {
1665  // special case for sigma minor
1666  if (it == SUMO_ATTR_JM_SIGMA_MINOR) {
1667  // check attributes sigma minor
1668  if ((JMAttribute < 0) || (JMAttribute > 1)) {
1669  WRITE_ERRORF(TL("Invalid Junction-Model Attribute %. Only values between [0-1] are allowed"), toString(it));
1670  return false;
1671  }
1672  } else {
1673  // check attributes of type "nonNegativeFloatType" (>= 0)
1674  if (JMAttribute < 0) {
1675  WRITE_ERRORF(TL("Invalid Junction-Model Attribute %. Must be equal or greater than 0"), toString(it));
1676  return false;
1677  }
1678  }
1679  // add parsedJMAttribute to cfParameter
1680  into->jmParameter[it] = parsedJMAttribute;
1681  }
1682  }
1683  }
1684  // all JM parameters successfully parsed, then return true
1685  return true;
1686 }
1687 
1688 
1689 SUMOVehicleClass
1690 SUMOVehicleParserHelper::parseVehicleClass(const SUMOSAXAttributes& attrs, const std::string& id) {
1691  SUMOVehicleClass vclass = SVC_IGNORING;
1692  bool ok = true;
1693  std::string vclassS = attrs.getOpt<std::string>(SUMO_ATTR_VCLASS, id.c_str(), ok, "");
1694  if (vclassS == "") {
1695  return vclass;
1696  }
1697  try {
1698  const SUMOVehicleClass result = getVehicleClassID(vclassS);
1699  const std::string& realName = SumoVehicleClassStrings.getString(result);
1700  if (realName != vclassS) {
1701  WRITE_WARNING("The vehicle class '" + vclassS + "' for " + attrs.getObjectType() + " '" + id + "' is deprecated, use '" + realName + "' instead.");
1702  }
1703  return result;
1704  } catch (...) {
1705  WRITE_ERRORF(TL("The vehicle class '%' for % '%' is not known."), vclassS, attrs.getObjectType(), id);
1706  }
1707  return vclass;
1708 }
1709 
1710 
1711 SUMOVehicleShape
1712 SUMOVehicleParserHelper::parseGuiShape(const SUMOSAXAttributes& attrs, const std::string& id) {
1713  bool ok = true;
1714  std::string vclassS = attrs.getOpt<std::string>(SUMO_ATTR_GUISHAPE, id.c_str(), ok, "");
1715  if (SumoVehicleShapeStrings.hasString(vclassS)) {
1716  const SUMOVehicleShape result = SumoVehicleShapeStrings.get(vclassS);
1717  const std::string& realName = SumoVehicleShapeStrings.getString(result);
1718  if (realName != vclassS) {
1719  WRITE_WARNING("The shape '" + vclassS + "' for " + attrs.getObjectType() + " '" + id + "' is deprecated, use '" + realName + "' instead.");
1720  }
1721  return result;
1722  } else {
1723  WRITE_ERRORF(TL("The shape '%' for % '%' is not known."), vclassS, attrs.getObjectType(), id);
1724  return SUMOVehicleShape::UNKNOWN;
1725  }
1726 }
1727 
1728 
1729 double
1730 SUMOVehicleParserHelper::parseWalkPos(SumoXMLAttr attr, const bool hardFail, const std::string& id, double maxPos, const std::string& val, SumoRNG* rng) {
1731  double result;
1732  std::string error;
1733  ArrivalPosDefinition proc = ArrivalPosDefinition::DEFAULT;
1734  // only supports 'random' and 'max'
1735  if (!SUMOVehicleParameter::parseArrivalPos(val, toString(SUMO_TAG_WALK), id, result, proc, error)) {
1736  handleVehicleError(hardFail, nullptr, error);
1737  }
1738  if (proc == ArrivalPosDefinition::RANDOM) {
1739  result = RandHelper::rand(maxPos, rng);
1740  } else if (proc == ArrivalPosDefinition::CENTER) {
1741  result = maxPos / 2.;
1742  } else if (proc == ArrivalPosDefinition::MAX) {
1743  result = maxPos;
1744  }
1745  return SUMOVehicleParameter::interpretEdgePos(result, maxPos, attr, id);
1746 }
1747 
1748 
1749 SUMOTime
1750 SUMOVehicleParserHelper::processActionStepLength(double given) {
1751  const std::string defaultError = "The parameter action-step-length must be a non-negative multiple of the simulation step-length. ";
1752  SUMOTime result = TIME2STEPS(given);
1753  if (result <= 0) {
1754  if (result < 0) {
1755  WRITE_WARNING(defaultError + "Ignoring given value (=" + toString(STEPS2TIME(result)) + " s.)");
1756  }
1757  result = DELTA_T;
1758  } else if (result % DELTA_T != 0) {
1759  result = (SUMOTime)((double)DELTA_T * floor(double(result) / double(DELTA_T)));
1760  result = MAX2(DELTA_T, result);
1761  if (fabs(given * 1000. - double(result)) > NUMERICAL_EPS) {
1762  WRITE_WARNING(defaultError + "Parsing given value (" + toString(given) + " s.) to the adjusted value " + toString(STEPS2TIME(result)) + " s.");
1763  }
1764  }
1765  return result;
1766 }
1767 
1768 
1769 bool
1770 SUMOVehicleParserHelper::isInternalRouteID(const std::string& id) {
1771  return id.substr(0, 1) == "!";
1772 }
1773 
1774 
1775 int
1776 SUMOVehicleParserHelper::parseCarWalkTransfer(const OptionsCont& oc, const bool hasTaxi) {
1777  int carWalk = 0;
1778  for (const std::string& opt : oc.getStringVector("persontrip.transfer.car-walk")) {
1779  if (opt == "parkingAreas") {
1780  carWalk |= ModeChangeOptions::PARKING_AREAS;
1781  } else if (opt == "ptStops") {
1782  carWalk |= ModeChangeOptions::PT_STOPS;
1783  } else if (opt == "allJunctions") {
1784  carWalk |= ModeChangeOptions::ALL_JUNCTIONS;
1785  } else {
1786  WRITE_ERRORF(TL("Invalid transfer option '%'. Must be one of 'parkingAreas', 'ptStops' and 'allJunctions'"), opt);
1787  }
1788  }
1789  const StringVector taxiDropoff = oc.getStringVector("persontrip.transfer.taxi-walk");
1790  const StringVector taxiPickup = oc.getStringVector("persontrip.transfer.walk-taxi");
1791  if (taxiDropoff.empty() && hasTaxi) {
1792  carWalk |= ModeChangeOptions::TAXI_DROPOFF_ANYWHERE;
1793  } else {
1794  for (const std::string& opt : taxiDropoff) {
1795  if (opt == "parkingAreas") {
1796  carWalk |= ModeChangeOptions::TAXI_DROPOFF_PARKING_AREAS;
1797  } else if (opt == "ptStops") {
1798  carWalk |= ModeChangeOptions::TAXI_DROPOFF_PT;
1799  } else if (opt == "allJunctions") {
1800  carWalk |= ModeChangeOptions::TAXI_DROPOFF_ANYWHERE;
1801  } else {
1802  WRITE_ERRORF(TL("Invalid transfer option '%'. Must be one of 'parkingAreas', 'ptStops' and 'allJunctions'"), opt);
1803  }
1804  }
1805  }
1806  if (taxiPickup.empty() && hasTaxi) {
1807  carWalk |= ModeChangeOptions::TAXI_PICKUP_ANYWHERE;
1808  } else {
1809  for (const std::string& opt : taxiPickup) {
1810  if (opt == "parkingAreas") {
1811  carWalk |= ModeChangeOptions::TAXI_PICKUP_PARKING_AREAS;
1812  } else if (opt == "ptStops") {
1813  carWalk |= ModeChangeOptions::TAXI_PICKUP_PT;
1814  } else if (opt == "allJunctions") {
1815  carWalk |= ModeChangeOptions::TAXI_PICKUP_ANYWHERE;
1816  } else {
1817  WRITE_ERRORF(TL("Invalid transfer option '%'. Must be one of 'parkingAreas', 'ptStops' and 'allJunctions'"), opt);
1818  }
1819  }
1820  }
1821  return carWalk;
1822 }
1823 
1824 
1825 SUMOVehicleParameter*
1826 SUMOVehicleParserHelper::handleVehicleError(const bool hardFail, SUMOVehicleParameter* vehicleParameter, const std::string message) {
1827  if (vehicleParameter) {
1828  delete vehicleParameter;
1829  }
1830  if (hardFail) {
1831  throw ProcessError(message);
1832  } else if (message.size() > 0) {
1833  WRITE_ERROR(message);
1834  }
1835  return nullptr;
1836 }
1837 
1838 
1839 SUMOVTypeParameter*
1840 SUMOVehicleParserHelper::handleVehicleTypeError(const bool hardFail, SUMOVTypeParameter* vehicleTypeParameter, const std::string message) {
1841  if (vehicleTypeParameter) {
1842  delete vehicleTypeParameter;
1843  }
1844  if (hardFail) {
1845  throw ProcessError(message);
1846  } else if (message.size() > 0) {
1847  WRITE_ERROR(message);
1848  }
1849  return nullptr;
1850 }
1851 
1852 /****************************************************************************/
SUMOTime
long long int SUMOTime
Definition: GUI.h:35
TAXI_DROPOFF_ANYWHERE
@ TAXI_DROPOFF_ANYWHERE
taxi customer may exit anywhere
Definition: IntermodalNetwork.h:63
PT_STOPS
@ PT_STOPS
public transport stops and access
Definition: IntermodalNetwork.h:55
TAXI_PICKUP_ANYWHERE
@ TAXI_PICKUP_ANYWHERE
taxi customer may be picked up anywhere
Definition: IntermodalNetwork.h:69
TAXI_PICKUP_PARKING_AREAS
@ TAXI_PICKUP_PARKING_AREAS
taxi customer may be picked up at parking areas
Definition: IntermodalNetwork.h:65
TAXI_DROPOFF_PT
@ TAXI_DROPOFF_PT
taxi customer may exit at public transport stops
Definition: IntermodalNetwork.h:61
TAXI_DROPOFF_PARKING_AREAS
@ TAXI_DROPOFF_PARKING_AREAS
taxi customer may exit at parking areas
Definition: IntermodalNetwork.h:59
ALL_JUNCTIONS
@ ALL_JUNCTIONS
junctions with edges allowing the additional mode
Definition: IntermodalNetwork.h:57
TAXI_PICKUP_PT
@ TAXI_PICKUP_PT
taxi customer may be picked up at public transport stops
Definition: IntermodalNetwork.h:67
PARKING_AREAS
@ PARKING_AREAS
parking areas
Definition: IntermodalNetwork.h:53
WRITE_WARNINGF
#define WRITE_WARNINGF(...)
Definition: MsgHandler.h:296
WRITE_ERRORF
#define WRITE_ERRORF(...)
Definition: MsgHandler.h:305
WRITE_ERROR
#define WRITE_ERROR(msg)
Definition: MsgHandler.h:304
WRITE_WARNING
#define WRITE_WARNING(msg)
Definition: MsgHandler.h:295
TL
#define TL(string)
Definition: MsgHandler.h:315
StringVector
std::vector< std::string > StringVector
Definition of a vector of strings.
Definition: Option.h:42
DELTA_T
SUMOTime DELTA_T
Definition: SUMOTime.cpp:38
string2time
SUMOTime string2time(const std::string &r)
convert string to SUMOTime
Definition: SUMOTime.cpp:46
STEPS2TIME
#define STEPS2TIME(x)
Definition: SUMOTime.h:55
SUMOTime_MAX
#define SUMOTime_MAX
Definition: SUMOTime.h:34
TIME2STEPS
#define TIME2STEPS(x)
Definition: SUMOTime.h:57
VTYPEPARS_TTT_SET
const long long int VTYPEPARS_TTT_SET
Definition: SUMOVTypeParameter.h:76
VTYPEPARS_SHAPE_SET
const long long int VTYPEPARS_SHAPE_SET
Definition: SUMOVTypeParameter.h:53
VTYPEPARS_LOADING_DURATION
const long long int VTYPEPARS_LOADING_DURATION
Definition: SUMOVTypeParameter.h:61
VTYPEPARS_TTT_BIDI_SET
const long long int VTYPEPARS_TTT_BIDI_SET
Definition: SUMOVTypeParameter.h:77
VTYPEPARS_SCALE_SET
const long long int VTYPEPARS_SCALE_SET
Definition: SUMOVTypeParameter.h:74
VTYPEPARS_PERSON_CAPACITY
const long long int VTYPEPARS_PERSON_CAPACITY
Definition: SUMOVTypeParameter.h:58
VTYPEPARS_CAR_FOLLOW_MODEL
const long long int VTYPEPARS_CAR_FOLLOW_MODEL
Definition: SUMOVTypeParameter.h:62
VTYPEPARS_WIDTH_SET
const long long int VTYPEPARS_WIDTH_SET
Definition: SUMOVTypeParameter.h:51
VTYPEPARS_ACTIONSTEPLENGTH_SET
const long long int VTYPEPARS_ACTIONSTEPLENGTH_SET
Definition: SUMOVTypeParameter.h:66
VTYPEPARS_MAXSPEED_LAT_SET
const long long int VTYPEPARS_MAXSPEED_LAT_SET
Definition: SUMOVTypeParameter.h:63
VTYPEPARS_MAXSPEED_SET
const long long int VTYPEPARS_MAXSPEED_SET
Definition: SUMOVTypeParameter.h:45
VTYPEPARS_EMISSIONCLASS_SET
const long long int VTYPEPARS_EMISSIONCLASS_SET
Definition: SUMOVTypeParameter.h:48
VTYPEPARS_LATALIGNMENT_SET
const long long int VTYPEPARS_LATALIGNMENT_SET
Definition: SUMOVTypeParameter.h:64
VTYPEPARS_COLOR_SET
const long long int VTYPEPARS_COLOR_SET
Definition: SUMOVTypeParameter.h:49
VTYPEPARS_LANE_CHANGE_MODEL_SET
const long long int VTYPEPARS_LANE_CHANGE_MODEL_SET
Definition: SUMOVTypeParameter.h:57
VTYPEPARS_DESIRED_MAXSPEED_SET
const long long int VTYPEPARS_DESIRED_MAXSPEED_SET
Definition: SUMOVTypeParameter.h:67
VTYPEPARS_OSGFILE_SET
const long long int VTYPEPARS_OSGFILE_SET
Definition: SUMOVTypeParameter.h:54
VTYPEPARS_MANEUVER_ANGLE_TIMES_SET
const long long int VTYPEPARS_MANEUVER_ANGLE_TIMES_SET
Definition: SUMOVTypeParameter.h:72
VTYPEPARS_SPEEDFACTOR_PREMATURE_SET
const long long int VTYPEPARS_SPEEDFACTOR_PREMATURE_SET
Definition: SUMOVTypeParameter.h:79
VTYPEPARS_SPEEDFACTOR_SET
const long long int VTYPEPARS_SPEEDFACTOR_SET
Definition: SUMOVTypeParameter.h:47
VTYPEPARS_MINGAP_SET
const long long int VTYPEPARS_MINGAP_SET
Definition: SUMOVTypeParameter.h:44
VTYPEPARS_PROBABILITY_SET
const long long int VTYPEPARS_PROBABILITY_SET
Definition: SUMOVTypeParameter.h:46
VTYPEPARS_HEIGHT_SET
const long long int VTYPEPARS_HEIGHT_SET
Definition: SUMOVTypeParameter.h:52
VTYPEPARS_PARKING_BADGES_SET
const long long int VTYPEPARS_PARKING_BADGES_SET
Definition: SUMOVTypeParameter.h:80
VTYPEPARS_MASS_SET
const long long int VTYPEPARS_MASS_SET
Definition: SUMOVTypeParameter.h:75
VTYPEPARS_BOARDING_DURATION
const long long int VTYPEPARS_BOARDING_DURATION
Definition: SUMOVTypeParameter.h:59
LatAlignmentDefinition
LatAlignmentDefinition
Possible ways to choose the lateral alignment, i.e., how vehicles align themselves within their lane.
Definition: SUMOVTypeParameter.h:95
VTYPEPARS_BOARDING_FACTOR_SET
const long long int VTYPEPARS_BOARDING_FACTOR_SET
Definition: SUMOVTypeParameter.h:81
VTYPEPARS_VEHICLECLASS_SET
const long long int VTYPEPARS_VEHICLECLASS_SET
Definition: SUMOVTypeParameter.h:50
VTYPEPARS_IMPATIENCE_SET
const long long int VTYPEPARS_IMPATIENCE_SET
Definition: SUMOVTypeParameter.h:56
VTYPEPARS_LENGTH_SET
const long long int VTYPEPARS_LENGTH_SET
Definition: SUMOVTypeParameter.h:43
VTYPEPARS_IMGFILE_SET
const long long int VTYPEPARS_IMGFILE_SET
Definition: SUMOVTypeParameter.h:55
VTYPEPARS_CONTAINER_CAPACITY
const long long int VTYPEPARS_CONTAINER_CAPACITY
Definition: SUMOVTypeParameter.h:60
VTYPEPARS_MINGAP_LAT_SET
const long long int VTYPEPARS_MINGAP_LAT_SET
Definition: SUMOVTypeParameter.h:65
getVehicleClassID
SUMOVehicleClass getVehicleClassID(const std::string &name)
Returns the class id of the abstract class given by its name.
Definition: SUMOVehicleClass.cpp:320
SumoVehicleClassStrings
StringBijection< SUMOVehicleClass > SumoVehicleClassStrings(sumoVehicleClassStringInitializer, SVC_CUSTOM2, false)
SumoVehicleShapeStrings
StringBijection< SUMOVehicleShape > SumoVehicleShapeStrings(sumoVehicleShapeStringInitializer, SUMOVehicleShape::UNKNOWN, false)
DEFAULT_PEDTYPE_ID
const std::string DEFAULT_PEDTYPE_ID
SUMOVehicleShape
SUMOVehicleShape
Definition of vehicle classes to differ between different appearances.
Definition: SUMOVehicleClass.h:48
SUMOVehicleShape::UNKNOWN
@ UNKNOWN
not defined
DEFAULT_CONTAINERTYPE_ID
const std::string DEFAULT_CONTAINERTYPE_ID
SUMOVehicleClass
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types.
Definition: SUMOVehicleClass.h:140
SVC_IGNORING
@ SVC_IGNORING
vehicles ignoring classes
Definition: SUMOVehicleClass.h:142
SVC_PASSENGER
@ SVC_PASSENGER
vehicle is a passenger car (a "normal" car)
Definition: SUMOVehicleClass.h:166
SVC_BICYCLE
@ SVC_BICYCLE
vehicle is a bicycle
Definition: SUMOVehicleClass.h:186
SVC_PEDESTRIAN
@ SVC_PEDESTRIAN
pedestrian
Definition: SUMOVehicleClass.h:163
VEHPARS_DEPARTEDGE_SET
const int VEHPARS_DEPARTEDGE_SET
Definition: SUMOVehicleParameter.h:69
VEHPARS_ARRIVALEDGE_SET
const int VEHPARS_ARRIVALEDGE_SET
Definition: SUMOVehicleParameter.h:70
VEHPARS_PARKING_BADGES_SET
const int VEHPARS_PARKING_BADGES_SET
Definition: SUMOVehicleParameter.h:74
VEHPARS_PROB_SET
const int VEHPARS_PROB_SET
Definition: SUMOVehicleParameter.h:52
RouteIndexDefinition
RouteIndexDefinition
Possible ways to choose the departure and arrival edge.
Definition: SUMOVehicleParameter.h:239
VEHPARS_VPH_SET
const int VEHPARS_VPH_SET
Definition: SUMOVehicleParameter.h:51
VEHPARS_END_SET
const int VEHPARS_END_SET
Definition: SUMOVehicleParameter.h:48
VEHPARS_ROUTE_SET
const int VEHPARS_ROUTE_SET
Definition: SUMOVehicleParameter.h:54
VEHPARS_COLOR_SET
const int VEHPARS_COLOR_SET
Definition: SUMOVehicleParameter.h:43
DepartLaneDefinition
DepartLaneDefinition
Possible ways to choose a lane on depart.
Definition: SUMOVehicleParameter.h:135
VEHPARS_TO_TAZ_SET
const int VEHPARS_TO_TAZ_SET
Definition: SUMOVehicleParameter.h:60
ArrivalSpeedDefinition
ArrivalSpeedDefinition
Possible ways to choose the arrival speed.
Definition: SUMOVehicleParameter.h:307
DepartPosLatDefinition
DepartPosLatDefinition
Possible ways to choose the lateral departure position.
Definition: SUMOVehicleParameter.h:187
DepartPosDefinition
DepartPosDefinition
Possible ways to choose the departure position.
Definition: SUMOVehicleParameter.h:157
VEHPARS_SPEEDFACTOR_SET
const int VEHPARS_SPEEDFACTOR_SET
Definition: SUMOVehicleParameter.h:68
ArrivalLaneDefinition
ArrivalLaneDefinition
Possible ways to choose the arrival lane.
Definition: SUMOVehicleParameter.h:253
VEHPARS_DEPARTPOS_SET
const int VEHPARS_DEPARTPOS_SET
Definition: SUMOVehicleParameter.h:46
VEHPARS_CONTAINER_NUMBER_SET
const int VEHPARS_CONTAINER_NUMBER_SET
Definition: SUMOVehicleParameter.h:64
VEHPARS_ARRIVALLANE_SET
const int VEHPARS_ARRIVALLANE_SET
Definition: SUMOVehicleParameter.h:55
DepartSpeedDefinition
DepartSpeedDefinition
Possible ways to choose the departure speed.
Definition: SUMOVehicleParameter.h:213
VEHPARS_DEPARTLANE_SET
const int VEHPARS_DEPARTLANE_SET
Definition: SUMOVehicleParameter.h:45
VEHPARS_ARRIVALPOSLAT_SET
const int VEHPARS_ARRIVALPOSLAT_SET
Definition: SUMOVehicleParameter.h:66
VEHPARS_FROM_TAZ_SET
const int VEHPARS_FROM_TAZ_SET
Definition: SUMOVehicleParameter.h:59
VEHPARS_NUMBER_SET
const int VEHPARS_NUMBER_SET
Definition: SUMOVehicleParameter.h:49
VEHPARS_ARRIVALSPEED_SET
const int VEHPARS_ARRIVALSPEED_SET
Definition: SUMOVehicleParameter.h:57
VEHPARS_CALIBRATORSPEED_SET
const int VEHPARS_CALIBRATORSPEED_SET
Definition: SUMOVehicleParameter.h:71
VEHPARS_FORCE_REROUTE
const int VEHPARS_FORCE_REROUTE
Definition: SUMOVehicleParameter.h:61
ArrivalPosDefinition
ArrivalPosDefinition
Possible ways to choose the arrival position.
Definition: SUMOVehicleParameter.h:271
ArrivalPosDefinition::RANDOM
@ RANDOM
The arrival position is chosen randomly.
ArrivalPosDefinition::MAX
@ MAX
The maximum arrival position is used.
ArrivalPosDefinition::DEFAULT
@ DEFAULT
No information given; use default.
ArrivalPosDefinition::CENTER
@ CENTER
Half the road length.
VEHPARS_LINE_SET
const int VEHPARS_LINE_SET
Definition: SUMOVehicleParameter.h:58
VEHPARS_PERSON_NUMBER_SET
const int VEHPARS_PERSON_NUMBER_SET
Definition: SUMOVehicleParameter.h:63
VEHPARS_DEPARTSPEED_SET
const int VEHPARS_DEPARTSPEED_SET
Definition: SUMOVehicleParameter.h:47
VEHPARS_PERIOD_SET
const int VEHPARS_PERIOD_SET
Definition: SUMOVehicleParameter.h:50
ArrivalPosLatDefinition
ArrivalPosLatDefinition
Possible ways to choose the lateral arrival position.
Definition: SUMOVehicleParameter.h:289
VEHPARS_VTYPE_SET
const int VEHPARS_VTYPE_SET
Definition: SUMOVehicleParameter.h:44
VEHPARS_ARRIVALPOS_SET
const int VEHPARS_ARRIVALPOS_SET
Definition: SUMOVehicleParameter.h:56
DepartDefinition::TRIGGERED
@ TRIGGERED
The departure is person triggered.
VEHPARS_DEPARTPOSLAT_SET
const int VEHPARS_DEPARTPOSLAT_SET
Definition: SUMOVehicleParameter.h:65
SumoXMLTag
SumoXMLTag
Numbers representing SUMO-XML - element names.
Definition: SUMOXMLDefinitions.h:41
SUMO_TAG_CF_KRAUSS
@ SUMO_TAG_CF_KRAUSS
Definition: SUMOXMLDefinitions.h:334
SUMO_TAG_CF_BKERNER
@ SUMO_TAG_CF_BKERNER
Definition: SUMOXMLDefinitions.h:344
SUMO_TAG_CF_KRAUSSX
@ SUMO_TAG_CF_KRAUSSX
Definition: SUMOXMLDefinitions.h:337
SUMO_TAG_CF_CACC
@ SUMO_TAG_CF_CACC
Definition: SUMOXMLDefinitions.h:348
SUMO_TAG_VTYPE
@ SUMO_TAG_VTYPE
description of a vehicle/person/container type
Definition: SUMOXMLDefinitions.h:171
SUMO_TAG_WALK
@ SUMO_TAG_WALK
Definition: SUMOXMLDefinitions.h:358
SUMO_TAG_NOTHING
@ SUMO_TAG_NOTHING
invalid tag, must be the last one
Definition: SUMOXMLDefinitions.h:797
SUMO_TAG_CF_CC
@ SUMO_TAG_CF_CC
Definition: SUMOXMLDefinitions.h:350
SUMO_TAG_CONTAINERFLOW
@ SUMO_TAG_CONTAINERFLOW
Definition: SUMOXMLDefinitions.h:373
SUMO_TAG_CF_KRAUSS_PLUS_SLOPE
@ SUMO_TAG_CF_KRAUSS_PLUS_SLOPE
Definition: SUMOXMLDefinitions.h:335
SUMO_TAG_CF_IDM
@ SUMO_TAG_CF_IDM
Definition: SUMOXMLDefinitions.h:341
SUMO_TAG_CF_W99
@ SUMO_TAG_CF_W99
Definition: SUMOXMLDefinitions.h:346
SUMO_TAG_CF_RAIL
@ SUMO_TAG_CF_RAIL
Definition: SUMOXMLDefinitions.h:349
SUMO_TAG_CF_SMART_SK
@ SUMO_TAG_CF_SMART_SK
Definition: SUMOXMLDefinitions.h:339
SUMO_TAG_CF_EIDM
@ SUMO_TAG_CF_EIDM
Definition: SUMOXMLDefinitions.h:338
SUMO_TAG_CF_PWAGNER2009
@ SUMO_TAG_CF_PWAGNER2009
Definition: SUMOXMLDefinitions.h:343
SUMO_TAG_CF_KRAUSS_ORIG1
@ SUMO_TAG_CF_KRAUSS_ORIG1
Definition: SUMOXMLDefinitions.h:336
SUMO_TAG_CF_WIEDEMANN
@ SUMO_TAG_CF_WIEDEMANN
Definition: SUMOXMLDefinitions.h:345
SUMO_TAG_FLOW
@ SUMO_TAG_FLOW
a flow definition using from and to edges or a route
Definition: SUMOXMLDefinitions.h:163
SUMO_TAG_CONTAINER
@ SUMO_TAG_CONTAINER
Definition: SUMOXMLDefinitions.h:370
SUMO_TAG_PERSON
@ SUMO_TAG_PERSON
Definition: SUMOXMLDefinitions.h:355
SUMO_TAG_CF_IDMM
@ SUMO_TAG_CF_IDMM
Definition: SUMOXMLDefinitions.h:342
SUMO_TAG_CF_DANIEL1
@ SUMO_TAG_CF_DANIEL1
Definition: SUMOXMLDefinitions.h:340
SUMO_TAG_PERSONFLOW
@ SUMO_TAG_PERSONFLOW
Definition: SUMOXMLDefinitions.h:359
SUMO_TAG_CF_ACC
@ SUMO_TAG_CF_ACC
Definition: SUMOXMLDefinitions.h:347
LaneChangeModel
LaneChangeModel
Definition: SUMOXMLDefinitions.h:2180
SumoXMLAttr
SumoXMLAttr
Numbers representing SUMO-XML - attributes.
Definition: SUMOXMLDefinitions.h:808
SUMO_ATTR_TMP4
@ SUMO_ATTR_TMP4
Definition: SUMOXMLDefinitions.h:1202
SUMO_ATTR_CF_W99_CC9
@ SUMO_ATTR_CF_W99_CC9
Definition: SUMOXMLDefinitions.h:1608
SUMO_ATTR_GCC_GAIN_GAP_DOT_CACC
@ SUMO_ATTR_GCC_GAIN_GAP_DOT_CACC
Definition: SUMOXMLDefinitions.h:1238
SUMO_ATTR_CF_EIDM_T_ACC_MAX
@ SUMO_ATTR_CF_EIDM_T_ACC_MAX
Definition: SUMOXMLDefinitions.h:1216
SUMO_ATTR_STARTUP_DELAY
@ SUMO_ATTR_STARTUP_DELAY
Definition: SUMOXMLDefinitions.h:1197
SUMO_ATTR_RESISTANCE_COEFFICIENT_CONSTANT
@ SUMO_ATTR_RESISTANCE_COEFFICIENT_CONSTANT
Definition: SUMOXMLDefinitions.h:1258
SUMO_ATTR_CF_EIDM_EPSILON_ACC
@ SUMO_ATTR_CF_EIDM_EPSILON_ACC
Definition: SUMOXMLDefinitions.h:1215
SUMO_ATTR_CF_W99_CC5
@ SUMO_ATTR_CF_W99_CC5
Definition: SUMOXMLDefinitions.h:1604
SUMO_ATTR_LCA_PUSHY
@ SUMO_ATTR_LCA_PUSHY
Definition: SUMOXMLDefinitions.h:1268
SUMO_ATTR_CF_CC_FLATBED_KP
@ SUMO_ATTR_CF_CC_FLATBED_KP
Definition: SUMOXMLDefinitions.h:1625
SUMO_ATTR_NUMBER
@ SUMO_ATTR_NUMBER
Definition: SUMOXMLDefinitions.h:1365
SUMO_ATTR_ARRIVALSPEED
@ SUMO_ATTR_ARRIVALSPEED
Definition: SUMOXMLDefinitions.h:959
SUMO_ATTR_GCC_GAIN_SPEED
@ SUMO_ATTR_GCC_GAIN_SPEED
Definition: SUMOXMLDefinitions.h:1225
SUMO_ATTR_EMISSIONCLASS
@ SUMO_ATTR_EMISSIONCLASS
Definition: SUMOXMLDefinitions.h:1546
SUMO_ATTR_ARRIVALLANE
@ SUMO_ATTR_ARRIVALLANE
Definition: SUMOXMLDefinitions.h:956
SUMO_ATTR_DEPART
@ SUMO_ATTR_DEPART
Definition: SUMOXMLDefinitions.h:950
SUMO_ATTR_CF_CC_LAMBDA
@ SUMO_ATTR_CF_CC_LAMBDA
Definition: SUMOXMLDefinitions.h:1613
SUMO_ATTR_DEPARTEDGE
@ SUMO_ATTR_DEPARTEDGE
Definition: SUMOXMLDefinitions.h:955
SUMO_ATTR_CF_CC_FLATBED_D
@ SUMO_ATTR_CF_CC_FLATBED_D
Definition: SUMOXMLDefinitions.h:1626
SUMO_ATTR_VEHSPERHOUR
@ SUMO_ATTR_VEHSPERHOUR
Definition: SUMOXMLDefinitions.h:1535
SUMO_ATTR_ARRIVALEDGE
@ SUMO_ATTR_ARRIVALEDGE
Definition: SUMOXMLDefinitions.h:960
SUMO_ATTR_SPEED
@ SUMO_ATTR_SPEED
Definition: SUMOXMLDefinitions.h:820
SUMO_ATTR_LCA_COOPERATIVE_SPEED
@ SUMO_ATTR_LCA_COOPERATIVE_SPEED
Definition: SUMOXMLDefinitions.h:1278
SUMO_ATTR_RESISTANCE_TABLE
@ SUMO_ATTR_RESISTANCE_TABLE
Definition: SUMOXMLDefinitions.h:1254
SUMO_ATTR_CF_EIDM_T_LOOK_AHEAD
@ SUMO_ATTR_CF_EIDM_T_LOOK_AHEAD
Definition: SUMOXMLDefinitions.h:1206
SUMO_ATTR_CF_CC_FLATBED_KA
@ SUMO_ATTR_CF_CC_FLATBED_KA
Definition: SUMOXMLDefinitions.h:1623
SUMO_ATTR_CF_CC_PLOEG_KP
@ SUMO_ATTR_CF_CC_PLOEG_KP
Definition: SUMOXMLDefinitions.h:1620
SUMO_ATTR_CF_WIEDEMANN_SECURITY
@ SUMO_ATTR_CF_WIEDEMANN_SECURITY
Definition: SUMOXMLDefinitions.h:1598
SUMO_ATTR_LCA_ASSERTIVE
@ SUMO_ATTR_LCA_ASSERTIVE
Definition: SUMOXMLDefinitions.h:1270
SUMO_ATTR_LCA_LANE_DISCIPLINE
@ SUMO_ATTR_LCA_LANE_DISCIPLINE
Definition: SUMOXMLDefinitions.h:1284
SUMO_ATTR_TRAIN_TYPE
@ SUMO_ATTR_TRAIN_TYPE
Definition: SUMOXMLDefinitions.h:1251
SUMO_ATTR_CF_EIDM_USEVEHDYNAMICS
@ SUMO_ATTR_CF_EIDM_USEVEHDYNAMICS
Definition: SUMOXMLDefinitions.h:1205
SUMO_ATTR_CF_IDMM_ADAPT_TIME
@ SUMO_ATTR_CF_IDMM_ADAPT_TIME
Definition: SUMOXMLDefinitions.h:1596
SUMO_ATTR_LANE_CHANGE_MODEL
@ SUMO_ATTR_LANE_CHANGE_MODEL
Definition: SUMOXMLDefinitions.h:977
SUMO_ATTR_CF_KERNER_PHI
@ SUMO_ATTR_CF_KERNER_PHI
Definition: SUMOXMLDefinitions.h:1597
SUMO_ATTR_LCA_TURN_ALIGNMENT_DISTANCE
@ SUMO_ATTR_LCA_TURN_ALIGNMENT_DISTANCE
Definition: SUMOXMLDefinitions.h:1282
SUMO_ATTR_GC_GAIN_SPACE
@ SUMO_ATTR_GC_GAIN_SPACE
Definition: SUMOXMLDefinitions.h:1228
SUMO_ATTR_SCALE
@ SUMO_ATTR_SCALE
Definition: SUMOXMLDefinitions.h:984
SUMO_ATTR_DEPARTPOS_LAT
@ SUMO_ATTR_DEPARTPOS_LAT
Definition: SUMOXMLDefinitions.h:953
SUMO_ATTR_PARKING_BADGES
@ SUMO_ATTR_PARKING_BADGES
Definition: SUMOXMLDefinitions.h:991
SUMO_ATTR_CF_EIDM_C_COOLNESS
@ SUMO_ATTR_CF_EIDM_C_COOLNESS
Definition: SUMOXMLDefinitions.h:1210
SUMO_ATTR_CF_EIDM_SIG_ERROR
@ SUMO_ATTR_CF_EIDM_SIG_ERROR
Definition: SUMOXMLDefinitions.h:1213
SUMO_ATTR_LCA_PUSHYGAP
@ SUMO_ATTR_LCA_PUSHYGAP
Definition: SUMOXMLDefinitions.h:1269
SUMO_ATTR_CA_GAIN_GAP_CACC
@ SUMO_ATTR_CA_GAIN_GAP_CACC
Definition: SUMOXMLDefinitions.h:1241
SUMO_ATTR_LCA_LOOKAHEADLEFT
@ SUMO_ATTR_LCA_LOOKAHEADLEFT
Definition: SUMOXMLDefinitions.h:1274
SUMO_ATTR_APPARENTDECEL
@ SUMO_ATTR_APPARENTDECEL
Definition: SUMOXMLDefinitions.h:969
SUMO_ATTR_MAXSPEED_LAT
@ SUMO_ATTR_MAXSPEED_LAT
Definition: SUMOXMLDefinitions.h:963
SUMO_ATTR_GC_GAIN_GAP_DOT_CACC
@ SUMO_ATTR_GC_GAIN_GAP_DOT_CACC
Definition: SUMOXMLDefinitions.h:1240
SUMO_ATTR_LCA_SPEEDGAIN_PARAM
@ SUMO_ATTR_LCA_SPEEDGAIN_PARAM
Definition: SUMOXMLDefinitions.h:1264
SUMO_ATTR_ARRIVALPOS
@ SUMO_ATTR_ARRIVALPOS
Definition: SUMOXMLDefinitions.h:957
SUMO_ATTR_TMP3
@ SUMO_ATTR_TMP3
Definition: SUMOXMLDefinitions.h:1201
SUMO_ATTR_MASSFACTOR
@ SUMO_ATTR_MASSFACTOR
Definition: SUMOXMLDefinitions.h:1255
SUMO_ATTR_ACTIONSTEPLENGTH
@ SUMO_ATTR_ACTIONSTEPLENGTH
Definition: SUMOXMLDefinitions.h:970
SUMO_ATTR_CF_CC_PLOEG_H
@ SUMO_ATTR_CF_CC_PLOEG_H
Definition: SUMOXMLDefinitions.h:1622
SUMO_ATTR_LCA_MAXDISTLATSTANDING
@ SUMO_ATTR_LCA_MAXDISTLATSTANDING
Definition: SUMOXMLDefinitions.h:1281
SUMO_ATTR_LCA_IMPATIENCE
@ SUMO_ATTR_LCA_IMPATIENCE
Definition: SUMOXMLDefinitions.h:1271
SUMO_ATTR_BEGIN
@ SUMO_ATTR_BEGIN
weights: time range begin
Definition: SUMOXMLDefinitions.h:1380
SUMO_ATTR_MINGAP
@ SUMO_ATTR_MINGAP
Definition: SUMOXMLDefinitions.h:979
SUMO_ATTR_LCA_COOPERATIVE_ROUNDABOUT
@ SUMO_ATTR_LCA_COOPERATIVE_ROUNDABOUT
Definition: SUMOXMLDefinitions.h:1277
SUMO_ATTR_MAXTRACTION
@ SUMO_ATTR_MAXTRACTION
Definition: SUMOXMLDefinitions.h:1257
SUMO_ATTR_CA_GAIN_GAP_DOT_CACC
@ SUMO_ATTR_CA_GAIN_GAP_DOT_CACC
Definition: SUMOXMLDefinitions.h:1242
SUMO_ATTR_HEADWAY_TIME_CACC_TO_ACC
@ SUMO_ATTR_HEADWAY_TIME_CACC_TO_ACC
Definition: SUMOXMLDefinitions.h:1243
SUMO_ATTR_MASS
@ SUMO_ATTR_MASS
Definition: SUMOXMLDefinitions.h:1547
SUMO_ATTR_CF_CC_OMEGAN
@ SUMO_ATTR_CF_CC_OMEGAN
Definition: SUMOXMLDefinitions.h:1616
SUMO_ATTR_CONTAINER_NUMBER
@ SUMO_ATTR_CONTAINER_NUMBER
Definition: SUMOXMLDefinitions.h:1353
SUMO_ATTR_CF_CC_C1
@ SUMO_ATTR_CF_CC_C1
Definition: SUMOXMLDefinitions.h:1614
SUMO_ATTR_TMP2
@ SUMO_ATTR_TMP2
Definition: SUMOXMLDefinitions.h:1200
SUMO_ATTR_CF_W99_CC8
@ SUMO_ATTR_CF_W99_CC8
Definition: SUMOXMLDefinitions.h:1607
SUMO_ATTR_CA_GAIN_SPACE
@ SUMO_ATTR_CA_GAIN_SPACE
Definition: SUMOXMLDefinitions.h:1230
SUMO_ATTR_LINE
@ SUMO_ATTR_LINE
Definition: SUMOXMLDefinitions.h:1516
SUMO_ATTR_LOADING_DURATION
@ SUMO_ATTR_LOADING_DURATION
Definition: SUMOXMLDefinitions.h:982
SUMO_ATTR_CF_IDM_DELTA
@ SUMO_ATTR_CF_IDM_DELTA
Definition: SUMOXMLDefinitions.h:1593
SUMO_ATTR_CF_EIDM_MAX_VEH_PREVIEW
@ SUMO_ATTR_CF_EIDM_MAX_VEH_PREVIEW
Definition: SUMOXMLDefinitions.h:1219
SUMO_ATTR_LCA_SPEEDGAIN_LOOKAHEAD
@ SUMO_ATTR_LCA_SPEEDGAIN_LOOKAHEAD
Definition: SUMOXMLDefinitions.h:1276
SUMO_ATTR_LCA_MAXSPEEDLATFACTOR
@ SUMO_ATTR_LCA_MAXSPEEDLATFACTOR
Definition: SUMOXMLDefinitions.h:1280
SUMO_ATTR_MANEUVER_ANGLE_TIMES
@ SUMO_ATTR_MANEUVER_ANGLE_TIMES
Class specific timing values for vehicle maneuvering through angle ranges.
Definition: SUMOXMLDefinitions.h:990
SUMO_ATTR_CF_CC_CCACCEL
@ SUMO_ATTR_CF_CC_CCACCEL
Definition: SUMOXMLDefinitions.h:1619
SUMO_ATTR_CONTAINERSPERHOUR
@ SUMO_ATTR_CONTAINERSPERHOUR
Definition: SUMOXMLDefinitions.h:1537
SUMO_ATTR_CF_EIDM_T_REACTION
@ SUMO_ATTR_CF_EIDM_T_REACTION
Definition: SUMOXMLDefinitions.h:1208
SUMO_ATTR_MODES
@ SUMO_ATTR_MODES
Definition: SUMOXMLDefinitions.h:1354
SUMO_ATTR_CF_EIDM_T_PERSISTENCE_ESTIMATE
@ SUMO_ATTR_CF_EIDM_T_PERSISTENCE_ESTIMATE
Definition: SUMOXMLDefinitions.h:1209
SUMO_ATTR_VTYPES
@ SUMO_ATTR_VTYPES
Definition: SUMOXMLDefinitions.h:1327
SUMO_ATTR_MAXPOWER
@ SUMO_ATTR_MAXPOWER
Definition: SUMOXMLDefinitions.h:1256
SUMO_ATTR_CF_PWAGNER2009_TAULAST
@ SUMO_ATTR_CF_PWAGNER2009_TAULAST
Definition: SUMOXMLDefinitions.h:1591
SUMO_ATTR_TIME_TO_TELEPORT_BIDI
@ SUMO_ATTR_TIME_TO_TELEPORT_BIDI
Definition: SUMOXMLDefinitions.h:987
SUMO_ATTR_CF_CC_PLOEG_KD
@ SUMO_ATTR_CF_CC_PLOEG_KD
Definition: SUMOXMLDefinitions.h:1621
SUMO_ATTR_CF_CC_TAU
@ SUMO_ATTR_CF_CC_TAU
Definition: SUMOXMLDefinitions.h:1617
SUMO_ATTR_GC_GAIN_GAP_CACC
@ SUMO_ATTR_GC_GAIN_GAP_CACC
Definition: SUMOXMLDefinitions.h:1239
SUMO_ATTR_DEPARTPOS
@ SUMO_ATTR_DEPARTPOS
Definition: SUMOXMLDefinitions.h:952
SUMO_ATTR_CF_EIDM_SIG_GAP
@ SUMO_ATTR_CF_EIDM_SIG_GAP
Definition: SUMOXMLDefinitions.h:1212
SUMO_ATTR_CAR_FOLLOW_MODEL
@ SUMO_ATTR_CAR_FOLLOW_MODEL
Definition: SUMOXMLDefinitions.h:978
SUMO_ATTR_CF_EIDM_JERK_MAX
@ SUMO_ATTR_CF_EIDM_JERK_MAX
Definition: SUMOXMLDefinitions.h:1214
SUMO_ATTR_RESISTANCE_COEFFICIENT_QUADRATIC
@ SUMO_ATTR_RESISTANCE_COEFFICIENT_QUADRATIC
Definition: SUMOXMLDefinitions.h:1260
SUMO_ATTR_DECEL
@ SUMO_ATTR_DECEL
Definition: SUMOXMLDefinitions.h:967
SUMO_ATTR_LCA_MAXSPEEDLATSTANDING
@ SUMO_ATTR_LCA_MAXSPEEDLATSTANDING
Definition: SUMOXMLDefinitions.h:1279
SUMO_ATTR_LCA_KEEPRIGHT_PARAM
@ SUMO_ATTR_LCA_KEEPRIGHT_PARAM
Definition: SUMOXMLDefinitions.h:1265
SUMO_ATTR_GUISHAPE
@ SUMO_ATTR_GUISHAPE
Definition: SUMOXMLDefinitions.h:1542
SUMO_ATTR_DESIRED_MAXSPEED
@ SUMO_ATTR_DESIRED_MAXSPEED
Definition: SUMOXMLDefinitions.h:962
SUMO_ATTR_REROUTE
@ SUMO_ATTR_REROUTE
Definition: SUMOXMLDefinitions.h:1348
SUMO_ATTR_PERHOUR
@ SUMO_ATTR_PERHOUR
Definition: SUMOXMLDefinitions.h:1538
SUMO_ATTR_CONTAINER_CAPACITY
@ SUMO_ATTR_CONTAINER_CAPACITY
Definition: SUMOXMLDefinitions.h:1350
SUMO_ATTR_CF_CC_XI
@ SUMO_ATTR_CF_CC_XI
Definition: SUMOXMLDefinitions.h:1615
SUMO_ATTR_CA_OVERRIDE
@ SUMO_ATTR_CA_OVERRIDE
Definition: SUMOXMLDefinitions.h:1231
SUMO_ATTR_PERIOD
@ SUMO_ATTR_PERIOD
Definition: SUMOXMLDefinitions.h:1343
SUMO_ATTR_LCA_COOPERATIVE_PARAM
@ SUMO_ATTR_LCA_COOPERATIVE_PARAM
Definition: SUMOXMLDefinitions.h:1263
SUMO_ATTR_LCA_OPPOSITE_PARAM
@ SUMO_ATTR_LCA_OPPOSITE_PARAM
Definition: SUMOXMLDefinitions.h:1267
SUMO_ATTR_BOARDING_FACTOR
@ SUMO_ATTR_BOARDING_FACTOR
Definition: SUMOXMLDefinitions.h:983
SUMO_ATTR_TO_TAZ
@ SUMO_ATTR_TO_TAZ
Definition: SUMOXMLDefinitions.h:1347
SUMO_ATTR_CF_CC_CCDECEL
@ SUMO_ATTR_CF_CC_CCDECEL
Definition: SUMOXMLDefinitions.h:1610
SUMO_ATTR_DEPARTSPEED
@ SUMO_ATTR_DEPARTSPEED
Definition: SUMOXMLDefinitions.h:954
SUMO_ATTR_GCC_GAIN_SPACE
@ SUMO_ATTR_GCC_GAIN_SPACE
Definition: SUMOXMLDefinitions.h:1226
SUMO_ATTR_MINGAP_LAT
@ SUMO_ATTR_MINGAP_LAT
Definition: SUMOXMLDefinitions.h:965
SUMO_ATTR_EMERGENCYDECEL
@ SUMO_ATTR_EMERGENCYDECEL
Definition: SUMOXMLDefinitions.h:968
SUMO_ATTR_CF_CC_FLATBED_H
@ SUMO_ATTR_CF_CC_FLATBED_H
Definition: SUMOXMLDefinitions.h:1627
SUMO_ATTR_CF_W99_CC3
@ SUMO_ATTR_CF_W99_CC3
Definition: SUMOXMLDefinitions.h:1602
SUMO_ATTR_LCA_OVERTAKE_DELTASPEED_FACTOR
@ SUMO_ATTR_LCA_OVERTAKE_DELTASPEED_FACTOR
Definition: SUMOXMLDefinitions.h:1287
SUMO_ATTR_CF_CC_LANES_COUNT
@ SUMO_ATTR_CF_CC_LANES_COUNT
Definition: SUMOXMLDefinitions.h:1618
SUMO_ATTR_HEIGHT
@ SUMO_ATTR_HEIGHT
Definition: SUMOXMLDefinitions.h:1541
SUMO_ATTR_END
@ SUMO_ATTR_END
weights: time range end
Definition: SUMOXMLDefinitions.h:1382
SUMO_ATTR_LCA_SUBLANE_PARAM
@ SUMO_ATTR_LCA_SUBLANE_PARAM
Definition: SUMOXMLDefinitions.h:1266
SUMO_ATTR_LCA_SIGMA
@ SUMO_ATTR_LCA_SIGMA
Definition: SUMOXMLDefinitions.h:1285
SUMO_ATTR_LATALIGNMENT
@ SUMO_ATTR_LATALIGNMENT
Definition: SUMOXMLDefinitions.h:964
SUMO_ATTR_FROM_TAZ
@ SUMO_ATTR_FROM_TAZ
Definition: SUMOXMLDefinitions.h:1346
SUMO_ATTR_CF_IDM_STEPPING
@ SUMO_ATTR_CF_IDM_STEPPING
Definition: SUMOXMLDefinitions.h:1594
SUMO_ATTR_SIGMA_STEP
@ SUMO_ATTR_SIGMA_STEP
Definition: SUMOXMLDefinitions.h:1196
SUMO_ATTR_DEPARTLANE
@ SUMO_ATTR_DEPARTLANE
Definition: SUMOXMLDefinitions.h:951
SUMO_ATTR_CF_IDMM_ADAPT_FACTOR
@ SUMO_ATTR_CF_IDMM_ADAPT_FACTOR
Definition: SUMOXMLDefinitions.h:1595
SUMO_ATTR_SPEED_TABLE
@ SUMO_ATTR_SPEED_TABLE
Definition: SUMOXMLDefinitions.h:1252
SUMO_ATTR_IMPATIENCE
@ SUMO_ATTR_IMPATIENCE
Definition: SUMOXMLDefinitions.h:1548
SUMO_ATTR_COLLISION_MINGAP_FACTOR
@ SUMO_ATTR_COLLISION_MINGAP_FACTOR
Definition: SUMOXMLDefinitions.h:980
SUMO_ATTR_VCLASS
@ SUMO_ATTR_VCLASS
Definition: SUMOXMLDefinitions.h:971
SUMO_ATTR_ACCEL
@ SUMO_ATTR_ACCEL
Definition: SUMOXMLDefinitions.h:966
SUMO_ATTR_BOARDING_DURATION
@ SUMO_ATTR_BOARDING_DURATION
Definition: SUMOXMLDefinitions.h:981
SUMO_ATTR_CF_CC_CONSTSPACING
@ SUMO_ATTR_CF_CC_CONSTSPACING
Definition: SUMOXMLDefinitions.h:1611
SUMO_ATTR_CF_EIDM_M_FLATNESS
@ SUMO_ATTR_CF_EIDM_M_FLATNESS
Definition: SUMOXMLDefinitions.h:1217
SUMO_ATTR_CF_W99_CC2
@ SUMO_ATTR_CF_W99_CC2
Definition: SUMOXMLDefinitions.h:1601
SUMO_ATTR_CF_W99_CC4
@ SUMO_ATTR_CF_W99_CC4
Definition: SUMOXMLDefinitions.h:1603
SUMO_ATTR_JM_SIGMA_MINOR
@ SUMO_ATTR_JM_SIGMA_MINOR
Definition: SUMOXMLDefinitions.h:1301
SUMO_ATTR_CF_W99_CC6
@ SUMO_ATTR_CF_W99_CC6
Definition: SUMOXMLDefinitions.h:1605
SUMO_ATTR_PROB
@ SUMO_ATTR_PROB
Definition: SUMOXMLDefinitions.h:1321
SUMO_ATTR_CF_EIDM_M_BEGIN
@ SUMO_ATTR_CF_EIDM_M_BEGIN
Definition: SUMOXMLDefinitions.h:1218
SUMO_ATTR_CF_EIDM_T_PERSISTENCE_DRIVE
@ SUMO_ATTR_CF_EIDM_T_PERSISTENCE_DRIVE
Definition: SUMOXMLDefinitions.h:1207
SUMO_ATTR_TIME_TO_TELEPORT
@ SUMO_ATTR_TIME_TO_TELEPORT
Definition: SUMOXMLDefinitions.h:986
SUMO_ATTR_SPEEDFACTOR
@ SUMO_ATTR_SPEEDFACTOR
Definition: SUMOXMLDefinitions.h:975
SUMO_ATTR_CA_GAIN_SPEED
@ SUMO_ATTR_CA_GAIN_SPEED
Definition: SUMOXMLDefinitions.h:1229
SUMO_ATTR_CF_EIDM_SIG_LEADER
@ SUMO_ATTR_CF_EIDM_SIG_LEADER
Definition: SUMOXMLDefinitions.h:1211
SUMO_ATTR_TYPE
@ SUMO_ATTR_TYPE
Definition: SUMOXMLDefinitions.h:864
SUMO_ATTR_CF_CC_KP
@ SUMO_ATTR_CF_CC_KP
Definition: SUMOXMLDefinitions.h:1612
SUMO_ATTR_LENGTH
@ SUMO_ATTR_LENGTH
Definition: SUMOXMLDefinitions.h:915
SUMO_ATTR_ROUTE
@ SUMO_ATTR_ROUTE
Definition: SUMOXMLDefinitions.h:892
SUMO_ATTR_RESISTANCE_COEFFICIENT_LINEAR
@ SUMO_ATTR_RESISTANCE_COEFFICIENT_LINEAR
Definition: SUMOXMLDefinitions.h:1259
SUMO_ATTR_APPLYDRIVERSTATE
@ SUMO_ATTR_APPLYDRIVERSTATE
Definition: SUMOXMLDefinitions.h:1245
SUMO_ATTR_PERSON_NUMBER
@ SUMO_ATTR_PERSON_NUMBER
Definition: SUMOXMLDefinitions.h:1352
SUMO_ATTR_COLOR
@ SUMO_ATTR_COLOR
A color information.
Definition: SUMOXMLDefinitions.h:1412
SUMO_ATTR_CF_PWAGNER2009_APPROB
@ SUMO_ATTR_CF_PWAGNER2009_APPROB
Definition: SUMOXMLDefinitions.h:1592
SUMO_ATTR_MAXSPEED
@ SUMO_ATTR_MAXSPEED
Definition: SUMOXMLDefinitions.h:961
SUMO_ATTR_ID
@ SUMO_ATTR_ID
Definition: SUMOXMLDefinitions.h:900
SUMO_ATTR_SIGMA
@ SUMO_ATTR_SIGMA
Definition: SUMOXMLDefinitions.h:1195
SUMO_ATTR_K
@ SUMO_ATTR_K
Definition: SUMOXMLDefinitions.h:1576
SUMO_ATTR_TMP1
@ SUMO_ATTR_TMP1
Definition: SUMOXMLDefinitions.h:1199
SUMO_ATTR_SPEEDFACTOR_PREMATURE
@ SUMO_ATTR_SPEEDFACTOR_PREMATURE
Definition: SUMOXMLDefinitions.h:988
SUMO_ATTR_OSGFILE
@ SUMO_ATTR_OSGFILE
Definition: SUMOXMLDefinitions.h:1543
SUMO_ATTR_LCA_OVERTAKE_RIGHT
@ SUMO_ATTR_LCA_OVERTAKE_RIGHT
Definition: SUMOXMLDefinitions.h:1283
SUMO_ATTR_ARRIVALPOS_LAT
@ SUMO_ATTR_ARRIVALPOS_LAT
Definition: SUMOXMLDefinitions.h:958
SUMO_ATTR_LCA_ACCEL_LAT
@ SUMO_ATTR_LCA_ACCEL_LAT
Definition: SUMOXMLDefinitions.h:1273
SUMO_ATTR_CF_W99_CC7
@ SUMO_ATTR_CF_W99_CC7
Definition: SUMOXMLDefinitions.h:1606
SUMO_ATTR_LCA_STRATEGIC_PARAM
@ SUMO_ATTR_LCA_STRATEGIC_PARAM
Definition: SUMOXMLDefinitions.h:1262
SUMO_ATTR_TRACTION_TABLE
@ SUMO_ATTR_TRACTION_TABLE
Definition: SUMOXMLDefinitions.h:1253
SUMO_ATTR_CF_W99_CC1
@ SUMO_ATTR_CF_W99_CC1
Definition: SUMOXMLDefinitions.h:1600
SUMO_ATTR_TAU
@ SUMO_ATTR_TAU
Definition: SUMOXMLDefinitions.h:1198
SUMO_ATTR_INSERTIONCHECKS
@ SUMO_ATTR_INSERTIONCHECKS
Definition: SUMOXMLDefinitions.h:985
SUMO_ATTR_IMGFILE
@ SUMO_ATTR_IMGFILE
Definition: SUMOXMLDefinitions.h:1544
SUMO_ATTR_WIDTH
@ SUMO_ATTR_WIDTH
Definition: SUMOXMLDefinitions.h:908
SUMO_ATTR_PERSON_CAPACITY
@ SUMO_ATTR_PERSON_CAPACITY
Definition: SUMOXMLDefinitions.h:1349
SUMO_ATTR_GC_GAIN_SPEED
@ SUMO_ATTR_GC_GAIN_SPEED
Definition: SUMOXMLDefinitions.h:1227
SUMO_ATTR_GCC_GAIN_GAP_CACC
@ SUMO_ATTR_GCC_GAIN_GAP_CACC
Definition: SUMOXMLDefinitions.h:1237
SUMO_ATTR_LCA_KEEPRIGHT_ACCEPTANCE_TIME
@ SUMO_ATTR_LCA_KEEPRIGHT_ACCEPTANCE_TIME
Definition: SUMOXMLDefinitions.h:1286
SUMO_ATTR_LCA_EXPERIMENTAL1
@ SUMO_ATTR_LCA_EXPERIMENTAL1
Definition: SUMOXMLDefinitions.h:1288
SUMO_ATTR_SC_GAIN
@ SUMO_ATTR_SC_GAIN
Definition: SUMOXMLDefinitions.h:1224
SUMO_ATTR_TMP5
@ SUMO_ATTR_TMP5
Definition: SUMOXMLDefinitions.h:1203
SUMO_ATTR_SC_GAIN_CACC
@ SUMO_ATTR_SC_GAIN_CACC
Definition: SUMOXMLDefinitions.h:1236
SUMO_ATTR_LCA_TIME_TO_IMPATIENCE
@ SUMO_ATTR_LCA_TIME_TO_IMPATIENCE
Definition: SUMOXMLDefinitions.h:1272
SUMO_ATTR_CF_CC_FLATBED_KV
@ SUMO_ATTR_CF_CC_FLATBED_KV
Definition: SUMOXMLDefinitions.h:1624
SUMO_ATTR_SC_MIN_GAP
@ SUMO_ATTR_SC_MIN_GAP
Definition: SUMOXMLDefinitions.h:1244
SUMO_ATTR_SPEEDDEV
@ SUMO_ATTR_SPEEDDEV
Definition: SUMOXMLDefinitions.h:976
SUMO_ATTR_CF_WIEDEMANN_ESTIMATION
@ SUMO_ATTR_CF_WIEDEMANN_ESTIMATION
Definition: SUMOXMLDefinitions.h:1599
SUMO_ATTR_PERSONSPERHOUR
@ SUMO_ATTR_PERSONSPERHOUR
Definition: SUMOXMLDefinitions.h:1536
SUMO_ATTR_LCA_SPEEDGAINRIGHT
@ SUMO_ATTR_LCA_SPEEDGAINRIGHT
Definition: SUMOXMLDefinitions.h:1275
MAX2
T MAX2(T a, T b)
Definition: StdDefs.h:82
toString
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:46
Distribution_Parameterized::parse
void parse(const std::string &description, const bool hardFail)
Overwrite by parsable distribution description.
Definition: Distribution_Parameterized.cpp:64
Distribution_Parameterized::getParameter
std::vector< double > & getParameter()
Returns the parameters of this distribution.
Definition: Distribution_Parameterized.cpp:142
Distribution_Parameterized::isValid
const std::string isValid() const
check whether the distribution is valid
Definition: Distribution_Parameterized.cpp:167
FileHelpers::isAbsolute
static bool isAbsolute(const std::string &path)
Returns the information whether the given path is absolute.
Definition: FileHelpers.cpp:154
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:140
OptionsCont
A storage for options typed value containers)
Definition: OptionsCont.h:89
OptionsCont::getStringVector
const StringVector & getStringVector(const std::string &name) const
Returns the list of string-value of the named option (only for Option_StringVector)
Definition: OptionsCont.cpp:241
OptionsCont::getOptions
static OptionsCont & getOptions()
Retrieves the options.
Definition: OptionsCont.cpp:60
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:229
RGBColor::YELLOW
static const RGBColor YELLOW
Definition: RGBColor.h:188
RGBColor::DEFAULT_COLOR
static const RGBColor DEFAULT_COLOR
The default color (for vehicle types and vehicles)
Definition: RGBColor.h:199
RandHelper::rand
static double rand(SumoRNG *rng=nullptr)
Returns a random real number in [0, 1)
Definition: RandHelper.cpp:94
SUMOSAXAttributes
Encapsulated SAX-Attributes.
Definition: SUMOSAXAttributes.h:56
SUMOSAXAttributes::getOpt
T getOpt(int attr, const char *objectid, bool &ok, T defaultValue=T(), bool report=true) const
Tries to read given attribute assuming it is an int.
Definition: SUMOSAXAttributes.h:459
SUMOSAXAttributes::getObjectType
const std::string & getObjectType() const
return the objecttype to which these attributes belong
Definition: SUMOSAXAttributes.h:367
SUMOSAXAttributes::getName
virtual std::string getName(int attr) const =0
Converts the given attribute id into a man readable string.
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:433
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.
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:60
SUMOVTypeParameter
Structure representing possible vehicle parameter.
Definition: SUMOVTypeParameter.h:122
SUMOVTypeParameter::width
double width
This class' width.
Definition: SUMOVTypeParameter.h:325
SUMOVTypeParameter::cfParameter
SubParams cfParameter
Car-following parameter.
Definition: SUMOVTypeParameter.h:345
SUMOVTypeParameter::defaultProbability
double defaultProbability
The probability when being added to a distribution without an explicit probability.
Definition: SUMOVTypeParameter.h:286
SUMOVTypeParameter::actionStepLength
SUMOTime actionStepLength
The vehicle type's default actionStepLength [ms], i.e. the interval between two control actions....
Definition: SUMOVTypeParameter.h:283
SUMOVTypeParameter::height
double height
This class' height.
Definition: SUMOVTypeParameter.h:328
SUMOVTypeParameter::desiredMaxSpeed
double desiredMaxSpeed
The vehicle type's desired maximum speed [m/s].
Definition: SUMOVTypeParameter.h:279
SUMOVTypeParameter::emissionClass
SUMOEmissionClass emissionClass
The emission class of this vehicle.
Definition: SUMOVTypeParameter.h:292
SUMOVTypeParameter::latAlignmentOffset
double latAlignmentOffset
(optional) The vehicle's desired lateral alignment as offset in m from center line
Definition: SUMOVTypeParameter.h:360
SUMOVTypeParameter::parkingBadges
std::vector< std::string > parkingBadges
the parking access rights
Definition: SUMOVTypeParameter.h:392
SUMOVTypeParameter::AllowedJMAttrs
static std::set< SumoXMLAttr > AllowedJMAttrs
allowed attrs for the junction model
Definition: SUMOVTypeParameter.h:410
SUMOVTypeParameter::length
double length
The physical vehicle length.
Definition: SUMOVTypeParameter.h:270
SUMOVTypeParameter::maxSpeedLat
double maxSpeedLat
The vehicle type's maximum lateral speed [m/s].
Definition: SUMOVTypeParameter.h:357
SUMOVTypeParameter::speedFactorPremature
double speedFactorPremature
the possible speed reduction when a train is ahead of schedule
Definition: SUMOVTypeParameter.h:383
SUMOVTypeParameter::color
RGBColor color
The color.
Definition: SUMOVTypeParameter.h:298
SUMOVTypeParameter::parametersSet
long long int parametersSet
Information for the router which parameter were set.
Definition: SUMOVTypeParameter.h:398
SUMOVTypeParameter::minGap
double minGap
This class' free space in front of the vehicle itself.
Definition: SUMOVTypeParameter.h:273
SUMOVTypeParameter::imgFile
std::string imgFile
Image file for this class.
Definition: SUMOVTypeParameter.h:337
SUMOVTypeParameter::shape
SUMOVehicleShape shape
This class' shape.
Definition: SUMOVTypeParameter.h:331
SUMOVTypeParameter::personCapacity
int personCapacity
The person capacity of the vehicle.
Definition: SUMOVTypeParameter.h:307
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:289
SUMOVTypeParameter::scale
double scale
individual scaling factor (-1 for undefined)
Definition: SUMOVTypeParameter.h:319
SUMOVTypeParameter::timeToTeleport
SUMOTime timeToTeleport
the custom time-to-teleport for this type
Definition: SUMOVTypeParameter.h:377
SUMOVTypeParameter::osgFile
std::string osgFile
3D model file for this class
Definition: SUMOVTypeParameter.h:334
SUMOVTypeParameter::maxSpeed
double maxSpeed
The vehicle type's (technical) maximum speed [m/s].
Definition: SUMOVTypeParameter.h:276
SUMOVTypeParameter::timeToTeleportBidi
SUMOTime timeToTeleportBidi
the custom time-to-teleport.bidi for this type
Definition: SUMOVTypeParameter.h:380
SUMOVTypeParameter::containerCapacity
int containerCapacity
The container capacity of the vehicle.
Definition: SUMOVTypeParameter.h:310
SUMOVTypeParameter::boardingDuration
SUMOTime boardingDuration
The time a person needs to board the vehicle.
Definition: SUMOVTypeParameter.h:313
SUMOVTypeParameter::minGapLat
double minGapLat
The vehicle type's minimum lateral gap [m].
Definition: SUMOVTypeParameter.h:366
SUMOVTypeParameter::boardingFactor
double boardingFactor
factor for boardingDuration / loadingDuration
Definition: SUMOVTypeParameter.h:395
SUMOVTypeParameter::mass
double mass
The mass.
Definition: SUMOVTypeParameter.h:295
SUMOVTypeParameter::loadingDuration
SUMOTime loadingDuration
The time a container needs to get loaded on the vehicle.
Definition: SUMOVTypeParameter.h:316
SUMOVTypeParameter::id
std::string id
The vehicle type's id.
Definition: SUMOVTypeParameter.h:267
SUMOVTypeParameter::cfModel
SumoXMLTag cfModel
The enum-representation of the car-following model to use.
Definition: SUMOVTypeParameter.h:342
SUMOVTypeParameter::lcParameter
SubParams lcParameter
Lane-changing parameter.
Definition: SUMOVTypeParameter.h:348
SUMOVTypeParameter::latAlignmentProcedure
LatAlignmentDefinition latAlignmentProcedure
Information on how the vehicle shall choose the lateral alignment.
Definition: SUMOVTypeParameter.h:363
SUMOVTypeParameter::jmParameter
SubParams jmParameter
Junction-model parameter.
Definition: SUMOVTypeParameter.h:351
SUMOVTypeParameter::impatience
double impatience
The vehicle's impatience (willingness to obstruct others)
Definition: SUMOVTypeParameter.h:304
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:477
SUMOVTypeParameter::lcModel
LaneChangeModel lcModel
The lane-change model to use.
Definition: SUMOVTypeParameter.h:354
SUMOVTypeParameter::parseLatAlignment
static bool parseLatAlignment(const std::string &val, double &lao, LatAlignmentDefinition &lad)
Parses and validates a given latAlignment value.
Definition: SUMOVTypeParameter.cpp:979
SUMOVehicleParameter
Structure representing possible vehicle parameter.
Definition: SUMOVehicleParameter.h:332
SUMOVehicleParameter::departPosLat
double departPosLat
(optional) The lateral position the vehicle shall depart from
Definition: SUMOVehicleParameter.h:697
SUMOVehicleParameter::arrivalPosLat
double arrivalPosLat
(optional) The lateral position the vehicle shall arrive on
Definition: SUMOVehicleParameter.h:731
SUMOVehicleParameter::repetitionProbability
double repetitionProbability
The probability for emitting a vehicle per second.
Definition: SUMOVehicleParameter.h:765
SUMOVehicleParameter::parametersSet
int parametersSet
Information for the router which parameter were set, TraCI may modify this (when changing color)
Definition: SUMOVehicleParameter.h:815
SUMOVehicleParameter::departLane
int departLane
(optional) The lane the vehicle shall depart from (index in edge)
Definition: SUMOVehicleParameter.h:685
SUMOVehicleParameter::arrivalSpeedProcedure
ArrivalSpeedDefinition arrivalSpeedProcedure
Information how the vehicle's end speed shall be chosen.
Definition: SUMOVehicleParameter.h:740
SUMOVehicleParameter::departSpeed
double departSpeed
(optional) The initial speed of the vehicle
Definition: SUMOVehicleParameter.h:703
SUMOVehicleParameter::tag
SumoXMLTag tag
The vehicle tag.
Definition: SUMOVehicleParameter.h:662
SUMOVehicleParameter::vtypeid
std::string vtypeid
The vehicle's type id.
Definition: SUMOVehicleParameter.h:671
SUMOVehicleParameter::repetitionOffset
SUMOTime repetitionOffset
The time offset between vehicle reinsertions.
Definition: SUMOVehicleParameter.h:759
SUMOVehicleParameter::speedFactor
double speedFactor
individual speedFactor (overriding distribution from vType)
Definition: SUMOVehicleParameter.h:806
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:559
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:622
SUMOVehicleParameter::arrivalLaneProcedure
ArrivalLaneDefinition arrivalLaneProcedure
Information how the vehicle shall choose the lane to arrive on.
Definition: SUMOVehicleParameter.h:722
SUMOVehicleParameter::departLaneProcedure
DepartLaneDefinition departLaneProcedure
Information how the vehicle shall choose the lane to depart from.
Definition: SUMOVehicleParameter.h:688
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:491
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:592
SUMOVehicleParameter::personNumber
int personNumber
The static number of persons in the vehicle when it departs (not including boarding persons)
Definition: SUMOVehicleParameter.h:800
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:652
SUMOVehicleParameter::poissonRate
double poissonRate
The rate for emitting vehicles with a poisson distribution.
Definition: SUMOVehicleParameter.h:768
SUMOVehicleParameter::arrivalEdgeProcedure
RouteIndexDefinition arrivalEdgeProcedure
Information how the vehicle's final edge shall be chosen.
Definition: SUMOVehicleParameter.h:746
SUMOVehicleParameter::departPosLatProcedure
DepartPosLatDefinition departPosLatProcedure
Information how the vehicle shall choose the lateral departure position.
Definition: SUMOVehicleParameter.h:700
SUMOVehicleParameter::modes
SVCPermissions modes
The modes a person or container can use.
Definition: SUMOVehicleParameter.h:794
SUMOVehicleParameter::repetitionEnd
SUMOTime repetitionEnd
The time at which the flow ends (only needed when using repetitionProbability)
Definition: SUMOVehicleParameter.h:771
SUMOVehicleParameter::vTypes
std::string vTypes
The types of usable (auto-generated) vehicles for a person / container.
Definition: SUMOVehicleParameter.h:797
SUMOVehicleParameter::departPos
double departPos
(optional) The position the vehicle shall depart from
Definition: SUMOVehicleParameter.h:691
SUMOVehicleParameter::departSpeedProcedure
DepartSpeedDefinition departSpeedProcedure
Information how the vehicle's initial speed shall be chosen.
Definition: SUMOVehicleParameter.h:706
SUMOVehicleParameter::color
RGBColor color
The vehicle's color, TraCI may change this.
Definition: SUMOVehicleParameter.h:674
SUMOVehicleParameter::arrivalPos
double arrivalPos
(optional) The position the vehicle shall arrive on
Definition: SUMOVehicleParameter.h:725
SUMOVehicleParameter::calibratorSpeed
double calibratorSpeed
speed (used by calibrator flows
Definition: SUMOVehicleParameter.h:809
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:378
SUMOVehicleParameter::routeid
std::string routeid
The vehicle's route id.
Definition: SUMOVehicleParameter.h:668
SUMOVehicleParameter::id
std::string id
The vehicle's id.
Definition: SUMOVehicleParameter.h:665
SUMOVehicleParameter::parkingBadges
std::vector< std::string > parkingBadges
The parking access rights.
Definition: SUMOVehicleParameter.h:791
SUMOVehicleParameter::departEdge
int departEdge
(optional) The initial edge within the route of the vehicle
Definition: SUMOVehicleParameter.h:709
SUMOVehicleParameter::parseDepart
static bool parseDepart(const std::string &val, const std::string &element, const std::string &id, SUMOTime &depart, DepartDefinition &dd, std::string &error, const std::string &attr="departure")
Validates a given depart value.
Definition: SUMOVehicleParameter.cpp:343
SUMOVehicleParameter::parsePersonModes
static bool parsePersonModes(const std::string &modes, const std::string &element, const std::string &id, SVCPermissions &modeSet, std::string &error)
Validates a given person modes value.
Definition: SUMOVehicleParameter.cpp:696
SUMOVehicleParameter::arrivalPosProcedure
ArrivalPosDefinition arrivalPosProcedure
Information how the vehicle shall choose the arrival position.
Definition: SUMOVehicleParameter.h:728
SUMOVehicleParameter::parseRouteIndex
static bool parseRouteIndex(const std::string &val, const std::string &element, const std::string &id, const SumoXMLAttr attr, int &edgeIndex, RouteIndexDefinition &rid, std::string &error)
Validates a given departEdge or arrivalEdge value.
Definition: SUMOVehicleParameter.cpp:530
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:455
SUMOVehicleParameter::toTaz
std::string toTaz
The vehicle's destination zone (district)
Definition: SUMOVehicleParameter.h:782
SUMOVehicleParameter::arrivalSpeed
double arrivalSpeed
(optional) The final speed of the vehicle (not used yet)
Definition: SUMOVehicleParameter.h:737
SUMOVehicleParameter::interpretEdgePos
static double interpretEdgePos(double pos, double maximumValue, SumoXMLAttr attr, const std::string &id, bool silent=false)
Interprets negative edge positions and fits them onto a given edge.
Definition: SUMOVehicleParameter.cpp:681
SUMOVehicleParameter::departProcedure
DepartDefinition departProcedure
Information how the vehicle shall choose the depart time.
Definition: SUMOVehicleParameter.h:682
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:415
SUMOVehicleParameter::insertionChecks
int insertionChecks
bitset of InsertionCheck
Definition: SUMOVehicleParameter.h:812
SUMOVehicleParameter::arrivalEdge
int arrivalEdge
(optional) The final edge within the route of the vehicle
Definition: SUMOVehicleParameter.h:743
SUMOVehicleParameter::fromTaz
std::string fromTaz
The vehicle's origin zone (district)
Definition: SUMOVehicleParameter.h:779
SUMOVehicleParameter::departPosProcedure
DepartPosDefinition departPosProcedure
Information how the vehicle shall choose the departure position.
Definition: SUMOVehicleParameter.h:694
SUMOVehicleParameter::line
std::string line
The vehicle's line (mainly for public transport)
Definition: SUMOVehicleParameter.h:776
SUMOVehicleParameter::containerNumber
int containerNumber
The static number of containers in the vehicle when it departs.
Definition: SUMOVehicleParameter.h:803
SUMOVehicleParameter::departEdgeProcedure
RouteIndexDefinition departEdgeProcedure
Information how the vehicle's initial edge shall be chosen.
Definition: SUMOVehicleParameter.h:712
SUMOVehicleParameter::arrivalPosLatProcedure
ArrivalPosLatDefinition arrivalPosLatProcedure
Information how the vehicle shall choose the lateral arrival position.
Definition: SUMOVehicleParameter.h:734
SUMOVehicleParserHelper::parseCarWalkTransfer
static int parseCarWalkTransfer(const OptionsCont &oc, const bool hasTaxi=false)
Definition: SUMOVehicleParserHelper.cpp:1776
SUMOVehicleParserHelper::getAllowedCFModelAttrs
static const CFAttrMap & getAllowedCFModelAttrs()
returns allowed attrs for each known CF-model (init on first use)
Definition: SUMOVehicleParserHelper.cpp:1339
SUMOVehicleParserHelper::beginVTypeParsing
static SUMOVTypeParameter * beginVTypeParsing(const SUMOSAXAttributes &attrs, const bool hardFail, const std::string &file)
Starts to parse a vehicle type.
Definition: SUMOVehicleParserHelper.cpp:757
SUMOVehicleParserHelper::parseLCParams
static bool parseLCParams(SUMOVTypeParameter *into, LaneChangeModel model, const SUMOSAXAttributes &attrs)
Parses lane change model attributes.
Definition: SUMOVehicleParserHelper.cpp:1531
SUMOVehicleParserHelper::isInternalRouteID
static bool isInternalRouteID(const std::string &id)
Checks whether the route ID uses the syntax of internal routes.
Definition: SUMOVehicleParserHelper.cpp:1770
SUMOVehicleParserHelper::CFAttrMap
std::map< SumoXMLTag, std::set< SumoXMLAttr > > CFAttrMap
Car-Following attributes map.
Definition: SUMOVehicleParserHelper.h:202
SUMOVehicleParserHelper::parseID
static std::string parseID(const SUMOSAXAttributes &attrs, const SumoXMLTag element)
parse ID
Definition: SUMOVehicleParserHelper.cpp:393
SUMOVehicleParserHelper::parseCFMParams
static bool parseCFMParams(SUMOVTypeParameter *into, const SumoXMLTag element, const SUMOSAXAttributes &attrs, const bool nestedCFM)
Parses Car Following Mode params.
Definition: SUMOVehicleParserHelper.cpp:1240
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:1750
SUMOVehicleParserHelper::LCAttrMap
std::map< LaneChangeModel, std::set< SumoXMLAttr > > LCAttrMap
Lane-Change-Model attributes map.
Definition: SUMOVehicleParserHelper.h:205
SUMOVehicleParserHelper::handleVehicleTypeError
static SUMOVTypeParameter * handleVehicleTypeError(const bool hardFail, SUMOVTypeParameter *vehicleTypeParameter, const std::string message="")
handle error loading SUMOVTypeParameter
Definition: SUMOVehicleParserHelper.cpp:1840
SUMOVehicleParserHelper::parseCommonAttributes
static void parseCommonAttributes(const SUMOSAXAttributes &attrs, SUMOVehicleParameter *ret, SumoXMLTag tag, const bool allowInternalRoutes=false)
Parses attributes common to vehicles and flows.
Definition: SUMOVehicleParserHelper.cpp:416
SUMOVehicleParserHelper::parseAngleTimesMap
static bool parseAngleTimesMap(SUMOVTypeParameter *vtype, const std::string)
Parse string containing AngleTimes triplets (angle, entry time, exit time)
Definition: SUMOVehicleParserHelper.cpp:1204
SUMOVehicleParserHelper::parseVehicleAttributes
static SUMOVehicleParameter * parseVehicleAttributes(int element, const SUMOSAXAttributes &attrs, const bool hardFail, const bool optionalID=false, const bool skipDepart=false, const bool allowInternalRoutes=false)
Parses a vehicle's attributes.
Definition: SUMOVehicleParserHelper.cpp:334
SUMOVehicleParserHelper::parseGuiShape
static SUMOVehicleShape parseGuiShape(const SUMOSAXAttributes &attrs, const std::string &id)
Parses the vehicle class.
Definition: SUMOVehicleParserHelper.cpp:1712
SUMOVehicleParserHelper::parseVehicleClass
static SUMOVehicleClass parseVehicleClass(const SUMOSAXAttributes &attrs, const std::string &id)
Parses the vehicle class.
Definition: SUMOVehicleParserHelper.cpp:1690
SUMOVehicleParserHelper::parseWalkPos
static double parseWalkPos(SumoXMLAttr attr, const bool hardFail, const std::string &id, double maxPos, const std::string &val, SumoRNG *rng=0)
parse departPos or arrivalPos for a walk
Definition: SUMOVehicleParserHelper.cpp:1730
SUMOVehicleParserHelper::allowedLCModelAttrs
static LCAttrMap allowedLCModelAttrs
allowed attrs for each known LC-model
Definition: SUMOVehicleParserHelper.h:214
SUMOVehicleParserHelper::parseFlowAttributes
static SUMOVehicleParameter * parseFlowAttributes(SumoXMLTag tag, const SUMOSAXAttributes &attrs, const bool hardFail, const bool needID, const SUMOTime beginDefault, const SUMOTime endDefault, const bool allowInternalRoutes=false)
Parses a flow's attributes.
Definition: SUMOVehicleParserHelper.cpp:57
SUMOVehicleParserHelper::handleVehicleError
static SUMOVehicleParameter * handleVehicleError(const bool hardFail, SUMOVehicleParameter *vehicleParameter, const std::string message="")
handle error loading SUMOVehicleParameter
Definition: SUMOVehicleParserHelper.cpp:1826
SUMOVehicleParserHelper::allowedCFModelAttrs
static CFAttrMap allowedCFModelAttrs
allowed attrs for each known CF-model
Definition: SUMOVehicleParserHelper.h:211
SUMOVehicleParserHelper::parseJMParams
static bool parseJMParams(SUMOVTypeParameter *into, const SUMOSAXAttributes &attrs)
Parses junction model attributes.
Definition: SUMOVehicleParserHelper.cpp:1645
SUMOXMLDefinitions::CarFollowModels
static StringBijection< SumoXMLTag > CarFollowModels
car following models
Definition: SUMOXMLDefinitions.h:2278
SUMOXMLDefinitions::InsertionChecks
static StringBijection< InsertionCheck > InsertionChecks
traffic light layouts
Definition: SUMOXMLDefinitions.h:2272
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:1718
SUMOXMLDefinitions::TrainTypes
static StringBijection< TrainType > TrainTypes
train types
Definition: SUMOXMLDefinitions.h:2284
SUMOXMLDefinitions::Tags
static SequentialStringBijection Tags
The names of SUMO-XML elements for use in netbuild.
Definition: SUMOXMLDefinitions.h:2230
SUMOXMLDefinitions::LaneChangeModels
static StringBijection< LaneChangeModel > LaneChangeModels
lane change models
Definition: SUMOXMLDefinitions.h:2275
StringBijection::get
T get(const std::string &str) const
Definition: StringBijection.h:95
StringTokenizer::size
int size() const
returns the number of existing substrings
Definition: StringTokenizer.cpp:136
StringTokenizer::get
std::string get(int pos) const
returns the item at the given position
Definition: StringTokenizer.cpp:123
StringTokenizer::hasNext
bool hasNext()
returns the information whether further substrings exist
Definition: StringTokenizer.cpp:93
StringTokenizer::next
std::string next()
returns the next substring when it exists. Otherwise the behaviour is undefined
Definition: StringTokenizer.cpp:98
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:385
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:318
nlohmann::detail::get
auto get(const nlohmann::detail::iteration_proxy_value< IteratorType > &i) -> decltype(i.key())
Definition: json.hpp:4451
SUMOVTypeParameter::VClassDefaultValues
struct for default values that depend of VClass
Definition: SUMOVTypeParameter.h:126
SUMOVTypeParameter::VClassDefaultValues::maxSpeed
double maxSpeed
The vehicle type's maximum speed [m/s] (technical limit, not subject to speed deviation)
Definition: SUMOVTypeParameter.h:140