53 #define CALL_MICRO_FUN(veh, fun, mesoResult) ((dynamic_cast<MSVehicle*>(veh) == nullptr ? (mesoResult) : dynamic_cast<MSVehicle*>(veh)->fun))
62 #define DEBUG_COND (veh->isSelected())
84 Vehicle::isOnInit(
const std::string& vehID) {
86 return sumoVehicle ==
nullptr || sumoVehicle->
getLane() ==
nullptr;
90 std::vector<std::string>
91 Vehicle::getIDList() {
92 std::vector<std::string> ids;
95 if (isVisible((*i).second)) {
96 ids.push_back((*i).first);
103 Vehicle::getIDCount() {
104 return (
int)getIDList().size();
109 Vehicle::getSpeed(
const std::string& vehID) {
115 Vehicle::getLateralSpeed(
const std::string& vehID) {
122 Vehicle::getAcceleration(
const std::string& vehID) {
129 Vehicle::getSpeedWithoutTraCI(
const std::string& vehID) {
136 Vehicle::getPosition(
const std::string& vehID,
const bool includeZ) {
138 if (isVisible(veh)) {
141 return TraCIPosition();
146 Vehicle::getPosition3D(
const std::string& vehID) {
147 return getPosition(vehID,
true);
152 Vehicle::getAngle(
const std::string& vehID) {
159 Vehicle::getSlope(
const std::string& vehID) {
166 Vehicle::getRoadID(
const std::string& vehID) {
173 Vehicle::getLaneID(
const std::string& vehID) {
180 Vehicle::getLaneIndex(
const std::string& vehID) {
187 Vehicle::getTypeID(
const std::string& vehID) {
193 Vehicle::getRouteID(
const std::string& vehID) {
199 Vehicle::getRouteIndex(
const std::string& vehID) {
206 Vehicle::getColor(
const std::string& vehID) {
211 Vehicle::getLanePosition(
const std::string& vehID) {
217 Vehicle::getLateralLanePosition(
const std::string& vehID) {
223 Vehicle::getCO2Emission(
const std::string& vehID) {
229 Vehicle::getCOEmission(
const std::string& vehID) {
235 Vehicle::getHCEmission(
const std::string& vehID) {
241 Vehicle::getPMxEmission(
const std::string& vehID) {
247 Vehicle::getNOxEmission(
const std::string& vehID) {
253 Vehicle::getFuelConsumption(
const std::string& vehID) {
259 Vehicle::getNoiseEmission(
const std::string& vehID) {
265 Vehicle::getElectricityConsumption(
const std::string& vehID) {
271 Vehicle::getPersonNumber(
const std::string& vehID) {
276 Vehicle::getPersonCapacity(
const std::string& vehID) {
280 std::vector<std::string>
281 Vehicle::getPersonIDList(
const std::string& vehID) {
285 std::pair<std::string, double>
286 Vehicle::getLeader(
const std::string& vehID,
double dist) {
289 std::pair<const MSVehicle* const, double> leaderInfo = veh->
getLeader(dist);
290 const std::string leaderID = leaderInfo.first !=
nullptr ? leaderInfo.first->getID() :
"";
291 double gap = leaderInfo.second;
292 if (leaderInfo.first !=
nullptr
293 && leaderInfo.first->getLane() !=
nullptr
294 && leaderInfo.first->getLane()->isInternal()
297 || (veh->
getLane()->
getLinkCont().front()->getIndex() != leaderInfo.first->getLane()->getLinkCont().front()->getIndex()))) {
300 gap =
MAX2(0.0, gap);
302 return std::make_pair(leaderID, gap);
304 return std::make_pair(
"", -1);
309 std::pair<std::string, double>
310 Vehicle::getFollower(
const std::string& vehID,
double dist) {
313 std::pair<const MSVehicle* const, double> leaderInfo = veh->
getFollower(dist);
314 return std::make_pair(
315 leaderInfo.first !=
nullptr ? leaderInfo.first->getID() :
"",
318 return std::make_pair(
"", -1);
324 Vehicle::getWaitingTime(
const std::string& vehID) {
330 Vehicle::getAccumulatedWaitingTime(
const std::string& vehID) {
337 Vehicle::getAdaptedTraveltime(
const std::string& vehID,
double time,
const std::string& edgeID) {
346 Vehicle::getEffort(
const std::string& vehID,
double time,
const std::string& edgeID) {
355 Vehicle::isRouteValid(
const std::string& vehID) {
361 std::vector<std::string>
362 Vehicle::getRoute(
const std::string& vehID) {
363 std::vector<std::string> result;
367 result.push_back((*i)->getID());
374 Vehicle::getSignals(
const std::string& vehID) {
380 std::vector<TraCIBestLanesData>
381 Vehicle::getBestLanes(
const std::string& vehID) {
382 std::vector<TraCIBestLanesData> result;
384 if (veh !=
nullptr && veh->
isOnRoad()) {
386 TraCIBestLanesData bld;
387 bld.laneID = lq.lane->
getID();
388 bld.length = lq.length;
389 bld.occupation = lq.nextOccupation;
390 bld.bestLaneOffset = lq.bestLaneOffset;
391 bld.allowsContinuation = lq.allowsContinuation;
392 for (
const MSLane*
const lane : lq.bestContinuations) {
393 if (lane !=
nullptr) {
394 bld.continuationLanes.push_back(lane->
getID());
397 result.emplace_back(bld);
404 std::vector<TraCINextTLSData>
405 Vehicle::getNextTLS(
const std::string& vehID) {
406 std::vector<TraCINextTLSData> result;
412 if (veh !=
nullptr) {
417 std::vector<MSLink*>::const_iterator linkIt =
MSLane::succLinkSec(*veh, view, *lane, bestLaneConts);
420 if ((*linkIt)->isTLSControlled()) {
421 TraCINextTLSData ntd;
422 ntd.id = (*linkIt)->getTLLogic()->getID();
423 ntd.tlIndex = (*linkIt)->getTLIndex();
425 ntd.state = (char)(*linkIt)->getState();
426 result.push_back(ntd);
429 lane = (*linkIt)->getViaLaneOrLane();
439 for (
int i = 0; i < remainingEdges; i++) {
443 if (allowed !=
nullptr && allowed->size() != 0) {
444 for (
const MSLink*
const link : allowed->front()->getLinkCont()) {
445 if (&link->getLane()->getEdge() == next) {
446 if (link->isTLSControlled()) {
447 TraCINextTLSData ntd;
448 ntd.id = link->getTLLogic()->getID();
449 ntd.tlIndex = link->getTLIndex();
451 ntd.state = (char)link->getState();
452 result.push_back(ntd);
454 seen += allowed->front()->getLength();
468 std::vector<TraCINextStopData>
469 Vehicle::getNextStops(
const std::string& vehID) {
470 return getStops(vehID, 0);
473 std::vector<TraCINextStopData>
474 Vehicle::getStops(
const std::string& vehID,
int limit) {
475 std::vector<TraCINextStopData> result;
479 const std::vector<SUMOVehicleParameter::Stop>& pastStops = vehicle->
getPastStops();
480 const int n = (int)pastStops.size();
481 for (
int i =
MAX2(0, n + limit); i < n; i++) {
486 if (!stop.collision) {
489 result.push_back(nsd);
490 if (limit > 0 && (
int)result.size() >= limit) {
501 Vehicle::getStopState(
const std::string& vehID) {
504 if (veh ==
nullptr) {
511 result = ((stop.
reached ? 1 : 0) +
515 (stop.
busstop !=
nullptr ? 16 : 0) +
525 Vehicle::getDistance(
const std::string& vehID) {
536 Vehicle::getDrivingDistance(
const std::string& vehID,
const std::string& edgeID,
double position,
int ) {
543 if (distance == std::numeric_limits<double>::max()) {
554 Vehicle::getDrivingDistance2D(
const std::string& vehID,
double x,
double y) {
556 if (veh ==
nullptr) {
563 if (distance == std::numeric_limits<double>::max()) {
574 Vehicle::getAllowedSpeed(
const std::string& vehID) {
581 Vehicle::getSpeedFactor(
const std::string& vehID) {
587 Vehicle::getSpeedMode(
const std::string& vehID) {
594 Vehicle::getLaneChangeMode(
const std::string& vehID) {
601 Vehicle::getRoutingMode(
const std::string& vehID) {
607 Vehicle::getLine(
const std::string& vehID) {
612 std::vector<std::string>
613 Vehicle::getVia(
const std::string& vehID) {
619 Vehicle::getLaneChangeState(
const std::string& vehID,
int direction) {
622 return veh->
isOnRoad() ?
CALL_MICRO_FUN(veh, getLaneChangeModel().getSavedState(direction), undefined) : undefined;
627 Vehicle::getParameter(
const std::string& vehID,
const std::string& key) {
632 throw TraCIException(error);
641 std::vector<std::pair<std::string, double> >
642 Vehicle::getNeighbors(
const std::string& vehID,
const int mode) {
643 int dir = (1 & mode) != 0 ? -1 : 1;
644 bool queryLeaders = (2 & mode) != 0;
645 bool blockersOnly = (4 & mode) != 0;
648 std::vector<std::pair<std::string, double> > result;
649 if (veh ==
nullptr) {
652 #ifdef DEBUG_NEIGHBORS
654 std::cout <<
"getNeighbors() for veh '" << vehID <<
"': dir=" << dir
655 <<
", queryLeaders=" << queryLeaders
656 <<
", blockersOnly=" << blockersOnly << std::endl;
665 if (targetLane ==
nullptr) {
690 for (
int i = 0; i < neighbors.
numSublanes(); i++) {
692 if (n.first !=
nullptr) {
696 std::swap(follower, leader);
701 if (n.second < secureGap) {
702 blockers.
addLeader(n.first, n.second, 0, i);
706 neighbors = blockers;
710 for (
int i = 0; i < neighbors.
numSublanes(); i++) {
712 if (n.first !=
nullptr &&
714 (result.size() == 0 || result.back().first != n.first->getID())) {
715 result.push_back(std::make_pair(n.first->getID(), n.second));
724 Vehicle::getFollowSpeed(
const std::string& vehID,
double speed,
double gap,
double leaderSpeed,
double leaderMaxDecel,
const std::string& leaderID) {
727 if (veh ==
nullptr) {
728 WRITE_ERROR(
"getFollowSpeed not applicable for meso");
737 Vehicle::getSecureGap(
const std::string& vehID,
double speed,
double leaderSpeed,
double leaderMaxDecel,
const std::string& leaderID) {
740 if (veh ==
nullptr) {
741 WRITE_ERROR(
"getSecureGap not applicable for meso");
750 Vehicle::getStopSpeed(
const std::string& vehID,
const double speed,
double gap) {
753 if (veh ==
nullptr) {
754 WRITE_ERROR(
"getStopSpeed not applicable for meso");
761 Vehicle::getStopDelay(
const std::string& vehID) {
766 Vehicle::getStopArrivalDelay(
const std::string& vehID) {
776 Vehicle::getTimeLoss(
const std::string& vehID) {
780 std::vector<std::string>
781 Vehicle::getTaxiFleet(
int taxiState) {
782 std::vector<std::string> result;
784 if (taxi->getHolder().hasDeparted()) {
786 || (taxiState == 0 && taxi->getState() == 0)
787 || (taxiState != 0 && (taxi->getState() & taxiState) == taxiState)) {
788 result.push_back(taxi->getHolder().getID());
796 Vehicle::getEmissionClass(
const std::string& vehID) {
801 Vehicle::getShapeClass(
const std::string& vehID) {
807 Vehicle::getLength(
const std::string& vehID) {
813 Vehicle::getAccel(
const std::string& vehID) {
819 Vehicle::getDecel(
const std::string& vehID) {
824 double Vehicle::getEmergencyDecel(
const std::string& vehID) {
829 double Vehicle::getApparentDecel(
const std::string& vehID) {
834 double Vehicle::getActionStepLength(
const std::string& vehID) {
839 double Vehicle::getLastActionTime(
const std::string& vehID) {
842 if (microVeh !=
nullptr) {
852 Vehicle::getTau(
const std::string& vehID) {
858 Vehicle::getImperfection(
const std::string& vehID) {
864 Vehicle::getSpeedDeviation(
const std::string& vehID) {
870 Vehicle::getVehicleClass(
const std::string& vehID) {
876 Vehicle::getMinGap(
const std::string& vehID) {
882 Vehicle::getMinGapLat(
const std::string& vehID) {
885 }
catch (
const TraCIException&) {
893 Vehicle::getMaxSpeed(
const std::string& vehID) {
899 Vehicle::getMaxSpeedLat(
const std::string& vehID) {
905 Vehicle::getLateralAlignment(
const std::string& vehID) {
911 Vehicle::getWidth(
const std::string& vehID) {
917 Vehicle::getHeight(
const std::string& vehID) {
923 Vehicle::setStop(
const std::string& vehID,
924 const std::string& edgeID,
933 pos, laneIndex, startPos, flags, duration, until);
936 throw TraCIException(error);
942 Vehicle::replaceStop(
const std::string& vehID,
944 const std::string& edgeID,
957 WRITE_WARNING(
"Stop replacement parameter 'teleport=" +
toString(teleport) +
"' ignored for vehicle '" + vehID +
"' when only removing stop.");
960 throw TraCIException(
"Stop replacement failed for vehicle '" + vehID +
"' (invalid nextStopIndex).");
964 pos, laneIndex, startPos, flags, duration, until);
967 if (!vehicle->
replaceStop(nextStopIndex, stopPars,
"traci:replaceStop", teleport != 0, error)) {
968 throw TraCIException(
"Stop replacement failed for vehicle '" + vehID +
"' (" + error +
").");
975 Vehicle::rerouteParkingArea(
const std::string& vehID,
const std::string& parkingAreaID) {
978 if (veh ==
nullptr) {
979 WRITE_WARNING(
"rerouteParkingArea not yet implemented for meso");
985 throw TraCIException(error);
990 Vehicle::resume(
const std::string& vehID) {
993 if (veh ==
nullptr) {
998 throw TraCIException(
"Failed to resume vehicle '" + veh->
getID() +
"', it has no stops.");
1002 std::ostringstream strs;
1003 strs <<
"reached: " << sto.
reached;
1004 strs <<
", duration:" << sto.
duration;
1005 strs <<
", edge:" << (*sto.
edge)->getID();
1007 std::string posStr = strs.str();
1008 throw TraCIException(
"Failed to resume from stopping for vehicle '" + veh->
getID() +
"', " + posStr);
1014 Vehicle::changeTarget(
const std::string& vehID,
const std::string& edgeID) {
1017 const bool onInit = isOnInit(vehID);
1018 if (destEdge ==
nullptr) {
1019 throw TraCIException(
"Destination edge '" + edgeID +
"' is not known.");
1027 std::string errorMsg;
1028 if (!veh->
replaceRouteEdges(newRoute, -1, 0,
"traci:changeTarget", onInit,
false,
true, &errorMsg)) {
1029 throw TraCIException(
"Route replacement failed for vehicle '" + veh->
getID() +
"' (" + errorMsg +
").");
1036 throw TraCIException(e.what());
1042 Vehicle::changeLane(
const std::string& vehID,
int laneIndex,
double duration) {
1045 if (veh ==
nullptr) {
1046 WRITE_ERROR(
"changeLane not applicable for meso");
1050 std::vector<std::pair<SUMOTime, int> > laneTimeLine;
1051 laneTimeLine.push_back(std::make_pair(
MSNet::getInstance()->getCurrentTimeStep(), laneIndex));
1057 Vehicle::changeLaneRelative(
const std::string& vehID,
int indexOffset,
double duration) {
1060 if (veh ==
nullptr) {
1061 WRITE_ERROR(
"changeLaneRelative not applicable for meso");
1065 std::vector<std::pair<SUMOTime, int> > laneTimeLine;
1067 if (laneIndex < 0 && !veh->getLaneChangeModel().isOpposite()) {
1069 WRITE_WARNING(
"Ignoring changeLaneRelative for vehicle '" + vehID +
"' that isn't on the road");
1074 laneTimeLine.push_back(std::make_pair(
MSNet::getInstance()->getCurrentTimeStep(), laneIndex));
1082 Vehicle::changeSublane(
const std::string& vehID,
double latDist) {
1085 if (veh ==
nullptr) {
1086 WRITE_ERROR(
"changeSublane not applicable for meso");
1095 Vehicle::add(
const std::string& vehID,
1096 const std::string& routeID,
1097 const std::string& typeID,
1098 const std::string& depart,
1099 const std::string& departLane,
1100 const std::string& departPos,
1101 const std::string& departSpeed,
1102 const std::string& arrivalLane,
1103 const std::string& arrivalPos,
1104 const std::string& arrivalSpeed,
1105 const std::string& fromTaz,
1106 const std::string& toTaz,
1107 const std::string& line,
1111 if (veh !=
nullptr) {
1112 throw TraCIException(
"The vehicle '" + vehID +
"' to add already exists.");
1116 vehicleParams.
id = vehID;
1119 throw TraCIException(
"Invalid type '" + typeID +
"' for vehicle '" + vehID +
"'.");
1123 if (routeID ==
"") {
1129 if (route ==
nullptr) {
1132 std::vector<std::string> edges;
1133 edges.push_back(e->getID());
1134 libsumo::Route::add(dummyRouteID, edges);
1144 throw TraCIException(
"Invalid route '" + routeID +
"' for vehicle '" + vehID +
"'.");
1148 if (route->
getEdges().size() == 2) {
1150 if (std::find(succ.begin(), succ.end(), route->
getEdges().back()) == succ.end()) {
1154 if (fromTaz !=
"" || toTaz !=
"") {
1159 throw TraCIException(error);
1163 WRITE_WARNING(
"Departure time for vehicle '" + vehID +
"' is in the past; using current time instead.");
1168 throw TraCIException(error);
1171 throw TraCIException(error);
1174 throw TraCIException(error);
1177 throw TraCIException(error);
1180 throw TraCIException(error);
1183 throw TraCIException(error);
1185 vehicleParams.
fromTaz = fromTaz;
1186 vehicleParams.
toTaz = toTaz;
1187 vehicleParams.
line = line;
1195 if (fromTaz ==
"" && !route->
getEdges().front()->validateDepartSpeed(*vehicle)) {
1197 throw TraCIException(
"Departure speed for vehicle '" + vehID +
"' is too high for the departure edge '" + route->
getEdges().front()->getID() +
"'.");
1202 throw TraCIException(
"Vehicle '" + vehID +
"' has no valid route (" + msg +
"). ");
1209 if (vehicle !=
nullptr) {
1212 throw TraCIException(e.what());
1218 Vehicle::moveToXY(
const std::string& vehID,
const std::string& edgeID,
const int laneIndex,
1219 const double x,
const double y,
double angle,
const int keepRoute,
double matchThreshold) {
1222 if (veh ==
nullptr) {
1226 const bool doKeepRoute = (keepRoute & 1) != 0 && veh->
getID() !=
"VTD_EGO";
1227 const bool mayLeaveNetwork = (keepRoute & 2) != 0;
1228 const bool ignorePermissions = (keepRoute & 4) != 0;
1232 const std::string origID = edgeID +
"_" +
toString(laneIndex);
1236 const double origAngle = angle;
1241 while (angle >= 360.) {
1244 while (angle < 0.) {
1252 std::cout <<
" wantedPos=" << pos <<
" origID=" << origID <<
" laneIndex=" << laneIndex <<
" origAngle=" << origAngle <<
" angle=" << angle <<
" keepRoute=" << keepRoute << std::endl;
1258 double lanePosLat = 0;
1259 double bestDistance = std::numeric_limits<double>::max();
1260 int routeOffset = 0;
1262 double maxRouteDistance = matchThreshold;
1271 vClass, setLateralPos,
1272 bestDistance, &lane, lanePos, routeOffset);
1278 vClass, setLateralPos,
1279 bestDistance, &lane, lanePos, routeOffset, edges);
1281 if ((found && bestDistance <= maxRouteDistance) || mayLeaveNetwork) {
1284 if (found && setLateralPos) {
1287 lanePosLat = perpDist;
1288 if (!mayLeaveNetwork) {
1296 WRITE_WARNING(
"Could not determine position on lane '" + lane->
getID() +
"' at lateral position " +
toString(-lanePosLat) +
".");
1300 lanePosLat = -lanePosLat;
1309 assert((found && lane != 0) || (!found && lane == 0));
1310 assert(!
ISNAN(lanePos));
1312 if (lane !=
nullptr) {
1321 std::cout <<
SIMTIME <<
" veh=" << vehID +
" moveToXYResult lane='" <<
Named::getIDSecure(lane) <<
"' lanePos=" << lanePos <<
" lanePosLat=" << lanePosLat <<
"\n";
1328 if (lane ==
nullptr) {
1329 throw TraCIException(
"Could not map vehicle '" + vehID +
"', no road found within " +
toString(maxRouteDistance) +
"m.");
1331 throw TraCIException(
"Could not map vehicle '" + vehID +
"', distance to road is " +
toString(bestDistance) +
".");
1337 Vehicle::slowDown(
const std::string& vehID,
double speed,
double duration) {
1340 if (veh ==
nullptr) {
1345 std::vector<std::pair<SUMOTime, double> > speedTimeLine;
1352 Vehicle::openGap(
const std::string& vehID,
double newTimeHeadway,
double newSpaceHeadway,
double duration,
double changeRate,
double maxDecel,
const std::string& referenceVehID) {
1355 if (veh ==
nullptr) {
1361 if (referenceVehID !=
"") {
1365 if (newTimeHeadway == -1) {
1366 newTimeHeadway = originalTau;
1368 if (originalTau > newTimeHeadway) {
1369 WRITE_WARNING(
"Ignoring openGap(). New time headway must not be smaller than the original.");
1376 Vehicle::deactivateGapControl(
const std::string& vehID) {
1379 if (veh ==
nullptr) {
1380 WRITE_ERROR(
"deactivateGapControl not applicable for meso");
1390 Vehicle::requestToC(
const std::string& vehID,
double leadTime) {
1391 setParameter(vehID,
"device.toc.requestToC",
toString(leadTime));
1395 Vehicle::setSpeed(
const std::string& vehID,
double speed) {
1398 if (veh ==
nullptr) {
1403 std::vector<std::pair<SUMOTime, double> > speedTimeLine;
1405 speedTimeLine.push_back(std::make_pair(
MSNet::getInstance()->getCurrentTimeStep(), speed));
1412 Vehicle::setPreviousSpeed(
const std::string& vehID,
double prevspeed) {
1415 if (veh ==
nullptr) {
1416 WRITE_WARNING(
"setPreviousSpeed not yet implemented for meso");
1424 Vehicle::setSpeedMode(
const std::string& vehID,
int speedMode) {
1427 if (veh ==
nullptr) {
1436 Vehicle::setLaneChangeMode(
const std::string& vehID,
int laneChangeMode) {
1439 if (veh ==
nullptr) {
1440 WRITE_ERROR(
"setLaneChangeMode not applicable for meso");
1448 Vehicle::setRoutingMode(
const std::string& vehID,
int routingMode) {
1453 Vehicle::setType(
const std::string& vehID,
const std::string& typeID) {
1455 if (vehicleType ==
nullptr) {
1456 throw TraCIException(
"Vehicle type '" + typeID +
"' is not known");
1462 Vehicle::setRouteID(
const std::string& vehID,
const std::string& routeID) {
1466 throw TraCIException(
"The route '" + routeID +
"' is not known.");
1470 WRITE_WARNING(
"Invalid route replacement for vehicle '" + veh->
getID() +
"'. " + msg);
1472 throw TraCIException(
"Route replacement failed for " + veh->
getID());
1476 std::string errorMsg;
1477 if (!veh->
replaceRoute(r,
"traci:setRouteID", veh->
getLane() ==
nullptr, 0,
true,
true, &errorMsg)) {
1478 throw TraCIException(
"Route replacement failed for vehicle '" + veh->
getID() +
"' (" + errorMsg +
").");
1483 Vehicle::setRoute(
const std::string& vehID,
const std::string& edgeID) {
1484 setRoute(vehID, std::vector<std::string>({edgeID}));
1488 Vehicle::setRoute(
const std::string& vehID,
const std::vector<std::string>& edgeIDs) {
1491 const bool onInit = veh->
getLane() ==
nullptr;
1494 if (edges.size() > 0 && edges.front()->isInternal()) {
1495 if (edges.size() == 1) {
1497 edges.push_back(edges.back()->getLanes()[0]->getNextNormal());
1501 edges.erase(edges.begin());
1506 throw TraCIException(
"Invalid edge list for vehicle '" + veh->
getID() +
"' (" + e.what() +
")");
1508 std::string errorMsg;
1509 if (!veh->
replaceRouteEdges(edges, -1, 0,
"traci:setRoute", onInit,
true,
true, &errorMsg)) {
1510 throw TraCIException(
"Route replacement failed for vehicle '" + veh->
getID() +
"' (" + errorMsg +
").");
1515 Vehicle::updateBestLanes(
const std::string& vehID) {
1518 if (veh ==
nullptr) {
1519 WRITE_ERROR(
"updateBestLanes not applicable for meso");
1528 Vehicle::setAdaptedTraveltime(
const std::string& vehID,
const std::string& edgeID,
1529 double time,
double begSeconds,
double endSeconds) {
1532 if (edge ==
nullptr) {
1533 throw TraCIException(
"Edge '" + edgeID +
"' is not known.");
1537 if (begSeconds == 0 && endSeconds == std::numeric_limits<double>::max()) {
1554 Vehicle::setEffort(
const std::string& vehID,
const std::string& edgeID,
1555 double effort,
double begSeconds,
double endSeconds) {
1558 if (edge ==
nullptr) {
1559 throw TraCIException(
"Edge '" + edgeID +
"' is not known.");
1563 if (begSeconds == 0 && endSeconds == std::numeric_limits<double>::max()) {
1580 Vehicle::rerouteTraveltime(
const std::string& vehID,
const bool currentTravelTimes) {
1589 Vehicle::rerouteEffort(
const std::string& vehID) {
1597 Vehicle::setSignals(
const std::string& vehID,
int signals) {
1600 if (veh ==
nullptr) {
1601 WRITE_ERROR(
"setSignals not applicable for meso");
1616 Vehicle::moveTo(
const std::string& vehID,
const std::string& laneID,
double position,
int reason) {
1619 if (veh ==
nullptr) {
1626 throw TraCIException(
"Unknown lane '" + laneID +
"'.");
1650 throw TraCIException(
"Lane '" + laneID +
"' is not on the route of vehicle '" + vehID +
"'.");
1654 if (veh->
getLane() !=
nullptr) {
1662 const int newRouteIndex = (int)(it - veh->
getRoute().
begin());
1663 if (oldRouteIndex > newRouteIndex) {
1686 throw TraCIException(
"Invalid moveTo reason '" +
toString(reason) +
"' for vehicle '" + vehID +
"'.");
1696 Vehicle::setActionStepLength(
const std::string& vehID,
double actionStepLength,
bool resetActionOffset) {
1697 if (actionStepLength < 0.0) {
1698 WRITE_ERROR(
"Invalid action step length (<0). Ignoring command setActionStepLength().");
1703 if (veh ==
nullptr) {
1704 WRITE_ERROR(
"setActionStepLength not applicable for meso");
1708 if (actionStepLength == 0.) {
1717 Vehicle::remove(
const std::string& vehID,
char reason) {
1741 throw TraCIException(
"Unknown removal status.");
1746 if (microVeh !=
nullptr) {
1747 if (veh->
getLane() !=
nullptr) {
1761 Vehicle::setColor(
const std::string& vehID,
const TraCIColor& col) {
1763 p.
color.
set((
unsigned char)col.r, (
unsigned char)col.g, (
unsigned char)col.b, (
unsigned char)col.a);
1769 Vehicle::setSpeedFactor(
const std::string& vehID,
double factor) {
1775 Vehicle::setLine(
const std::string& vehID,
const std::string& line) {
1781 Vehicle::setVia(
const std::string& vehID,
const std::vector<std::string>& via) {
1788 throw TraCIException(e.what());
1795 Vehicle::setLength(
const std::string& vehID,
double length) {
1801 Vehicle::setMaxSpeed(
const std::string& vehID,
double speed) {
1807 Vehicle::setVehicleClass(
const std::string& vehID,
const std::string& clazz) {
1813 Vehicle::setShapeClass(
const std::string& vehID,
const std::string& clazz) {
1819 Vehicle::setEmissionClass(
const std::string& vehID,
const std::string& clazz) {
1825 Vehicle::setWidth(
const std::string& vehID,
double width) {
1831 Vehicle::setHeight(
const std::string& vehID,
double height) {
1837 Vehicle::setMinGap(
const std::string& vehID,
double minGap) {
1843 Vehicle::setAccel(
const std::string& vehID,
double accel) {
1849 Vehicle::setDecel(
const std::string& vehID,
double decel) {
1855 Vehicle::setEmergencyDecel(
const std::string& vehID,
double decel) {
1856 VehicleType::setEmergencyDecel(
Helper::getVehicle(vehID)->getSingularType().getID(), decel);
1861 Vehicle::setApparentDecel(
const std::string& vehID,
double decel) {
1867 Vehicle::setImperfection(
const std::string& vehID,
double imperfection) {
1873 Vehicle::setTau(
const std::string& vehID,
double tau) {
1879 Vehicle::setMinGapLat(
const std::string& vehID,
double minGapLat) {
1881 setParameter(vehID,
"laneChangeModel.minGapLat",
toString(minGapLat));
1882 }
catch (TraCIException&) {
1890 Vehicle::setMaxSpeedLat(
const std::string& vehID,
double speed) {
1896 Vehicle::setLateralAlignment(
const std::string& vehID,
const std::string& latAlignment) {
1902 throw TraCIException(
"Unknown value '" + latAlignment +
"' when setting latAlignment for vehID '" + vehID +
"';\n must be one of (\"right\", \"center\", \"arbitrary\", \"nice\", \"compact\", \"left\" or a float)");
1908 Vehicle::setParameter(
const std::string& vehID,
const std::string& key,
const std::string& value) {
1913 if (tok.size() < 3) {
1914 throw TraCIException(
"Invalid device parameter '" + key +
"' for vehicle '" + vehID +
"'");
1917 veh->
setDeviceParameter(tok.get(1), key.substr(tok.get(0).size() + tok.get(1).size() + 2), value);
1919 throw TraCIException(
"Vehicle '" + vehID +
"' does not support device parameter '" + key +
"' (" + e.what() +
").");
1922 if (microVeh ==
nullptr) {
1923 throw TraCIException(
"Meso Vehicle '" + vehID +
"' does not support laneChangeModel parameters.");
1925 const std::string attrName = key.substr(16);
1929 throw TraCIException(
"Vehicle '" + vehID +
"' does not support laneChangeModel parameter '" + key +
"' (" + e.what() +
").");
1932 if (microVeh ==
nullptr) {
1933 throw TraCIException(
"Meso Vehicle '" + vehID +
"' does not support carFollowModel parameters.");
1935 const std::string attrName = key.substr(15);
1939 throw TraCIException(
"Vehicle '" + vehID +
"' does not support carFollowModel parameter '" + key +
"' (" + e.what() +
").");
1947 throw TraCIException(e.what());
1951 if (tok.size() != 3) {
1952 throw TraCIException(
"Invalid request for device status change. Expected format is 'has.DEVICENAME.device'");
1954 const std::string deviceName = tok.get(1);
1959 throw TraCIException(
"Changing device status requires a 'true' or 'false'");
1962 throw TraCIException(
"Device removal is not supported for device of type '" + deviceName +
"'");
1967 throw TraCIException(
"Cannot create vehicle device (" + std::string(e.what()) +
").");
1976 Vehicle::highlight(
const std::string& vehID,
const TraCIColor& col,
double size,
const int alphaMax,
const double duration,
const int type) {
1982 const double l2 = veh->
getLength() * 0.5;
1989 const unsigned int nPoints = 34;
1993 #ifdef DEBUG_DYNAMIC_SHAPES
1994 std::cout <<
SIMTIME <<
" Vehicle::highlight() for vehicle '" << vehID <<
"'\n"
1995 <<
" circle: " << circlePV << std::endl;
2001 while (Polygon::exists(polyID)) {
2010 lyr += (type + 1) / 257.;
2013 Polygon::addHighlightPolygon(vehID, type, polyID, circle, col,
true,
"highlight", (
int)lyr, lw);
2016 double maxAttack = 1.0;
2017 std::vector<double> timeSpan;
2018 if (duration > 0.) {
2019 timeSpan = {0,
MIN2(maxAttack, duration / 3.), 2.*duration / 3., duration};
2022 std::vector<double> alphaSpan;
2023 if (alphaMax > 0.) {
2024 alphaSpan = {0., (double) alphaMax, (
double)(alphaMax) / 3., 0.};
2027 Polygon::addDynamics(polyID, vehID, timeSpan, alphaSpan,
false,
true);
2031 Vehicle::dispatchTaxi(
const std::string& vehID,
const std::vector<std::string>& reservations) {
2034 if (taxi ==
nullptr) {
2035 throw TraCIException(
"Vehicle '" + vehID +
"' is not a taxi");
2038 if (dispatcher ==
nullptr) {
2039 throw TraCIException(
"Cannot dispatch taxi because no reservations have been made");
2042 if (traciDispatcher ==
nullptr) {
2043 throw TraCIException(
"device.taxi.dispatch-algorithm 'traci' has not been loaded");
2045 if (reservations.size() == 0) {
2046 throw TraCIException(
"No reservations have been specified for vehicle '" + vehID +
"'");
2051 throw TraCIException(
"Could not interpret reservations for vehicle '" + vehID +
"' (" + e.what() +
").");
2059 Vehicle::subscribeLeader(
const std::string& vehID,
double dist,
double begin,
double end) {
2066 Vehicle::addSubscriptionFilterLanes(
const std::vector<int>& lanes,
bool noOpposite,
double downstreamDist,
double upstreamDist) {
2069 s->filterLanes = lanes;
2072 addSubscriptionFilterNoOpposite();
2075 addSubscriptionFilterDownstreamDistance(downstreamDist);
2078 addSubscriptionFilterUpstreamDistance(upstreamDist);
2084 Vehicle::addSubscriptionFilterNoOpposite() {
2090 Vehicle::addSubscriptionFilterDownstreamDistance(
double dist) {
2093 s->filterDownstreamDist = dist;
2099 Vehicle::addSubscriptionFilterUpstreamDistance(
double dist) {
2102 s->filterUpstreamDist = dist;
2108 Vehicle::addSubscriptionFilterCFManeuver(
double downstreamDist,
double upstreamDist) {
2109 addSubscriptionFilterLeadFollow(std::vector<int>({0}));
2111 addSubscriptionFilterDownstreamDistance(downstreamDist);
2114 addSubscriptionFilterUpstreamDistance(upstreamDist);
2121 Vehicle::addSubscriptionFilterLCManeuver(
int direction,
bool noOpposite,
double downstreamDist,
double upstreamDist) {
2122 std::vector<int> lanes;
2125 lanes = std::vector<int>({-1, 0, 1});
2126 }
else if (direction != -1 && direction != 1) {
2127 WRITE_WARNING(
"Ignoring lane change subscription filter with non-neighboring lane offset direction=" +
2130 lanes = std::vector<int>({0, direction});
2132 addSubscriptionFilterLeadFollow(lanes);
2134 addSubscriptionFilterNoOpposite();
2137 addSubscriptionFilterDownstreamDistance(downstreamDist);
2140 addSubscriptionFilterUpstreamDistance(upstreamDist);
2146 Vehicle::addSubscriptionFilterLeadFollow(
const std::vector<int>& lanes) {
2148 addSubscriptionFilterLanes(lanes);
2153 Vehicle::addSubscriptionFilterTurn(
double downstreamDist,
double foeDistToJunction) {
2156 addSubscriptionFilterDownstreamDistance(downstreamDist);
2159 s->filterFoeDistToJunction = foeDistToJunction;
2165 Vehicle::addSubscriptionFilterVClass(
const std::vector<std::string>& vClasses) {
2174 Vehicle::addSubscriptionFilterVType(
const std::vector<std::string>& vTypes) {
2177 s->filterVTypes.insert(vTypes.begin(), vTypes.end());
2183 Vehicle::addSubscriptionFilterFieldOfVision(
double openingAngle) {
2186 s->filterFieldOfVisionOpeningAngle = openingAngle;
2192 Vehicle::addSubscriptionFilterLateralDistance(
double lateralDist,
double downstreamDist,
double upstreamDist) {
2195 s->filterLateralDist = lateralDist;
2198 addSubscriptionFilterDownstreamDistance(downstreamDist);
2201 addSubscriptionFilterUpstreamDistance(upstreamDist);
2212 std::shared_ptr<VariableWrapper>
2213 Vehicle::makeWrapper() {
2214 return std::make_shared<Helper::SubscriptionWrapper>(handleVariable, mySubscriptionResults, myContextSubscriptionResults);
2219 Vehicle::handleVariable(
const std::string& objID,
const int variable, VariableWrapper* wrapper,
tcpip::Storage* paramData) {
2222 return wrapper->wrapStringList(objID, variable, getIDList());
2224 return wrapper->wrapInt(objID, variable, getIDCount());
2226 return wrapper->wrapPosition(objID, variable, getPosition(objID));
2228 return wrapper->wrapPosition(objID, variable, getPosition(objID,
true));
2230 return wrapper->wrapDouble(objID, variable, getAngle(objID));
2232 return wrapper->wrapDouble(objID, variable, getSpeed(objID));
2234 return wrapper->wrapDouble(objID, variable, getLateralSpeed(objID));
2236 return wrapper->wrapString(objID, variable, getRoadID(objID));
2238 return wrapper->wrapDouble(objID, variable, getSpeedWithoutTraCI(objID));
2240 return wrapper->wrapDouble(objID, variable, getSlope(objID));
2242 return wrapper->wrapString(objID, variable, getLaneID(objID));
2244 return wrapper->wrapInt(objID, variable, getLaneIndex(objID));
2246 return wrapper->wrapString(objID, variable, getTypeID(objID));
2248 return wrapper->wrapString(objID, variable, getRouteID(objID));
2250 return wrapper->wrapInt(objID, variable, getRouteIndex(objID));
2252 return wrapper->wrapColor(objID, variable, getColor(objID));
2254 return wrapper->wrapDouble(objID, variable, getLanePosition(objID));
2256 return wrapper->wrapDouble(objID, variable, getLateralLanePosition(objID));
2258 return wrapper->wrapDouble(objID, variable, getCO2Emission(objID));
2260 return wrapper->wrapDouble(objID, variable, getCOEmission(objID));
2262 return wrapper->wrapDouble(objID, variable, getHCEmission(objID));
2264 return wrapper->wrapDouble(objID, variable, getPMxEmission(objID));
2266 return wrapper->wrapDouble(objID, variable, getNOxEmission(objID));
2268 return wrapper->wrapDouble(objID, variable, getFuelConsumption(objID));
2270 return wrapper->wrapDouble(objID, variable, getNoiseEmission(objID));
2272 return wrapper->wrapDouble(objID, variable, getElectricityConsumption(objID));
2274 return wrapper->wrapInt(objID, variable, getPersonNumber(objID));
2276 return wrapper->wrapInt(objID, variable, getPersonCapacity(objID));
2278 return wrapper->wrapStringList(objID, variable, getPersonIDList(objID));
2280 return wrapper->wrapDouble(objID, variable, getWaitingTime(objID));
2282 return wrapper->wrapDouble(objID, variable, getAccumulatedWaitingTime(objID));
2284 return wrapper->wrapInt(objID, variable, isRouteValid(objID));
2286 return wrapper->wrapStringList(objID, variable, getRoute(objID));
2288 return wrapper->wrapInt(objID, variable, getSignals(objID));
2290 return wrapper->wrapInt(objID, variable, getStopState(objID));
2292 return wrapper->wrapDouble(objID, variable, getDistance(objID));
2294 return wrapper->wrapDouble(objID, variable, getAllowedSpeed(objID));
2296 return wrapper->wrapDouble(objID, variable, getSpeedFactor(objID));
2298 return wrapper->wrapInt(objID, variable, getSpeedMode(objID));
2300 return wrapper->wrapInt(objID, variable, getLaneChangeMode(objID));
2302 return wrapper->wrapInt(objID, variable, getRoutingMode(objID));
2304 return wrapper->wrapString(objID, variable, getLine(objID));
2306 return wrapper->wrapStringList(objID, variable, getVia(objID));
2308 return wrapper->wrapDouble(objID, variable, getAcceleration(objID));
2310 return wrapper->wrapDouble(objID, variable, getLastActionTime(objID));
2312 return wrapper->wrapDouble(objID, variable, getStopDelay(objID));
2314 return wrapper->wrapDouble(objID, variable, getStopArrivalDelay(objID));
2316 return wrapper->wrapDouble(objID, variable, getTimeLoss(objID));
2318 return wrapper->wrapDouble(objID, variable, getMinGapLat(objID));
2322 return wrapper->wrapStringDoublePair(objID, variable, getLeader(objID, dist));
2327 return wrapper->wrapStringDoublePair(objID, variable, getFollower(objID, dist));
2331 return wrapper->wrapString(objID, variable, getParameter(objID, paramData->
readString()));
2334 return wrapper->wrapStringPair(objID, variable, getParameterWithKey(objID, paramData->
readString()));
2339 return VehicleType::handleVariableWithID(objID, getTypeID(objID), variable, wrapper, paramData);
std::vector< const MSEdge * > ConstMSEdgeVector
std::vector< MSEdge * > MSEdgeVector
std::pair< const MSVehicle *, double > CLeaderDist
ConstMSEdgeVector::const_iterator MSRouteIterator
#define WRITE_WARNING(msg)
LatAlignmentDefinition
Possible ways to choose the lateral alignment, i.e., how vehicles align themselves within their lane.
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.
StringBijection< SUMOVehicleClass > SumoVehicleClassStrings(sumoVehicleClassStringInitializer, SVC_CUSTOM2, false)
SVCPermissions parseVehicleClasses(const std::string &allowedS)
Parses the given definition of allowed vehicle classes into the given containers Deprecated classes g...
std::string getVehicleShapeName(SUMOVehicleShape id)
Returns the class name of the shape class given by its id.
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types.
@ SVC_IGNORING
vehicles ignoring classes
const int VEHPARS_COLOR_SET
const int VEHPARS_FORCE_REROUTE
@ DEPART_GIVEN
The time is given.
@ DEPART_CONTAINER_TRIGGERED
The departure is container triggered.
@ DEPART_TRIGGERED
The departure is person triggered.
@ DEPART_NOW
The vehicle is discarded if emission fails (not fully implemented yet)
@ LCA_UNKNOWN
The action has not been determined.
const double INVALID_DOUBLE
#define UNUSED_PARAMETER(x)
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
#define LIBSUMO_SUBSCRIPTION_IMPLEMENTATION(CLASS, DOMAIN)
#define LIBSUMO_GET_PARAMETER_WITH_KEY_IMPLEMENTATION(CLASS)
std::vector< double > & getParameter()
Returns the parameters of this distribution.
static PositionVector makeRing(const double radius1, const double radius2, const Position ¢er, unsigned int nPoints)
static const double INVALID_OFFSET
a value to signify offsets outside the range of [0, Line.length()]
static double naviDegree(const double angle)
A vehicle from the mesoscopic point of view.
SUMOTime getEventTime() const
Returns the (planned) time at which the vehicle leaves his current cell.
virtual double getSafetyFactor() const
return factor for modifying the safety constraints of the car-following model
virtual void setParameter(const std::string &key, const std::string &value)
try to set the given parameter for this laneChangeModel. Throw exception for unsupported key
SUMOAbstractRouter< MSEdge, SUMOVehicle > & getRouterTT(const int rngIndex, SUMOVehicleClass svc) const
void setRoutingMode(int value)
Sets routing behavior.
int getRoutingMode() const
return the current routing mode
The base class for microscopic and mesoscopic vehicles.
double getMaxSpeed() const
Returns the maximum speed.
MSVehicleDevice * getDevice(const std::type_info &type) const
Returns a device of the given type if it exists or 0.
void resetRoutePosition(int index, DepartLaneDefinition departLaneProcedure)
reset index of edge within route
virtual BaseInfluencer & getBaseInfluencer()=0
Returns the velocity/lane influencer.
bool replaceStop(int nextStopIndex, SUMOVehicleParameter::Stop stop, const std::string &info, bool teleport, std::string &errorMsg)
void setChosenSpeedFactor(const double factor)
Returns the precomputed factor by which the driver wants to be faster than the speed limit.
virtual double getStopDelay() const
Returns the estimated public transport stop (departure) delay in seconds.
const std::list< MSStop > & getStops() const
const SUMOVehicleParameter & getParameter() const
Returns the vehicle's parameter (including departure definition)
double getFuelConsumption() const
Returns fuel consumption of the current state.
double getCO2Emissions() const
Returns CO2 emission of the current state.
virtual std::pair< const MSVehicle *const, double > getFollower(double dist=0) const
Returns the follower of the vehicle looking for a fixed distance.
double getChosenSpeedFactor() const
Returns the precomputed factor by which the driver wants to be faster than the speed limit.
double getElectricityConsumption() const
Returns electricity consumption of the current state.
virtual double getTimeLossSeconds() const
Returns the time loss in seconds.
double getOdometer() const
Returns the distance that was already driven by this vehicle.
MSVehicleType & getSingularType()
Replaces the current vehicle type with a new one used by this vehicle only.
virtual void replaceVehicleType(MSVehicleType *type)
Replaces the current vehicle type by the one given.
virtual void onRemovalFromNet(const MSMoveReminder::Notification)
Called when the vehicle is removed from the network.
double getLength() const
Returns the vehicle's length.
bool isParking() const
Returns whether the vehicle is parking.
const MSEdge * getEdge() const
Returns the edge the vehicle is currently at.
double getHarmonoise_NoiseEmissions() const
Returns noise emissions of the current state.
bool hasValidRoute(std::string &msg, const MSRoute *route=0) const
Validates the current or given route.
int getPersonNumber() const
Returns the number of persons.
virtual std::pair< const MSVehicle *const, double > getLeader(double dist=0) const
Returns the leader of the vehicle looking for a fixed distance.
void setJunctionModelParameter(const std::string &key, const std::string &value)
set individual junction model paramete (not type related)
double getNOxEmissions() const
Returns NOx emission of the current state.
double getPMxEmissions() const
Returns PMx emission of the current state.
bool hasDeparted() const
Returns whether this vehicle has already departed.
double getCOEmissions() const
Returns CO emission of the current state.
virtual const MSEdge * getRerouteOrigin() const
Returns the starting point for reroutes (usually the current edge)
const MSRouteIterator & getCurrentRouteEdge() const
Returns an iterator pointing to the current edge in this vehicles route.
void setDeviceParameter(const std::string &deviceName, const std::string &key, const std::string &value)
try to set the given parameter from any of the vehicles devices, raise InvalidArgument if no device p...
const MSVehicleType & getVehicleType() const
Returns the vehicle's type definition.
bool hasStops() const
Returns whether the vehicle has to stop somewhere.
void addToOdometer(double value)
Manipulate the odometer.
std::string getPrefixedParameter(const std::string &key, std::string &error) const
retrieve parameters of devices, models and the vehicle itself
SUMOVehicleClass getVClass() const
Returns the vehicle's access class.
virtual double getStopArrivalDelay() const
Returns the estimated public transport stop arrival delay in seconds.
virtual bool replaceRoute(const MSRoute *route, const std::string &info, bool onInit=false, int offset=0, bool addStops=true, bool removeStops=true, std::string *msgReturn=nullptr)
Replaces the current route by the given one.
std::vector< std::string > getPersonIDList() const
Returns the list of persons.
const MSEdgeWeightsStorage & getWeightsStorage() const
Returns the vehicle's internal edge travel times/efforts container.
double getHCEmissions() const
Returns HC emission of the current state.
virtual bool addTraciStop(SUMOVehicleParameter::Stop stop, std::string &errorMsg)
int getRoutePosition() const
return index of edge within route
virtual bool isOnRoad() const
Returns the information whether the vehicle is on a road (is simulated)
void reroute(SUMOTime t, const std::string &info, SUMOAbstractRouter< MSEdge, SUMOVehicle > &router, const bool onInit=false, const bool withTaz=false, const bool silent=false)
Performs a rerouting using the given router.
const std::vector< SUMOVehicleParameter::Stop > & getPastStops() const
const MSRoute & getRoute() const
Returns the current route.
void createDevice(const std::string &deviceName)
create device of the given type
bool isStopped() const
Returns whether the vehicle is at a stop.
bool abortNextStop(int nextStopIndex=0)
deletes the next stop at the given index if it exists
bool replaceRouteEdges(ConstMSEdgeVector &edges, double cost, double savings, const std::string &info, bool onInit=false, bool check=false, bool removeStops=true, std::string *msgReturn=nullptr)
Replaces the current route by the given edges.
virtual double getSecureGap(const MSVehicle *const, const MSVehicle *const, const double speed, const double leaderSpeed, const double leaderMaxDecel) const
Returns the minimum gap to reserve if the leader is braking at maximum (>=0)
double stopSpeed(const MSVehicle *const veh, const double speed, double gap) const
Computes the vehicle's safe speed for approaching a non-moving obstacle (no dawdling)
double getEmergencyDecel() const
Get the vehicle type's maximal phisically possible deceleration [m/s^2].
virtual double followSpeed(const MSVehicle *const veh, double speed, double gap2pred, double predSpeed, double predMaxDecel, const MSVehicle *const pred=0) const =0
Computes the vehicle's follow speed (no dawdling)
double getApparentDecel() const
Get the vehicle type's apparent deceleration [m/s^2] (the one regarded by its followers.
double getMaxAccel() const
Get the vehicle type's maximum acceleration [m/s^2].
virtual double getImperfection() const
Get the driver's imperfection.
double getMaxDecel() const
Get the vehicle type's maximal comfortable deceleration [m/s^2].
virtual void setParameter(MSVehicle *veh, const std::string &key, const std::string &value) const
try to set the given parameter for this carFollowingModel
virtual double getHeadwayTime() const
Get the driver's desired headway [s].
A device which collects info on the vehicle trip (mainly on departure and arrival)
static const std::vector< MSDevice_Taxi * > & getFleet()
static MSDispatch * getDispatchAlgorithm()
A dispatch algorithm that services customers in reservation order and always sends the closest availa...
void interpretDispatch(MSDevice_Taxi *taxi, const std::vector< std::string > &reservationsIDs)
trigger taxi dispatch.
An algorithm that performs distpach for a taxi fleet.
A road/street connecting two junctions.
static const MSEdgeVector & getAllEdges()
Returns all edges with a numerical id.
static void parseEdgesList(const std::string &desc, ConstMSEdgeVector &into, const std::string &rid)
Parses the given string assuming it contains a list of edge ids divided by spaces.
const std::vector< MSLane * > * allowedLanes(const MSEdge &destination, SUMOVehicleClass vclass=SVC_IGNORING) const
Get the allowed lanes to reach the destination-edge.
bool isInternal() const
return whether this edge is an internal edge
static bool dictionary(const std::string &id, MSEdge *edge)
Inserts edge into the static dictionary Returns true if the key id isn't already in the dictionary....
double getVehicleMaxSpeed(const SUMOTrafficObject *const veh) const
Returns the maximum speed the vehicle may use on this edge.
const MSEdge * getNormalBefore() const
if this edge is an internal edge, return its first normal predecessor, otherwise the edge itself
bool retrieveExistingTravelTime(const MSEdge *const e, const double t, double &value) const
Returns a travel time for an edge and time if stored.
bool knowsTravelTime(const MSEdge *const e) const
Returns the information whether any travel time is known for the given edge.
void addTravelTime(const MSEdge *const e, double begin, double end, double value)
Adds a travel time information for an edge and a time span.
void removeEffort(const MSEdge *const e)
Removes the effort information for an edge.
bool knowsEffort(const MSEdge *const e) const
Returns the information whether any effort is known for the given edge.
void addEffort(const MSEdge *const e, double begin, double end, double value)
Adds an effort information for an edge and a time span.
bool retrieveExistingEffort(const MSEdge *const e, const double t, double &value) const
Returns an effort for an edge and time if stored.
void removeTravelTime(const MSEdge *const e)
Removes the travel time information for an edge.
static double gLateralResolution
void alreadyDeparted(SUMOVehicle *veh)
stops trying to emit the given vehicle (because it already departed)
void add(SUMOVehicle *veh)
Adds a single vehicle for departure.
Representation of a lane in the micro simulation.
const std::vector< MSLink * > & getLinkCont() const
returns the container with all links !!!
MSLane * getParallelLane(int offset, bool includeOpposite=true) const
Returns the lane with the given offset parallel to this one or 0 if it does not exist.
virtual MSVehicle * removeVehicle(MSVehicle *remVehicle, MSMoveReminder::Notification notification, bool notify=true)
static std::vector< MSLink * >::const_iterator succLinkSec(const SUMOVehicle &veh, int nRouteSuccs, const MSLane &succLinkSource, const std::vector< MSLane * > &conts)
void forceVehicleInsertion(MSVehicle *veh, double pos, MSMoveReminder::Notification notification, double posLat=0)
Inserts the given vehicle at the given position.
const MSEdge * getNextNormal() const
Returns the lane's follower if it is an internal lane, the edge of the lane otherwise.
void addLeaders(const MSVehicle *vehicle, double vehPos, MSLeaderDistanceInfo &result, bool oppositeDirection=false)
get leaders for ego on the given lane
double getLength() const
Returns the lane's length.
bool isLinkEnd(std::vector< MSLink * >::const_iterator &i) const
double getOppositePos(double pos) const
return the corresponding position on the opposite lane
static bool dictionary(const std::string &id, MSLane *lane)
Static (sic!) container methods {.
MSLeaderDistanceInfo getFollowersOnConsecutive(const MSVehicle *ego, double backOffset, bool allSublanes, double searchDist=-1, bool ignoreMinorLinks=false) const
return the sublane followers with the largest missing rear gap among all predecessor lanes (within di...
MSEdge & getEdge() const
Returns the lane's edge.
const PositionVector & getShape() const
Returns this lane's shape.
double getWidth() const
Returns the lane's width.
const Position geometryPositionAtOffset(double offset, double lateralOffset=0) const
saves leader/follower vehicles and their distances relative to an ego vehicle
void fixOppositeGaps(bool isFollower)
subtract vehicle length from all gaps if the leader vehicle is driving in the opposite direction
virtual int addLeader(const MSVehicle *veh, double gap, double latOffset=0, int sublane=-1)
Notification
Definition of a vehicle state.
@ NOTIFICATION_VAPORIZED_TRACI
The vehicle got removed via TraCI.
@ NOTIFICATION_ARRIVED
The vehicle arrived at its destination (is deleted)
@ NOTIFICATION_TELEPORT_ARRIVED
The vehicle was teleported out of the net.
@ NOTIFICATION_DEPARTED
The vehicle has departed (was inserted into the network)
@ NOTIFICATION_JUNCTION
The vehicle arrived at a junction.
@ NOTIFICATION_TELEPORT
The vehicle is being teleported.
static MSNet * getInstance()
Returns the pointer to the unique instance of MSNet (singleton).
MSVehicleControl & getVehicleControl()
Returns the vehicle control.
SUMOTime getCurrentTimeStep() const
Returns the current simulation step.
MSInsertionControl & getInsertionControl()
Returns the insertion control.
MSRouteIterator end() const
Returns the end of the list of edges to pass.
static bool dictionary(const std::string &id, const MSRoute *route)
Adds a route to the dictionary.
double getDistanceBetween(double fromPos, double toPos, const MSEdge *fromEdge, const MSEdge *toEdge, bool includeInternal=true, int routePosition=0) const
Compute the distance between 2 given edges on this route, including the length of internal lanes....
MSRouteIterator begin() const
Returns the begin of the list of edges to pass.
const ConstMSEdgeVector & getEdges() const
MSStoppingPlace * containerstop
(Optional) container stop if one is assigned to the stop
bool reached
Information whether the stop has been reached.
MSRouteIterator edge
The edge in the route to stop at.
MSParkingArea * parkingarea
(Optional) parkingArea if one is assigned to the stop
MSStoppingPlace * chargingStation
(Optional) charging station if one is assigned to the stop
SUMOTime duration
The stopping duration.
const SUMOVehicleParameter::Stop pars
The stop parameter.
MSStoppingPlace * busstop
(Optional) bus stop if one is assigned to the stop
void setLaneChangeMode(int value)
Sets lane changing behavior.
void deactivateGapController()
Deactivates the gap control.
void setSpeedMode(int speedMode)
Sets speed-constraining behaviors.
void setLaneTimeLine(const std::vector< std::pair< SUMOTime, int > > &laneTimeLine)
Sets a new lane timeline.
void setSublaneChange(double latDist)
Sets a new sublane-change request.
void setSignals(int signals)
void setSpeedTimeLine(const std::vector< std::pair< SUMOTime, double > > &speedTimeLine)
Sets a new velocity timeline.
void activateGapController(double originalTau, double newTimeHeadway, double newSpaceHeadway, double duration, double changeRate, double maxDecel, MSVehicle *refVeh=nullptr)
Activates the gap control with the given parameters,.
The class responsible for building and deletion of vehicles.
std::map< std::string, SUMOVehicle * >::const_iterator constVehIt
Definition of the internal vehicles map iterator.
void removePending()
Removes a vehicle after it has ended.
virtual void deleteVehicle(SUMOVehicle *v, bool discard=false)
Deletes the vehicle.
virtual bool addVehicle(const std::string &id, SUMOVehicle *v)
Tries to insert the vehicle into the internal vehicle container.
SUMOVehicle * getVehicle(const std::string &id) const
Returns the vehicle with the given id.
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 scheduleVehicleRemoval(SUMOVehicle *veh, bool checkDuplicate=false)
Removes a vehicle after it has ended.
constVehIt loadedVehBegin() const
Returns the begin of the internal vehicle map.
virtual SUMOVehicle * buildVehicle(SUMOVehicleParameter *defs, const MSRoute *route, MSVehicleType *type, const bool ignoreStopErrors, const bool fromRouteFile=true)
Builds a vehicle, increases the number of built vehicles.
constVehIt loadedVehEnd() const
Returns the end of the internal vehicle map.
Representation of a vehicle in the micro simulation.
void updateBestLanes(bool forceRebuild=false, const MSLane *startLane=0)
computes the best lanes to use in order to continue the route
bool isOnRoad() const
Returns the information whether the vehicle is on a road (is simulated)
SUMOTime getLastActionTime() const
Returns the time of the vehicle's last action point.
void setTentativeLaneAndPosition(MSLane *lane, double pos, double posLat=0)
set tentative lane and position during insertion to ensure that all cfmodels work (some of them requi...
void setPreviousSpeed(double prevspeed)
Sets the influenced previous speed.
MSAbstractLaneChangeModel & getLaneChangeModel()
MSLane * getMutableLane() const
Returns the lane the vehicle is on Non const version indicates that something volatile is going on.
Position getPosition(const double offset=0) const
Return current position (x/y, cartesian)
const std::vector< MSLane * > & getBestLanesContinuation() const
Returns the best sequence of lanes to continue the route starting at myLane.
void onRemovalFromNet(const MSMoveReminder::Notification reason)
Called when the vehicle is removed from the network.
bool resumeFromStopping()
double getBackPositionOnLane(const MSLane *lane) const
Get the vehicle's position relative to the given lane.
void resetActionOffset(const SUMOTime timeUntilNextAction=0)
Resets the action offset for the vehicle.
bool rerouteParkingArea(const std::string &parkingAreaID, std::string &errorMsg)
void switchOffSignal(int signal)
Switches the given signal off.
@ VEH_SIGNAL_NONE
Everything is switched off.
BaseInfluencer & getBaseInfluencer()
Returns the velocity/lane influencer.
Influencer & getInfluencer()
void setActionStepLength(double actionStepLength, bool resetActionOffset=true)
Sets the action steplength of the vehicle.
double getLateralPositionOnLane() const
Get the vehicle's lateral position on the lane.
double getSpeed() const
Returns the vehicle's current speed.
const std::vector< LaneQ > & getBestLanes() const
Returns the description of best lanes to use in order to continue the route.
double getPositionOnLane() const
Get the vehicle's position along the lane.
const MSLane * getLane() const
Returns the lane the vehicle is on.
const MSCFModel & getCarFollowModel() const
Returns the vehicle's car following model definition.
bool hasInfluencer() const
whether the vehicle is individually influenced (via TraCI or special parameters)
void switchOnSignal(int signal)
Switches the given signal on.
The car-following model and parameter.
void setHeight(const double &height)
Set a new value for this type's height.
void setMaxSpeedLat(const double &maxSpeedLat)
Set a new value for this type's maximum lateral speed.
double getMinGapLat() const
Get the minimum lateral gap that vehicles of this type maintain.
double getWidth() const
Get the width which vehicles of this class shall have when being drawn.
SUMOVehicleClass getVehicleClass() const
Get this vehicle type's vehicle class.
void setEmissionClass(SUMOEmissionClass eclass)
Set a new value for this type's emission class.
double getMaxSpeed() const
Get vehicle's maximum speed [m/s].
int getPersonCapacity() const
Get this vehicle type's person capacity.
void setMinGapLat(const double &minGapLat)
Set a new value for this type's minimum lataral gap.
double getMinGap() const
Get the free space in front of vehicles of this class.
void setApparentDecel(double apparentDecel)
Set a new value for this type's apparent deceleration.
double getHeight() const
Get the height which vehicles of this class shall have when being drawn.
void setMaxSpeed(const double &maxSpeed)
Set a new value for this type's maximum speed.
double getActionStepLengthSecs() const
Returns this type's default action step length in seconds.
void setLength(const double &length)
Set a new value for this type's length.
double getMaxSpeedLat() const
Get vehicle's maximum lateral speed [m/s].
void setVClass(SUMOVehicleClass vclass)
Set a new value for this type's vehicle class.
void setAccel(double accel)
Set a new value for this type's acceleration.
void setWidth(const double &width)
Set a new value for this type's width.
void setImperfection(double imperfection)
Set a new value for this type's imperfection.
const Distribution_Parameterized & getSpeedFactor() const
Returns this type's speed factor.
void setPreferredLateralAlignment(const LatAlignmentDefinition &latAlignment, double latAlignmentOffset=0.0)
Set vehicle's preferred lateral alignment.
void setTau(double tau)
Set a new value for this type's headway.
const std::string & getID() const
Returns the name of the vehicle type.
double getLength() const
Get vehicle's length [m].
const MSCFModel & getCarFollowModel() const
Returns the vehicle type's car following model definition (const version)
void setMinGap(const double &minGap)
Set a new value for this type's minimum gap.
void setShape(SUMOVehicleShape shape)
Set a new value for this type's shape.
static std::string getIDSecure(const T *obj, const std::string &fallBack="NULL")
get an identifier for Named-like object which may be Null
const std::string & getID() const
Returns the id.
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.
A point in 2D or 3D with translation and scaling methods.
double distanceTo2D(const Position &p2) const
returns the euclidean distance in the x-y-plane
void sub(double dx, double dy)
Substracts the given position from this one.
void setz(double z)
set position z
double z() const
Returns the z-position.
double angleTo2D(const Position &other) const
returns the angle in the plane of the vector pointing from here to the other position
double rotationAtOffset(double pos) const
Returns the rotation at the given length.
double distance2D(const Position &p, bool perpendicular=false) const
closest 2D-distance to point p (or -1 if perpendicular is true and the point is beyond this vector)
void move2side(double amount, double maxExtension=100)
move position vector to side using certain ammount
void set(unsigned char r, unsigned char g, unsigned char b, unsigned char a)
assigns new values
virtual bool compute(const E *from, const E *to, const V *const vehicle, SUMOTime msTime, std::vector< const E * > &into, bool silent=false)=0
Builds the route between the given edges using the minimum effort at the given time The definition of...
virtual double getSlope() const =0
Returns the slope of the road at object's position in degrees.
virtual double getSpeed() const =0
Returns the object's current speed.
virtual Position getPosition(const double offset=0) const =0
Return current position (x/y, cartesian)
virtual const MSLane * getLane() const =0
Returns the lane the object is currently at.
virtual double getPositionOnLane() const =0
Get the object's position along the lane.
static bool parseLatAlignment(const std::string &val, double &lao, LatAlignmentDefinition &lad)
Parses and validates a given latAlignment value.
Representation of a vehicle.
virtual int getRouteValidity(bool update=true, bool silent=false, std::string *msgReturn=nullptr)=0
computes validity attributes for the current route
virtual bool wasRemoteControlled(SUMOTime lookBack=DELTA_T) const =0
Returns the information whether the vehicle is fully controlled via TraCI.
virtual bool isOnRoad() const =0
Returns the information whether the vehicle is on a road (is simulated)
virtual bool isParking() const =0
Returns the information whether the vehicle is parked.
virtual double getAngle() const =0
Get the vehicle's angle.
Definition of vehicle stop (position and duration)
double startPos
The stopping position start.
bool triggered
whether an arriving person lets the vehicle continue
bool parking
whether the vehicle is removed from the net while stopping
bool containerTriggered
whether an arriving container lets the vehicle continue
Structure representing possible vehicle parameter.
int parametersSet
Information for the router which parameter were set, TraCI may modify this (when changing color)
int departLane
(optional) The lane the vehicle shall depart from (index in edge)
ArrivalSpeedDefinition arrivalSpeedProcedure
Information how the vehicle's end speed shall be chosen.
double departSpeed
(optional) The initial speed of the vehicle
std::vector< std::string > via
List of the via-edges the vehicle must visit.
static bool parseArrivalLane(const std::string &val, const std::string &element, const std::string &id, int &lane, ArrivalLaneDefinition &ald, std::string &error)
Validates a given arrivalLane value.
ArrivalLaneDefinition arrivalLaneProcedure
Information how the vehicle shall choose the lane to arrive on.
DepartLaneDefinition departLaneProcedure
Information how the vehicle shall choose the lane to depart from.
static bool parseDepartSpeed(const std::string &val, const std::string &element, const std::string &id, double &speed, DepartSpeedDefinition &dsd, std::string &error)
Validates a given departSpeed value.
static bool parseArrivalPos(const std::string &val, const std::string &element, const std::string &id, double &pos, ArrivalPosDefinition &apd, std::string &error)
Validates a given arrivalPos value.
int personNumber
The static number of persons in the vehicle when it departs (not including boarding persons)
static bool parseArrivalSpeed(const std::string &val, const std::string &element, const std::string &id, double &speed, ArrivalSpeedDefinition &asd, std::string &error)
Validates a given arrivalSpeed value.
double departPos
(optional) The position the vehicle shall depart from
DepartSpeedDefinition departSpeedProcedure
Information how the vehicle's initial speed shall be chosen.
RGBColor color
The vehicle's color, TraCI may change this.
double arrivalPos
(optional) The position the vehicle shall arrive on
static bool parseDepartLane(const std::string &val, const std::string &element, const std::string &id, int &lane, DepartLaneDefinition &dld, std::string &error)
Validates a given departLane value.
std::string id
The vehicle's id.
static bool parseDepart(const std::string &val, const std::string &element, const std::string &id, SUMOTime &depart, DepartDefinition &dd, std::string &error, const std::string &attr="departure")
Validates a given depart value.
bool wasSet(int what) const
Returns whether the given parameter was set.
ArrivalPosDefinition arrivalPosProcedure
Information how the vehicle shall choose the arrival position.
std::string toTaz
The vehicle's destination zone (district)
double arrivalSpeed
(optional) The final speed of the vehicle (not used yet)
DepartDefinition departProcedure
Information how the vehicle shall choose the depart time.
static bool parseDepartPos(const std::string &val, const std::string &element, const std::string &id, double &pos, DepartPosDefinition &dpd, std::string &error)
Validates a given departPos value.
std::string fromTaz
The vehicle's origin zone (district)
DepartPosDefinition departPosProcedure
Information how the vehicle shall choose the departure position.
std::string line
The vehicle's line (mainly for public transport)
static double toDouble(const std::string &sData)
converts a string into the double value described by it by calling the char-type converter
static bool startsWith(const std::string &str, const std::string prefix)
Checks whether a given string starts with the prefix.
static bool endsWith(const std::string &str, const std::string suffix)
Checks whether a given string ends with the suffix.
static bool toBool(const std::string &sData)
converts a string into the bool value described by it by calling the char-type converter
C++ TraCI client API implementation.
static MSEdge * getEdge(const std::string &edgeID)
static TraCIPosition makeTraCIPosition(const Position &position, const bool includeZ=false)
static bool moveToXYMap_matchingRoutePosition(const Position &pos, const std::string &origID, const ConstMSEdgeVector ¤tRoute, int routeIndex, SUMOVehicleClass vClass, bool setLateralPos, double &bestDistance, MSLane **lane, double &lanePos, int &routeOffset)
static TraCIPositionVector makeTraCIPositionVector(const PositionVector &positionVector)
helper functions
static MSBaseVehicle * getVehicle(const std::string &id)
static TraCIColor makeTraCIColor(const RGBColor &color)
static TraCINextStopData buildStopData(const SUMOVehicleParameter::Stop &stopPar)
static void setRemoteControlled(MSVehicle *v, Position xyPos, MSLane *l, double pos, double posLat, double angle, int edgeOffset, ConstMSEdgeVector route, SUMOTime t)
static const MSVehicleType & getVehicleType(const std::string &vehicleID)
static bool moveToXYMap(const Position &pos, double maxRouteDistance, bool mayLeaveNetwork, const std::string &origID, const double angle, double speed, const ConstMSEdgeVector ¤tRoute, const int routePosition, const MSLane *currentLane, double currentLanePos, bool onRoad, SUMOVehicleClass vClass, bool setLateralPos, double &bestDistance, MSLane **lane, double &lanePos, int &routeOffset, ConstMSEdgeVector &edges)
static std::pair< MSLane *, double > convertCartesianToRoadMap(const Position &pos, const SUMOVehicleClass vClass)
static SUMOVehicleParameter::Stop buildStopParameters(const std::string &edgeOrStoppingPlaceID, double pos, int laneIndex, double startPos, int flags, double duration, double until)
static Subscription * addSubscriptionFilter(SubscriptionFilterType filter)
virtual std::string readString()
virtual int readUnsignedByte()
virtual double readDouble()
#define CALL_MICRO_FUN(veh, fun, mesoResult)
TRACI_CONST double INVALID_DOUBLE_VALUE
TRACI_CONST int VAR_LASTACTIONTIME
TRACI_CONST int VAR_EDGES
TRACI_CONST int VAR_NOXEMISSION
TRACI_CONST int VAR_LANECHANGE_MODE
TRACI_CONST int MOVE_AUTOMATIC
TRACI_CONST int LAST_STEP_PERSON_ID_LIST
TRACI_CONST int TRACI_ID_LIST
TRACI_CONST int VAR_ROUTING_MODE
TRACI_CONST int VAR_WAITING_TIME
std::map< std::string, libsumo::SubscriptionResults > ContextSubscriptionResults
TRACI_CONST int VAR_ROAD_ID
TRACI_CONST int MOVE_NORMAL
TRACI_CONST int VAR_TIMELOSS
TRACI_CONST int VAR_SPEED_FACTOR
TRACI_CONST int VAR_STOP_ARRIVALDELAY
TRACI_CONST int VAR_SPEED_LAT
TRACI_CONST int VAR_ANGLE
TRACI_CONST int VAR_ALLOWED_SPEED
TRACI_CONST int VAR_LANE_INDEX
TRACI_CONST int VAR_PMXEMISSION
TRACI_CONST int VAR_SPEED_WITHOUT_TRACI
TRACI_CONST int MOVE_TELEPORT
TRACI_CONST int VAR_PERSON_NUMBER
TRACI_CONST int VAR_COEMISSION
TRACI_CONST int VAR_COLOR
TRACI_CONST int VAR_POSITION
TRACI_CONST int VAR_PERSON_CAPACITY
TRACI_CONST int VAR_LEADER
TRACI_CONST int VAR_CO2EMISSION
TRACI_CONST int REMOVE_TELEPORT
TRACI_CONST int VAR_TAXI_FLEET
TRACI_CONST int VAR_ROUTE_VALID
TRACI_CONST int VAR_SPEEDSETMODE
TRACI_CONST int VAR_FUELCONSUMPTION
std::map< std::string, libsumo::TraCIResults > SubscriptionResults
{object->{variable->value}}
TRACI_CONST int VAR_SLOPE
TRACI_CONST int VAR_HCEMISSION
TRACI_CONST int VAR_PARAMETER
TRACI_CONST int VAR_LANEPOSITION
TRACI_CONST int REMOVE_PARKING
TRACI_CONST int VAR_LANE_ID
TRACI_CONST int VAR_NOISEEMISSION
TRACI_CONST int VAR_POSITION3D
TRACI_CONST int VAR_SPEED
TRACI_CONST int VAR_SIGNALS
TRACI_CONST int VAR_PARAMETER_WITH_KEY
TRACI_CONST int VAR_ACCUMULATED_WAITING_TIME
TRACI_CONST int VAR_MINGAP_LAT
TRACI_CONST int INVALID_INT_VALUE
TRACI_CONST int VAR_ROUTE_INDEX
TRACI_CONST int VAR_ACCELERATION
TRACI_CONST int VAR_ROUTE_ID
TRACI_CONST int REMOVE_ARRIVED
@ SUBS_FILTER_LEAD_FOLLOW
@ SUBS_FILTER_UPSTREAM_DIST
@ SUBS_FILTER_DOWNSTREAM_DIST
@ SUBS_FILTER_LATERAL_DIST
@ SUBS_FILTER_FIELD_OF_VISION
TRACI_CONST int VAR_LANEPOSITION_LAT
TRACI_CONST int VAR_STOP_DELAY
TRACI_CONST int REMOVE_TELEPORT_ARRIVED
TRACI_CONST int REMOVE_VAPORIZED
TRACI_CONST int VAR_STOPSTATE
TRACI_CONST int VAR_FOLLOWER
std::map< int, std::shared_ptr< libsumo::TraCIResult > > TraCIResults
{variable->value}
TRACI_CONST int VAR_DISTANCE
TRACI_CONST int VAR_ELECTRICITYCONSUMPTION
A structure representing the best lanes for continuing the current route starting at 'lane'.