Eclipse SUMO - Simulation of Urban MObility
Loading...
Searching...
No Matches
GNEVType.cpp
Go to the documentation of this file.
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/****************************************************************************/
18// Definition of Vehicle Types in netedit
19/****************************************************************************/
20
21#include <netedit/GNENet.h>
22#include <netedit/GNETagProperties.h>
23#include <netedit/GNEUndoList.h>
24#include <netedit/changes/GNEChange_Attribute.h>
25#include <utils/emissions/PollutantsInterface.h>
26#include <utils/xml/NamespaceIDs.h>
27
28#include "GNEVType.h"
29
30// ===========================================================================
31// member method definitions
32// ===========================================================================
33
34GNEVType::GNEVType(SumoXMLTag tag, GNENet* net) :
35 GNEDemandElement(net, tag),
36 SUMOVTypeParameter(""),
37 myDefaultVehicleType(true),
38 myDefaultVehicleTypeModified(false) {
39 // init Rail Visualization Parameters
40 initRailVisualizationParameters();
41}
42
43
44GNEVType::GNEVType(const std::string& vTypeID, GNENet* net, FileBucket* fileBucket, const SUMOVehicleClass& defaultVClass) :
45 GNEDemandElement(vTypeID, net, SUMO_TAG_VTYPE, fileBucket),
46 SUMOVTypeParameter(vTypeID),
47 myDefaultVehicleType(true),
48 myDefaultVehicleTypeModified(false) {
49 // set default vehicle class
50 vehicleClass = defaultVClass;
51 // init Rail Visualization Parameters
52 initRailVisualizationParameters();
53}
54
55
56GNEVType::GNEVType(const std::string& vTypeID, GNENet* net, FileBucket* fileBucket) :
57 GNEDemandElement(vTypeID, net, SUMO_TAG_VTYPE, fileBucket),
58 SUMOVTypeParameter(vTypeID),
59 myDefaultVehicleType(false),
60 myDefaultVehicleTypeModified(false) {
61 // set default vehicle class
62 vehicleClass = SVC_PASSENGER;
63 // init Rail Visualization Parameters
64 initRailVisualizationParameters();
65}
66
67
68GNEVType::GNEVType(const GNEAdditional* calibrator) :
69 GNEDemandElement(calibrator->getNet()->getAttributeCarriers()->generateDemandElementID(SUMO_TAG_VTYPE), calibrator->getNet(),
70 SUMO_TAG_VTYPE, calibrator->getFileBucket()),
71 SUMOVTypeParameter(""),
72 myDefaultVehicleType(false),
73 myDefaultVehicleTypeModified(false) {
74 // init Rail Visualization Parameters
75 initRailVisualizationParameters();
76 id = getID();
77}
78
79
80GNEVType::GNEVType(GNENet* net, FileBucket* fileBucket, const SUMOVTypeParameter& vTypeParameter) :
81 GNEDemandElement(vTypeParameter.id, net, SUMO_TAG_VTYPE, fileBucket),
82 SUMOVTypeParameter(vTypeParameter),
83 myDefaultVehicleType(false),
84 myDefaultVehicleTypeModified(false) {
85 // init Rail Visualization Parameters
86 initRailVisualizationParameters();
87}
88
89
90GNEVType::GNEVType(const std::string& newVTypeID, GNENet* net, GNEVType* vTypeOriginal) :
91 GNEDemandElement(newVTypeID, net, vTypeOriginal->getTagProperty()->getTag(), vTypeOriginal->getFileBucket()),
92 SUMOVTypeParameter(*vTypeOriginal),
93 myDefaultVehicleType(false),
94 myDefaultVehicleTypeModified(false) {
95 // change manually the ID (to avoid to use the ID of vTypeOriginal)
96 id = newVTypeID;
97 // init Rail Visualization Parameters
98 initRailVisualizationParameters();
99}
100
101
102GNEVType::~GNEVType() {}
103
104
105GNEMoveElement*
106GNEVType::getMoveElement() const {
107 return nullptr;
108}
109
110
111Parameterised*
112GNEVType::getParameters() {
113 return this;
114}
115
116
117const Parameterised*
118GNEVType::getParameters() const {
119 return this;
120}
121
122
123void
124GNEVType::writeDemandElement(OutputDevice& device) const {
125 // only write default vehicle types if it was modified
126 if (myDefaultVehicleType) {
127 if (myDefaultVehicleTypeModified) {
128 write(device);
129 }
130 } else {
131 write(device);
132 }
133}
134
135
136GNEDemandElement::Problem
137GNEVType::isDemandElementValid() const {
138 // currently vTypes don't have problems
139 return GNEDemandElement::Problem::OK;
140}
141
142
143std::string
144GNEVType::getDemandElementProblem() const {
145 return "";
146}
147
148
149void
150GNEVType::fixDemandElementProblem() {
151 // nothing to fix
152}
153
154
155SUMOVehicleClass
156GNEVType::getVClass() const {
157 return vehicleClass;
158}
159
160
161const RGBColor&
162GNEVType::getColor() const {
163 return color;
164}
165
166
167void
168GNEVType::updateGeometry() {
169 // update geometry of all childrens
170 for (const auto& i : getChildDemandElements()) {
171 i->updateGeometry();
172 }
173}
174
175
176Position
177GNEVType::getPositionInView() const {
178 return Position();
179}
180
181
182std::string
183GNEVType::getParentName() const {
184 return myNet->getMicrosimID();
185}
186
187
188Boundary
189GNEVType::getCenteringBoundary() const {
190 // Vehicle Types doesn't have boundaries
191 return Boundary(-0.1, -0.1, 0.1, 0.1);
192}
193
194
195void
196GNEVType::splitEdgeGeometry(const double /*splitPosition*/, const GNENetworkElement* /*originalElement*/, const GNENetworkElement* /*newElement*/, GNEUndoList* /*undoList*/) {
197 // geometry of this element cannot be splitted
198}
199
200
201void
202GNEVType::drawGL(const GUIVisualizationSettings&) const {
203 // Vehicle Types aren't draw
204}
205
206
207void
208GNEVType::computePathElement() {
209 // nothing to compute
210}
211
212
213void
214GNEVType::drawLanePartialGL(const GUIVisualizationSettings& /*s*/, const GNESegment* /*segment*/, const double /*offsetFront*/) const {
215 // vehicleTypes don't use drawJunctionPartialGL
216}
217
218
219void
220GNEVType::drawJunctionPartialGL(const GUIVisualizationSettings& /*s*/, const GNESegment* /*segment*/, const double /*offsetFront*/) const {
221 // vehicleTypes don't use drawJunctionPartialGL
222}
223
224
225GNELane*
226GNEVType::getFirstPathLane() const {
227 // vehicle types don't use lanes
228 return nullptr;
229}
230
231
232GNELane*
233GNEVType::getLastPathLane() const {
234 // vehicle types don't use lanes
235 return nullptr;
236}
237
238
239std::string
240GNEVType::getAttribute(SumoXMLAttr key) const {
241 // obtain default values depending of vehicle class
242 VClassDefaultValues defaultValues(vehicleClass);
243 switch (key) {
244 case SUMO_ATTR_ID:
245 return getMicrosimID();
246 // CFM Attributes
247 case SUMO_ATTR_ACCEL:
248 case SUMO_ATTR_DECEL:
249 case SUMO_ATTR_APPARENTDECEL:
250 case SUMO_ATTR_EMERGENCYDECEL:
251 case SUMO_ATTR_SIGMA:
252 case SUMO_ATTR_TAU:
253 // this CFM has default values
254 return getCFParamString(key, myTagProperty->getDefaultStringValue(key));
255 // JM Attributes
256 case SUMO_ATTR_JM_CROSSING_GAP:
257 case SUMO_ATTR_JM_IGNORE_KEEPCLEAR_TIME:
258 case SUMO_ATTR_JM_DRIVE_AFTER_YELLOW_TIME:
259 case SUMO_ATTR_JM_DRIVE_AFTER_RED_TIME:
260 case SUMO_ATTR_JM_DRIVE_RED_SPEED:
261 case SUMO_ATTR_JM_IGNORE_FOE_PROB:
262 case SUMO_ATTR_JM_IGNORE_FOE_SPEED:
263 case SUMO_ATTR_JM_SIGMA_MINOR:
264 case SUMO_ATTR_JM_TIMEGAP_MINOR:
265 // this JM has default values
266 return getJMParamString(key, myTagProperty->getDefaultStringValue(key));
267 case SUMO_ATTR_IMPATIENCE:
268 if (wasSet(VTYPEPARS_IMPATIENCE_SET)) {
269 return toString(impatience);
270 } else {
271 return myTagProperty->getDefaultStringValue(SUMO_ATTR_IMPATIENCE);
272 }
273 // LCM Attributes
274 case SUMO_ATTR_LCA_STRATEGIC_PARAM:
275 case SUMO_ATTR_LCA_COOPERATIVE_PARAM:
276 case SUMO_ATTR_LCA_SPEEDGAIN_PARAM:
277 case SUMO_ATTR_LCA_KEEPRIGHT_PARAM:
278 case SUMO_ATTR_LCA_SUBLANE_PARAM:
279 case SUMO_ATTR_LCA_OPPOSITE_PARAM:
280 case SUMO_ATTR_LCA_PUSHY:
281 case SUMO_ATTR_LCA_PUSHYGAP:
282 case SUMO_ATTR_LCA_ASSERTIVE:
283 case SUMO_ATTR_LCA_IMPATIENCE:
284 case SUMO_ATTR_LCA_TIME_TO_IMPATIENCE:
285 case SUMO_ATTR_LCA_ACCEL_LAT:
286 case SUMO_ATTR_LCA_LOOKAHEADLEFT:
287 case SUMO_ATTR_LCA_SPEEDGAINRIGHT:
288 case SUMO_ATTR_LCA_MAXSPEEDLATSTANDING:
289 case SUMO_ATTR_LCA_MAXSPEEDLATFACTOR:
290 case SUMO_ATTR_LCA_TURN_ALIGNMENT_DISTANCE:
291 case SUMO_ATTR_LCA_OVERTAKE_RIGHT:
292 case SUMO_ATTR_LCA_KEEPRIGHT_ACCEPTANCE_TIME:
293 case SUMO_ATTR_LCA_OVERTAKE_DELTASPEED_FACTOR:
294 /* case SUMO_ATTR_LCA_EXPERIMENTAL1: */
295 return getLCParamString(key, myTagProperty->getDefaultStringValue(key));
296 //
297 case SUMO_ATTR_CF_EIDM_USEVEHDYNAMICS:
298 case SUMO_ATTR_CF_EIDM_MAX_VEH_PREVIEW:
299 case SUMO_ATTR_CF_EIDM_T_LOOK_AHEAD:
300 case SUMO_ATTR_CF_EIDM_T_PERSISTENCE_DRIVE:
301 case SUMO_ATTR_CF_EIDM_T_REACTION:
302 case SUMO_ATTR_CF_EIDM_T_PERSISTENCE_ESTIMATE:
303 case SUMO_ATTR_CF_EIDM_C_COOLNESS:
304 case SUMO_ATTR_CF_EIDM_SIG_LEADER:
305 case SUMO_ATTR_CF_EIDM_SIG_GAP:
306 case SUMO_ATTR_CF_EIDM_SIG_ERROR:
307 case SUMO_ATTR_CF_EIDM_JERK_MAX:
308 case SUMO_ATTR_CF_EIDM_EPSILON_ACC:
309 case SUMO_ATTR_CF_EIDM_T_ACC_MAX:
310 case SUMO_ATTR_CF_EIDM_M_FLATNESS:
311 case SUMO_ATTR_CF_EIDM_M_BEGIN:
312 case SUMO_ATTR_CF_W99_CC1:
313 case SUMO_ATTR_CF_W99_CC2:
314 case SUMO_ATTR_CF_W99_CC3:
315 case SUMO_ATTR_CF_W99_CC4:
316 case SUMO_ATTR_CF_W99_CC5:
317 case SUMO_ATTR_CF_W99_CC6:
318 case SUMO_ATTR_CF_W99_CC7:
319 case SUMO_ATTR_CF_W99_CC8:
320 case SUMO_ATTR_CF_W99_CC9:
321 return getCFParamString(key, myTagProperty->getDefaultStringValue(key));
322 case SUMO_ATTR_COLLISION_MINGAP_FACTOR:
323 case SUMO_ATTR_TMP1:
324 case SUMO_ATTR_TMP2:
325 case SUMO_ATTR_TMP3:
326 case SUMO_ATTR_TMP4:
327 case SUMO_ATTR_TMP5:
328 case SUMO_ATTR_CF_PWAGNER2009_TAULAST:
329 case SUMO_ATTR_CF_PWAGNER2009_APPROB:
330 case SUMO_ATTR_CF_IDMM_ADAPT_FACTOR:
331 case SUMO_ATTR_CF_IDMM_ADAPT_TIME:
332 case SUMO_ATTR_CF_WIEDEMANN_SECURITY:
333 case SUMO_ATTR_CF_WIEDEMANN_ESTIMATION:
334 case SUMO_ATTR_TRAIN_TYPE:
335 case SUMO_ATTR_K:
336 case SUMO_ATTR_CF_KERNER_PHI:
337 case SUMO_ATTR_CF_IDM_DELTA:
338 case SUMO_ATTR_CF_IDM_STEPPING:
339 return getCFParamString(key, "");
340 // Mutable values
341 case SUMO_ATTR_LENGTH:
342 if (wasSet(VTYPEPARS_LENGTH_SET)) {
343 return toString(length);
344 } else {
345 return toString(defaultValues.length);
346 }
347 case SUMO_ATTR_MINGAP:
348 if (wasSet(VTYPEPARS_MINGAP_SET)) {
349 return toString(minGap);
350 } else {
351 return toString(defaultValues.minGap);
352 }
353 case SUMO_ATTR_MAXSPEED:
354 if (wasSet(VTYPEPARS_MAXSPEED_SET)) {
355 return toString(maxSpeed);
356 } else {
357 return toString(defaultValues.maxSpeed);
358 }
359 case SUMO_ATTR_SPEEDFACTOR:
360 if (wasSet(VTYPEPARS_SPEEDFACTOR_SET)) {
361 return toString(speedFactor);
362 } else {
363 return toString(defaultValues.speedFactor);
364 }
365 case SUMO_ATTR_DESIRED_MAXSPEED:
366 if (wasSet(VTYPEPARS_DESIRED_MAXSPEED_SET)) {
367 return toString(desiredMaxSpeed);
368 } else {
369 return toString(defaultValues.desiredMaxSpeed);
370 }
371 case SUMO_ATTR_PARKING_BADGES:
372 if (wasSet(VTYPEPARS_PARKING_BADGES_SET)) {
373 return joinToString(parkingBadges, " ");
374 } else {
375 return "";
376 }
377 case SUMO_ATTR_PERSON_CAPACITY:
378 if (wasSet(VTYPEPARS_PERSON_CAPACITY)) {
379 return toString(personCapacity);
380 } else {
381 return toString(defaultValues.personCapacity);
382 }
383 case SUMO_ATTR_CONTAINER_CAPACITY:
384 if (wasSet(VTYPEPARS_CONTAINER_CAPACITY)) {
385 return toString(containerCapacity);
386 } else {
387 return toString(defaultValues.containerCapacity);
388 }
389 case SUMO_ATTR_OSGFILE:
390 if (wasSet(VTYPEPARS_OSGFILE_SET)) {
391 return osgFile;
392 } else {
393 return defaultValues.osgFile;
394 }
395 case SUMO_ATTR_COLOR:
396 if (wasSet(VTYPEPARS_COLOR_SET)) {
397 return toString(color);
398 } else {
399 return "";
400 }
401 case SUMO_ATTR_VCLASS:
402 if (myDefaultVehicleType || wasSet(VTYPEPARS_VEHICLECLASS_SET)) {
403 return toString(vehicleClass);
404 } else {
405 return myTagProperty->getDefaultStringValue(SUMO_ATTR_VCLASS);
406 }
407 case SUMO_ATTR_EMISSIONCLASS:
408 if (wasSet(VTYPEPARS_EMISSIONCLASS_SET)) {
409 return PollutantsInterface::getName(emissionClass);
410 } else {
411 return PollutantsInterface::getName(defaultValues.emissionClass);
412 }
413 case SUMO_ATTR_GUISHAPE:
414 if (wasSet(VTYPEPARS_SHAPE_SET)) {
415 return getVehicleShapeName(shape);
416 } else {
417 return getVehicleShapeName(defaultValues.shape);
418 }
419 case SUMO_ATTR_WIDTH:
420 if (wasSet(VTYPEPARS_WIDTH_SET)) {
421 return toString(width);
422 } else {
423 return toString(defaultValues.width);
424 }
425 case SUMO_ATTR_HEIGHT:
426 if (wasSet(VTYPEPARS_HEIGHT_SET)) {
427 return toString(height);
428 } else {
429 return toString(defaultValues.height);
430 }
431 case SUMO_ATTR_IMGFILE:
432 if (wasSet(VTYPEPARS_IMGFILE_SET)) {
433 return imgFile;
434 } else {
435 return myTagProperty->getDefaultStringValue(SUMO_ATTR_IMGFILE);
436 }
437 case SUMO_ATTR_LANE_CHANGE_MODEL:
438 if (wasSet(VTYPEPARS_LANE_CHANGE_MODEL_SET)) {
439 return SUMOXMLDefinitions::LaneChangeModels.getString(lcModel);
440 } else {
441 return myTagProperty->getDefaultStringValue(SUMO_ATTR_LANE_CHANGE_MODEL);
442 }
443 case SUMO_ATTR_CAR_FOLLOW_MODEL:
444 if (wasSet(VTYPEPARS_CAR_FOLLOW_MODEL)) {
445 return SUMOXMLDefinitions::CarFollowModels.getString(cfModel);
446 } else {
447 return myTagProperty->getDefaultStringValue(SUMO_ATTR_CAR_FOLLOW_MODEL);
448 }
449 case SUMO_ATTR_BOARDING_DURATION:
450 if (wasSet(VTYPEPARS_BOARDING_DURATION)) {
451 return time2string(boardingDuration);
452 } else {
453 return myTagProperty->getDefaultStringValue(SUMO_ATTR_BOARDING_DURATION);
454 }
455 case SUMO_ATTR_LOADING_DURATION:
456 if (wasSet(VTYPEPARS_LOADING_DURATION)) {
457 return time2string(loadingDuration);
458 } else {
459 return myTagProperty->getDefaultStringValue(SUMO_ATTR_LOADING_DURATION);
460 }
461 case SUMO_ATTR_LATALIGNMENT:
462 if (wasSet(VTYPEPARS_LATALIGNMENT_SET)) {
463 if (latAlignmentProcedure != LatAlignmentDefinition::GIVEN) {
464 return toString(latAlignmentProcedure);
465 } else {
466 return toString(latAlignmentOffset);
467 }
468 } else {
469 return toString(defaultValues.latAlignmentProcedure);
470 }
471 case SUMO_ATTR_MINGAP_LAT:
472 if (wasSet(VTYPEPARS_MINGAP_LAT_SET)) {
473 return toString(minGapLat);
474 } else {
475 return myTagProperty->getDefaultStringValue(SUMO_ATTR_MINGAP_LAT);
476 }
477 case SUMO_ATTR_MAXSPEED_LAT:
478 if (wasSet(VTYPEPARS_MAXSPEED_LAT_SET)) {
479 return toString(maxSpeedLat);
480 } else {
481 return myTagProperty->getDefaultStringValue(SUMO_ATTR_MAXSPEED_LAT);
482 }
483 case SUMO_ATTR_ACTIONSTEPLENGTH:
484 if (wasSet(VTYPEPARS_ACTIONSTEPLENGTH_SET)) {
485 return time2string(actionStepLength);
486 } else {
487 return myTagProperty->getDefaultStringValue(SUMO_ATTR_ACTIONSTEPLENGTH);
488 }
489 case SUMO_ATTR_PROB:
490 if (wasSet(VTYPEPARS_PROBABILITY_SET)) {
491 return toString(defaultProbability);
492 } else {
493 return myTagProperty->getDefaultStringValue(SUMO_ATTR_PROB);
494 }
495 case SUMO_ATTR_CARRIAGE_LENGTH:
496 if (wasSet(VTYPEPARS_CARRIAGE_LENGTH_SET)) {
497 return toString(carriageLength);
498 } else {
499 return toString(defaultValues.carriageLength);
500 }
501 case SUMO_ATTR_LOCOMOTIVE_LENGTH:
502 if (wasSet(VTYPEPARS_LOCOMOTIVE_LENGTH_SET)) {
503 return toString(locomotiveLength);
504 } else {
505 return toString(defaultValues.locomotiveLength);
506 }
507 case SUMO_ATTR_CARRIAGE_GAP:
508 if (wasSet(VTYPEPARS_CARRIAGE_GAP_SET)) {
509 return toString(carriageGap);
510 } else {
511 return myTagProperty->getDefaultStringValue(SUMO_ATTR_CARRIAGE_GAP);
512 }
513 // other
514 case GNE_ATTR_DEFAULT_VTYPE:
515 return myDefaultVehicleType ? TRUE_STR : FALSE_STR;
516 case GNE_ATTR_DEFAULT_VTYPE_MODIFIED:
517 if (myDefaultVehicleType) {
518 return myDefaultVehicleTypeModified ? TRUE_STR : FALSE_STR;
519 } else {
520 return FALSE_STR;
521 }
522 default:
523 return getCommonAttribute(key);
524 }
525}
526
527
528double
529GNEVType::getAttributeDouble(SumoXMLAttr key) const {
530 // obtain default values depending of vehicle class
531 VClassDefaultValues defaultValues(vehicleClass);
532 switch (key) {
533 case SUMO_ATTR_LENGTH:
534 if (wasSet(VTYPEPARS_LENGTH_SET)) {
535 return length;
536 } else {
537 return defaultValues.length;
538 }
539 case SUMO_ATTR_MINGAP:
540 if (wasSet(VTYPEPARS_MINGAP_SET)) {
541 return minGap;
542 } else {
543 return defaultValues.minGap;
544 }
545 case SUMO_ATTR_WIDTH:
546 if (wasSet(VTYPEPARS_WIDTH_SET)) {
547 return width;
548 } else {
549 return defaultValues.width;
550 }
551 case SUMO_ATTR_HEIGHT:
552 if (wasSet(VTYPEPARS_HEIGHT_SET)) {
553 return height;
554 } else {
555 return defaultValues.height;
556 }
557 case SUMO_ATTR_MAXSPEED:
558 if (wasSet(VTYPEPARS_MAXSPEED_SET)) {
559 return maxSpeed;
560 } else {
561 return defaultValues.maxSpeed;
562 }
563 case SUMO_ATTR_PROB:
564 if (wasSet(VTYPEPARS_PROBABILITY_SET)) {
565 return defaultProbability;
566 } else {
567 return parse<double>(myTagProperty->getDefaultStringValue(SUMO_ATTR_PROB));
568 }
569 default:
570 return getCommonAttributeDouble(key);
571 }
572}
573
574
575Position
579
580
581void
582GNEVType::setAttribute(SumoXMLAttr key, const std::string& value, GNEUndoList* undoList) {
583 if (value == getAttribute(key)) {
584 return; //avoid needless changes, later logic relies on the fact that attributes have changed
585 }
586 switch (key) {
587 case SUMO_ATTR_ID:
588 GNEChange_Attribute::changeAttribute(this, key, value, undoList);
589 break;
590 // CFM Attributes
591 case SUMO_ATTR_ACCEL:
592 case SUMO_ATTR_DECEL:
593 case SUMO_ATTR_APPARENTDECEL:
594 case SUMO_ATTR_EMERGENCYDECEL:
595 case SUMO_ATTR_SIGMA:
596 case SUMO_ATTR_TAU:
597 case SUMO_ATTR_COLLISION_MINGAP_FACTOR:
598 case SUMO_ATTR_TMP1:
599 case SUMO_ATTR_TMP2:
600 case SUMO_ATTR_TMP3:
601 case SUMO_ATTR_TMP4:
602 case SUMO_ATTR_TMP5:
603 case SUMO_ATTR_CF_EIDM_USEVEHDYNAMICS:
604 case SUMO_ATTR_CF_EIDM_MAX_VEH_PREVIEW:
605 case SUMO_ATTR_CF_EIDM_T_LOOK_AHEAD:
606 case SUMO_ATTR_CF_EIDM_T_PERSISTENCE_DRIVE:
607 case SUMO_ATTR_CF_EIDM_T_REACTION:
608 case SUMO_ATTR_CF_EIDM_T_PERSISTENCE_ESTIMATE:
609 case SUMO_ATTR_CF_EIDM_C_COOLNESS:
610 case SUMO_ATTR_CF_EIDM_SIG_LEADER:
611 case SUMO_ATTR_CF_EIDM_SIG_GAP:
612 case SUMO_ATTR_CF_EIDM_SIG_ERROR:
613 case SUMO_ATTR_CF_EIDM_JERK_MAX:
614 case SUMO_ATTR_CF_EIDM_EPSILON_ACC:
615 case SUMO_ATTR_CF_EIDM_T_ACC_MAX:
616 case SUMO_ATTR_CF_EIDM_M_FLATNESS:
617 case SUMO_ATTR_CF_EIDM_M_BEGIN:
618 case SUMO_ATTR_CF_PWAGNER2009_TAULAST:
619 case SUMO_ATTR_CF_PWAGNER2009_APPROB:
620 case SUMO_ATTR_CF_IDMM_ADAPT_FACTOR:
621 case SUMO_ATTR_CF_IDMM_ADAPT_TIME:
622 case SUMO_ATTR_CF_WIEDEMANN_SECURITY:
623 case SUMO_ATTR_CF_WIEDEMANN_ESTIMATION:
624 case SUMO_ATTR_TRAIN_TYPE:
625 case SUMO_ATTR_K:
626 case SUMO_ATTR_CF_KERNER_PHI:
627 case SUMO_ATTR_CF_IDM_DELTA:
628 case SUMO_ATTR_CF_IDM_STEPPING:
629 case SUMO_ATTR_CF_W99_CC1:
630 case SUMO_ATTR_CF_W99_CC2:
631 case SUMO_ATTR_CF_W99_CC3:
632 case SUMO_ATTR_CF_W99_CC4:
633 case SUMO_ATTR_CF_W99_CC5:
634 case SUMO_ATTR_CF_W99_CC6:
635 case SUMO_ATTR_CF_W99_CC7:
636 case SUMO_ATTR_CF_W99_CC8:
637 case SUMO_ATTR_CF_W99_CC9:
638 // JM Attributes
639 case SUMO_ATTR_JM_CROSSING_GAP:
640 case SUMO_ATTR_JM_IGNORE_KEEPCLEAR_TIME:
641 case SUMO_ATTR_JM_DRIVE_AFTER_YELLOW_TIME:
642 case SUMO_ATTR_JM_DRIVE_AFTER_RED_TIME:
643 case SUMO_ATTR_JM_DRIVE_RED_SPEED:
644 case SUMO_ATTR_JM_IGNORE_FOE_PROB:
645 case SUMO_ATTR_JM_IGNORE_FOE_SPEED:
646 case SUMO_ATTR_JM_SIGMA_MINOR:
647 case SUMO_ATTR_JM_TIMEGAP_MINOR:
648 case SUMO_ATTR_IMPATIENCE:
649 // LCM Attributes
650 case SUMO_ATTR_LCA_STRATEGIC_PARAM:
651 case SUMO_ATTR_LCA_COOPERATIVE_PARAM:
652 case SUMO_ATTR_LCA_SPEEDGAIN_PARAM:
653 case SUMO_ATTR_LCA_KEEPRIGHT_PARAM:
654 case SUMO_ATTR_LCA_SUBLANE_PARAM:
655 case SUMO_ATTR_LCA_OPPOSITE_PARAM:
656 case SUMO_ATTR_LCA_PUSHY:
657 case SUMO_ATTR_LCA_PUSHYGAP:
658 case SUMO_ATTR_LCA_ASSERTIVE:
659 case SUMO_ATTR_LCA_IMPATIENCE:
660 case SUMO_ATTR_LCA_TIME_TO_IMPATIENCE:
661 case SUMO_ATTR_LCA_ACCEL_LAT:
662 case SUMO_ATTR_LCA_LOOKAHEADLEFT:
663 case SUMO_ATTR_LCA_SPEEDGAINRIGHT:
664 case SUMO_ATTR_LCA_MAXSPEEDLATSTANDING:
665 case SUMO_ATTR_LCA_MAXSPEEDLATFACTOR:
666 case SUMO_ATTR_LCA_TURN_ALIGNMENT_DISTANCE:
667 case SUMO_ATTR_LCA_OVERTAKE_RIGHT:
668 case SUMO_ATTR_LCA_KEEPRIGHT_ACCEPTANCE_TIME:
669 case SUMO_ATTR_LCA_OVERTAKE_DELTASPEED_FACTOR:
670 /* case SUMO_ATTR_LCA_EXPERIMENTAL1: */
671 //
672 case SUMO_ATTR_LENGTH:
673 case SUMO_ATTR_MINGAP:
674 case SUMO_ATTR_MAXSPEED:
675 case SUMO_ATTR_SPEEDFACTOR:
676 case SUMO_ATTR_DESIRED_MAXSPEED:
677 case SUMO_ATTR_COLOR:
678 case SUMO_ATTR_VCLASS:
679 case SUMO_ATTR_EMISSIONCLASS:
680 case SUMO_ATTR_GUISHAPE:
681 case SUMO_ATTR_WIDTH:
682 case SUMO_ATTR_HEIGHT:
683 case SUMO_ATTR_IMGFILE:
684 case SUMO_ATTR_LANE_CHANGE_MODEL:
685 case SUMO_ATTR_CAR_FOLLOW_MODEL:
686 case SUMO_ATTR_PERSON_CAPACITY:
687 case SUMO_ATTR_CONTAINER_CAPACITY:
688 case SUMO_ATTR_BOARDING_DURATION:
689 case SUMO_ATTR_LOADING_DURATION:
690 case SUMO_ATTR_LATALIGNMENT:
691 case SUMO_ATTR_MINGAP_LAT:
692 case SUMO_ATTR_MAXSPEED_LAT:
693 case SUMO_ATTR_ACTIONSTEPLENGTH:
694 case SUMO_ATTR_PROB:
695 case SUMO_ATTR_OSGFILE:
696 case SUMO_ATTR_CARRIAGE_LENGTH:
697 case SUMO_ATTR_LOCOMOTIVE_LENGTH:
698 case SUMO_ATTR_CARRIAGE_GAP:
699 // if we change the original value of a default vehicle Type, change also flag "myDefaultVehicleType"
700 if (myDefaultVehicleType) {
701 GNEChange_Attribute::changeAttribute(this, GNE_ATTR_DEFAULT_VTYPE_MODIFIED, "true", undoList, true);
702 }
703 GNEChange_Attribute::changeAttribute(this, key, value, undoList, true);
704 break;
705 case GNE_ATTR_DEFAULT_VTYPE_MODIFIED:
706 GNEChange_Attribute::changeAttribute(this, GNE_ATTR_DEFAULT_VTYPE_MODIFIED, value, undoList, true);
707 break;
708 default:
709 setCommonAttribute(key, value, undoList);
710 break;
711 }
712}
713
714
715bool
716GNEVType::isValid(SumoXMLAttr key, const std::string& value) {
717 // a empty value is always valid except for IDs
718 if ((key != SUMO_ATTR_ID) && value.empty()) {
719 return true;
720 }
721 switch (key) {
722 case SUMO_ATTR_ID:
723 return isValidDemandElementID(NamespaceIDs::types, value);
724 // CFM Attributes
725 case SUMO_ATTR_SIGMA:
726 return canParse<double>(value) && (parse<double>(value) >= 0) && (parse<double>(value) <= 1);
727 case SUMO_ATTR_ACCEL:
728 case SUMO_ATTR_DECEL:
729 case SUMO_ATTR_APPARENTDECEL:
730 case SUMO_ATTR_EMERGENCYDECEL:
731 case SUMO_ATTR_TAU:
732 case SUMO_ATTR_COLLISION_MINGAP_FACTOR:
733 case SUMO_ATTR_TMP1:
734 case SUMO_ATTR_TMP2:
735 case SUMO_ATTR_TMP3:
736 case SUMO_ATTR_TMP4:
737 case SUMO_ATTR_TMP5:
738 case SUMO_ATTR_CF_PWAGNER2009_TAULAST:
739 case SUMO_ATTR_CF_PWAGNER2009_APPROB:
740 case SUMO_ATTR_CF_IDMM_ADAPT_FACTOR:
741 case SUMO_ATTR_CF_IDMM_ADAPT_TIME:
742 case SUMO_ATTR_CF_WIEDEMANN_SECURITY:
743 case SUMO_ATTR_CF_WIEDEMANN_ESTIMATION:
744 case SUMO_ATTR_K:
745 case SUMO_ATTR_CF_KERNER_PHI:
746 case SUMO_ATTR_CF_IDM_DELTA:
747 case SUMO_ATTR_CF_IDM_STEPPING:
748 case SUMO_ATTR_CF_W99_CC1:
749 case SUMO_ATTR_CF_W99_CC2:
750 case SUMO_ATTR_CF_W99_CC3:
751 case SUMO_ATTR_CF_W99_CC4:
752 case SUMO_ATTR_CF_W99_CC5:
753 case SUMO_ATTR_CF_W99_CC6:
754 case SUMO_ATTR_CF_W99_CC7:
755 case SUMO_ATTR_CF_W99_CC8:
756 case SUMO_ATTR_CF_W99_CC9:
757 return canParse<double>(value);
758 case SUMO_ATTR_CF_EIDM_USEVEHDYNAMICS:
759 return canParse<bool>(value);
760 case SUMO_ATTR_CF_EIDM_MAX_VEH_PREVIEW:
761 return canParse<int>(value) && (parse<int>(value) >= 0);
762 case SUMO_ATTR_CF_EIDM_T_LOOK_AHEAD:
763 return canParse<double>(value) && (parse<double>(value) >= 1);
764 case SUMO_ATTR_CF_EIDM_T_PERSISTENCE_DRIVE:
765 return canParse<double>(value) && (parse<double>(value) >= 1);
766 case SUMO_ATTR_CF_EIDM_T_REACTION:
767 return canParse<double>(value) && (parse<double>(value) >= 0);
768 case SUMO_ATTR_CF_EIDM_T_PERSISTENCE_ESTIMATE:
769 return canParse<double>(value) && (parse<double>(value) >= 1);
770 case SUMO_ATTR_CF_EIDM_C_COOLNESS:
771 return canParse<double>(value) && (parse<double>(value) >= 0) && (parse<double>(value) <= 1);
772 case SUMO_ATTR_CF_EIDM_SIG_LEADER:
773 return canParse<double>(value) && (parse<double>(value) >= 0) && (parse<double>(value) <= 1);
774 case SUMO_ATTR_CF_EIDM_SIG_GAP:
775 return canParse<double>(value) && (parse<double>(value) >= 0) && (parse<double>(value) <= 1);
776 case SUMO_ATTR_CF_EIDM_SIG_ERROR:
777 return canParse<double>(value) && (parse<double>(value) >= 0) && (parse<double>(value) <= 1);
778 case SUMO_ATTR_CF_EIDM_JERK_MAX:
779 return canParse<double>(value) && (parse<double>(value) >= 1);
780 case SUMO_ATTR_CF_EIDM_EPSILON_ACC:
781 return canParse<double>(value) && (parse<double>(value) >= 0);
782 case SUMO_ATTR_CF_EIDM_T_ACC_MAX:
783 return canParse<double>(value) && (parse<double>(value) >= 0);
784 case SUMO_ATTR_CF_EIDM_M_FLATNESS:
785 return canParse<double>(value) && (parse<double>(value) >= 1) && (parse<double>(value) <= 5);
786 case SUMO_ATTR_CF_EIDM_M_BEGIN:
787 return canParse<double>(value) && (parse<double>(value) >= 0) && (parse<double>(value) <= 1.5);
788 case SUMO_ATTR_TRAIN_TYPE:
789 // rail string
790 return SUMOXMLDefinitions::TrainTypes.hasString(value);
791 // JM Attributes
792 case SUMO_ATTR_JM_CROSSING_GAP:
793 return canParse<double>(value) && (parse<double>(value) >= 0);
794 case SUMO_ATTR_JM_IGNORE_KEEPCLEAR_TIME:
795 return canParse<double>(value) && (parse<double>(value) >= -1);
796 case SUMO_ATTR_JM_DRIVE_AFTER_YELLOW_TIME:
797 return canParse<double>(value) && (parse<double>(value) >= -1);
798 case SUMO_ATTR_JM_DRIVE_AFTER_RED_TIME:
799 return canParse<double>(value) && (parse<double>(value) >= -1);
800 case SUMO_ATTR_JM_DRIVE_RED_SPEED:
801 return canParse<double>(value) && (parse<double>(value) >= 0);
802 case SUMO_ATTR_JM_IGNORE_FOE_PROB:
803 return canParse<double>(value) && (parse<double>(value) >= 0);
804 case SUMO_ATTR_JM_IGNORE_FOE_SPEED:
805 return canParse<double>(value) && (parse<double>(value) >= 0);
806 case SUMO_ATTR_JM_SIGMA_MINOR:
807 return canParse<double>(value) && (parse<double>(value) >= 0) && (parse<double>(value) <= 1);
808 case SUMO_ATTR_JM_TIMEGAP_MINOR:
809 return canParse<double>(value) && (parse<double>(value) >= 0);
810 case SUMO_ATTR_IMPATIENCE:
811 return canParse<double>(value) && (parse<double>(value) >= 0);
812 // LCM Attributes
813 case SUMO_ATTR_LCA_STRATEGIC_PARAM:
814 case SUMO_ATTR_LCA_COOPERATIVE_PARAM:
815 case SUMO_ATTR_LCA_SPEEDGAIN_PARAM:
816 case SUMO_ATTR_LCA_KEEPRIGHT_PARAM:
817 case SUMO_ATTR_LCA_SUBLANE_PARAM:
818 case SUMO_ATTR_LCA_OPPOSITE_PARAM:
819 case SUMO_ATTR_LCA_PUSHY:
820 return canParse<double>(value);
821 case SUMO_ATTR_LCA_PUSHYGAP:
822 case SUMO_ATTR_LCA_IMPATIENCE:
823 case SUMO_ATTR_LCA_MAXSPEEDLATSTANDING:
824 case SUMO_ATTR_LCA_TURN_ALIGNMENT_DISTANCE: // 0 mean disabled
825 case SUMO_ATTR_LCA_TIME_TO_IMPATIENCE: // 0 mean disabled
826 case SUMO_ATTR_LCA_OVERTAKE_RIGHT: // 0 mean disabled
827 return canParse<double>(value) && (parse<double>(value) >= 0);
828 case SUMO_ATTR_LCA_ASSERTIVE:
829 case SUMO_ATTR_LCA_LOOKAHEADLEFT:
830 case SUMO_ATTR_LCA_SPEEDGAINRIGHT:
831 case SUMO_ATTR_LCA_ACCEL_LAT:
832 case SUMO_ATTR_LCA_MAXSPEEDLATFACTOR:
833 return canParse<double>(value) && (parse<double>(value) > 0);
834 case SUMO_ATTR_LCA_KEEPRIGHT_ACCEPTANCE_TIME:
835 return canParse<double>(value) && (parse<double>(value) >= 0 || parse<double>(value) == -1);
836 case SUMO_ATTR_LCA_OVERTAKE_DELTASPEED_FACTOR:
837 return canParse<double>(value) && (parse<double>(value) >= -1) && (parse<double>(value) <= 1);
838 /* case SUMO_ATTR_LCA_EXPERIMENTAL1:
839 return true;
840 */
841 //
842 case SUMO_ATTR_LENGTH:
843 return canParse<double>(value) && (parse<double>(value) > 0);
844 case SUMO_ATTR_MINGAP:
845 return canParse<double>(value) && (parse<double>(value) >= 0);
846 case SUMO_ATTR_MAXSPEED:
847 return canParse<double>(value) && (parse<double>(value) >= 0);
848 case SUMO_ATTR_SPEEDFACTOR:
849 return Distribution_Parameterized::isValidDescription(value);
850 case SUMO_ATTR_DESIRED_MAXSPEED:
851 return canParse<double>(value) && (parse<double>(value) >= 0);
852 case SUMO_ATTR_COLOR:
853 if (value.empty()) {
854 return true;
855 } else {
856 return canParse<RGBColor>(value);
857 }
858 case SUMO_ATTR_VCLASS:
859 return canParseVehicleClasses(value);
860 case SUMO_ATTR_EMISSIONCLASS:
861 // check if given value correspond to a string of PollutantsInterface::getAllClassesStr()
862 for (const auto& eClass : PollutantsInterface::getAllClassesStr()) {
863 if (value == eClass) {
864 return true;
865 }
866 }
867 return false;
868 case SUMO_ATTR_GUISHAPE:
869 if (value.empty() || (value == "default")) {
870 return true;
871 } else {
872 return canParseVehicleShape(value);
873 }
874 case SUMO_ATTR_WIDTH:
875 return canParse<double>(value);
876 case SUMO_ATTR_HEIGHT:
877 return canParse<double>(value);
878 case SUMO_ATTR_IMGFILE:
879 return SUMOXMLDefinitions::isValidFilename(value);
880 case SUMO_ATTR_LANE_CHANGE_MODEL:
881 return SUMOXMLDefinitions::LaneChangeModels.hasString(value);
882 case SUMO_ATTR_CAR_FOLLOW_MODEL:
883 return SUMOXMLDefinitions::CarFollowModels.hasString(value);
884 case SUMO_ATTR_PERSON_CAPACITY:
885 return canParse<int>(value);
886 case SUMO_ATTR_CONTAINER_CAPACITY:
887 return canParse<int>(value);
888 case SUMO_ATTR_BOARDING_DURATION:
889 return canParse<SUMOTime>(value) && (parse<SUMOTime>(value) >= 0);
890 case SUMO_ATTR_LOADING_DURATION:
891 return canParse<SUMOTime>(value) && (parse<SUMOTime>(value) >= 0);
892 case SUMO_ATTR_LATALIGNMENT:
893 return SUMOVTypeParameter::isValidLatAlignment(value);
894 case SUMO_ATTR_MINGAP_LAT:
895 return canParse<double>(value);
896 case SUMO_ATTR_MAXSPEED_LAT:
897 return canParse<double>(value);
898 case SUMO_ATTR_ACTIONSTEPLENGTH:
899 return canParse<SUMOTime>(value) && (parse<SUMOTime>(value) >= 0);
900 case SUMO_ATTR_PROB:
901 return canParse<double>(value) && (parse<double>(value) >= 0);
902 case SUMO_ATTR_OSGFILE:
903 return SUMOXMLDefinitions::isValidFilename(value);
904 case SUMO_ATTR_CARRIAGE_LENGTH:
905 return canParse<double>(value) && (parse<double>(value) >= -1);
906 case SUMO_ATTR_LOCOMOTIVE_LENGTH:
907 return canParse<double>(value) && (parse<double>(value) >= -1);
908 case SUMO_ATTR_CARRIAGE_GAP:
909 return canParse<double>(value) && (parse<double>(value) >= 0);
910 case GNE_ATTR_DEFAULT_VTYPE_MODIFIED:
911 if (myDefaultVehicleType) {
912 return canParse<bool>(value);
913 } else {
914 return false;
915 }
916 default:
917 return isCommonAttributeValid(key, value);
918 }
919}
920
921
922bool
923GNEVType::isAttributeEnabled(SumoXMLAttr key) const {
924 switch (key) {
925 case SUMO_ATTR_ID:
926 if (id == DEFAULT_VTYPE_ID
927 || id == DEFAULT_PEDTYPE_ID
928 || id == DEFAULT_BIKETYPE_ID
929 || id == DEFAULT_TAXITYPE_ID
930 || id == DEFAULT_RAILTYPE_ID) {
931 return false;
932 } else {
933 return true;
934 }
935 case SUMO_ATTR_LENGTH:
936 return wasSet(VTYPEPARS_LENGTH_SET);
937 case SUMO_ATTR_MINGAP:
938 return wasSet(VTYPEPARS_MINGAP_SET);
939 case SUMO_ATTR_MAXSPEED:
940 return wasSet(VTYPEPARS_MAXSPEED_SET);
941 case SUMO_ATTR_SPEEDFACTOR:
942 return wasSet(VTYPEPARS_SPEEDFACTOR_SET);
943 case SUMO_ATTR_DESIRED_MAXSPEED:
944 return wasSet(VTYPEPARS_DESIRED_MAXSPEED_SET);
945 case SUMO_ATTR_PERSON_CAPACITY:
946 return wasSet(VTYPEPARS_PERSON_CAPACITY);
947 case SUMO_ATTR_CONTAINER_CAPACITY:
948 return wasSet(VTYPEPARS_CONTAINER_CAPACITY);
949 case SUMO_ATTR_OSGFILE:
950 return wasSet(VTYPEPARS_OSGFILE_SET);
951 case SUMO_ATTR_CARRIAGE_LENGTH:
952 return wasSet(VTYPEPARS_CARRIAGE_LENGTH_SET);
953 case SUMO_ATTR_LOCOMOTIVE_LENGTH:
954 return wasSet(VTYPEPARS_LOCOMOTIVE_LENGTH_SET);
955 case SUMO_ATTR_CARRIAGE_GAP:
956 return wasSet(VTYPEPARS_CARRIAGE_GAP_SET);
957 default:
958 return true;
959 }
960}
961
962
963std::string
964GNEVType::getPopUpID() const {
965 return getTagStr();
966}
967
968
969std::string
970GNEVType::getHierarchyName() const {
971 return getTagStr() + ": " + getAttribute(SUMO_ATTR_ID) ;
972}
973
974
975bool
976GNEVType::overwriteVType(GNEDemandElement* vType, const SUMOVTypeParameter newVTypeParameter, GNEUndoList* undoList) {
977 // open undo list and overwrite all values of default VType
978 undoList->begin(vType, "update default " + vType->getTagStr() + " '" + DEFAULT_VTYPE_ID + "'");
979 // CFM values
980 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_ACCEL, "").empty()) {
981 vType->setAttribute(SUMO_ATTR_ACCEL, toString(newVTypeParameter.getCFParam(SUMO_ATTR_ACCEL, 0)), undoList);
982 }
983 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_DECEL, "").empty()) {
984 vType->setAttribute(SUMO_ATTR_DECEL, toString(newVTypeParameter.getCFParam(SUMO_ATTR_DECEL, 0)), undoList);
985 }
986 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_APPARENTDECEL, "").empty()) {
987 vType->setAttribute(SUMO_ATTR_APPARENTDECEL, toString(newVTypeParameter.getCFParam(SUMO_ATTR_APPARENTDECEL, 0)), undoList);
988 }
989 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_EMERGENCYDECEL, "").empty()) {
990 vType->setAttribute(SUMO_ATTR_EMERGENCYDECEL, toString(newVTypeParameter.getCFParam(SUMO_ATTR_EMERGENCYDECEL, 0)), undoList);
991 }
992 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_SIGMA, "").empty()) {
993 vType->setAttribute(SUMO_ATTR_SIGMA, toString(newVTypeParameter.getCFParam(SUMO_ATTR_SIGMA, 0)), undoList);
994 }
995 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_TAU, "").empty()) {
996 vType->setAttribute(SUMO_ATTR_TAU, toString(newVTypeParameter.getCFParam(SUMO_ATTR_TAU, 0)), undoList);
997 }
998 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_COLLISION_MINGAP_FACTOR, "").empty()) {
999 vType->setAttribute(SUMO_ATTR_COLLISION_MINGAP_FACTOR, toString(newVTypeParameter.getCFParam(SUMO_ATTR_COLLISION_MINGAP_FACTOR, 0)), undoList);
1000 }
1001 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_TMP1, "").empty()) {
1002 vType->setAttribute(SUMO_ATTR_TMP1, toString(newVTypeParameter.getCFParam(SUMO_ATTR_TMP1, 0)), undoList);
1003 }
1004 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_TMP2, "").empty()) {
1005 vType->setAttribute(SUMO_ATTR_TMP2, toString(newVTypeParameter.getCFParam(SUMO_ATTR_TMP2, 0)), undoList);
1006 }
1007 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_TMP3, "").empty()) {
1008 vType->setAttribute(SUMO_ATTR_TMP3, toString(newVTypeParameter.getCFParam(SUMO_ATTR_TMP3, 0)), undoList);
1009 }
1010 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_TMP4, "").empty()) {
1011 vType->setAttribute(SUMO_ATTR_TMP4, toString(newVTypeParameter.getCFParam(SUMO_ATTR_TMP4, 0)), undoList);
1012 }
1013 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_TMP5, "").empty()) {
1014 vType->setAttribute(SUMO_ATTR_TMP5, toString(newVTypeParameter.getCFParam(SUMO_ATTR_TMP5, 0)), undoList);
1015 }
1016 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_USEVEHDYNAMICS, "").empty()) {
1017 vType->setAttribute(SUMO_ATTR_CF_EIDM_USEVEHDYNAMICS, toString(newVTypeParameter.getCFParam(SUMO_ATTR_CF_EIDM_USEVEHDYNAMICS, 0)), undoList);
1018 }
1019 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_MAX_VEH_PREVIEW, "").empty()) {
1020 vType->setAttribute(SUMO_ATTR_CF_EIDM_MAX_VEH_PREVIEW, toString(newVTypeParameter.getCFParam(SUMO_ATTR_CF_EIDM_MAX_VEH_PREVIEW, 0)), undoList);
1021 }
1022 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_T_LOOK_AHEAD, "").empty()) {
1023 vType->setAttribute(SUMO_ATTR_CF_EIDM_T_LOOK_AHEAD, toString(newVTypeParameter.getCFParam(SUMO_ATTR_CF_EIDM_T_LOOK_AHEAD, 0)), undoList);
1024 }
1025 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_T_PERSISTENCE_DRIVE, "").empty()) {
1026 vType->setAttribute(SUMO_ATTR_CF_EIDM_T_PERSISTENCE_DRIVE, toString(newVTypeParameter.getCFParam(SUMO_ATTR_CF_EIDM_T_PERSISTENCE_DRIVE, 0)), undoList);
1027 }
1028 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_T_REACTION, "").empty()) {
1029 vType->setAttribute(SUMO_ATTR_CF_EIDM_T_REACTION, toString(newVTypeParameter.getCFParam(SUMO_ATTR_CF_EIDM_T_REACTION, 0)), undoList);
1030 }
1031 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_T_PERSISTENCE_ESTIMATE, "").empty()) {
1032 vType->setAttribute(SUMO_ATTR_CF_EIDM_T_PERSISTENCE_ESTIMATE, toString(newVTypeParameter.getCFParam(SUMO_ATTR_CF_EIDM_T_PERSISTENCE_ESTIMATE, 0)), undoList);
1033 }
1034 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_C_COOLNESS, "").empty()) {
1035 vType->setAttribute(SUMO_ATTR_CF_EIDM_C_COOLNESS, toString(newVTypeParameter.getCFParam(SUMO_ATTR_CF_EIDM_C_COOLNESS, 0)), undoList);
1036 }
1037 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_SIG_LEADER, "").empty()) {
1038 vType->setAttribute(SUMO_ATTR_CF_EIDM_SIG_LEADER, toString(newVTypeParameter.getCFParam(SUMO_ATTR_CF_EIDM_SIG_LEADER, 0)), undoList);
1039 }
1040 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_SIG_GAP, "").empty()) {
1041 vType->setAttribute(SUMO_ATTR_CF_EIDM_SIG_GAP, toString(newVTypeParameter.getCFParam(SUMO_ATTR_CF_EIDM_SIG_GAP, 0)), undoList);
1042 }
1043 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_SIG_ERROR, "").empty()) {
1044 vType->setAttribute(SUMO_ATTR_CF_EIDM_SIG_ERROR, toString(newVTypeParameter.getCFParam(SUMO_ATTR_CF_EIDM_SIG_ERROR, 0)), undoList);
1045 }
1046 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_JERK_MAX, "").empty()) {
1047 vType->setAttribute(SUMO_ATTR_CF_EIDM_JERK_MAX, toString(newVTypeParameter.getCFParam(SUMO_ATTR_CF_EIDM_JERK_MAX, 0)), undoList);
1048 }
1049 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_EPSILON_ACC, "").empty()) {
1050 vType->setAttribute(SUMO_ATTR_CF_EIDM_EPSILON_ACC, toString(newVTypeParameter.getCFParam(SUMO_ATTR_CF_EIDM_EPSILON_ACC, 0)), undoList);
1051 }
1052 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_T_ACC_MAX, "").empty()) {
1053 vType->setAttribute(SUMO_ATTR_CF_EIDM_T_ACC_MAX, toString(newVTypeParameter.getCFParam(SUMO_ATTR_CF_EIDM_T_ACC_MAX, 0)), undoList);
1054 }
1055 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_M_FLATNESS, "").empty()) {
1056 vType->setAttribute(SUMO_ATTR_CF_EIDM_M_FLATNESS, toString(newVTypeParameter.getCFParam(SUMO_ATTR_CF_EIDM_M_FLATNESS, 0)), undoList);
1057 }
1058 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_EIDM_M_BEGIN, "").empty()) {
1059 vType->setAttribute(SUMO_ATTR_CF_EIDM_M_BEGIN, toString(newVTypeParameter.getCFParam(SUMO_ATTR_CF_EIDM_M_BEGIN, 0)), undoList);
1060 }
1061 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_W99_CC1, "").empty()) {
1062 vType->setAttribute(SUMO_ATTR_CF_W99_CC1, toString(newVTypeParameter.getCFParam(SUMO_ATTR_CF_W99_CC1, 0)), undoList);
1063 }
1064 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_W99_CC2, "").empty()) {
1065 vType->setAttribute(SUMO_ATTR_CF_W99_CC2, toString(newVTypeParameter.getCFParam(SUMO_ATTR_CF_W99_CC2, 0)), undoList);
1066 }
1067 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_W99_CC3, "").empty()) {
1068 vType->setAttribute(SUMO_ATTR_CF_W99_CC3, toString(newVTypeParameter.getCFParam(SUMO_ATTR_CF_W99_CC3, 0)), undoList);
1069 }
1070 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_W99_CC4, "").empty()) {
1071 vType->setAttribute(SUMO_ATTR_CF_W99_CC4, toString(newVTypeParameter.getCFParam(SUMO_ATTR_CF_W99_CC4, 0)), undoList);
1072 }
1073 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_W99_CC5, "").empty()) {
1074 vType->setAttribute(SUMO_ATTR_CF_W99_CC5, toString(newVTypeParameter.getCFParam(SUMO_ATTR_CF_W99_CC5, 0)), undoList);
1075 }
1076 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_W99_CC6, "").empty()) {
1077 vType->setAttribute(SUMO_ATTR_CF_W99_CC6, toString(newVTypeParameter.getCFParam(SUMO_ATTR_CF_W99_CC6, 0)), undoList);
1078 }
1079 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_W99_CC7, "").empty()) {
1080 vType->setAttribute(SUMO_ATTR_CF_W99_CC7, toString(newVTypeParameter.getCFParam(SUMO_ATTR_CF_W99_CC7, 0)), undoList);
1081 }
1082 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_W99_CC8, "").empty()) {
1083 vType->setAttribute(SUMO_ATTR_CF_W99_CC8, toString(newVTypeParameter.getCFParam(SUMO_ATTR_CF_W99_CC8, 0)), undoList);
1084 }
1085 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_W99_CC9, "").empty()) {
1086 vType->setAttribute(SUMO_ATTR_CF_W99_CC9, toString(newVTypeParameter.getCFParam(SUMO_ATTR_CF_W99_CC9, 0)), undoList);
1087 }
1088 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_PWAGNER2009_TAULAST, "").empty()) {
1089 vType->setAttribute(SUMO_ATTR_CF_PWAGNER2009_TAULAST, toString(newVTypeParameter.getCFParam(SUMO_ATTR_CF_PWAGNER2009_TAULAST, 0)), undoList);
1090 }
1091 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_PWAGNER2009_APPROB, "").empty()) {
1092 vType->setAttribute(SUMO_ATTR_CF_PWAGNER2009_APPROB, toString(newVTypeParameter.getCFParam(SUMO_ATTR_CF_PWAGNER2009_APPROB, 0)), undoList);
1093 }
1094 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_IDMM_ADAPT_FACTOR, "").empty()) {
1095 vType->setAttribute(SUMO_ATTR_CF_IDMM_ADAPT_FACTOR, toString(newVTypeParameter.getCFParam(SUMO_ATTR_CF_IDMM_ADAPT_FACTOR, 0)), undoList);
1096 }
1097 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_IDMM_ADAPT_TIME, "").empty()) {
1098 vType->setAttribute(SUMO_ATTR_CF_IDMM_ADAPT_TIME, toString(newVTypeParameter.getCFParam(SUMO_ATTR_CF_IDMM_ADAPT_TIME, 0)), undoList);
1099 }
1100 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_WIEDEMANN_SECURITY, "").empty()) {
1101 vType->setAttribute(SUMO_ATTR_CF_WIEDEMANN_SECURITY, toString(newVTypeParameter.getCFParam(SUMO_ATTR_CF_WIEDEMANN_SECURITY, 0)), undoList);
1102 }
1103 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_WIEDEMANN_ESTIMATION, "").empty()) {
1104 vType->setAttribute(SUMO_ATTR_CF_WIEDEMANN_ESTIMATION, toString(newVTypeParameter.getCFParam(SUMO_ATTR_CF_WIEDEMANN_ESTIMATION, 0)), undoList);
1105 }
1106 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_TRAIN_TYPE, "").empty()) {
1107 vType->setAttribute(SUMO_ATTR_TRAIN_TYPE, toString(newVTypeParameter.getCFParam(SUMO_ATTR_TRAIN_TYPE, 0)), undoList);
1108 }
1109 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_K, "").empty()) {
1110 vType->setAttribute(SUMO_ATTR_K, toString(newVTypeParameter.getCFParam(SUMO_ATTR_K, 0)), undoList);
1111 }
1112 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_KERNER_PHI, "").empty()) {
1113 vType->setAttribute(SUMO_ATTR_CF_KERNER_PHI, toString(newVTypeParameter.getCFParam(SUMO_ATTR_CF_KERNER_PHI, 0)), undoList);
1114 }
1115 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_IDM_DELTA, "").empty()) {
1116 vType->setAttribute(SUMO_ATTR_CF_IDM_DELTA, toString(newVTypeParameter.getCFParam(SUMO_ATTR_CF_IDM_DELTA, 0)), undoList);
1117 }
1118 if (!newVTypeParameter.getCFParamString(SUMO_ATTR_CF_IDM_STEPPING, "").empty()) {
1119 vType->setAttribute(SUMO_ATTR_CF_IDM_STEPPING, toString(newVTypeParameter.getCFParam(SUMO_ATTR_CF_IDM_STEPPING, 0)), undoList);
1120 }
1121 // JM values
1122 if (!newVTypeParameter.getJMParamString(SUMO_ATTR_JM_CROSSING_GAP, "").empty()) {
1123 vType->setAttribute(SUMO_ATTR_JM_CROSSING_GAP, toString(newVTypeParameter.getJMParam(SUMO_ATTR_JM_CROSSING_GAP, 0)), undoList);
1124 }
1125 if (!newVTypeParameter.getJMParamString(SUMO_ATTR_JM_IGNORE_KEEPCLEAR_TIME, "").empty()) {
1126 vType->setAttribute(SUMO_ATTR_JM_IGNORE_KEEPCLEAR_TIME, toString(newVTypeParameter.getJMParam(SUMO_ATTR_JM_IGNORE_KEEPCLEAR_TIME, 0)), undoList);
1127 }
1128 if (!newVTypeParameter.getJMParamString(SUMO_ATTR_JM_DRIVE_AFTER_YELLOW_TIME, "").empty()) {
1129 vType->setAttribute(SUMO_ATTR_JM_DRIVE_AFTER_YELLOW_TIME, toString(newVTypeParameter.getJMParam(SUMO_ATTR_JM_DRIVE_AFTER_YELLOW_TIME, 0)), undoList);
1130 }
1131 if (!newVTypeParameter.getJMParamString(SUMO_ATTR_JM_DRIVE_AFTER_RED_TIME, "").empty()) {
1132 vType->setAttribute(SUMO_ATTR_JM_DRIVE_AFTER_RED_TIME, toString(newVTypeParameter.getJMParam(SUMO_ATTR_JM_DRIVE_AFTER_RED_TIME, 0)), undoList);
1133 }
1134 if (!newVTypeParameter.getJMParamString(SUMO_ATTR_JM_DRIVE_RED_SPEED, "").empty()) {
1135 vType->setAttribute(SUMO_ATTR_JM_DRIVE_RED_SPEED, toString(newVTypeParameter.getJMParam(SUMO_ATTR_JM_DRIVE_RED_SPEED, 0)), undoList);
1136 }
1137 if (!newVTypeParameter.getJMParamString(SUMO_ATTR_JM_IGNORE_FOE_PROB, "").empty()) {
1138 vType->setAttribute(SUMO_ATTR_JM_IGNORE_FOE_PROB, toString(newVTypeParameter.getJMParam(SUMO_ATTR_JM_IGNORE_FOE_PROB, 0)), undoList);
1139 }
1140 if (!newVTypeParameter.getJMParamString(SUMO_ATTR_JM_IGNORE_FOE_SPEED, "").empty()) {
1141 vType->setAttribute(SUMO_ATTR_JM_IGNORE_FOE_SPEED, toString(newVTypeParameter.getJMParam(SUMO_ATTR_JM_IGNORE_FOE_SPEED, 0)), undoList);
1142 }
1143 if (!newVTypeParameter.getJMParamString(SUMO_ATTR_JM_SIGMA_MINOR, "").empty()) {
1144 vType->setAttribute(SUMO_ATTR_JM_SIGMA_MINOR, toString(newVTypeParameter.getJMParam(SUMO_ATTR_JM_SIGMA_MINOR, 0)), undoList);
1145 }
1146 if (!newVTypeParameter.getJMParamString(SUMO_ATTR_JM_TIMEGAP_MINOR, "").empty()) {
1147 vType->setAttribute(SUMO_ATTR_JM_TIMEGAP_MINOR, toString(newVTypeParameter.getJMParam(SUMO_ATTR_JM_TIMEGAP_MINOR, 0)), undoList);
1148 }
1149 if (newVTypeParameter.wasSet(VTYPEPARS_IMPATIENCE_SET)) {
1150 vType->setAttribute(SUMO_ATTR_IMPATIENCE, toString(newVTypeParameter.impatience), undoList);
1151 }
1152 // LCM values
1153 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_STRATEGIC_PARAM, "").empty()) {
1154 vType->setAttribute(SUMO_ATTR_LCA_STRATEGIC_PARAM, toString(newVTypeParameter.getLCParam(SUMO_ATTR_LCA_STRATEGIC_PARAM, 0)), undoList);
1155 }
1156 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_COOPERATIVE_PARAM, "").empty()) {
1157 vType->setAttribute(SUMO_ATTR_LCA_COOPERATIVE_PARAM, toString(newVTypeParameter.getLCParam(SUMO_ATTR_LCA_COOPERATIVE_PARAM, 0)), undoList);
1158 }
1159 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_SPEEDGAIN_PARAM, "").empty()) {
1160 vType->setAttribute(SUMO_ATTR_LCA_SPEEDGAIN_PARAM, toString(newVTypeParameter.getLCParam(SUMO_ATTR_LCA_SPEEDGAIN_PARAM, 0)), undoList);
1161 }
1162 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_KEEPRIGHT_PARAM, "").empty()) {
1163 vType->setAttribute(SUMO_ATTR_LCA_KEEPRIGHT_PARAM, toString(newVTypeParameter.getLCParam(SUMO_ATTR_LCA_KEEPRIGHT_PARAM, 0)), undoList);
1164 }
1165 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_SUBLANE_PARAM, "").empty()) {
1166 vType->setAttribute(SUMO_ATTR_LCA_SUBLANE_PARAM, toString(newVTypeParameter.getLCParam(SUMO_ATTR_LCA_SUBLANE_PARAM, 0)), undoList);
1167 }
1168 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_OPPOSITE_PARAM, "").empty()) {
1169 vType->setAttribute(SUMO_ATTR_LCA_OPPOSITE_PARAM, toString(newVTypeParameter.getLCParam(SUMO_ATTR_LCA_OPPOSITE_PARAM, 0)), undoList);
1170 }
1171 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_PUSHY, "").empty()) {
1172 vType->setAttribute(SUMO_ATTR_LCA_PUSHY, toString(newVTypeParameter.getLCParam(SUMO_ATTR_LCA_PUSHY, 0)), undoList);
1173 }
1174 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_PUSHYGAP, "").empty()) {
1175 vType->setAttribute(SUMO_ATTR_LCA_PUSHYGAP, toString(newVTypeParameter.getLCParam(SUMO_ATTR_LCA_PUSHYGAP, 0)), undoList);
1176 }
1177 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_ASSERTIVE, "").empty()) {
1178 vType->setAttribute(SUMO_ATTR_LCA_ASSERTIVE, toString(newVTypeParameter.getLCParam(SUMO_ATTR_LCA_ASSERTIVE, 0)), undoList);
1179 }
1180 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_IMPATIENCE, "").empty()) {
1181 vType->setAttribute(SUMO_ATTR_LCA_IMPATIENCE, toString(newVTypeParameter.getLCParam(SUMO_ATTR_LCA_IMPATIENCE, 0)), undoList);
1182 }
1183 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_TIME_TO_IMPATIENCE, "").empty()) {
1184 vType->setAttribute(SUMO_ATTR_LCA_TIME_TO_IMPATIENCE, toString(newVTypeParameter.getLCParam(SUMO_ATTR_LCA_TIME_TO_IMPATIENCE, 0)), undoList);
1185 }
1186 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_ACCEL_LAT, "").empty()) {
1187 vType->setAttribute(SUMO_ATTR_LCA_ACCEL_LAT, toString(newVTypeParameter.getLCParam(SUMO_ATTR_LCA_ACCEL_LAT, 0)), undoList);
1188 }
1189 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_LOOKAHEADLEFT, "").empty()) {
1190 vType->setAttribute(SUMO_ATTR_LCA_LOOKAHEADLEFT, toString(newVTypeParameter.getLCParam(SUMO_ATTR_LCA_LOOKAHEADLEFT, 0)), undoList);
1191 }
1192 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_SPEEDGAINRIGHT, "").empty()) {
1193 vType->setAttribute(SUMO_ATTR_LCA_SPEEDGAINRIGHT, toString(newVTypeParameter.getLCParam(SUMO_ATTR_LCA_SPEEDGAINRIGHT, 0)), undoList);
1194 }
1195 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_MAXSPEEDLATSTANDING, "").empty()) {
1196 vType->setAttribute(SUMO_ATTR_LCA_MAXSPEEDLATSTANDING, toString(newVTypeParameter.getLCParam(SUMO_ATTR_LCA_MAXSPEEDLATSTANDING, 0)), undoList);
1197 }
1198 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_MAXSPEEDLATFACTOR, "").empty()) {
1199 vType->setAttribute(SUMO_ATTR_LCA_MAXSPEEDLATFACTOR, toString(newVTypeParameter.getLCParam(SUMO_ATTR_LCA_MAXSPEEDLATFACTOR, 0)), undoList);
1200 }
1201 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_TURN_ALIGNMENT_DISTANCE, "").empty()) {
1202 vType->setAttribute(SUMO_ATTR_LCA_TURN_ALIGNMENT_DISTANCE, toString(newVTypeParameter.getLCParam(SUMO_ATTR_LCA_TURN_ALIGNMENT_DISTANCE, 0)), undoList);
1203 }
1204 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_OVERTAKE_RIGHT, "").empty()) {
1205 vType->setAttribute(SUMO_ATTR_LCA_OVERTAKE_RIGHT, toString(newVTypeParameter.getLCParam(SUMO_ATTR_LCA_OVERTAKE_RIGHT, 0)), undoList);
1206 }
1207 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_KEEPRIGHT_ACCEPTANCE_TIME, "").empty()) {
1208 vType->setAttribute(SUMO_ATTR_LCA_KEEPRIGHT_ACCEPTANCE_TIME, toString(newVTypeParameter.getLCParam(SUMO_ATTR_LCA_KEEPRIGHT_ACCEPTANCE_TIME, 0)), undoList);
1209 }
1210 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_OVERTAKE_DELTASPEED_FACTOR, "").empty()) {
1211 vType->setAttribute(SUMO_ATTR_LCA_OVERTAKE_DELTASPEED_FACTOR, toString(newVTypeParameter.getLCParam(SUMO_ATTR_LCA_OVERTAKE_DELTASPEED_FACTOR, 0)), undoList);
1212 }
1213 if (!newVTypeParameter.getLCParamString(SUMO_ATTR_LCA_EXPERIMENTAL1, "").empty()) {
1214 vType->setAttribute(SUMO_ATTR_LCA_EXPERIMENTAL1, toString(newVTypeParameter.getLCParam(SUMO_ATTR_LCA_EXPERIMENTAL1, 0)), undoList);
1215 }
1216 // vType parameters
1217 if (newVTypeParameter.wasSet(VTYPEPARS_VEHICLECLASS_SET)) {
1218 vType->setAttribute(SUMO_ATTR_VCLASS, toString(newVTypeParameter.vehicleClass), undoList);
1219 }
1220 if (newVTypeParameter.wasSet(VTYPEPARS_LENGTH_SET)) {
1221 vType->setAttribute(SUMO_ATTR_LENGTH, toString(newVTypeParameter.length), undoList);
1222 }
1223 if (newVTypeParameter.wasSet(VTYPEPARS_MINGAP_SET)) {
1224 vType->setAttribute(SUMO_ATTR_MINGAP, toString(newVTypeParameter.minGap), undoList);
1225 }
1226 if (newVTypeParameter.wasSet(VTYPEPARS_MAXSPEED_SET)) {
1227 vType->setAttribute(SUMO_ATTR_MAXSPEED, toString(newVTypeParameter.maxSpeed), undoList);
1228 }
1229 if (newVTypeParameter.wasSet(VTYPEPARS_SPEEDFACTOR_SET)) {
1230 vType->setAttribute(SUMO_ATTR_SPEEDFACTOR, toString(newVTypeParameter.speedFactor), undoList);
1231 }
1232 if (newVTypeParameter.wasSet(VTYPEPARS_DESIRED_MAXSPEED_SET)) {
1233 vType->setAttribute(SUMO_ATTR_DESIRED_MAXSPEED, toString(newVTypeParameter.desiredMaxSpeed), undoList);
1234 }
1235 if (newVTypeParameter.wasSet(VTYPEPARS_COLOR_SET)) {
1236 vType->setAttribute(SUMO_ATTR_COLOR, toString(newVTypeParameter.color), undoList);
1237 }
1238 if (newVTypeParameter.wasSet(VTYPEPARS_EMISSIONCLASS_SET)) {
1239 vType->setAttribute(SUMO_ATTR_EMISSIONCLASS, PollutantsInterface::getName(newVTypeParameter.emissionClass), undoList);
1240 }
1241 if (newVTypeParameter.wasSet(VTYPEPARS_SHAPE_SET)) {
1242 vType->setAttribute(SUMO_ATTR_GUISHAPE, getVehicleShapeName(newVTypeParameter.shape), undoList);
1243 }
1244 if (newVTypeParameter.wasSet(VTYPEPARS_WIDTH_SET)) {
1245 vType->setAttribute(SUMO_ATTR_WIDTH, toString(newVTypeParameter.width), undoList);
1246 }
1247 if (newVTypeParameter.wasSet(VTYPEPARS_HEIGHT_SET)) {
1248 vType->setAttribute(SUMO_ATTR_HEIGHT, toString(newVTypeParameter.height), undoList);
1249 }
1250 if (newVTypeParameter.wasSet(VTYPEPARS_IMGFILE_SET)) {
1251 vType->setAttribute(SUMO_ATTR_IMGFILE, toString(newVTypeParameter.imgFile), undoList);
1252 }
1253 if (newVTypeParameter.wasSet(VTYPEPARS_LANE_CHANGE_MODEL_SET)) {
1254 vType->setAttribute(SUMO_ATTR_LANE_CHANGE_MODEL, SUMOXMLDefinitions::LaneChangeModels.getString(newVTypeParameter.lcModel), undoList);
1255 }
1256 if (newVTypeParameter.wasSet(VTYPEPARS_CAR_FOLLOW_MODEL)) {
1257 vType->setAttribute(SUMO_ATTR_CAR_FOLLOW_MODEL, SUMOXMLDefinitions::CarFollowModels.getString(newVTypeParameter.cfModel), undoList);
1258 }
1259 if (newVTypeParameter.wasSet(VTYPEPARS_PERSON_CAPACITY)) {
1260 vType->setAttribute(SUMO_ATTR_PERSON_CAPACITY, toString(newVTypeParameter.personCapacity), undoList);
1261 }
1262 if (newVTypeParameter.wasSet(VTYPEPARS_CONTAINER_CAPACITY)) {
1263 vType->setAttribute(SUMO_ATTR_CONTAINER_CAPACITY, toString(newVTypeParameter.containerCapacity), undoList);
1264 }
1265 if (newVTypeParameter.wasSet(VTYPEPARS_BOARDING_DURATION)) {
1266 vType->setAttribute(SUMO_ATTR_BOARDING_DURATION, time2string(newVTypeParameter.boardingDuration), undoList);
1267 }
1268 if (newVTypeParameter.wasSet(VTYPEPARS_LOADING_DURATION)) {
1269 vType->setAttribute(SUMO_ATTR_LOADING_DURATION, time2string(newVTypeParameter.loadingDuration), undoList);
1270 }
1271 if (newVTypeParameter.wasSet(VTYPEPARS_LATALIGNMENT_SET)) {
1272 if (newVTypeParameter.latAlignmentProcedure != LatAlignmentDefinition::GIVEN) {
1273 vType->setAttribute(SUMO_ATTR_LATALIGNMENT, toString(newVTypeParameter.latAlignmentProcedure), undoList);
1274 } else {
1275 vType->setAttribute(SUMO_ATTR_LATALIGNMENT, toString(newVTypeParameter.latAlignmentOffset), undoList);
1276 }
1277 }
1278 if (newVTypeParameter.wasSet(VTYPEPARS_MINGAP_LAT_SET)) {
1279 vType->setAttribute(SUMO_ATTR_MINGAP_LAT, toString(newVTypeParameter.minGapLat), undoList);
1280 }
1281 if (newVTypeParameter.wasSet(VTYPEPARS_MAXSPEED_LAT_SET)) {
1282 vType->setAttribute(SUMO_ATTR_MAXSPEED_LAT, toString(newVTypeParameter.maxSpeedLat), undoList);
1283 }
1284 if (newVTypeParameter.wasSet(VTYPEPARS_ACTIONSTEPLENGTH_SET)) {
1285 vType->setAttribute(SUMO_ATTR_ACTIONSTEPLENGTH, time2string(newVTypeParameter.actionStepLength), undoList);
1286 }
1287 if (newVTypeParameter.wasSet(VTYPEPARS_PROBABILITY_SET)) {
1288 vType->setAttribute(SUMO_ATTR_PROB, toString(newVTypeParameter.defaultProbability), undoList);
1289 }
1290 if (newVTypeParameter.wasSet(VTYPEPARS_OSGFILE_SET)) {
1291 vType->setAttribute(SUMO_ATTR_OSGFILE, toString(newVTypeParameter.osgFile), undoList);
1292 }
1293 if (newVTypeParameter.hasParameter(toString(SUMO_ATTR_CARRIAGE_LENGTH))) {
1294 vType->setAttribute(SUMO_ATTR_CARRIAGE_LENGTH, newVTypeParameter.getParameter(toString(SUMO_ATTR_CARRIAGE_LENGTH), ""), undoList);
1295 }
1296 if (newVTypeParameter.hasParameter(toString(SUMO_ATTR_LOCOMOTIVE_LENGTH))) {
1297 vType->setAttribute(SUMO_ATTR_LOCOMOTIVE_LENGTH, newVTypeParameter.getParameter(toString(SUMO_ATTR_LOCOMOTIVE_LENGTH), ""), undoList);
1298 }
1299 if (newVTypeParameter.hasParameter(toString(SUMO_ATTR_CARRIAGE_GAP))) {
1300 vType->setAttribute(SUMO_ATTR_CARRIAGE_GAP, newVTypeParameter.getParameter(toString(SUMO_ATTR_CARRIAGE_GAP), ""), undoList);
1301 }
1302 if (newVTypeParameter.hasParameter(toString(SUMO_ATTR_PARKING_BADGES))) {
1303 vType->setAttribute(SUMO_ATTR_PARKING_BADGES, newVTypeParameter.getParameter(toString(SUMO_ATTR_PARKING_BADGES), ""), undoList);
1304 }
1305 // parse parameters
1306 std::string parametersStr;
1307 // Generate an string using the following structure: "key1=value1|key2=value2|...
1308 for (const auto& parameter : newVTypeParameter.getParametersMap()) {
1309 parametersStr += parameter.first + "=" + parameter.second + "|";
1310 }
1311 // remove the last "|"
1312 if (!parametersStr.empty()) {
1313 parametersStr.pop_back();
1314 }
1315 if (parametersStr != vType->getAttribute(GNE_ATTR_PARAMETERS)) {
1316 vType->setAttribute(GNE_ATTR_PARAMETERS, parametersStr, undoList);
1317 }
1318 // close undo list
1319 undoList->end();
1320 return true;
1321}
1322
1323// ===========================================================================
1324// private
1325// ===========================================================================
1326
1327void
1328GNEVType::setAttribute(SumoXMLAttr key, const std::string& value) {
1329 // obtain default values depending of vehicle class
1330 VClassDefaultValues defaultValues(vehicleClass);
1331 switch (key) {
1332 case SUMO_ATTR_ID:
1333 // update microsimID
1334 setDemandElementID(value);
1335 // manually change VType parameters ID
1336 id = value;
1337 break;
1338 // CFM Attributes
1339 case SUMO_ATTR_ACCEL:
1340 case SUMO_ATTR_DECEL:
1341 case SUMO_ATTR_APPARENTDECEL:
1342 case SUMO_ATTR_EMERGENCYDECEL:
1343 case SUMO_ATTR_SIGMA:
1344 case SUMO_ATTR_TAU:
1345 case SUMO_ATTR_COLLISION_MINGAP_FACTOR:
1346 case SUMO_ATTR_TMP1:
1347 case SUMO_ATTR_TMP2:
1348 case SUMO_ATTR_TMP3:
1349 case SUMO_ATTR_TMP4:
1350 case SUMO_ATTR_TMP5:
1351 case SUMO_ATTR_CF_PWAGNER2009_TAULAST:
1352 case SUMO_ATTR_CF_PWAGNER2009_APPROB:
1353 case SUMO_ATTR_CF_IDMM_ADAPT_FACTOR:
1354 case SUMO_ATTR_CF_IDMM_ADAPT_TIME:
1355 case SUMO_ATTR_CF_WIEDEMANN_SECURITY:
1356 case SUMO_ATTR_CF_WIEDEMANN_ESTIMATION:
1357 case SUMO_ATTR_TRAIN_TYPE:
1358 case SUMO_ATTR_K:
1359 case SUMO_ATTR_CF_KERNER_PHI:
1360 case SUMO_ATTR_CF_IDM_DELTA:
1361 case SUMO_ATTR_CF_IDM_STEPPING:
1362 // empty values means that value isn't set
1363 if (value.empty()) {
1364 const auto it = cfParameter.find(key);
1365 if (it != cfParameter.end()) {
1366 cfParameter.erase(it);
1367 }
1368 } else {
1369 cfParameter[key] = value;
1370 }
1371 break;
1372 case SUMO_ATTR_CF_EIDM_USEVEHDYNAMICS:
1373 case SUMO_ATTR_CF_EIDM_MAX_VEH_PREVIEW:
1374 case SUMO_ATTR_CF_EIDM_T_LOOK_AHEAD:
1375 case SUMO_ATTR_CF_EIDM_T_PERSISTENCE_DRIVE:
1376 case SUMO_ATTR_CF_EIDM_T_REACTION:
1377 case SUMO_ATTR_CF_EIDM_T_PERSISTENCE_ESTIMATE:
1378 case SUMO_ATTR_CF_EIDM_C_COOLNESS:
1379 case SUMO_ATTR_CF_EIDM_SIG_LEADER:
1380 case SUMO_ATTR_CF_EIDM_SIG_GAP:
1381 case SUMO_ATTR_CF_EIDM_SIG_ERROR:
1382 case SUMO_ATTR_CF_EIDM_JERK_MAX:
1383 case SUMO_ATTR_CF_EIDM_EPSILON_ACC:
1384 case SUMO_ATTR_CF_EIDM_T_ACC_MAX:
1385 case SUMO_ATTR_CF_EIDM_M_FLATNESS:
1386 case SUMO_ATTR_CF_EIDM_M_BEGIN:
1387 case SUMO_ATTR_CF_W99_CC1:
1388 case SUMO_ATTR_CF_W99_CC2:
1389 case SUMO_ATTR_CF_W99_CC3:
1390 case SUMO_ATTR_CF_W99_CC4:
1391 case SUMO_ATTR_CF_W99_CC5:
1392 case SUMO_ATTR_CF_W99_CC6:
1393 case SUMO_ATTR_CF_W99_CC7:
1394 case SUMO_ATTR_CF_W99_CC8:
1395 case SUMO_ATTR_CF_W99_CC9:
1396 // empty or default values means that value isn't set
1397 if (value.empty() || (canParse<double>(value) && (parse<double>(value) == myTagProperty->getDefaultDoubleValue(key)))) {
1398 const auto it = cfParameter.find(key);
1399 if (it != cfParameter.end()) {
1400 cfParameter.erase(it);
1401 }
1402 } else {
1403 cfParameter[key] = value;
1404 }
1405 break;
1406 // JM Attributes
1407 case SUMO_ATTR_JM_CROSSING_GAP:
1408 case SUMO_ATTR_JM_IGNORE_KEEPCLEAR_TIME:
1409 case SUMO_ATTR_JM_DRIVE_AFTER_YELLOW_TIME:
1410 case SUMO_ATTR_JM_DRIVE_AFTER_RED_TIME:
1411 case SUMO_ATTR_JM_DRIVE_RED_SPEED:
1412 case SUMO_ATTR_JM_IGNORE_FOE_PROB:
1413 case SUMO_ATTR_JM_IGNORE_FOE_SPEED:
1414 case SUMO_ATTR_JM_SIGMA_MINOR:
1415 case SUMO_ATTR_JM_TIMEGAP_MINOR:
1416 // empty values means that value isn't set
1417 if (value.empty()) {
1418 const auto it = jmParameter.find(key);
1419 if (it != jmParameter.end()) {
1420 jmParameter.erase(it);
1421 }
1422 } else {
1423 jmParameter[key] = value;
1424 }
1425 break;
1426 case SUMO_ATTR_IMPATIENCE:
1427 if (!value.empty() && (value != myTagProperty->getDefaultStringValue(key))) {
1428 impatience = parse<double>(value);
1429 // mark parameter as set
1430 parametersSet |= VTYPEPARS_IMPATIENCE_SET;
1431 } else {
1432 // set default value
1433 impatience = parse<double>(myTagProperty->getDefaultStringValue(key));
1434 // unset parameter
1435 parametersSet &= ~VTYPEPARS_IMPATIENCE_SET;
1436 }
1437 break;
1438 // LCM Attributes
1439 case SUMO_ATTR_LCA_STRATEGIC_PARAM:
1440 case SUMO_ATTR_LCA_COOPERATIVE_PARAM:
1441 case SUMO_ATTR_LCA_SPEEDGAIN_PARAM:
1442 case SUMO_ATTR_LCA_KEEPRIGHT_PARAM:
1443 case SUMO_ATTR_LCA_SUBLANE_PARAM:
1444 case SUMO_ATTR_LCA_OPPOSITE_PARAM:
1445 case SUMO_ATTR_LCA_PUSHY:
1446 case SUMO_ATTR_LCA_PUSHYGAP:
1447 case SUMO_ATTR_LCA_ASSERTIVE:
1448 case SUMO_ATTR_LCA_IMPATIENCE:
1449 case SUMO_ATTR_LCA_ACCEL_LAT:
1450 case SUMO_ATTR_LCA_LOOKAHEADLEFT:
1451 case SUMO_ATTR_LCA_SPEEDGAINRIGHT:
1452 case SUMO_ATTR_LCA_MAXSPEEDLATSTANDING:
1453 case SUMO_ATTR_LCA_MAXSPEEDLATFACTOR:
1454
1455 /* case SUMO_ATTR_LCA_EXPERIMENTAL1: */
1456 // empty values means that value isn't set
1457 if (value.empty()) {
1458 const auto it = lcParameter.find(key);
1459 if (it != lcParameter.end()) {
1460 lcParameter.erase(it);
1461 }
1462 } else {
1463 lcParameter[key] = value;
1464 }
1465 break;
1466 case SUMO_ATTR_LCA_KEEPRIGHT_ACCEPTANCE_TIME:
1467 // empty or -1 value means that value isn't set
1468 if (value.empty() || (canParse<double>(value) && (parse<double>(value) == -1))) {
1469 const auto it = lcParameter.find(key);
1470 if (it != lcParameter.end()) {
1471 lcParameter.erase(it);
1472 }
1473 } else {
1474 lcParameter[key] = value;
1475 }
1476 break;
1477 case SUMO_ATTR_LCA_TURN_ALIGNMENT_DISTANCE:
1478 case SUMO_ATTR_LCA_TIME_TO_IMPATIENCE:
1479 case SUMO_ATTR_LCA_OVERTAKE_RIGHT:
1480 case SUMO_ATTR_LCA_OVERTAKE_DELTASPEED_FACTOR:
1481 // empty or null values means that value isn't set
1482 if (value.empty() || (canParse<double>(value) && (parse<double>(value) == 0))) {
1483 const auto it = lcParameter.find(key);
1484 if (it != lcParameter.end()) {
1485 lcParameter.erase(it);
1486 }
1487 } else {
1488 lcParameter[key] = value;
1489 }
1490 break;
1491 //
1492 case SUMO_ATTR_LENGTH:
1493 if (!value.empty() && (value != toString(defaultValues.length))) {
1494 length = parse<double>(value);
1495 // mark parameter as set
1496 parametersSet |= VTYPEPARS_LENGTH_SET;
1497 } else {
1498 // set default value
1499 length = defaultValues.length;
1500 // unset parameter
1501 parametersSet &= ~VTYPEPARS_LENGTH_SET;
1502 }
1503 break;
1504 case SUMO_ATTR_MINGAP:
1505 if (!value.empty() && (value != toString(defaultValues.minGap))) {
1506 minGap = parse<double>(value);
1507 // mark parameter as set
1508 parametersSet |= VTYPEPARS_MINGAP_SET;
1509 } else {
1510 // set default value
1511 minGap = defaultValues.minGap;
1512 // unset parameter
1513 parametersSet &= ~VTYPEPARS_MINGAP_SET;
1514 }
1515 break;
1516 case SUMO_ATTR_MAXSPEED:
1517 if (!value.empty() && (value != toString(defaultValues.maxSpeed))) {
1518 maxSpeed = parse<double>(value);
1519 // mark parameter as set
1520 parametersSet |= VTYPEPARS_MAXSPEED_SET;
1521 } else {
1522 // set default value
1523 maxSpeed = defaultValues.maxSpeed;
1524 // unset parameter
1525 parametersSet &= ~VTYPEPARS_MAXSPEED_SET;
1526 }
1527 break;
1528 case SUMO_ATTR_SPEEDFACTOR:
1529 if (!value.empty() && (value != toString(defaultValues.speedFactor))) {
1530 speedFactor.parse(value, false);
1531 // mark parameter as set
1532 parametersSet |= VTYPEPARS_SPEEDFACTOR_SET;
1533 } else {
1534 // set default value
1535 speedFactor.parse(toString(defaultValues.speedFactor), false);
1536 // unset parameter
1537 parametersSet &= ~VTYPEPARS_SPEEDFACTOR_SET;
1538 }
1539 break;
1540 case SUMO_ATTR_DESIRED_MAXSPEED:
1541 if (!value.empty() && (value != toString(defaultValues.desiredMaxSpeed))) {
1542 desiredMaxSpeed = parse<double>(value);
1543 // mark parameter as set
1544 parametersSet |= VTYPEPARS_DESIRED_MAXSPEED_SET;
1545 } else {
1546 // set default value
1547 desiredMaxSpeed = defaultValues.desiredMaxSpeed;
1548 // unset parameter
1549 parametersSet &= ~VTYPEPARS_DESIRED_MAXSPEED_SET;
1550 }
1551 break;
1552 case SUMO_ATTR_COLOR:
1553 if (!value.empty() && (value != myTagProperty->getDefaultStringValue(key))) {
1554 color = parse<RGBColor>(value);
1555 // mark parameter as set
1556 parametersSet |= VTYPEPARS_COLOR_SET;
1557 } else {
1558 // unset parameter
1559 parametersSet &= ~VTYPEPARS_COLOR_SET;
1560 }
1561 break;
1562 case SUMO_ATTR_VCLASS:
1563 if (!value.empty() && (value != myTagProperty->getDefaultStringValue(key))) {
1564 vehicleClass = getVehicleClassID(value);
1565 // mark parameter as set
1566 parametersSet |= VTYPEPARS_VEHICLECLASS_SET;
1567 } else {
1568 // set default value
1569 vehicleClass = getVehicleClassID(myTagProperty->getDefaultStringValue(key));
1570 // unset parameter
1571 parametersSet &= ~VTYPEPARS_VEHICLECLASS_SET;
1572 }
1573 // update default values
1574 updateDefaultVClassAttributes(defaultValues);
1575 break;
1576 case SUMO_ATTR_PARKING_BADGES:
1577 if (!value.empty()) {
1578 parkingBadges = parse<std::vector<std::string>>(value);
1579 // mark parameter as set
1580 parametersSet |= VTYPEPARS_PARKING_BADGES_SET;
1581 } else {
1582 // set default value
1583 parkingBadges.clear();
1584 // unset parameter
1585 parametersSet &= ~VTYPEPARS_PARKING_BADGES_SET;
1586 }
1587 break;
1588 case SUMO_ATTR_EMISSIONCLASS:
1589 if (!value.empty() && (value != toString(defaultValues.emissionClass))) {
1590 emissionClass = PollutantsInterface::getClassByName(value);
1591 // mark parameter as set
1592 parametersSet |= VTYPEPARS_EMISSIONCLASS_SET;
1593 } else {
1594 // set default value
1595 emissionClass = defaultValues.emissionClass;
1596 // unset parameter
1597 parametersSet &= ~VTYPEPARS_EMISSIONCLASS_SET;
1598 }
1599 break;
1600 case SUMO_ATTR_GUISHAPE:
1601 if (value.empty() || (value == "default")) {
1602 // set default value
1603 shape = defaultValues.shape;
1604 // unset parameter
1605 parametersSet &= ~VTYPEPARS_SHAPE_SET;
1606 } else if (!value.empty() && (value != SumoVehicleShapeStrings.getString(defaultValues.shape))) {
1607 shape = getVehicleShapeID(value);
1608 // mark parameter as set
1609 parametersSet |= VTYPEPARS_SHAPE_SET;
1610 } else {
1611 // set default value
1612 shape = defaultValues.shape;
1613 // unset parameter
1614 parametersSet &= ~VTYPEPARS_SHAPE_SET;
1615 }
1616 break;
1617 case SUMO_ATTR_WIDTH:
1618 if (!value.empty() && (value != toString(defaultValues.width))) {
1619 width = parse<double>(value);
1620 // mark parameter as set
1621 parametersSet |= VTYPEPARS_WIDTH_SET;
1622 } else {
1623 // set default value
1624 width = defaultValues.width;
1625 // unset parameter
1626 parametersSet &= ~VTYPEPARS_WIDTH_SET;
1627 }
1628 break;
1629 case SUMO_ATTR_HEIGHT:
1630 if (!value.empty() && (value != toString(defaultValues.height))) {
1631 height = parse<double>(value);
1632 // mark parameter as set
1633 parametersSet |= VTYPEPARS_HEIGHT_SET;
1634 } else {
1635 // set default value
1636 height = defaultValues.height;
1637 // unset parameter
1638 parametersSet &= ~VTYPEPARS_HEIGHT_SET;
1639 }
1640 break;
1641 case SUMO_ATTR_IMGFILE:
1642 if (!value.empty() && (value != myTagProperty->getDefaultStringValue(key))) {
1643 imgFile = value;
1644 // mark parameter as set
1645 parametersSet |= VTYPEPARS_IMGFILE_SET;
1646 } else {
1647 // set default value
1648 imgFile = myTagProperty->getDefaultStringValue(key);
1649 // unset parameter
1650 parametersSet &= ~VTYPEPARS_IMGFILE_SET;
1651 }
1652 break;
1653 case SUMO_ATTR_LANE_CHANGE_MODEL:
1654 if (!value.empty() && (value != myTagProperty->getDefaultStringValue(key))) {
1655 lcModel = SUMOXMLDefinitions::LaneChangeModels.get(value);
1656 // mark parameter as set
1657 parametersSet |= VTYPEPARS_LANE_CHANGE_MODEL_SET;
1658 } else {
1659 // set default value
1660 lcModel = SUMOXMLDefinitions::LaneChangeModels.get(myTagProperty->getDefaultStringValue(key));
1661 // unset parameter
1662 parametersSet &= ~VTYPEPARS_LANE_CHANGE_MODEL_SET;
1663 }
1664 break;
1665 case SUMO_ATTR_CAR_FOLLOW_MODEL:
1666 if (!value.empty() && (value != myTagProperty->getDefaultStringValue(key))) {
1667 cfModel = SUMOXMLDefinitions::CarFollowModels.get(value);
1668 // mark parameter as set
1669 parametersSet |= VTYPEPARS_CAR_FOLLOW_MODEL;
1670 } else {
1671 // set default value
1672 cfModel = SUMOXMLDefinitions::CarFollowModels.get(myTagProperty->getDefaultStringValue(key));
1673 // unset parameter
1674 parametersSet &= ~VTYPEPARS_CAR_FOLLOW_MODEL;
1675 }
1676 break;
1677 case SUMO_ATTR_PERSON_CAPACITY:
1678 if (!value.empty() && (value != toString(defaultValues.personCapacity))) {
1679 personCapacity = parse<int>(value);
1680 // mark parameter as set
1681 parametersSet |= VTYPEPARS_PERSON_CAPACITY;
1682 } else {
1683 // set default value
1684 personCapacity = defaultValues.personCapacity;
1685 // unset parameter
1686 parametersSet &= ~VTYPEPARS_PERSON_CAPACITY;
1687 }
1688 break;
1689 case SUMO_ATTR_CONTAINER_CAPACITY:
1690 if (!value.empty() && (value != toString(defaultValues.containerCapacity))) {
1691 containerCapacity = parse<int>(value);
1692 // mark parameter as set
1693 parametersSet |= VTYPEPARS_CONTAINER_CAPACITY;
1694 } else {
1695 // set default value
1696 containerCapacity = defaultValues.containerCapacity;
1697 // unset parameter
1698 parametersSet &= ~VTYPEPARS_CONTAINER_CAPACITY;
1699 }
1700 break;
1701 case SUMO_ATTR_BOARDING_DURATION:
1702 if (!value.empty() && (value != myTagProperty->getDefaultStringValue(key))) {
1703 boardingDuration = string2time(value);
1704 // mark parameter as set
1705 parametersSet |= VTYPEPARS_BOARDING_DURATION;
1706 } else {
1707 // set default value
1708 boardingDuration = myTagProperty->getDefaultTimeValue(key);
1709 // unset parameter
1710 parametersSet &= ~VTYPEPARS_BOARDING_DURATION;
1711 }
1712 break;
1713 case SUMO_ATTR_LOADING_DURATION:
1714 if (!value.empty() && (value != myTagProperty->getDefaultStringValue(key))) {
1715 loadingDuration = string2time(value);
1716 // mark parameter as set
1717 parametersSet |= VTYPEPARS_LOADING_DURATION;
1718 } else {
1719 // set default value
1720 loadingDuration = myTagProperty->getDefaultTimeValue(key);
1721 // unset parameter
1722 parametersSet &= ~VTYPEPARS_LOADING_DURATION;
1723 }
1724 break;
1725 case SUMO_ATTR_LATALIGNMENT:
1726 if (!value.empty() && (value != toString(defaultValues.latAlignmentProcedure))) {
1727 parseLatAlignment(value, latAlignmentOffset, latAlignmentProcedure);
1728 // mark parameter as set
1729 parametersSet |= VTYPEPARS_LATALIGNMENT_SET;
1730 } else {
1731 // set default value
1732 parseLatAlignment(toString(defaultValues.latAlignmentProcedure), latAlignmentOffset, latAlignmentProcedure);
1733 // unset parameter
1734 parametersSet &= ~VTYPEPARS_LATALIGNMENT_SET;
1735 }
1736 break;
1737 case SUMO_ATTR_MINGAP_LAT:
1738 if (!value.empty() && (value != myTagProperty->getDefaultStringValue(key))) {
1739 minGapLat = parse<double>(value);
1740 // mark parameter as set
1741 parametersSet |= VTYPEPARS_MINGAP_LAT_SET;
1742 } else {
1743 // set default value
1744 minGapLat = myTagProperty->getDefaultDoubleValue(key);
1745 // unset parameter
1746 parametersSet &= ~VTYPEPARS_MINGAP_LAT_SET;
1747 }
1748 break;
1749 case SUMO_ATTR_MAXSPEED_LAT:
1750 if (!value.empty() && (value != myTagProperty->getDefaultStringValue(key))) {
1751 maxSpeedLat = parse<double>(value);
1752 // mark parameter as set
1753 parametersSet |= VTYPEPARS_MAXSPEED_LAT_SET;
1754 } else {
1755 // set default value
1756 maxSpeedLat = myTagProperty->getDefaultDoubleValue(key);
1757 // unset parameter
1758 parametersSet &= ~VTYPEPARS_MAXSPEED_LAT_SET;
1759 }
1760 break;
1761 case SUMO_ATTR_ACTIONSTEPLENGTH:
1762 if (!value.empty() && (value != myTagProperty->getDefaultStringValue(key))) {
1763 actionStepLength = string2time(value);
1764 // mark parameter as set
1765 parametersSet |= VTYPEPARS_ACTIONSTEPLENGTH_SET;
1766 } else {
1767 // set default value
1768 actionStepLength = myTagProperty->getDefaultTimeValue(key);
1769 // unset parameter
1770 parametersSet &= ~VTYPEPARS_ACTIONSTEPLENGTH_SET;
1771 }
1772 break;
1773 case SUMO_ATTR_PROB:
1774 if (!value.empty() && (value != myTagProperty->getDefaultStringValue(key))) {
1775 defaultProbability = parse<double>(value);
1776 // mark parameter as set
1777 parametersSet |= VTYPEPARS_PROBABILITY_SET;
1778 } else {
1779 // set default value
1780 defaultProbability = myTagProperty->getDefaultDoubleValue(key);
1781 // unset parameter
1782 parametersSet &= ~VTYPEPARS_PROBABILITY_SET;
1783 }
1784 break;
1785 case SUMO_ATTR_OSGFILE:
1786 if (!value.empty() && (value != defaultValues.osgFile)) {
1787 osgFile = value;
1788 // mark parameter as set
1789 parametersSet |= VTYPEPARS_OSGFILE_SET;
1790 } else {
1791 // set default value
1792 osgFile = defaultValues.osgFile;
1793 // unset parameter
1794 parametersSet &= ~VTYPEPARS_OSGFILE_SET;
1795 }
1796 break;
1797 case SUMO_ATTR_CARRIAGE_LENGTH:
1798 if (!value.empty() && (value != toString(defaultValues.carriageLength))) {
1799 carriageLength = parse<double>(value);
1800 // mark parameter as set
1801 parametersSet |= VTYPEPARS_CARRIAGE_LENGTH_SET;
1802 // set parameter in SUMOVTypeParameter (needed for writting in XML)
1803 SUMOVTypeParameter::setParameter(toString(key), value);
1804 } else {
1805 // set default value
1806 carriageLength = defaultValues.carriageLength;
1807 // unset parameter
1808 parametersSet &= ~VTYPEPARS_CARRIAGE_LENGTH_SET;
1809 // remove from params (needed for writting in XML)
1810 SUMOVTypeParameter::unsetParameter(toString(key));
1811 }
1812 break;
1813 case SUMO_ATTR_LOCOMOTIVE_LENGTH:
1814 if (!value.empty() && (value != toString(defaultValues.locomotiveLength))) {
1815 locomotiveLength = parse<double>(value);
1816 // mark parameter as set
1817 parametersSet |= VTYPEPARS_LOCOMOTIVE_LENGTH_SET;
1818 // set parameter in SUMOVTypeParameter (needed for writting in XML)
1819 SUMOVTypeParameter::setParameter(toString(key), value);
1820 } else {
1821 // set default value
1822 locomotiveLength = defaultValues.locomotiveLength;
1823 // unset parameter
1824 parametersSet &= ~VTYPEPARS_LOCOMOTIVE_LENGTH_SET;
1825 // remove from params (needed for writting in XML)
1826 SUMOVTypeParameter::unsetParameter(toString(key));
1827 }
1828 break;
1829 case SUMO_ATTR_CARRIAGE_GAP:
1830 if (!value.empty() && (value != myTagProperty->getDefaultStringValue(key))) {
1831 carriageGap = parse<double>(value);
1832 // mark parameter as set
1833 parametersSet |= VTYPEPARS_CARRIAGE_GAP_SET;
1834 // set parameter in SUMOVTypeParameter (needed for writting in XML)
1835 SUMOVTypeParameter::setParameter(toString(key), value);
1836 } else {
1837 // set default value
1838 carriageGap = myTagProperty->getDefaultDoubleValue(key);
1839 // unset parameter
1840 parametersSet &= ~VTYPEPARS_CARRIAGE_GAP_SET;
1841 // remove from params (needed for writting in XML)
1842 SUMOVTypeParameter::unsetParameter(toString(key));
1843 }
1844 break;
1845 case GNE_ATTR_DEFAULT_VTYPE_MODIFIED:
1846 myDefaultVehicleTypeModified = parse<bool>(value);
1847 if (myDefaultVehicleTypeModified) {
1848 myFileBucket->removeDefaultVType();
1849 myFileBucket->addElement(false);
1850 } else {
1851 myFileBucket->addDefaultVType();
1852 myFileBucket->removeElement(false);
1853 }
1854 break;
1855 default:
1856 setCommonAttribute(key, value);
1857 break;
1858 }
1859 // check if geometry must be marked as deprecated
1860 if (myTagProperty->hasAttribute(key) && (myTagProperty->getAttributeProperties(key)->requireUpdateGeometry())) {
1861 updateGeometry();
1862 }
1863}
1864
1865
1866void
1867GNEVType::updateDefaultVClassAttributes(const VClassDefaultValues& defaultValues) {
1868 if (!wasSet(VTYPEPARS_LENGTH_SET)) {
1869 length = defaultValues.length;
1870 }
1871 if (!wasSet(VTYPEPARS_MINGAP_SET)) {
1872 minGap = defaultValues.minGap;
1873 }
1874 if (!wasSet(VTYPEPARS_MAXSPEED_SET)) {
1875 maxSpeed = defaultValues.maxSpeed;
1876 }
1877 if (!wasSet(VTYPEPARS_WIDTH_SET)) {
1878 width = defaultValues.width;
1879 }
1880 if (!wasSet(VTYPEPARS_HEIGHT_SET)) {
1881 height = defaultValues.height;
1882 }
1883 if (!wasSet(VTYPEPARS_SHAPE_SET)) {
1884 shape = defaultValues.shape;
1885 }
1886 if (!wasSet(VTYPEPARS_EMISSIONCLASS_SET)) {
1887 emissionClass = defaultValues.emissionClass;
1888 }
1889 if (!wasSet(VTYPEPARS_SPEEDFACTOR_SET)) {
1890 speedFactor = defaultValues.speedFactor;
1891 }
1892 if (!wasSet(VTYPEPARS_DESIRED_MAXSPEED_SET)) {
1893 desiredMaxSpeed = defaultValues.desiredMaxSpeed;
1894 }
1895 if (!wasSet(VTYPEPARS_PERSON_CAPACITY)) {
1896 personCapacity = defaultValues.personCapacity;
1897 }
1898 if (!wasSet(VTYPEPARS_CONTAINER_CAPACITY)) {
1899 containerCapacity = defaultValues.containerCapacity;
1900 }
1901 if (!wasSet(VTYPEPARS_OSGFILE_SET)) {
1902 osgFile = defaultValues.osgFile;
1903 }
1904 if (!wasSet(VTYPEPARS_CARRIAGE_LENGTH_SET)) {
1905 carriageLength = defaultValues.carriageLength;
1906 }
1907 if (!wasSet(VTYPEPARS_LOCOMOTIVE_LENGTH_SET)) {
1908 locomotiveLength = defaultValues.locomotiveLength;
1909 }
1910}
1911
1912/****************************************************************************/
GNEChange_Attribute.h
value
const std::string invalid_return< std::string >::value
Definition SUMOSAXAttributes.cpp:49
string2time
SUMOTime string2time(const std::string &r)
convert string to SUMOTime
Definition SUMOTime.cpp:46
time2string
std::string time2string(SUMOTime t, bool humanReadable)
convert SUMOTime to string (independently of global format setting)
Definition SUMOTime.cpp:91
VTYPEPARS_SHAPE_SET
const long long int VTYPEPARS_SHAPE_SET
Definition SUMOVTypeParameter.h:54
VTYPEPARS_LOADING_DURATION
const long long int VTYPEPARS_LOADING_DURATION
Definition SUMOVTypeParameter.h:62
VTYPEPARS_PERSON_CAPACITY
const long long int VTYPEPARS_PERSON_CAPACITY
Definition SUMOVTypeParameter.h:59
VTYPEPARS_CAR_FOLLOW_MODEL
const long long int VTYPEPARS_CAR_FOLLOW_MODEL
Definition SUMOVTypeParameter.h:63
VTYPEPARS_WIDTH_SET
const long long int VTYPEPARS_WIDTH_SET
Definition SUMOVTypeParameter.h:52
VTYPEPARS_CARRIAGE_LENGTH_SET
const long long int VTYPEPARS_CARRIAGE_LENGTH_SET
Definition SUMOVTypeParameter.h:69
VTYPEPARS_ACTIONSTEPLENGTH_SET
const long long int VTYPEPARS_ACTIONSTEPLENGTH_SET
Definition SUMOVTypeParameter.h:67
VTYPEPARS_MAXSPEED_LAT_SET
const long long int VTYPEPARS_MAXSPEED_LAT_SET
Definition SUMOVTypeParameter.h:64
VTYPEPARS_MAXSPEED_SET
const long long int VTYPEPARS_MAXSPEED_SET
Definition SUMOVTypeParameter.h:46
VTYPEPARS_EMISSIONCLASS_SET
const long long int VTYPEPARS_EMISSIONCLASS_SET
Definition SUMOVTypeParameter.h:49
VTYPEPARS_LATALIGNMENT_SET
const long long int VTYPEPARS_LATALIGNMENT_SET
Definition SUMOVTypeParameter.h:65
VTYPEPARS_COLOR_SET
const long long int VTYPEPARS_COLOR_SET
Definition SUMOVTypeParameter.h:50
VTYPEPARS_LANE_CHANGE_MODEL_SET
const long long int VTYPEPARS_LANE_CHANGE_MODEL_SET
Definition SUMOVTypeParameter.h:58
VTYPEPARS_DESIRED_MAXSPEED_SET
const long long int VTYPEPARS_DESIRED_MAXSPEED_SET
Definition SUMOVTypeParameter.h:68
VTYPEPARS_OSGFILE_SET
const long long int VTYPEPARS_OSGFILE_SET
Definition SUMOVTypeParameter.h:55
VTYPEPARS_SPEEDFACTOR_SET
const long long int VTYPEPARS_SPEEDFACTOR_SET
Definition SUMOVTypeParameter.h:48
VTYPEPARS_CARRIAGE_GAP_SET
const long long int VTYPEPARS_CARRIAGE_GAP_SET
Definition SUMOVTypeParameter.h:71
VTYPEPARS_MINGAP_SET
const long long int VTYPEPARS_MINGAP_SET
Definition SUMOVTypeParameter.h:45
VTYPEPARS_PROBABILITY_SET
const long long int VTYPEPARS_PROBABILITY_SET
Definition SUMOVTypeParameter.h:47
VTYPEPARS_HEIGHT_SET
const long long int VTYPEPARS_HEIGHT_SET
Definition SUMOVTypeParameter.h:53
VTYPEPARS_PARKING_BADGES_SET
const long long int VTYPEPARS_PARKING_BADGES_SET
Definition SUMOVTypeParameter.h:81
VTYPEPARS_BOARDING_DURATION
const long long int VTYPEPARS_BOARDING_DURATION
Definition SUMOVTypeParameter.h:60
LatAlignmentDefinition::GIVEN
@ GIVEN
The alignment as offset is given.
Definition SUMOVTypeParameter.h:100
VTYPEPARS_VEHICLECLASS_SET
const long long int VTYPEPARS_VEHICLECLASS_SET
Definition SUMOVTypeParameter.h:51
VTYPEPARS_IMPATIENCE_SET
const long long int VTYPEPARS_IMPATIENCE_SET
Definition SUMOVTypeParameter.h:57
VTYPEPARS_LENGTH_SET
const long long int VTYPEPARS_LENGTH_SET
Definition SUMOVTypeParameter.h:44
VTYPEPARS_IMGFILE_SET
const long long int VTYPEPARS_IMGFILE_SET
Definition SUMOVTypeParameter.h:56
VTYPEPARS_CONTAINER_CAPACITY
const long long int VTYPEPARS_CONTAINER_CAPACITY
Definition SUMOVTypeParameter.h:61
VTYPEPARS_MINGAP_LAT_SET
const long long int VTYPEPARS_MINGAP_LAT_SET
Definition SUMOVTypeParameter.h:66
VTYPEPARS_LOCOMOTIVE_LENGTH_SET
const long long int VTYPEPARS_LOCOMOTIVE_LENGTH_SET
Definition SUMOVTypeParameter.h:70
canParseVehicleShape
bool canParseVehicleShape(const std::string &shape)
Checks whether the given string contains only known vehicle shape.
Definition SUMOVehicleClass.cpp:496
SumoVehicleShapeStrings
StringBijection< SUMOVehicleShape > SumoVehicleShapeStrings(sumoVehicleShapeStringInitializer, SUMOVehicleShape::UNKNOWN, false)
getVehicleClassID
SUMOVehicleClass getVehicleClassID(const std::string &name)
Returns the class id of the abstract class given by its name.
Definition SUMOVehicleClass.cpp:324
getVehicleShapeID
SUMOVehicleShape getVehicleShapeID(const std::string &name)
Returns the class id of the shape class given by its name.
Definition SUMOVehicleClass.cpp:486
canParseVehicleClasses
bool canParseVehicleClasses(const std::string &classes)
Checks whether the given string contains only known vehicle classes.
Definition SUMOVehicleClass.cpp:381
getVehicleShapeName
std::string getVehicleShapeName(SUMOVehicleShape id)
Returns the class name of the shape class given by its id.
Definition SUMOVehicleClass.cpp:502
DEFAULT_TAXITYPE_ID
const std::string DEFAULT_TAXITYPE_ID
DEFAULT_RAILTYPE_ID
const std::string DEFAULT_RAILTYPE_ID
DEFAULT_PEDTYPE_ID
const std::string DEFAULT_PEDTYPE_ID
DEFAULT_VTYPE_ID
const std::string DEFAULT_VTYPE_ID
SUMOVehicleClass
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types.
Definition SUMOVehicleClass.h:140
SVC_PASSENGER
@ SVC_PASSENGER
vehicle is a passenger car (a "normal" car)
Definition SUMOVehicleClass.h:166
DEFAULT_BIKETYPE_ID
const std::string DEFAULT_BIKETYPE_ID
SumoXMLTag
SumoXMLTag
Numbers representing SUMO-XML - element names.
Definition SUMOXMLDefinitions.h:41
SUMO_TAG_VTYPE
@ SUMO_TAG_VTYPE
description of a vehicle/person/container type
Definition SUMOXMLDefinitions.h:177
SumoXMLAttr
SumoXMLAttr
Numbers representing SUMO-XML - attributes.
Definition SUMOXMLDefinitions.h:775
SUMO_ATTR_TMP4
@ SUMO_ATTR_TMP4
Definition SUMOXMLDefinitions.h:1193
SUMO_ATTR_CF_W99_CC9
@ SUMO_ATTR_CF_W99_CC9
Definition SUMOXMLDefinitions.h:1617
SUMO_ATTR_CF_EIDM_T_ACC_MAX
@ SUMO_ATTR_CF_EIDM_T_ACC_MAX
Definition SUMOXMLDefinitions.h:1207
SUMO_ATTR_CF_EIDM_EPSILON_ACC
@ SUMO_ATTR_CF_EIDM_EPSILON_ACC
Definition SUMOXMLDefinitions.h:1206
SUMO_ATTR_CF_W99_CC5
@ SUMO_ATTR_CF_W99_CC5
Definition SUMOXMLDefinitions.h:1613
SUMO_ATTR_LCA_PUSHY
@ SUMO_ATTR_LCA_PUSHY
Definition SUMOXMLDefinitions.h:1264
SUMO_ATTR_EMISSIONCLASS
@ SUMO_ATTR_EMISSIONCLASS
Definition SUMOXMLDefinitions.h:1555
SUMO_ATTR_JM_IGNORE_FOE_SPEED
@ SUMO_ATTR_JM_IGNORE_FOE_SPEED
Definition SUMOXMLDefinitions.h:1299
SUMO_ATTR_JM_IGNORE_KEEPCLEAR_TIME
@ SUMO_ATTR_JM_IGNORE_KEEPCLEAR_TIME
Definition SUMOXMLDefinitions.h:1298
SUMO_ATTR_CF_EIDM_T_LOOK_AHEAD
@ SUMO_ATTR_CF_EIDM_T_LOOK_AHEAD
Definition SUMOXMLDefinitions.h:1197
SUMO_ATTR_CF_WIEDEMANN_SECURITY
@ SUMO_ATTR_CF_WIEDEMANN_SECURITY
Definition SUMOXMLDefinitions.h:1607
SUMO_ATTR_LCA_ASSERTIVE
@ SUMO_ATTR_LCA_ASSERTIVE
Definition SUMOXMLDefinitions.h:1267
SUMO_ATTR_TRAIN_TYPE
@ SUMO_ATTR_TRAIN_TYPE
Definition SUMOXMLDefinitions.h:1242
SUMO_ATTR_CF_EIDM_USEVEHDYNAMICS
@ SUMO_ATTR_CF_EIDM_USEVEHDYNAMICS
Definition SUMOXMLDefinitions.h:1196
SUMO_ATTR_CF_IDMM_ADAPT_TIME
@ SUMO_ATTR_CF_IDMM_ADAPT_TIME
Definition SUMOXMLDefinitions.h:1605
SUMO_ATTR_LANE_CHANGE_MODEL
@ SUMO_ATTR_LANE_CHANGE_MODEL
Definition SUMOXMLDefinitions.h:966
SUMO_ATTR_CF_KERNER_PHI
@ SUMO_ATTR_CF_KERNER_PHI
Definition SUMOXMLDefinitions.h:1606
SUMO_ATTR_LCA_TURN_ALIGNMENT_DISTANCE
@ SUMO_ATTR_LCA_TURN_ALIGNMENT_DISTANCE
Definition SUMOXMLDefinitions.h:1282
SUMO_ATTR_PARKING_BADGES
@ SUMO_ATTR_PARKING_BADGES
Definition SUMOXMLDefinitions.h:980
SUMO_ATTR_CF_EIDM_C_COOLNESS
@ SUMO_ATTR_CF_EIDM_C_COOLNESS
Definition SUMOXMLDefinitions.h:1201
SUMO_ATTR_CF_EIDM_SIG_ERROR
@ SUMO_ATTR_CF_EIDM_SIG_ERROR
Definition SUMOXMLDefinitions.h:1204
SUMO_ATTR_LCA_PUSHYGAP
@ SUMO_ATTR_LCA_PUSHYGAP
Definition SUMOXMLDefinitions.h:1265
SUMO_ATTR_LCA_LOOKAHEADLEFT
@ SUMO_ATTR_LCA_LOOKAHEADLEFT
Definition SUMOXMLDefinitions.h:1271
SUMO_ATTR_APPARENTDECEL
@ SUMO_ATTR_APPARENTDECEL
Definition SUMOXMLDefinitions.h:956
SUMO_ATTR_MAXSPEED_LAT
@ SUMO_ATTR_MAXSPEED_LAT
Definition SUMOXMLDefinitions.h:950
SUMO_ATTR_LCA_SPEEDGAIN_PARAM
@ SUMO_ATTR_LCA_SPEEDGAIN_PARAM
Definition SUMOXMLDefinitions.h:1260
SUMO_ATTR_TMP3
@ SUMO_ATTR_TMP3
Definition SUMOXMLDefinitions.h:1192
SUMO_ATTR_ACTIONSTEPLENGTH
@ SUMO_ATTR_ACTIONSTEPLENGTH
Definition SUMOXMLDefinitions.h:959
SUMO_ATTR_LCA_IMPATIENCE
@ SUMO_ATTR_LCA_IMPATIENCE
Definition SUMOXMLDefinitions.h:1268
SUMO_ATTR_MINGAP
@ SUMO_ATTR_MINGAP
Definition SUMOXMLDefinitions.h:968
GNE_ATTR_PARAMETERS
@ GNE_ATTR_PARAMETERS
parameters "key1=value1|key2=value2|...|keyN=valueN"
Definition SUMOXMLDefinitions.h:1779
SUMO_ATTR_JM_DRIVE_AFTER_RED_TIME
@ SUMO_ATTR_JM_DRIVE_AFTER_RED_TIME
Definition SUMOXMLDefinitions.h:1296
SUMO_ATTR_TMP2
@ SUMO_ATTR_TMP2
Definition SUMOXMLDefinitions.h:1191
SUMO_ATTR_CF_W99_CC8
@ SUMO_ATTR_CF_W99_CC8
Definition SUMOXMLDefinitions.h:1616
SUMO_ATTR_LOADING_DURATION
@ SUMO_ATTR_LOADING_DURATION
Definition SUMOXMLDefinitions.h:971
SUMO_ATTR_CF_IDM_DELTA
@ SUMO_ATTR_CF_IDM_DELTA
Definition SUMOXMLDefinitions.h:1602
SUMO_ATTR_CF_EIDM_MAX_VEH_PREVIEW
@ SUMO_ATTR_CF_EIDM_MAX_VEH_PREVIEW
Definition SUMOXMLDefinitions.h:1210
SUMO_ATTR_LCA_MAXSPEEDLATFACTOR
@ SUMO_ATTR_LCA_MAXSPEEDLATFACTOR
Definition SUMOXMLDefinitions.h:1280
GNE_ATTR_DEFAULT_VTYPE
@ GNE_ATTR_DEFAULT_VTYPE
Flag to check if VType is a default VType.
Definition SUMOXMLDefinitions.h:1797
SUMO_ATTR_CF_EIDM_T_REACTION
@ SUMO_ATTR_CF_EIDM_T_REACTION
Definition SUMOXMLDefinitions.h:1199
SUMO_ATTR_CF_EIDM_T_PERSISTENCE_ESTIMATE
@ SUMO_ATTR_CF_EIDM_T_PERSISTENCE_ESTIMATE
Definition SUMOXMLDefinitions.h:1200
SUMO_ATTR_CF_PWAGNER2009_TAULAST
@ SUMO_ATTR_CF_PWAGNER2009_TAULAST
Definition SUMOXMLDefinitions.h:1600
SUMO_ATTR_CF_EIDM_SIG_GAP
@ SUMO_ATTR_CF_EIDM_SIG_GAP
Definition SUMOXMLDefinitions.h:1203
SUMO_ATTR_CAR_FOLLOW_MODEL
@ SUMO_ATTR_CAR_FOLLOW_MODEL
Definition SUMOXMLDefinitions.h:967
SUMO_ATTR_CF_EIDM_JERK_MAX
@ SUMO_ATTR_CF_EIDM_JERK_MAX
Definition SUMOXMLDefinitions.h:1205
SUMO_ATTR_DECEL
@ SUMO_ATTR_DECEL
Definition SUMOXMLDefinitions.h:954
SUMO_ATTR_LCA_MAXSPEEDLATSTANDING
@ SUMO_ATTR_LCA_MAXSPEEDLATSTANDING
Definition SUMOXMLDefinitions.h:1279
SUMO_ATTR_JM_DRIVE_AFTER_YELLOW_TIME
@ SUMO_ATTR_JM_DRIVE_AFTER_YELLOW_TIME
Definition SUMOXMLDefinitions.h:1295
SUMO_ATTR_LCA_KEEPRIGHT_PARAM
@ SUMO_ATTR_LCA_KEEPRIGHT_PARAM
Definition SUMOXMLDefinitions.h:1261
SUMO_ATTR_GUISHAPE
@ SUMO_ATTR_GUISHAPE
Definition SUMOXMLDefinitions.h:1552
SUMO_ATTR_DESIRED_MAXSPEED
@ SUMO_ATTR_DESIRED_MAXSPEED
Definition SUMOXMLDefinitions.h:949
SUMO_ATTR_JM_IGNORE_FOE_PROB
@ SUMO_ATTR_JM_IGNORE_FOE_PROB
Definition SUMOXMLDefinitions.h:1300
SUMO_ATTR_CONTAINER_CAPACITY
@ SUMO_ATTR_CONTAINER_CAPACITY
Definition SUMOXMLDefinitions.h:1354
SUMO_ATTR_LCA_COOPERATIVE_PARAM
@ SUMO_ATTR_LCA_COOPERATIVE_PARAM
Definition SUMOXMLDefinitions.h:1259
SUMO_ATTR_LCA_OPPOSITE_PARAM
@ SUMO_ATTR_LCA_OPPOSITE_PARAM
Definition SUMOXMLDefinitions.h:1263
SUMO_ATTR_MINGAP_LAT
@ SUMO_ATTR_MINGAP_LAT
Definition SUMOXMLDefinitions.h:952
SUMO_ATTR_EMERGENCYDECEL
@ SUMO_ATTR_EMERGENCYDECEL
Definition SUMOXMLDefinitions.h:955
SUMO_ATTR_CF_W99_CC3
@ SUMO_ATTR_CF_W99_CC3
Definition SUMOXMLDefinitions.h:1611
SUMO_ATTR_LCA_OVERTAKE_DELTASPEED_FACTOR
@ SUMO_ATTR_LCA_OVERTAKE_DELTASPEED_FACTOR
Definition SUMOXMLDefinitions.h:1287
SUMO_ATTR_HEIGHT
@ SUMO_ATTR_HEIGHT
Definition SUMOXMLDefinitions.h:1551
SUMO_ATTR_LCA_SUBLANE_PARAM
@ SUMO_ATTR_LCA_SUBLANE_PARAM
Definition SUMOXMLDefinitions.h:1262
SUMO_ATTR_JM_CROSSING_GAP
@ SUMO_ATTR_JM_CROSSING_GAP
Definition SUMOXMLDefinitions.h:1294
SUMO_ATTR_CARRIAGE_LENGTH
@ SUMO_ATTR_CARRIAGE_LENGTH
Definition SUMOXMLDefinitions.h:1859
SUMO_ATTR_LATALIGNMENT
@ SUMO_ATTR_LATALIGNMENT
Definition SUMOXMLDefinitions.h:951
SUMO_ATTR_CF_IDM_STEPPING
@ SUMO_ATTR_CF_IDM_STEPPING
Definition SUMOXMLDefinitions.h:1603
SUMO_ATTR_CF_IDMM_ADAPT_FACTOR
@ SUMO_ATTR_CF_IDMM_ADAPT_FACTOR
Definition SUMOXMLDefinitions.h:1604
SUMO_ATTR_IMPATIENCE
@ SUMO_ATTR_IMPATIENCE
Definition SUMOXMLDefinitions.h:1557
SUMO_ATTR_COLLISION_MINGAP_FACTOR
@ SUMO_ATTR_COLLISION_MINGAP_FACTOR
Definition SUMOXMLDefinitions.h:969
SUMO_ATTR_VCLASS
@ SUMO_ATTR_VCLASS
Definition SUMOXMLDefinitions.h:960
SUMO_ATTR_ACCEL
@ SUMO_ATTR_ACCEL
Definition SUMOXMLDefinitions.h:953
SUMO_ATTR_BOARDING_DURATION
@ SUMO_ATTR_BOARDING_DURATION
Definition SUMOXMLDefinitions.h:970
SUMO_ATTR_CF_EIDM_M_FLATNESS
@ SUMO_ATTR_CF_EIDM_M_FLATNESS
Definition SUMOXMLDefinitions.h:1208
SUMO_ATTR_CF_W99_CC2
@ SUMO_ATTR_CF_W99_CC2
Definition SUMOXMLDefinitions.h:1610
SUMO_ATTR_CF_W99_CC4
@ SUMO_ATTR_CF_W99_CC4
Definition SUMOXMLDefinitions.h:1612
SUMO_ATTR_JM_SIGMA_MINOR
@ SUMO_ATTR_JM_SIGMA_MINOR
Definition SUMOXMLDefinitions.h:1302
SUMO_ATTR_CF_W99_CC6
@ SUMO_ATTR_CF_W99_CC6
Definition SUMOXMLDefinitions.h:1614
SUMO_ATTR_PROB
@ SUMO_ATTR_PROB
Definition SUMOXMLDefinitions.h:1325
SUMO_ATTR_CF_EIDM_M_BEGIN
@ SUMO_ATTR_CF_EIDM_M_BEGIN
Definition SUMOXMLDefinitions.h:1209
SUMO_ATTR_CF_EIDM_T_PERSISTENCE_DRIVE
@ SUMO_ATTR_CF_EIDM_T_PERSISTENCE_DRIVE
Definition SUMOXMLDefinitions.h:1198
SUMO_ATTR_SPEEDFACTOR
@ SUMO_ATTR_SPEEDFACTOR
Definition SUMOXMLDefinitions.h:964
SUMO_ATTR_CF_EIDM_SIG_LEADER
@ SUMO_ATTR_CF_EIDM_SIG_LEADER
Definition SUMOXMLDefinitions.h:1202
SUMO_ATTR_LENGTH
@ SUMO_ATTR_LENGTH
Definition SUMOXMLDefinitions.h:900
SUMO_ATTR_COLOR
@ SUMO_ATTR_COLOR
A color information.
Definition SUMOXMLDefinitions.h:1416
SUMO_ATTR_CF_PWAGNER2009_APPROB
@ SUMO_ATTR_CF_PWAGNER2009_APPROB
Definition SUMOXMLDefinitions.h:1601
SUMO_ATTR_MAXSPEED
@ SUMO_ATTR_MAXSPEED
Definition SUMOXMLDefinitions.h:948
SUMO_ATTR_ID
@ SUMO_ATTR_ID
Definition SUMOXMLDefinitions.h:885
SUMO_ATTR_SIGMA
@ SUMO_ATTR_SIGMA
Definition SUMOXMLDefinitions.h:1186
GNE_ATTR_DEFAULT_VTYPE_MODIFIED
@ GNE_ATTR_DEFAULT_VTYPE_MODIFIED
Flag to check if a default VType was modified.
Definition SUMOXMLDefinitions.h:1799
SUMO_ATTR_K
@ SUMO_ATTR_K
Definition SUMOXMLDefinitions.h:1585
SUMO_ATTR_TMP1
@ SUMO_ATTR_TMP1
Definition SUMOXMLDefinitions.h:1190
SUMO_ATTR_OSGFILE
@ SUMO_ATTR_OSGFILE
Definition SUMOXMLDefinitions.h:1553
SUMO_ATTR_LCA_OVERTAKE_RIGHT
@ SUMO_ATTR_LCA_OVERTAKE_RIGHT
Definition SUMOXMLDefinitions.h:1283
SUMO_ATTR_LCA_ACCEL_LAT
@ SUMO_ATTR_LCA_ACCEL_LAT
Definition SUMOXMLDefinitions.h:1270
SUMO_ATTR_CF_W99_CC7
@ SUMO_ATTR_CF_W99_CC7
Definition SUMOXMLDefinitions.h:1615
SUMO_ATTR_LCA_STRATEGIC_PARAM
@ SUMO_ATTR_LCA_STRATEGIC_PARAM
Definition SUMOXMLDefinitions.h:1258
SUMO_ATTR_CF_W99_CC1
@ SUMO_ATTR_CF_W99_CC1
Definition SUMOXMLDefinitions.h:1609
SUMO_ATTR_TAU
@ SUMO_ATTR_TAU
Definition SUMOXMLDefinitions.h:1189
SUMO_ATTR_IMGFILE
@ SUMO_ATTR_IMGFILE
Definition SUMOXMLDefinitions.h:1554
SUMO_ATTR_WIDTH
@ SUMO_ATTR_WIDTH
Definition SUMOXMLDefinitions.h:893
SUMO_ATTR_PERSON_CAPACITY
@ SUMO_ATTR_PERSON_CAPACITY
Definition SUMOXMLDefinitions.h:1353
SUMO_ATTR_LCA_KEEPRIGHT_ACCEPTANCE_TIME
@ SUMO_ATTR_LCA_KEEPRIGHT_ACCEPTANCE_TIME
Definition SUMOXMLDefinitions.h:1286
SUMO_ATTR_LCA_EXPERIMENTAL1
@ SUMO_ATTR_LCA_EXPERIMENTAL1
Definition SUMOXMLDefinitions.h:1289
SUMO_ATTR_LOCOMOTIVE_LENGTH
@ SUMO_ATTR_LOCOMOTIVE_LENGTH
Definition SUMOXMLDefinitions.h:1860
SUMO_ATTR_TMP5
@ SUMO_ATTR_TMP5
Definition SUMOXMLDefinitions.h:1194
SUMO_ATTR_JM_DRIVE_RED_SPEED
@ SUMO_ATTR_JM_DRIVE_RED_SPEED
Definition SUMOXMLDefinitions.h:1297
SUMO_ATTR_LCA_TIME_TO_IMPATIENCE
@ SUMO_ATTR_LCA_TIME_TO_IMPATIENCE
Definition SUMOXMLDefinitions.h:1269
SUMO_ATTR_JM_TIMEGAP_MINOR
@ SUMO_ATTR_JM_TIMEGAP_MINOR
Definition SUMOXMLDefinitions.h:1306
SUMO_ATTR_CARRIAGE_GAP
@ SUMO_ATTR_CARRIAGE_GAP
Definition SUMOXMLDefinitions.h:1861
SUMO_ATTR_CF_WIEDEMANN_ESTIMATION
@ SUMO_ATTR_CF_WIEDEMANN_ESTIMATION
Definition SUMOXMLDefinitions.h:1608
SUMO_ATTR_LCA_SPEEDGAINRIGHT
@ SUMO_ATTR_LCA_SPEEDGAINRIGHT
Definition SUMOXMLDefinitions.h:1272
joinToString
std::string joinToString(const std::vector< T > &v, const T_BETWEEN &between, std::streamsize accuracy=gPrecision)
Definition ToString.h:314
toString
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition ToString.h:49
Boundary
A class that stores a 2D geometrical boundary.
Definition Boundary.h:39
Distribution_Parameterized::isValidDescription
static bool isValidDescription(const std::string &description)
validate input description
Definition Distribution_Parameterized.cpp:91
GNEAttributeCarrier::getCommonAttributeDouble
double getCommonAttributeDouble(SumoXMLAttr key) const
Definition GNEAttributeCarrier.cpp:882
GNEAttributeCarrier::myFileBucket
FileBucket * myFileBucket
filebucket vinculated whith this AC
Definition GNEAttributeCarrier.h:416
GNEAttributeCarrier::FALSE_STR
static const std::string FALSE_STR
true value in string format(used for comparing boolean values in getAttribute(...))
Definition GNEAttributeCarrier.h:397
GNEAttributeCarrier::TRUE_STR
static const std::string TRUE_STR
true value in string format (used for comparing boolean values in getAttribute(......
Definition GNEAttributeCarrier.h:394
GNEAttributeCarrier::getID
const std::string getID() const override
get ID (all Attribute Carriers have one)
Definition GNEAttributeCarrier.cpp:95
GNEAttributeCarrier::parse
static T parse(const std::string &string)
parses a value of type T from string (used for basic types: int, double, bool, etc....
GNEAttributeCarrier::setCommonAttribute
void setCommonAttribute(SumoXMLAttr key, const std::string &value, GNEUndoList *undoList)
Definition GNEAttributeCarrier.cpp:900
GNEAttributeCarrier::getTagStr
const std::string & getTagStr() const
get tag assigned to this object in string format
Definition GNEAttributeCarrier.cpp:818
GNEAttributeCarrier::getCommonAttributePosition
Position getCommonAttributePosition(SumoXMLAttr key) const
Definition GNEAttributeCarrier.cpp:888
GNEAttributeCarrier::canParse
static bool canParse(const std::string &string)
true if a value of type T can be parsed from string
GNEAttributeCarrier::getTagProperty
const GNETagProperties * getTagProperty() const
get tagProperty associated with this Attribute Carrier
Definition GNEAttributeCarrier.cpp:841
GNEAttributeCarrier::myNet
GNENet * myNet
pointer to net
Definition GNEAttributeCarrier.h:404
GNEAttributeCarrier::getNet
GNENet * getNet() const
get pointer to net
Definition GNEAttributeCarrier.cpp:101
GNEAttributeCarrier::isCommonAttributeValid
bool isCommonAttributeValid(SumoXMLAttr key, const std::string &value) const
Definition GNEAttributeCarrier.cpp:915
GNEAttributeCarrier::setAttribute
virtual void setAttribute(SumoXMLAttr key, const std::string &value, GNEUndoList *undoList)=0
GNEAttributeCarrier::getAttribute
virtual std::string getAttribute(SumoXMLAttr key) const =0
GNEAttributeCarrier::getCommonAttribute
std::string getCommonAttribute(SumoXMLAttr key) const
Definition GNEAttributeCarrier.cpp:847
GNEAttributeCarrier::myTagProperty
const GNETagProperties * myTagProperty
reference to tagProperty associated with this attribute carrier
Definition GNEAttributeCarrier.h:401
GNEChange_Attribute::changeAttribute
static void changeAttribute(GNEAttributeCarrier *AC, SumoXMLAttr key, const std::string &value, GNEUndoList *undoList, const bool force=false)
change attribute
Definition GNEChange_Attribute.cpp:42
GNEDemandElement::isValidDemandElementID
bool isValidDemandElementID(const std::string &value) const
check if a new demand element ID is valid
Definition GNEDemandElement.cpp:449
GNEDemandElement::setDemandElementID
void setDemandElementID(const std::string &newID)
set demand element id
Definition GNEDemandElement.cpp:475
GNEDemandElement::getFileBucket
FileBucket * getFileBucket() const override
get reference to fileBucket in which save this AC
Definition GNEDemandElement.cpp:97
GNEDemandElement::GNEDemandElement
GNEDemandElement(GNENet *net, SumoXMLTag tag)
Constructor for templates.
Definition GNEDemandElement.cpp:49
GNEDemandElement::Problem
Problem
enum class for demandElement problems
Definition GNEDemandElement.h:48
GNEHierarchicalElement::getChildDemandElements
const GNEHierarchicalContainerChildren< GNEDemandElement * > & getChildDemandElements() const
return child demand elements
Definition GNEHierarchicalElement.cpp:143
GNEUndoList::end
void end()
End undo command sub-group. If the sub-group is still empty, it will be deleted; otherwise,...
Definition GNEUndoList.cpp:247
GNEUndoList::begin
void begin(GUIIcon icon, const std::string &description)
Begin undo command sub-group with current supermode. This begins a new group of commands that are tre...
Definition GNEUndoList.cpp:209
GNEVType::getColor
const RGBColor & getColor() const override
get color
Definition GNEVType.cpp:162
GNEVType::getMoveElement
GNEMoveElement * getMoveElement() const override
methods to retrieve the elements linked to this vType
Definition GNEVType.cpp:106
GNEVType::getPositionInView
Position getPositionInView() const override
Returns position of additional in view.
Definition GNEVType.cpp:177
GNEVType::~GNEVType
~GNEVType()
destructor
Definition GNEVType.cpp:102
GNEVType::isAttributeEnabled
bool isAttributeEnabled(SumoXMLAttr key) const override
Definition GNEVType.cpp:923
GNEVType::getFirstPathLane
GNELane * getFirstPathLane() const override
get first path lane
Definition GNEVType.cpp:226
GNEVType::getVClass
SUMOVehicleClass getVClass() const override
obtain VClass related with this demand element
Definition GNEVType.cpp:156
GNEVType::splitEdgeGeometry
void splitEdgeGeometry(const double splitPosition, const GNENetworkElement *originalElement, const GNENetworkElement *newElement, GNEUndoList *undoList) override
split geometry
Definition GNEVType.cpp:196
GNEVType::getAttribute
std::string getAttribute(SumoXMLAttr key) const override
inherited from GNEAttributeCarrier
Definition GNEVType.cpp:240
GNEVType::getParameters
Parameterised * getParameters() override
get parameters associated with this vType
Definition GNEVType.cpp:112
GNEVType::overwriteVType
static bool overwriteVType(GNEDemandElement *vType, const SUMOVTypeParameter newVTypeParameter, GNEUndoList *undoList)
overwrite all values of GNEVType with a SUMOVTypeParameter
Definition GNEVType.cpp:976
GNEVType::fixDemandElementProblem
void fixDemandElementProblem() override
fix demand element problem
Definition GNEVType.cpp:150
GNEVType::getAttributeDouble
double getAttributeDouble(SumoXMLAttr key) const override
Definition GNEVType.cpp:529
GNEVType::writeDemandElement
void writeDemandElement(OutputDevice &device) const override
write demand element element into a xml file
Definition GNEVType.cpp:124
GNEVType::getDemandElementProblem
std::string getDemandElementProblem() const override
return a string with the current demand element problem
Definition GNEVType.cpp:144
GNEVType::updateDefaultVClassAttributes
void updateDefaultVClassAttributes(const VClassDefaultValues &defaultValues)
function called after set new VClass
Definition GNEVType.cpp:1867
GNEVType::drawLanePartialGL
void drawLanePartialGL(const GUIVisualizationSettings &s, const GNESegment *segment, const double offsetFront) const override
Draws partial object over lane.
Definition GNEVType.cpp:214
GNEVType::isValid
bool isValid(SumoXMLAttr key, const std::string &value) override
Definition GNEVType.cpp:716
GNEVType::myDefaultVehicleType
bool myDefaultVehicleType
flag to check if this GNEVType is a default vehicle Type (For Vehicles, Pedestrians....
Definition GNEVType.h:205
GNEVType::getLastPathLane
GNELane * getLastPathLane() const override
get last path lane
Definition GNEVType.cpp:233
GNEVType::getCenteringBoundary
Boundary getCenteringBoundary() const override
Returns the boundary to which the view shall be centered in order to show the object.
Definition GNEVType.cpp:189
GNEVType::updateGeometry
void updateGeometry() override
update pre-computed geometry information
Definition GNEVType.cpp:168
GNEVType::GNEVType
GNEVType(SumoXMLTag tag, GNENet *net)
default constructor
Definition GNEVType.cpp:34
GNEVType::drawGL
void drawGL(const GUIVisualizationSettings &s) const override
Draws the object.
Definition GNEVType.cpp:202
GNEVType::isDemandElementValid
Problem isDemandElementValid() const override
check if current demand element is valid to be written into XML
Definition GNEVType.cpp:137
GNEVType::getPopUpID
std::string getPopUpID() const override
get PopPup ID (Used in AC Hierarchy)
Definition GNEVType.cpp:964
GNEVType::getAttributePosition
Position getAttributePosition(SumoXMLAttr key) const override
Definition GNEVType.cpp:576
GNEVType::getParentName
std::string getParentName() const override
Returns the name of the parent object.
Definition GNEVType.cpp:183
GNEVType::getHierarchyName
std::string getHierarchyName() const override
get Hierarchy Name (Used in AC Hierarchy)
Definition GNEVType.cpp:970
GNEVType::drawJunctionPartialGL
void drawJunctionPartialGL(const GUIVisualizationSettings &s, const GNESegment *segment, const double offsetFront) const override
Draws partial object over junction.
Definition GNEVType.cpp:220
GNEVType::computePathElement
void computePathElement() override
compute pathElement
Definition GNEVType.cpp:208
GNEVType::setAttribute
void setAttribute(SumoXMLAttr key, const std::string &value, GNEUndoList *undoList) override
Definition GNEVType.cpp:582
GNEVType::myDefaultVehicleTypeModified
bool myDefaultVehicleTypeModified
flag to check if this default GNEVType was modified
Definition GNEVType.h:208
GUIGlObject::getMicrosimID
const std::string & getMicrosimID() const
Returns the id of the object as known to microsim.
Definition GUIGlObject.h:144
GUIVisualizationSettings
Stores the information about how to visualize structures.
Definition GUIVisualizationSettings.h:587
NamespaceIDs::types
static const std::vector< SumoXMLTag > types
type namespace
Definition NamespaceIDs.h:64
OutputDevice
Static storage of an output device and its base (abstract) implementation.
Definition OutputDevice.h:64
Parameterised
An upper class for objects with additional parameters.
Definition Parameterised.h:41
Parameterised::unsetParameter
void unsetParameter(const std::string &key)
Removes a parameter.
Definition Parameterised.cpp:51
Parameterised::hasParameter
bool hasParameter(const std::string &key) const
Returns whether the parameter is set.
Definition Parameterised.cpp:84
Parameterised::getParameter
virtual const std::string getParameter(const std::string &key, const std::string defaultValue="") const
Returns the value for a given key.
Definition Parameterised.cpp:90
Parameterised::getParametersMap
const Parameterised::Map & getParametersMap() const
Returns the inner key/value map.
Definition Parameterised.cpp:124
Parameterised::setParameter
virtual void setParameter(const std::string &key, const std::string &value)
Sets a parameter.
Definition Parameterised.cpp:45
Position
A point in 2D or 3D with translation and scaling methods.
Definition Position.h:37
SUMOVTypeParameter::locomotiveLength
double locomotiveLength
the length of the locomotive
Definition SUMOVTypeParameter.h:388
SUMOVTypeParameter::isValidLatAlignment
static bool isValidLatAlignment(const std::string &val)
Definition SUMOVTypeParameter.h:483
SUMOVTypeParameter::width
double width
This class' width.
Definition SUMOVTypeParameter.h:335
SUMOVTypeParameter::cfParameter
SubParams cfParameter
Car-following parameter.
Definition SUMOVTypeParameter.h:358
SUMOVTypeParameter::write
void write(OutputDevice &dev) const
Writes the vtype.
Definition SUMOVTypeParameter.cpp:452
SUMOVTypeParameter::defaultProbability
double defaultProbability
The probability when being added to a distribution without an explicit probability.
Definition SUMOVTypeParameter.h:296
SUMOVTypeParameter::actionStepLength
SUMOTime actionStepLength
The vehicle type's default actionStepLength [ms], i.e. the interval between two control actions....
Definition SUMOVTypeParameter.h:293
SUMOVTypeParameter::wasSet
bool wasSet(long long int what) const
Returns whether the given parameter was set.
Definition SUMOVTypeParameter.h:209
SUMOVTypeParameter::height
double height
This class' height.
Definition SUMOVTypeParameter.h:338
SUMOVTypeParameter::desiredMaxSpeed
double desiredMaxSpeed
The vehicle type's desired maximum speed [m/s].
Definition SUMOVTypeParameter.h:289
SUMOVTypeParameter::emissionClass
SUMOEmissionClass emissionClass
The emission class of this vehicle.
Definition SUMOVTypeParameter.h:302
SUMOVTypeParameter::latAlignmentOffset
double latAlignmentOffset
(optional) The vehicle's desired lateral alignment as offset in m from center line
Definition SUMOVTypeParameter.h:373
SUMOVTypeParameter::getJMParamString
std::string getJMParamString(const SumoXMLAttr attr, const std::string defaultValue) const
Returns the named value from the map, or the default if it is not contained there.
Definition SUMOVTypeParameter.cpp:727
SUMOVTypeParameter::carriageLength
double carriageLength
the length of train carriages
Definition SUMOVTypeParameter.h:385
SUMOVTypeParameter::parkingBadges
std::vector< std::string > parkingBadges
the parking access rights
Definition SUMOVTypeParameter.h:418
SUMOVTypeParameter::length
double length
The physical vehicle length.
Definition SUMOVTypeParameter.h:280
SUMOVTypeParameter::maxSpeedLat
double maxSpeedLat
The vehicle type's maximum lateral speed [m/s].
Definition SUMOVTypeParameter.h:370
SUMOVTypeParameter::initRailVisualizationParameters
void initRailVisualizationParameters(const std::string fileName="")
init Rail Visualization Parameters
Definition SUMOVTypeParameter.cpp:787
SUMOVTypeParameter::color
RGBColor color
The color.
Definition SUMOVTypeParameter.h:308
SUMOVTypeParameter::parametersSet
long long int parametersSet
Information for the router which parameter were set.
Definition SUMOVTypeParameter.h:424
SUMOVTypeParameter::minGap
double minGap
This class' free space in front of the vehicle itself.
Definition SUMOVTypeParameter.h:283
SUMOVTypeParameter::imgFile
std::string imgFile
Image file for this class.
Definition SUMOVTypeParameter.h:347
SUMOVTypeParameter::shape
SUMOVehicleShape shape
This class' shape.
Definition SUMOVTypeParameter.h:341
SUMOVTypeParameter::personCapacity
int personCapacity
The person capacity of the vehicle.
Definition SUMOVTypeParameter.h:317
SUMOVTypeParameter::speedFactor
Distribution_Parameterized speedFactor
The factor by which the maximum speed may deviate from the allowed max speed on the street.
Definition SUMOVTypeParameter.h:299
SUMOVTypeParameter::getLCParam
double getLCParam(const SumoXMLAttr attr, const double defaultValue) const
Returns the named value from the map, or the default if it is not contained there.
Definition SUMOVTypeParameter.cpp:691
SUMOVTypeParameter::osgFile
std::string osgFile
3D model file for this class
Definition SUMOVTypeParameter.h:344
SUMOVTypeParameter::maxSpeed
double maxSpeed
The vehicle type's (technical) maximum speed [m/s].
Definition SUMOVTypeParameter.h:286
SUMOVTypeParameter::carriageGap
double carriageGap
the length of the gap between carriages
Definition SUMOVTypeParameter.h:391
SUMOVTypeParameter::containerCapacity
int containerCapacity
The container capacity of the vehicle.
Definition SUMOVTypeParameter.h:320
SUMOVTypeParameter::boardingDuration
SUMOTime boardingDuration
The time a person needs to board the vehicle.
Definition SUMOVTypeParameter.h:323
SUMOVTypeParameter::getCFParam
double getCFParam(const SumoXMLAttr attr, const double defaultValue) const
Returns the named value from the map, or the default if it is not contained there.
Definition SUMOVTypeParameter.cpp:636
SUMOVTypeParameter::minGapLat
double minGapLat
The vehicle type's minimum lateral gap [m].
Definition SUMOVTypeParameter.h:379
SUMOVTypeParameter::vehicleClass
SUMOVehicleClass vehicleClass
The vehicle's class.
Definition SUMOVTypeParameter.h:311
SUMOVTypeParameter::SUMOVTypeParameter
SUMOVTypeParameter(const std::string &vtid, const SUMOVehicleClass vc=SVC_IGNORING)
Constructor.
Definition SUMOVTypeParameter.cpp:326
SUMOVTypeParameter::getJMParam
double getJMParam(const SumoXMLAttr attr, const double defaultValue) const
Returns the named value from the map, or the default if it is not contained there.
Definition SUMOVTypeParameter.cpp:717
SUMOVTypeParameter::loadingDuration
SUMOTime loadingDuration
The time a container needs to get loaded on the vehicle.
Definition SUMOVTypeParameter.h:326
SUMOVTypeParameter::getCFParamString
std::string getCFParamString(const SumoXMLAttr attr, const std::string defaultValue) const
Returns the named value from the map, or the default if it is not contained there.
Definition SUMOVTypeParameter.cpp:646
SUMOVTypeParameter::id
std::string id
The vehicle type's id.
Definition SUMOVTypeParameter.h:277
SUMOVTypeParameter::cfModel
SumoXMLTag cfModel
The enum-representation of the car-following model to use.
Definition SUMOVTypeParameter.h:355
SUMOVTypeParameter::getLCParamString
std::string getLCParamString(const SumoXMLAttr attr, const std::string &defaultValue) const
Returns the named value from the map, or the default if it is not contained there.
Definition SUMOVTypeParameter.cpp:701
SUMOVTypeParameter::lcParameter
SubParams lcParameter
Lane-changing parameter.
Definition SUMOVTypeParameter.h:361
SUMOVTypeParameter::latAlignmentProcedure
LatAlignmentDefinition latAlignmentProcedure
Information on how the vehicle shall choose the lateral alignment.
Definition SUMOVTypeParameter.h:376
SUMOVTypeParameter::jmParameter
SubParams jmParameter
Junction-model parameter.
Definition SUMOVTypeParameter.h:364
SUMOVTypeParameter::impatience
double impatience
The vehicle's impatience (willingness to obstruct others).
Definition SUMOVTypeParameter.h:314
SUMOVTypeParameter::lcModel
LaneChangeModel lcModel
The lane-change model to use.
Definition SUMOVTypeParameter.h:367
SUMOVTypeParameter::parseLatAlignment
static bool parseLatAlignment(const std::string &val, double &lao, LatAlignmentDefinition &lad)
Parses and validates a given latAlignment value.
Definition SUMOVTypeParameter.cpp:1047
SUMOXMLDefinitions::CarFollowModels
static StringBijection< SumoXMLTag > CarFollowModels
car following models
Definition SUMOXMLDefinitions.h:2577
SUMOXMLDefinitions::isValidFilename
static bool isValidFilename(const std::string &value)
whether the given string is a valid attribute for a filename (for example, a name)
Definition SUMOXMLDefinitions.cpp:2056
SUMOXMLDefinitions::TrainTypes
static StringBijection< TrainType > TrainTypes
train types
Definition SUMOXMLDefinitions.h:2583
SUMOXMLDefinitions::LaneChangeModels
static StringBijection< LaneChangeModel > LaneChangeModels
lane change models
Definition SUMOXMLDefinitions.h:2574
SUMOVTypeParameter::VClassDefaultValues
struct for default values that depend of VClass
Definition SUMOVTypeParameter.h:127
SUMOVTypeParameter::VClassDefaultValues::personCapacity
int personCapacity
The person capacity of the vehicle.
Definition SUMOVTypeParameter.h:165
SUMOVTypeParameter::VClassDefaultValues::carriageLength
double carriageLength
the length of train carriages
Definition SUMOVTypeParameter.h:174
SUMOVTypeParameter::VClassDefaultValues::desiredMaxSpeed
double desiredMaxSpeed
The vehicle type's desired maximum speed [m/s].
Definition SUMOVTypeParameter.h:144
SUMOVTypeParameter::VClassDefaultValues::osgFile
std::string osgFile
3D model file for this class
Definition SUMOVTypeParameter.h:171
SUMOVTypeParameter::VClassDefaultValues::emissionClass
SUMOEmissionClass emissionClass
The emission class of this vehicle.
Definition SUMOVTypeParameter.h:156
SUMOVTypeParameter::VClassDefaultValues::minGap
double minGap
This class' free space in front of the vehicle itself.
Definition SUMOVTypeParameter.h:135
SUMOVTypeParameter::VClassDefaultValues::containerCapacity
int containerCapacity
The container capacity of the vehicle.
Definition SUMOVTypeParameter.h:168
SUMOVTypeParameter::VClassDefaultValues::maxSpeed
double maxSpeed
The vehicle type's maximum speed [m/s] (technical limit, not subject to speed deviation).
Definition SUMOVTypeParameter.h:141
SUMOVTypeParameter::VClassDefaultValues::speedFactor
Distribution_Parameterized speedFactor
The factor by which the maximum speed may deviate from the allowed max speed on the street.
Definition SUMOVTypeParameter.h:162
SUMOVTypeParameter::VClassDefaultValues::length
double length
The physical vehicle length.
Definition SUMOVTypeParameter.h:132
SUMOVTypeParameter::VClassDefaultValues::shape
SUMOVehicleShape shape
This class' shape.
Definition SUMOVTypeParameter.h:153
SUMOVTypeParameter::VClassDefaultValues::latAlignmentProcedure
LatAlignmentDefinition latAlignmentProcedure
the lateral alignment procedure
Definition SUMOVTypeParameter.h:189
SUMOVTypeParameter::VClassDefaultValues::locomotiveLength
double locomotiveLength
the length of train locomotive
Definition SUMOVTypeParameter.h:177