Eclipse SUMO - Simulation of Urban MObility
Loading...
Searching...
No Matches
libsumo/Lane.cpp
Go to the documentation of this file.
1/****************************************************************************/
2// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3// Copyright (C) 2017-2024 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/****************************************************************************/
23// C++ TraCI client API implementation
24/****************************************************************************/
25#include <config.h>
26
27#include <microsim/MSNet.h>
28#include <microsim/MSLane.h>
29#include <microsim/MSEdge.h>
30#include <microsim/MSVehicle.h>
31#include <microsim/MSLink.h>
34#include <libsumo/Helper.h>
36#include "Lane.h"
37
38
39namespace libsumo {
40// ===========================================================================
41// static member initializations
42// ===========================================================================
43SubscriptionResults Lane::mySubscriptionResults;
44ContextSubscriptionResults Lane::myContextSubscriptionResults;
45
46
47// ===========================================================================
48// static member definitions
49// ===========================================================================
50std::vector<std::string>
51Lane::getIDList() {
52 MSNet::getInstance(); // just to check that we actually have a network
53 std::vector<std::string> ids;
55 return ids;
56}
57
58
59int
60Lane::getIDCount() {
61 return (int)getIDList().size();
62}
63
64
65std::string
66Lane::getEdgeID(const std::string& laneID) {
67 return getLane(laneID)->getEdge().getID();
68}
69
70
71double
72Lane::getLength(const std::string& laneID) {
73 return getLane(laneID)->getLength();
74}
75
76
77double
78Lane::getMaxSpeed(const std::string& laneID) {
79 return getLane(laneID)->getSpeedLimit();
80}
81
82double
83Lane::getFriction(const std::string& laneID) {
84 return getLane(laneID)->getFrictionCoefficient();
85}
86
87int
88Lane::getLinkNumber(const std::string& laneID) {
89 return (int)getLane(laneID)->getLinkCont().size();
90}
91
92
93std::vector<TraCIConnection>
94Lane::getLinks(const std::string& laneID) {
95 std::vector<TraCIConnection> v;
96 const MSLane* const lane = getLane(laneID);
98 for (const MSLink* const link : lane->getLinkCont()) {
99 const std::string approachedLane = link->getLane() != nullptr ? link->getLane()->getID() : "";
100 const bool hasPrio = link->havePriority();
101 const double speed = MIN2(lane->getSpeedLimit(), link->getLane()->getSpeedLimit());
102 const bool isOpen = link->opened(currTime, speed, speed, SUMOVTypeParameter::getDefault().length,
104 const bool hasFoe = link->hasApproachingFoe(currTime, currTime, 0, SUMOVTypeParameter::getDefaultDecel());
105 const std::string approachedInternal = link->getViaLane() != nullptr ? link->getViaLane()->getID() : "";
106 const std::string state = SUMOXMLDefinitions::LinkStates.getString(link->getState());
107 const std::string direction = SUMOXMLDefinitions::LinkDirections.getString(link->getDirection());
108 const double length = link->getLength();
109 v.push_back(TraCIConnection(approachedLane, hasPrio, isOpen, hasFoe, approachedInternal, state, direction, length));
110 }
111 return v;
112}
113
114
115std::vector<std::string>
116Lane::getAllowed(const std::string& laneID) {
117 SVCPermissions permissions = getLane(laneID)->getPermissions();
118 if (permissions == SVCAll) { // special case: write nothing
119 permissions = 0;
120 }
121 return getVehicleClassNamesList(permissions);
122}
123
124
125std::vector<std::string>
126Lane::getDisallowed(const std::string& laneID) {
127 return getVehicleClassNamesList(invertPermissions((getLane(laneID)->getPermissions()))); // negation yields disallowed
128}
129
130
131std::vector<std::string>
132Lane::getChangePermissions(const std::string& laneID, const int direction) {
133 if (direction == libsumo::LANECHANGE_LEFT) {
134 return getVehicleClassNamesList(getLane(laneID)->getChangeLeft());
135 } else if (direction == libsumo::LANECHANGE_RIGHT) {
136 return getVehicleClassNamesList(getLane(laneID)->getChangeRight());
137 } else {
138 throw TraCIException("Invalid direction for change permission (must be " + toString(libsumo::LANECHANGE_LEFT) + " or " + toString(libsumo::LANECHANGE_RIGHT));
139 }
140}
141
142
143TraCIPositionVector
144Lane::getShape(const std::string& laneID) {
145 TraCIPositionVector pv;
146 const PositionVector& shp = getLane(laneID)->getShape();
147 for (PositionVector::const_iterator pi = shp.begin(); pi != shp.end(); ++pi) {
148 TraCIPosition p;
149 p.x = pi->x();
150 p.y = pi->y();
151 p.z = pi->z();
152 pv.value.push_back(p);
153 }
154 return pv;
155}
156
157
158double
159Lane::getWidth(const std::string& laneID) {
160 return getLane(laneID)->getWidth();
161}
162
163
164double
165Lane::getCO2Emission(const std::string& laneID) {
166 return getLane(laneID)->getEmissions<PollutantsInterface::CO2>();
167}
168
169
170double
171Lane::getCOEmission(const std::string& laneID) {
172 return getLane(laneID)->getEmissions<PollutantsInterface::CO>();
173}
174
175
176double
177Lane::getHCEmission(const std::string& laneID) {
178 return getLane(laneID)->getEmissions<PollutantsInterface::HC>();
179}
180
181
182double
183Lane::getPMxEmission(const std::string& laneID) {
184 return getLane(laneID)->getEmissions<PollutantsInterface::PM_X>();
185}
186
187
188double
189Lane::getNOxEmission(const std::string& laneID) {
190 return getLane(laneID)->getEmissions<PollutantsInterface::NO_X>();
191}
192
193double
194Lane::getFuelConsumption(const std::string& laneID) {
195 return getLane(laneID)->getEmissions<PollutantsInterface::FUEL>();
196}
197
198
199double
200Lane::getNoiseEmission(const std::string& laneID) {
201 return getLane(laneID)->getHarmonoise_NoiseEmissions();
202}
203
204
205double
206Lane::getElectricityConsumption(const std::string& laneID) {
207 return getLane(laneID)->getEmissions<PollutantsInterface::ELEC>();
208}
209
210
211double
212Lane::getLastStepMeanSpeed(const std::string& laneID) {
213 return getLane(laneID)->getMeanSpeed();
214}
215
216
217double
218Lane::getLastStepOccupancy(const std::string& laneID) {
219 return getLane(laneID)->getNettoOccupancy();
220}
221
222
223double
224Lane::getLastStepLength(const std::string& laneID) {
225 const MSLane* lane = getLane(laneID);
226 double length = 0;
227 const MSLane::VehCont& vehs = lane->getVehiclesSecure();
228 for (MSLane::VehCont::const_iterator j = vehs.begin(); j != vehs.end(); ++j) {
229 length += (*j)->getVehicleType().getLength();
230 }
231 if (vehs.size() > 0) {
232 length = length / (double)vehs.size();
233 }
234 lane->releaseVehicles();
235 return length;
236}
237
238
239double
240Lane::getWaitingTime(const std::string& laneID) {
241 return getLane(laneID)->getWaitingSeconds();
242}
243
244
245double
246Lane::getTraveltime(const std::string& laneID) {
247 const MSLane* lane = getLane(laneID);
248 double meanSpeed = lane->getMeanSpeed();
249 if (meanSpeed != 0) {
250 return lane->getLength() / meanSpeed;
251 } else {
252 return 1000000.;
253 }
254}
255
256
257int
258Lane::getLastStepVehicleNumber(const std::string& laneID) {
259 return (int)getLane(laneID)->getVehicleNumber();
260}
261
262
263int
264Lane::getLastStepHaltingNumber(const std::string& laneID) {
265 const MSLane* lane = getLane(laneID);
266 int halting = 0;
267 const MSLane::VehCont& vehs = lane->getVehiclesSecure();
268 for (MSLane::VehCont::const_iterator j = vehs.begin(); j != vehs.end(); ++j) {
269 if ((*j)->getSpeed() < SUMO_const_haltingSpeed) {
270 ++halting;
271 }
272 }
273 lane->releaseVehicles();
274 return halting;
275}
276
277
278std::vector<std::string>
279Lane::getLastStepVehicleIDs(const std::string& laneID) {
280 const MSLane* lane = getLane(laneID);
281 std::vector<std::string> vehIDs;
282 const MSLane::VehCont& vehs = lane->getVehiclesSecure();
283 for (MSLane::VehCont::const_iterator j = vehs.begin(); j != vehs.end(); ++j) {
284 vehIDs.push_back((*j)->getID());
285 }
286 lane->releaseVehicles();
287 return vehIDs;
288}
289
290
291std::vector<std::string>
292Lane::getFoes(const std::string& laneID, const std::string& toLaneID) {
293 std::vector<std::string> foeIDs;
294 const MSLink* const link = getLane(laneID)->getLinkTo(getLane(toLaneID));
295 if (link == nullptr) {
296 throw TraCIException("No connection from lane '" + laneID + "' to lane '" + toLaneID + "'");
297 }
298 for (const MSLink* foe : link->getFoeLinks()) {
299 foeIDs.push_back(foe->getLaneBefore()->getID());
300 }
301 return foeIDs;
302}
303
304
305std::vector<std::string>
306Lane::getInternalFoes(const std::string& laneID) {
307 const MSLane* lane = getLane(laneID);
308 const std::vector<const MSLane*>* foeLanes;
309 std::vector<const MSLane*>::const_iterator it;
310 std::vector<std::string> foeIDs;
311
312 if ((lane->isInternal() || lane->isCrossing()) && lane->getLinkCont().size() > 0) {
313 MSLink* link = lane->getLinkCont().front();
314 foeLanes = &link->getFoeLanes();
315
316 for (it = foeLanes->begin(); foeLanes->end() != it; ++it) {
317 foeIDs.push_back((*it)->getID());
318 }
319 }
320 return foeIDs;
321}
322
323
324const std::vector<std::string>
325Lane::getPendingVehicles(const std::string& laneID) {
326 MSLane* const l = getLane(laneID); // validate laneID
327 std::vector<std::string> vehIDs;
329 if (veh->getLane() == l) {
330 vehIDs.push_back(veh->getID());
331 }
332 }
333 return vehIDs;
334}
335
336
337double
338Lane::getAngle(const std::string& laneID, double relativePosition) {
339 double angle;
340 MSLane* lane = getLane(laneID);
341 if (relativePosition == libsumo::INVALID_DOUBLE_VALUE) {
342 Position start = lane->getShape().front();
343 Position end = lane->getShape().back();
344 angle = start.angleTo2D(end);
345 } else {
346 angle = lane->getShape().rotationAtOffset(lane->interpolateLanePosToGeometryPos(relativePosition));
347 }
348
349 return GeomHelper::naviDegree(angle);
350}
351
352
353std::string
354Lane::getBidiLane(const std::string& laneID) {
355 const MSLane* bidi = getLane(laneID)->getBidiLane();
356 return bidi == nullptr ? "" : bidi->getID();
357}
358
359void
360Lane::setAllowed(const std::string& laneID, std::string allowedClass) {
361 setAllowed(laneID, std::vector<std::string>({allowedClass}));
362}
363
364
365void
366Lane::setAllowed(const std::string& laneID, std::vector<std::string> allowedClasses) {
367 MSLane* const l = getLane(laneID);
370}
371
372
373void
374Lane::setDisallowed(const std::string& laneID, std::string disallowedClasses) {
375 setDisallowed(laneID, std::vector<std::string>({disallowedClasses}));
376}
377
378
379void
380Lane::setDisallowed(const std::string& laneID, std::vector<std::string> disallowedClasses) {
381 MSLane* const l = getLane(laneID);
382 l->setPermissions(invertPermissions(parseVehicleClasses(disallowedClasses)), MSLane::CHANGE_PERMISSIONS_PERMANENT); // negation yields allowed
384}
385
386
387void
388Lane::setChangePermissions(const std::string& laneID, std::vector<std::string> allowedClasses, const int direction) {
389 MSLane* const l = getLane(laneID);
390 if (direction == libsumo::LANECHANGE_LEFT) {
391 l->setChangeLeft(parseVehicleClasses(allowedClasses));
392 } else if (direction == libsumo::LANECHANGE_RIGHT) {
393 l->setChangeRight(parseVehicleClasses(allowedClasses));
394 } else {
395 throw TraCIException("Invalid direction for change permission (must be " + toString(libsumo::LANECHANGE_LEFT) + " or " + toString(libsumo::LANECHANGE_RIGHT));
396 }
397}
398
399
400void
401Lane::setMaxSpeed(const std::string& laneID, double speed) {
402 getLane(laneID)->setMaxSpeed(speed, false, true);
403}
404
405
406void
407Lane::setLength(const std::string& laneID, double length) {
408 getLane(laneID)->setLength(length);
409}
410
411
412void
413Lane::setFriction(const std::string& laneID, double friction) {
414 getLane(laneID)->setFrictionCoefficient(friction);
415}
416
417
418std::string
419Lane::getParameter(const std::string& laneID, const std::string& param) {
420 return getLane(laneID)->getParameter(param, "");
421}
422
423
425
426
427void
428Lane::setParameter(const std::string& laneID, const std::string& key, const std::string& value) {
429 getLane(laneID)->setParameter(key, value);
430}
431
432
434
435
436MSLane*
437Lane::getLane(const std::string& id) {
438 MSLane* const lane = MSLane::dictionary(id);
439 if (lane == nullptr) {
440 throw TraCIException("Lane '" + id + "' is not known");
441 }
442 return lane;
443}
444
445
446void
447Lane::storeShape(const std::string& id, PositionVector& shape) {
448 shape = getLane(id)->getShape();
449}
450
451
452std::shared_ptr<VariableWrapper>
453Lane::makeWrapper() {
454 return std::make_shared<Helper::SubscriptionWrapper>(handleVariable, mySubscriptionResults, myContextSubscriptionResults);
455}
456
457
458bool
459Lane::handleVariable(const std::string& objID, const int variable, VariableWrapper* wrapper, tcpip::Storage* paramData) {
460 switch (variable) {
461 case TRACI_ID_LIST:
462 return wrapper->wrapStringList(objID, variable, getIDList());
463 case ID_COUNT:
464 return wrapper->wrapInt(objID, variable, getIDCount());
465 case LANE_LINK_NUMBER:
466 return wrapper->wrapInt(objID, variable, getLinkNumber(objID));
467 case LANE_EDGE_ID:
468 return wrapper->wrapString(objID, variable, getEdgeID(objID));
469 case VAR_LENGTH:
470 return wrapper->wrapDouble(objID, variable, getLength(objID));
471 case VAR_MAXSPEED:
472 return wrapper->wrapDouble(objID, variable, getMaxSpeed(objID));
473 case VAR_FRICTION:
474 return wrapper->wrapDouble(objID, variable, getFriction(objID));
475 case LANE_ALLOWED:
476 return wrapper->wrapStringList(objID, variable, getAllowed(objID));
477 case LANE_DISALLOWED:
478 return wrapper->wrapStringList(objID, variable, getDisallowed(objID));
479 case LANE_CHANGES:
480 paramData->readUnsignedByte();
481 return wrapper->wrapStringList(objID, variable, getChangePermissions(objID, paramData->readByte()));
482 case VAR_CO2EMISSION:
483 return wrapper->wrapDouble(objID, variable, getCO2Emission(objID));
484 case VAR_COEMISSION:
485 return wrapper->wrapDouble(objID, variable, getCOEmission(objID));
486 case VAR_HCEMISSION:
487 return wrapper->wrapDouble(objID, variable, getHCEmission(objID));
488 case VAR_PMXEMISSION:
489 return wrapper->wrapDouble(objID, variable, getPMxEmission(objID));
490 case VAR_NOXEMISSION:
491 return wrapper->wrapDouble(objID, variable, getNOxEmission(objID));
493 return wrapper->wrapDouble(objID, variable, getFuelConsumption(objID));
495 return wrapper->wrapDouble(objID, variable, getNoiseEmission(objID));
497 return wrapper->wrapDouble(objID, variable, getElectricityConsumption(objID));
499 return wrapper->wrapInt(objID, variable, getLastStepVehicleNumber(objID));
501 return wrapper->wrapDouble(objID, variable, getLastStepMeanSpeed(objID));
503 return wrapper->wrapStringList(objID, variable, getLastStepVehicleIDs(objID));
505 return wrapper->wrapDouble(objID, variable, getLastStepOccupancy(objID));
507 return wrapper->wrapInt(objID, variable, getLastStepHaltingNumber(objID));
508 case LAST_STEP_LENGTH:
509 return wrapper->wrapDouble(objID, variable, getLastStepLength(objID));
510 case VAR_WAITING_TIME:
511 return wrapper->wrapDouble(objID, variable, getWaitingTime(objID));
513 return wrapper->wrapDouble(objID, variable, getTraveltime(objID));
514 case VAR_WIDTH:
515 return wrapper->wrapDouble(objID, variable, getWidth(objID));
516 case VAR_SHAPE:
517 return wrapper->wrapPositionVector(objID, variable, getShape(objID));
519 return wrapper->wrapStringList(objID, variable, getPendingVehicles(objID));
520 case VAR_ANGLE:
521 paramData->readUnsignedByte();
522 return wrapper->wrapDouble(objID, variable, getAngle(objID, paramData->readDouble()));
523 case VAR_BIDI:
524 return wrapper->wrapString(objID, variable, getBidiLane(objID));
526 paramData->readUnsignedByte();
527 return wrapper->wrapString(objID, variable, getParameter(objID, paramData->readString()));
529 paramData->readUnsignedByte();
530 return wrapper->wrapStringPair(objID, variable, getParameterWithKey(objID, paramData->readString()));
531 default:
532 return false;
533 }
534}
535}
536
537
538/****************************************************************************/
long long int SUMOTime
Definition GUI.h:36
const SVCPermissions SVCAll
all VClasses are allowed
SVCPermissions invertPermissions(SVCPermissions permissions)
negate the given permissions and ensure that only relevant bits are set
const std::vector< std::string > & getVehicleClassNamesList(SVCPermissions permissions)
Returns the ids of the given classes, divided using a ' '.
SVCPermissions parseVehicleClasses(const std::string &allowedS)
Parses the given definition of allowed vehicle classes into the given containers Deprecated classes g...
long long int SVCPermissions
bitset where each bit declares whether a certain SVC may use this edge/lane
T MIN2(T a, T b)
Definition StdDefs.h:76
const double SUMO_const_haltingSpeed
the speed threshold at which vehicles are considered as halting
Definition StdDefs.h:58
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
static double naviDegree(const double angle)
C++ TraCI client API implementation.
void rebuildAllowedLanes(const bool onInit=false)
Definition MSEdge.cpp:322
const MSVehicleContainer::VehicleVector & getPendingVehicles() const
retrieve vehicles waiting for insertion
Representation of a lane in the micro simulation.
Definition MSLane.h:84
static void insertIDs(std::vector< std::string > &into)
Adds the ids of all stored lanes into the given vector.
Definition MSLane.cpp:2446
void setChangeRight(SVCPermissions permissions)
Sets the permissions for changing to the right neighbour lane.
Definition MSLane.cpp:4477
double getSpeedLimit() const
Returns the lane's maximum allowed speed.
Definition MSLane.h:592
std::vector< MSVehicle * > VehCont
Container for vehicles.
Definition MSLane.h:119
static const long CHANGE_PERMISSIONS_PERMANENT
Definition MSLane.h:1365
double getLength() const
Returns the lane's length.
Definition MSLane.h:606
void setChangeLeft(SVCPermissions permissions)
Sets the permissions for changing to the left neighbour lane.
Definition MSLane.cpp:4471
void setPermissions(SVCPermissions permissions, long long transientID)
Sets the permissions to the given value. If a transientID is given, the permissions are recored as te...
Definition MSLane.cpp:4438
bool isCrossing() const
Definition MSLane.cpp:2557
static bool dictionary(const std::string &id, MSLane *lane)
Static (sic!) container methods {.
Definition MSLane.cpp:2414
bool isInternal() const
Definition MSLane.cpp:2545
virtual const VehCont & getVehiclesSecure() const
Returns the vehicles container; locks it for microsimulation.
Definition MSLane.h:483
virtual void releaseVehicles() const
Allows to use the container for microsimulation again.
Definition MSLane.h:513
double interpolateLanePosToGeometryPos(double lanePos) const
Definition MSLane.h:554
MSLane * getBidiLane() const
retrieve bidirectional lane or nullptr
Definition MSLane.cpp:4564
virtual const PositionVector & getShape(bool) const
Definition MSLane.h:294
MSEdge & getEdge() const
Returns the lane's edge.
Definition MSLane.h:764
const std::vector< MSLink * > & getLinkCont() const
returns the container with all links !!!
Definition MSLane.h:724
double getMeanSpeed() const
Returns the mean speed on this lane.
Definition MSLane.cpp:3358
static MSNet * getInstance()
Returns the pointer to the unique instance of MSNet (singleton).
Definition MSNet.cpp:185
SUMOTime getCurrentTimeStep() const
Returns the current simulation step.
Definition MSNet.h:320
MSInsertionControl & getInsertionControl()
Returns the insertion control.
Definition MSNet.h:431
const std::string & getID() const
Returns the id.
Definition Named.h:74
A point in 2D or 3D with translation and scaling methods.
Definition Position.h:37
double angleTo2D(const Position &other) const
returns the angle in the plane of the vector pointing from here to the other position (in radians bet...
Definition Position.h:286
A list of positions.
double rotationAtOffset(double pos) const
Returns the rotation at the given length.
static double getDefaultDecel(const SUMOVehicleClass vc=SVC_IGNORING)
Returns the default deceleration for the given vehicle class This needs to be a function because the ...
static const SUMOVTypeParameter & getDefault()
return the default parameters, this is a function due to the http://www.parashift....
Representation of a vehicle.
Definition SUMOVehicle.h:62
static StringBijection< LinkState > LinkStates
link states
static StringBijection< LinkDirection > LinkDirections
link directions
const std::string & getString(const T key) const
virtual std::string readString()
Definition storage.cpp:180
virtual int readUnsignedByte()
Definition storage.cpp:155
virtual int readByte()
Definition storage.cpp:128
virtual double readDouble()
Definition storage.cpp:362
TRACI_CONST double INVALID_DOUBLE_VALUE
TRACI_CONST int LAST_STEP_VEHICLE_ID_LIST
TRACI_CONST int LAST_STEP_VEHICLE_NUMBER
TRACI_CONST int VAR_NOXEMISSION
TRACI_CONST int TRACI_ID_LIST
TRACI_CONST int VAR_WAITING_TIME
std::map< std::string, libsumo::SubscriptionResults > ContextSubscriptionResults
Definition TraCIDefs.h:338
TRACI_CONST int LANE_LINK_NUMBER
TRACI_CONST int LANE_CHANGES
TRACI_CONST int LAST_STEP_LENGTH
TRACI_CONST int VAR_ANGLE
TRACI_CONST int LANE_EDGE_ID
TRACI_CONST int VAR_PMXEMISSION
TRACI_CONST int VAR_COEMISSION
TRACI_CONST int VAR_WIDTH
TRACI_CONST int VAR_MAXSPEED
TRACI_CONST int LAST_STEP_MEAN_SPEED
TRACI_CONST int VAR_CO2EMISSION
TRACI_CONST int LANECHANGE_RIGHT
TRACI_CONST int VAR_PENDING_VEHICLES
TRACI_CONST int VAR_FUELCONSUMPTION
std::map< std::string, libsumo::TraCIResults > SubscriptionResults
{object->{variable->value}}
Definition TraCIDefs.h:337
TRACI_CONST int VAR_SHAPE
TRACI_CONST int LAST_STEP_VEHICLE_HALTING_NUMBER
TRACI_CONST int VAR_LENGTH
TRACI_CONST int VAR_HCEMISSION
TRACI_CONST int ID_COUNT
TRACI_CONST int VAR_PARAMETER
TRACI_CONST int LANECHANGE_LEFT
TRACI_CONST int LAST_STEP_OCCUPANCY
TRACI_CONST int VAR_BIDI
TRACI_CONST int VAR_NOISEEMISSION
TRACI_CONST int LANE_DISALLOWED
TRACI_CONST int VAR_PARAMETER_WITH_KEY
TRACI_CONST int VAR_FRICTION
TRACI_CONST int VAR_CURRENT_TRAVELTIME
TRACI_CONST int LANE_ALLOWED
TRACI_CONST int VAR_ELECTRICITYCONSUMPTION