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