Line data Source code
1 : /****************************************************************************/
2 : // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3 : // Copyright (C) 2001-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 SUMOVehicleParameter.cpp
15 : /// @author Daniel Krajzewicz
16 : /// @author Jakob Erdmann
17 : /// @author Michael Behrisch
18 : /// @date Tue, 31.03.2009
19 : ///
20 : // Structure representing possible vehicle parameter
21 : /****************************************************************************/
22 : #include <config.h>
23 : #include <utils/common/MsgHandler.h>
24 : #include <utils/common/StringTokenizer.h>
25 : #include <utils/common/StringUtils.h>
26 : #include <utils/common/ToString.h>
27 : #include <utils/common/RandHelper.h>
28 : #include <utils/iodevices/OutputDevice.h>
29 : #include <utils/options/OptionsCont.h>
30 :
31 : #include "SUMOVehicleParameter.h"
32 :
33 : // ===========================================================================
34 : // member method definitions
35 : // ===========================================================================
36 :
37 1204947 : SUMOVehicleParameter::SUMOVehicleParameter()
38 2409894 : : tag(SUMO_TAG_NOTHING), vtypeid(DEFAULT_VTYPE_ID), color(RGBColor::DEFAULT_COLOR),
39 1204947 : depart(-1), departProcedure(DepartDefinition::GIVEN),
40 1204947 : departLane(0), departLaneProcedure(DepartLaneDefinition::DEFAULT),
41 1204947 : departPos(0), departPosProcedure(DepartPosDefinition::DEFAULT),
42 1204947 : departPosLat(0), departPosLatProcedure(DepartPosLatDefinition::DEFAULT),
43 1204947 : departSpeed(-1), departSpeedProcedure(DepartSpeedDefinition::DEFAULT),
44 1204947 : departEdge(0), departEdgeProcedure(RouteIndexDefinition::DEFAULT),
45 1204947 : arrivalLane(0), arrivalLaneProcedure(ArrivalLaneDefinition::DEFAULT),
46 1204947 : arrivalPos(0), arrivalPosProcedure(ArrivalPosDefinition::DEFAULT),
47 1204947 : arrivalPosLat(0), arrivalPosLatProcedure(ArrivalPosLatDefinition::DEFAULT),
48 1204947 : arrivalSpeed(-1), arrivalSpeedProcedure(ArrivalSpeedDefinition::DEFAULT),
49 1204947 : arrivalEdge(-1), arrivalEdgeProcedure(RouteIndexDefinition::DEFAULT),
50 1204947 : repetitionNumber(-1),
51 1204947 : repetitionsDone(-1),
52 1204947 : repetitionOffset(-1),
53 1204947 : repetitionTotalOffset(0),
54 1204947 : repetitionProbability(-1),
55 1204947 : poissonRate(0),
56 1204947 : repetitionEnd(-1),
57 1204947 : line(), fromTaz(), toTaz(), personNumber(0), containerNumber(0),
58 1204947 : speedFactor(-1),
59 1204947 : calibratorSpeed(-1),
60 1204947 : insertionChecks((int)InsertionCheck::ALL),
61 1204947 : parametersSet(0)
62 1204947 : { }
63 :
64 :
65 13204288 : SUMOVehicleParameter::~SUMOVehicleParameter() {
66 13204288 : }
67 :
68 :
69 : bool
70 289828 : SUMOVehicleParameter::defaultOptionOverrides(const OptionsCont& oc, const std::string& optionName) const {
71 579656 : return oc.exists(optionName) && oc.isSet(optionName) && oc.getBool("defaults-override");
72 : }
73 :
74 :
75 : void
76 550972 : SUMOVehicleParameter::write(OutputDevice& dev, const OptionsCont& oc, const SumoXMLTag altTag, const std::string& typeID) const {
77 550972 : if (!id.empty()) {
78 : // only used by calibrator flows
79 550972 : dev.openTag(altTag).writeAttr(SUMO_ATTR_ID, id);
80 : }
81 550972 : if (typeID == "") {
82 524070 : if (wasSet(VEHPARS_VTYPE_SET)) {
83 38111 : dev.writeAttr(SUMO_ATTR_TYPE, vtypeid);
84 : }
85 : } else {
86 26902 : dev.writeAttr(SUMO_ATTR_TYPE, typeID);
87 : }
88 : // write depart depending of tag
89 : if (altTag == SUMO_TAG_FLOW
90 550972 : || altTag == SUMO_TAG_PERSONFLOW
91 : || altTag == SUMO_TAG_CONTAINERFLOW
92 : || altTag == GNE_TAG_FLOW_ROUTE
93 : || altTag == GNE_TAG_FLOW_WITHROUTE
94 : || altTag == SUMO_TAG_FLOWSTATE) {
95 1027 : dev.writeAttr(SUMO_ATTR_BEGIN, getDepart());
96 :
97 1027 : if (wasSet(VEHPARS_END_SET)) {
98 1023 : dev.writeAttr(SUMO_ATTR_END, time2string(repetitionEnd));
99 : }
100 1027 : if (wasSet(VEHPARS_NUMBER_SET)) {
101 63 : dev.writeAttr(SUMO_ATTR_NUMBER, repetitionNumber);
102 : }
103 1027 : if (wasSet(VEHPARS_VPH_SET)) {
104 0 : dev.writeAttr(SUMO_ATTR_PERHOUR, 3600 / STEPS2TIME(repetitionOffset));
105 : }
106 : // netedit uses VEHPARS_POISSON_SET
107 1027 : if (wasSet(VEHPARS_PERIOD_SET) || wasSet(VEHPARS_POISSON_SET)) {
108 606 : if (repetitionOffset >= 0 && !wasSet(VEHPARS_POISSON_SET)) {
109 544 : dev.writeAttr(SUMO_ATTR_PERIOD, StringUtils::adjustDecimalValue(STEPS2TIME(repetitionOffset), 20));
110 : } else {
111 186 : dev.writeAttr(SUMO_ATTR_PERIOD, "exp(" + StringUtils::adjustDecimalValue(poissonRate, 20) + ")");
112 : }
113 : }
114 1027 : if (wasSet(VEHPARS_PROB_SET) && repetitionProbability > 0) {
115 362 : dev.writeAttr(SUMO_ATTR_PROB, StringUtils::adjustDecimalValue(repetitionProbability, 20));
116 : }
117 : } else {
118 549945 : dev.writeAttr(SUMO_ATTR_DEPART, getDepart());
119 : }
120 : // optional parameter
121 : // departlane
122 654948 : if (wasSet(VEHPARS_DEPARTLANE_SET) && !defaultOptionOverrides(oc, "departlane")) {
123 207752 : dev.writeNonEmptyAttr(SUMO_ATTR_DEPARTLANE, getDepartLane());
124 771775 : } else if (oc.exists("departlane") && oc.isSet("departlane")) {
125 894 : dev.writeNonEmptyAttr(SUMO_ATTR_DEPARTLANE, oc.getString("departlane"));
126 : }
127 : // departpos
128 592102 : if (wasSet(VEHPARS_DEPARTPOS_SET) && !defaultOptionOverrides(oc, "departpos")) {
129 82100 : dev.writeNonEmptyAttr(SUMO_ATTR_DEPARTPOS, getDepartPos());
130 914989 : } else if (oc.exists("departpos") && oc.isSet("departpos")) {
131 844 : dev.writeNonEmptyAttr(SUMO_ATTR_DEPARTPOS, oc.getString("departpos"));
132 : }
133 : // departPosLat
134 550972 : if (wasSet(VEHPARS_DEPARTPOSLAT_SET)) {
135 12 : dev.writeNonEmptyAttr(SUMO_ATTR_DEPARTPOS_LAT, getDepartPosLat());
136 : }
137 : // departspeed
138 686709 : if (wasSet(VEHPARS_DEPARTSPEED_SET) && !defaultOptionOverrides(oc, "departspeed")) {
139 271314 : dev.writeNonEmptyAttr(SUMO_ATTR_DEPARTSPEED, getDepartSpeed());
140 736523 : } else if (oc.exists("departspeed") && oc.isSet("departspeed")) {
141 902 : dev.writeNonEmptyAttr(SUMO_ATTR_DEPARTSPEED, oc.getString("departspeed"));
142 : }
143 : // departedge
144 551317 : if (wasSet(VEHPARS_DEPARTEDGE_SET) && !defaultOptionOverrides(oc, "departedge")) {
145 690 : dev.writeNonEmptyAttr(SUMO_ATTR_DEPARTEDGE, getDepartEdge());
146 550627 : } else if (oc.exists("departedge") && oc.isSet("departedge")) {
147 0 : dev.writeNonEmptyAttr(SUMO_ATTR_DEPARTEDGE, oc.getString("departedge"));
148 : }
149 : // arrivallane
150 551378 : if (wasSet(VEHPARS_ARRIVALLANE_SET) && !defaultOptionOverrides(oc, "arrivallane")) {
151 732 : dev.writeNonEmptyAttr(SUMO_ATTR_ARRIVALLANE, getArrivalLane());
152 957973 : } else if (oc.exists("arrivallane") && oc.isSet("arrivallane")) {
153 884 : dev.writeNonEmptyAttr(SUMO_ATTR_ARRIVALLANE, oc.getString("arrivallane"));
154 : }
155 : // arrivalpos
156 555312 : if (wasSet(VEHPARS_ARRIVALPOS_SET) && !defaultOptionOverrides(oc, "arrivalpos")) {
157 8560 : dev.writeNonEmptyAttr(SUMO_ATTR_ARRIVALPOS, getArrivalPos());
158 953790 : } else if (oc.exists("arrivalpos") && oc.isSet("arrivalpos")) {
159 864 : dev.writeNonEmptyAttr(SUMO_ATTR_ARRIVALPOS, oc.getString("arrivalpos"));
160 : }
161 : // arrivalPosLat
162 550972 : if (wasSet(VEHPARS_ARRIVALPOSLAT_SET)) {
163 0 : dev.writeNonEmptyAttr(SUMO_ATTR_ARRIVALPOS_LAT, getArrivalPosLat());
164 : }
165 : // arrivalspeed
166 554839 : if (wasSet(VEHPARS_ARRIVALSPEED_SET) && !defaultOptionOverrides(oc, "arrivalspeed")) {
167 7654 : dev.writeNonEmptyAttr(SUMO_ATTR_ARRIVALSPEED, getArrivalSpeed());
168 954522 : } else if (oc.exists("arrivalspeed") && oc.isSet("arrivalspeed")) {
169 884 : dev.writeNonEmptyAttr(SUMO_ATTR_ARRIVALSPEED, oc.getString("arrivalspeed"));
170 : }
171 : // arrivalEdge
172 551199 : if (wasSet(VEHPARS_ARRIVALEDGE_SET) && !defaultOptionOverrides(oc, "arrivaledge") && arrivalEdge >= 0) {
173 454 : dev.writeNonEmptyAttr(SUMO_ATTR_ARRIVALEDGE, getArrivalEdge());
174 550745 : } else if (oc.exists("arrivaledge") && oc.isSet("arrivaledge")) {
175 0 : dev.writeNonEmptyAttr(SUMO_ATTR_ARRIVALEDGE, oc.getString("arrivaledge"));
176 : }
177 : // color
178 550972 : if (wasSet(VEHPARS_COLOR_SET)) {
179 8688 : if (color.isRandom()) {
180 0 : dev.writeAttr(SUMO_ATTR_COLOR, "random");
181 : } else {
182 8688 : dev.writeAttr(SUMO_ATTR_COLOR, color);
183 : }
184 : }
185 : // line
186 550972 : if (wasSet(VEHPARS_LINE_SET)) {
187 414 : dev.writeAttr(SUMO_ATTR_LINE, line);
188 : }
189 : // from TAZ
190 550972 : if (wasSet(VEHPARS_FROM_TAZ_SET)) {
191 9775 : dev.writeAttr(SUMO_ATTR_FROM_TAZ, fromTaz);
192 : }
193 : // to TAZ
194 550972 : if (wasSet(VEHPARS_TO_TAZ_SET)) {
195 9781 : dev.writeAttr(SUMO_ATTR_TO_TAZ, toTaz);
196 : }
197 : // person number
198 550972 : if (wasSet(VEHPARS_PERSON_NUMBER_SET)) {
199 0 : dev.writeAttr(SUMO_ATTR_PERSON_NUMBER, personNumber);
200 : }
201 : // container number
202 550972 : if (wasSet(VEHPARS_CONTAINER_NUMBER_SET)) {
203 0 : dev.writeAttr(SUMO_ATTR_CONTAINER_NUMBER, containerNumber);
204 : }
205 : // individual speedFactor
206 550972 : if (wasSet(VEHPARS_SPEEDFACTOR_SET)) {
207 : // might be saving state with custom precision
208 : const int precision = dev.getPrecision();
209 49350 : dev.setPrecision(MAX2(gPrecisionRandom, precision));
210 49350 : dev.writeAttr(SUMO_ATTR_SPEEDFACTOR, speedFactor);
211 49350 : dev.setPrecision(precision);
212 : }
213 : // speed (only used by calibrators)
214 550972 : if (wasSet(VEHPARS_CALIBRATORSPEED_SET)) {
215 0 : dev.writeAttr(SUMO_ATTR_SPEED, calibratorSpeed);
216 : }
217 : // insertionChecks
218 550972 : if (wasSet(VEHPARS_INSERTION_CHECKS_SET) && insertionChecks != (int)InsertionCheck::ALL) {
219 : std::vector<std::string> checks;
220 109 : if (insertionChecks == (int)InsertionCheck::NONE) {
221 204 : checks.push_back(toString(InsertionCheck::NONE));
222 : } else {
223 98 : for (auto it : SUMOXMLDefinitions::InsertionChecks.getValues()) {
224 91 : if (((int)it & insertionChecks) != 0) {
225 126 : checks.push_back(toString(it));
226 : }
227 7 : }
228 : }
229 109 : dev.writeAttr(SUMO_ATTR_INSERTIONCHECKS, checks);
230 109 : }
231 : // parking access rights
232 550972 : if (wasSet(VEHPARS_PARKING_BADGES_SET)) {
233 0 : dev.writeNonEmptyAttr(SUMO_ATTR_PARKING_BADGES, joinToString(parkingBadges, " "));
234 : }
235 550972 : }
236 :
237 :
238 : void
239 33471 : SUMOVehicleParameter::Stop::write(OutputDevice& dev, const bool close, const bool writeTagAndParents) const {
240 33471 : if (writeTagAndParents) {
241 33471 : dev.openTag(SUMO_TAG_STOP);
242 33471 : if (busstop != "") {
243 11490 : dev.writeAttr(SUMO_ATTR_BUS_STOP, busstop);
244 : }
245 33471 : if (containerstop != "") {
246 439 : dev.writeAttr(SUMO_ATTR_CONTAINER_STOP, containerstop);
247 : }
248 33471 : if (chargingStation != "") {
249 342 : dev.writeAttr(SUMO_ATTR_CHARGING_STATION, chargingStation);
250 : }
251 33471 : if (parkingarea != "") {
252 10305 : dev.writeAttr(SUMO_ATTR_PARKING_AREA, parkingarea);
253 : }
254 33471 : if ((busstop == "") && (containerstop == "") && (parkingarea == "") && (chargingStation == "")) {
255 10909 : if (lane != "") {
256 9161 : dev.writeAttr(SUMO_ATTR_LANE, lane);
257 : } else {
258 1748 : dev.writeAttr(SUMO_ATTR_EDGE, edge);
259 : }
260 10909 : if ((parametersSet & STOP_START_SET) != 0) {
261 5213 : dev.writeAttr(SUMO_ATTR_STARTPOS, startPos);
262 : }
263 10909 : if ((parametersSet & STOP_END_SET) != 0) {
264 9102 : dev.writeAttr(SUMO_ATTR_ENDPOS, endPos);
265 : }
266 : }
267 : }
268 33471 : if (index > 0) {
269 920 : dev.writeAttr(SUMO_ATTR_INDEX, index);
270 : }
271 33471 : if ((parametersSet & STOP_POSLAT_SET) != 0 && posLat != INVALID_DOUBLE) {
272 77 : dev.writeAttr(SUMO_ATTR_POSITION_LAT, posLat);
273 : }
274 33471 : if ((parametersSet & STOP_ARRIVAL_SET) && (arrival >= 0)) {
275 544 : dev.writeAttr(SUMO_ATTR_ARRIVAL, time2string(arrival));
276 : }
277 33471 : if ((parametersSet & STOP_DURATION_SET) && (duration >= 0)) {
278 20377 : dev.writeAttr(SUMO_ATTR_DURATION, time2string(duration));
279 : }
280 33471 : if ((parametersSet & STOP_UNTIL_SET) && (until >= 0)) {
281 14616 : dev.writeAttr(SUMO_ATTR_UNTIL, time2string(until));
282 : }
283 33471 : if ((parametersSet & STOP_STARTED_SET) && (started >= 0)) {
284 109 : dev.writeAttr(SUMO_ATTR_STARTED, time2string(started));
285 : }
286 33471 : if ((parametersSet & STOP_ENDED_SET) && (ended >= 0)) {
287 124 : dev.writeAttr(SUMO_ATTR_ENDED, time2string(ended));
288 : }
289 33471 : if ((parametersSet & STOP_EXTENSION_SET) && (extension >= 0)) {
290 73 : dev.writeAttr(SUMO_ATTR_EXTENSION, time2string(extension));
291 : }
292 33471 : if ((parametersSet & STOP_TRIGGER_SET) != 0) {
293 2467 : const std::vector<std::string> triggers = getTriggers();
294 2467 : if (triggers.size() > 0) {
295 2457 : dev.writeAttr(SUMO_ATTR_TRIGGERED, triggers);
296 : }
297 2467 : }
298 33471 : if ((parametersSet & STOP_PARKING_SET) != 0) {
299 4436 : dev.writeAttr(SUMO_ATTR_PARKING, parking);
300 : }
301 33471 : if ((parametersSet & STOP_EXPECTED_SET) != 0 && awaitedPersons.size() > 0) {
302 53 : dev.writeAttr(SUMO_ATTR_EXPECTED, awaitedPersons);
303 : }
304 33471 : if ((parametersSet & STOP_PERMITTED_SET) != 0 && permitted.size() > 0) {
305 1582 : dev.writeAttr(SUMO_ATTR_PERMITTED, permitted);
306 : }
307 33471 : if ((parametersSet & STOP_EXPECTED_CONTAINERS_SET) != 0 && awaitedContainers.size() > 0) {
308 4 : dev.writeAttr(SUMO_ATTR_EXPECTED_CONTAINERS, awaitedContainers);
309 : }
310 33471 : if ((parametersSet & STOP_TRIP_ID_SET) != 0) {
311 55 : dev.writeAttr(SUMO_ATTR_TRIP_ID, tripId);
312 : }
313 33471 : if ((parametersSet & STOP_LINE_SET) != 0) {
314 22 : dev.writeAttr(SUMO_ATTR_LINE, line);
315 : }
316 33471 : if ((parametersSet & STOP_SPLIT_SET) != 0) {
317 21 : dev.writeAttr(SUMO_ATTR_SPLIT, split);
318 : }
319 33471 : if ((parametersSet & STOP_JOIN_SET) != 0) {
320 17 : dev.writeAttr(SUMO_ATTR_JOIN, join);
321 : }
322 33471 : if ((parametersSet & STOP_SPEED_SET) != 0) {
323 168 : dev.writeAttr(SUMO_ATTR_SPEED, speed);
324 : }
325 33471 : if ((parametersSet & STOP_ONDEMAND_SET) != 0) {
326 88 : dev.writeAttr(SUMO_ATTR_ONDEMAND, onDemand);
327 : }
328 33471 : if ((parametersSet & STOP_JUMP_SET) != 0 && jump >= 0) {
329 321 : dev.writeAttr(SUMO_ATTR_JUMP, time2string(jump));
330 : }
331 33471 : if ((parametersSet & STOP_JUMP_UNTIL_SET) != 0 && jumpUntil >= 0) {
332 9 : dev.writeAttr(SUMO_ATTR_JUMP_UNTIL, time2string(jumpUntil));
333 : }
334 33471 : if ((parametersSet & STOP_PRIORITY_SET) != 0 && priority >= 0) {
335 329 : dev.writeAttr(SUMO_ATTR_PRIORITY, priority);
336 : }
337 33471 : if (collision) {
338 745 : dev.writeAttr(SUMO_ATTR_COLLISION, collision);
339 : }
340 : // only write friendly position if is true
341 33471 : if (friendlyPos) {
342 0 : dev.writeAttr(SUMO_ATTR_FRIENDLY_POS, friendlyPos);
343 : }
344 : // only write act type if isn't empty
345 33471 : if (!actType.empty()) {
346 3909 : dev.writeAttr(SUMO_ATTR_ACTTYPE, actType);
347 : }
348 33471 : if (close) {
349 : // the user is closing the stop it is responsible for writing params
350 24464 : writeParams(dev);
351 48928 : dev.closeTag();
352 : }
353 33471 : }
354 :
355 : std::vector<std::string>
356 230 : SUMOVehicleParameter::Stop::getStoppingPlaceIDs() const {
357 : std::vector<std::string> result;
358 230 : if (busstop != "") {
359 110 : result.push_back(busstop);
360 : }
361 230 : if (containerstop != "") {
362 10 : result.push_back(containerstop);
363 : }
364 230 : if (chargingStation != "") {
365 10 : result.push_back(chargingStation);
366 : }
367 230 : if (parkingarea != "") {
368 10 : result.push_back(parkingarea);
369 : }
370 230 : return result;
371 0 : }
372 :
373 : bool
374 700122 : SUMOVehicleParameter::parseDepart(const std::string& val, const std::string& element, const std::string& id,
375 : SUMOTime& depart, DepartDefinition& dd, std::string& error, const std::string& attr) {
376 700122 : if (val == "triggered") {
377 1488 : dd = DepartDefinition::TRIGGERED;
378 698634 : } else if (val == "containerTriggered") {
379 104 : dd = DepartDefinition::CONTAINER_TRIGGERED;
380 698530 : } else if (val == "now") {
381 : // only used via TraCI. depart must be set by the calling code
382 22904 : dd = DepartDefinition::NOW;
383 675626 : } else if (val == "split") {
384 40 : dd = DepartDefinition::SPLIT;
385 675586 : } else if (val == "begin") {
386 12 : dd = DepartDefinition::BEGIN;
387 : } else {
388 : try {
389 675574 : depart = string2time(val);
390 675564 : dd = DepartDefinition::GIVEN;
391 675564 : if (depart < 0) {
392 14 : error = "Negative " + attr + " time in the definition of " + element + " '" + id + "'.";
393 7 : return false;
394 : }
395 10 : } catch (...) {
396 10 : if (id.empty()) {
397 0 : error = "Invalid " + attr + " time for " + element + ". Must be one of (\"triggered\", \"containerTriggered\", \"now\", or a float >= 0)";
398 : } else {
399 30 : error = "Invalid " + attr + " time for " + element + " '" + id + "';\n must be one of (\"triggered\", \"containerTriggered\", \"now\", or a float >= 0)";
400 : }
401 : return false;
402 10 : }
403 : }
404 : return true;
405 : }
406 :
407 :
408 : bool
409 178845 : SUMOVehicleParameter::parseDepartLane(const std::string& val, const std::string& element, const std::string& id,
410 : int& lane, DepartLaneDefinition& dld, std::string& error) {
411 : bool ok = true;
412 178845 : lane = 0;
413 178845 : dld = DepartLaneDefinition::GIVEN;
414 178845 : if (val == "random") {
415 4171 : dld = DepartLaneDefinition::RANDOM;
416 174674 : } else if (val == "free") {
417 2394 : dld = DepartLaneDefinition::FREE;
418 172280 : } else if (val == "allowed") {
419 131 : dld = DepartLaneDefinition::ALLOWED_FREE;
420 172149 : } else if (val == "best") {
421 94696 : dld = DepartLaneDefinition::BEST_FREE;
422 77453 : } else if (val == "best_prob") {
423 12900 : dld = DepartLaneDefinition::BEST_PROB;
424 64553 : } else if (val == "first") {
425 31793 : dld = DepartLaneDefinition::FIRST_ALLOWED;
426 : } else {
427 : try {
428 32760 : lane = StringUtils::toInt(val);
429 32693 : if (lane < 0) {
430 : ok = false;
431 : }
432 67 : } catch (...) {
433 : ok = false;
434 67 : }
435 : }
436 : if (!ok) {
437 67 : if (id.empty()) {
438 0 : error = "Invalid departLane definition for " + element + ". Must be one of (\"random\", \"free\", \"allowed\", \"best\", \"best_prob\", \"first\", or an int>=0)";
439 : } else {
440 201 : error = "Invalid departLane definition for " + element + " '" + id + "';\n must be one of (\"random\", \"free\", \"allowed\", \"best\", \"best_prob\", \"first\", or an int>=0)";
441 : }
442 : }
443 178845 : return ok;
444 : }
445 :
446 :
447 : bool
448 115085 : SUMOVehicleParameter::parseDepartPos(const std::string& val, const std::string& element, const std::string& id,
449 : double& pos, DepartPosDefinition& dpd, std::string& error) {
450 : bool ok = true;
451 115085 : pos = 0.;
452 115085 : dpd = DepartPosDefinition::GIVEN;
453 115085 : if (val == "random") {
454 3396 : dpd = DepartPosDefinition::RANDOM;
455 111689 : } else if (val == "random_free") {
456 72 : dpd = DepartPosDefinition::RANDOM_FREE;
457 111617 : } else if (val == "random_location") {
458 0 : dpd = DepartPosDefinition::RANDOM_LOCATION;
459 111617 : } else if (val == "free") {
460 436 : dpd = DepartPosDefinition::FREE;
461 111181 : } else if (val == "base") {
462 1029 : dpd = DepartPosDefinition::BASE;
463 110152 : } else if (val == "last") {
464 898 : dpd = DepartPosDefinition::LAST;
465 109254 : } else if (val == "splitFront") {
466 5 : dpd = DepartPosDefinition::SPLIT_FRONT;
467 109249 : } else if (val == "stop") {
468 2717 : dpd = DepartPosDefinition::STOP;
469 : } else {
470 : try {
471 106532 : pos = StringUtils::toDouble(val);
472 67 : } catch (...) {
473 : ok = false;
474 67 : }
475 : }
476 : if (!ok) {
477 67 : if (id.empty()) {
478 0 : error = "Invalid departPos definition for " + element + ". Must be one of (\"random\", \"random_free\", \"free\", \"base\", \"last\" or a float)";
479 : } else {
480 201 : error = "Invalid departPos definition for " + element + " '" + id + "';\n must be one of (\"random\", \"random_free\", \"free\", \"base\", \"last\" or a float)";
481 : }
482 : }
483 115085 : return ok;
484 : }
485 :
486 :
487 : bool
488 8969 : SUMOVehicleParameter::parseDepartPosLat(const std::string& val, const std::string& element, const std::string& id,
489 : double& pos, DepartPosLatDefinition& dpd, std::string& error) {
490 : bool ok = true;
491 8969 : pos = 0.;
492 8969 : dpd = DepartPosLatDefinition::GIVEN;
493 8969 : if (val == "random") {
494 6181 : dpd = DepartPosLatDefinition::RANDOM;
495 2788 : } else if (val == "random_free") {
496 448 : dpd = DepartPosLatDefinition::RANDOM_FREE;
497 2340 : } else if (val == "free") {
498 71 : dpd = DepartPosLatDefinition::FREE;
499 2269 : } else if (val == "right") {
500 242 : dpd = DepartPosLatDefinition::RIGHT;
501 2027 : } else if (val == "center") {
502 606 : dpd = DepartPosLatDefinition::CENTER;
503 1421 : } else if (val == "left") {
504 184 : dpd = DepartPosLatDefinition::LEFT;
505 : } else {
506 : try {
507 1237 : pos = StringUtils::toDouble(val);
508 0 : } catch (...) {
509 : ok = false;
510 0 : }
511 : }
512 : if (!ok) {
513 0 : if (id.empty()) {
514 0 : error = "Invalid departPosLat definition for " + element + ". Must be one of (\"random\", \"random_free\", \"free\", \"right\", \"center\", \"left\", or a float)";
515 : } else {
516 0 : error = "Invalid departPosLat definition for " + element + " '" + id + "';\n must be one of (\"random\", \"random_free\", \"free\", \"right\", \"center\", \"left\", or a float)";
517 : }
518 : }
519 8969 : return ok;
520 : }
521 :
522 :
523 : bool
524 310772 : SUMOVehicleParameter::parseDepartSpeed(const std::string& val, const std::string& element, const std::string& id,
525 : double& speed, DepartSpeedDefinition& dsd, std::string& error) {
526 : bool ok = true;
527 310772 : speed = -1.;
528 310772 : dsd = DepartSpeedDefinition::GIVEN;
529 310772 : if (val == "random") {
530 254 : dsd = DepartSpeedDefinition::RANDOM;
531 310518 : } else if (val == "max") {
532 139146 : dsd = DepartSpeedDefinition::MAX;
533 171372 : } else if (val == "desired") {
534 313 : dsd = DepartSpeedDefinition::DESIRED;
535 171059 : } else if (val == "speedLimit") {
536 547 : dsd = DepartSpeedDefinition::LIMIT;
537 170512 : } else if (val == "last") {
538 52 : dsd = DepartSpeedDefinition::LAST;
539 170460 : } else if (val == "avg") {
540 14418 : dsd = DepartSpeedDefinition::AVG;
541 : } else {
542 : try {
543 156042 : speed = StringUtils::toDouble(val);
544 155975 : if (speed < 0) {
545 : ok = false;
546 : }
547 67 : } catch (...) {
548 : ok = false;
549 67 : }
550 : }
551 : if (!ok) {
552 67 : if (id.empty()) {
553 0 : error = "Invalid departSpeed '" + val + "' definition for " + element + ". Must be one of (\"random\", \"max\", or a float>=0)";
554 : } else {
555 201 : error = "Invalid departSpeed definition '" + val + "' for " + element + " '" + id + "';\n must be one of (\"random\", \"max\", or a float>=0)";
556 : }
557 : }
558 310772 : return ok;
559 : }
560 :
561 :
562 : bool
563 412 : SUMOVehicleParameter::parseRouteIndex(const std::string& val, const std::string& element, const std::string& id,
564 : const SumoXMLAttr attr, int& edgeIndex, RouteIndexDefinition& rid, std::string& error) {
565 : bool ok = true;
566 412 : edgeIndex = -1;
567 412 : rid = RouteIndexDefinition::GIVEN;
568 412 : if (val == "random") {
569 63 : rid = RouteIndexDefinition::RANDOM;
570 : } else {
571 : try {
572 349 : edgeIndex = StringUtils::toInt(val);
573 349 : if (edgeIndex < 0) {
574 : ok = false;
575 : }
576 0 : } catch (...) {
577 : ok = false;
578 0 : }
579 : }
580 : if (!ok) {
581 14 : if (id.empty()) {
582 0 : error = "Invalid " + toString(attr) + " definition for " + element + ". Must be one of (\"random\", \"free\", or an int>=0)";
583 : } else {
584 42 : error = "Invalid " + toString(attr) + " definition for " + element + " '" + id + "';\n must be one of (\"random\", \"free\", or an int>=0)";
585 : }
586 : }
587 412 : return ok;
588 : }
589 :
590 :
591 : bool
592 26324 : SUMOVehicleParameter::parseArrivalLane(const std::string& val, const std::string& element, const std::string& id,
593 : int& lane, ArrivalLaneDefinition& ald, std::string& error) {
594 : bool ok = true;
595 26324 : lane = 0;
596 26324 : ald = ArrivalLaneDefinition::GIVEN;
597 26324 : if (val == "current") {
598 23500 : ald = ArrivalLaneDefinition::CURRENT;
599 2824 : } else if (val == "random") {
600 84 : ald = ArrivalLaneDefinition::RANDOM;
601 2740 : } else if (val == "first") {
602 7 : ald = ArrivalLaneDefinition::FIRST_ALLOWED;
603 : } else {
604 : try {
605 2733 : lane = StringUtils::toInt(val);
606 2666 : if (lane < 0) {
607 : ok = false;
608 : }
609 67 : } catch (...) {
610 : ok = false;
611 67 : }
612 : }
613 : if (!ok) {
614 67 : if (id.empty()) {
615 0 : error = "Invalid arrivalLane definition for " + element + ". Must be one of (\"current\", or an int>=0)";
616 : } else {
617 201 : error = "Invalid arrivalLane definition for " + element + " '" + id + "';\n must be one of (\"current\", or an int>=0)";
618 : }
619 : }
620 26324 : return ok;
621 : }
622 :
623 :
624 : bool
625 63453 : SUMOVehicleParameter::parseArrivalPos(const std::string& val, const std::string& element, const std::string& id,
626 : double& pos, ArrivalPosDefinition& apd, std::string& error) {
627 : bool ok = true;
628 63453 : pos = 0.;
629 63453 : apd = ArrivalPosDefinition::GIVEN;
630 63453 : if (val == "random") {
631 1688 : apd = ArrivalPosDefinition::RANDOM;
632 61765 : } else if (val == "center") {
633 0 : apd = ArrivalPosDefinition::CENTER;
634 61765 : } else if (val == "max") {
635 23054 : apd = ArrivalPosDefinition::MAX;
636 : } else {
637 : try {
638 38711 : pos = StringUtils::toDouble(val);
639 67 : } catch (...) {
640 : ok = false;
641 67 : }
642 : }
643 : if (!ok) {
644 67 : if (id.empty()) {
645 0 : error = "Invalid arrivalPos definition for " + element + ". Must be one of (\"random\", \"max\", or a float)";
646 : } else {
647 201 : error = "Invalid arrivalPos definition for " + element + " '" + id + "';\n must be one of (\"random\", \"max\", or a float)";
648 : }
649 : }
650 63453 : return ok;
651 : }
652 :
653 :
654 : bool
655 1072 : SUMOVehicleParameter::parseArrivalPosLat(const std::string& val, const std::string& element, const std::string& id,
656 : double& pos, ArrivalPosLatDefinition& apd, std::string& error) {
657 : bool ok = true;
658 1072 : pos = 0.;
659 1072 : apd = ArrivalPosLatDefinition::GIVEN;
660 1072 : if (val == "right") {
661 496 : apd = ArrivalPosLatDefinition::RIGHT;
662 576 : } else if (val == "center") {
663 9 : apd = ArrivalPosLatDefinition::CENTER;
664 567 : } else if (val == "left") {
665 41 : apd = ArrivalPosLatDefinition::LEFT;
666 : } else {
667 : try {
668 526 : pos = StringUtils::toDouble(val);
669 0 : } catch (...) {
670 : ok = false;
671 0 : }
672 : }
673 : if (!ok) {
674 0 : if (id.empty()) {
675 0 : error = "Invalid arrivalPosLat definition for " + element + ". Must be one of (\"right\", \"center\", \"left\", or a float)";
676 : } else {
677 0 : error = "Invalid arrivalPosLat definition for " + element + " '" + id + "';\n must be one of (\"right\", \"center\", \"left\", or a float)";
678 : }
679 : }
680 1072 : return ok;
681 : }
682 :
683 :
684 : bool
685 26828 : SUMOVehicleParameter::parseArrivalSpeed(const std::string& val, const std::string& element, const std::string& id,
686 : double& speed, ArrivalSpeedDefinition& asd, std::string& error) {
687 : bool ok = true;
688 26828 : speed = -1.;
689 26828 : asd = ArrivalSpeedDefinition::GIVEN;
690 26828 : if (val == "current") {
691 23579 : asd = ArrivalSpeedDefinition::CURRENT;
692 : } else {
693 : try {
694 3249 : speed = StringUtils::toDouble(val);
695 3182 : if (speed < 0) {
696 : ok = false;
697 : }
698 67 : } catch (...) {
699 : ok = false;
700 67 : }
701 : }
702 : if (!ok) {
703 67 : if (id.empty()) {
704 0 : error = "Invalid arrivalSpeed definition for " + element + ". Must be one of (\"current\", or a float>=0)";
705 : } else {
706 201 : error = "Invalid arrivalSpeed definition for " + element + " '" + id + "';\n must be one of (\"current\", or a float>=0)";
707 : }
708 : }
709 26828 : return ok;
710 : }
711 :
712 :
713 : double
714 1499429 : SUMOVehicleParameter::interpretEdgePos(double pos, double maximumValue, SumoXMLAttr attr, const std::string& id, bool silent) {
715 1499429 : if (pos < 0) {
716 28793 : pos = maximumValue + pos;
717 : }
718 1499429 : if (pos > maximumValue && pos != std::numeric_limits<double>::infinity()) {
719 0 : if (!silent) {
720 0 : WRITE_WARNINGF(TL("Invalid % % given for %. Using edge end instead."), toString(attr), toString(pos), id);
721 : }
722 0 : pos = maximumValue;
723 : }
724 1499429 : return pos;
725 : }
726 :
727 :
728 : bool
729 1255 : SUMOVehicleParameter::parsePersonModes(const std::string& modes, const std::string& element, const std::string& id, SVCPermissions& modeSet, std::string& error) {
730 : // separte modes in different strings, and check if modes are valid
731 3967 : for (StringTokenizer st(modes); st.hasNext();) {
732 1457 : const std::string mode = st.next();
733 1457 : if (mode == "car") {
734 537 : modeSet |= SVC_PASSENGER;
735 920 : } else if (mode == "taxi") {
736 226 : modeSet |= SVC_TAXI;
737 694 : } else if (mode == "bicycle") {
738 43 : modeSet |= SVC_BICYCLE;
739 651 : } else if (mode == "public") {
740 651 : modeSet |= SVC_BUS;
741 : } else {
742 0 : if (id.empty()) {
743 0 : error = "Unknown person mode '" + mode + "'. Must be a combination of (\"car\", \"taxi\", \"bicycle\" or \"public\")";
744 : } else {
745 0 : error = "Unknown person mode '" + mode + "' for " + element + " '" + id + "';\n must be a combination of (\"car\", \"taxi\", \"bicycle\" or \"public\")";
746 : }
747 : return false;
748 : }
749 1255 : }
750 1255 : return true;
751 : }
752 :
753 :
754 : void
755 41922 : SUMOVehicleParameter::parseStopTriggers(const std::vector<std::string>& triggers, bool expectTrigger, Stop& stop) {
756 41922 : if (triggers.size() == 0 && expectTrigger) {
757 1074 : stop.triggered = true;
758 : }
759 43589 : for (std::string val : triggers) {
760 1667 : if (val == toString(SUMO_TAG_PERSON)) {
761 1075 : stop.triggered = true;
762 592 : } else if (val == toString(SUMO_TAG_CONTAINER)) {
763 303 : stop.containerTriggered = true;
764 289 : } else if (val == toString(SUMO_ATTR_JOIN)) {
765 128 : stop.joinTriggered = true;
766 : } else {
767 : try {
768 161 : stop.triggered = StringUtils::toBool(val);
769 0 : } catch (BoolFormatException&) {
770 0 : WRITE_ERROR(TL("Value of stop attribute 'trigger' must be 'person', 'container', 'join' or a boolean"));
771 0 : }
772 : }
773 : }
774 41922 : }
775 :
776 :
777 : ParkingType
778 4510 : SUMOVehicleParameter::parseParkingType(const std::string& value) {
779 4510 : if (value == toString(ParkingType::OPPORTUNISTIC)) {
780 : return ParkingType::OPPORTUNISTIC;
781 : } else {
782 4510 : return StringUtils::toBool(value) ? ParkingType::OFFROAD : ParkingType::ONROAD;
783 : }
784 : }
785 :
786 :
787 : std::vector<std::string>
788 2496 : SUMOVehicleParameter::Stop::getTriggers() const {
789 : std::vector<std::string> triggers;
790 2496 : if (triggered) {
791 4624 : triggers.push_back(toString(SUMO_TAG_PERSON));
792 : }
793 2496 : if (containerTriggered) {
794 274 : triggers.push_back(toString(SUMO_TAG_CONTAINER));
795 : }
796 2496 : if (joinTriggered) {
797 64 : triggers.push_back(toString(SUMO_ATTR_JOIN));
798 : }
799 2496 : return triggers;
800 0 : }
801 :
802 : int
803 9728 : SUMOVehicleParameter::Stop::getFlags() const {
804 9728 : return (((parking == ParkingType::OFFROAD) ? 1 : 0) +
805 9728 : (triggered ? 2 : 0) +
806 9728 : (containerTriggered ? 4 : 0) +
807 9728 : (busstop != "" ? 8 : 0) +
808 9728 : (containerstop != "" ? 16 : 0) +
809 9728 : (chargingStation != "" ? 32 : 0) +
810 9728 : (parkingarea != "" ? 64 : 0) +
811 9728 : (overheadWireSegment != "" ? 128 : 0));
812 : }
813 :
814 :
815 : std::string
816 550972 : SUMOVehicleParameter::getDepart() const {
817 550972 : if (departProcedure == DepartDefinition::TRIGGERED) {
818 848 : return "triggered";
819 550124 : } else if (departProcedure == DepartDefinition::CONTAINER_TRIGGERED) {
820 16 : return "containerTriggered";
821 : // } else if (departProcedure == DepartDefinition::NOW) { // TODO check whether this is useful in XML input (currently TraCI only)
822 : // return "now";
823 550108 : } else if (departProcedure == DepartDefinition::SPLIT) {
824 0 : return "split";
825 550108 : } else if (departProcedure == DepartDefinition::BEGIN) {
826 10 : return "begin";
827 : } else {
828 550098 : return time2string(depart);
829 : }
830 : }
831 :
832 :
833 : std::string
834 103876 : SUMOVehicleParameter::getDepartLane() const {
835 : std::string val;
836 103876 : switch (departLaneProcedure) {
837 16109 : case DepartLaneDefinition::GIVEN:
838 16109 : val = toString(departLane);
839 16109 : break;
840 : case DepartLaneDefinition::RANDOM:
841 : val = "random";
842 : break;
843 : case DepartLaneDefinition::FREE:
844 : val = "free";
845 : break;
846 : case DepartLaneDefinition::ALLOWED_FREE:
847 : val = "allowed";
848 : break;
849 : case DepartLaneDefinition::BEST_FREE:
850 : val = "best";
851 : break;
852 : case DepartLaneDefinition::BEST_PROB:
853 : val = "best_prob";
854 : break;
855 : case DepartLaneDefinition::FIRST_ALLOWED:
856 : val = "first";
857 : break;
858 : case DepartLaneDefinition::DEFAULT:
859 : default:
860 : break;
861 : }
862 103876 : return val;
863 : }
864 :
865 :
866 : std::string
867 41050 : SUMOVehicleParameter::getDepartPos() const {
868 : std::string val;
869 41050 : switch (departPosProcedure) {
870 25103 : case DepartPosDefinition::GIVEN:
871 25103 : val = toString(departPos);
872 25103 : break;
873 13269 : case DepartPosDefinition::GIVEN_VEHROUTE:
874 13269 : val = StringUtils::pruneZeros(toString(departPos, MAX2(gPrecisionRandom, gPrecision)), 2);
875 13269 : break;
876 : case DepartPosDefinition::RANDOM:
877 : val = "random";
878 : break;
879 : case DepartPosDefinition::RANDOM_FREE:
880 : val = "random_free";
881 : break;
882 : case DepartPosDefinition::RANDOM_LOCATION:
883 : val = "random_location";
884 : break;
885 : case DepartPosDefinition::FREE:
886 : val = "free";
887 : break;
888 : case DepartPosDefinition::LAST:
889 : val = "last";
890 : break;
891 : case DepartPosDefinition::BASE:
892 : val = "base";
893 : break;
894 : case DepartPosDefinition::SPLIT_FRONT:
895 : val = "splitFront";
896 : break;
897 : case DepartPosDefinition::STOP:
898 : val = "stop";
899 : break;
900 : case DepartPosDefinition::DEFAULT:
901 : default:
902 : break;
903 : }
904 41050 : return val;
905 : }
906 :
907 :
908 : std::string
909 6 : SUMOVehicleParameter::getDepartPosLat() const {
910 : std::string val;
911 6 : switch (departPosLatProcedure) {
912 0 : case DepartPosLatDefinition::GIVEN:
913 0 : val = toString(departPosLat);
914 0 : break;
915 4 : case DepartPosLatDefinition::GIVEN_VEHROUTE:
916 4 : val = StringUtils::pruneZeros(toString(departPosLat, MAX2(gPrecisionRandom, gPrecision)), 2);
917 4 : break;
918 : case DepartPosLatDefinition::RANDOM:
919 : val = "random";
920 : break;
921 : case DepartPosLatDefinition::RANDOM_FREE:
922 : val = "random_free";
923 : break;
924 : case DepartPosLatDefinition::FREE:
925 : val = "free";
926 : break;
927 : case DepartPosLatDefinition::RIGHT:
928 : val = "right";
929 : break;
930 : case DepartPosLatDefinition::CENTER:
931 : val = "center";
932 : break;
933 : case DepartPosLatDefinition::LEFT:
934 : val = "left";
935 : break;
936 : case DepartPosLatDefinition::DEFAULT:
937 : default:
938 : break;
939 : }
940 6 : return val;
941 : }
942 :
943 :
944 : std::string
945 135657 : SUMOVehicleParameter::getDepartSpeed() const {
946 : std::string val;
947 135657 : switch (departSpeedProcedure) {
948 2576 : case DepartSpeedDefinition::GIVEN:
949 2576 : val = toString(departSpeed);
950 2576 : break;
951 45306 : case DepartSpeedDefinition::GIVEN_VEHROUTE:
952 45306 : val = StringUtils::pruneZeros(toString(departSpeed, MAX2(gPrecisionRandom, gPrecision)), 2);
953 45306 : break;
954 : case DepartSpeedDefinition::RANDOM:
955 : val = "random";
956 : break;
957 : case DepartSpeedDefinition::MAX:
958 : val = "max";
959 : break;
960 : case DepartSpeedDefinition::DESIRED:
961 : val = "desired";
962 : break;
963 : case DepartSpeedDefinition::LIMIT:
964 : val = "speedLimit";
965 : break;
966 : case DepartSpeedDefinition::LAST:
967 : val = "last";
968 : break;
969 : case DepartSpeedDefinition::AVG:
970 : val = "avg";
971 : break;
972 : case DepartSpeedDefinition::DEFAULT:
973 : default:
974 : break;
975 : }
976 135657 : return val;
977 : }
978 :
979 :
980 : std::string
981 345 : SUMOVehicleParameter::getDepartEdge() const {
982 : std::string val;
983 345 : switch (departEdgeProcedure) {
984 345 : case RouteIndexDefinition::GIVEN:
985 345 : val = toString(departEdge);
986 345 : break;
987 : case RouteIndexDefinition::RANDOM:
988 : val = "random";
989 : break;
990 : case RouteIndexDefinition::DEFAULT:
991 : default:
992 : break;
993 : }
994 345 : return val;
995 : }
996 :
997 : std::string
998 227 : SUMOVehicleParameter::getArrivalEdge() const {
999 : std::string val;
1000 227 : switch (arrivalEdgeProcedure) {
1001 227 : case RouteIndexDefinition::GIVEN:
1002 227 : val = toString(arrivalEdge);
1003 227 : break;
1004 : case RouteIndexDefinition::RANDOM:
1005 : val = "random";
1006 : break;
1007 : case RouteIndexDefinition::DEFAULT:
1008 : default:
1009 : break;
1010 : }
1011 227 : return val;
1012 : }
1013 :
1014 :
1015 :
1016 :
1017 : std::string
1018 366 : SUMOVehicleParameter::getArrivalLane() const {
1019 : std::string val;
1020 366 : switch (arrivalLaneProcedure) {
1021 196 : case ArrivalLaneDefinition::GIVEN:
1022 196 : val = toString(arrivalLane);
1023 196 : break;
1024 : case ArrivalLaneDefinition::CURRENT:
1025 : val = "current";
1026 : break;
1027 : case ArrivalLaneDefinition::RANDOM:
1028 : val = "random";
1029 : break;
1030 : case ArrivalLaneDefinition::FIRST_ALLOWED:
1031 : val = "first";
1032 : break;
1033 : case ArrivalLaneDefinition::DEFAULT:
1034 : default:
1035 : break;
1036 : }
1037 366 : return val;
1038 : }
1039 :
1040 :
1041 : std::string
1042 4280 : SUMOVehicleParameter::getArrivalPos() const {
1043 : std::string val;
1044 4280 : switch (arrivalPosProcedure) {
1045 3884 : case ArrivalPosDefinition::GIVEN:
1046 3884 : val = toString(arrivalPos);
1047 3884 : break;
1048 : case ArrivalPosDefinition::RANDOM:
1049 : val = "random";
1050 : break;
1051 : case ArrivalPosDefinition::CENTER:
1052 : val = "center";
1053 : break;
1054 : case ArrivalPosDefinition::MAX:
1055 : val = "max";
1056 : break;
1057 : case ArrivalPosDefinition::DEFAULT:
1058 : default:
1059 : break;
1060 : }
1061 4280 : return val;
1062 : }
1063 :
1064 :
1065 : std::string
1066 0 : SUMOVehicleParameter::getArrivalPosLat() const {
1067 : std::string val;
1068 0 : switch (arrivalPosLatProcedure) {
1069 0 : case ArrivalPosLatDefinition::GIVEN:
1070 0 : val = toString(arrivalPosLat);
1071 0 : break;
1072 : case ArrivalPosLatDefinition::RIGHT:
1073 : val = "right";
1074 : break;
1075 : case ArrivalPosLatDefinition::CENTER:
1076 : val = "center";
1077 : break;
1078 : case ArrivalPosLatDefinition::LEFT:
1079 : val = "left";
1080 : break;
1081 : case ArrivalPosLatDefinition::DEFAULT:
1082 : default:
1083 : break;
1084 : }
1085 0 : return val;
1086 : }
1087 :
1088 :
1089 : std::string
1090 3827 : SUMOVehicleParameter::getArrivalSpeed() const {
1091 : std::string val;
1092 3827 : switch (arrivalSpeedProcedure) {
1093 3657 : case ArrivalSpeedDefinition::GIVEN:
1094 3657 : val = toString(arrivalSpeed);
1095 3657 : break;
1096 : case ArrivalSpeedDefinition::CURRENT:
1097 : val = "current";
1098 : break;
1099 : case ArrivalSpeedDefinition::DEFAULT:
1100 : default:
1101 : break;
1102 : }
1103 3827 : return val;
1104 : }
1105 :
1106 :
1107 : void
1108 5445630 : SUMOVehicleParameter::incrementFlow(double scale, SumoRNG* rng) {
1109 5445630 : repetitionsDone++;
1110 : // equidistant or exponential offset (for poisson distributed arrivals)
1111 5445630 : if (repetitionProbability < 0) {
1112 4886667 : if (repetitionOffset >= 0) {
1113 4498372 : repetitionTotalOffset += (SUMOTime)((double)repetitionOffset / scale);
1114 : } else {
1115 : assert(poissonRate > 0);
1116 : // we need to cache this do avoid double generation of the rng in the TIME2STEPS macro
1117 388295 : const double r = RandHelper::randExp(poissonRate, rng);
1118 388295 : repetitionTotalOffset += TIME2STEPS(r / scale);
1119 : }
1120 : }
1121 5445630 : }
1122 :
1123 :
1124 : std::string
1125 0 : SUMOVehicleParameter::getInsertionChecks() const {
1126 0 : if ((insertionChecks == 0) || (insertionChecks == (int)InsertionCheck::ALL)) {
1127 0 : return SUMOXMLDefinitions::InsertionChecks.getString(InsertionCheck::ALL);
1128 : } else {
1129 : std::vector<std::string> insertionChecksStrs;
1130 0 : const auto insertionCheckValues = SUMOXMLDefinitions::InsertionChecks.getValues();
1131 : // iterate over values
1132 0 : for (const auto insertionCheckValue : insertionCheckValues) {
1133 0 : if ((insertionCheckValue != InsertionCheck::ALL) && (insertionChecks & (int)insertionCheckValue) != 0) {
1134 0 : insertionChecksStrs.push_back(SUMOXMLDefinitions::InsertionChecks.getString(insertionCheckValue));
1135 : }
1136 : }
1137 0 : return toString(insertionChecksStrs);
1138 0 : }
1139 : }
1140 :
1141 :
1142 : bool
1143 0 : SUMOVehicleParameter::areInsertionChecksValid(const std::string& value) const {
1144 0 : if (value.empty()) {
1145 : return true;
1146 : } else {
1147 : // split value in substrinsg
1148 0 : StringTokenizer valueStrs(value, " ");
1149 : // iterate over values
1150 0 : while (valueStrs.hasNext()) {
1151 0 : if (!SUMOXMLDefinitions::InsertionChecks.hasString(valueStrs.next())) {
1152 : return false;
1153 : }
1154 : }
1155 : return true;
1156 0 : }
1157 : }
1158 :
1159 :
1160 : int
1161 44549 : SUMOVehicleParameter::parseInsertionChecks(const std::string& value) {
1162 : // first reset insertionChecks
1163 : int result = 0;
1164 44549 : if (value.empty()) {
1165 : return (int)InsertionCheck::ALL;
1166 : } else {
1167 : // split value in substrinsg
1168 133647 : StringTokenizer insertionCheckStrs(value, " ");
1169 91748 : while (insertionCheckStrs.hasNext()) {
1170 47203 : std::string val = insertionCheckStrs.next();
1171 : if (SUMOXMLDefinitions::InsertionChecks.hasString(val)) {
1172 47199 : result |= (int)SUMOXMLDefinitions::InsertionChecks.get(val);
1173 : } else {
1174 16 : throw InvalidArgument("Unknown value '" + val + "' in " + toString(SUMO_ATTR_INSERTIONCHECKS) + ".");
1175 : }
1176 : }
1177 44549 : }
1178 44545 : return result;
1179 : }
1180 :
1181 : /****************************************************************************/
|