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