56 #define CALL_MICRO_FUN(veh, fun, mesoResult) ((dynamic_cast<MSVehicle*>(veh) == nullptr ? (mesoResult) : dynamic_cast<MSVehicle*>(veh)->fun))
57 #define CALL_MESO_FUN(veh, fun, microResult) ((dynamic_cast<MEVehicle*>(veh) == nullptr ? (microResult) : dynamic_cast<MEVehicle*>(veh)->fun))
65 #define DEBUG_COND (veh->isSelected())
87 Vehicle::isOnInit(
const std::string& vehID) {
89 return sumoVehicle ==
nullptr || sumoVehicle->
getLane() ==
nullptr;
93 std::vector<std::string>
94 Vehicle::getIDList() {
95 std::vector<std::string> ids;
98 if (isVisible((*i).second)) {
99 ids.push_back((*i).first);
106 Vehicle::getIDCount() {
107 return (
int)getIDList().size();
112 Vehicle::getSpeed(
const std::string& vehID) {
118 Vehicle::getLateralSpeed(
const std::string& vehID) {
125 Vehicle::getAcceleration(
const std::string& vehID) {
132 Vehicle::getSpeedWithoutTraCI(
const std::string& vehID) {
139 Vehicle::getPosition(
const std::string& vehID,
const bool includeZ) {
141 if (isVisible(veh)) {
144 return TraCIPosition();
149 Vehicle::getPosition3D(
const std::string& vehID) {
150 return getPosition(vehID,
true);
155 Vehicle::getAngle(
const std::string& vehID) {
162 Vehicle::getSlope(
const std::string& vehID) {
169 Vehicle::getRoadID(
const std::string& vehID) {
176 Vehicle::getLaneID(
const std::string& vehID) {
183 Vehicle::getLaneIndex(
const std::string& vehID) {
187 if (microVeh !=
nullptr) {
199 Vehicle::getSegmentID(
const std::string& vehID) {
205 Vehicle::getSegmentIndex(
const std::string& vehID) {
211 Vehicle::getTypeID(
const std::string& vehID) {
217 Vehicle::getRouteID(
const std::string& vehID) {
223 Vehicle::getDeparture(
const std::string& vehID) {
230 Vehicle::getDepartDelay(
const std::string& vehID) {
236 Vehicle::getRouteIndex(
const std::string& vehID) {
243 Vehicle::getColor(
const std::string& vehID) {
248 Vehicle::getLanePosition(
const std::string& vehID) {
254 Vehicle::getLateralLanePosition(
const std::string& vehID) {
260 Vehicle::getCO2Emission(
const std::string& vehID) {
266 Vehicle::getCOEmission(
const std::string& vehID) {
272 Vehicle::getHCEmission(
const std::string& vehID) {
278 Vehicle::getPMxEmission(
const std::string& vehID) {
284 Vehicle::getNOxEmission(
const std::string& vehID) {
290 Vehicle::getFuelConsumption(
const std::string& vehID) {
296 Vehicle::getNoiseEmission(
const std::string& vehID) {
302 Vehicle::getElectricityConsumption(
const std::string& vehID) {
308 Vehicle::getPersonNumber(
const std::string& vehID) {
313 Vehicle::getPersonCapacity(
const std::string& vehID) {
319 Vehicle::getBoardingDuration(
const std::string& vehID) {
324 std::vector<std::string>
325 Vehicle::getPersonIDList(
const std::string& vehID) {
329 std::pair<std::string, double>
330 Vehicle::getLeader(
const std::string& vehID,
double dist) {
333 std::pair<const MSVehicle* const, double> leaderInfo = veh->
getLeader(dist);
334 const std::string leaderID = leaderInfo.first !=
nullptr ? leaderInfo.first->getID() :
"";
335 double gap = leaderInfo.second;
336 if (leaderInfo.first !=
nullptr
337 && leaderInfo.first->getLane() !=
nullptr
338 && leaderInfo.first->getLane()->isInternal()
341 || (veh->
getLane()->
getLinkCont().front()->getIndex() != leaderInfo.first->getLane()->getLinkCont().front()->getIndex()))) {
344 gap =
MAX2(0.0, gap);
346 return std::make_pair(leaderID, gap);
348 return std::make_pair(
"", -1);
353 std::pair<std::string, double>
354 Vehicle::getFollower(
const std::string& vehID,
double dist) {
357 std::pair<const MSVehicle* const, double> leaderInfo = veh->
getFollower(dist);
358 return std::make_pair(
359 leaderInfo.first !=
nullptr ? leaderInfo.first->getID() :
"",
362 return std::make_pair(
"", -1);
367 std::vector<TraCIJunctionFoe>
368 Vehicle::getJunctionFoes(
const std::string& vehID,
double dist) {
369 std::vector<TraCIJunctionFoe> result;
372 if (veh ==
nullptr) {
378 const std::vector<const MSLane*> internalLanes;
382 curDist += lane->getLength();
383 if (lane->isInternal()) {
384 const MSLink* exitLink = lane->getLinkCont().front();
386 const std::vector<MSLink::ConflictInfo>& conflicts = exitLink->
getConflicts();
394 const MSLink* foeExitLink = foeLane->getLinkCont().front();
395 const double distToCrossing = curDist - distBehindCrossing;
400 jf.foeId = foe->
getID();
401 jf.egoDist = distToCrossing;
407 jf.foeDist = item.second.dist - foeDistBehindCrossing - prevFoeDist;
410 jf.egoLane = lane->getID();
411 jf.foeLane = foeLane->getID();
414 result.push_back(jf);
426 Vehicle::getWaitingTime(
const std::string& vehID) {
432 Vehicle::getAccumulatedWaitingTime(
const std::string& vehID) {
439 Vehicle::getAdaptedTraveltime(
const std::string& vehID,
double time,
const std::string& edgeID) {
448 Vehicle::getEffort(
const std::string& vehID,
double time,
const std::string& edgeID) {
457 Vehicle::isRouteValid(
const std::string& vehID) {
463 std::vector<std::string>
464 Vehicle::getRoute(
const std::string& vehID) {
465 std::vector<std::string> result;
469 result.push_back((*i)->getID());
476 Vehicle::getSignals(
const std::string& vehID) {
482 std::vector<TraCIBestLanesData>
483 Vehicle::getBestLanes(
const std::string& vehID) {
484 std::vector<TraCIBestLanesData> result;
486 if (veh !=
nullptr && veh->
isOnRoad()) {
488 TraCIBestLanesData bld;
489 bld.laneID = lq.lane->
getID();
490 bld.length = lq.length;
491 bld.occupation = lq.nextOccupation;
492 bld.bestLaneOffset = lq.bestLaneOffset;
493 bld.allowsContinuation = lq.allowsContinuation;
494 for (
const MSLane*
const lane : lq.bestContinuations) {
495 if (lane !=
nullptr) {
496 bld.continuationLanes.push_back(lane->
getID());
499 result.emplace_back(bld);
506 std::vector<TraCINextTLSData>
507 Vehicle::getNextTLS(
const std::string& vehID) {
508 std::vector<TraCINextTLSData> result;
511 if (veh !=
nullptr) {
518 std::vector<MSLink*>::const_iterator linkIt =
MSLane::succLinkSec(*veh, view, *lane, bestLaneConts);
521 if ((*linkIt)->isTLSControlled()) {
522 TraCINextTLSData ntd;
523 ntd.id = (*linkIt)->getTLLogic()->getID();
524 ntd.tlIndex = (*linkIt)->getTLIndex();
526 ntd.state = (char)(*linkIt)->getState();
527 result.push_back(ntd);
530 lane = (*linkIt)->getViaLaneOrLane();
541 for (
int i = 0; i < remainingEdges; i++) {
545 if (allowed !=
nullptr && allowed->size() != 0) {
546 for (
const MSLink*
const link : allowed->front()->getLinkCont()) {
547 if (&link->getLane()->getEdge() == next) {
548 if (link->isTLSControlled()) {
549 TraCINextTLSData ntd;
550 ntd.id = link->getTLLogic()->getID();
551 ntd.tlIndex = link->getTLIndex();
553 ntd.state = (char)link->getState();
554 result.push_back(ntd);
556 seen += next->
getLength() + link->getInternalLengthsAfter();
572 std::vector<TraCINextStopData>
573 Vehicle::getNextStops(
const std::string& vehID) {
574 return getStops(vehID, 0);
577 std::vector<libsumo::TraCIConnection>
578 Vehicle::getNextLinks(
const std::string& vehID) {
579 std::vector<libsumo::TraCIConnection> result;
585 if (veh !=
nullptr) {
590 std::vector<MSLink*>::const_iterator linkIt =
MSLane::succLinkSec(*veh, view, *lane, bestLaneConts);
593 const MSLink* link = (*linkIt);
594 const std::string approachedLane = link->
getLane() !=
nullptr ? link->
getLane()->
getID() :
"";
604 result.push_back(TraCIConnection(approachedLane, hasPrio, isOpen, hasFoe, approachedInternal, state, direction, length));
606 lane = (*linkIt)->getViaLaneOrLane();
614 for (
int i = 0; i < remainingEdges; i++) {
618 if (allowed !=
nullptr && allowed->size() != 0) {
619 for (
const MSLink*
const link : allowed->front()->getLinkCont()) {
620 if (&link->getLane()->getEdge() == next) {
621 const std::string approachedLane = link->getLane() !=
nullptr ? link->getLane()->getID() :
"";
622 const bool hasPrio = link->havePriority();
623 const double speed =
MIN2(lane->
getSpeedLimit(), link->getLane()->getSpeedLimit());
627 const std::string approachedInternal = link->getViaLane() !=
nullptr ? link->getViaLane()->getID() :
"";
630 const double length = link->getLength();
631 result.push_back(TraCIConnection(approachedLane, hasPrio, isOpen, hasFoe, approachedInternal, state, direction, length));
645 std::vector<TraCINextStopData>
646 Vehicle::getStops(
const std::string& vehID,
int limit) {
647 std::vector<TraCINextStopData> result;
651 const std::vector<SUMOVehicleParameter::Stop>& pastStops = vehicle->
getPastStops();
652 const int n = (int)pastStops.size();
653 for (
int i =
MAX2(0, n + limit); i < n; i++) {
658 if (!stop.pars.collision) {
661 result.push_back(nsd);
662 if (limit > 0 && (
int)result.size() >= limit) {
673 Vehicle::getStopState(
const std::string& vehID) {
676 if (veh ==
nullptr) {
690 Vehicle::getDistance(
const std::string& vehID) {
701 Vehicle::getDrivingDistance(
const std::string& vehID,
const std::string& edgeID,
double pos,
int laneIndex) {
708 if (distance == std::numeric_limits<double>::max()) {
719 Vehicle::getDrivingDistance2D(
const std::string& vehID,
double x,
double y) {
721 if (veh ==
nullptr) {
730 if (distance == std::numeric_limits<double>::max()) {
741 Vehicle::getAllowedSpeed(
const std::string& vehID) {
748 Vehicle::getSpeedFactor(
const std::string& vehID) {
754 Vehicle::getSpeedMode(
const std::string& vehID) {
761 Vehicle::getLaneChangeMode(
const std::string& vehID) {
768 Vehicle::getRoutingMode(
const std::string& vehID) {
774 Vehicle::getLine(
const std::string& vehID) {
779 std::vector<std::string>
780 Vehicle::getVia(
const std::string& vehID) {
786 Vehicle::getLaneChangeState(
const std::string& vehID,
int direction) {
789 return veh->
isOnRoad() ?
CALL_MICRO_FUN(veh, getLaneChangeModel().getSavedState(direction), undefined) : undefined;
794 Vehicle::getParameter(
const std::string& vehID,
const std::string& key) {
799 throw TraCIException(error);
808 std::vector<std::pair<std::string, double> >
809 Vehicle::getNeighbors(
const std::string& vehID,
const int mode) {
810 int dir = (1 & mode) != 0 ? -1 : 1;
811 bool queryLeaders = (2 & mode) != 0;
812 bool blockersOnly = (4 & mode) != 0;
815 std::vector<std::pair<std::string, double> > result;
816 if (veh ==
nullptr) {
819 #ifdef DEBUG_NEIGHBORS
821 std::cout <<
"getNeighbors() for veh '" << vehID <<
"': dir=" << dir
822 <<
", queryLeaders=" << queryLeaders
823 <<
", blockersOnly=" << blockersOnly << std::endl;
832 if (targetLane ==
nullptr) {
857 for (
int i = 0; i < neighbors.
numSublanes(); i++) {
859 if (n.first !=
nullptr) {
868 if (n.second < secureGap) {
869 blockers.
addLeader(n.first, n.second, 0, i);
873 neighbors = blockers;
877 for (
int i = 0; i < neighbors.
numSublanes(); i++) {
879 if (n.first !=
nullptr &&
881 (result.size() == 0 || result.back().first != n.first->getID())) {
882 result.push_back(std::make_pair(n.first->getID(), n.second));
891 Vehicle::getFollowSpeed(
const std::string& vehID,
double speed,
double gap,
double leaderSpeed,
double leaderMaxDecel,
const std::string& leaderID) {
894 if (veh ==
nullptr) {
895 WRITE_ERROR(
"getFollowSpeed not applicable for meso");
904 Vehicle::getSecureGap(
const std::string& vehID,
double speed,
double leaderSpeed,
double leaderMaxDecel,
const std::string& leaderID) {
907 if (veh ==
nullptr) {
908 WRITE_ERROR(
"getSecureGap not applicable for meso");
917 Vehicle::getStopSpeed(
const std::string& vehID,
const double speed,
double gap) {
920 if (veh ==
nullptr) {
921 WRITE_ERROR(
"getStopSpeed not applicable for meso");
928 Vehicle::getStopDelay(
const std::string& vehID) {
934 Vehicle::getImpatience(
const std::string& vehID) {
940 Vehicle::getStopArrivalDelay(
const std::string& vehID) {
950 Vehicle::getTimeLoss(
const std::string& vehID) {
954 std::vector<std::string>
955 Vehicle::getTaxiFleet(
int taxiState) {
956 std::vector<std::string> result;
958 if (taxi->getHolder().hasDeparted()) {
960 || (taxiState == 0 && taxi->getState() == 0)
961 || (taxiState != 0 && (taxi->getState() & taxiState) == taxiState)) {
962 result.push_back(taxi->getHolder().getID());
969 std::vector<std::string>
970 Vehicle::getLoadedIDList() {
971 std::vector<std::string> ids;
974 ids.push_back(i->first);
979 std::vector<std::string>
980 Vehicle::getTeleportingIDList() {
981 std::vector<std::string> ids;
986 ids.push_back(veh->
getID());
993 Vehicle::getEmissionClass(
const std::string& vehID) {
998 Vehicle::getShapeClass(
const std::string& vehID) {
1004 Vehicle::getLength(
const std::string& vehID) {
1010 Vehicle::getAccel(
const std::string& vehID) {
1016 Vehicle::getDecel(
const std::string& vehID) {
1021 double Vehicle::getEmergencyDecel(
const std::string& vehID) {
1026 double Vehicle::getApparentDecel(
const std::string& vehID) {
1031 double Vehicle::getActionStepLength(
const std::string& vehID) {
1036 double Vehicle::getLastActionTime(
const std::string& vehID) {
1039 if (microVeh !=
nullptr) {
1049 Vehicle::getTau(
const std::string& vehID) {
1055 Vehicle::getImperfection(
const std::string& vehID) {
1061 Vehicle::getSpeedDeviation(
const std::string& vehID) {
1067 Vehicle::getVehicleClass(
const std::string& vehID) {
1073 Vehicle::getMinGap(
const std::string& vehID) {
1079 Vehicle::getMinGapLat(
const std::string& vehID) {
1082 }
catch (
const TraCIException&) {
1090 Vehicle::getMaxSpeed(
const std::string& vehID) {
1096 Vehicle::getMaxSpeedLat(
const std::string& vehID) {
1102 Vehicle::getLateralAlignment(
const std::string& vehID) {
1108 Vehicle::getWidth(
const std::string& vehID) {
1114 Vehicle::getHeight(
const std::string& vehID) {
1120 Vehicle::getMass(
const std::string& vehID) {
1126 Vehicle::setStop(
const std::string& vehID,
1127 const std::string& edgeID,
1136 pos, laneIndex, startPos, flags, duration, until);
1139 throw TraCIException(error);
1145 Vehicle::replaceStop(
const std::string& vehID,
1147 const std::string& edgeID,
1160 if (teleport != 0) {
1161 if (!vehicle->
rerouteBetweenStops(nextStopIndex,
"traci:replaceStop", (teleport & 1), error)) {
1162 throw TraCIException(
"Stop replacement failed for vehicle '" + vehID +
"' (" + error +
").");
1166 if (msVeh->
getLane() !=
nullptr) {
1171 throw TraCIException(
"Stop replacement failed for vehicle '" + vehID +
"' (invalid nextStopIndex).");
1175 pos, laneIndex, startPos, flags, duration, until);
1177 if (!vehicle->
replaceStop(nextStopIndex, stopPars,
"traci:replaceStop", teleport != 0, error)) {
1178 throw TraCIException(
"Stop replacement failed for vehicle '" + vehID +
"' (" + error +
").");
1185 Vehicle::insertStop(
const std::string& vehID,
1187 const std::string& edgeID,
1197 pos, laneIndex, startPos, flags, duration, until);
1200 if (!vehicle->
insertStop(nextStopIndex, stopPars,
"traci:insertStop", teleport != 0, error)) {
1201 throw TraCIException(
"Stop insertion failed for vehicle '" + vehID +
"' (" + error +
").");
1207 Vehicle::getStopParameter(
const std::string& vehID,
int nextStopIndex,
const std::string& param,
bool customParam) {
1210 if (nextStopIndex >= (
int)vehicle->
getStops().size() || (nextStopIndex < 0 && -nextStopIndex > (
int)vehicle->
getPastStops().size())) {
1284 throw TraCIException(
"Could not get stop parameter for vehicle '" + vehID +
"' (" + e.what() +
")");
1291 Vehicle::setStopParameter(
const std::string& vehID,
int nextStopIndex,
1292 const std::string& param,
const std::string& value,
1313 std::string edgeOrStopID = value;
1316 edgeOrStopID = pars.
edge;
1355 throw TraCIException(
"Changing stop index is not supported");
1360 if (pars.
speed > 0 && value !=
"") {
1361 throw ProcessError(
TLF(
"Waypoint (speed = %) at index % does not support triggers", pars.
speed, nextStopIndex));
1399 throw ProcessError(
TLF(
"Triggered stop at index % cannot be changed into a waypoint by setting speed to %", nextStopIndex, speed));
1419 throw TraCIException(
"Could not set stop parameter for vehicle '" + vehID +
"' (" + e.what() +
")");
1425 Vehicle::rerouteParkingArea(
const std::string& vehID,
const std::string& parkingAreaID) {
1428 if (veh ==
nullptr) {
1429 WRITE_WARNING(
"rerouteParkingArea not yet implemented for meso");
1435 throw TraCIException(error);
1440 Vehicle::resume(
const std::string& vehID) {
1443 if (veh ==
nullptr) {
1448 throw TraCIException(
"Failed to resume vehicle '" + veh->
getID() +
"', it has no stops.");
1452 std::ostringstream strs;
1453 strs <<
"reached: " << sto.
reached;
1454 strs <<
", duration:" << sto.
duration;
1455 strs <<
", edge:" << (*sto.
edge)->getID();
1457 std::string posStr = strs.str();
1458 throw TraCIException(
"Failed to resume from stopping for vehicle '" + veh->
getID() +
"', " + posStr);
1464 Vehicle::changeTarget(
const std::string& vehID,
const std::string& edgeID) {
1467 const bool onInit = isOnInit(vehID);
1468 if (destEdge ==
nullptr) {
1469 throw TraCIException(
"Destination edge '" + edgeID +
"' is not known.");
1474 veh->
getRouterTT(), onInit,
false,
false, destEdge);
1476 throw TraCIException(
"ChangeTarget failed for vehicle '" + veh->
getID() +
"', destination edge '" + edgeID +
"' unreachable.");
1479 throw TraCIException(e.what());
1485 Vehicle::changeLane(
const std::string& vehID,
int laneIndex,
double duration) {
1489 throw TraCIException(
"Duration parameter exceeds the time value range.");
1493 if (veh ==
nullptr) {
1494 WRITE_ERROR(
"changeLane not applicable for meso");
1498 std::vector<std::pair<SUMOTime, int> > laneTimeLine;
1499 laneTimeLine.push_back(std::make_pair(
MSNet::getInstance()->getCurrentTimeStep(), laneIndex));
1505 Vehicle::changeLaneRelative(
const std::string& vehID,
int indexOffset,
double duration) {
1509 throw TraCIException(
"Duration parameter exceeds the time value range.");
1513 if (veh ==
nullptr) {
1514 WRITE_ERROR(
"changeLaneRelative not applicable for meso");
1518 std::vector<std::pair<SUMOTime, int> > laneTimeLine;
1520 if (laneIndex < 0 && !veh->getLaneChangeModel().isOpposite()) {
1522 WRITE_WARNINGF(
TL(
"Ignoring changeLaneRelative for vehicle '%' that isn't on the road"), vehID);
1527 laneTimeLine.push_back(std::make_pair(
MSNet::getInstance()->getCurrentTimeStep(), laneIndex));
1535 Vehicle::changeSublane(
const std::string& vehID,
double latDist) {
1538 if (veh ==
nullptr) {
1539 WRITE_ERROR(
"changeSublane not applicable for meso");
1548 Vehicle::add(
const std::string& vehID,
1549 const std::string& routeID,
1550 const std::string& typeID,
1551 const std::string& depart,
1552 const std::string& departLane,
1553 const std::string& departPos,
1554 const std::string& departSpeed,
1555 const std::string& arrivalLane,
1556 const std::string& arrivalPos,
1557 const std::string& arrivalSpeed,
1558 const std::string& fromTaz,
1559 const std::string& toTaz,
1560 const std::string& line,
1564 if (veh !=
nullptr) {
1565 throw TraCIException(
"The vehicle '" + vehID +
"' to add already exists.");
1569 vehicleParams.
id = vehID;
1572 throw TraCIException(
"Invalid type '" + typeID +
"' for vehicle '" + vehID +
"'.");
1574 if (typeID !=
"DEFAULT_VEHTYPE") {
1575 vehicleParams.
vtypeid = typeID;
1579 WRITE_WARNINGF(
TL(
"Internal routes receive an ID starting with '!' and must not be referenced in other vehicle or flow definitions. Please remove all references to route '%' in case it is internal."), routeID);
1583 if (routeID ==
"") {
1589 if (route ==
nullptr) {
1592 std::vector<std::string> edges;
1593 edges.push_back(e->getID());
1594 libsumo::Route::add(dummyRouteID, edges);
1604 throw TraCIException(
"Invalid route '" + routeID +
"' for vehicle '" + vehID +
"'.");
1608 if (route->getEdges().size() == 2) {
1609 const MSEdgeVector& succ = route->getEdges().front()->getSuccessors();
1610 if (std::find(succ.begin(), succ.end(), route->getEdges().back()) == succ.end()) {
1614 if (fromTaz !=
"" || toTaz !=
"") {
1619 throw TraCIException(error);
1623 WRITE_WARNINGF(
TL(
"Departure time for vehicle '%' is in the past; using current time instead."), vehID);
1628 throw TraCIException(error);
1631 throw TraCIException(error);
1634 throw TraCIException(error);
1637 throw TraCIException(error);
1640 throw TraCIException(error);
1643 throw TraCIException(error);
1646 if (departLane !=
"first") {
1649 if (departPos !=
"base") {
1652 if (departSpeed !=
"0") {
1655 if (arrivalLane !=
"current") {
1658 if (arrivalPos !=
"max") {
1661 if (arrivalSpeed !=
"current") {
1664 if (fromTaz !=
"") {
1673 if (personNumber != 0) {
1677 vehicleParams.
fromTaz = fromTaz;
1678 vehicleParams.
toTaz = toTaz;
1679 vehicleParams.
line = line;
1687 if (fromTaz ==
"" && !route->getEdges().front()->validateDepartSpeed(*vehicle)) {
1689 throw TraCIException(
"Departure speed for vehicle '" + vehID +
"' is too high for the departure edge '" + route->getEdges().front()->getID() +
"'.");
1694 throw TraCIException(
"Vehicle '" + vehID +
"' has no valid route (" + msg +
"). ");
1701 if (vehicle !=
nullptr) {
1704 throw TraCIException(e.what());
1710 Vehicle::moveToXY(
const std::string& vehID,
const std::string& edgeID,
const int laneIndex,
1711 const double x,
const double y,
double angle,
const int keepRoute,
double matchThreshold) {
1714 if (veh ==
nullptr) {
1718 const bool doKeepRoute = (keepRoute & 1) != 0 && veh->
getID() !=
"VTD_EGO";
1719 const bool mayLeaveNetwork = (keepRoute & 2) != 0;
1720 const bool ignorePermissions = (keepRoute & 4) != 0;
1724 const std::string origID = edgeID +
"_" +
toString(laneIndex);
1728 const double origAngle = angle;
1733 while (angle >= 360.) {
1736 while (angle < 0.) {
1744 std::cout <<
" wantedPos=" << pos <<
" origID=" << origID <<
" laneIndex=" << laneIndex <<
" origAngle=" << origAngle <<
" angle=" << angle <<
" keepRoute=" << keepRoute << std::endl;
1750 double lanePosLat = 0;
1751 double bestDistance = std::numeric_limits<double>::max();
1752 int routeOffset = 0;
1754 double maxRouteDistance = matchThreshold;
1763 vClass, setLateralPos,
1764 bestDistance, &lane, lanePos, routeOffset);
1770 vClass, setLateralPos,
1771 bestDistance, &lane, lanePos, routeOffset, edges);
1773 if ((found && bestDistance <= maxRouteDistance) || mayLeaveNetwork) {
1776 if (found && setLateralPos) {
1779 lanePosLat = perpDist;
1780 if (!mayLeaveNetwork) {
1792 lanePosLat = -lanePosLat;
1801 assert((found && lane != 0) || (!found && lane == 0));
1802 assert(!std::isnan(lanePos));
1804 if (lane !=
nullptr) {
1813 std::cout <<
SIMTIME <<
" veh=" << vehID +
" moveToXYResult lane='" <<
Named::getIDSecure(lane) <<
"' lanePos=" << lanePos <<
" lanePosLat=" << lanePosLat <<
"\n";
1820 if (lane ==
nullptr) {
1821 throw TraCIException(
"Could not map vehicle '" + vehID +
"', no road found within " +
toString(maxRouteDistance) +
"m.");
1823 throw TraCIException(
"Could not map vehicle '" + vehID +
"', distance to road is " +
toString(bestDistance) +
".");
1829 Vehicle::slowDown(
const std::string& vehID,
double speed,
double duration) {
1833 throw TraCIException(
"Duration parameter exceeds the time value range.");
1837 if (veh ==
nullptr) {
1842 std::vector<std::pair<SUMOTime, double> > speedTimeLine;
1849 Vehicle::openGap(
const std::string& vehID,
double newTimeHeadway,
double newSpaceHeadway,
double duration,
double changeRate,
double maxDecel,
const std::string& referenceVehID) {
1853 throw TraCIException(
"Duration parameter exceeds the time value range.");
1857 if (veh ==
nullptr) {
1863 if (referenceVehID !=
"") {
1867 if (newTimeHeadway == -1) {
1868 newTimeHeadway = originalTau;
1870 if (originalTau > newTimeHeadway) {
1871 WRITE_WARNING(
"Ignoring openGap(). New time headway must not be smaller than the original.");
1878 Vehicle::deactivateGapControl(
const std::string& vehID) {
1881 if (veh ==
nullptr) {
1882 WRITE_ERROR(
"deactivateGapControl not applicable for meso");
1892 Vehicle::requestToC(
const std::string& vehID,
double leadTime) {
1893 setParameter(vehID,
"device.toc.requestToC",
toString(leadTime));
1897 Vehicle::setSpeed(
const std::string& vehID,
double speed) {
1900 if (veh ==
nullptr) {
1905 std::vector<std::pair<SUMOTime, double> > speedTimeLine;
1907 speedTimeLine.push_back(std::make_pair(
MSNet::getInstance()->getCurrentTimeStep(), speed));
1914 Vehicle::setAcceleration(
const std::string& vehID,
double acceleration,
double duration) {
1918 throw TraCIException(
"Duration parameter exceeds the time value range.");
1922 if (veh ==
nullptr) {
1923 WRITE_WARNING(
"setAcceleration not yet implemented for meso");
1927 double targetSpeed = std::max(veh->
getSpeed() + acceleration * duration, 0.0);
1928 std::vector<std::pair<SUMOTime, double>> speedTimeLine;
1935 Vehicle::setPreviousSpeed(
const std::string& vehID,
double prevSpeed,
double prevAcceleration) {
1938 if (veh ==
nullptr) {
1939 WRITE_WARNING(
"setPreviousSpeed not yet implemented for meso");
1943 prevAcceleration = std::numeric_limits<double>::min();
1949 Vehicle::setSpeedMode(
const std::string& vehID,
int speedMode) {
1952 if (veh ==
nullptr) {
1961 Vehicle::setLaneChangeMode(
const std::string& vehID,
int laneChangeMode) {
1964 if (veh ==
nullptr) {
1965 WRITE_ERROR(
"setLaneChangeMode not applicable for meso");
1973 Vehicle::setRoutingMode(
const std::string& vehID,
int routingMode) {
1978 Vehicle::setType(
const std::string& vehID,
const std::string& typeID) {
1980 if (vehicleType ==
nullptr) {
1981 throw TraCIException(
"Vehicle type '" + typeID +
"' is not known");
1986 if (microVeh !=
nullptr && microVeh->
isOnRoad()) {
1993 Vehicle::setRouteID(
const std::string& vehID,
const std::string& routeID) {
1997 throw TraCIException(
"The route '" + routeID +
"' is not known.");
2000 WRITE_WARNINGF(
TL(
"Internal routes receive an ID starting with '!' and must not be referenced in other vehicle or flow definitions. Please remove all references to route '%' in case it is internal."), routeID);
2006 throw TraCIException(
"Route replacement failed for " + veh->
getID());
2010 std::string errorMsg;
2011 if (!veh->
replaceRoute(r,
"traci:setRouteID", veh->
getLane() ==
nullptr, 0,
true,
true, &errorMsg)) {
2012 throw TraCIException(
"Route replacement failed for vehicle '" + veh->
getID() +
"' (" + errorMsg +
").");
2017 Vehicle::setRoute(
const std::string& vehID,
const std::string& edgeID) {
2018 setRoute(vehID, std::vector<std::string>({edgeID}));
2023 Vehicle::setRoute(
const std::string& vehID,
const std::vector<std::string>& edgeIDs) {
2026 const bool onInit = veh->
getLane() ==
nullptr;
2029 if (edges.size() > 0 && edges.front()->isInternal()) {
2030 if (edges.size() == 1) {
2032 edges.push_back(edges.back()->getLanes()[0]->getNextNormal());
2036 edges.erase(edges.begin());
2041 throw TraCIException(
"Invalid edge list for vehicle '" + veh->
getID() +
"' (" + e.what() +
")");
2043 std::string errorMsg;
2044 if (!veh->
replaceRouteEdges(edges, -1, 0,
"traci:setRoute", onInit,
true,
true, &errorMsg)) {
2045 throw TraCIException(
"Route replacement failed for vehicle '" + veh->
getID() +
"' (" + errorMsg +
").");
2051 Vehicle::setLateralLanePosition(
const std::string& vehID,
double posLat) {
2054 if (veh !=
nullptr) {
2057 WRITE_ERROR(
"setLateralLanePosition not applicable for meso");
2063 Vehicle::updateBestLanes(
const std::string& vehID) {
2066 if (veh ==
nullptr) {
2067 WRITE_ERROR(
"updateBestLanes not applicable for meso");
2077 Vehicle::setAdaptedTraveltime(
const std::string& vehID,
const std::string& edgeID,
2078 double time,
double begSeconds,
double endSeconds) {
2081 if (edge ==
nullptr) {
2082 throw TraCIException(
"Edge '" + edgeID +
"' is not known.");
2086 if (begSeconds == 0 && endSeconds == std::numeric_limits<double>::max()) {
2103 Vehicle::setEffort(
const std::string& vehID,
const std::string& edgeID,
2104 double effort,
double begSeconds,
double endSeconds) {
2107 if (edge ==
nullptr) {
2108 throw TraCIException(
"Edge '" + edgeID +
"' is not known.");
2112 if (begSeconds == 0 && endSeconds == std::numeric_limits<double>::max()) {
2129 Vehicle::rerouteTraveltime(
const std::string& vehID,
const bool currentTravelTimes) {
2144 Vehicle::rerouteEffort(
const std::string& vehID) {
2152 Vehicle::setSignals(
const std::string& vehID,
int signals) {
2155 if (veh ==
nullptr) {
2156 WRITE_ERROR(
"setSignals not applicable for meso");
2171 Vehicle::moveTo(
const std::string& vehID,
const std::string& laneID,
double pos,
int reason) {
2174 if (veh ==
nullptr) {
2181 throw TraCIException(
"Unknown lane '" + laneID +
"'.");
2205 throw TraCIException(
"Lane '" + laneID +
"' is not on the route of vehicle '" + vehID +
"'.");
2209 if (veh->
getLane() !=
nullptr) {
2217 const int newRouteIndex = (int)(it - veh->
getRoute().
begin());
2218 if (oldRouteIndex > newRouteIndex) {
2242 throw TraCIException(
"Invalid moveTo reason '" +
toString(reason) +
"' for vehicle '" + vehID +
"'.");
2252 Vehicle::setActionStepLength(
const std::string& vehID,
double actionStepLength,
bool resetActionOffset) {
2253 if (actionStepLength < 0.0) {
2254 WRITE_ERROR(
"Invalid action step length (<0). Ignoring command setActionStepLength().");
2259 if (veh ==
nullptr) {
2260 WRITE_ERROR(
"setActionStepLength not applicable for meso");
2264 if (actionStepLength == 0.) {
2273 Vehicle::setBoardingDuration(
const std::string& vehID,
double boardingDuration) {
2277 throw TraCIException(
"BoardingDuration parameter exceeds the time value range.");
2284 Vehicle::setImpatience(
const std::string& vehID,
double impatience) {
2292 Vehicle::remove(
const std::string& vehID,
char reason) {
2316 throw TraCIException(
"Unknown removal status.");
2321 if (microVeh !=
nullptr) {
2322 if (veh->
getLane() !=
nullptr) {
2336 Vehicle::setColor(
const std::string& vehID,
const TraCIColor& col) {
2338 p.
color.
set((
unsigned char)col.r, (
unsigned char)col.g, (
unsigned char)col.b, (
unsigned char)col.a);
2344 Vehicle::setSpeedFactor(
const std::string& vehID,
double factor) {
2350 Vehicle::setLine(
const std::string& vehID,
const std::string& line) {
2356 Vehicle::setVia(
const std::string& vehID,
const std::vector<std::string>& edgeList) {
2363 throw TraCIException(e.what());
2370 Vehicle::setLength(
const std::string& vehID,
double length) {
2376 Vehicle::setMaxSpeed(
const std::string& vehID,
double speed) {
2382 Vehicle::setVehicleClass(
const std::string& vehID,
const std::string& clazz) {
2386 if (microVeh !=
nullptr && microVeh->
isOnRoad()) {
2393 Vehicle::setShapeClass(
const std::string& vehID,
const std::string& clazz) {
2399 Vehicle::setEmissionClass(
const std::string& vehID,
const std::string& clazz) {
2405 Vehicle::setWidth(
const std::string& vehID,
double width) {
2411 Vehicle::setHeight(
const std::string& vehID,
double height) {
2417 Vehicle::setMass(
const std::string& vehID,
double mass) {
2423 Vehicle::setMinGap(
const std::string& vehID,
double minGap) {
2427 if (microVeh !=
nullptr && microVeh->
isOnRoad()) {
2434 Vehicle::setAccel(
const std::string& vehID,
double accel) {
2440 Vehicle::setDecel(
const std::string& vehID,
double decel) {
2446 Vehicle::setEmergencyDecel(
const std::string& vehID,
double decel) {
2447 VehicleType::setEmergencyDecel(
Helper::getVehicle(vehID)->getSingularType().getID(), decel);
2452 Vehicle::setApparentDecel(
const std::string& vehID,
double decel) {
2458 Vehicle::setImperfection(
const std::string& vehID,
double imperfection) {
2464 Vehicle::setTau(
const std::string& vehID,
double tau) {
2470 Vehicle::setMinGapLat(
const std::string& vehID,
double minGapLat) {
2472 setParameter(vehID,
"laneChangeModel.minGapLat",
toString(minGapLat));
2473 }
catch (TraCIException&) {
2481 Vehicle::setMaxSpeedLat(
const std::string& vehID,
double speed) {
2487 Vehicle::setLateralAlignment(
const std::string& vehID,
const std::string& latAlignment) {
2493 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)");
2499 Vehicle::setParameter(
const std::string& vehID,
const std::string& key,
const std::string& value) {
2504 if (tok.size() < 3) {
2505 throw TraCIException(
"Invalid device parameter '" + key +
"' for vehicle '" + vehID +
"'");
2510 throw TraCIException(
"Vehicle '" + vehID +
"' does not support device parameter '" + key +
"' (" + e.what() +
").");
2513 if (microVeh ==
nullptr) {
2514 throw TraCIException(
"Meso Vehicle '" + vehID +
"' does not support laneChangeModel parameters.");
2516 const std::string attrName =
key.substr(16);
2520 throw TraCIException(
"Vehicle '" + vehID +
"' does not support laneChangeModel parameter '" + key +
"' (" + e.what() +
").");
2523 if (microVeh ==
nullptr) {
2524 throw TraCIException(
"Meso Vehicle '" + vehID +
"' does not support carFollowModel parameters.");
2529 throw TraCIException(
"Vehicle '" + vehID +
"' does not support carFollowModel parameter '" + key +
"' (" + e.what() +
").");
2537 throw TraCIException(e.what());
2541 if (tok.size() != 3) {
2542 throw TraCIException(
"Invalid request for device status change. Expected format is 'has.DEVICENAME.device'");
2544 const std::string deviceName = tok.get(1);
2549 throw TraCIException(
"Changing device status requires a 'true' or 'false'");
2552 throw TraCIException(
"Device removal is not supported for device of type '" + deviceName +
"'");
2557 throw TraCIException(
"Cannot create vehicle device (" + std::string(e.what()) +
").");
2566 Vehicle::highlight(
const std::string& vehID,
const TraCIColor& col,
double size,
const int alphaMax,
const double duration,
const int type) {
2573 const double l2 = veh->
getLength() * 0.5;
2580 const unsigned int nPoints = 34;
2584 #ifdef DEBUG_DYNAMIC_SHAPES
2585 std::cout <<
SIMTIME <<
" Vehicle::highlight() for vehicle '" << vehID <<
"'\n"
2586 <<
" circle: " << circlePV << std::endl;
2592 while (Polygon::exists(polyID)) {
2601 lyr += (type + 1) / 257.;
2604 Polygon::addHighlightPolygon(vehID, type, polyID, circle, col,
true,
"highlight", (
int)lyr, lw);
2607 double maxAttack = 1.0;
2608 std::vector<double> timeSpan;
2609 if (duration > 0.) {
2610 timeSpan = {0,
MIN2(maxAttack, duration / 3.), 2.*duration / 3., duration};
2613 std::vector<double> alphaSpan;
2614 if (alphaMax > 0.) {
2615 alphaSpan = {0., (double) alphaMax, (
double)(alphaMax) / 3., 0.};
2618 Polygon::addDynamics(polyID, vehID, timeSpan, alphaSpan,
false,
true);
2622 Vehicle::dispatchTaxi(
const std::string& vehID,
const std::vector<std::string>& reservations) {
2626 throw TraCIException(
"Vehicle '" + vehID +
"' has not yet departed");
2628 if (taxi ==
nullptr) {
2629 throw TraCIException(
"Vehicle '" + vehID +
"' is not a taxi");
2632 if (dispatcher ==
nullptr) {
2633 throw TraCIException(
"Cannot dispatch taxi because no reservations have been made");
2636 if (traciDispatcher ==
nullptr) {
2637 throw TraCIException(
"device.taxi.dispatch-algorithm 'traci' has not been loaded");
2639 if (reservations.size() == 0) {
2640 throw TraCIException(
"No reservations have been specified for vehicle '" + vehID +
"'");
2645 throw TraCIException(
"Could not interpret reservations for vehicle '" + vehID +
"' (" + e.what() +
").");
2653 Vehicle::subscribeLeader(
const std::string& vehID,
double dist,
double begin,
double end) {
2660 Vehicle::addSubscriptionFilterLanes(
const std::vector<int>& lanes,
bool noOpposite,
double downstreamDist,
double upstreamDist) {
2663 s->filterLanes = lanes;
2666 addSubscriptionFilterNoOpposite();
2669 addSubscriptionFilterDownstreamDistance(downstreamDist);
2672 addSubscriptionFilterUpstreamDistance(upstreamDist);
2678 Vehicle::addSubscriptionFilterNoOpposite() {
2684 Vehicle::addSubscriptionFilterDownstreamDistance(
double dist) {
2687 s->filterDownstreamDist = dist;
2693 Vehicle::addSubscriptionFilterUpstreamDistance(
double dist) {
2696 s->filterUpstreamDist = dist;
2702 Vehicle::addSubscriptionFilterCFManeuver(
double downstreamDist,
double upstreamDist) {
2703 addSubscriptionFilterLeadFollow(std::vector<int>({0}));
2705 addSubscriptionFilterDownstreamDistance(downstreamDist);
2708 addSubscriptionFilterUpstreamDistance(upstreamDist);
2715 Vehicle::addSubscriptionFilterLCManeuver(
int direction,
bool noOpposite,
double downstreamDist,
double upstreamDist) {
2716 std::vector<int> lanes;
2719 lanes = std::vector<int>({-1, 0, 1});
2720 }
else if (direction != -1 && direction != 1) {
2721 WRITE_WARNINGF(
TL(
"Ignoring lane change subscription filter with non-neighboring lane offset direction=%."), direction);
2723 lanes = std::vector<int>({0, direction});
2725 addSubscriptionFilterLeadFollow(lanes);
2727 addSubscriptionFilterNoOpposite();
2730 addSubscriptionFilterDownstreamDistance(downstreamDist);
2733 addSubscriptionFilterUpstreamDistance(upstreamDist);
2739 Vehicle::addSubscriptionFilterLeadFollow(
const std::vector<int>& lanes) {
2741 addSubscriptionFilterLanes(lanes);
2746 Vehicle::addSubscriptionFilterTurn(
double downstreamDist,
double foeDistToJunction) {
2749 addSubscriptionFilterDownstreamDistance(downstreamDist);
2752 s->filterFoeDistToJunction = foeDistToJunction;
2758 Vehicle::addSubscriptionFilterVClass(
const std::vector<std::string>& vClasses) {
2767 Vehicle::addSubscriptionFilterVType(
const std::vector<std::string>& vTypes) {
2770 s->filterVTypes.insert(vTypes.begin(), vTypes.end());
2776 Vehicle::addSubscriptionFilterFieldOfVision(
double openingAngle) {
2779 s->filterFieldOfVisionOpeningAngle = openingAngle;
2785 Vehicle::addSubscriptionFilterLateralDistance(
double lateralDist,
double downstreamDist,
double upstreamDist) {
2788 s->filterLateralDist = lateralDist;
2791 addSubscriptionFilterDownstreamDistance(downstreamDist);
2794 addSubscriptionFilterUpstreamDistance(upstreamDist);
2805 std::shared_ptr<VariableWrapper>
2806 Vehicle::makeWrapper() {
2807 return std::make_shared<Helper::SubscriptionWrapper>(handleVariable, mySubscriptionResults, myContextSubscriptionResults);
2812 Vehicle::handleVariable(
const std::string& objID,
const int variable, VariableWrapper* wrapper,
tcpip::Storage* paramData) {
2815 return wrapper->wrapStringList(objID, variable, getIDList());
2817 return wrapper->wrapInt(objID, variable, getIDCount());
2819 return wrapper->wrapPosition(objID, variable, getPosition(objID));
2821 return wrapper->wrapPosition(objID, variable, getPosition(objID,
true));
2823 return wrapper->wrapDouble(objID, variable, getAngle(objID));
2825 return wrapper->wrapDouble(objID, variable, getSpeed(objID));
2827 return wrapper->wrapDouble(objID, variable, getLateralSpeed(objID));
2829 return wrapper->wrapString(objID, variable, getRoadID(objID));
2831 return wrapper->wrapDouble(objID, variable, getSpeedWithoutTraCI(objID));
2833 return wrapper->wrapDouble(objID, variable, getSlope(objID));
2835 return wrapper->wrapString(objID, variable, getLaneID(objID));
2837 return wrapper->wrapInt(objID, variable, getLaneIndex(objID));
2839 return wrapper->wrapString(objID, variable, getSegmentID(objID));
2841 return wrapper->wrapInt(objID, variable, getSegmentIndex(objID));
2843 return wrapper->wrapString(objID, variable, getTypeID(objID));
2845 return wrapper->wrapString(objID, variable, getRouteID(objID));
2847 return wrapper->wrapDouble(objID, variable, getDeparture(objID));
2849 return wrapper->wrapDouble(objID, variable, getDepartDelay(objID));
2851 return wrapper->wrapInt(objID, variable, getRouteIndex(objID));
2853 return wrapper->wrapColor(objID, variable, getColor(objID));
2855 return wrapper->wrapDouble(objID, variable, getLanePosition(objID));
2857 return wrapper->wrapDouble(objID, variable, getLateralLanePosition(objID));
2859 return wrapper->wrapDouble(objID, variable, getCO2Emission(objID));
2861 return wrapper->wrapDouble(objID, variable, getCOEmission(objID));
2863 return wrapper->wrapDouble(objID, variable, getHCEmission(objID));
2865 return wrapper->wrapDouble(objID, variable, getPMxEmission(objID));
2867 return wrapper->wrapDouble(objID, variable, getNOxEmission(objID));
2869 return wrapper->wrapDouble(objID, variable, getFuelConsumption(objID));
2871 return wrapper->wrapDouble(objID, variable, getNoiseEmission(objID));
2873 return wrapper->wrapDouble(objID, variable, getElectricityConsumption(objID));
2875 return wrapper->wrapInt(objID, variable, getPersonNumber(objID));
2877 return wrapper->wrapInt(objID, variable, getPersonCapacity(objID));
2879 return wrapper->wrapDouble(objID, variable, getBoardingDuration(objID));
2881 return wrapper->wrapStringList(objID, variable, getPersonIDList(objID));
2883 return wrapper->wrapDouble(objID, variable, getWaitingTime(objID));
2885 return wrapper->wrapDouble(objID, variable, getAccumulatedWaitingTime(objID));
2887 return wrapper->wrapInt(objID, variable, isRouteValid(objID));
2889 return wrapper->wrapStringList(objID, variable, getRoute(objID));
2891 return wrapper->wrapInt(objID, variable, getSignals(objID));
2893 return wrapper->wrapInt(objID, variable, getStopState(objID));
2895 return wrapper->wrapDouble(objID, variable, getDistance(objID));
2897 return wrapper->wrapDouble(objID, variable, getAllowedSpeed(objID));
2899 return wrapper->wrapDouble(objID, variable, getSpeedFactor(objID));
2901 return wrapper->wrapInt(objID, variable, getSpeedMode(objID));
2903 return wrapper->wrapInt(objID, variable, getLaneChangeMode(objID));
2905 return wrapper->wrapInt(objID, variable, getRoutingMode(objID));
2907 return wrapper->wrapString(objID, variable, getLine(objID));
2909 return wrapper->wrapStringList(objID, variable, getVia(objID));
2911 return wrapper->wrapDouble(objID, variable, getAcceleration(objID));
2913 return wrapper->wrapDouble(objID, variable, getLastActionTime(objID));
2915 return wrapper->wrapDouble(objID, variable, getStopDelay(objID));
2917 return wrapper->wrapDouble(objID, variable, getImpatience(objID));
2919 return wrapper->wrapDouble(objID, variable, getStopArrivalDelay(objID));
2921 return wrapper->wrapDouble(objID, variable, getTimeLoss(objID));
2923 return wrapper->wrapDouble(objID, variable, getMinGapLat(objID));
2927 return wrapper->wrapStringDoublePair(objID, variable, getLeader(objID, dist));
2932 return wrapper->wrapStringDoublePair(objID, variable, getFollower(objID, dist));
2935 return wrapper->wrapStringList(objID, variable, getLoadedIDList());
2937 return wrapper->wrapStringList(objID, variable, getTeleportingIDList());
2940 return wrapper->wrapString(objID, variable, getParameter(objID, paramData->
readString()));
2943 return wrapper->wrapStringPair(objID, variable, getParameterWithKey(objID, paramData->
readString()));
2948 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_WARNINGF(...)
#define WRITE_WARNING(msg)
std::shared_ptr< const MSRoute > ConstMSRoutePtr
void checkTimeBounds(const double time)
check the valid SUMOTime range of double input and throw an error if out of bounds
SUMOTime string2time(const std::string &r)
convert string to SUMOTime
std::string time2string(SUMOTime t, bool humanReadable)
convert SUMOTime to string (independently of global format setting)
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 STOP_ARRIVAL_SET
const int STOP_DURATION_SET
const int VEHPARS_COLOR_SET
const int STOP_POSLAT_SET
const int STOP_EXPECTED_SET
const int VEHPARS_TO_TAZ_SET
const int STOP_PARKING_SET
const int STOP_TRIP_ID_SET
const int VEHPARS_DEPARTPOS_SET
const int STOP_PERMITTED_SET
const int VEHPARS_ARRIVALLANE_SET
const int VEHPARS_DEPARTLANE_SET
const int VEHPARS_FROM_TAZ_SET
const int VEHPARS_ARRIVALSPEED_SET
const int STOP_EXTENSION_SET
const int VEHPARS_FORCE_REROUTE
const int STOP_TRIGGER_SET
const int STOP_ONDEMAND_SET
const int VEHPARS_LINE_SET
const int STOP_STARTED_SET
const int VEHPARS_PERSON_NUMBER_SET
const int STOP_EXPECTED_CONTAINERS_SET
const int VEHPARS_DEPARTSPEED_SET
const int VEHPARS_VTYPE_SET
const int VEHPARS_ARRIVALPOS_SET
@ GIVEN
The time is given.
@ NOW
The vehicle is discarded if emission fails (not fully implemented yet)
@ CONTAINER_TRIGGERED
The departure is container triggered.
@ TRIGGERED
The departure is person triggered.
@ LCA_UNKNOWN
The action has not been determined.
@ SUMO_ATTR_CONTAINER_STOP
@ SUMO_ATTR_CHARGING_STATION
@ SUMO_ATTR_EXPECTED_CONTAINERS
const double INVALID_DOUBLE
invalid double
std::string joinToString(const std::vector< T > &v, const T_BETWEEN &between, std::streamsize accuracy=gPrecision)
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
#define LIBSUMO_SUBSCRIPTION_IMPLEMENTATION(CLASS, DOM)
#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.
int getQueIndex() const
Returns the index of the que the vehicle is in.
SUMOTime getEventTime() const
Returns the (planned) time at which the vehicle leaves its current segment.
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
void setExtraImpatience(double value)
Sets routing behavior.
The base class for microscopic and mesoscopic vehicles.
double getMaxSpeed() const
Returns the maximum speed (the minimum of desired and technical maximum speed)
double getImpatience() const
Returns this vehicles impatience.
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.
void setCarFollowModelParameter(const std::string &key, const std::string &value)
set individual carFollow model parameters (not type related)
void setRoutingMode(int value)
Sets routing behavior.
virtual double getStopDelay() const
Returns the estimated public transport stop (departure) delay in seconds.
bool rerouteBetweenStops(int nextStopIndex, const std::string &info, bool teleport, std::string &errorMsg)
const std::list< MSStop > & getStops() const
const SUMOVehicleParameter & getParameter() const
Returns the vehicle's parameter (including departure definition)
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.
virtual bool replaceRoute(ConstMSRoutePtr route, const std::string &info, bool onInit=false, int offset=0, bool addRouteStops=true, bool removeStops=true, std::string *msgReturn=nullptr)
Replaces the current route by the given one.
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.
bool hasValidRoute(std::string &msg, ConstMSRoutePtr route=0) const
Validates the current or given route.
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.
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)
bool hasDeparted() const
Returns whether this vehicle has already departed.
SUMOTime getDeparture() const
Returns this vehicle's real departure time.
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.
MSStop & getStop(int nextStopIndex)
bool insertStop(int nextStopIndex, SUMOVehicleParameter::Stop stop, const std::string &info, bool teleport, std::string &errorMsg)
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.
virtual bool addTraciStop(SUMOVehicleParameter::Stop stop, std::string &errorMsg)
int getRoutingMode() const
return routing mode (configures router choice but also handling of transient permission changes)
int getRoutePosition() const
return index of edge within route
double getEmissions() const
Returns emissions of the current state The value is always per 1s, so multiply by step length if nece...
SUMOAbstractRouter< MSEdge, SUMOVehicle > & getRouterTT() const
virtual bool isOnRoad() const
Returns the information whether the vehicle is on a road (is simulated)
const std::vector< SUMOVehicleParameter::Stop > & getPastStops() const
const MSRoute & getRoute() const
Returns the current route.
bool reroute(SUMOTime t, const std::string &info, SUMOAbstractRouter< MSEdge, SUMOVehicle > &router, const bool onInit=false, const bool withTaz=false, const bool silent=false, const MSEdge *sink=nullptr)
Performs a rerouting using the given router.
void createDevice(const std::string &deviceName)
create device of the given type
bool isStopped() const
Returns whether the vehicle is at a stop.
MSDevice * getDevice(const std::type_info &type) const
Returns a device of the given type if it exists, nullptr otherwise.
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.
double getEmergencyDecel() const
Get the vehicle type's maximal phisically possible deceleration [m/s^2].
virtual double getSecureGap(const MSVehicle *const veh, 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 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].
double brakeGap(const double speed) const
Returns the distance the vehicle needs to halt including driver's reaction time tau (i....
virtual double getImperfection() const
Get the driver's imperfection.
double getMaxDecel() const
Get the vehicle type's maximal comfortable 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 CalcReason usage=CalcReason::CURRENT) const =0
Computes the vehicle's follow speed (no dawdling)
double stopSpeed(const MSVehicle *const veh, const double speed, double gap, const CalcReason usage=CalcReason::CURRENT) const
Computes the vehicle's safe speed for approaching a non-moving obstacle (no dawdling)
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, bool ignoreTransientPermissions=false) const
Get the allowed lanes to reach the destination-edge.
const std::vector< MSLane * > & getLanes() const
Returns this edge's lanes.
double getLength() const
return the length of the 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
static bool gSemiImplicitEulerUpdate
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.
virtual const MSJunctionLogic * getLogic() const
virtual const MSLogicJunction::LinkBits & getResponseFor(int linkIndex) const
Returns the response for the given link.
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.
double getSpeedLimit() const
Returns the lane's maximum allowed speed.
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
int getIndex() const
Returns the lane's index.
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 {.
MSEdge & getEdge() const
Returns the lane's edge.
MSLeaderDistanceInfo getFollowersOnConsecutive(const MSVehicle *ego, double backOffset, bool allSublanes, double searchDist=-1, MinorLinkMode mLinkMode=FOLLOW_ALWAYS) const
return the sublane followers with the largest missing rear gap among all predecessor lanes (within di...
double getWidth() const
Returns the lane's width.
const Position geometryPositionAtOffset(double offset, double lateralOffset=0) const
virtual const PositionVector & getShape(bool) 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)
LinkState getState() const
Returns the current state of the link.
bool hasApproachingFoe(SUMOTime arrivalTime, SUMOTime leaveTime, double speed, double decel) const
Returns the information whether a vehicle is approaching on one of the link's foe streams.
MSLane * getViaLane() const
Returns the following inner lane.
MSLane * getLane() const
Returns the connected lane.
bool opened(SUMOTime arrivalTime, double arrivalSpeed, double leaveSpeed, double vehicleLength, double impatience, double decel, SUMOTime waitingTime, double posLat=0, BlockingFoes *collectFoes=nullptr, bool ignoreRed=false, const SUMOTrafficObject *ego=nullptr, double dist=-1) const
Returns the information whether the link may be passed.
int getIndex() const
Returns the respond index (for visualization)
bool havePriority() const
Returns whether this link is a major link.
ApproachingVehicleInformation getApproaching(const SUMOVehicle *veh) const
@ CONFLICT_NO_INTERSECTION
const std::vector< const MSLane * > & getFoeLanes() const
MSJunction * getJunction() const
LinkDirection getDirection() const
Returns the direction the vehicle passing this link take.
const std::vector< ConflictInfo > & getConflicts() const
double getLength() const
Returns the length of this link.
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, ConstMSRoutePtr route)
Adds a route to the dictionary.
MSRouteIterator begin() const
Returns the begin of the list of edges to pass.
double getDistanceBetween(double fromPos, double toPos, const MSLane *fromLane, const MSLane *toLane, int routePosition=0) const
Compute the distance between 2 given edges on this route, optionally including the length of internal...
const ConstMSEdgeVector & getEdges() const
const MSLane * lane
The lane to stop at (microsim only)
void initPars(const SUMOVehicleParameter::Stop &stopPar)
initialize attributes from the given stop parameters
int getStateFlagsOld() const
return flags as used by Vehicle::getStopState
bool reached
Information whether the stop has been reached.
MSRouteIterator edge
The edge in the route to stop at.
SUMOTime duration
The stopping duration.
const SUMOVehicleParameter::Stop pars
The stop parameter.
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 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.
virtual SUMOVehicle * buildVehicle(SUMOVehicleParameter *defs, ConstMSRoutePtr route, MSVehicleType *type, const bool ignoreStopErrors, const VehicleDefinitionSource source=ROUTEFILE, bool addRouteStops=true)
Builds a vehicle, increases the number of built vehicles.
void scheduleVehicleRemoval(SUMOVehicle *veh, bool checkDuplicate=false)
Removes a vehicle after it has ended.
virtual void deleteVehicle(SUMOVehicle *v, bool discard=false, bool wasKept=false)
Deletes the vehicle.
constVehIt loadedVehBegin() const
Returns the begin of the internal vehicle map.
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
const std::vector< const MSLane * > getUpcomingLanesUntil(double distance) const
Returns the upcoming (best followed by default 0) sequence of lanes to continue the route starting at...
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, double prevAcceleration)
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.
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.
void updateLaneBruttoSum()
Update the lane brutto occupancy after a change in minGap.
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 setLateralPositionOnLane(double posLat)
void switchOnSignal(int signal)
Switches the given signal on.
static MSVehicleTransfer * getInstance()
Returns the instance of this object.
void remove(MSVehicle *veh)
Remove a vehicle from this transfer object.
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 (technical) 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.
void setBoardingDuration(SUMOTime duration, bool isPerson=true)
Set a new value for this type's boardingDuration.
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].
void setMass(double mass)
Set a new value for this type's mass.
const MSCFModel & getCarFollowModel() const
Returns the vehicle type's car following model definition (const version)
double getMass() const
Get this vehicle type's mass.
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.
virtual const std::string getParameter(const std::string &key, const std::string defaultValue="") const
Returns the value for a given key.
virtual void setParameter(const std::string &key, const std::string &value)
Sets a parameter.
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)
Subtracts 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 (in radians bet...
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 amount
void set(unsigned char r, unsigned char g, unsigned char b, unsigned char a)
assigns new values
virtual double getSlope() const =0
Returns the slope of the road at object's position in degrees.
virtual double getPreviousSpeed() const =0
Returns the object's previous speed.
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 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....
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 hasDeparted() const =0
Returns whether this vehicle has departed.
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)
int getFlags() const
return flags as per Vehicle::getStops
SUMOTime started
the time at which this stop was reached
std::string edge
The edge to stop at.
ParkingType parking
whether the vehicle is removed from the net while stopping
std::string lane
The lane to stop at.
SUMOTime extension
The maximum time extension for boarding / loading.
double speed
the speed at which this stop counts as reached (waypoint mode)
std::string parkingarea
(Optional) parking area if one is assigned to the stop
std::string split
the id of the vehicle (train portion) that splits of upon reaching this stop
double startPos
The stopping position start.
std::string line
the new line id of the trip within a cyclical public transport route
double posLat
the lateral offset when stopping
bool onDemand
whether the stop may be skipped
std::string chargingStation
(Optional) charging station if one is assigned to the stop
std::vector< std::string > getTriggers() const
write trigger attribute
std::set< std::string > permitted
IDs of persons or containers that may board/load at this stop.
int parametersSet
Information for the output which parameter were set.
SUMOTime jump
transfer time if there shall be a jump from this stop to the next route edge
std::string join
the id of the vehicle (train portion) to which this vehicle shall be joined
SUMOTime until
The time at which the vehicle may continue its journey.
std::string actType
act Type (only used by Persons) (used by netedit)
SUMOTime ended
the time at which this stop was ended
double endPos
The stopping position end.
std::set< std::string > awaitedPersons
IDs of persons the vehicle has to wait for until departing.
std::set< std::string > awaitedContainers
IDs of containers the vehicle has to wait for until departing.
std::string busstop
(Optional) bus stop if one is assigned to the stop
std::string tripId
id of the trip within a cyclical public transport route
std::string containerstop
(Optional) container stop if one is assigned to the stop
SUMOTime arrival
The (expected) time at which the vehicle reaches the stop.
SUMOTime duration
The stopping duration.
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::string vtypeid
The vehicle's type id.
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 ParkingType parseParkingType(const std::string &value)
parses parking type value
static void parseStopTriggers(const std::vector< std::string > &triggers, bool expectTrigger, Stop &stop)
parses stop trigger values
static bool isInternalRouteID(const std::string &id)
Checks whether the route ID uses the syntax of internal routes.
static StringBijection< LinkState > LinkStates
link states
static int getIndexFromLane(const std::string laneID)
return lane index when given the lane ID
static StringBijection< LinkDirection > LinkDirections
link directions
const std::string & getString(const T key) const
std::set< std::string > getSet()
return set of strings
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 int toInt(const std::string &sData)
converts a string into the integer value described by it by calling the char-type converter,...
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)
static const MSLane * getLaneChecking(const std::string &edgeID, int laneIndex, double pos)
virtual std::string readString()
virtual int readUnsignedByte()
virtual double readDouble()
#define CALL_MESO_FUN(veh, fun, microResult)
#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_IMPATIENCE
TRACI_CONST int VAR_SEGMENT_ID
TRACI_CONST int VAR_DEPARTURE
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 VAR_BOARDING_DURATION
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 VAR_TELEPORTING_LIST
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_SEGMENT_INDEX
TRACI_CONST int ROUTING_MODE_DEFAULT
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
TRACI_CONST int VAR_LOADED_LIST
TRACI_CONST int VAR_DEPART_DELAY
std::map< int, std::shared_ptr< libsumo::TraCIResult > > TraCIResults
{variable->value}
TRACI_CONST int VAR_DISTANCE
TRACI_CONST int ROUTING_MODE_AGGREGATED_CUSTOM
TRACI_CONST int VAR_ELECTRICITYCONSUMPTION
@ key
the parser read a key of a value in an object
NLOHMANN_BASIC_JSON_TPL_DECLARATION void swap(nlohmann::NLOHMANN_BASIC_JSON_TPL &j1, nlohmann::NLOHMANN_BASIC_JSON_TPL &j2) noexcept(//NOLINT(readability-inconsistent-declaration-parameter-name) is_nothrow_move_constructible< nlohmann::NLOHMANN_BASIC_JSON_TPL >::value &&//NOLINT(misc-redundant-expression) is_nothrow_move_assignable< nlohmann::NLOHMANN_BASIC_JSON_TPL >::value)
exchanges the values of two JSON objects
pre-computed information for conflict points
double getFoeConflictSize(const MSLink *foeExitLink) const
double conflictSize
the length of the conflict space
double getFoeLengthBehindCrossing(const MSLink *foeExitLink) const
double lengthBehindCrossing
length of internal lane after the crossing point
A structure representing the best lanes for continuing the current route starting at 'lane'.