SUMO - Simulation of Urban MObility
GNECalibratorVehicleType.cpp
Go to the documentation of this file.
1 /****************************************************************************/
2 // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3 // Copyright (C) 2001-2017 German Aerospace Center (DLR) and others.
4 /****************************************************************************/
5 //
6 // This program and the accompanying materials
7 // are made available under the terms of the Eclipse Public License v2.0
8 // which accompanies this distribution, and is available at
9 // http://www.eclipse.org/legal/epl-v20.html
10 //
11 /****************************************************************************/
17 //
18 /****************************************************************************/
19 
20 // ===========================================================================
21 // included modules
22 // ===========================================================================
23 #ifdef _MSC_VER
24 #include <windows_config.h>
25 #else
26 #include <config.h>
27 #endif
28 
29 #include <string>
30 #include <iostream>
31 #include <utility>
35 #include <utils/common/ToString.h>
36 #include <utils/geom/GeomHelper.h>
42 #include <utils/gui/div/GLHelper.h>
46 
48 #include "GNECalibrator.h"
49 #include "GNECalibratorDialog.h"
50 #include "GNEViewNet.h"
51 #include "GNENet.h"
52 #include "GNEUndoList.h"
53 #include "GNEChange_Attribute.h"
54 
55 
56 // ===========================================================================
57 // member method definitions
58 // ===========================================================================
59 
62  myCalibratorParent(calibratorDialog->getEditedCalibrator()),
63  myVehicleTypeID(calibratorDialog->getEditedCalibrator()->getViewNet()->getNet()->generateCalibratorVehicleTypeID()),
64  myAccel(getDefaultValue<double>(SUMO_TAG_VTYPE, SUMO_ATTR_ACCEL)),
65  myDecel(getDefaultValue<double>(SUMO_TAG_VTYPE, SUMO_ATTR_DECEL)),
66  mySigma(getDefaultValue<double>(SUMO_TAG_VTYPE, SUMO_ATTR_SIGMA)),
67  myTau(getDefaultValue<double>(SUMO_TAG_VTYPE, SUMO_ATTR_TAU)),
68  myLength(getDefaultValue<double>(SUMO_TAG_VTYPE, SUMO_ATTR_LENGTH)),
69  myMinGap(getDefaultValue<double>(SUMO_TAG_VTYPE, SUMO_ATTR_MINGAP)),
70  myMaxSpeed(getDefaultValue<double>(SUMO_TAG_VTYPE, SUMO_ATTR_MAXSPEED)),
71  mySpeedFactor(getDefaultValue<double>(SUMO_TAG_VTYPE, SUMO_ATTR_SPEEDFACTOR)),
72  mySpeedDev(getDefaultValue<double>(SUMO_TAG_VTYPE, SUMO_ATTR_SPEEDDEV)),
73  myColor(getDefaultValue<RGBColor>(SUMO_TAG_VTYPE, SUMO_ATTR_COLOR)),
74  myVClass(getDefaultValue<SUMOVehicleClass>(SUMO_TAG_VTYPE, SUMO_ATTR_VCLASS)),
75  myEmissionClass(getDefaultValue<std::string>(SUMO_TAG_VTYPE, SUMO_ATTR_EMISSIONCLASS)),
76  myShape(getDefaultValue<SUMOVehicleShape>(SUMO_TAG_VTYPE, SUMO_ATTR_GUISHAPE)),
77  myWidth(getDefaultValue<double>(SUMO_TAG_VTYPE, SUMO_ATTR_WIDTH)),
78  myFilename(getDefaultValue<std::string>(SUMO_TAG_VTYPE, SUMO_ATTR_IMGFILE)),
79  myImpatience(getDefaultValue<double>(SUMO_TAG_VTYPE, SUMO_ATTR_IMPATIENCE)),
80  myLaneChangeModel(getDefaultValue<std::string>(SUMO_TAG_VTYPE, SUMO_ATTR_LANE_CHANGE_MODEL)),
81  myCarFollowModel(getDefaultValue<std::string>(SUMO_TAG_VTYPE, SUMO_ATTR_CAR_FOLLOW_MODEL)),
82  myPersonCapacity(getDefaultValue<int>(SUMO_TAG_VTYPE, SUMO_ATTR_PERSON_CAPACITY)),
83  myContainerCapacity(getDefaultValue<int>(SUMO_TAG_VTYPE, SUMO_ATTR_CONTAINER_CAPACITY)),
84  myBoardingDuration(getDefaultValue<double>(SUMO_TAG_VTYPE, SUMO_ATTR_BOARDING_DURATION)),
85  myLoadingDuration(getDefaultValue<double>(SUMO_TAG_VTYPE, SUMO_ATTR_LOADING_DURATION)),
86  myLatAlignment(getDefaultValue<std::string>(SUMO_TAG_VTYPE, SUMO_ATTR_LATALIGNMENT)),
87  myMinGapLat(getDefaultValue<double>(SUMO_TAG_VTYPE, SUMO_ATTR_MINGAP_LAT)),
88  myMaxSpeedLat(getDefaultValue<double>(SUMO_TAG_VTYPE, SUMO_ATTR_MAXSPEED_LAT)) {
89 }
90 
91 
92 GNECalibratorVehicleType::GNECalibratorVehicleType(GNECalibrator* calibratorParent, std::string vehicleTypeID,
93  double accel, double decel, double sigma, double tau, double length, double minGap, double maxSpeed,
94  double speedFactor, double speedDev, const RGBColor& color, SUMOVehicleClass vClass, const std::string& emissionClass,
95  SUMOVehicleShape shape, double width, const std::string& filename, double impatience, const std::string& laneChangeModel,
96  const std::string& carFollowModel, int personCapacity, int containerCapacity, double boardingDuration,
97  double loadingDuration, const std::string& latAlignment, double minGapLat, double maxSpeedLat) :
99  myCalibratorParent(calibratorParent),
100  myVehicleTypeID(vehicleTypeID),
101  myAccel(accel),
102  myDecel(decel),
103  mySigma(sigma),
104  myTau(tau),
105  myLength(length),
106  myMinGap(minGap),
107  myMaxSpeed(maxSpeed),
108  mySpeedFactor(speedFactor),
109  mySpeedDev(speedDev),
110  myColor(color),
111  myVClass(vClass),
112  myEmissionClass(emissionClass),
113  myShape(shape),
114  myWidth(width),
115  myFilename(filename),
116  myImpatience(impatience),
117  myLaneChangeModel(laneChangeModel),
118  myCarFollowModel(carFollowModel),
119  myPersonCapacity(personCapacity),
120  myContainerCapacity(containerCapacity),
121  myBoardingDuration(boardingDuration),
122  myLoadingDuration(loadingDuration),
123  myLatAlignment(latAlignment),
124  myMinGapLat(minGapLat),
125  myMaxSpeedLat(maxSpeedLat) {
126 }
127 
128 
130 
131 
132 void
134  // Open vehicle type tag
135  device.openTag(getTag());
136  // write id
138  //write accel
140  // write decel
142  // write sigma
144  // write tau
145  device.writeAttr(SUMO_ATTR_TAU, myTau);
146  // write lenght
148  // write min gap
150  // write max speed
152  // write speed factor
154  // write speed dev
156  // write color
158  // write vehicle class
160  // write emission class
162  // write shape
164  // write width
166  // write filename
168  // write impatience
170  // write lane change model
172  // write car follow model
174  // write person capacity
176  // write container capacity
178  // write boarding duration
180  // write loading duration
182  // write get lat alignment
184  // write min gap lat
186  // write max speed lat
188  // Close vehicle type tag
189  device.closeTag();
190 }
191 
192 
195  return myCalibratorParent;
196 }
197 
198 
199 std::string
201  switch (key) {
202  case SUMO_ATTR_ID:
203  return myVehicleTypeID;
204  case SUMO_ATTR_ACCEL:
205  return toString(myAccel);
206  case SUMO_ATTR_DECEL:
207  return toString(myDecel);
208  case SUMO_ATTR_SIGMA:
209  return toString(mySigma);
210  case SUMO_ATTR_TAU:
211  return toString(myTau);
212  case SUMO_ATTR_LENGTH:
213  return toString(myLength);
214  case SUMO_ATTR_MINGAP:
215  return toString(myMinGap);
216  case SUMO_ATTR_MAXSPEED:
217  return toString(myMaxSpeed);
219  return toString(mySpeedFactor);
220  case SUMO_ATTR_SPEEDDEV:
221  return toString(mySpeedDev);
222  case SUMO_ATTR_COLOR:
223  return toString(myColor);
224  case SUMO_ATTR_VCLASS:
225  return toString(myVClass);
227  return myEmissionClass;
228  case SUMO_ATTR_GUISHAPE:
230  case SUMO_ATTR_WIDTH:
231  return toString(myWidth);
232  case SUMO_ATTR_IMGFILE:
233  return myFilename;
235  return toString(myImpatience);
237  return myLaneChangeModel;
239  return myCarFollowModel;
241  return toString(myPersonCapacity);
247  return toString(myLoadingDuration);
249  return myLatAlignment;
251  return toString(myMinGapLat);
253  return toString(myMaxSpeedLat);
254  default:
255  throw InvalidArgument(toString(getTag()) + " doesn't have an attribute of type '" + toString(key) + "'");
256  }
257 }
258 
259 
260 void
261 GNECalibratorVehicleType::setAttribute(SumoXMLAttr key, const std::string& value, GNEUndoList* undoList) {
262  if (value == getAttribute(key)) {
263  return; //avoid needless changes, later logic relies on the fact that attributes have changed
264  }
265  switch (key) {
266  case SUMO_ATTR_ID:
267  case SUMO_ATTR_ACCEL:
268  case SUMO_ATTR_DECEL:
269  case SUMO_ATTR_SIGMA:
270  case SUMO_ATTR_TAU:
271  case SUMO_ATTR_LENGTH:
272  case SUMO_ATTR_MINGAP:
273  case SUMO_ATTR_MAXSPEED:
275  case SUMO_ATTR_SPEEDDEV:
276  case SUMO_ATTR_COLOR:
277  case SUMO_ATTR_VCLASS:
279  case SUMO_ATTR_GUISHAPE:
280  case SUMO_ATTR_WIDTH:
281  case SUMO_ATTR_IMGFILE:
292  undoList->p_add(new GNEChange_Attribute(this, key, value));
293  break;
294  default:
295  throw InvalidArgument(toString(getTag()) + " doesn't have an attribute of type '" + toString(key) + "'");
296  }
297 }
298 
299 
300 bool
301 GNECalibratorVehicleType::isValid(SumoXMLAttr key, const std::string& value) {
302  switch (key) {
303  case SUMO_ATTR_ID:
304  return isValidID(value) && (myCalibratorParent->getViewNet()->getNet()->retrieveCalibratorVehicleType(value, false) == NULL);
305  case SUMO_ATTR_ACCEL:
306  return canParse<double>(value);
307  case SUMO_ATTR_DECEL:
308  return canParse<double>(value);
309  case SUMO_ATTR_SIGMA:
310  return canParse<double>(value);
311  case SUMO_ATTR_TAU:
312  return canParse<double>(value);
313  case SUMO_ATTR_LENGTH:
314  return canParse<double>(value);
315  case SUMO_ATTR_MINGAP:
316  return canParse<double>(value);
317  case SUMO_ATTR_MAXSPEED:
318  return canParse<double>(value);
320  return canParse<double>(value);
321  case SUMO_ATTR_SPEEDDEV:
322  return canParse<double>(value);
323  case SUMO_ATTR_COLOR:
324  return canParse<RGBColor>(value);
325  case SUMO_ATTR_VCLASS:
326  return canParseVehicleClasses(value);
328  return true;
329  case SUMO_ATTR_GUISHAPE:
330  return canParseVehicleShape(value);
331  case SUMO_ATTR_WIDTH:
332  return canParse<double>(value);
333  case SUMO_ATTR_IMGFILE:
334  return isValidFilename(value);
336  return canParse<double>(value);
338  return (value == "LC2013") || (value == "SL2015") || (value == "DK2008");
340  return (value == "Krauss") || (value == "KraussOrig1") || (value == "PWagner2009") ||
341  (value == "BKerner") || (value == "IDM") || (value == "IDMM") || (value == "KraussPS") ||
342  (value == "KraussAB") || (value == "SmartSK") || (value == "Wiedemann") || (value == "Daniel1");
344  return canParse<int>(value);
346  return canParse<int>(value);
348  return canParse<double>(value);
350  return canParse<double>(value);
352  if ((value == "") || (value == "left") || (value == "right") || (value == "center")) {
353  return true;
354  } else {
355  return canParse<double>(value);
356  }
358  return canParse<double>(value);
360  return canParse<double>(value);
361  default:
362  throw InvalidArgument(toString(getTag()) + " doesn't have an attribute of type '" + toString(key) + "'");
363  }
364 }
365 
366 
367 void
368 GNECalibratorVehicleType::setAttribute(SumoXMLAttr key, const std::string& value) {
369  switch (key) {
370  case SUMO_ATTR_ID: {
371  std::string oldID = myVehicleTypeID;
372  myVehicleTypeID = value;
374  break;
375  }
376  case SUMO_ATTR_ACCEL:
377  myAccel = parse<double>(value);
378  break;
379  case SUMO_ATTR_DECEL:
380  myDecel = parse<double>(value);
381  break;
382  case SUMO_ATTR_SIGMA:
383  mySigma = parse<double>(value);
384  break;
385  case SUMO_ATTR_TAU:
386  myTau = parse<double>(value);
387  break;
388  case SUMO_ATTR_LENGTH:
389  myLength = parse<double>(value);
390  break;
391  case SUMO_ATTR_MINGAP:
392  myMinGap = parse<double>(value);
393  break;
394  case SUMO_ATTR_MAXSPEED:
395  myMaxSpeed = parse<double>(value);
396  break;
398  mySpeedFactor = parse<double>(value);
399  break;
400  case SUMO_ATTR_SPEEDDEV:
401  mySpeedDev = parse<double>(value);
402  break;
403  case SUMO_ATTR_COLOR:
404  myColor = parse<RGBColor>(value);
405  break;
406  case SUMO_ATTR_VCLASS:
407  myVClass = getVehicleClassID(value);
408  break;
410  myEmissionClass = value;
411  break;
412  case SUMO_ATTR_GUISHAPE:
413  myShape = getVehicleShapeID(value);
414  break;
415  case SUMO_ATTR_WIDTH:
416  myWidth = parse<double>(value);
417  break;
418  case SUMO_ATTR_IMGFILE:
419  myFilename = value;
420  break;
422  myImpatience = parse<double>(value);
423  break;
425  myLaneChangeModel = value;
426  break;
428  myCarFollowModel = value;
429  break;
431  myPersonCapacity = parse<int>(value);
432  break;
434  myContainerCapacity = parse<int>(value);
435  break;
437  myBoardingDuration = parse<double>(value);
438  break;
440  myLoadingDuration = parse<double>(value);
441  break;
443  myLatAlignment = value;
444  break;
446  myMinGapLat = parse<double>(value);
447  break;
449  myMaxSpeedLat = parse<double>(value);
450  break;
451  default:
452  throw InvalidArgument(toString(getTag()) + " doesn't have an attribute of type '" + toString(key) + "'");
453  }
454 }
455 
456 /****************************************************************************/
SUMOVehicleClass getVehicleClassID(const std::string &name)
Returns the class id of the abstract class given by its name.
double myTau
Car-following model parameter.
double myMinGap
Empty space after leader [m].
double myMaxSpeedLat
The maximum lateral speed when using the sublane-model.
OutputDevice & writeAttr(const SumoXMLAttr attr, const T &val)
writes a named attribute
Definition: OutputDevice.h:260
description of a vehicle type
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types...
void changeCalibratorVehicleTypeID(GNECalibratorVehicleType *vehicleType, const std::string &oldID)
change Calibrator Vehicle Type ID
Definition: GNENet.cpp:1889
std::string getAttribute(SumoXMLAttr key) const
inherited from GNEAttributeCarrier
double myImpatience
Willingess of drivers to impede vehicles with higher priority. See below for semantics.
double myWidth
The vehicle&#39;s width [m] (only used for drawing)
double myAccel
The acceleration ability of vehicles of this type (in m/s^2)
GNECalibrator * myCalibratorParent
pointer to calibrator parent
SumoXMLAttr
Numbers representing SUMO-XML - attributes.
double myDecel
The deceleration ability of vehicles of this type (in m/s^2)
void writeVehicleType(OutputDevice &device)
write Flow values into a XML
static bool isValidFilename(const std::string &value)
true if value is a valid file value
std::string myLatAlignment
The preferred lateral alignment when using the sublane-model. One of (left, right, center, compact, nice, arbitrary).
double myLength
The vehicle&#39;s netto-length (length) (in m)
std::string getVehicleShapeName(SUMOVehicleShape id)
Returns the class name of the shape class given by its id.
bool canParseVehicleShape(const std::string &shape)
Checks whether the given string contains only known vehicle shape.
double mySigma
Car-following model parameter.
void p_add(GNEChange_Attribute *cmd)
special method, avoid empty changes, always execute
static bool isValidID(const std::string &value)
true if value is a valid sumo ID
std::string myCarFollowModel
The model used for car following.
std::string myVehicleTypeID
vehicleType ID
bool isValid(SumoXMLAttr key, const std::string &value)
RGBColor myColor
This vehicle type&#39;s color.
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:55
int myPersonCapacity
The number of persons (excluding an autonomous driver) the vehicle can transport. ...
double mySpeedDev
The deviation of the speedFactor; see below for details.
friend class GNEChange_Attribute
declare friend class
SUMOVehicleClass myVClass
An abstract vehicle class.
SUMOVehicleShape myShape
How this vehicle is rendered.
std::string myEmissionClass
An abstract emission class.
std::string myFilename
Image file for rendering vehicles of this type (should be grayscale to allow functional coloring) ...
bool canParseVehicleClasses(const std::string &classes)
Checks whether the given string contains only known vehicle classes.
Dialog for edit calibrators.
GNEViewNet * getViewNet() const
Returns a pointer to GNEViewNet in which additional element is located.
double myBoardingDuration
The time required by a person to board the vehicle.
SUMOVehicleShape
Definition of vehicle classes to differ between different appearences.
GNECalibratorVehicleType * retrieveCalibratorVehicleType(const std::string &id, bool hardFail=true) const
Returns the named calibrator vehicle type.
Definition: GNENet.cpp:1816
GNENet * getNet() const
get the net object
GNECalibrator * getCalibratorParent() const
get pointer to calibrator parent
double myLoadingDuration
The time required to load a container onto the vehicle.
SUMOVehicleShape getVehicleShapeID(const std::string &name)
Returns the class id of the shape class given by its name.
Static storage of an output device and its base (abstract) implementation.
Definition: OutputDevice.h:70
bool closeTag()
Closes the most recently opened tag.
double myMinGapLat
The minimum lateral gap at a speed difference of 100km/h when using the sublane-model.
A color information.
double myMaxSpeed
The vehicle&#39;s maximum velocity (in m/s)
double mySpeedFactor
The vehicles expected multiplicator for lane speed limits.
std::string myLaneChangeModel
The model used for changing lanes.
OutputDevice & openTag(const std::string &xmlElement)
Opens an XML tag.
int myContainerCapacity
The number of containers the vehicle can transport.
GNECalibratorVehicleType(GNECalibratorDialog *calibratorDialog)
constructor (Used only in GNECalibratorDialog)
void setAttribute(SumoXMLAttr key, const std::string &value, GNEUndoList *undoList)
SumoXMLTag getTag() const
get XML Tag assigned to this object