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