Eclipse SUMO - Simulation of Urban MObility
libsumo/VehicleType.cpp
Go to the documentation of this file.
1 /****************************************************************************/
2 // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3 // Copyright (C) 2017-2022 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 // C++ TraCI client API implementation
19 /****************************************************************************/
20 #include <config.h>
21 
22 #include <microsim/MSNet.h>
24 #include <microsim/MSVehicleType.h>
25 #include <libsumo/TraCIConstants.h>
28 #include "Helper.h"
29 #include "VehicleType.h"
30 
31 
32 namespace libsumo {
33 // ===========================================================================
34 // static member initializations
35 // ===========================================================================
36 SubscriptionResults VehicleType::mySubscriptionResults;
37 ContextSubscriptionResults VehicleType::myContextSubscriptionResults;
38 
39 
40 // ===========================================================================
41 // static member definitions
42 // ===========================================================================
43 std::vector<std::string>
44 VehicleType::getIDList() {
45  std::vector<std::string> ids;
47  return ids;
48 }
49 
50 
51 int
52 VehicleType::getIDCount() {
53  return (int)getIDList().size();
54 }
55 
56 
57 double
58 VehicleType::getLength(const std::string& typeID) {
59  return getVType(typeID)->getLength();
60 }
61 
62 
63 double
64 VehicleType::getMaxSpeed(const std::string& typeID) {
65  return getVType(typeID)->getMaxSpeed();
66 }
67 
68 
69 double
70 VehicleType::getActionStepLength(const std::string& typeID) {
71  return getVType(typeID)->getActionStepLengthSecs();
72 }
73 
74 
75 double
76 VehicleType::getSpeedFactor(const std::string& typeID) {
77  return getVType(typeID)->getSpeedFactor().getParameter()[0];
78 }
79 
80 
81 double
82 VehicleType::getSpeedDeviation(const std::string& typeID) {
83  return getVType(typeID)->getSpeedFactor().getParameter()[1];
84 }
85 
86 
87 double
88 VehicleType::getAccel(const std::string& typeID) {
89  return getVType(typeID)->getCarFollowModel().getMaxAccel();
90 }
91 
92 
93 double
94 VehicleType::getDecel(const std::string& typeID) {
95  return getVType(typeID)->getCarFollowModel().getMaxDecel();
96 }
97 
98 
99 double
100 VehicleType::getEmergencyDecel(const std::string& typeID) {
101  return getVType(typeID)->getCarFollowModel().getEmergencyDecel();
102 }
103 
104 
105 double
106 VehicleType::getApparentDecel(const std::string& typeID) {
107  return getVType(typeID)->getCarFollowModel().getApparentDecel();
108 }
109 
110 
111 double
112 VehicleType::getImperfection(const std::string& typeID) {
113  return getVType(typeID)->getCarFollowModel().getImperfection();
114 }
115 
116 
117 double
118 VehicleType::getTau(const std::string& typeID) {
119  return getVType(typeID)->getCarFollowModel().getHeadwayTime();
120 }
121 
122 
123 std::string
124 VehicleType::getVehicleClass(const std::string& typeID) {
125  return toString(getVType(typeID)->getVehicleClass());
126 }
127 
128 
129 std::string
130 VehicleType::getEmissionClass(const std::string& typeID) {
131  return PollutantsInterface::getName(getVType(typeID)->getEmissionClass());
132 }
133 
134 
135 std::string
136 VehicleType::getShapeClass(const std::string& typeID) {
137  return getVehicleShapeName(getVType(typeID)->getGuiShape());
138 }
139 
140 
141 double
142 VehicleType::getMinGap(const std::string& typeID) {
143  return getVType(typeID)->getMinGap();
144 }
145 
146 
147 double
148 VehicleType::getWidth(const std::string& typeID) {
149  return getVType(typeID)->getWidth();
150 }
151 
152 
153 double
154 VehicleType::getHeight(const std::string& typeID) {
155  return getVType(typeID)->getHeight();
156 }
157 
158 
159 TraCIColor
160 VehicleType::getColor(const std::string& typeID) {
161  return Helper::makeTraCIColor(getVType(typeID)->getColor());
162 }
163 
164 
165 double
166 VehicleType::getMinGapLat(const std::string& typeID) {
167  return getVType(typeID)->getMinGapLat();
168 }
169 
170 
171 double
172 VehicleType::getMaxSpeedLat(const std::string& typeID) {
173  return getVType(typeID)->getMaxSpeedLat();
174 }
175 
176 
177 std::string
178 VehicleType::getLateralAlignment(const std::string& typeID) {
179  if (getVType(typeID)->getPreferredLateralAlignment() != LatAlignmentDefinition::GIVEN) {
180  return toString(getVType(typeID)->getPreferredLateralAlignment());
181  } else {
182  return toString(getVType(typeID)->getPreferredLateralAlignmentOffset());
183  }
184 }
185 
186 
187 std::string
188 VehicleType::getParameter(const std::string& typeID, const std::string& key) {
189  return getVType(typeID)->getParameter().getParameter(key, "");
190 }
191 
193 
194 int
195 VehicleType::getPersonCapacity(const std::string& typeID) {
196  return getVType(typeID)->getPersonCapacity();
197 }
198 
199 void
200 VehicleType::setLength(const std::string& typeID, double length) {
201  getVType(typeID)->setLength(length);
202 }
203 
204 
205 void
206 VehicleType::setMaxSpeed(const std::string& typeID, double speed) {
207  getVType(typeID)->setMaxSpeed(speed);
208 }
209 
210 
211 void
212 VehicleType::setActionStepLength(const std::string& typeID, double actionStepLength, bool resetActionOffset) {
213  getVType(typeID)->setActionStepLength(SUMOVehicleParserHelper::processActionStepLength(actionStepLength), resetActionOffset);
214 }
215 
216 
217 void
218 VehicleType::setVehicleClass(const std::string& typeID, const std::string& clazz) {
219  getVType(typeID)->setVClass(getVehicleClassID(clazz));
220 }
221 
222 
223 void
224 VehicleType::setSpeedFactor(const std::string& typeID, double factor) {
225  getVType(typeID)->setSpeedFactor(factor);
226 }
227 
228 
229 void
230 VehicleType::setSpeedDeviation(const std::string& typeID, double deviation) {
231  getVType(typeID)->setSpeedDeviation(deviation);
232 }
233 
234 
235 void
236 VehicleType::setEmissionClass(const std::string& typeID, const std::string& clazz) {
237  getVType(typeID)->setEmissionClass(PollutantsInterface::getClassByName(clazz));
238 }
239 
240 
241 void
242 VehicleType::setShapeClass(const std::string& typeID, const std::string& shapeClass) {
243  getVType(typeID)->setShape(getVehicleShapeID(shapeClass));
244 }
245 
246 
247 void
248 VehicleType::setWidth(const std::string& typeID, double width) {
249  getVType(typeID)->setWidth(width);
250 }
251 
252 
253 void
254 VehicleType::setHeight(const std::string& typeID, double height) {
255  getVType(typeID)->setHeight(height);
256 }
257 
258 
259 void
260 VehicleType::setMinGap(const std::string& typeID, double minGap) {
261  getVType(typeID)->setMinGap(minGap);
262 }
263 
264 
265 void
266 VehicleType::setAccel(const std::string& typeID, double accel) {
267  getVType(typeID)->setAccel(accel);
268 }
269 
270 
271 void
272 VehicleType::setDecel(const std::string& typeID, double decel) {
273  MSVehicleType* v = getVType(typeID);
274  v->setDecel(decel);
275  // automatically raise emergencyDecel to ensure it is at least as high as decel
276  if (decel > v->getCarFollowModel().getEmergencyDecel()) {
277  if (v->getParameter().cfParameter.count(SUMO_ATTR_EMERGENCYDECEL) > 0) {
278  // notify user only if emergencyDecel was previously specified
279  WRITE_WARNING("Automatically setting emergencyDecel to " + toString(decel) + " for vType '" + typeID + "' to match decel.");
280  }
281  v->setEmergencyDecel(decel);
282  }
283 }
284 
285 
286 void
287 VehicleType::setEmergencyDecel(const std::string& typeID, double decel) {
288  MSVehicleType* v = getVType(typeID);
289  v->setEmergencyDecel(decel);
290  if (decel < v->getCarFollowModel().getMaxDecel()) {
291  WRITE_WARNING("New value of emergencyDecel (" + toString(decel) + ") is lower than decel (" + toString(v->getCarFollowModel().getMaxDecel()) + ")");
292  }
293 }
294 
295 
296 void
297 VehicleType::setApparentDecel(const std::string& typeID, double decel) {
298  getVType(typeID)->setApparentDecel(decel);
299 }
300 
301 
302 void
303 VehicleType::setImperfection(const std::string& typeID, double imperfection) {
304  getVType(typeID)->setImperfection(imperfection);
305 }
306 
307 
308 void
309 VehicleType::setTau(const std::string& typeID, double tau) {
310  getVType(typeID)->setTau(tau);
311 }
312 
313 
314 void
315 VehicleType::setColor(const std::string& typeID, const TraCIColor& c) {
316  getVType(typeID)->setColor(Helper::makeRGBColor(c));
317 }
318 
319 
320 void
321 VehicleType::setMinGapLat(const std::string& typeID, double minGapLat) {
322  getVType(typeID)->setMinGapLat(minGapLat);
323 }
324 
325 
326 void
327 VehicleType::setMaxSpeedLat(const std::string& typeID, double speed) {
328  getVType(typeID)->setMaxSpeedLat(speed);
329 }
330 
331 
332 void
333 VehicleType::setLateralAlignment(const std::string& typeID, const std::string& latAlignment) {
334  double lao;
336  if (SUMOVTypeParameter::parseLatAlignment(latAlignment, lao, lad)) {
337  getVType(typeID)->setPreferredLateralAlignment(lad, lao);
338  } else {
339  throw TraCIException("Unknown value '" + latAlignment + "' when setting latAlignment for vType '" + typeID + "';\n must be one of (\"right\", \"center\", \"arbitrary\", \"nice\", \"compact\", \"left\" or a float)");
340  }
341 }
342 
343 
344 void
345 VehicleType::copy(const std::string& origTypeID, const std::string& newTypeID) {
346  getVType(origTypeID)->duplicateType(newTypeID, true);
347 }
348 
349 
350 void
351 VehicleType::setParameter(const std::string& typeID, const std::string& name, const std::string& value) {
352  ((SUMOVTypeParameter&)getVType(typeID)->getParameter()).setParameter(name, value);
353 }
354 
355 
357 
358 
360 VehicleType::getVType(std::string id) {
362  if (t == nullptr) {
363  throw TraCIException("Vehicle type '" + id + "' is not known");
364  }
365  return t;
366 }
367 
368 
369 std::shared_ptr<VariableWrapper>
370 VehicleType::makeWrapper() {
371  return std::make_shared<Helper::SubscriptionWrapper>(handleVariable, mySubscriptionResults, myContextSubscriptionResults);
372 }
373 
374 
375 bool
376 VehicleType::handleVariable(const std::string& objID, const int variable, VariableWrapper* wrapper, tcpip::Storage* paramData) {
377  return handleVariableWithID(objID, objID, variable, wrapper, paramData);
378 }
379 
380 
381 bool
382 VehicleType::handleVariableWithID(const std::string& objID, const std::string& typeID, const int variable, VariableWrapper* wrapper, tcpip::Storage* paramData) {
383  switch (variable) {
384  case TRACI_ID_LIST:
385  return wrapper->wrapStringList(objID, variable, getIDList());
386  case ID_COUNT:
387  return wrapper->wrapInt(objID, variable, getIDCount());
388  case VAR_LENGTH:
389  return wrapper->wrapDouble(objID, variable, getLength(typeID));
390  case VAR_HEIGHT:
391  return wrapper->wrapDouble(objID, variable, getHeight(typeID));
392  case VAR_MINGAP:
393  return wrapper->wrapDouble(objID, variable, getMinGap(typeID));
394  case VAR_MAXSPEED:
395  return wrapper->wrapDouble(objID, variable, getMaxSpeed(typeID));
396  case VAR_ACCEL:
397  return wrapper->wrapDouble(objID, variable, getAccel(typeID));
398  case VAR_DECEL:
399  return wrapper->wrapDouble(objID, variable, getDecel(typeID));
400  case VAR_EMERGENCY_DECEL:
401  return wrapper->wrapDouble(objID, variable, getEmergencyDecel(typeID));
402  case VAR_APPARENT_DECEL:
403  return wrapper->wrapDouble(objID, variable, getApparentDecel(typeID));
405  return wrapper->wrapDouble(objID, variable, getActionStepLength(typeID));
406  case VAR_IMPERFECTION:
407  return wrapper->wrapDouble(objID, variable, getImperfection(typeID));
408  case VAR_TAU:
409  return wrapper->wrapDouble(objID, variable, getTau(typeID));
410  case VAR_SPEED_FACTOR:
411  return wrapper->wrapDouble(objID, variable, getSpeedFactor(typeID));
412  case VAR_SPEED_DEVIATION:
413  return wrapper->wrapDouble(objID, variable, getSpeedDeviation(typeID));
414  case VAR_VEHICLECLASS:
415  return wrapper->wrapString(objID, variable, getVehicleClass(typeID));
416  case VAR_EMISSIONCLASS:
417  return wrapper->wrapString(objID, variable, getEmissionClass(typeID));
418  case VAR_SHAPECLASS:
419  return wrapper->wrapString(objID, variable, getShapeClass(typeID));
420  case VAR_WIDTH:
421  return wrapper->wrapDouble(objID, variable, getWidth(typeID));
422  case VAR_COLOR:
423  return wrapper->wrapColor(objID, variable, getColor(typeID));
424  case VAR_MINGAP_LAT:
425  return wrapper->wrapDouble(objID, variable, getMinGapLat(typeID));
426  case VAR_MAXSPEED_LAT:
427  return wrapper->wrapDouble(objID, variable, getMaxSpeedLat(typeID));
428  case VAR_LATALIGNMENT:
429  return wrapper->wrapString(objID, variable, getLateralAlignment(typeID));
430  case VAR_PERSON_CAPACITY:
431  return wrapper->wrapInt(objID, variable, getPersonCapacity(typeID));
433  paramData->readUnsignedByte();
434  return wrapper->wrapString(objID, variable, getParameter(objID, paramData->readString()));
436  paramData->readUnsignedByte();
437  return wrapper->wrapStringPair(objID, variable, getParameterWithKey(objID, paramData->readString()));
438  default:
439  return false;
440  }
441 }
442 
443 }
444 
445 
446 /****************************************************************************/
#define WRITE_WARNING(msg)
Definition: MsgHandler.h:280
LatAlignmentDefinition
Possible ways to choose the lateral alignment, i.e., how vehicles align themselves within their lane.
@ GIVEN
The alignment as offset is given.
SUMOVehicleClass getVehicleClassID(const std::string &name)
Returns the class id of the abstract class given by its name.
SUMOVehicleShape getVehicleShapeID(const std::string &name)
Returns the class id of the shape class given by its name.
std::string getVehicleShapeName(SUMOVehicleShape id)
Returns the class name of the shape class given by its id.
@ SUMO_ATTR_EMERGENCYDECEL
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:46
#define LIBSUMO_SUBSCRIPTION_IMPLEMENTATION(CLASS, DOMAIN)
Definition: TraCIDefs.h:69
#define LIBSUMO_GET_PARAMETER_WITH_KEY_IMPLEMENTATION(CLASS)
Definition: TraCIDefs.h:115
double getEmergencyDecel() const
Get the vehicle type's maximal phisically possible deceleration [m/s^2].
Definition: MSCFModel.h:247
double getMaxDecel() const
Get the vehicle type's maximal comfortable deceleration [m/s^2].
Definition: MSCFModel.h:239
static MSNet * getInstance()
Returns the pointer to the unique instance of MSNet (singleton).
Definition: MSNet.cpp:174
MSVehicleControl & getVehicleControl()
Returns the vehicle control.
Definition: MSNet.h:376
MSVehicleType * getVType(const std::string &id=DEFAULT_VTYPE_ID, SumoRNG *rng=nullptr, bool readOnly=false)
Returns the named vehicle type or a sample from the named distribution.
void insertVTypeIDs(std::vector< std::string > &into) const
Inserts ids of all known vehicle types and vehicle type distributions to the given vector.
The car-following model and parameter.
Definition: MSVehicleType.h:62
void setEmergencyDecel(double emergencyDecel)
Set a new value for this type's emergency deceleration.
void setDecel(double decel)
Set a new value for this type's deceleration.
const MSCFModel & getCarFollowModel() const
Returns the vehicle type's car following model definition (const version)
const SUMOVTypeParameter & getParameter() const
static std::string getName(const SUMOEmissionClass c)
Checks whether the string describes a known vehicle class.
static SUMOEmissionClass getClassByName(const std::string &eClass, const SUMOVehicleClass vc=SVC_IGNORING)
Checks whether the string describes a known vehicle class.
Structure representing possible vehicle parameter.
SubParams cfParameter
Car-following parameter.
static bool parseLatAlignment(const std::string &val, double &lao, LatAlignmentDefinition &lad)
Parses and validates a given latAlignment value.
static SUMOTime processActionStepLength(double given)
Checks and converts given value for the action step length from seconds to miliseconds assuring it be...
C++ TraCI client API implementation.
Definition: VehicleType.h:77
static TraCIColor makeTraCIColor(const RGBColor &color)
Definition: Helper.cpp:361
static RGBColor makeRGBColor(const TraCIColor &color)
Definition: Helper.cpp:372
virtual std::string readString()
Definition: storage.cpp:180
virtual int readUnsignedByte()
Definition: storage.cpp:155
TRACI_CONST int VAR_VEHICLECLASS
TRACI_CONST int TRACI_ID_LIST
TRACI_CONST int VAR_LATALIGNMENT
TRACI_CONST int VAR_MINGAP
TRACI_CONST int VAR_SHAPECLASS
std::map< std::string, libsumo::SubscriptionResults > ContextSubscriptionResults
Definition: TraCIDefs.h:279
TRACI_CONST int VAR_ACTIONSTEPLENGTH
TRACI_CONST int VAR_SPEED_FACTOR
TRACI_CONST int VAR_TAU
TRACI_CONST int VAR_COLOR
TRACI_CONST int VAR_WIDTH
TRACI_CONST int VAR_PERSON_CAPACITY
TRACI_CONST int VAR_MAXSPEED
std::map< std::string, libsumo::TraCIResults > SubscriptionResults
{object->{variable->value}}
Definition: TraCIDefs.h:278
TRACI_CONST int VAR_LENGTH
TRACI_CONST int VAR_MAXSPEED_LAT
TRACI_CONST int ID_COUNT
TRACI_CONST int VAR_PARAMETER
TRACI_CONST int VAR_IMPERFECTION
TRACI_CONST int VAR_HEIGHT
TRACI_CONST int VAR_APPARENT_DECEL
TRACI_CONST int VAR_DECEL
TRACI_CONST int VAR_PARAMETER_WITH_KEY
TRACI_CONST int VAR_MINGAP_LAT
TRACI_CONST int VAR_EMERGENCY_DECEL
TRACI_CONST int VAR_EMISSIONCLASS
TRACI_CONST int VAR_ACCEL
TRACI_CONST int VAR_SPEED_DEVIATION