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