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>
28#include "Helper.h"
29#include "VehicleType.h"
30
31
32namespace libsumo {
33// ===========================================================================
34// static member initializations
35// ===========================================================================
36SubscriptionResults VehicleType::mySubscriptionResults;
37ContextSubscriptionResults VehicleType::myContextSubscriptionResults;
38
39
40// ===========================================================================
41// static member definitions
42// ===========================================================================
43std::vector<std::string>
44VehicleType::getIDList() {
45 std::vector<std::string> ids;
47 return ids;
48}
49
50
51int
52VehicleType::getIDCount() {
53 return (int)getIDList().size();
54}
55
56
57double
58VehicleType::getLength(const std::string& typeID) {
59 return getVType(typeID)->getLength();
60}
61
62
63double
64VehicleType::getMaxSpeed(const std::string& typeID) {
65 return getVType(typeID)->getMaxSpeed();
66}
67
68
69double
70VehicleType::getActionStepLength(const std::string& typeID) {
71 return getVType(typeID)->getActionStepLengthSecs();
72}
73
74
75double
76VehicleType::getSpeedFactor(const std::string& typeID) {
77 return getVType(typeID)->getSpeedFactor().getParameter()[0];
78}
79
80
81double
82VehicleType::getSpeedDeviation(const std::string& typeID) {
83 return getVType(typeID)->getSpeedFactor().getParameter()[1];
84}
85
86
87double
88VehicleType::getAccel(const std::string& typeID) {
89 return getVType(typeID)->getCarFollowModel().getMaxAccel();
90}
91
92
93double
94VehicleType::getDecel(const std::string& typeID) {
95 return getVType(typeID)->getCarFollowModel().getMaxDecel();
96}
97
98
99double
100VehicleType::getEmergencyDecel(const std::string& typeID) {
101 return getVType(typeID)->getCarFollowModel().getEmergencyDecel();
102}
103
104
105double
106VehicleType::getApparentDecel(const std::string& typeID) {
107 return getVType(typeID)->getCarFollowModel().getApparentDecel();
108}
109
110
111double
112VehicleType::getImperfection(const std::string& typeID) {
113 return getVType(typeID)->getCarFollowModel().getImperfection();
114}
115
116
117double
118VehicleType::getTau(const std::string& typeID) {
119 return getVType(typeID)->getCarFollowModel().getHeadwayTime();
120}
121
122
123std::string
124VehicleType::getVehicleClass(const std::string& typeID) {
125 return toString(getVType(typeID)->getVehicleClass());
126}
127
128
129std::string
130VehicleType::getEmissionClass(const std::string& typeID) {
131 return PollutantsInterface::getName(getVType(typeID)->getEmissionClass());
132}
133
134
135std::string
136VehicleType::getShapeClass(const std::string& typeID) {
137 return getVehicleShapeName(getVType(typeID)->getGuiShape());
138}
139
140
141double
142VehicleType::getMinGap(const std::string& typeID) {
143 return getVType(typeID)->getMinGap();
144}
145
146
147double
148VehicleType::getWidth(const std::string& typeID) {
149 return getVType(typeID)->getWidth();
150}
151
152
153double
154VehicleType::getHeight(const std::string& typeID) {
155 return getVType(typeID)->getHeight();
156}
157
158
159TraCIColor
160VehicleType::getColor(const std::string& typeID) {
161 return Helper::makeTraCIColor(getVType(typeID)->getColor());
162}
163
164
165double
166VehicleType::getMinGapLat(const std::string& typeID) {
167 return getVType(typeID)->getMinGapLat();
168}
169
170
171double
172VehicleType::getMaxSpeedLat(const std::string& typeID) {
173 return getVType(typeID)->getMaxSpeedLat();
174}
175
176
177std::string
178VehicleType::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
187std::string
188VehicleType::getParameter(const std::string& typeID, const std::string& key) {
189 return getVType(typeID)->getParameter().getParameter(key, "");
190}
191
193
194int
195VehicleType::getPersonCapacity(const std::string& typeID) {
196 return getVType(typeID)->getPersonCapacity();
197}
198
199double
200VehicleType::getScale(const std::string& typeID) {
201 return getVType(typeID)->getParameter().scale;
202}
203
204void
205VehicleType::setLength(const std::string& typeID, double length) {
206 getVType(typeID)->setLength(length);
207}
208
209
210void
211VehicleType::setMaxSpeed(const std::string& typeID, double speed) {
212 getVType(typeID)->setMaxSpeed(speed);
213}
214
215
216void
217VehicleType::setActionStepLength(const std::string& typeID, double actionStepLength, bool resetActionOffset) {
218 getVType(typeID)->setActionStepLength(SUMOVehicleParserHelper::processActionStepLength(actionStepLength), resetActionOffset);
219}
220
221
222void
223VehicleType::setVehicleClass(const std::string& typeID, const std::string& clazz) {
224 getVType(typeID)->setVClass(getVehicleClassID(clazz));
225}
226
227
228void
229VehicleType::setSpeedFactor(const std::string& typeID, double factor) {
230 getVType(typeID)->setSpeedFactor(factor);
231}
232
233
234void
235VehicleType::setSpeedDeviation(const std::string& typeID, double deviation) {
236 getVType(typeID)->setSpeedDeviation(deviation);
237}
238
239
240void
241VehicleType::setEmissionClass(const std::string& typeID, const std::string& clazz) {
242 getVType(typeID)->setEmissionClass(PollutantsInterface::getClassByName(clazz));
243}
244
245
246void
247VehicleType::setShapeClass(const std::string& typeID, const std::string& shapeClass) {
248 getVType(typeID)->setShape(getVehicleShapeID(shapeClass));
249}
250
251
252void
253VehicleType::setWidth(const std::string& typeID, double width) {
254 getVType(typeID)->setWidth(width);
255}
256
257
258void
259VehicleType::setHeight(const std::string& typeID, double height) {
260 getVType(typeID)->setHeight(height);
261}
262
263
264void
265VehicleType::setMinGap(const std::string& typeID, double minGap) {
266 getVType(typeID)->setMinGap(minGap);
267}
268
269
270void
271VehicleType::setAccel(const std::string& typeID, double accel) {
272 getVType(typeID)->setAccel(accel);
273}
274
275
276void
277VehicleType::setDecel(const std::string& typeID, double decel) {
278 MSVehicleType* v = getVType(typeID);
279 v->setDecel(decel);
280 // automatically raise emergencyDecel to ensure it is at least as high as decel
281 if (decel > v->getCarFollowModel().getEmergencyDecel()) {
283 // notify user only if emergencyDecel was previously specified
284 WRITE_WARNING("Automatically setting emergencyDecel to " + toString(decel) + " for vType '" + typeID + "' to match decel.");
285 }
286 v->setEmergencyDecel(decel);
287 }
288}
289
290
291void
292VehicleType::setEmergencyDecel(const std::string& typeID, double decel) {
293 MSVehicleType* v = getVType(typeID);
294 v->setEmergencyDecel(decel);
295 if (decel < v->getCarFollowModel().getMaxDecel()) {
296 WRITE_WARNING("New value of emergencyDecel (" + toString(decel) + ") is lower than decel (" + toString(v->getCarFollowModel().getMaxDecel()) + ")");
297 }
298}
299
300
301void
302VehicleType::setApparentDecel(const std::string& typeID, double decel) {
303 getVType(typeID)->setApparentDecel(decel);
304}
305
306
307void
308VehicleType::setImperfection(const std::string& typeID, double imperfection) {
309 getVType(typeID)->setImperfection(imperfection);
310}
311
312
313void
314VehicleType::setTau(const std::string& typeID, double tau) {
315 getVType(typeID)->setTau(tau);
316}
317
318
319void
320VehicleType::setColor(const std::string& typeID, const TraCIColor& c) {
321 getVType(typeID)->setColor(Helper::makeRGBColor(c));
322}
323
324
325void
326VehicleType::setMinGapLat(const std::string& typeID, double minGapLat) {
327 getVType(typeID)->setMinGapLat(minGapLat);
328}
329
330
331void
332VehicleType::setMaxSpeedLat(const std::string& typeID, double speed) {
333 getVType(typeID)->setMaxSpeedLat(speed);
334}
335
336
337void
338VehicleType::setLateralAlignment(const std::string& typeID, const std::string& latAlignment) {
339 double lao;
341 if (SUMOVTypeParameter::parseLatAlignment(latAlignment, lao, lad)) {
342 getVType(typeID)->setPreferredLateralAlignment(lad, lao);
343 } else {
344 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)");
345 }
346}
347
348void
349VehicleType::setScale(const std::string& typeID, double value) {
350 getVType(typeID)->setScale(value);
351}
352
353void
354VehicleType::copy(const std::string& origTypeID, const std::string& newTypeID) {
355 getVType(origTypeID)->duplicateType(newTypeID, true);
356}
357
358
359void
360VehicleType::setParameter(const std::string& typeID, const std::string& name, const std::string& value) {
361 ((SUMOVTypeParameter&)getVType(typeID)->getParameter()).setParameter(name, value);
362}
363
364
366
367
369VehicleType::getVType(std::string id) {
371 if (t == nullptr) {
372 throw TraCIException("Vehicle type '" + id + "' is not known");
373 }
374 return t;
375}
376
377
378std::shared_ptr<VariableWrapper>
379VehicleType::makeWrapper() {
380 return std::make_shared<Helper::SubscriptionWrapper>(handleVariable, mySubscriptionResults, myContextSubscriptionResults);
381}
382
383
384bool
385VehicleType::handleVariable(const std::string& objID, const int variable, VariableWrapper* wrapper, tcpip::Storage* paramData) {
386 return handleVariableWithID(objID, objID, variable, wrapper, paramData);
387}
388
389
390bool
391VehicleType::handleVariableWithID(const std::string& objID, const std::string& typeID, const int variable, VariableWrapper* wrapper, tcpip::Storage* paramData) {
392 switch (variable) {
393 case TRACI_ID_LIST:
394 return wrapper->wrapStringList(objID, variable, getIDList());
395 case ID_COUNT:
396 return wrapper->wrapInt(objID, variable, getIDCount());
397 case VAR_LENGTH:
398 return wrapper->wrapDouble(objID, variable, getLength(typeID));
399 case VAR_HEIGHT:
400 return wrapper->wrapDouble(objID, variable, getHeight(typeID));
401 case VAR_MINGAP:
402 return wrapper->wrapDouble(objID, variable, getMinGap(typeID));
403 case VAR_MAXSPEED:
404 return wrapper->wrapDouble(objID, variable, getMaxSpeed(typeID));
405 case VAR_ACCEL:
406 return wrapper->wrapDouble(objID, variable, getAccel(typeID));
407 case VAR_DECEL:
408 return wrapper->wrapDouble(objID, variable, getDecel(typeID));
410 return wrapper->wrapDouble(objID, variable, getEmergencyDecel(typeID));
412 return wrapper->wrapDouble(objID, variable, getApparentDecel(typeID));
414 return wrapper->wrapDouble(objID, variable, getActionStepLength(typeID));
415 case VAR_IMPERFECTION:
416 return wrapper->wrapDouble(objID, variable, getImperfection(typeID));
417 case VAR_TAU:
418 return wrapper->wrapDouble(objID, variable, getTau(typeID));
419 case VAR_SPEED_FACTOR:
420 return wrapper->wrapDouble(objID, variable, getSpeedFactor(typeID));
422 return wrapper->wrapDouble(objID, variable, getSpeedDeviation(typeID));
423 case VAR_VEHICLECLASS:
424 return wrapper->wrapString(objID, variable, getVehicleClass(typeID));
426 return wrapper->wrapString(objID, variable, getEmissionClass(typeID));
427 case VAR_SHAPECLASS:
428 return wrapper->wrapString(objID, variable, getShapeClass(typeID));
429 case VAR_WIDTH:
430 return wrapper->wrapDouble(objID, variable, getWidth(typeID));
431 case VAR_COLOR:
432 return wrapper->wrapColor(objID, variable, getColor(typeID));
433 case VAR_MINGAP_LAT:
434 return wrapper->wrapDouble(objID, variable, getMinGapLat(typeID));
435 case VAR_MAXSPEED_LAT:
436 return wrapper->wrapDouble(objID, variable, getMaxSpeedLat(typeID));
437 case VAR_LATALIGNMENT:
438 return wrapper->wrapString(objID, variable, getLateralAlignment(typeID));
440 return wrapper->wrapInt(objID, variable, getPersonCapacity(typeID));
441 case VAR_SCALE:
442 return wrapper->wrapDouble(objID, variable, getScale(typeID));
444 paramData->readUnsignedByte();
445 return wrapper->wrapString(objID, variable, getParameter(objID, paramData->readString()));
447 paramData->readUnsignedByte();
448 return wrapper->wrapStringPair(objID, variable, getParameterWithKey(objID, paramData->readString()));
449 default:
450 return false;
451 }
452}
453
454}
455
456
457/****************************************************************************/
#define WRITE_WARNING(msg)
Definition: MsgHandler.h:265
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, DOM)
Definition: TraCIDefs.h:76
#define LIBSUMO_GET_PARAMETER_WITH_KEY_IMPLEMENTATION(CLASS)
Definition: TraCIDefs.h:123
double getEmergencyDecel() const
Get the vehicle type's maximal phisically possible deceleration [m/s^2].
Definition: MSCFModel.h:270
double getMaxDecel() const
Get the vehicle type's maximal comfortable deceleration [m/s^2].
Definition: MSCFModel.h:262
static MSNet * getInstance()
Returns the pointer to the unique instance of MSNet (singleton).
Definition: MSNet.cpp:183
MSVehicleControl & getVehicleControl()
Returns the vehicle control.
Definition: MSNet.h:379
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:63
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.
static TraCIColor makeTraCIColor(const RGBColor &color)
Definition: Helper.cpp:357
static RGBColor makeRGBColor(const TraCIColor &color)
Definition: Helper.cpp:368
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_SCALE
TRACI_CONST int VAR_MINGAP
TRACI_CONST int VAR_SHAPECLASS
std::map< std::string, libsumo::SubscriptionResults > ContextSubscriptionResults
Definition: TraCIDefs.h:301
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:300
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