Eclipse SUMO - Simulation of Urban MObility
Loading...
Searching...
No Matches
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
48SUMOVehicleParserHelper::CFAttrMap SUMOVehicleParserHelper::allowedCFModelAttrs;
49SUMOVehicleParserHelper::LCAttrMap SUMOVehicleParserHelper::allowedLCModelAttrs;
50
51
52// ===========================================================================
53// method definitions
54// ===========================================================================
55
56SUMOVehicleParameter*
57SUMOVehicleParserHelper::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
333SUMOVehicleParameter*
334SUMOVehicleParserHelper::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
392std::string
393SUMOVehicleParserHelper::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
415void
416SUMOVehicleParserHelper::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->parametersSet |= VEHPARS_INSERTION_CHECKS_SET;
687 bool ok = true;
688 std::string checks = attrs.get<std::string>(SUMO_ATTR_INSERTIONCHECKS, ret->id.c_str(), ok);
689 if (!ok) {
690 handleVehicleError(true, ret);
691 } else {
692 try {
693 ret->insertionChecks = SUMOVehicleParameter::parseInsertionChecks(checks);
694 } catch (InvalidArgument& e) {
695 handleVehicleError(true, ret, e.what());
696 }
697 }
698 }
699 // parse parking access rights
700 if (attrs.hasAttribute(SUMO_ATTR_PARKING_BADGES)) {
701 bool ok = true;
702 std::vector<std::string> badges = attrs.get<std::vector<std::string>>(SUMO_ATTR_PARKING_BADGES, ret->id.c_str(), ok);
703 if (!ok) {
704 handleVehicleError(true, ret);
705 } else {
706 ret->parametersSet |= VEHPARS_PARKING_BADGES_SET;
707 ret->parkingBadges = badges;
708 }
709 }
710 // parse modes (transportables only)
711 ret->modes = 0;
712 if (attrs.hasAttribute(SUMO_ATTR_MODES)) {
713 bool ok = true;
714 const std::string modeString = attrs.get<std::string>(SUMO_ATTR_MODES, ret->id.c_str(), ok);
715 if (!ok) {
716 handleVehicleError(true, ret);
717 } else {
718 std::string errorMsg;
719 if (!SUMOVehicleParameter::parsePersonModes(modeString, toString(tag), ret->id, ret->modes, errorMsg)) {
720 handleVehicleError(true, ret, errorMsg);
721 }
722 }
723 }
724 // parse usable vehicle types (transportables only)
725 if (attrs.hasAttribute(SUMO_ATTR_VTYPES)) {
726 bool ok = true;
727 ret->vTypes = attrs.get<std::string>(SUMO_ATTR_VTYPES, ret->id.c_str(), ok);
728 if (!ok) {
729 handleVehicleError(true, ret);
730 }
731 }
732 // parse speed (only used by calibrators flow)
733 // also used by vehicle in saved state but this is parsed elsewhere
734 if (tag == SUMO_TAG_FLOW && attrs.hasAttribute(SUMO_ATTR_SPEED)) {
735 bool ok = true;
736 double calibratorSpeed = attrs.get<double>(SUMO_ATTR_SPEED, ret->id.c_str(), ok);
737 if (!ok) {
738 handleVehicleError(true, ret);
739 } else if (calibratorSpeed >= 0 || calibratorSpeed == -1) {
740 ret->parametersSet |= VEHPARS_CALIBRATORSPEED_SET;
741 ret->calibratorSpeed = calibratorSpeed;
742 } else {
743 handleVehicleError(true, ret, toString(SUMO_ATTR_SPEED) + " may not be negative");
744 }
745 }
746 /*/ parse via
747 if (attrs.hasAttribute(SUMO_ATTR_VIA)) {
748 ret->setParameter |= VEHPARS_VIA_SET;
749 SUMOSAXAttributes::parseStringVector(attrs.get<std::string>(SUMO_ATTR_VIA, ret->id.c_str(), ok), ret->via);
750 }
751 */
752}
753
754
755SUMOVTypeParameter*
756SUMOVehicleParserHelper::beginVTypeParsing(const SUMOSAXAttributes& attrs, const bool hardFail, const std::string& file) {
757 // first obtain ID
758 std::string id = parseID(attrs, SUMO_TAG_VTYPE);
759 // check if ID is valid
760 if (!id.empty()) {
761 SUMOVehicleClass vClass = SVC_PASSENGER;
762 if (attrs.hasAttribute(SUMO_ATTR_VCLASS)) {
763 vClass = parseVehicleClass(attrs, id);
764 }
765 // create vType
766 SUMOVTypeParameter* vType = new SUMOVTypeParameter(id, vClass);
767 // parse attributes
768 if (attrs.hasAttribute(SUMO_ATTR_VCLASS)) {
769 vType->parametersSet |= VTYPEPARS_VEHICLECLASS_SET;
770 }
771 if (attrs.hasAttribute(SUMO_ATTR_LENGTH)) {
772 bool ok = true;
773 const double length = attrs.get<double>(SUMO_ATTR_LENGTH, vType->id.c_str(), ok);
774 if (!ok) {
775 return handleVehicleTypeError(hardFail, vType);
776 } else if (length <= 0) {
777 return handleVehicleTypeError(hardFail, vType, toString(SUMO_ATTR_LENGTH) + " must be greater than 0");
778 } else {
779 vType->length = length;
780 vType->parametersSet |= VTYPEPARS_LENGTH_SET;
781 }
782 }
783 if (attrs.hasAttribute(SUMO_ATTR_MINGAP)) {
784 bool ok = true;
785 const double minGap = attrs.get<double>(SUMO_ATTR_MINGAP, vType->id.c_str(), ok);
786 if (!ok) {
787 return handleVehicleTypeError(hardFail, vType);
788 } else if (minGap < 0) {
789 return handleVehicleTypeError(hardFail, vType, toString(SUMO_ATTR_MINGAP) + " must be equal or greater than 0");
790 } else {
791 vType->minGap = minGap;
792 vType->parametersSet |= VTYPEPARS_MINGAP_SET;
793 }
794 }
795 if (attrs.hasAttribute(SUMO_ATTR_MAXSPEED)) {
796 bool ok = true;
797 const double maxSpeed = attrs.get<double>(SUMO_ATTR_MAXSPEED, vType->id.c_str(), ok);
798 if (!ok) {
799 return handleVehicleTypeError(hardFail, vType);
800 } else if (maxSpeed <= 0) {
801 return handleVehicleTypeError(hardFail, vType, toString(SUMO_ATTR_MAXSPEED) + " must be greater than 0");
802 } else {
803 vType->maxSpeed = maxSpeed;
804 vType->parametersSet |= VTYPEPARS_MAXSPEED_SET;
805 }
806 }
807 if (attrs.hasAttribute(SUMO_ATTR_DESIRED_MAXSPEED)) {
808 bool ok = true;
809 const double desiredMaxSpeed = attrs.get<double>(SUMO_ATTR_DESIRED_MAXSPEED, vType->id.c_str(), ok);
810 if (!ok) {
811 return handleVehicleTypeError(hardFail, vType);
812 } else if (desiredMaxSpeed <= 0) {
813 return handleVehicleTypeError(hardFail, vType, toString(SUMO_ATTR_DESIRED_MAXSPEED) + " must be greater than 0");
814 } else {
815 vType->desiredMaxSpeed = desiredMaxSpeed;
816 vType->parametersSet |= VTYPEPARS_DESIRED_MAXSPEED_SET;
817 }
818 } else if (attrs.hasAttribute(SUMO_ATTR_MAXSPEED)) {
819 if (vClass == SVC_PEDESTRIAN) {
820 // backward compatibility because pedestrian maxSpeed was subject to speedFactor up to 1.14.1
821 vType->desiredMaxSpeed = vType->maxSpeed;;
822 vType->maxSpeed = MAX2(vType->maxSpeed, SUMOVTypeParameter::VClassDefaultValues(vClass).maxSpeed);
823 } else if (vClass == SVC_BICYCLE) {
824 // backward compatibility because default desired speed did not exist up to 1.14.1
825 vType->desiredMaxSpeed = MAX2(vType->maxSpeed, vType->desiredMaxSpeed);
826 }
827 }
828
829 if (attrs.hasAttribute(SUMO_ATTR_SPEEDFACTOR)) {
830 bool ok = true;
831 vType->speedFactor.parse(attrs.get<std::string>(SUMO_ATTR_SPEEDFACTOR, vType->id.c_str(), ok), hardFail);
832 if (!ok) {
833 return handleVehicleTypeError(hardFail, vType);
834 } else {
835 vType->parametersSet |= VTYPEPARS_SPEEDFACTOR_SET;
836 }
837 }
838 if (attrs.hasAttribute(SUMO_ATTR_SPEEDDEV)) {
839 bool ok = true;
840 const double speedDev = attrs.get<double>(SUMO_ATTR_SPEEDDEV, vType->id.c_str(), ok);
841 if (!ok) {
842 return handleVehicleTypeError(hardFail, vType);
843 } else if (speedDev < 0) {
844 return handleVehicleTypeError(hardFail, vType, toString(SUMO_ATTR_SPEEDDEV) + " must be equal or greater than 0");
845 } else {
846 vType->speedFactor.getParameter()[1] = speedDev;
847 vType->parametersSet |= VTYPEPARS_SPEEDFACTOR_SET;
848 }
849 }
850 // validate speed distribution
851 const std::string& error = vType->speedFactor.isValid();
852 if (error != "") {
853 return handleVehicleTypeError(hardFail, vType, "Invalid speed distribution when parsing vType '" + vType->id + "' (" + error + ")");
854 }
855 if (attrs.hasAttribute(SUMO_ATTR_ACTIONSTEPLENGTH)) {
856 bool ok = true;
857 const double actionStepLengthSecs = attrs.get<double>(SUMO_ATTR_ACTIONSTEPLENGTH, vType->id.c_str(), ok);
858 if (!ok) {
859 return handleVehicleTypeError(hardFail, vType);
860 } else {
861 // processActionStepLength(...) function includes warnings
862 vType->actionStepLength = processActionStepLength(actionStepLengthSecs);
863 vType->parametersSet |= VTYPEPARS_ACTIONSTEPLENGTH_SET;
864 }
865 }
866 if (attrs.hasAttribute(SUMO_ATTR_EMISSIONCLASS)) {
867 bool ok = true;
868 const std::string parsedEmissionClass = attrs.getOpt<std::string>(SUMO_ATTR_EMISSIONCLASS, id.c_str(), ok, "");
869 // check if emission class is correct
870 try {
871 vType->emissionClass = PollutantsInterface::getClassByName(parsedEmissionClass);
872 vType->parametersSet |= VTYPEPARS_EMISSIONCLASS_SET;
873 } catch (...) {
874 return handleVehicleTypeError(hardFail, vType, toString(SUMO_ATTR_EMISSIONCLASS) + " with name '" + parsedEmissionClass + "' doesn't exist.");
875 }
876 }
877 if (attrs.hasAttribute(SUMO_ATTR_MASS)) {
878 bool ok = true;
879 const double mass = attrs.get<double>(SUMO_ATTR_MASS, vType->id.c_str(), ok);
880 if (!ok) {
881 return handleVehicleTypeError(hardFail, vType);
882 } else if (mass < 0) {
883 return handleVehicleTypeError(hardFail, vType, toString(SUMO_ATTR_MASS) + " must be equal or greater than 0");
884 } else {
885 vType->mass = mass;
886 vType->parametersSet |= VTYPEPARS_MASS_SET;
887 }
888 }
889 if (attrs.hasAttribute(SUMO_ATTR_IMPATIENCE)) {
890 bool ok = true;
891 const std::string impatienceStr = attrs.get<std::string>(SUMO_ATTR_IMPATIENCE, vType->id.c_str(), ok);
892 if (!ok) {
893 return handleVehicleTypeError(hardFail, vType);
894 } else if (impatienceStr == "off") {
895 vType->impatience = -std::numeric_limits<double>::max();
896 } else {
897 const double impatienceDouble = attrs.get<double>(SUMO_ATTR_IMPATIENCE, vType->id.c_str(), ok);
898 if (!ok) {
899 return handleVehicleTypeError(hardFail, vType);
900 } else {
901 vType->impatience = impatienceDouble;
902 vType->parametersSet |= VTYPEPARS_IMPATIENCE_SET;
903 }
904 }
905 }
906 if (attrs.hasAttribute(SUMO_ATTR_WIDTH)) {
907 bool ok = true;
908 const double width = attrs.get<double>(SUMO_ATTR_WIDTH, vType->id.c_str(), ok);
909 if (!ok) {
910 return handleVehicleTypeError(hardFail, vType);
911 } else if (width <= 0) {
912 return handleVehicleTypeError(hardFail, vType, toString(SUMO_ATTR_WIDTH) + " must be greater than 0");
913 } else {
914 vType->width = width;
915 vType->parametersSet |= VTYPEPARS_WIDTH_SET;
916 if (vClass == SVC_PEDESTRIAN
917 && OptionsCont::getOptions().exists("pedestrian.striping.stripe-width")
918 && OptionsCont::getOptions().getString("pedestrian.model") == "striping"
919 && OptionsCont::getOptions().getFloat("pedestrian.striping.stripe-width") < vType->width) {
920 WRITE_WARNINGF(TL("Pedestrian vType '%' width % is larger than pedestrian.striping.stripe-width and this may cause collisions with vehicles."), id, vType->width);
921 }
922 }
923 }
924 if (attrs.hasAttribute(SUMO_ATTR_HEIGHT)) {
925 bool ok = true;
926 const double height = attrs.get<double>(SUMO_ATTR_HEIGHT, vType->id.c_str(), ok);
927 if (!ok) {
928 return handleVehicleTypeError(hardFail, vType);
929 } else if (height < 0) {
930 return handleVehicleTypeError(hardFail, vType, toString(SUMO_ATTR_HEIGHT) + " must be equal or greater than 0");
931 } else {
932 vType->height = height;
933 vType->parametersSet |= VTYPEPARS_HEIGHT_SET;
934 }
935 }
936 if (attrs.hasAttribute(SUMO_ATTR_GUISHAPE)) {
937 vType->shape = parseGuiShape(attrs, vType->id);
938 if (vType->shape != SUMOVehicleShape::UNKNOWN) {
939 vType->parametersSet |= VTYPEPARS_SHAPE_SET;
940 }
941 }
942 if (attrs.hasAttribute(SUMO_ATTR_OSGFILE)) {
943 bool ok = true;
944 const std::string osgFile = attrs.get<std::string>(SUMO_ATTR_OSGFILE, vType->id.c_str(), ok);
945 if (!ok) {
946 return handleVehicleTypeError(hardFail, vType);
947 } else {
948 vType->osgFile = osgFile;
949 vType->parametersSet |= VTYPEPARS_OSGFILE_SET;
950 }
951 }
952 if (attrs.hasAttribute(SUMO_ATTR_IMGFILE)) {
953 bool ok = true;
954 std::string imgFile = attrs.get<std::string>(SUMO_ATTR_IMGFILE, vType->id.c_str(), ok);
955 if (!ok) {
956 return handleVehicleTypeError(hardFail, vType);
957 } else {
958 // check relative path
959 if ((imgFile != "") && !FileHelpers::isAbsolute(imgFile)) {
960 imgFile = FileHelpers::getConfigurationRelative(file, imgFile);
961 }
962 vType->imgFile = imgFile;
963 vType->parametersSet |= VTYPEPARS_IMGFILE_SET;
964 }
965 }
966 if (attrs.hasAttribute(SUMO_ATTR_COLOR)) {
967 bool ok = true;
968 const RGBColor color = attrs.get<RGBColor>(SUMO_ATTR_COLOR, vType->id.c_str(), ok);
969 if (!ok) {
970 return handleVehicleTypeError(hardFail, vType);
971 } else {
972 vType->color = color;
973 vType->parametersSet |= VTYPEPARS_COLOR_SET;
974 }
975 } else {
976 vType->color = RGBColor::YELLOW;
977 }
978 if (attrs.hasAttribute(SUMO_ATTR_PROB)) {
979 bool ok = true;
980 const double defaultProbability = attrs.get<double>(SUMO_ATTR_PROB, vType->id.c_str(), ok);
981 if (!ok) {
982 return handleVehicleTypeError(hardFail, vType);
983 } else if (defaultProbability < 0) {
984 return handleVehicleTypeError(hardFail, vType, toString(SUMO_ATTR_PROB) + " must be equal or greater than 0");
985 } else {
986 vType->defaultProbability = defaultProbability;
987 vType->parametersSet |= VTYPEPARS_PROBABILITY_SET;
988 }
989 }
990 if (attrs.hasAttribute(SUMO_ATTR_LANE_CHANGE_MODEL)) {
991 bool ok = true;
992 std::string lcmS = attrs.get<std::string>(SUMO_ATTR_LANE_CHANGE_MODEL, vType->id.c_str(), ok);
993 if (!ok) {
994 return handleVehicleTypeError(hardFail, vType);
995 } else if (lcmS == "JE2013") {
996 WRITE_WARNING(TL("Lane change model 'JE2013' is deprecated. Using default model instead."));
997 lcmS = "default";
998 }
999 if (SUMOXMLDefinitions::LaneChangeModels.hasString(lcmS)) {
1000 vType->lcModel = SUMOXMLDefinitions::LaneChangeModels.get(lcmS);
1001 vType->parametersSet |= VTYPEPARS_LANE_CHANGE_MODEL_SET;
1002 } else {
1003 return handleVehicleTypeError(hardFail, vType, "Unknown lane change model '" + lcmS + "' when parsing vType '" + vType->id + "'");
1004 }
1005 }
1006 if (attrs.hasAttribute(SUMO_ATTR_CAR_FOLLOW_MODEL)) {
1007 bool ok = true;
1008 const std::string cfmValue = attrs.get<std::string>(SUMO_ATTR_CAR_FOLLOW_MODEL, vType->id.c_str(), ok);
1009 if (!ok) {
1010 return handleVehicleTypeError(hardFail, vType);
1011 } else if (SUMOXMLDefinitions::CarFollowModels.hasString(cfmValue)) {
1012 vType->cfModel = SUMOXMLDefinitions::CarFollowModels.get(cfmValue);
1013 vType->parametersSet |= VTYPEPARS_CAR_FOLLOW_MODEL;
1014 } else {
1015 return handleVehicleTypeError(hardFail, vType, "Unknown car following model '" + cfmValue + "' when parsing vType '" + vType->id + "'");
1016 }
1017 }
1018 if (attrs.hasAttribute(SUMO_ATTR_PERSON_CAPACITY)) {
1019 bool ok = true;
1020 const int personCapacity = attrs.get<int>(SUMO_ATTR_PERSON_CAPACITY, vType->id.c_str(), ok);
1021 if (!ok) {
1022 return handleVehicleTypeError(hardFail, vType);
1023 } else if (personCapacity < 0) {
1024 return handleVehicleTypeError(hardFail, vType, toString(SUMO_ATTR_PERSON_CAPACITY) + " must be equal or greater than 0");
1025 } else {
1026 vType->personCapacity = personCapacity;
1027 vType->parametersSet |= VTYPEPARS_PERSON_CAPACITY;
1028 }
1029 }
1030 if (attrs.hasAttribute(SUMO_ATTR_CONTAINER_CAPACITY)) {
1031 bool ok = true;
1032 const int containerCapacity = attrs.get<int>(SUMO_ATTR_CONTAINER_CAPACITY, vType->id.c_str(), ok);
1033 if (!ok) {
1034 return handleVehicleTypeError(hardFail, vType);
1035 } else if (containerCapacity < 0) {
1036 return handleVehicleTypeError(hardFail, vType, toString(SUMO_ATTR_CONTAINER_CAPACITY) + " must be equal or greater than 0");
1037 } else {
1038 vType->containerCapacity = containerCapacity;
1039 vType->parametersSet |= VTYPEPARS_CONTAINER_CAPACITY;
1040 }
1041 }
1042 if (attrs.hasAttribute(SUMO_ATTR_BOARDING_DURATION)) {
1043 bool ok = true;
1044 const SUMOTime boardingDuration = attrs.getSUMOTimeReporting(SUMO_ATTR_BOARDING_DURATION, vType->id.c_str(), ok);
1045 if (!ok) {
1046 return handleVehicleTypeError(hardFail, vType);
1047 } else if (boardingDuration < 0) {
1048 return handleVehicleTypeError(hardFail, vType, toString(SUMO_ATTR_BOARDING_DURATION) + " must be equal or greater than 0");
1049 } else {
1050 vType->boardingDuration = boardingDuration;
1051 vType->parametersSet |= VTYPEPARS_BOARDING_DURATION;
1052 }
1053 }
1054 if (attrs.hasAttribute(SUMO_ATTR_LOADING_DURATION)) {
1055 bool ok = true;
1056 const SUMOTime loadingDuration = attrs.getSUMOTimeReporting(SUMO_ATTR_LOADING_DURATION, vType->id.c_str(), ok);
1057 if (!ok) {
1058 return handleVehicleTypeError(hardFail, vType);
1059 } else if (loadingDuration < 0) {
1060 return handleVehicleTypeError(hardFail, vType, toString(SUMO_ATTR_LOADING_DURATION) + " must be equal or greater than 0");
1061 } else {
1062 vType->loadingDuration = loadingDuration;
1063 vType->parametersSet |= VTYPEPARS_LOADING_DURATION;
1064 }
1065 }
1066 if (attrs.hasAttribute(SUMO_ATTR_SCALE)) {
1067 bool ok = true;
1068 const double scale = attrs.get<double>(SUMO_ATTR_SCALE, id.c_str(), ok);
1069 if (!ok) {
1070 return handleVehicleTypeError(hardFail, vType);
1071 } else if (scale < 0) {
1072 return handleVehicleTypeError(hardFail, vType, toString(SUMO_ATTR_SCALE) + " may be not be negative");
1073 } else {
1074 vType->scale = scale;
1075 vType->parametersSet |= VTYPEPARS_SCALE_SET;
1076 }
1077 }
1078 if (attrs.hasAttribute(SUMO_ATTR_TIME_TO_TELEPORT)) {
1079 bool ok = true;
1080 const SUMOTime ttt = attrs.getSUMOTimeReporting(SUMO_ATTR_TIME_TO_TELEPORT, vType->id.c_str(), ok);
1081 if (!ok) {
1082 return handleVehicleTypeError(hardFail, vType);
1083 } else {
1084 vType->timeToTeleport = ttt;
1085 vType->parametersSet |= VTYPEPARS_TTT_SET;
1086 }
1087 }
1088 if (attrs.hasAttribute(SUMO_ATTR_TIME_TO_TELEPORT_BIDI)) {
1089 bool ok = true;
1090 const SUMOTime tttb = attrs.getSUMOTimeReporting(SUMO_ATTR_TIME_TO_TELEPORT_BIDI, vType->id.c_str(), ok);
1091 if (!ok) {
1092 return handleVehicleTypeError(hardFail, vType);
1093 } else {
1094 vType->timeToTeleportBidi = tttb;
1095 vType->parametersSet |= VTYPEPARS_TTT_BIDI_SET;
1096 }
1097 }
1098 if (attrs.hasAttribute(SUMO_ATTR_SPEEDFACTOR_PREMATURE)) {
1099 bool ok = true;
1100 const double sfp = attrs.get<double>(SUMO_ATTR_SPEEDFACTOR_PREMATURE, id.c_str(), ok);
1101 if (!ok) {
1102 return handleVehicleTypeError(hardFail, vType);
1103 } else {
1104 vType->speedFactorPremature = sfp;
1105 vType->parametersSet |= VTYPEPARS_SPEEDFACTOR_PREMATURE_SET;
1106 }
1107 }
1108 if (attrs.hasAttribute(SUMO_ATTR_BOARDING_FACTOR)) {
1109 bool ok = true;
1110 const double bf = attrs.get<double>(SUMO_ATTR_BOARDING_FACTOR, id.c_str(), ok);
1111 if (!ok) {
1112 return handleVehicleTypeError(hardFail, vType);
1113 } else if (bf < 0) {
1114 return handleVehicleTypeError(hardFail, vType, toString(SUMO_ATTR_BOARDING_FACTOR) + " must be equal or greater than 0");
1115 } else {
1116 vType->boardingFactor = bf;
1117 vType->parametersSet |= VTYPEPARS_BOARDING_FACTOR_SET;
1118 }
1119 }
1120 if (attrs.hasAttribute(SUMO_ATTR_MAXSPEED_LAT)) {
1121 bool ok = true;
1122 const double maxSpeedLat = attrs.get<double>(SUMO_ATTR_MAXSPEED_LAT, vType->id.c_str(), ok);
1123 if (!ok) {
1124 return handleVehicleTypeError(hardFail, vType);
1125 } else if (maxSpeedLat <= 0) {
1126 return handleVehicleTypeError(hardFail, vType, toString(SUMO_ATTR_MAXSPEED_LAT) + " must be greater than 0");
1127 } else {
1128 vType->maxSpeedLat = maxSpeedLat;
1129 vType->parametersSet |= VTYPEPARS_MAXSPEED_LAT_SET;
1130 }
1131 }
1132 if (attrs.hasAttribute(SUMO_ATTR_MINGAP_LAT)) {
1133 bool ok = true;
1134 const double minGapLat = attrs.get<double>(SUMO_ATTR_MINGAP_LAT, vType->id.c_str(), ok);
1135 if (!ok) {
1136 return handleVehicleTypeError(hardFail, vType);
1137 } else if (minGapLat < 0) {
1138 return handleVehicleTypeError(hardFail, vType, toString(SUMO_ATTR_MINGAP_LAT) + " must be equal or greater than 0");
1139 } else {
1140 vType->minGapLat = minGapLat;
1141 vType->parametersSet |= VTYPEPARS_MINGAP_LAT_SET;
1142 }
1143 }
1144 if (attrs.hasAttribute(SUMO_ATTR_LATALIGNMENT)) {
1145 bool ok = true;
1146 const std::string alignS = attrs.get<std::string>(SUMO_ATTR_LATALIGNMENT, vType->id.c_str(), ok);
1147 if (!ok) {
1148 return handleVehicleTypeError(hardFail, vType);
1149 } else {
1150 double lao;
1151 LatAlignmentDefinition lad;
1152 if (SUMOVTypeParameter::parseLatAlignment(alignS, lao, lad)) {
1153 vType->latAlignmentOffset = lao;
1154 vType->latAlignmentProcedure = lad;
1155 vType->parametersSet |= VTYPEPARS_LATALIGNMENT_SET;
1156 } else {
1157 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)");
1158 }
1159 }
1160 }
1161 if (attrs.hasAttribute(SUMO_ATTR_MANEUVER_ANGLE_TIMES)) {
1162 bool ok = true;
1163 const std::string angleTimesS = attrs.get<std::string>(SUMO_ATTR_MANEUVER_ANGLE_TIMES, vType->id.c_str(), ok);
1164 if (!ok) {
1165 return handleVehicleTypeError(hardFail, vType);
1166 } else if (parseAngleTimesMap(vType, angleTimesS)) {
1167 vType->parametersSet |= VTYPEPARS_MANEUVER_ANGLE_TIMES_SET;
1168 } else {
1169 return handleVehicleTypeError(hardFail, vType, "Invalid manoeuver angle times map for vType '" + vType->id + "'");
1170 }
1171 }
1172 if (attrs.hasAttribute(SUMO_ATTR_PARKING_BADGES)) {
1173 bool ok = true;
1174 std::vector<std::string> badges = attrs.get<std::vector<std::string>>(SUMO_ATTR_PARKING_BADGES, vType->id.c_str(), ok);
1175 if (!ok) {
1176 return handleVehicleTypeError(hardFail, vType);
1177 } else {
1178 vType->parametersSet |= VTYPEPARS_PARKING_BADGES_SET;
1179 vType->parkingBadges = badges;
1180 }
1181 }
1182 // try to parse Car Following Model params
1183 if (!parseCFMParams(vType, vType->cfModel, attrs, false)) {
1184 return handleVehicleTypeError(hardFail, vType, "Invalid parsing embedded VType");
1185 }
1186 // try to parse Lane Change Model params
1187 if (!parseLCParams(vType, vType->lcModel, attrs)) {
1188 return handleVehicleTypeError(hardFail, vType, "Invalid Lane Change Model Parameters");
1189 }
1190 // try to Junction Model params
1191 if (!parseJMParams(vType, attrs)) {
1192 return handleVehicleTypeError(hardFail, vType, "Invalid Junction Model Parameters");
1193 }
1194 // all ok, then return vType
1195 return vType;
1196 } else {
1197 return handleVehicleTypeError(hardFail, nullptr, "VType cannot be created");
1198 }
1199}
1200
1201
1202bool
1203SUMOVehicleParserHelper::parseAngleTimesMap(SUMOVTypeParameter* vtype, const std::string atm) {
1204 StringTokenizer st(atm, ",");
1205 std::map<int, std::pair<SUMOTime, SUMOTime>> angleTimesMap;
1206 int tripletCount = 0;
1207 while (st.hasNext()) {
1208 StringTokenizer pos(st.next());
1209 if (pos.size() != 3) {
1210 WRITE_ERRORF(TL("maneuverAngleTimes format for vType '%' % contains an invalid triplet."), vtype->id, atm);
1211 return false;
1212 } else {
1213 try {
1214 const int angle = StringUtils::toInt(pos.next());
1215 const SUMOTime t1 = string2time(pos.next());
1216 const SUMOTime t2 = string2time(pos.next());
1217 angleTimesMap[angle] = std::make_pair(t1, t2);
1218 } catch (...) {
1219 WRITE_ERRORF(TL("Triplet '%' for vType '%' maneuverAngleTimes cannot be parsed as 'int double double'"), st.get(tripletCount), vtype->id);
1220 return false;
1221 }
1222 tripletCount++;
1223 }
1224 }
1225 if (angleTimesMap.size() > 0) {
1226 vtype->myManoeuverAngleTimes.clear();
1227 for (const auto& angleTime : angleTimesMap) {
1228 vtype->myManoeuverAngleTimes.insert(angleTime);
1229 }
1230 angleTimesMap.clear();
1231 return true;
1232 } else {
1233 return false;
1234 }
1235}
1236
1237
1238bool
1239SUMOVehicleParserHelper::parseCFMParams(SUMOVTypeParameter* into, const SumoXMLTag element, const SUMOSAXAttributes& attrs, const bool nestedCFM) {
1240 const CFAttrMap& allowedCFM = getAllowedCFModelAttrs();
1241 CFAttrMap::const_iterator cf_it = allowedCFM.find(element);
1242 // check if given CFM is allowed
1243 if (cf_it == allowedCFM.end()) {
1244 if (SUMOXMLDefinitions::Tags.has((int)element)) {
1245 WRITE_ERRORF(TL("Unknown car-following model % when parsing vType '%'"), toString(element), into->id);
1246 } else {
1247 WRITE_ERRORF(TL("Unknown car-following model when parsing vType '%'"), into->id);
1248 }
1249 return false;
1250 }
1251 // check if we're parsing a nested CFM
1252 if (nestedCFM) {
1253 into->cfModel = cf_it->first;
1254 into->parametersSet |= VTYPEPARS_CAR_FOLLOW_MODEL;
1255 }
1256 // set CFM values
1257 for (const auto& it : cf_it->second) {
1258 if (attrs.hasAttribute(it)) {
1259 // first obtain CFM attribute in string format
1260 bool ok = true;
1261 std::string parsedCFMAttribute = attrs.get<std::string>(it, into->id.c_str(), ok);
1262 // check CFM Attribute
1263 if (!ok) {
1264 return false;
1265 } else if (it == SUMO_ATTR_TRAIN_TYPE) {
1266 // check if train value is valid
1267 if (!SUMOXMLDefinitions::TrainTypes.hasString(parsedCFMAttribute)) {
1268 WRITE_ERROR("Invalid train type '" + parsedCFMAttribute + "' used in Car-Following-Attribute " + toString(it));
1269 return false;
1270 }
1271 // add parsedCFMAttribute to cfParameter
1272 into->cfParameter[it] = parsedCFMAttribute;
1273 } else if (it == SUMO_ATTR_SPEED_TABLE || it == SUMO_ATTR_TRACTION_TABLE || it == SUMO_ATTR_RESISTANCE_TABLE) {
1274 into->cfParameter[it] = parsedCFMAttribute;
1275 } else if (it == SUMO_ATTR_CF_IDM_STEPPING) {
1276 // declare a int in wich save CFM int attribute
1277 double CFMDoubleAttribute = -1;
1278 try {
1279 // obtain CFM attribute in int format
1280 CFMDoubleAttribute = StringUtils::toDouble(parsedCFMAttribute);
1281 } catch (...) {
1282 WRITE_ERRORF(TL("Invalid Car-Following-Model Attribute %. Cannot be parsed to float"), toString(it));
1283 return false;
1284 }
1285 if (CFMDoubleAttribute <= 0) {
1286 WRITE_ERRORF(TL("Invalid Car-Following-Model Attribute %. Must be greater than 0"), toString(it));
1287 return false;
1288 }
1289 // add parsedCFMAttribute to cfParameter
1290 into->cfParameter[it] = parsedCFMAttribute;
1291 } else {
1292 // declare a double in wich save CFM float attribute
1293 double CFMDoubleAttribute = -1;
1294 try {
1295 // obtain CFM attribute in double format
1296 CFMDoubleAttribute = StringUtils::toDouble(parsedCFMAttribute);
1297 } catch (...) {
1298 WRITE_ERRORF(TL("Invalid Car-Following-Model Attribute %. Cannot be parsed to float"), toString(it));
1299 return false;
1300 }
1301 // check attributes of type "positiveFloatType" (> 0)
1302 switch (it) {
1303 case SUMO_ATTR_ACCEL:
1304 case SUMO_ATTR_DECEL:
1305 case SUMO_ATTR_APPARENTDECEL:
1306 case SUMO_ATTR_EMERGENCYDECEL:
1307 case SUMO_ATTR_TAU:
1308 if (CFMDoubleAttribute <= 0) {
1309 WRITE_ERRORF(TL("Invalid Car-Following-Model Attribute %. Must be greater than 0"), toString(it));
1310 return false;
1311 }
1312 break;
1313 default:
1314 break;
1315 }
1316 // check attributes restricted to [0-1]
1317 switch (it) {
1318 case SUMO_ATTR_SIGMA:
1319 if ((CFMDoubleAttribute < 0) || (CFMDoubleAttribute > 1)) {
1320 WRITE_ERRORF(TL("Invalid Car-Following-Model Attribute %. Only values between [0-1] are allowed"), toString(it));
1321 return false;
1322 }
1323 break;
1324 default:
1325 break;
1326 }
1327 // add parsedCFMAttribute to cfParameter
1328 into->cfParameter[it] = parsedCFMAttribute;
1329 }
1330 }
1331 }
1332 // all CFM successfully parsed, then return true
1333 return true;
1334}
1335
1336
1337const SUMOVehicleParserHelper::CFAttrMap&
1338SUMOVehicleParserHelper::getAllowedCFModelAttrs() {
1339 // init on first use
1340 if (allowedCFModelAttrs.size() == 0) {
1341 std::set<SumoXMLAttr> genericParams;
1342 genericParams.insert(SUMO_ATTR_TAU);
1343 genericParams.insert(SUMO_ATTR_ACCEL);
1344 genericParams.insert(SUMO_ATTR_DECEL);
1345 genericParams.insert(SUMO_ATTR_APPARENTDECEL);
1346 genericParams.insert(SUMO_ATTR_EMERGENCYDECEL);
1347 genericParams.insert(SUMO_ATTR_COLLISION_MINGAP_FACTOR);
1348 genericParams.insert(SUMO_ATTR_STARTUP_DELAY);
1349 // Krauss
1350 std::set<SumoXMLAttr> kraussParams(genericParams);
1351 kraussParams.insert(SUMO_ATTR_SIGMA);
1352 kraussParams.insert(SUMO_ATTR_SIGMA_STEP);
1353 allowedCFModelAttrs[SUMO_TAG_CF_KRAUSS] = kraussParams;
1354 allowedCFModelAttrs[SUMO_TAG_CF_KRAUSS_ORIG1] = kraussParams;
1355 allowedCFModelAttrs[SUMO_TAG_CF_KRAUSS_PLUS_SLOPE] = kraussParams;
1356 std::set<SumoXMLAttr> allParams(kraussParams);
1357 // KraussX
1358 std::set<SumoXMLAttr> kraussXParams(kraussParams);
1359 kraussXParams.insert(SUMO_ATTR_TMP1);
1360 kraussXParams.insert(SUMO_ATTR_TMP2);
1361 kraussXParams.insert(SUMO_ATTR_TMP3);
1362 kraussXParams.insert(SUMO_ATTR_TMP4);
1363 kraussXParams.insert(SUMO_ATTR_TMP5);
1364 allowedCFModelAttrs[SUMO_TAG_CF_KRAUSSX] = kraussXParams;
1365 allParams.insert(kraussXParams.begin(), kraussXParams.end());
1366 // SmartSK
1367 std::set<SumoXMLAttr> smartSKParams(genericParams);
1368 smartSKParams.insert(SUMO_ATTR_SIGMA);
1369 smartSKParams.insert(SUMO_ATTR_TMP1);
1370 smartSKParams.insert(SUMO_ATTR_TMP2);
1371 smartSKParams.insert(SUMO_ATTR_TMP3);
1372 smartSKParams.insert(SUMO_ATTR_TMP4);
1373 smartSKParams.insert(SUMO_ATTR_TMP5);
1374 allowedCFModelAttrs[SUMO_TAG_CF_SMART_SK] = smartSKParams;
1375 allParams.insert(smartSKParams.begin(), smartSKParams.end());
1376 // Daniel
1377 std::set<SumoXMLAttr> daniel1Params(genericParams);
1378 daniel1Params.insert(SUMO_ATTR_SIGMA);
1379 daniel1Params.insert(SUMO_ATTR_TMP1);
1380 daniel1Params.insert(SUMO_ATTR_TMP2);
1381 daniel1Params.insert(SUMO_ATTR_TMP3);
1382 daniel1Params.insert(SUMO_ATTR_TMP4);
1383 daniel1Params.insert(SUMO_ATTR_TMP5);
1384 allowedCFModelAttrs[SUMO_TAG_CF_DANIEL1] = daniel1Params;
1385 allParams.insert(daniel1Params.begin(), daniel1Params.end());
1386 // Peter Wagner
1387 std::set<SumoXMLAttr> pwagParams(genericParams);
1388 pwagParams.insert(SUMO_ATTR_SIGMA);
1389 pwagParams.insert(SUMO_ATTR_CF_PWAGNER2009_TAULAST);
1390 pwagParams.insert(SUMO_ATTR_CF_PWAGNER2009_APPROB);
1391 allowedCFModelAttrs[SUMO_TAG_CF_PWAGNER2009] = pwagParams;
1392 allParams.insert(pwagParams.begin(), pwagParams.end());
1393 // IDM params
1394 std::set<SumoXMLAttr> idmParams(genericParams);
1395 idmParams.insert(SUMO_ATTR_CF_IDM_DELTA);
1396 idmParams.insert(SUMO_ATTR_CF_IDM_STEPPING);
1397 allowedCFModelAttrs[SUMO_TAG_CF_IDM] = idmParams;
1398 allParams.insert(idmParams.begin(), idmParams.end());
1399 // EIDM
1400 std::set<SumoXMLAttr> eidmParams(genericParams);
1401 eidmParams.insert(SUMO_ATTR_CF_IDM_DELTA);
1402 eidmParams.insert(SUMO_ATTR_CF_IDM_STEPPING);
1403 eidmParams.insert(SUMO_ATTR_CF_EIDM_T_LOOK_AHEAD);
1404 eidmParams.insert(SUMO_ATTR_CF_EIDM_T_PERSISTENCE_DRIVE);
1405 eidmParams.insert(SUMO_ATTR_CF_EIDM_T_REACTION);
1406 eidmParams.insert(SUMO_ATTR_CF_EIDM_T_PERSISTENCE_ESTIMATE);
1407 eidmParams.insert(SUMO_ATTR_CF_EIDM_C_COOLNESS);
1408 eidmParams.insert(SUMO_ATTR_CF_EIDM_SIG_LEADER);
1409 eidmParams.insert(SUMO_ATTR_CF_EIDM_SIG_GAP);
1410 eidmParams.insert(SUMO_ATTR_CF_EIDM_SIG_ERROR);
1411 eidmParams.insert(SUMO_ATTR_CF_EIDM_JERK_MAX);
1412 eidmParams.insert(SUMO_ATTR_CF_EIDM_EPSILON_ACC);
1413 eidmParams.insert(SUMO_ATTR_CF_EIDM_T_ACC_MAX);
1414 eidmParams.insert(SUMO_ATTR_CF_EIDM_M_FLATNESS);
1415 eidmParams.insert(SUMO_ATTR_CF_EIDM_M_BEGIN);
1416 eidmParams.insert(SUMO_ATTR_CF_EIDM_USEVEHDYNAMICS);
1417 eidmParams.insert(SUMO_ATTR_CF_EIDM_MAX_VEH_PREVIEW);
1418 allowedCFModelAttrs[SUMO_TAG_CF_EIDM] = eidmParams;
1419 allParams.insert(eidmParams.begin(), eidmParams.end());
1420 // IDMM
1421 std::set<SumoXMLAttr> idmmParams(genericParams);
1422 idmmParams.insert(SUMO_ATTR_CF_IDMM_ADAPT_FACTOR);
1423 idmmParams.insert(SUMO_ATTR_CF_IDMM_ADAPT_TIME);
1424 idmmParams.insert(SUMO_ATTR_CF_IDM_STEPPING);
1425 allowedCFModelAttrs[SUMO_TAG_CF_IDMM] = idmmParams;
1426 allParams.insert(idmmParams.begin(), idmmParams.end());
1427 // Bieker
1428 std::set<SumoXMLAttr> bkernerParams(genericParams);
1429 bkernerParams.insert(SUMO_ATTR_K);
1430 bkernerParams.insert(SUMO_ATTR_CF_KERNER_PHI);
1431 allowedCFModelAttrs[SUMO_TAG_CF_BKERNER] = bkernerParams;
1432 allParams.insert(bkernerParams.begin(), bkernerParams.end());
1433 // Wiedemann
1434 std::set<SumoXMLAttr> wiedemannParams(genericParams);
1435 wiedemannParams.insert(SUMO_ATTR_CF_WIEDEMANN_SECURITY);
1436 wiedemannParams.insert(SUMO_ATTR_CF_WIEDEMANN_ESTIMATION);
1437 allowedCFModelAttrs[SUMO_TAG_CF_WIEDEMANN] = wiedemannParams;
1438 allParams.insert(wiedemannParams.begin(), wiedemannParams.end());
1439 // W99
1440 std::set<SumoXMLAttr> w99Params(genericParams);
1441 w99Params.insert(SUMO_ATTR_CF_W99_CC1);
1442 w99Params.insert(SUMO_ATTR_CF_W99_CC2);
1443 w99Params.insert(SUMO_ATTR_CF_W99_CC3);
1444 w99Params.insert(SUMO_ATTR_CF_W99_CC4);
1445 w99Params.insert(SUMO_ATTR_CF_W99_CC5);
1446 w99Params.insert(SUMO_ATTR_CF_W99_CC6);
1447 w99Params.insert(SUMO_ATTR_CF_W99_CC7);
1448 w99Params.insert(SUMO_ATTR_CF_W99_CC8);
1449 w99Params.insert(SUMO_ATTR_CF_W99_CC9);
1450 allowedCFModelAttrs[SUMO_TAG_CF_W99] = w99Params;
1451 allParams.insert(w99Params.begin(), w99Params.end());
1452 // Rail
1453 std::set<SumoXMLAttr> railParams(genericParams);
1454 railParams.insert(SUMO_ATTR_TRAIN_TYPE);
1455 railParams.insert(SUMO_ATTR_SPEED_TABLE);
1456 railParams.insert(SUMO_ATTR_TRACTION_TABLE);
1457 railParams.insert(SUMO_ATTR_RESISTANCE_TABLE);
1458 railParams.insert(SUMO_ATTR_MASSFACTOR);
1459 railParams.insert(SUMO_ATTR_MAXPOWER);
1460 railParams.insert(SUMO_ATTR_MAXTRACTION);
1461 railParams.insert(SUMO_ATTR_RESISTANCE_COEFFICIENT_CONSTANT);
1462 railParams.insert(SUMO_ATTR_RESISTANCE_COEFFICIENT_LINEAR);
1463 railParams.insert(SUMO_ATTR_RESISTANCE_COEFFICIENT_QUADRATIC);
1464 allowedCFModelAttrs[SUMO_TAG_CF_RAIL] = railParams;
1465 allParams.insert(railParams.begin(), railParams.end());
1466 // ACC
1467 std::set<SumoXMLAttr> ACCParams(genericParams);
1468 ACCParams.insert(SUMO_ATTR_SC_GAIN);
1469 ACCParams.insert(SUMO_ATTR_GCC_GAIN_SPEED);
1470 ACCParams.insert(SUMO_ATTR_GCC_GAIN_SPACE);
1471 ACCParams.insert(SUMO_ATTR_GC_GAIN_SPEED);
1472 ACCParams.insert(SUMO_ATTR_GC_GAIN_SPACE);
1473 ACCParams.insert(SUMO_ATTR_CA_GAIN_SPEED);
1474 ACCParams.insert(SUMO_ATTR_CA_GAIN_SPACE);
1475 ACCParams.insert(SUMO_ATTR_CA_OVERRIDE);
1476 ACCParams.insert(SUMO_ATTR_APPLYDRIVERSTATE);
1477 allowedCFModelAttrs[SUMO_TAG_CF_ACC] = ACCParams;
1478 allParams.insert(ACCParams.begin(), ACCParams.end());
1479 // CACC
1480 std::set<SumoXMLAttr> CACCParams(genericParams);
1481 CACCParams.insert(SUMO_ATTR_SC_GAIN_CACC);
1482 CACCParams.insert(SUMO_ATTR_GCC_GAIN_GAP_CACC);
1483 CACCParams.insert(SUMO_ATTR_GCC_GAIN_GAP_DOT_CACC);
1484 CACCParams.insert(SUMO_ATTR_GC_GAIN_GAP_CACC);
1485 CACCParams.insert(SUMO_ATTR_GC_GAIN_GAP_DOT_CACC);
1486 CACCParams.insert(SUMO_ATTR_CA_GAIN_GAP_CACC);
1487 CACCParams.insert(SUMO_ATTR_CA_GAIN_GAP_DOT_CACC);
1488 CACCParams.insert(SUMO_ATTR_GCC_GAIN_SPEED);
1489 CACCParams.insert(SUMO_ATTR_GCC_GAIN_SPACE);
1490 CACCParams.insert(SUMO_ATTR_GC_GAIN_SPEED);
1491 CACCParams.insert(SUMO_ATTR_GC_GAIN_SPACE);
1492 CACCParams.insert(SUMO_ATTR_CA_GAIN_SPEED);
1493 CACCParams.insert(SUMO_ATTR_CA_GAIN_SPACE);
1494 CACCParams.insert(SUMO_ATTR_CA_OVERRIDE);
1495 CACCParams.insert(SUMO_ATTR_HEADWAY_TIME_CACC_TO_ACC);
1496 CACCParams.insert(SUMO_ATTR_APPLYDRIVERSTATE);
1497 CACCParams.insert(SUMO_ATTR_SC_MIN_GAP);
1498 allowedCFModelAttrs[SUMO_TAG_CF_CACC] = CACCParams;
1499 allParams.insert(CACCParams.begin(), CACCParams.end());
1500 // CC
1501 std::set<SumoXMLAttr> ccParams(genericParams);
1502 ccParams.insert(SUMO_ATTR_CF_CC_C1);
1503 ccParams.insert(SUMO_ATTR_CF_CC_CCDECEL);
1504 ccParams.insert(SUMO_ATTR_CF_CC_CONSTSPACING);
1505 ccParams.insert(SUMO_ATTR_CF_CC_KP);
1506 ccParams.insert(SUMO_ATTR_CF_CC_LAMBDA);
1507 ccParams.insert(SUMO_ATTR_CF_CC_OMEGAN);
1508 ccParams.insert(SUMO_ATTR_CF_CC_TAU);
1509 ccParams.insert(SUMO_ATTR_CF_CC_XI);
1510 ccParams.insert(SUMO_ATTR_CF_CC_LANES_COUNT);
1511 ccParams.insert(SUMO_ATTR_CF_CC_CCACCEL);
1512 ccParams.insert(SUMO_ATTR_CF_CC_PLOEG_KP);
1513 ccParams.insert(SUMO_ATTR_CF_CC_PLOEG_KD);
1514 ccParams.insert(SUMO_ATTR_CF_CC_PLOEG_H);
1515 ccParams.insert(SUMO_ATTR_CF_CC_FLATBED_KA);
1516 ccParams.insert(SUMO_ATTR_CF_CC_FLATBED_KV);
1517 ccParams.insert(SUMO_ATTR_CF_CC_FLATBED_KP);
1518 ccParams.insert(SUMO_ATTR_CF_CC_FLATBED_D);
1519 ccParams.insert(SUMO_ATTR_CF_CC_FLATBED_H);
1520 allowedCFModelAttrs[SUMO_TAG_CF_CC] = ccParams;
1521 allParams.insert(ccParams.begin(), ccParams.end());
1522 // last element
1523 allowedCFModelAttrs[SUMO_TAG_NOTHING] = allParams;
1524 }
1525 return allowedCFModelAttrs;
1526}
1527
1528
1529bool
1530SUMOVehicleParserHelper::parseLCParams(SUMOVTypeParameter* into, LaneChangeModel model, const SUMOSAXAttributes& attrs) {
1531 if (allowedLCModelAttrs.size() == 0) {
1532 // lc2013
1533 std::set<SumoXMLAttr> lc2013Params;
1534 lc2013Params.insert(SUMO_ATTR_LCA_STRATEGIC_PARAM);
1535 lc2013Params.insert(SUMO_ATTR_LCA_COOPERATIVE_PARAM);
1536 lc2013Params.insert(SUMO_ATTR_LCA_SPEEDGAIN_PARAM);
1537 lc2013Params.insert(SUMO_ATTR_LCA_KEEPRIGHT_PARAM);
1538 lc2013Params.insert(SUMO_ATTR_LCA_OPPOSITE_PARAM);
1539 lc2013Params.insert(SUMO_ATTR_LCA_LOOKAHEADLEFT);
1540 lc2013Params.insert(SUMO_ATTR_LCA_SPEEDGAINRIGHT);
1541 lc2013Params.insert(SUMO_ATTR_LCA_MAXSPEEDLATSTANDING);
1542 lc2013Params.insert(SUMO_ATTR_LCA_MAXSPEEDLATFACTOR);
1543 lc2013Params.insert(SUMO_ATTR_LCA_MAXDISTLATSTANDING);
1544 lc2013Params.insert(SUMO_ATTR_LCA_ASSERTIVE);
1545 lc2013Params.insert(SUMO_ATTR_LCA_STRATEGIC_LOOKAHEAD);
1546 lc2013Params.insert(SUMO_ATTR_LCA_SPEEDGAIN_LOOKAHEAD);
1547 lc2013Params.insert(SUMO_ATTR_LCA_SPEEDGAIN_REMAIN_TIME);
1548 lc2013Params.insert(SUMO_ATTR_LCA_COOPERATIVE_ROUNDABOUT);
1549 lc2013Params.insert(SUMO_ATTR_LCA_COOPERATIVE_SPEED);
1550 lc2013Params.insert(SUMO_ATTR_LCA_OVERTAKE_RIGHT);
1551 lc2013Params.insert(SUMO_ATTR_LCA_SIGMA);
1552 lc2013Params.insert(SUMO_ATTR_LCA_KEEPRIGHT_ACCEPTANCE_TIME);
1553 lc2013Params.insert(SUMO_ATTR_LCA_OVERTAKE_DELTASPEED_FACTOR);
1554 lc2013Params.insert(SUMO_ATTR_LCA_CONTRIGHT);
1555 lc2013Params.insert(SUMO_ATTR_LCA_EXPERIMENTAL1);
1556 allowedLCModelAttrs[LaneChangeModel::LC2013] = lc2013Params;
1557 // sl2015 (extension of lc2013)
1558 std::set<SumoXMLAttr> sl2015Params = lc2013Params;
1559 sl2015Params.insert(SUMO_ATTR_LCA_PUSHY);
1560 sl2015Params.insert(SUMO_ATTR_LCA_PUSHYGAP);
1561 sl2015Params.insert(SUMO_ATTR_LCA_SUBLANE_PARAM);
1562 sl2015Params.insert(SUMO_ATTR_LCA_IMPATIENCE);
1563 sl2015Params.insert(SUMO_ATTR_LCA_TIME_TO_IMPATIENCE);
1564 sl2015Params.insert(SUMO_ATTR_LCA_ACCEL_LAT);
1565 sl2015Params.insert(SUMO_ATTR_LCA_TURN_ALIGNMENT_DISTANCE);
1566 sl2015Params.insert(SUMO_ATTR_LCA_LANE_DISCIPLINE);
1567 allowedLCModelAttrs[LaneChangeModel::SL2015] = sl2015Params;
1568 // DK2008
1569 std::set<SumoXMLAttr> noParams;
1570 allowedLCModelAttrs[LaneChangeModel::DK2008] = noParams;
1571 // default model may be either LC2013 or SL2015
1572 // we allow both sets (sl2015 is a superset of lc2013Params)
1573 allowedLCModelAttrs[LaneChangeModel::DEFAULT] = sl2015Params;
1574 }
1575 std::set<SumoXMLAttr> allowed = allowedLCModelAttrs[model];
1576 // iterate over LCM attributes
1577 for (const auto& it : allowed) {
1578 if (attrs.hasAttribute(it)) {
1579 // first obtain CFM attribute in string format
1580 bool ok = true;
1581 std::string parsedLCMAttribute = attrs.get<std::string>(it, into->id.c_str(), ok);
1582 if (!ok) {
1583 return false;
1584 }
1585 // declare a double in wich save CFM attribute
1586 double LCMAttribute = -1;
1587 try {
1588 // obtain CFM attribute in double format
1589 LCMAttribute = StringUtils::toDouble(parsedLCMAttribute);
1590 } catch (...) {
1591 WRITE_ERRORF(TL("Invalid Lane-Change-Model Attribute %. Cannot be parsed to float"), toString(it));
1592 return false;
1593 }
1594 // check attributes of type "nonNegativeFloatType" (>= 0)
1595 switch (it) {
1596 case SUMO_ATTR_LCA_PUSHYGAP:
1597 case SUMO_ATTR_LCA_MAXSPEEDLATSTANDING:
1598 case SUMO_ATTR_LCA_IMPATIENCE:
1599 case SUMO_ATTR_LCA_OVERTAKE_RIGHT:
1600 case SUMO_ATTR_LCA_ASSERTIVE:
1601 case SUMO_ATTR_LCA_LOOKAHEADLEFT:
1602 case SUMO_ATTR_LCA_SPEEDGAINRIGHT:
1603 case SUMO_ATTR_LCA_TURN_ALIGNMENT_DISTANCE:
1604 case SUMO_ATTR_LCA_TIME_TO_IMPATIENCE:
1605 case SUMO_ATTR_LCA_LANE_DISCIPLINE:
1606 case SUMO_ATTR_LCA_SIGMA:
1607 if (LCMAttribute < 0) {
1608 WRITE_ERRORF(TL("Invalid Lane-Change-Model Attribute %. Must be equal or greater than 0"), toString(it));
1609 return false;
1610 }
1611 break;
1612 default:
1613 break;
1614 }
1615 // check attributes of type "positiveFloatType" (> 0)
1616 switch (it) {
1617 case SUMO_ATTR_LCA_ACCEL_LAT:
1618 if (LCMAttribute <= 0) {
1619 WRITE_ERRORF(TL("Invalid Lane-Change-Model Attribute %. Must be greater than 0"), toString(it));
1620 return false;
1621 }
1622 break;
1623 default:
1624 break;
1625 }
1626 // check limits of attributes
1627 switch (it) {
1628 case SUMO_ATTR_LCA_OVERTAKE_DELTASPEED_FACTOR:
1629 if (LCMAttribute < -1 || LCMAttribute > 1) {
1630 WRITE_ERRORF(TL("Invalid Lane-Change-Model Attribute %. Must be between -1 and 1"), toString(it));
1631 return false;
1632 }
1633 break;
1634 default:
1635 break;
1636 }
1637 // add parsedLCMAttribute to cfParameter
1638 into->lcParameter[it] = parsedLCMAttribute;
1639 }
1640 }
1641 // all LCM parsed ok, then return true
1642 return true;
1643}
1644
1645
1646bool
1647SUMOVehicleParserHelper::parseJMParams(SUMOVTypeParameter* into, const SUMOSAXAttributes& attrs) {
1648 for (const auto& it : SUMOVTypeParameter::AllowedJMAttrs) {
1649 if (attrs.hasAttribute(it)) {
1650 // first obtain CFM attribute in string format
1651 bool ok = true;
1652 std::string parsedJMAttribute = attrs.get<std::string>(it, into->id.c_str(), ok);
1653 if (!ok) {
1654 return false;
1655 }
1656 // declare a double in wich save CFM attribute
1657 double JMAttribute = -1;
1658 try {
1659 // obtain CFM attribute in double format
1660 JMAttribute = StringUtils::toDouble(parsedJMAttribute);
1661 } catch (...) {
1662 WRITE_ERRORF(TL("Invalid Junction-Model Attribute %. Cannot be parsed to float"), toString(it));
1663 return false;
1664 }
1665 // now continue checking other properties (-1 is the default value)
1666 if (JMAttribute != -1) {
1667 // special case for sigma minor
1668 if (it == SUMO_ATTR_JM_SIGMA_MINOR) {
1669 // check attributes sigma minor
1670 if ((JMAttribute < 0) || (JMAttribute > 1)) {
1671 WRITE_ERRORF(TL("Invalid Junction-Model Attribute %. Only values between [0-1] are allowed"), toString(it));
1672 return false;
1673 }
1674 } else {
1675 // check attributes of type "nonNegativeFloatType" (>= 0)
1676 if (JMAttribute < 0) {
1677 WRITE_ERRORF(TL("Invalid Junction-Model Attribute %. Must be equal or greater than 0"), toString(it));
1678 return false;
1679 }
1680 }
1681 // add parsedJMAttribute to cfParameter
1682 into->jmParameter[it] = parsedJMAttribute;
1683 }
1684 }
1685 }
1686 // all JM parameters successfully parsed, then return true
1687 return true;
1688}
1689
1690
1691SUMOVehicleClass
1692SUMOVehicleParserHelper::parseVehicleClass(const SUMOSAXAttributes& attrs, const std::string& id) {
1693 SUMOVehicleClass vclass = SVC_IGNORING;
1694 bool ok = true;
1695 std::string vclassS = attrs.getOpt<std::string>(SUMO_ATTR_VCLASS, id.c_str(), ok, "");
1696 if (vclassS == "") {
1697 return vclass;
1698 }
1699 try {
1700 const SUMOVehicleClass result = getVehicleClassID(vclassS);
1701 const std::string& realName = SumoVehicleClassStrings.getString(result);
1702 if (realName != vclassS) {
1703 WRITE_WARNING("The vehicle class '" + vclassS + "' for " + attrs.getObjectType() + " '" + id + "' is deprecated, use '" + realName + "' instead.");
1704 }
1705 return result;
1706 } catch (...) {
1707 WRITE_ERRORF(TL("The vehicle class '%' for % '%' is not known."), vclassS, attrs.getObjectType(), id);
1708 }
1709 return vclass;
1710}
1711
1712
1713SUMOVehicleShape
1714SUMOVehicleParserHelper::parseGuiShape(const SUMOSAXAttributes& attrs, const std::string& id) {
1715 bool ok = true;
1716 std::string vclassS = attrs.getOpt<std::string>(SUMO_ATTR_GUISHAPE, id.c_str(), ok, "");
1717 if (SumoVehicleShapeStrings.hasString(vclassS)) {
1718 const SUMOVehicleShape result = SumoVehicleShapeStrings.get(vclassS);
1719 const std::string& realName = SumoVehicleShapeStrings.getString(result);
1720 if (realName != vclassS) {
1721 WRITE_WARNING("The shape '" + vclassS + "' for " + attrs.getObjectType() + " '" + id + "' is deprecated, use '" + realName + "' instead.");
1722 }
1723 return result;
1724 } else {
1725 WRITE_ERRORF(TL("The shape '%' for % '%' is not known."), vclassS, attrs.getObjectType(), id);
1726 return SUMOVehicleShape::UNKNOWN;
1727 }
1728}
1729
1730
1731double
1732SUMOVehicleParserHelper::parseWalkPos(SumoXMLAttr attr, const bool hardFail, const std::string& id, double maxPos, const std::string& val, SumoRNG* rng) {
1733 double result;
1734 std::string error;
1735 ArrivalPosDefinition proc = ArrivalPosDefinition::DEFAULT;
1736 // only supports 'random' and 'max'
1737 if (!SUMOVehicleParameter::parseArrivalPos(val, toString(SUMO_TAG_WALK), id, result, proc, error)) {
1738 handleVehicleError(hardFail, nullptr, error);
1739 }
1740 if (proc == ArrivalPosDefinition::RANDOM) {
1741 result = RandHelper::rand(maxPos, rng);
1742 } else if (proc == ArrivalPosDefinition::CENTER) {
1743 result = maxPos / 2.;
1744 } else if (proc == ArrivalPosDefinition::MAX) {
1745 result = maxPos;
1746 }
1747 return SUMOVehicleParameter::interpretEdgePos(result, maxPos, attr, id);
1748}
1749
1750
1751SUMOTime
1752SUMOVehicleParserHelper::processActionStepLength(double given) {
1753 const std::string defaultError = "The parameter action-step-length must be a non-negative multiple of the simulation step-length. ";
1754 SUMOTime result = TIME2STEPS(given);
1755 if (result <= 0) {
1756 if (result < 0) {
1757 WRITE_WARNING(defaultError + "Ignoring given value (=" + toString(STEPS2TIME(result)) + " s.)");
1758 }
1759 result = DELTA_T;
1760 } else if (result % DELTA_T != 0) {
1761 result = (SUMOTime)((double)DELTA_T * floor(double(result) / double(DELTA_T)));
1762 result = MAX2(DELTA_T, result);
1763 if (fabs(given * 1000. - double(result)) > NUMERICAL_EPS) {
1764 WRITE_WARNING(defaultError + "Parsing given value (" + toString(given) + " s.) to the adjusted value " + toString(STEPS2TIME(result)) + " s.");
1765 }
1766 }
1767 return result;
1768}
1769
1770
1771bool
1772SUMOVehicleParserHelper::isInternalRouteID(const std::string& id) {
1773 return id.substr(0, 1) == "!";
1774}
1775
1776
1777int
1778SUMOVehicleParserHelper::parseCarWalkTransfer(const OptionsCont& oc, const bool hasTaxi) {
1779 int carWalk = 0;
1780 for (const std::string& opt : oc.getStringVector("persontrip.transfer.car-walk")) {
1781 if (opt == "parkingAreas") {
1782 carWalk |= ModeChangeOptions::PARKING_AREAS;
1783 } else if (opt == "ptStops") {
1784 carWalk |= ModeChangeOptions::PT_STOPS;
1785 } else if (opt == "allJunctions") {
1786 carWalk |= ModeChangeOptions::ALL_JUNCTIONS;
1787 } else {
1788 WRITE_ERRORF(TL("Invalid transfer option '%'. Must be one of 'parkingAreas', 'ptStops' and 'allJunctions'"), opt);
1789 }
1790 }
1791 const StringVector taxiDropoff = oc.getStringVector("persontrip.transfer.taxi-walk");
1792 const StringVector taxiPickup = oc.getStringVector("persontrip.transfer.walk-taxi");
1793 if (taxiDropoff.empty() && hasTaxi) {
1794 carWalk |= ModeChangeOptions::TAXI_DROPOFF_ANYWHERE;
1795 } else {
1796 for (const std::string& opt : taxiDropoff) {
1797 if (opt == "parkingAreas") {
1798 carWalk |= ModeChangeOptions::TAXI_DROPOFF_PARKING_AREAS;
1799 } else if (opt == "ptStops") {
1800 carWalk |= ModeChangeOptions::TAXI_DROPOFF_PT;
1801 } else if (opt == "allJunctions") {
1802 carWalk |= ModeChangeOptions::TAXI_DROPOFF_ANYWHERE;
1803 } else {
1804 WRITE_ERRORF(TL("Invalid transfer option '%'. Must be one of 'parkingAreas', 'ptStops' and 'allJunctions'"), opt);
1805 }
1806 }
1807 }
1808 if (taxiPickup.empty() && hasTaxi) {
1809 carWalk |= ModeChangeOptions::TAXI_PICKUP_ANYWHERE;
1810 } else {
1811 for (const std::string& opt : taxiPickup) {
1812 if (opt == "parkingAreas") {
1813 carWalk |= ModeChangeOptions::TAXI_PICKUP_PARKING_AREAS;
1814 } else if (opt == "ptStops") {
1815 carWalk |= ModeChangeOptions::TAXI_PICKUP_PT;
1816 } else if (opt == "allJunctions") {
1817 carWalk |= ModeChangeOptions::TAXI_PICKUP_ANYWHERE;
1818 } else {
1819 WRITE_ERRORF(TL("Invalid transfer option '%'. Must be one of 'parkingAreas', 'ptStops' and 'allJunctions'"), opt);
1820 }
1821 }
1822 }
1823 return carWalk;
1824}
1825
1826
1827SUMOVehicleParameter*
1828SUMOVehicleParserHelper::handleVehicleError(const bool hardFail, SUMOVehicleParameter* vehicleParameter, const std::string message) {
1829 if (vehicleParameter) {
1830 delete vehicleParameter;
1831 }
1832 if (hardFail) {
1833 throw ProcessError(message);
1834 } else if (message.size() > 0) {
1835 WRITE_ERROR(message);
1836 }
1837 return nullptr;
1838}
1839
1840
1841SUMOVTypeParameter*
1842SUMOVehicleParserHelper::handleVehicleTypeError(const bool hardFail, SUMOVTypeParameter* vehicleTypeParameter, const std::string message) {
1843 if (vehicleTypeParameter) {
1844 delete vehicleTypeParameter;
1845 }
1846 if (hardFail) {
1847 throw ProcessError(message);
1848 } else if (message.size() > 0) {
1849 WRITE_ERROR(message);
1850 }
1851 return nullptr;
1852}
1853
1854/****************************************************************************/
SUMOTime
long long int SUMOTime
Definition GUI.h:36
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
SumoVehicleShapeStrings
StringBijection< SUMOVehicleShape > SumoVehicleShapeStrings(sumoVehicleShapeStringInitializer, SUMOVehicleShape::UNKNOWN, false)
getVehicleClassID
SUMOVehicleClass getVehicleClassID(const std::string &name)
Returns the class id of the abstract class given by its name.
Definition SUMOVehicleClass.cpp:324
SumoVehicleClassStrings
StringBijection< SUMOVehicleClass > SumoVehicleClassStrings(sumoVehicleClassStringInitializer, SVC_CUSTOM2, 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_ARRIVALSPEED_SET
const long long int VEHPARS_ARRIVALSPEED_SET
Definition SUMOVehicleParameter.h:57
VEHPARS_DEPARTPOSLAT_SET
const long long int VEHPARS_DEPARTPOSLAT_SET
Definition SUMOVehicleParameter.h:65
VEHPARS_ARRIVALPOSLAT_SET
const long long int VEHPARS_ARRIVALPOSLAT_SET
Definition SUMOVehicleParameter.h:66
VEHPARS_PERSON_NUMBER_SET
const long long int VEHPARS_PERSON_NUMBER_SET
Definition SUMOVehicleParameter.h:63
VEHPARS_DEPARTSPEED_SET
const long long int VEHPARS_DEPARTSPEED_SET
Definition SUMOVehicleParameter.h:47
RouteIndexDefinition
RouteIndexDefinition
Possible ways to choose the departure and arrival edge.
Definition SUMOVehicleParameter.h:242
VEHPARS_FORCE_REROUTE
const long long int VEHPARS_FORCE_REROUTE
Definition SUMOVehicleParameter.h:61
DepartLaneDefinition
DepartLaneDefinition
Possible ways to choose a lane on depart.
Definition SUMOVehicleParameter.h:136
VEHPARS_END_SET
const long long int VEHPARS_END_SET
Definition SUMOVehicleParameter.h:48
ArrivalSpeedDefinition
ArrivalSpeedDefinition
Possible ways to choose the arrival speed.
Definition SUMOVehicleParameter.h:310
VEHPARS_PERIOD_SET
const long long int VEHPARS_PERIOD_SET
Definition SUMOVehicleParameter.h:50
DepartPosLatDefinition
DepartPosLatDefinition
Possible ways to choose the lateral departure position.
Definition SUMOVehicleParameter.h:190
DepartPosDefinition
DepartPosDefinition
Possible ways to choose the departure position.
Definition SUMOVehicleParameter.h:160
VEHPARS_ROUTE_SET
const long long int VEHPARS_ROUTE_SET
Definition SUMOVehicleParameter.h:54
ArrivalLaneDefinition
ArrivalLaneDefinition
Possible ways to choose the arrival lane.
Definition SUMOVehicleParameter.h:256
VEHPARS_COLOR_SET
const long long int VEHPARS_COLOR_SET
Definition SUMOVehicleParameter.h:43
DepartSpeedDefinition
DepartSpeedDefinition
Possible ways to choose the departure speed.
Definition SUMOVehicleParameter.h:216
VEHPARS_TO_TAZ_SET
const long long int VEHPARS_TO_TAZ_SET
Definition SUMOVehicleParameter.h:60
VEHPARS_ARRIVALLANE_SET
const long long int VEHPARS_ARRIVALLANE_SET
Definition SUMOVehicleParameter.h:55
VEHPARS_DEPARTLANE_SET
const long long int VEHPARS_DEPARTLANE_SET
Definition SUMOVehicleParameter.h:45
VEHPARS_DEPARTPOS_SET
const long long int VEHPARS_DEPARTPOS_SET
Definition SUMOVehicleParameter.h:46
VEHPARS_ARRIVALPOS_SET
const long long int VEHPARS_ARRIVALPOS_SET
Definition SUMOVehicleParameter.h:56
VEHPARS_ARRIVALEDGE_SET
const long long int VEHPARS_ARRIVALEDGE_SET
Definition SUMOVehicleParameter.h:70
VEHPARS_CONTAINER_NUMBER_SET
const long long int VEHPARS_CONTAINER_NUMBER_SET
Definition SUMOVehicleParameter.h:64
VEHPARS_FROM_TAZ_SET
const long long int VEHPARS_FROM_TAZ_SET
Definition SUMOVehicleParameter.h:59
VEHPARS_PARKING_BADGES_SET
const long long int VEHPARS_PARKING_BADGES_SET
Definition SUMOVehicleParameter.h:74
VEHPARS_PROB_SET
const long long int VEHPARS_PROB_SET
Definition SUMOVehicleParameter.h:52
VEHPARS_SPEEDFACTOR_SET
const long long int VEHPARS_SPEEDFACTOR_SET
Definition SUMOVehicleParameter.h:68
VEHPARS_VTYPE_SET
const long long int VEHPARS_VTYPE_SET
Definition SUMOVehicleParameter.h:44
VEHPARS_VPH_SET
const long long int VEHPARS_VPH_SET
Definition SUMOVehicleParameter.h:51
ArrivalPosDefinition
ArrivalPosDefinition
Possible ways to choose the arrival position.
Definition SUMOVehicleParameter.h:274
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_CALIBRATORSPEED_SET
const long long int VEHPARS_CALIBRATORSPEED_SET
Definition SUMOVehicleParameter.h:71
ArrivalPosLatDefinition
ArrivalPosLatDefinition
Possible ways to choose the lateral arrival position.
Definition SUMOVehicleParameter.h:292
VEHPARS_LINE_SET
const long long int VEHPARS_LINE_SET
Definition SUMOVehicleParameter.h:58
VEHPARS_DEPARTEDGE_SET
const long long int VEHPARS_DEPARTEDGE_SET
Definition SUMOVehicleParameter.h:69
VEHPARS_INSERTION_CHECKS_SET
const long long int VEHPARS_INSERTION_CHECKS_SET
Definition SUMOVehicleParameter.h:75
VEHPARS_NUMBER_SET
const long long int VEHPARS_NUMBER_SET
Definition SUMOVehicleParameter.h:49
DepartDefinition::TRIGGERED
@ TRIGGERED
The departure is person triggered.
SumoXMLTag
SumoXMLTag
Numbers representing SUMO-XML - element names.
Definition SUMOXMLDefinitions.h:41
SUMO_TAG_CF_KRAUSS
@ SUMO_TAG_CF_KRAUSS
Definition SUMOXMLDefinitions.h:339
SUMO_TAG_CF_BKERNER
@ SUMO_TAG_CF_BKERNER
Definition SUMOXMLDefinitions.h:349
SUMO_TAG_CF_KRAUSSX
@ SUMO_TAG_CF_KRAUSSX
Definition SUMOXMLDefinitions.h:342
SUMO_TAG_CF_CACC
@ SUMO_TAG_CF_CACC
Definition SUMOXMLDefinitions.h:353
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:363
SUMO_TAG_NOTHING
@ SUMO_TAG_NOTHING
invalid tag, must be the last one
Definition SUMOXMLDefinitions.h:802
SUMO_TAG_CF_CC
@ SUMO_TAG_CF_CC
Definition SUMOXMLDefinitions.h:355
SUMO_TAG_CONTAINERFLOW
@ SUMO_TAG_CONTAINERFLOW
Definition SUMOXMLDefinitions.h:378
SUMO_TAG_CF_KRAUSS_PLUS_SLOPE
@ SUMO_TAG_CF_KRAUSS_PLUS_SLOPE
Definition SUMOXMLDefinitions.h:340
SUMO_TAG_CF_IDM
@ SUMO_TAG_CF_IDM
Definition SUMOXMLDefinitions.h:346
SUMO_TAG_CF_W99
@ SUMO_TAG_CF_W99
Definition SUMOXMLDefinitions.h:351
SUMO_TAG_CF_RAIL
@ SUMO_TAG_CF_RAIL
Definition SUMOXMLDefinitions.h:354
SUMO_TAG_CF_SMART_SK
@ SUMO_TAG_CF_SMART_SK
Definition SUMOXMLDefinitions.h:344
SUMO_TAG_CF_EIDM
@ SUMO_TAG_CF_EIDM
Definition SUMOXMLDefinitions.h:343
SUMO_TAG_CF_PWAGNER2009
@ SUMO_TAG_CF_PWAGNER2009
Definition SUMOXMLDefinitions.h:348
SUMO_TAG_CF_KRAUSS_ORIG1
@ SUMO_TAG_CF_KRAUSS_ORIG1
Definition SUMOXMLDefinitions.h:341
SUMO_TAG_CF_WIEDEMANN
@ SUMO_TAG_CF_WIEDEMANN
Definition SUMOXMLDefinitions.h:350
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:375
SUMO_TAG_PERSON
@ SUMO_TAG_PERSON
Definition SUMOXMLDefinitions.h:360
SUMO_TAG_CF_IDMM
@ SUMO_TAG_CF_IDMM
Definition SUMOXMLDefinitions.h:347
SUMO_TAG_CF_DANIEL1
@ SUMO_TAG_CF_DANIEL1
Definition SUMOXMLDefinitions.h:345
SUMO_TAG_PERSONFLOW
@ SUMO_TAG_PERSONFLOW
Definition SUMOXMLDefinitions.h:364
SUMO_TAG_CF_ACC
@ SUMO_TAG_CF_ACC
Definition SUMOXMLDefinitions.h:352
SumoXMLAttr
SumoXMLAttr
Numbers representing SUMO-XML - attributes.
Definition SUMOXMLDefinitions.h:813
SUMO_ATTR_TMP4
@ SUMO_ATTR_TMP4
Definition SUMOXMLDefinitions.h:1214
SUMO_ATTR_CF_W99_CC9
@ SUMO_ATTR_CF_W99_CC9
Definition SUMOXMLDefinitions.h:1627
SUMO_ATTR_GCC_GAIN_GAP_DOT_CACC
@ SUMO_ATTR_GCC_GAIN_GAP_DOT_CACC
Definition SUMOXMLDefinitions.h:1250
SUMO_ATTR_CF_EIDM_T_ACC_MAX
@ SUMO_ATTR_CF_EIDM_T_ACC_MAX
Definition SUMOXMLDefinitions.h:1228
SUMO_ATTR_STARTUP_DELAY
@ SUMO_ATTR_STARTUP_DELAY
Definition SUMOXMLDefinitions.h:1209
SUMO_ATTR_RESISTANCE_COEFFICIENT_CONSTANT
@ SUMO_ATTR_RESISTANCE_COEFFICIENT_CONSTANT
Definition SUMOXMLDefinitions.h:1270
SUMO_ATTR_CF_EIDM_EPSILON_ACC
@ SUMO_ATTR_CF_EIDM_EPSILON_ACC
Definition SUMOXMLDefinitions.h:1227
SUMO_ATTR_CF_W99_CC5
@ SUMO_ATTR_CF_W99_CC5
Definition SUMOXMLDefinitions.h:1623
SUMO_ATTR_LCA_PUSHY
@ SUMO_ATTR_LCA_PUSHY
Definition SUMOXMLDefinitions.h:1280
SUMO_ATTR_CF_CC_FLATBED_KP
@ SUMO_ATTR_CF_CC_FLATBED_KP
Definition SUMOXMLDefinitions.h:1644
SUMO_ATTR_NUMBER
@ SUMO_ATTR_NUMBER
Definition SUMOXMLDefinitions.h:1383
SUMO_ATTR_ARRIVALSPEED
@ SUMO_ATTR_ARRIVALSPEED
Definition SUMOXMLDefinitions.h:971
SUMO_ATTR_GCC_GAIN_SPEED
@ SUMO_ATTR_GCC_GAIN_SPEED
Definition SUMOXMLDefinitions.h:1237
SUMO_ATTR_EMISSIONCLASS
@ SUMO_ATTR_EMISSIONCLASS
Definition SUMOXMLDefinitions.h:1565
SUMO_ATTR_ARRIVALLANE
@ SUMO_ATTR_ARRIVALLANE
Definition SUMOXMLDefinitions.h:968
SUMO_ATTR_DEPART
@ SUMO_ATTR_DEPART
Definition SUMOXMLDefinitions.h:962
SUMO_ATTR_CF_CC_LAMBDA
@ SUMO_ATTR_CF_CC_LAMBDA
Definition SUMOXMLDefinitions.h:1632
SUMO_ATTR_DEPARTEDGE
@ SUMO_ATTR_DEPARTEDGE
Definition SUMOXMLDefinitions.h:967
SUMO_ATTR_CF_CC_FLATBED_D
@ SUMO_ATTR_CF_CC_FLATBED_D
Definition SUMOXMLDefinitions.h:1645
SUMO_ATTR_VEHSPERHOUR
@ SUMO_ATTR_VEHSPERHOUR
Definition SUMOXMLDefinitions.h:1554
SUMO_ATTR_ARRIVALEDGE
@ SUMO_ATTR_ARRIVALEDGE
Definition SUMOXMLDefinitions.h:972
SUMO_ATTR_SPEED
@ SUMO_ATTR_SPEED
Definition SUMOXMLDefinitions.h:825
SUMO_ATTR_LCA_COOPERATIVE_SPEED
@ SUMO_ATTR_LCA_COOPERATIVE_SPEED
Definition SUMOXMLDefinitions.h:1292
SUMO_ATTR_RESISTANCE_TABLE
@ SUMO_ATTR_RESISTANCE_TABLE
Definition SUMOXMLDefinitions.h:1266
SUMO_ATTR_CF_EIDM_T_LOOK_AHEAD
@ SUMO_ATTR_CF_EIDM_T_LOOK_AHEAD
Definition SUMOXMLDefinitions.h:1218
SUMO_ATTR_CF_CC_FLATBED_KA
@ SUMO_ATTR_CF_CC_FLATBED_KA
Definition SUMOXMLDefinitions.h:1642
SUMO_ATTR_CF_CC_PLOEG_KP
@ SUMO_ATTR_CF_CC_PLOEG_KP
Definition SUMOXMLDefinitions.h:1639
SUMO_ATTR_CF_WIEDEMANN_SECURITY
@ SUMO_ATTR_CF_WIEDEMANN_SECURITY
Definition SUMOXMLDefinitions.h:1617
SUMO_ATTR_LCA_ASSERTIVE
@ SUMO_ATTR_LCA_ASSERTIVE
Definition SUMOXMLDefinitions.h:1283
SUMO_ATTR_LCA_LANE_DISCIPLINE
@ SUMO_ATTR_LCA_LANE_DISCIPLINE
Definition SUMOXMLDefinitions.h:1298
SUMO_ATTR_TRAIN_TYPE
@ SUMO_ATTR_TRAIN_TYPE
Definition SUMOXMLDefinitions.h:1263
SUMO_ATTR_CF_EIDM_USEVEHDYNAMICS
@ SUMO_ATTR_CF_EIDM_USEVEHDYNAMICS
Definition SUMOXMLDefinitions.h:1217
SUMO_ATTR_CF_IDMM_ADAPT_TIME
@ SUMO_ATTR_CF_IDMM_ADAPT_TIME
Definition SUMOXMLDefinitions.h:1615
SUMO_ATTR_LANE_CHANGE_MODEL
@ SUMO_ATTR_LANE_CHANGE_MODEL
Definition SUMOXMLDefinitions.h:989
SUMO_ATTR_CF_KERNER_PHI
@ SUMO_ATTR_CF_KERNER_PHI
Definition SUMOXMLDefinitions.h:1616
SUMO_ATTR_LCA_TURN_ALIGNMENT_DISTANCE
@ SUMO_ATTR_LCA_TURN_ALIGNMENT_DISTANCE
Definition SUMOXMLDefinitions.h:1296
SUMO_ATTR_GC_GAIN_SPACE
@ SUMO_ATTR_GC_GAIN_SPACE
Definition SUMOXMLDefinitions.h:1240
SUMO_ATTR_SCALE
@ SUMO_ATTR_SCALE
Definition SUMOXMLDefinitions.h:996
SUMO_ATTR_DEPARTPOS_LAT
@ SUMO_ATTR_DEPARTPOS_LAT
Definition SUMOXMLDefinitions.h:965
SUMO_ATTR_PARKING_BADGES
@ SUMO_ATTR_PARKING_BADGES
Definition SUMOXMLDefinitions.h:1003
SUMO_ATTR_CF_EIDM_C_COOLNESS
@ SUMO_ATTR_CF_EIDM_C_COOLNESS
Definition SUMOXMLDefinitions.h:1222
SUMO_ATTR_CF_EIDM_SIG_ERROR
@ SUMO_ATTR_CF_EIDM_SIG_ERROR
Definition SUMOXMLDefinitions.h:1225
SUMO_ATTR_LCA_PUSHYGAP
@ SUMO_ATTR_LCA_PUSHYGAP
Definition SUMOXMLDefinitions.h:1281
SUMO_ATTR_CA_GAIN_GAP_CACC
@ SUMO_ATTR_CA_GAIN_GAP_CACC
Definition SUMOXMLDefinitions.h:1253
SUMO_ATTR_LCA_LOOKAHEADLEFT
@ SUMO_ATTR_LCA_LOOKAHEADLEFT
Definition SUMOXMLDefinitions.h:1287
SUMO_ATTR_APPARENTDECEL
@ SUMO_ATTR_APPARENTDECEL
Definition SUMOXMLDefinitions.h:981
SUMO_ATTR_MAXSPEED_LAT
@ SUMO_ATTR_MAXSPEED_LAT
Definition SUMOXMLDefinitions.h:975
SUMO_ATTR_GC_GAIN_GAP_DOT_CACC
@ SUMO_ATTR_GC_GAIN_GAP_DOT_CACC
Definition SUMOXMLDefinitions.h:1252
SUMO_ATTR_LCA_SPEEDGAIN_PARAM
@ SUMO_ATTR_LCA_SPEEDGAIN_PARAM
Definition SUMOXMLDefinitions.h:1276
SUMO_ATTR_ARRIVALPOS
@ SUMO_ATTR_ARRIVALPOS
Definition SUMOXMLDefinitions.h:969
SUMO_ATTR_TMP3
@ SUMO_ATTR_TMP3
Definition SUMOXMLDefinitions.h:1213
SUMO_ATTR_MASSFACTOR
@ SUMO_ATTR_MASSFACTOR
Definition SUMOXMLDefinitions.h:1267
SUMO_ATTR_ACTIONSTEPLENGTH
@ SUMO_ATTR_ACTIONSTEPLENGTH
Definition SUMOXMLDefinitions.h:982
SUMO_ATTR_CF_CC_PLOEG_H
@ SUMO_ATTR_CF_CC_PLOEG_H
Definition SUMOXMLDefinitions.h:1641
SUMO_ATTR_LCA_MAXDISTLATSTANDING
@ SUMO_ATTR_LCA_MAXDISTLATSTANDING
Definition SUMOXMLDefinitions.h:1295
SUMO_ATTR_LCA_IMPATIENCE
@ SUMO_ATTR_LCA_IMPATIENCE
Definition SUMOXMLDefinitions.h:1284
SUMO_ATTR_BEGIN
@ SUMO_ATTR_BEGIN
weights: time range begin
Definition SUMOXMLDefinitions.h:1398
SUMO_ATTR_MINGAP
@ SUMO_ATTR_MINGAP
Definition SUMOXMLDefinitions.h:991
SUMO_ATTR_LCA_COOPERATIVE_ROUNDABOUT
@ SUMO_ATTR_LCA_COOPERATIVE_ROUNDABOUT
Definition SUMOXMLDefinitions.h:1291
SUMO_ATTR_MAXTRACTION
@ SUMO_ATTR_MAXTRACTION
Definition SUMOXMLDefinitions.h:1269
SUMO_ATTR_CA_GAIN_GAP_DOT_CACC
@ SUMO_ATTR_CA_GAIN_GAP_DOT_CACC
Definition SUMOXMLDefinitions.h:1254
SUMO_ATTR_HEADWAY_TIME_CACC_TO_ACC
@ SUMO_ATTR_HEADWAY_TIME_CACC_TO_ACC
Definition SUMOXMLDefinitions.h:1255
SUMO_ATTR_MASS
@ SUMO_ATTR_MASS
Definition SUMOXMLDefinitions.h:1566
SUMO_ATTR_CF_CC_OMEGAN
@ SUMO_ATTR_CF_CC_OMEGAN
Definition SUMOXMLDefinitions.h:1635
SUMO_ATTR_CONTAINER_NUMBER
@ SUMO_ATTR_CONTAINER_NUMBER
Definition SUMOXMLDefinitions.h:1371
SUMO_ATTR_CF_CC_C1
@ SUMO_ATTR_CF_CC_C1
Definition SUMOXMLDefinitions.h:1633
SUMO_ATTR_TMP2
@ SUMO_ATTR_TMP2
Definition SUMOXMLDefinitions.h:1212
SUMO_ATTR_CF_W99_CC8
@ SUMO_ATTR_CF_W99_CC8
Definition SUMOXMLDefinitions.h:1626
SUMO_ATTR_CA_GAIN_SPACE
@ SUMO_ATTR_CA_GAIN_SPACE
Definition SUMOXMLDefinitions.h:1242
SUMO_ATTR_LINE
@ SUMO_ATTR_LINE
Definition SUMOXMLDefinitions.h:1535
SUMO_ATTR_LOADING_DURATION
@ SUMO_ATTR_LOADING_DURATION
Definition SUMOXMLDefinitions.h:994
SUMO_ATTR_CF_IDM_DELTA
@ SUMO_ATTR_CF_IDM_DELTA
Definition SUMOXMLDefinitions.h:1612
SUMO_ATTR_CF_EIDM_MAX_VEH_PREVIEW
@ SUMO_ATTR_CF_EIDM_MAX_VEH_PREVIEW
Definition SUMOXMLDefinitions.h:1231
SUMO_ATTR_LCA_SPEEDGAIN_LOOKAHEAD
@ SUMO_ATTR_LCA_SPEEDGAIN_LOOKAHEAD
Definition SUMOXMLDefinitions.h:1289
SUMO_ATTR_LCA_MAXSPEEDLATFACTOR
@ SUMO_ATTR_LCA_MAXSPEEDLATFACTOR
Definition SUMOXMLDefinitions.h:1294
SUMO_ATTR_MANEUVER_ANGLE_TIMES
@ SUMO_ATTR_MANEUVER_ANGLE_TIMES
Class specific timing values for vehicle maneuvering through angle ranges.
Definition SUMOXMLDefinitions.h:1002
SUMO_ATTR_CF_CC_CCACCEL
@ SUMO_ATTR_CF_CC_CCACCEL
Definition SUMOXMLDefinitions.h:1638
SUMO_ATTR_CONTAINERSPERHOUR
@ SUMO_ATTR_CONTAINERSPERHOUR
Definition SUMOXMLDefinitions.h:1556
SUMO_ATTR_CF_EIDM_T_REACTION
@ SUMO_ATTR_CF_EIDM_T_REACTION
Definition SUMOXMLDefinitions.h:1220
SUMO_ATTR_MODES
@ SUMO_ATTR_MODES
Definition SUMOXMLDefinitions.h:1372
SUMO_ATTR_CF_EIDM_T_PERSISTENCE_ESTIMATE
@ SUMO_ATTR_CF_EIDM_T_PERSISTENCE_ESTIMATE
Definition SUMOXMLDefinitions.h:1221
SUMO_ATTR_VTYPES
@ SUMO_ATTR_VTYPES
Definition SUMOXMLDefinitions.h:1345
SUMO_ATTR_MAXPOWER
@ SUMO_ATTR_MAXPOWER
Definition SUMOXMLDefinitions.h:1268
SUMO_ATTR_CF_PWAGNER2009_TAULAST
@ SUMO_ATTR_CF_PWAGNER2009_TAULAST
Definition SUMOXMLDefinitions.h:1610
SUMO_ATTR_TIME_TO_TELEPORT_BIDI
@ SUMO_ATTR_TIME_TO_TELEPORT_BIDI
Definition SUMOXMLDefinitions.h:999
SUMO_ATTR_CF_CC_PLOEG_KD
@ SUMO_ATTR_CF_CC_PLOEG_KD
Definition SUMOXMLDefinitions.h:1640
SUMO_ATTR_CF_CC_TAU
@ SUMO_ATTR_CF_CC_TAU
Definition SUMOXMLDefinitions.h:1636
SUMO_ATTR_GC_GAIN_GAP_CACC
@ SUMO_ATTR_GC_GAIN_GAP_CACC
Definition SUMOXMLDefinitions.h:1251
SUMO_ATTR_DEPARTPOS
@ SUMO_ATTR_DEPARTPOS
Definition SUMOXMLDefinitions.h:964
SUMO_ATTR_CF_EIDM_SIG_GAP
@ SUMO_ATTR_CF_EIDM_SIG_GAP
Definition SUMOXMLDefinitions.h:1224
SUMO_ATTR_CAR_FOLLOW_MODEL
@ SUMO_ATTR_CAR_FOLLOW_MODEL
Definition SUMOXMLDefinitions.h:990
SUMO_ATTR_CF_EIDM_JERK_MAX
@ SUMO_ATTR_CF_EIDM_JERK_MAX
Definition SUMOXMLDefinitions.h:1226
SUMO_ATTR_RESISTANCE_COEFFICIENT_QUADRATIC
@ SUMO_ATTR_RESISTANCE_COEFFICIENT_QUADRATIC
Definition SUMOXMLDefinitions.h:1272
SUMO_ATTR_DECEL
@ SUMO_ATTR_DECEL
Definition SUMOXMLDefinitions.h:979
SUMO_ATTR_LCA_MAXSPEEDLATSTANDING
@ SUMO_ATTR_LCA_MAXSPEEDLATSTANDING
Definition SUMOXMLDefinitions.h:1293
SUMO_ATTR_LCA_KEEPRIGHT_PARAM
@ SUMO_ATTR_LCA_KEEPRIGHT_PARAM
Definition SUMOXMLDefinitions.h:1277
SUMO_ATTR_GUISHAPE
@ SUMO_ATTR_GUISHAPE
Definition SUMOXMLDefinitions.h:1561
SUMO_ATTR_DESIRED_MAXSPEED
@ SUMO_ATTR_DESIRED_MAXSPEED
Definition SUMOXMLDefinitions.h:974
SUMO_ATTR_REROUTE
@ SUMO_ATTR_REROUTE
Definition SUMOXMLDefinitions.h:1366
SUMO_ATTR_PERHOUR
@ SUMO_ATTR_PERHOUR
Definition SUMOXMLDefinitions.h:1557
SUMO_ATTR_LCA_STRATEGIC_LOOKAHEAD
@ SUMO_ATTR_LCA_STRATEGIC_LOOKAHEAD
Definition SUMOXMLDefinitions.h:1282
SUMO_ATTR_LCA_CONTRIGHT
@ SUMO_ATTR_LCA_CONTRIGHT
Definition SUMOXMLDefinitions.h:1302
SUMO_ATTR_CONTAINER_CAPACITY
@ SUMO_ATTR_CONTAINER_CAPACITY
Definition SUMOXMLDefinitions.h:1368
SUMO_ATTR_CF_CC_XI
@ SUMO_ATTR_CF_CC_XI
Definition SUMOXMLDefinitions.h:1634
SUMO_ATTR_CA_OVERRIDE
@ SUMO_ATTR_CA_OVERRIDE
Definition SUMOXMLDefinitions.h:1243
SUMO_ATTR_PERIOD
@ SUMO_ATTR_PERIOD
Definition SUMOXMLDefinitions.h:1361
SUMO_ATTR_LCA_COOPERATIVE_PARAM
@ SUMO_ATTR_LCA_COOPERATIVE_PARAM
Definition SUMOXMLDefinitions.h:1275
SUMO_ATTR_LCA_OPPOSITE_PARAM
@ SUMO_ATTR_LCA_OPPOSITE_PARAM
Definition SUMOXMLDefinitions.h:1279
SUMO_ATTR_BOARDING_FACTOR
@ SUMO_ATTR_BOARDING_FACTOR
Definition SUMOXMLDefinitions.h:995
SUMO_ATTR_TO_TAZ
@ SUMO_ATTR_TO_TAZ
Definition SUMOXMLDefinitions.h:1365
SUMO_ATTR_CF_CC_CCDECEL
@ SUMO_ATTR_CF_CC_CCDECEL
Definition SUMOXMLDefinitions.h:1629
SUMO_ATTR_DEPARTSPEED
@ SUMO_ATTR_DEPARTSPEED
Definition SUMOXMLDefinitions.h:966
SUMO_ATTR_LCA_SPEEDGAIN_REMAIN_TIME
@ SUMO_ATTR_LCA_SPEEDGAIN_REMAIN_TIME
Definition SUMOXMLDefinitions.h:1290
SUMO_ATTR_GCC_GAIN_SPACE
@ SUMO_ATTR_GCC_GAIN_SPACE
Definition SUMOXMLDefinitions.h:1238
SUMO_ATTR_MINGAP_LAT
@ SUMO_ATTR_MINGAP_LAT
Definition SUMOXMLDefinitions.h:977
SUMO_ATTR_EMERGENCYDECEL
@ SUMO_ATTR_EMERGENCYDECEL
Definition SUMOXMLDefinitions.h:980
SUMO_ATTR_CF_CC_FLATBED_H
@ SUMO_ATTR_CF_CC_FLATBED_H
Definition SUMOXMLDefinitions.h:1646
SUMO_ATTR_CF_W99_CC3
@ SUMO_ATTR_CF_W99_CC3
Definition SUMOXMLDefinitions.h:1621
SUMO_ATTR_LCA_OVERTAKE_DELTASPEED_FACTOR
@ SUMO_ATTR_LCA_OVERTAKE_DELTASPEED_FACTOR
Definition SUMOXMLDefinitions.h:1301
SUMO_ATTR_CF_CC_LANES_COUNT
@ SUMO_ATTR_CF_CC_LANES_COUNT
Definition SUMOXMLDefinitions.h:1637
SUMO_ATTR_HEIGHT
@ SUMO_ATTR_HEIGHT
Definition SUMOXMLDefinitions.h:1560
SUMO_ATTR_END
@ SUMO_ATTR_END
weights: time range end
Definition SUMOXMLDefinitions.h:1400
SUMO_ATTR_LCA_SUBLANE_PARAM
@ SUMO_ATTR_LCA_SUBLANE_PARAM
Definition SUMOXMLDefinitions.h:1278
SUMO_ATTR_LCA_SIGMA
@ SUMO_ATTR_LCA_SIGMA
Definition SUMOXMLDefinitions.h:1299
SUMO_ATTR_LATALIGNMENT
@ SUMO_ATTR_LATALIGNMENT
Definition SUMOXMLDefinitions.h:976
SUMO_ATTR_FROM_TAZ
@ SUMO_ATTR_FROM_TAZ
Definition SUMOXMLDefinitions.h:1364
SUMO_ATTR_CF_IDM_STEPPING
@ SUMO_ATTR_CF_IDM_STEPPING
Definition SUMOXMLDefinitions.h:1613
SUMO_ATTR_SIGMA_STEP
@ SUMO_ATTR_SIGMA_STEP
Definition SUMOXMLDefinitions.h:1208
SUMO_ATTR_DEPARTLANE
@ SUMO_ATTR_DEPARTLANE
Definition SUMOXMLDefinitions.h:963
SUMO_ATTR_CF_IDMM_ADAPT_FACTOR
@ SUMO_ATTR_CF_IDMM_ADAPT_FACTOR
Definition SUMOXMLDefinitions.h:1614
SUMO_ATTR_SPEED_TABLE
@ SUMO_ATTR_SPEED_TABLE
Definition SUMOXMLDefinitions.h:1264
SUMO_ATTR_IMPATIENCE
@ SUMO_ATTR_IMPATIENCE
Definition SUMOXMLDefinitions.h:1567
SUMO_ATTR_COLLISION_MINGAP_FACTOR
@ SUMO_ATTR_COLLISION_MINGAP_FACTOR
Definition SUMOXMLDefinitions.h:992
SUMO_ATTR_VCLASS
@ SUMO_ATTR_VCLASS
Definition SUMOXMLDefinitions.h:983
SUMO_ATTR_ACCEL
@ SUMO_ATTR_ACCEL
Definition SUMOXMLDefinitions.h:978
SUMO_ATTR_BOARDING_DURATION
@ SUMO_ATTR_BOARDING_DURATION
Definition SUMOXMLDefinitions.h:993
SUMO_ATTR_CF_CC_CONSTSPACING
@ SUMO_ATTR_CF_CC_CONSTSPACING
Definition SUMOXMLDefinitions.h:1630
SUMO_ATTR_CF_EIDM_M_FLATNESS
@ SUMO_ATTR_CF_EIDM_M_FLATNESS
Definition SUMOXMLDefinitions.h:1229
SUMO_ATTR_CF_W99_CC2
@ SUMO_ATTR_CF_W99_CC2
Definition SUMOXMLDefinitions.h:1620
SUMO_ATTR_CF_W99_CC4
@ SUMO_ATTR_CF_W99_CC4
Definition SUMOXMLDefinitions.h:1622
SUMO_ATTR_JM_SIGMA_MINOR
@ SUMO_ATTR_JM_SIGMA_MINOR
Definition SUMOXMLDefinitions.h:1316
SUMO_ATTR_CF_W99_CC6
@ SUMO_ATTR_CF_W99_CC6
Definition SUMOXMLDefinitions.h:1624
SUMO_ATTR_PROB
@ SUMO_ATTR_PROB
Definition SUMOXMLDefinitions.h:1339
SUMO_ATTR_CF_EIDM_M_BEGIN
@ SUMO_ATTR_CF_EIDM_M_BEGIN
Definition SUMOXMLDefinitions.h:1230
SUMO_ATTR_CF_EIDM_T_PERSISTENCE_DRIVE
@ SUMO_ATTR_CF_EIDM_T_PERSISTENCE_DRIVE
Definition SUMOXMLDefinitions.h:1219
SUMO_ATTR_TIME_TO_TELEPORT
@ SUMO_ATTR_TIME_TO_TELEPORT
Definition SUMOXMLDefinitions.h:998
SUMO_ATTR_SPEEDFACTOR
@ SUMO_ATTR_SPEEDFACTOR
Definition SUMOXMLDefinitions.h:987
SUMO_ATTR_CA_GAIN_SPEED
@ SUMO_ATTR_CA_GAIN_SPEED
Definition SUMOXMLDefinitions.h:1241
SUMO_ATTR_CF_EIDM_SIG_LEADER
@ SUMO_ATTR_CF_EIDM_SIG_LEADER
Definition SUMOXMLDefinitions.h:1223
SUMO_ATTR_TYPE
@ SUMO_ATTR_TYPE
Definition SUMOXMLDefinitions.h:869
SUMO_ATTR_CF_CC_KP
@ SUMO_ATTR_CF_CC_KP
Definition SUMOXMLDefinitions.h:1631
SUMO_ATTR_LENGTH
@ SUMO_ATTR_LENGTH
Definition SUMOXMLDefinitions.h:927
SUMO_ATTR_ROUTE
@ SUMO_ATTR_ROUTE
Definition SUMOXMLDefinitions.h:897
SUMO_ATTR_RESISTANCE_COEFFICIENT_LINEAR
@ SUMO_ATTR_RESISTANCE_COEFFICIENT_LINEAR
Definition SUMOXMLDefinitions.h:1271
SUMO_ATTR_APPLYDRIVERSTATE
@ SUMO_ATTR_APPLYDRIVERSTATE
Definition SUMOXMLDefinitions.h:1257
SUMO_ATTR_PERSON_NUMBER
@ SUMO_ATTR_PERSON_NUMBER
Definition SUMOXMLDefinitions.h:1370
SUMO_ATTR_COLOR
@ SUMO_ATTR_COLOR
A color information.
Definition SUMOXMLDefinitions.h:1430
SUMO_ATTR_CF_PWAGNER2009_APPROB
@ SUMO_ATTR_CF_PWAGNER2009_APPROB
Definition SUMOXMLDefinitions.h:1611
SUMO_ATTR_MAXSPEED
@ SUMO_ATTR_MAXSPEED
Definition SUMOXMLDefinitions.h:973
SUMO_ATTR_ID
@ SUMO_ATTR_ID
Definition SUMOXMLDefinitions.h:912
SUMO_ATTR_SIGMA
@ SUMO_ATTR_SIGMA
Definition SUMOXMLDefinitions.h:1207
SUMO_ATTR_K
@ SUMO_ATTR_K
Definition SUMOXMLDefinitions.h:1595
SUMO_ATTR_TMP1
@ SUMO_ATTR_TMP1
Definition SUMOXMLDefinitions.h:1211
SUMO_ATTR_SPEEDFACTOR_PREMATURE
@ SUMO_ATTR_SPEEDFACTOR_PREMATURE
Definition SUMOXMLDefinitions.h:1000
SUMO_ATTR_OSGFILE
@ SUMO_ATTR_OSGFILE
Definition SUMOXMLDefinitions.h:1562
SUMO_ATTR_LCA_OVERTAKE_RIGHT
@ SUMO_ATTR_LCA_OVERTAKE_RIGHT
Definition SUMOXMLDefinitions.h:1297
SUMO_ATTR_ARRIVALPOS_LAT
@ SUMO_ATTR_ARRIVALPOS_LAT
Definition SUMOXMLDefinitions.h:970
SUMO_ATTR_LCA_ACCEL_LAT
@ SUMO_ATTR_LCA_ACCEL_LAT
Definition SUMOXMLDefinitions.h:1286
SUMO_ATTR_CF_W99_CC7
@ SUMO_ATTR_CF_W99_CC7
Definition SUMOXMLDefinitions.h:1625
SUMO_ATTR_LCA_STRATEGIC_PARAM
@ SUMO_ATTR_LCA_STRATEGIC_PARAM
Definition SUMOXMLDefinitions.h:1274
SUMO_ATTR_TRACTION_TABLE
@ SUMO_ATTR_TRACTION_TABLE
Definition SUMOXMLDefinitions.h:1265
SUMO_ATTR_CF_W99_CC1
@ SUMO_ATTR_CF_W99_CC1
Definition SUMOXMLDefinitions.h:1619
SUMO_ATTR_TAU
@ SUMO_ATTR_TAU
Definition SUMOXMLDefinitions.h:1210
SUMO_ATTR_INSERTIONCHECKS
@ SUMO_ATTR_INSERTIONCHECKS
Definition SUMOXMLDefinitions.h:997
SUMO_ATTR_IMGFILE
@ SUMO_ATTR_IMGFILE
Definition SUMOXMLDefinitions.h:1563
SUMO_ATTR_WIDTH
@ SUMO_ATTR_WIDTH
Definition SUMOXMLDefinitions.h:920
SUMO_ATTR_PERSON_CAPACITY
@ SUMO_ATTR_PERSON_CAPACITY
Definition SUMOXMLDefinitions.h:1367
SUMO_ATTR_GC_GAIN_SPEED
@ SUMO_ATTR_GC_GAIN_SPEED
Definition SUMOXMLDefinitions.h:1239
SUMO_ATTR_GCC_GAIN_GAP_CACC
@ SUMO_ATTR_GCC_GAIN_GAP_CACC
Definition SUMOXMLDefinitions.h:1249
SUMO_ATTR_LCA_KEEPRIGHT_ACCEPTANCE_TIME
@ SUMO_ATTR_LCA_KEEPRIGHT_ACCEPTANCE_TIME
Definition SUMOXMLDefinitions.h:1300
SUMO_ATTR_LCA_EXPERIMENTAL1
@ SUMO_ATTR_LCA_EXPERIMENTAL1
Definition SUMOXMLDefinitions.h:1303
SUMO_ATTR_SC_GAIN
@ SUMO_ATTR_SC_GAIN
Definition SUMOXMLDefinitions.h:1236
SUMO_ATTR_TMP5
@ SUMO_ATTR_TMP5
Definition SUMOXMLDefinitions.h:1215
SUMO_ATTR_SC_GAIN_CACC
@ SUMO_ATTR_SC_GAIN_CACC
Definition SUMOXMLDefinitions.h:1248
SUMO_ATTR_LCA_TIME_TO_IMPATIENCE
@ SUMO_ATTR_LCA_TIME_TO_IMPATIENCE
Definition SUMOXMLDefinitions.h:1285
SUMO_ATTR_CF_CC_FLATBED_KV
@ SUMO_ATTR_CF_CC_FLATBED_KV
Definition SUMOXMLDefinitions.h:1643
SUMO_ATTR_SC_MIN_GAP
@ SUMO_ATTR_SC_MIN_GAP
Definition SUMOXMLDefinitions.h:1256
SUMO_ATTR_SPEEDDEV
@ SUMO_ATTR_SPEEDDEV
Definition SUMOXMLDefinitions.h:988
SUMO_ATTR_CF_WIEDEMANN_ESTIMATION
@ SUMO_ATTR_CF_WIEDEMANN_ESTIMATION
Definition SUMOXMLDefinitions.h:1618
SUMO_ATTR_PERSONSPERHOUR
@ SUMO_ATTR_PERSONSPERHOUR
Definition SUMOXMLDefinitions.h:1555
SUMO_ATTR_LCA_SPEEDGAINRIGHT
@ SUMO_ATTR_LCA_SPEEDGAINRIGHT
Definition SUMOXMLDefinitions.h:1288
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:228
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:480
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:454
SUMOSAXAttributes::getObjectType
const std::string & getObjectType() const
return the objecttype to which these attributes belong
Definition SUMOSAXAttributes.h:388
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::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:986
SUMOVehicleParameter
Structure representing possible vehicle parameter.
Definition SUMOVehicleParameter.h:335
SUMOVehicleParameter::departPosLat
double departPosLat
(optional) The lateral position the vehicle shall depart from
Definition SUMOVehicleParameter.h:703
SUMOVehicleParameter::arrivalPosLat
double arrivalPosLat
(optional) The lateral position the vehicle shall arrive on
Definition SUMOVehicleParameter.h:737
SUMOVehicleParameter::repetitionProbability
double repetitionProbability
The probability for emitting a vehicle per second.
Definition SUMOVehicleParameter.h:771
SUMOVehicleParameter::departLane
int departLane
(optional) The lane the vehicle shall depart from (index in edge)
Definition SUMOVehicleParameter.h:691
SUMOVehicleParameter::arrivalSpeedProcedure
ArrivalSpeedDefinition arrivalSpeedProcedure
Information how the vehicle's end speed shall be chosen.
Definition SUMOVehicleParameter.h:746
SUMOVehicleParameter::departSpeed
double departSpeed
(optional) The initial speed of the vehicle
Definition SUMOVehicleParameter.h:709
SUMOVehicleParameter::tag
SumoXMLTag tag
The vehicle tag.
Definition SUMOVehicleParameter.h:668
SUMOVehicleParameter::vtypeid
std::string vtypeid
The vehicle's type id.
Definition SUMOVehicleParameter.h:677
SUMOVehicleParameter::repetitionOffset
SUMOTime repetitionOffset
The time offset between vehicle reinsertions.
Definition SUMOVehicleParameter.h:765
SUMOVehicleParameter::speedFactor
double speedFactor
individual speedFactor (overriding distribution from vType)
Definition SUMOVehicleParameter.h:812
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:561
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:624
SUMOVehicleParameter::arrivalLaneProcedure
ArrivalLaneDefinition arrivalLaneProcedure
Information how the vehicle shall choose the lane to arrive on.
Definition SUMOVehicleParameter.h:728
SUMOVehicleParameter::parametersSet
long long int parametersSet
Information for the router which parameter were set, TraCI may modify this (when changing color)
Definition SUMOVehicleParameter.h:821
SUMOVehicleParameter::departLaneProcedure
DepartLaneDefinition departLaneProcedure
Information how the vehicle shall choose the lane to depart from.
Definition SUMOVehicleParameter.h:694
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:493
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:594
SUMOVehicleParameter::personNumber
int personNumber
The static number of persons in the vehicle when it departs (not including boarding persons)
Definition SUMOVehicleParameter.h:806
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:654
SUMOVehicleParameter::poissonRate
double poissonRate
The rate for emitting vehicles with a poisson distribution.
Definition SUMOVehicleParameter.h:774
SUMOVehicleParameter::arrivalEdgeProcedure
RouteIndexDefinition arrivalEdgeProcedure
Information how the vehicle's final edge shall be chosen.
Definition SUMOVehicleParameter.h:752
SUMOVehicleParameter::departPosLatProcedure
DepartPosLatDefinition departPosLatProcedure
Information how the vehicle shall choose the lateral departure position.
Definition SUMOVehicleParameter.h:706
SUMOVehicleParameter::modes
SVCPermissions modes
The modes a person or container can use.
Definition SUMOVehicleParameter.h:800
SUMOVehicleParameter::repetitionEnd
SUMOTime repetitionEnd
The time at which the flow ends (only needed when using repetitionProbability)
Definition SUMOVehicleParameter.h:777
SUMOVehicleParameter::vTypes
std::string vTypes
The types of usable (auto-generated) vehicles for a person / container.
Definition SUMOVehicleParameter.h:803
SUMOVehicleParameter::departPos
double departPos
(optional) The position the vehicle shall depart from
Definition SUMOVehicleParameter.h:697
SUMOVehicleParameter::departSpeedProcedure
DepartSpeedDefinition departSpeedProcedure
Information how the vehicle's initial speed shall be chosen.
Definition SUMOVehicleParameter.h:712
SUMOVehicleParameter::color
RGBColor color
The vehicle's color, TraCI may change this.
Definition SUMOVehicleParameter.h:680
SUMOVehicleParameter::arrivalPos
double arrivalPos
(optional) The position the vehicle shall arrive on
Definition SUMOVehicleParameter.h:731
SUMOVehicleParameter::parseInsertionChecks
static int parseInsertionChecks(const std::string &value)
parses insertion checks
Definition SUMOVehicleParameter.cpp:1130
SUMOVehicleParameter::calibratorSpeed
double calibratorSpeed
speed (used by calibrator flows
Definition SUMOVehicleParameter.h:815
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:674
SUMOVehicleParameter::id
std::string id
The vehicle's id.
Definition SUMOVehicleParameter.h:671
SUMOVehicleParameter::parkingBadges
std::vector< std::string > parkingBadges
The parking access rights.
Definition SUMOVehicleParameter.h:797
SUMOVehicleParameter::departEdge
int departEdge
(optional) The initial edge within the route of the vehicle
Definition SUMOVehicleParameter.h:715
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:698
SUMOVehicleParameter::arrivalPosProcedure
ArrivalPosDefinition arrivalPosProcedure
Information how the vehicle shall choose the arrival position.
Definition SUMOVehicleParameter.h:734
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:532
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:457
SUMOVehicleParameter::toTaz
std::string toTaz
The vehicle's destination zone (district)
Definition SUMOVehicleParameter.h:788
SUMOVehicleParameter::arrivalSpeed
double arrivalSpeed
(optional) The final speed of the vehicle (not used yet)
Definition SUMOVehicleParameter.h:743
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:683
SUMOVehicleParameter::departProcedure
DepartDefinition departProcedure
Information how the vehicle shall choose the depart time.
Definition SUMOVehicleParameter.h:688
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:417
SUMOVehicleParameter::insertionChecks
int insertionChecks
bitset of InsertionCheck
Definition SUMOVehicleParameter.h:818
SUMOVehicleParameter::arrivalEdge
int arrivalEdge
(optional) The final edge within the route of the vehicle
Definition SUMOVehicleParameter.h:749
SUMOVehicleParameter::fromTaz
std::string fromTaz
The vehicle's origin zone (district)
Definition SUMOVehicleParameter.h:785
SUMOVehicleParameter::departPosProcedure
DepartPosDefinition departPosProcedure
Information how the vehicle shall choose the departure position.
Definition SUMOVehicleParameter.h:700
SUMOVehicleParameter::line
std::string line
The vehicle's line (mainly for public transport)
Definition SUMOVehicleParameter.h:782
SUMOVehicleParameter::containerNumber
int containerNumber
The static number of containers in the vehicle when it departs.
Definition SUMOVehicleParameter.h:809
SUMOVehicleParameter::departEdgeProcedure
RouteIndexDefinition departEdgeProcedure
Information how the vehicle's initial edge shall be chosen.
Definition SUMOVehicleParameter.h:718
SUMOVehicleParameter::arrivalPosLatProcedure
ArrivalPosLatDefinition arrivalPosLatProcedure
Information how the vehicle shall choose the lateral arrival position.
Definition SUMOVehicleParameter.h:740
SUMOVehicleParserHelper::parseCarWalkTransfer
static int parseCarWalkTransfer(const OptionsCont &oc, const bool hasTaxi=false)
Definition SUMOVehicleParserHelper.cpp:1778
SUMOVehicleParserHelper::getAllowedCFModelAttrs
static const CFAttrMap & getAllowedCFModelAttrs()
returns allowed attrs for each known CF-model (init on first use)
Definition SUMOVehicleParserHelper.cpp:1338
SUMOVehicleParserHelper::beginVTypeParsing
static SUMOVTypeParameter * beginVTypeParsing(const SUMOSAXAttributes &attrs, const bool hardFail, const std::string &file)
Starts to parse a vehicle type.
Definition SUMOVehicleParserHelper.cpp:756
SUMOVehicleParserHelper::parseLCParams
static bool parseLCParams(SUMOVTypeParameter *into, LaneChangeModel model, const SUMOSAXAttributes &attrs)
Parses lane change model attributes.
Definition SUMOVehicleParserHelper.cpp:1530
SUMOVehicleParserHelper::isInternalRouteID
static bool isInternalRouteID(const std::string &id)
Checks whether the route ID uses the syntax of internal routes.
Definition SUMOVehicleParserHelper.cpp:1772
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:1239
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:1752
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:1842
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:1203
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:1714
SUMOVehicleParserHelper::parseVehicleClass
static SUMOVehicleClass parseVehicleClass(const SUMOSAXAttributes &attrs, const std::string &id)
Parses the vehicle class.
Definition SUMOVehicleParserHelper.cpp:1692
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:1732
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:1828
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:1647
SUMOXMLDefinitions::CarFollowModels
static StringBijection< SumoXMLTag > CarFollowModels
car following models
Definition SUMOXMLDefinitions.h:2303
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:1739
SUMOXMLDefinitions::TrainTypes
static StringBijection< TrainType > TrainTypes
train types
Definition SUMOXMLDefinitions.h:2309
SUMOXMLDefinitions::Tags
static SequentialStringBijection Tags
The names of SUMO-XML elements for use in netbuild.
Definition SUMOXMLDefinitions.h:2255
SUMOXMLDefinitions::LaneChangeModels
static StringBijection< LaneChangeModel > LaneChangeModels
lane change models
Definition SUMOXMLDefinitions.h:2300
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:392
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:325
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