Eclipse SUMO - Simulation of Urban MObility
MSVehicle.h
Go to the documentation of this file.
1/****************************************************************************/
2// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3// Copyright (C) 2001-2023 German Aerospace Center (DLR) and others.
4// This program and the accompanying materials are made available under the
5// terms of the Eclipse Public License 2.0 which is available at
6// https://www.eclipse.org/legal/epl-2.0/
7// This Source Code may also be made available under the following Secondary
8// Licenses when the conditions for such availability set forth in the Eclipse
9// Public License 2.0 are satisfied: GNU General Public License, version 2
10// or later which is available at
11// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
12// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
13/****************************************************************************/
27// Representation of a vehicle in the micro simulation
28/****************************************************************************/
29#pragma once
30#include <config.h>
31
32#include <list>
33#include <deque>
34#include <map>
35#include <set>
36#include <string>
37#include <vector>
38#include <memory>
39#include "MSGlobals.h"
40#include "MSBaseVehicle.h"
41#include "MSNet.h"
42
43#define INVALID_SPEED 299792458 + 1 // nothing can go faster than the speed of light! Refs. #2577
44
45// ===========================================================================
46// class declarations
47// ===========================================================================
49class MSMoveReminder;
50class MSLaneChanger;
53class MSStoppingPlace;
54class MSStop;
56class MSOverheadWire;
57class MSParkingArea;
58class MSPerson;
59class MSDevice;
60class OutputDevice;
61class Position;
62class MSJunction;
63class MSLeaderInfo;
68
69
70// ===========================================================================
71// class definitions
72// ===========================================================================
77class MSVehicle : public MSBaseVehicle {
78public:
79
81 friend class MSLaneChanger;
83
87 class State {
89 friend class MSVehicle;
90 friend class MSLaneChanger;
92
93 public:
95 State(double pos, double speed, double posLat, double backPos, double previousSpeed);
96
98 State(const State& state);
99
101 State& operator=(const State& state);
102
104 bool operator!=(const State& state);
105
107 double pos() const {
108 return myPos;
109 }
110
112 double speed() const {
113 return mySpeed;
114 };
115
117 double posLat() const {
118 return myPosLat;
119 }
120
122 double backPos() const {
123 return myBackPos;
124 }
125
127 double lastCoveredDist() const {
128 return myLastCoveredDist;
129 }
130
131
132 private:
134 double myPos;
135
137 double mySpeed;
138
140 double myPosLat;
141
143 // if the vehicle occupies multiple lanes, this is the position relative
144 // to the lane occupied by its back
145 double myBackPos;
146
149
155
156 };
157
158
163 public:
166
167 // return the waiting time within the last memory millisecs
168 SUMOTime cumulatedWaitingTime(SUMOTime memory = -1) const;
169
170 // process time passing for dt millisecs
171 void passTime(SUMOTime dt, bool waiting);
172
173 const std::string getState() const;
174
175 void setState(const std::string& state);
176
177 private:
180
184 std::deque<std::pair<SUMOTime, SUMOTime> > myWaitingIntervals;
185
188 };
189
190
203 };
204
213 MSVehicleType* type, const double speedFactor);
214
216 virtual ~MSVehicle();
217
218 void initDevices();
219
221 bool hasValidRouteStart(std::string& msg);
222
224
225
235
236
237
239
240
244 bool hasArrived() const;
245
256 bool replaceRoute(ConstMSRoutePtr route, const std::string& info, bool onInit = false, int offset = 0, bool addStops = true, bool removeStops = true, std::string* msgReturn = nullptr);
257
259
260
262
263
281 void workOnMoveReminders(double oldPos, double newPos, double newSpeed);
283
289 void workOnIdleReminders();
290
296 bool checkActionStep(const SUMOTime t);
297
303 void resetActionOffset(const SUMOTime timeUntilNextAction = 0);
304
305
315 void updateActionOffset(const SUMOTime oldActionStepLength, const SUMOTime newActionStepLength);
316
317
335 void planMove(const SUMOTime t, const MSLeaderInfo& ahead, const double lengthsInFront);
336
340
342 void registerInsertionApproach(MSLink* link, double dist);
343
344
357 bool executeMove();
358
360 void executeFractionalMove(double dist);
361
368 double getDeltaPos(const double accel) const;
369
370
372
373
377 double getPositionOnLane() const {
378 return myState.myPos;
379 }
380
384 double getLastStepDist() const {
385 return myState.lastCoveredDist();
386 }
387
391 double getPositionOnLane(const MSLane* lane) const;
392
401 inline double getBackPositionOnLane(const MSLane* lane) const {
402 return getBackPositionOnLane(lane, false);
403 }
404
408 double getBackPositionOnLane() const {
410 }
411
417 return myState.myPosLat;
418 }
419
420 void setLateralPositionOnLane(double posLat) {
421 myState.myPosLat = posLat;
422 }
423
426 }
427
432 double getRightSideOnLane() const;
433
438 double getLeftSideOnLane() const;
439
444 double getRightSideOnLane(const MSLane* lane) const;
445
450 double getLeftSideOnLane(const MSLane* lane) const;
451
455 double lateralDistanceToLane(const int offset) const;
456
458 double getLateralOverlap() const;
459 double getLateralOverlap(const MSLane* lane) const;
460 double getLateralOverlap(double posLat, const MSLane* lane) const;
461
467 double getLeftSideOnEdge(const MSLane* lane = 0) const;
468
474 double getRightSideOnEdge(const MSLane* lane = 0) const;
475
481 double getCenterOnEdge(const MSLane* lane = 0) const;
482
488 double getLatOffset(const MSLane* lane) const;
489
493 double getSpeed() const {
494 return myState.mySpeed;
495 }
496
497
501 double getPreviousSpeed() const {
503 }
504
505
510 void setPreviousSpeed(double prevSpeed, double prevAcceleration);
511
512
517 double getAcceleration() const {
518 return myAcceleration;
519 }
520
522 double getCurrentApparentDecel() const;
523
529 return myType->getActionStepLength();
530 }
531
536 double getActionStepLengthSecs() const {
538 }
539
540
545 return myLastActionTime;
546 }
547
549
550
551
553
554
558 double getSlope() const;
559
560
568 Position getPosition(const double offset = 0) const;
569
570
578 Position getPositionAlongBestLanes(double offset) const;
579
580
584 const MSLane* getLane() const {
585 return myLane;
586 }
587
593 return myLane;
594 }
595
596
601 double getMaxSpeedOnLane() const;
602
606 inline bool isOnRoad() const {
607 return myAmOnNet;
608 }
609
613 void
614 setIdling(bool amIdling) {
615 myAmIdling = amIdling;
616 }
617
622 inline bool isIdling() const {
623 return myAmIdling;
624 }
625
629 inline bool isActive() const {
630 return myActionStep;
631 }
632
636 inline bool isActionStep(SUMOTime t) const {
637 return (t - myLastActionTime) % getActionStepLength() == 0;
638// return t%getActionStepLength() == 0; // synchronized actions for all vehicles with identical actionsteplengths
639 }
640
641
645 bool isFrontOnLane(const MSLane* lane) const;
646
650 const MSEdge* getCurrentEdge() const;
651
653 const MSEdge* getNextEdgePtr() const;
654
661 ConstMSEdgeVector::const_iterator getRerouteOrigin() const;
662
663
671 return myWaitingTime;
672 }
673
681 return myTimeSinceStartup;
682 }
683
684 inline double getTimeSinceStartupSeconds() const {
686 }
687
698 return TIME2STEPS(myTimeLoss);
699 }
700
701
708 }
709
717 }
718
721 double getTimeLossSeconds() const {
722 return myTimeLoss;
723 }
724
727 double getStopDelay() const;
728
731 double getStopArrivalDelay() const;
732
736 double getAngle() const {
737 return myAngle;
738 }
739
740
745 return Position(std::cos(myAngle) * myState.speed(), std::sin(myAngle) * myState.speed());
746 }
748
750 double computeAngle() const;
751
753 void setAngle(double angle, bool straightenFurther = false);
754
761 void setActionStepLength(double actionStepLength, bool resetActionOffset = true);
762
764 static bool overlap(const MSVehicle* veh1, const MSVehicle* veh2) {
765 if (veh1->myState.myPos < veh2->myState.myPos) {
766 return veh2->myState.myPos - veh2->getVehicleType().getLengthWithGap() < veh1->myState.myPos;
767 }
768 return veh1->myState.myPos - veh1->getVehicleType().getLengthWithGap() < veh2->myState.myPos;
769 }
770
773 bool congested() const;
774
775
787 void activateReminders(const MSMoveReminder::Notification reason, const MSLane* enteredLane = 0);
788
795 void enterLaneAtMove(MSLane* enteredLane, bool onTeleporting = false);
796
797
798
807 void enterLaneAtInsertion(MSLane* enteredLane, double pos, double speed, double posLat,
808 MSMoveReminder::Notification notification);
809
814 void setTentativeLaneAndPosition(MSLane* lane, double pos, double posLat = 0);
815
820 void enterLaneAtLaneChange(MSLane* enteredLane);
821
822
824 void leaveLane(const MSMoveReminder::Notification reason, const MSLane* approachedLane = 0);
825
832 void updateDriveItems();
833
837 const std::pair<double, const MSLink*>& getNextTurn() {
838 return myNextTurn;
839 }
840
841
844
845 const std::vector<MSLane*>& getFurtherLanes() const {
846 return myFurtherLanes;
847 }
848
849 const std::vector<double>& getFurtherLanesPosLat() const {
851 }
852
853
855 bool onFurtherEdge(const MSEdge* edge) const;
856
859
860 //
864 struct LaneQ {
866 MSLane* lane = nullptr;
868 double length;
879 /* @brief Longest sequence of (normal-edge) lanes that can be followed without a lane change
880 * The 'length' attribute is the sum of these lane lengths
881 * (There may be alternative sequences that have equal length)
882 * It is the 'best' in the strategic sense of reducing required lane-changes
883 */
884 std::vector<MSLane*> bestContinuations;
885 };
886
890 const std::vector<LaneQ>& getBestLanes() const;
891
909 void updateBestLanes(bool forceRebuild = false, const MSLane* startLane = 0);
910
911
915 const std::vector<MSLane*>& getBestLanesContinuation() const;
916
917
921 const std::vector<MSLane*>& getBestLanesContinuation(const MSLane* const l) const;
922
929 const std::vector<const MSLane*> getUpcomingLanesUntil(double distance) const;
930
936 const std::vector<const MSLane*> getPastLanesUntil(double distance) const;
937
942 const std::vector<MSLane*> getUpstreamOppositeLanes() const;
943
944 /* @brief returns the current signed offset from the lane that is most
945 * suited for continuing the current route (in the strategic sense of reducing lane-changes)
946 * - 0 if the vehicle is one it's best lane
947 * - negative if the vehicle should change to the right
948 * - positive if the vehicle should change to the left
949 */
950 int getBestLaneOffset() const;
951
953 double getBestLaneDist() const;
954
956 void adaptBestLanesOccupation(int laneIndex, double density);
957
959
961 void fixPosition();
962
964 std::pair<const MSLane*, double> getLanePosAfterDist(double distance) const;
965
973 inline const MSCFModel& getCarFollowModel() const {
974 return myType->getCarFollowModel();
975 }
976
982 std::shared_ptr<MSSimpleDriverState> getDriverState() const;
983
988 double getFriction() const;
989
995 return myCFVariables;
996 }
997
999
1000
1001
1002
1005 bool replaceParkingArea(MSParkingArea* parkingArea, std::string& errorMsg);
1006
1010
1013
1016 inline bool hasDriverState() const {
1017 return myDriverState != nullptr;
1018 }
1019
1022
1025 bool willStop() const;
1026
1028 bool isStoppedOnLane() const;
1029
1031 bool keepStopping(bool afterProcessing = false) const;
1032
1037
1041 bool isRemoteControlled() const;
1042
1046 bool wasRemoteControlled(SUMOTime lookBack = DELTA_T) const;
1047
1049 double nextStopDist() const {
1050 return myStopDist;
1051 }
1053
1054 int getLaneIndex() const;
1055
1065 double getDistanceToPosition(double destPos, const MSEdge* destEdge) const;
1066
1067
1075 double processNextStop(double currentVelocity);
1076
1077
1085 std::pair<const MSVehicle* const, double> getLeader(double dist = 0) const;
1086
1095 std::pair<const MSVehicle* const, double> getFollower(double dist = 0) const;
1096
1103 double getTimeGapOnLane() const;
1104
1105
1110 void addTransportable(MSTransportable* transportable);
1111
1114
1150
1151
1157 LC_NEVER = 0, // lcModel shall never trigger changes at this level
1158 LC_NOCONFLICT = 1, // lcModel may trigger changes if not in conflict with TraCI request
1159 LC_ALWAYS = 2 // lcModel may always trigger changes of this level regardless of requests
1161
1162
1165 LCP_ALWAYS = 0, // change regardless of blockers, adapt own speed and speed of blockers
1166 LCP_NOOVERLAP = 1, // change unless overlapping with blockers, adapt own speed and speed of blockers
1167 LCP_URGENT = 2, // change if not blocked, adapt own speed and speed of blockers
1168 LCP_OPPORTUNISTIC = 3 // change if not blocked
1170
1171
1175 void switchOnSignal(int signal) {
1176 mySignals |= signal;
1177 }
1178
1179
1183 void switchOffSignal(int signal) {
1184 mySignals &= ~signal;
1185 }
1186
1187
1191 int getSignals() const {
1192 return mySignals;
1193 }
1194
1195
1200 bool signalSet(int which) const {
1201 return (mySignals & which) != 0;
1202 }
1204
1205
1207 bool unsafeLinkAhead(const MSLane* lane) const;
1208
1210 bool passingMinor() const;
1211
1212
1213
1221 double getSpeedWithoutTraciInfluence() const;
1222
1227 bool rerouteParkingArea(const std::string& parkingAreaID, std::string& errorMsg);
1228
1235 bool addTraciStop(SUMOVehicleParameter::Stop stop, std::string& errorMsg);
1236
1237 bool handleCollisionStop(MSStop& stop, const double distToStop);
1238
1243 bool resumeFromStopping();
1244
1246 double updateFurtherLanes(std::vector<MSLane*>& furtherLanes,
1247 std::vector<double>& furtherLanesPosLat,
1248 const std::vector<MSLane*>& passedLanes);
1249
1251 PositionVector getBoundingBox(double offset = 0) const;
1252
1254 PositionVector getBoundingPoly(double offset = 0) const;
1255
1267
1270 bool setExitManoeuvre();
1273
1275 bool manoeuvreIsComplete() const;
1278
1279
1287
1288 public:
1290 Manoeuvre();
1291
1293 Manoeuvre(const Manoeuvre& manoeuvre);
1294
1296 Manoeuvre& operator=(const Manoeuvre& manoeuvre);
1297
1299 bool operator!=(const Manoeuvre& manoeuvre);
1300
1303
1306
1309
1311 bool
1312 manoeuvreIsComplete(const ManoeuvreType checkType) const;
1313
1315 bool
1316 manoeuvreIsComplete() const;
1317
1319 double getGUIIncrement() const;
1320
1323
1326
1327 private:
1330
1332 std::string myManoeuvreStop;
1333
1336
1339
1342
1343 // @brief Angle (radians) through which parking vehicle moves in each sim step
1345 };
1346
1347 // Current or previous (completed) manoeuvre
1349
1363 private:
1364
1374 void vehicleStateChanged(const SUMOVehicle* const vehicle, MSNet::VehicleState to, const std::string& info = "");
1375 };
1376
1377
1381 virtual ~GapControlState();
1383 static void init();
1385 static void cleanup();
1387 void activate(double tauOriginal, double tauTarget, double additionalGap, double duration, double changeRate, double maxDecel, const MSVehicle* refVeh);
1389 void deactivate();
1406 double maxDecel;
1419
1421 static std::map<const MSVehicle*, GapControlState*> refVehMap;
1422
1423 private:
1425 };
1426
1427
1428 public:
1430 Influencer();
1431
1433 ~Influencer();
1434
1436 static void init();
1438 static void cleanup();
1439
1443 void setSpeedTimeLine(const std::vector<std::pair<SUMOTime, double> >& speedTimeLine);
1444
1447 void activateGapController(double originalTau, double newTimeHeadway, double newSpaceHeadway, double duration, double changeRate, double maxDecel, MSVehicle* refVeh = nullptr);
1448
1452
1456 void setLaneTimeLine(const std::vector<std::pair<SUMOTime, int> >& laneTimeLine);
1457
1461 void adaptLaneTimeLine(int indexShift);
1462
1466 void setSublaneChange(double latDist);
1467
1469 int getSpeedMode() const;
1470
1472 int getLaneChangeMode() const;
1473
1475
1477
1489 double influenceSpeed(SUMOTime currentTime, double speed, double vSafe, double vMin, double vMax);
1490
1503 double gapControlSpeed(SUMOTime currentTime, const SUMOVehicle* veh, double speed, double vSafe, double vMin, double vMax);
1504
1512 int influenceChangeDecision(const SUMOTime currentTime, const MSEdge& currentEdge, const int currentLaneIndex, int state);
1513
1514
1520 double changeRequestRemainingSeconds(const SUMOTime currentTime) const;
1521
1526 inline bool getRespectJunctionPriority() const {
1528 }
1529
1530
1534 inline bool getEmergencyBrakeRedLight() const {
1536 }
1537
1544 }
1545
1546
1550 }
1551
1555 void setSpeedMode(int speedMode);
1556
1560 void setLaneChangeMode(int value);
1561
1565 double getOriginalSpeed() const;
1566
1568 void setOriginalSpeed(double speed);
1569
1570 void setRemoteControlled(Position xyPos, MSLane* l, double pos, double posLat, double angle, int edgeOffset, const ConstMSEdgeVector& route, SUMOTime t);
1571
1573 return myLastRemoteAccess;
1574 }
1575
1578
1581
1583 double implicitSpeedRemote(const MSVehicle* veh, double oldSpeed);
1584
1586 double implicitDeltaPosRemote(const MSVehicle* veh);
1587
1588 bool isRemoteControlled() const;
1589
1590 bool isRemoteAffected(SUMOTime t) const;
1591
1592 void setSignals(int signals) {
1593 myTraCISignals = signals;
1594 }
1595
1596 int getSignals() const {
1597 return myTraCISignals;
1598 }
1599
1600 double getLatDist() const {
1601 return myLatDist;
1602 }
1603
1605 myLatDist = 0.;
1606 }
1607
1608 bool ignoreOverlap() const {
1610 }
1611
1612 private:
1614 std::vector<std::pair<SUMOTime, double> > mySpeedTimeLine;
1615
1617 std::vector<std::pair<SUMOTime, int> > myLaneTimeLine;
1618
1620 std::shared_ptr<GapControlState> myGapControlState;
1621
1624
1627
1630
1633
1636
1639
1642
1645
1648
1657
1659
1660
1671
1673
1674 // @brief the signals set via TraCI
1676
1677 };
1678
1679
1687
1688 const BaseInfluencer* getBaseInfluencer() const;
1689 const Influencer* getInfluencer() const;
1690
1691 bool hasInfluencer() const {
1692 return myInfluencer != nullptr;
1693 }
1694
1696 int influenceChangeDecision(int state);
1697
1699 void setRemoteState(Position xyPos);
1700
1702 static int nextLinkPriority(const std::vector<MSLane*>& conts);
1703
1705 bool isLeader(const MSLink* link, const MSVehicle* veh, const double gap) const;
1706
1707 // @brief get the position of the back bumper;
1708 const Position getBackPosition() const;
1709
1711 bool ignoreCollision() const;
1712
1714 void updateParkingState();
1715
1721
1723
1724
1726 void saveState(OutputDevice& out);
1727
1730 void loadState(const SUMOSAXAttributes& attrs, const SUMOTime offset);
1731
1732 void loadPreviousApproaching(MSLink* link, bool setRequest,
1733 SUMOTime arrivalTime, double arrivalSpeed,
1734 double arrivalSpeedBraking,
1735 double dist, double leaveSpeed);
1737
1738protected:
1739
1742
1758 void adaptLaneEntering2MoveReminder(const MSLane& enteredLane);
1760
1761
1769 void processLinkApproaches(double& vSafe, double& vSafeMin, double& vSafeMinDist);
1770
1771
1779 void processLaneAdvances(std::vector<MSLane*>& passedLanes, std::string& emergencyReason);
1780
1781
1789 double processTraCISpeedControl(double vSafe, double vNext);
1790
1791
1799
1802 void updateWaitingTime(double vNext);
1803
1806 void updateTimeLoss(double vNext);
1807
1808 /* @brief Check whether the vehicle is a train that can reverse its direction at the current point in its route
1809 * and return the speed in preparation for reversal
1810 *
1811 * @param[out] canReverse
1812 * @param[in] speedThreshold
1813 * @return speed for reversal
1814 */
1815 double checkReversal(bool& canReverse, double speedThreshold = SUMO_const_haltingSpeed, double seen = 0) const;
1816
1819 void setBrakingSignals(double vNext) ;
1820
1823 void setBlinkerInformation();
1824
1827 void setEmergencyBlueLight(SUMOTime currentTime);
1828
1830 void computeFurtherLanes(MSLane* enteredLane, double pos, bool collision = false);
1831
1833 void updateOccupancyAndCurrentBestLane(const MSLane* startLane);
1834
1836 double getBrakeGap(bool delayed = false) const;
1837
1839 Position validatePosition(Position result, double offset = 0) const;
1840
1842 virtual void drawOutsideNetwork(bool /*add*/) {};
1843
1845 void boardTransportables(MSStop& stop);
1846
1848 bool joinTrainPart(MSVehicle* veh);
1849
1851 bool joinTrainPartFront(MSVehicle* veh);
1852
1854 double slowDownForSchedule(double vMinComfortable) const;
1855
1856protected:
1857
1861
1864
1867
1870
1873
1879
1880
1881
1884
1886
1889
1890 /* @brief Complex data structure for keeping and updating LaneQ:
1891 * Each element of the outer vector corresponds to an upcoming edge on the vehicles route
1892 * The first element corresponds to the current edge and is returned in getBestLanes()
1893 * The other elements are only used as a temporary structure in updateBestLanes();
1894 */
1895 std::vector<std::vector<LaneQ> > myBestLanes;
1896
1897 /* @brief iterator to speed up retrieval of the current lane's LaneQ in getBestLaneOffset() and getBestLanesContinuation()
1898 * This is updated in updateOccupancyAndCurrentBestLane()
1899 */
1900 std::vector<LaneQ>::iterator myCurrentLaneInBestLanes;
1901
1902 static std::vector<MSLane*> myEmptyLaneVector;
1903
1906
1909 std::pair<double, const MSLink*> myNextTurn;
1910
1912 std::vector<MSLane*> myFurtherLanes;
1914 std::vector<double> myFurtherLanesPosLat;
1915
1918
1921
1924
1926
1928 double myAngle;
1929
1932
1935
1937
1942
1945
1946protected:
1947
1960 double accelV;
1963
1964 DriveProcessItem(MSLink* link, double vPass, double vWait, bool setRequest,
1965 SUMOTime arrivalTime, double arrivalSpeed,
1966 double arrivalSpeedBraking,
1967 double distance,
1968 double leaveSpeed) :
1969 myLink(link), myVLinkPass(vPass), myVLinkWait(vWait), mySetRequest(setRequest),
1970 myArrivalTime(arrivalTime), myArrivalSpeed(arrivalSpeed),
1971 myArrivalSpeedBraking(arrivalSpeedBraking),
1972 myDistance(distance),
1973 accelV(leaveSpeed), hadStoppedVehicle(false), availableSpace(0) {
1974 assert(vWait >= 0 || !MSGlobals::gSemiImplicitEulerUpdate);
1975 assert(vPass >= 0 || !MSGlobals::gSemiImplicitEulerUpdate);
1976 };
1977
1978
1980 DriveProcessItem(double vWait, double distance, double _availableSpace = 0) :
1981 myLink(0), myVLinkPass(vWait), myVLinkWait(vWait), mySetRequest(false),
1984 myDistance(distance),
1985 accelV(-1), hadStoppedVehicle(false), availableSpace(_availableSpace) {
1986 assert(vWait >= 0 || !MSGlobals::gSemiImplicitEulerUpdate);
1987 };
1988
1989
1990 inline void adaptLeaveSpeed(const double v) {
1991 if (accelV < 0) {
1992 accelV = v;
1993 } else {
1994 accelV = MIN2(accelV, v);
1995 }
1996 }
1997 inline double getLeaveSpeed() const {
1998 return accelV < 0 ? myVLinkPass : accelV;
1999 }
2000 };
2001
2003 // TODO: Consider making LFLinkLanes a std::deque for efficient front removal (needs refactoring in checkRewindLinkLanes()...)
2004 typedef std::vector< DriveProcessItem > DriveItemVector;
2005
2008
2011
2017 DriveItemVector::iterator myNextDriveItem;
2018
2020 void planMoveInternal(const SUMOTime t, MSLeaderInfo ahead, DriveItemVector& lfLinks, double& myStopDist, std::pair<double, const MSLink*>& myNextTurn) const;
2021
2023 void checkRewindLinkLanes(const double lengthsInFront, DriveItemVector& lfLinks) const;
2024
2026 void removeApproachingInformation(const DriveItemVector& lfLinks) const;
2027
2028 /* @brief adapt safe velocity in accordance to a moving obstacle:
2029 * - a leader vehicle
2030 * - a vehicle or pedestrian that crosses this vehicles path on an upcoming intersection
2031 * @param[in] leaderInfo The leading vehicle and the (virtual) distance to it
2032 * @param[in] lastLink the lastLink index
2033 * @param[in,out] the safe velocity for driving
2034 * @param[in,out] the safe velocity for arriving at the next link
2035 */
2036 void adaptToLeader(const std::pair<const MSVehicle*, double> leaderInfo,
2037 double seen,
2038 DriveProcessItem* const lastLink,
2039 double& v, double& vLinkPass) const;
2040
2042 bool brakeForOverlap(const MSLink* link, const MSLane* lane) const;
2043
2044public:
2045 void adaptToJunctionLeader(const std::pair<const MSVehicle*, double> leaderInfo,
2046 const double seen, DriveProcessItem* const lastLink,
2047 const MSLane* const lane, double& v, double& vLinkPass,
2048 double distToCrossing = -1) const;
2049
2051 bool ignoreRed(const MSLink* link, bool canBrake) const;
2052
2054 inline double accelThresholdForWaiting() const {
2055 return 0.5 * getCarFollowModel().getMaxAccel();
2056 }
2057
2058
2059protected:
2060
2061 /* @brief adapt safe velocity in accordance to multiple vehicles ahead:
2062 * @param[in] ahead The leader information according to the current lateral-resolution
2063 * @param[in] latOffset the lateral offset for locating the ego vehicle on the given lane
2064 * @param[in] seen the distance to the end of the current lane
2065 * @param[in] lastLink the lastLink index
2066 * @param[in] lane The current Lane the vehicle is on
2067 * @param[in,out] the safe velocity for driving
2068 * @param[in,out] the safe velocity for arriving at the next link
2069 */
2070 void adaptToLeaders(const MSLeaderInfo& ahead,
2071 double latOffset,
2072 const double seen, DriveProcessItem* const lastLink,
2073 const MSLane* const lane, double& v, double& vLinkPass) const;
2074
2075 void adaptToLeaderDistance(const MSLeaderDistanceInfo& ahead, double latOffset,
2076 double seen,
2077 DriveProcessItem* const lastLink,
2078 double& v, double& vLinkPass) const;
2079
2081 void checkLinkLeader(const MSLink* link, const MSLane* lane, double seen,
2082 DriveProcessItem* const lastLink, double& v, double& vLinkPass, double& vLinkWait, bool& setRequest,
2083 bool isShadowLink = false) const;
2084
2086 void checkLinkLeaderCurrentAndParallel(const MSLink* link, const MSLane* lane, double seen,
2087 DriveProcessItem* const lastLink, double& v, double& vLinkPass, double& vLinkWait, bool& setRequest) const;
2088
2089
2090 // @brief return the lane on which the back of this vehicle resides
2091 const MSLane* getBackLane() const;
2092
2100 void updateState(double vNext);
2101
2102
2104 bool keepClear(const MSLink* link) const;
2105
2107 std::pair<double, double> estimateTimeToNextStop() const;
2108
2109 /* @brief special considerations for opposite direction driving so that the
2110 * result can be used directly by getPositionOnLane(...) */
2111 double getBackPositionOnLane(const MSLane* lane, bool calledByGetPosition) const;
2112
2119 bool hasArrivedInternal(bool oppositeTransformed = true) const;
2120
2121
2122 SUMOTime getArrivalTime(SUMOTime t, double seen, double v, double arrivalSpeed) const;
2123
2125 bool isOppositeLane(const MSLane* lane) const;
2126
2128 void cleanupFurtherLanes();
2129
2130private:
2133
2136
2137
2138private:
2141
2144
2147
2148};
long long int SUMOTime
Definition: GUI.h:36
std::vector< const MSEdge * > ConstMSEdgeVector
Definition: MSEdge.h:74
std::shared_ptr< const MSRoute > ConstMSRoutePtr
Definition: Route.h:32
SUMOTime DELTA_T
Definition: SUMOTime.cpp:37
#define STEPS2TIME(x)
Definition: SUMOTime.h:54
#define TIME2STEPS(x)
Definition: SUMOTime.h:56
T MIN2(T a, T b)
Definition: StdDefs.h:76
const double SUMO_const_haltingSpeed
the speed threshold at which vehicles are considered as halting
Definition: StdDefs.h:58
Interface for lane-change models.
The base class for microscopic and mesoscopic vehicles.
Definition: MSBaseVehicle.h:55
MSVehicleType * myType
This vehicle's type.
void addStops(const bool ignoreStopErrors, MSRouteIterator *searchStart=nullptr, bool addRouteStops=true)
Adds stops to the built vehicle.
const MSVehicleType & getVehicleType() const
Returns the vehicle's type definition.
The car-following model abstraction.
Definition: MSCFModel.h:55
double getMaxAccel() const
Get the vehicle type's maximum acceleration [m/s^2].
Definition: MSCFModel.h:256
The ToC Device controls transition of control between automated and manual driving.
A device which collects info on current friction Coefficient on the road.
Abstract in-vehicle / in-person device.
Definition: MSDevice.h:61
A road/street connecting two junctions.
Definition: MSEdge.h:77
static bool gSemiImplicitEulerUpdate
Definition: MSGlobals.h:53
static SUMOTime gWaitingTimeMemory
length of memory for waiting times (in millisecs)
Definition: MSGlobals.h:112
The base class for an intersection.
Definition: MSJunction.h:58
Performs lane changing of vehicles.
Definition: MSLaneChanger.h:45
Performs lane changing of vehicles.
Representation of a lane in the micro simulation.
Definition: MSLane.h:84
saves leader/follower vehicles and their distances relative to an ego vehicle
Definition: MSLeaderInfo.h:144
Something on a lane to be noticed about vehicle movement.
Notification
Definition of a vehicle state.
Interface for objects listening to vehicle state changes.
Definition: MSNet.h:635
VehicleState
Definition of a vehicle state.
Definition: MSNet.h:602
Definition of overhead wire segment.
A lane area vehicles can halt at.
Definition: MSParkingArea.h:58
Provides an interface to an error whose fluctuation is controlled via the driver's 'awareness',...
Definition: MSStop.h:44
A lane area vehicles can halt at.
A static instance of this class in GapControlState deactivates gap control for vehicles whose referen...
Definition: MSVehicle.h:1367
void vehicleStateChanged(const SUMOVehicle *const vehicle, MSNet::VehicleState to, const std::string &info="")
Called if a vehicle changes its state.
Definition: MSVehicle.cpp:261
Changes the wished vehicle speed / lanes.
Definition: MSVehicle.h:1362
void setLaneChangeMode(int value)
Sets lane changing behavior.
Definition: MSVehicle.cpp:781
TraciLaneChangePriority myTraciLaneChangePriority
flags for determining the priority of traci lane change requests
Definition: MSVehicle.h:1672
bool getEmergencyBrakeRedLight() const
Returns whether red lights shall be a reason to brake.
Definition: MSVehicle.h:1534
SUMOTime getLaneTimeLineEnd()
Definition: MSVehicle.cpp:470
void adaptLaneTimeLine(int indexShift)
Adapts lane timeline when moving to a new lane and the lane index changes.
Definition: MSVehicle.cpp:422
void setRemoteControlled(Position xyPos, MSLane *l, double pos, double posLat, double angle, int edgeOffset, const ConstMSEdgeVector &route, SUMOTime t)
Definition: MSVehicle.cpp:792
bool isRemoteAffected(SUMOTime t) const
Definition: MSVehicle.cpp:811
int getSpeedMode() const
return the current speed mode
Definition: MSVehicle.cpp:435
void deactivateGapController()
Deactivates the gap control.
Definition: MSVehicle.cpp:409
Influencer()
Constructor.
Definition: MSVehicle.cpp:360
void setSpeedMode(int speedMode)
Sets speed-constraining behaviors.
Definition: MSVehicle.cpp:770
std::shared_ptr< GapControlState > myGapControlState
The gap control state.
Definition: MSVehicle.h:1620
bool considerSafeVelocity() const
Returns whether safe velocities shall be considered.
Definition: MSVehicle.h:1548
int getSignals() const
Definition: MSVehicle.h:1596
bool myConsiderMaxDeceleration
Whether the maximum deceleration shall be regarded.
Definition: MSVehicle.h:1638
ConstMSEdgeVector myRemoteRoute
Definition: MSVehicle.h:1655
void setLaneTimeLine(const std::vector< std::pair< SUMOTime, int > > &laneTimeLine)
Sets a new lane timeline.
Definition: MSVehicle.cpp:416
bool myRespectJunctionLeaderPriority
Whether the junction priority rules are respected (within)
Definition: MSVehicle.h:1647
void setOriginalSpeed(double speed)
Stores the originally longitudinal speed.
Definition: MSVehicle.cpp:661
double myOriginalSpeed
The velocity before influence.
Definition: MSVehicle.h:1623
double getLatDist() const
Definition: MSVehicle.h:1600
double implicitDeltaPosRemote(const MSVehicle *veh)
return the change in longitudinal position that is implicit in the new remote position
Definition: MSVehicle.cpp:928
double implicitSpeedRemote(const MSVehicle *veh, double oldSpeed)
return the speed that is implicit in the new remote position
Definition: MSVehicle.cpp:901
void postProcessRemoteControl(MSVehicle *v)
update position from remote control
Definition: MSVehicle.cpp:832
double gapControlSpeed(SUMOTime currentTime, const SUMOVehicle *veh, double speed, double vSafe, double vMin, double vMax)
Applies gap control logic on the speed.
Definition: MSVehicle.cpp:509
void setSublaneChange(double latDist)
Sets a new sublane-change request.
Definition: MSVehicle.cpp:430
double getOriginalSpeed() const
Returns the originally longitudinal speed to use.
Definition: MSVehicle.cpp:656
SUMOTime myLastRemoteAccess
Definition: MSVehicle.h:1656
std::vector< std::pair< SUMOTime, int > > myLaneTimeLine
The lane usage time line to apply.
Definition: MSVehicle.h:1617
bool getRespectJunctionLeaderPriority() const
Returns whether junction priority rules within the junction shall be respected (concerns vehicles wit...
Definition: MSVehicle.h:1542
LaneChangeMode myStrategicLC
lane changing which is necessary to follow the current route
Definition: MSVehicle.h:1661
LaneChangeMode mySpeedGainLC
lane changing to travel with higher speed
Definition: MSVehicle.h:1665
static void init()
Static initalization.
Definition: MSVehicle.cpp:385
LaneChangeMode mySublaneLC
changing to the prefered lateral alignment
Definition: MSVehicle.h:1669
bool getRespectJunctionPriority() const
Returns whether junction priority rules shall be respected (concerns approaching vehicles outside the...
Definition: MSVehicle.h:1526
static void cleanup()
Static cleanup.
Definition: MSVehicle.cpp:390
int getLaneChangeMode() const
return the current lane change mode
Definition: MSVehicle.cpp:447
SUMOTime getLaneTimeLineDuration()
Definition: MSVehicle.cpp:457
double influenceSpeed(SUMOTime currentTime, double speed, double vSafe, double vMin, double vMax)
Applies stored velocity information on the speed to use.
Definition: MSVehicle.cpp:480
double changeRequestRemainingSeconds(const SUMOTime currentTime) const
Return the remaining number of seconds of the current laneTimeLine assuming one exists.
Definition: MSVehicle.cpp:762
bool myConsiderSafeVelocity
Whether the safe velocity shall be regarded.
Definition: MSVehicle.h:1632
bool mySpeedAdaptationStarted
Whether influencing the speed has already started.
Definition: MSVehicle.h:1629
~Influencer()
Destructor.
Definition: MSVehicle.cpp:382
void setSignals(int signals)
Definition: MSVehicle.h:1592
double myLatDist
The requested lateral change.
Definition: MSVehicle.h:1626
bool myEmergencyBrakeRedLight
Whether red lights are a reason to brake.
Definition: MSVehicle.h:1644
LaneChangeMode myRightDriveLC
changing to the rightmost lane
Definition: MSVehicle.h:1667
void setSpeedTimeLine(const std::vector< std::pair< SUMOTime, double > > &speedTimeLine)
Sets a new velocity timeline.
Definition: MSVehicle.cpp:395
void updateRemoteControlRoute(MSVehicle *v)
update route if provided by remote control
Definition: MSVehicle.cpp:817
std::vector< std::pair< SUMOTime, double > > mySpeedTimeLine
The velocity time line to apply.
Definition: MSVehicle.h:1614
SUMOTime getLastAccessTimeStep() const
Definition: MSVehicle.h:1572
bool myConsiderMaxAcceleration
Whether the maximum acceleration shall be regarded.
Definition: MSVehicle.h:1635
LaneChangeMode myCooperativeLC
lane changing with the intent to help other vehicles
Definition: MSVehicle.h:1663
bool isRemoteControlled() const
Definition: MSVehicle.cpp:805
bool ignoreOverlap() const
Definition: MSVehicle.h:1608
bool myRespectJunctionPriority
Whether the junction priority rules are respected (approaching)
Definition: MSVehicle.h:1641
int influenceChangeDecision(const SUMOTime currentTime, const MSEdge &currentEdge, const int currentLaneIndex, int state)
Applies stored LaneChangeMode information and laneTimeLine.
Definition: MSVehicle.cpp:667
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,.
Definition: MSVehicle.cpp:401
Container for manouevering time associated with stopping.
Definition: MSVehicle.h:1286
SUMOTime myManoeuvreCompleteTime
Time at which this manoeuvre should complete.
Definition: MSVehicle.h:1338
MSVehicle::ManoeuvreType getManoeuvreType() const
Accessor (get) for manoeuvre type.
Definition: MSVehicle.cpp:7397
std::string myManoeuvreStop
The name of the stop associated with the Manoeuvre - for debug output.
Definition: MSVehicle.h:1332
bool manoeuvreIsComplete() const
Check if any manoeuver is ongoing and whether the completion time is beyond currentTime.
Definition: MSVehicle.cpp:7531
bool configureExitManoeuvre(MSVehicle *veh)
Setup the myManoeuvre for exiting (Sets completion time and manoeuvre type)
Definition: MSVehicle.cpp:7450
void setManoeuvreType(const MSVehicle::ManoeuvreType mType)
Accessor (set) for manoeuvre type.
Definition: MSVehicle.cpp:7413
Manoeuvre & operator=(const Manoeuvre &manoeuvre)
Assignment operator.
Definition: MSVehicle.cpp:7372
Manoeuvre()
Constructor.
Definition: MSVehicle.cpp:7361
std::string myManoeuvreVehicleID
The name of the vehicle associated with the Manoeuvre - for debug output.
Definition: MSVehicle.h:1329
ManoeuvreType myManoeuvreType
Manoeuvre type - currently entry, exit or none.
Definition: MSVehicle.h:1341
double getGUIIncrement() const
Accessor for GUI rotation step when parking (radians)
Definition: MSVehicle.cpp:7392
SUMOTime myManoeuvreStartTime
Time at which the Manoeuvre for this stop started.
Definition: MSVehicle.h:1335
bool operator!=(const Manoeuvre &manoeuvre)
Operator !=.
Definition: MSVehicle.cpp:7382
bool entryManoeuvreIsComplete(MSVehicle *veh)
Configure an entry manoeuvre if nothing is configured - otherwise check if complete.
Definition: MSVehicle.cpp:7492
bool configureEntryManoeuvre(MSVehicle *veh)
Setup the entry manoeuvre for this vehicle (Sets completion time and manoeuvre type)
Definition: MSVehicle.cpp:7419
Container that holds the vehicles driving state (position+speed).
Definition: MSVehicle.h:87
double lastCoveredDist() const
previous Speed of this state
Definition: MSVehicle.h:127
double myPosLat
the stored lateral position
Definition: MSVehicle.h:140
State(double pos, double speed, double posLat, double backPos, double previousSpeed)
Constructor.
Definition: MSVehicle.cpp:168
double myPreviousSpeed
the speed at the begin of the previous time step
Definition: MSVehicle.h:148
double myPos
the stored position
Definition: MSVehicle.h:134
bool operator!=(const State &state)
Operator !=.
Definition: MSVehicle.cpp:158
double myLastCoveredDist
Definition: MSVehicle.h:154
double mySpeed
the stored speed (should be >=0 at any time)
Definition: MSVehicle.h:137
State & operator=(const State &state)
Assignment operator.
Definition: MSVehicle.cpp:146
double posLat() const
Lateral Position of this state (m relative to the centerline of the lane).
Definition: MSVehicle.h:117
double pos() const
Position of this state.
Definition: MSVehicle.h:107
double speed() const
Speed of this state.
Definition: MSVehicle.h:112
double backPos() const
back Position of this state
Definition: MSVehicle.h:122
double myBackPos
the stored back position
Definition: MSVehicle.h:145
Stores the waiting intervals over the previous seconds (memory is to be specified in ms....
Definition: MSVehicle.h:162
void passTime(SUMOTime dt, bool waiting)
Definition: MSVehicle.cpp:202
const std::string getState() const
Definition: MSVehicle.cpp:234
SUMOTime cumulatedWaitingTime(SUMOTime memory=-1) const
Definition: MSVehicle.cpp:180
std::deque< std::pair< SUMOTime, SUMOTime > > myWaitingIntervals
Definition: MSVehicle.h:184
void setState(const std::string &state)
Definition: MSVehicle.cpp:245
SUMOTime myMemorySize
the maximal memory to store
Definition: MSVehicle.h:179
void appendWaitingTime(SUMOTime dt)
append an amount of dt millisecs to the stored waiting times
WaitingTimeCollector(SUMOTime memory=MSGlobals::gWaitingTimeMemory)
Constructor.
Definition: MSVehicle.cpp:176
Representation of a vehicle in the micro simulation.
Definition: MSVehicle.h:77
void setManoeuvreType(const MSVehicle::ManoeuvreType mType)
accessor function to myManoeuvre equivalent
Definition: MSVehicle.cpp:7408
TraciLaneChangePriority
modes for prioritizing traci lane change requests
Definition: MSVehicle.h:1164
@ LCP_NOOVERLAP
Definition: MSVehicle.h:1166
@ LCP_OPPORTUNISTIC
Definition: MSVehicle.h:1168
const std::vector< double > & getFurtherLanesPosLat() const
Definition: MSVehicle.h:849
double getRightSideOnEdge(const MSLane *lane=0) const
Get the vehicle's lateral position on the edge of the given lane (or its current edge if lane == 0)
Definition: MSVehicle.cpp:6430
bool wasRemoteControlled(SUMOTime lookBack=DELTA_T) const
Returns the information whether the vehicle is fully controlled via TraCI within the lookBack time.
Definition: MSVehicle.cpp:6999
void processLinkApproaches(double &vSafe, double &vSafeMin, double &vSafeMinDist)
This method iterates through the driveprocess items for the vehicle and adapts the given in/out param...
Definition: MSVehicle.cpp:3404
SUMOTime getTimeSinceStartup() const
Returns the SUMOTime spent driving since startup (speed was larger than 0.1m/s)
Definition: MSVehicle.h:680
void checkLinkLeader(const MSLink *link, const MSLane *lane, double seen, DriveProcessItem *const lastLink, double &v, double &vLinkPass, double &vLinkWait, bool &setRequest, bool isShadowLink=false) const
checks for link leaders on the given link
Definition: MSVehicle.cpp:3253
void checkRewindLinkLanes(const double lengthsInFront, DriveItemVector &lfLinks) const
runs heuristic for keeping the intersection clear in case of downstream jamming
Definition: MSVehicle.cpp:4868
MSVehicle(const MSVehicle &)
invalidated copy constructor
bool willStop() const
Returns whether the vehicle will stop on the current edge.
Definition: MSVehicle.cpp:1563
bool hasDriverState() const
Whether this vehicle is equipped with a MSDriverState.
Definition: MSVehicle.h:1016
static int nextLinkPriority(const std::vector< MSLane * > &conts)
get a numerical value for the priority of the upcoming link
Definition: MSVehicle.cpp:5967
double getTimeGapOnLane() const
Returns the time gap in seconds to the leader of the vehicle on the same lane.
Definition: MSVehicle.cpp:6288
void updateBestLanes(bool forceRebuild=false, const MSLane *startLane=0)
computes the best lanes to use in order to continue the route
Definition: MSVehicle.cpp:5534
bool myAmIdling
Whether the vehicle is trying to enter the network (eg after parking so engine is running)
Definition: MSVehicle.h:1923
SUMOTime myWaitingTime
The time the vehicle waits (is not faster than 0.1m/s) in seconds.
Definition: MSVehicle.h:1859
double getStopDelay() const
Returns the public transport stop delay in seconds.
Definition: MSVehicle.cpp:7634
double computeAngle() const
compute the current vehicle angle
Definition: MSVehicle.cpp:1405
double myTimeLoss
the time loss in seconds due to driving with less than maximum speed
Definition: MSVehicle.h:1863
SUMOTime myLastActionTime
Action offset (actions are taken at time myActionOffset + N*getActionStepLength()) Initialized to 0,...
Definition: MSVehicle.h:1878
ConstMSEdgeVector::const_iterator getRerouteOrigin() const
Returns the starting point for reroutes (usually the current edge)
Definition: MSVehicle.cpp:1345
bool hasArrivedInternal(bool oppositeTransformed=true) const
Returns whether this vehicle has already arived (reached the arrivalPosition on its final edge) metho...
Definition: MSVehicle.cpp:1084
double getFriction() const
Returns the current friction on the road as perceived by the friction device.
Definition: MSVehicle.cpp:7328
bool replaceParkingArea(MSParkingArea *parkingArea, std::string &errorMsg)
replace the current parking area stop with a new stop with merge duration
Definition: MSVehicle.cpp:1502
void boardTransportables(MSStop &stop)
board persons and load transportables at the given stop
Definition: MSVehicle.cpp:1870
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...
Definition: MSVehicle.cpp:6033
bool isOnRoad() const
Returns the information whether the vehicle is on a road (is simulated)
Definition: MSVehicle.h:606
void adaptLaneEntering2MoveReminder(const MSLane &enteredLane)
Adapts the vehicle's entering of a new lane.
Definition: MSVehicle.cpp:1167
void addTransportable(MSTransportable *transportable)
Adds a person or container to this vehicle.
Definition: MSVehicle.cpp:6299
MSParkingArea * getNextParkingArea()
get the upcoming parking area stop or nullptr
Definition: MSVehicle.cpp:1539
SUMOTime myJunctionConflictEntryTime
Definition: MSVehicle.h:1941
SUMOTime getLastActionTime() const
Returns the time of the vehicle's last action point.
Definition: MSVehicle.h:544
double getLeftSideOnEdge(const MSLane *lane=0) const
Get the vehicle's lateral position on the edge of the given lane (or its current edge if lane == 0)
Definition: MSVehicle.cpp:6436
PositionVector getBoundingPoly(double offset=0) const
get bounding polygon
Definition: MSVehicle.cpp:6716
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...
Definition: MSVehicle.cpp:6397
bool brakeForOverlap(const MSLink *link, const MSLane *lane) const
handle with transitions
Definition: MSVehicle.cpp:2098
SUMOTime getWaitingTime() const
Returns the SUMOTime waited (speed was lesser than 0.1m/s)
Definition: MSVehicle.h:670
void workOnMoveReminders(double oldPos, double newPos, double newSpeed)
Processes active move reminder.
Definition: MSVehicle.cpp:1108
bool isStoppedOnLane() const
Definition: MSVehicle.cpp:1568
double myAcceleration
The current acceleration after dawdling in m/s.
Definition: MSVehicle.h:1905
void registerInsertionApproach(MSLink *link, double dist)
register approach on insertion
Definition: MSVehicle.cpp:5136
SUMOTime getTimeLoss() const
Returns the SUMOTime lost (speed was lesser maximum speed)
Definition: MSVehicle.h:697
void cleanupFurtherLanes()
remove vehicle from further lanes (on leaving the network)
Definition: MSVehicle.cpp:1003
void adaptToLeaders(const MSLeaderInfo &ahead, double latOffset, const double seen, DriveProcessItem *const lastLink, const MSLane *const lane, double &v, double &vLinkPass) const
Definition: MSVehicle.cpp:2949
bool isActive() const
Returns whether the current simulation step is an action point for the vehicle.
Definition: MSVehicle.h:629
const MSLane * getBackLane() const
Definition: MSVehicle.cpp:4666
double getTimeLossSeconds() const
Returns the time loss in seconds.
Definition: MSVehicle.h:721
void enterLaneAtInsertion(MSLane *enteredLane, double pos, double speed, double posLat, MSMoveReminder::Notification notification)
Update when the vehicle enters a new lane in the emit step.
Definition: MSVehicle.cpp:5384
double getBackPositionOnLane() const
Get the vehicle's position relative to its current lane.
Definition: MSVehicle.h:408
void setPreviousSpeed(double prevSpeed, double prevAcceleration)
Sets the influenced previous speed.
Definition: MSVehicle.cpp:7334
const std::pair< double, const MSLink * > & getNextTurn()
Get the distance and direction of the next upcoming turn for the vehicle (within its look-ahead range...
Definition: MSVehicle.h:837
SUMOTime getArrivalTime(SUMOTime t, double seen, double v, double arrivalSpeed) const
Definition: MSVehicle.cpp:2930
double getAccumulatedWaitingSeconds() const
Returns the number of seconds waited (speed was lesser than 0.1m/s) within the last millisecs.
Definition: MSVehicle.h:715
bool isFrontOnLane(const MSLane *lane) const
Returns the information whether the front of the vehicle is on the given lane.
Definition: MSVehicle.cpp:4862
virtual ~MSVehicle()
Destructor.
Definition: MSVehicle.cpp:991
double getTimeSinceStartupSeconds() const
Definition: MSVehicle.h:684
void processLaneAdvances(std::vector< MSLane * > &passedLanes, std::string &emergencyReason)
This method checks if the vehicle has advanced over one or several lanes along its route and triggers...
Definition: MSVehicle.cpp:4110
MSAbstractLaneChangeModel & getLaneChangeModel()
Definition: MSVehicle.cpp:5510
void setEmergencyBlueLight(SUMOTime currentTime)
sets the blue flashing light for emergency vehicles
Definition: MSVehicle.cpp:6377
bool isActionStep(SUMOTime t) const
Returns whether the next simulation step will be an action point for the vehicle.
Definition: MSVehicle.h:636
MSAbstractLaneChangeModel * myLaneChangeModel
Definition: MSVehicle.h:1885
Position getPositionAlongBestLanes(double offset) const
Return the (x,y)-position, which the vehicle would reach if it continued along its best continuation ...
Definition: MSVehicle.cpp:1249
bool hasValidRouteStart(std::string &msg)
checks wether the vehicle can depart on the first edge
Definition: MSVehicle.cpp:1046
double getLeftSideOnLane() const
Get the lateral position of the vehicles left side on the lane:
Definition: MSVehicle.cpp:6412
std::vector< MSLane * > myFurtherLanes
The information into which lanes the vehicle laps into.
Definition: MSVehicle.h:1912
bool signalSet(int which) const
Returns whether the given signal is on.
Definition: MSVehicle.h:1200
MSCFModel::VehicleVariables * myCFVariables
The per vehicle variables of the car following model.
Definition: MSVehicle.h:2132
double getActionStepLengthSecs() const
Returns the vehicle's action step length in secs, i.e. the interval between two action points.
Definition: MSVehicle.h:536
bool addTraciStop(SUMOVehicleParameter::Stop stop, std::string &errorMsg)
Definition: MSVehicle.cpp:6841
void checkLinkLeaderCurrentAndParallel(const MSLink *link, const MSLane *lane, double seen, DriveProcessItem *const lastLink, double &v, double &vLinkPass, double &vLinkWait, bool &setRequest) const
checks for link leaders of the current link as well as the parallel link (if there is one)
Definition: MSVehicle.cpp:3237
void planMoveInternal(const SUMOTime t, MSLeaderInfo ahead, DriveItemVector &lfLinks, double &myStopDist, std::pair< double, const MSLink * > &myNextTurn) const
Definition: MSVehicle.cpp:2133
std::pair< double, const MSLink * > myNextTurn
the upcoming turn for the vehicle
Definition: MSVehicle.h:1909
int influenceChangeDecision(int state)
allow TraCI to influence a lane change decision
Definition: MSVehicle.cpp:6974
double getMaxSpeedOnLane() const
Returns the maximal speed for the vehicle on its current lane (including speed factor and deviation,...
Definition: MSVehicle.cpp:1315
bool isRemoteControlled() const
Returns the information whether the vehicle is fully controlled via TraCI.
Definition: MSVehicle.cpp:6993
bool myAmOnNet
Whether the vehicle is on the network (not parking, teleported, vaporized, or arrived)
Definition: MSVehicle.h:1920
double nextStopDist() const
return the distance to the next stop or doubleMax if there is none.
Definition: MSVehicle.h:1049
void enterLaneAtMove(MSLane *enteredLane, bool onTeleporting=false)
Update when the vehicle enters a new lane in the move step.
Definition: MSVehicle.cpp:5180
void adaptBestLanesOccupation(int laneIndex, double density)
update occupation from MSLaneChanger
Definition: MSVehicle.cpp:6196
std::pair< double, double > estimateTimeToNextStop() const
return time (s) and distance to the next stop
Definition: MSVehicle.cpp:7540
double accelThresholdForWaiting() const
maximum acceleration to consider a vehicle as 'waiting' at low speed
Definition: MSVehicle.h:2054
void setAngle(double angle, bool straightenFurther=false)
Set a custom vehicle angle in rad, optionally updates furtherLanePosLat.
Definition: MSVehicle.cpp:1358
std::vector< LaneQ >::iterator myCurrentLaneInBestLanes
Definition: MSVehicle.h:1900
MSVehicle & operator=(const MSVehicle &)
invalidated assignment operator
double getDeltaPos(const double accel) const
calculates the distance covered in the next integration step given an acceleration and assuming the c...
Definition: MSVehicle.cpp:3382
const MSLane * myLastBestLanesInternalLane
Definition: MSVehicle.h:1888
void updateOccupancyAndCurrentBestLane(const MSLane *startLane)
updates LaneQ::nextOccupation and myCurrentLaneInBestLanes
Definition: MSVehicle.cpp:5983
const std::vector< MSLane * > getUpstreamOppositeLanes() const
Returns the sequence of opposite lanes corresponding to past lanes.
Definition: MSVehicle.cpp:6160
WaitingTimeCollector myWaitingTimeCollector
Definition: MSVehicle.h:1860
void setRemoteState(Position xyPos)
sets position outside the road network
Definition: MSVehicle.cpp:6987
void fixPosition()
repair errors in vehicle position after changing between internal edges
Definition: MSVehicle.cpp:6204
double getAcceleration() const
Returns the vehicle's acceleration in m/s (this is computed as the last step's mean acceleration in c...
Definition: MSVehicle.h:517
double getSpeedWithoutTraciInfluence() const
Returns the uninfluenced velocity.
Definition: MSVehicle.cpp:6964
PositionVector getBoundingBox(double offset=0) const
get bounding rectangle
Definition: MSVehicle.cpp:6685
ManoeuvreType
flag identifying which, if any, manoeuvre is in progress
Definition: MSVehicle.h:1259
@ MANOEUVRE_ENTRY
Manoeuvre into stopping place.
Definition: MSVehicle.h:1261
@ MANOEUVRE_NONE
not manouevring
Definition: MSVehicle.h:1265
@ MANOEUVRE_EXIT
Manoeuvre out of stopping place.
Definition: MSVehicle.h:1263
const MSEdge * getNextEdgePtr() const
returns the next edge (possibly an internal edge)
Definition: MSVehicle.cpp:7676
Position getPosition(const double offset=0) const
Return current position (x/y, cartesian)
Definition: MSVehicle.cpp:1216
void setBrakingSignals(double vNext)
sets the braking lights on/off
Definition: MSVehicle.cpp:3917
const std::vector< MSLane * > & getBestLanesContinuation() const
Returns the best sequence of lanes to continue the route starting at myLane.
Definition: MSVehicle.cpp:6005
MSParkingArea * getCurrentParkingArea()
get the current parking area stop or nullptr
Definition: MSVehicle.cpp:1553
const MSEdge * myLastBestLanesEdge
Definition: MSVehicle.h:1887
bool ignoreCollision() const
whether this vehicle is except from collision checks
Definition: MSVehicle.cpp:1602
Influencer * myInfluencer
An instance of a velocity/lane influencing instance; built in "getInfluencer".
Definition: MSVehicle.h:2135
void saveState(OutputDevice &out)
Saves the states of a vehicle.
Definition: MSVehicle.cpp:7215
void setIdling(bool amIdling)
access function for Idling flag used to record whether vehicle is waiting to enter lane (after parkin...
Definition: MSVehicle.h:614
void onRemovalFromNet(const MSMoveReminder::Notification reason)
Called when the vehicle is removed from the network.
Definition: MSVehicle.cpp:1020
void planMove(const SUMOTime t, const MSLeaderInfo &ahead, const double lengthsInFront)
Compute safe velocities for the upcoming lanes based on positions and speeds from the last time step....
Definition: MSVehicle.cpp:2028
bool resumeFromStopping()
Definition: MSVehicle.cpp:6879
int getBestLaneOffset() const
Definition: MSVehicle.cpp:6176
void adaptToJunctionLeader(const std::pair< const MSVehicle *, double > leaderInfo, const double seen, DriveProcessItem *const lastLink, const MSLane *const lane, double &v, double &vLinkPass, double distToCrossing=-1) const
Definition: MSVehicle.cpp:3139
double lateralDistanceToLane(const int offset) const
Get the minimal lateral distance required to move fully onto the lane at given offset.
Definition: MSVehicle.cpp:6558
double getBackPositionOnLane(const MSLane *lane) const
Get the vehicle's position relative to the given lane.
Definition: MSVehicle.h:401
void resetActionOffset(const SUMOTime timeUntilNextAction=0)
Resets the action offset for the vehicle.
Definition: MSVehicle.cpp:2003
std::vector< DriveProcessItem > DriveItemVector
Container for used Links/visited Lanes during planMove() and executeMove.
Definition: MSVehicle.h:2004
void setBlinkerInformation()
sets the blue flashing light for emergency vehicles
Definition: MSVehicle.cpp:6316
const MSEdge * getCurrentEdge() const
Returns the edge the vehicle is currently at (possibly an internal edge or nullptr)
Definition: MSVehicle.cpp:7671
void adaptToLeaderDistance(const MSLeaderDistanceInfo &ahead, double latOffset, double seen, DriveProcessItem *const lastLink, double &v, double &vLinkPass) const
Definition: MSVehicle.cpp:3028
DriveItemVector::iterator myNextDriveItem
iterator pointing to the next item in myLFLinkLanes
Definition: MSVehicle.h:2017
void leaveLane(const MSMoveReminder::Notification reason, const MSLane *approachedLane=0)
Update of members if vehicle leaves a new lane in the lane change step or at arrival.
Definition: MSVehicle.cpp:5424
bool isIdling() const
Returns whether a sim vehicle is waiting to enter a lane (after parking has completed)
Definition: MSVehicle.h:622
std::shared_ptr< MSSimpleDriverState > getDriverState() const
Returns the vehicle driver's state.
Definition: MSVehicle.cpp:7322
void removeApproachingInformation(const DriveItemVector &lfLinks) const
unregister approach from all upcoming links
Definition: MSVehicle.cpp:6620
void replaceVehicleType(MSVehicleType *type)
Replaces the current vehicle type by the one given.
Definition: MSVehicle.cpp:4658
SUMOTime myJunctionEntryTimeNeverYield
Definition: MSVehicle.h:1940
double getLatOffset(const MSLane *lane) const
Get the offset that that must be added to interpret myState.myPosLat for the given lane.
Definition: MSVehicle.cpp:6485
bool rerouteParkingArea(const std::string &parkingAreaID, std::string &errorMsg)
Definition: MSVehicle.cpp:6765
bool hasArrived() const
Returns whether this vehicle has already arived (reached the arrivalPosition on its final edge)
Definition: MSVehicle.cpp:1078
void switchOffSignal(int signal)
Switches the given signal off.
Definition: MSVehicle.h:1183
void updateState(double vNext)
updates the vehicles state, given a next value for its speed. This value can be negative in case of t...
Definition: MSVehicle.cpp:4589
double getStopArrivalDelay() const
Returns the estimated public transport stop arrival delay in seconds.
Definition: MSVehicle.cpp:7655
int getSignals() const
Returns the signals.
Definition: MSVehicle.h:1191
int mySignals
State of things of the vehicle that can be on or off.
Definition: MSVehicle.h:1917
bool setExitManoeuvre()
accessor function to myManoeuvre equivalent
Definition: MSVehicle.cpp:7353
bool isOppositeLane(const MSLane *lane) const
whether the give lane is reverse direction of the current route or not
Definition: MSVehicle.cpp:5521
double myStopDist
distance to the next stop or doubleMax if there is none
Definition: MSVehicle.h:1931
Signalling
Some boolean values which describe the state of some vehicle parts.
Definition: MSVehicle.h:1118
@ VEH_SIGNAL_EMERGENCY_RED
A red emergency light is on.
Definition: MSVehicle.h:1146
@ VEH_SIGNAL_NONE
Everything is switched off.
Definition: MSVehicle.h:1120
@ VEH_SIGNAL_FOGLIGHT
The fog lights are on (no visualisation)
Definition: MSVehicle.h:1132
@ VEH_SIGNAL_FRONTLIGHT
The front lights are on (no visualisation)
Definition: MSVehicle.h:1130
@ VEH_SIGNAL_DOOR_OPEN_LEFT
One of the left doors is opened.
Definition: MSVehicle.h:1140
@ VEH_SIGNAL_BLINKER_RIGHT
Right blinker lights are switched on.
Definition: MSVehicle.h:1122
@ VEH_SIGNAL_BRAKELIGHT
The brake lights are on.
Definition: MSVehicle.h:1128
@ VEH_SIGNAL_BACKDRIVE
The backwards driving lights are on (no visualisation)
Definition: MSVehicle.h:1136
@ VEH_SIGNAL_EMERGENCY_BLUE
A blue emergency light is on.
Definition: MSVehicle.h:1144
@ VEH_SIGNAL_BLINKER_LEFT
Left blinker lights are switched on.
Definition: MSVehicle.h:1124
@ VEH_SIGNAL_DOOR_OPEN_RIGHT
One of the right doors is opened.
Definition: MSVehicle.h:1142
@ VEH_SIGNAL_BLINKER_EMERGENCY
Blinker lights on both sides are switched on.
Definition: MSVehicle.h:1126
@ VEH_SIGNAL_WIPER
The wipers are on.
Definition: MSVehicle.h:1138
@ VEH_SIGNAL_EMERGENCY_YELLOW
A yellow emergency light is on.
Definition: MSVehicle.h:1148
@ VEH_SIGNAL_HIGHBEAM
The high beam lights are on (no visualisation)
Definition: MSVehicle.h:1134
SUMOTime getActionStepLength() const
Returns the vehicle's action step length in millisecs, i.e. the interval between two action points.
Definition: MSVehicle.h:528
bool myHaveToWaitOnNextLink
Definition: MSVehicle.h:1925
SUMOTime collisionStopTime() const
Returns the remaining time a vehicle needs to stop due to a collision. A negative value indicates tha...
Definition: MSVehicle.cpp:1596
const std::vector< const MSLane * > getPastLanesUntil(double distance) const
Returns the sequence of past lanes (right-most on edge) based on the route starting at the current la...
Definition: MSVehicle.cpp:6102
double getBestLaneDist() const
returns the distance that can be driven without lane change
Definition: MSVehicle.cpp:6185
std::pair< const MSVehicle *const, double > getLeader(double dist=0) const
Returns the leader of the vehicle looking for a fixed distance.
Definition: MSVehicle.cpp:6246
double slowDownForSchedule(double vMinComfortable) const
optionally return an upper bound on speed to stay within the schedule
Definition: MSVehicle.cpp:2891
bool executeMove()
Executes planned vehicle movements with regards to right-of-way.
Definition: MSVehicle.cpp:4274
const MSLane * getLane() const
Returns the lane the vehicle is on.
Definition: MSVehicle.h:584
std::pair< const MSVehicle *const, double > getFollower(double dist=0) const
Returns the follower of the vehicle looking for a fixed distance.
Definition: MSVehicle.cpp:6276
double getLastStepDist() const
Get the distance the vehicle covered in the previous timestep.
Definition: MSVehicle.h:384
void invalidateCachedPosition()
Definition: MSVehicle.h:424
ChangeRequest
Requests set via TraCI.
Definition: MSVehicle.h:194
@ REQUEST_HOLD
vehicle want's to keep the current lane
Definition: MSVehicle.h:202
@ REQUEST_LEFT
vehicle want's to change to left lane
Definition: MSVehicle.h:198
@ REQUEST_NONE
vehicle doesn't want to change
Definition: MSVehicle.h:196
@ REQUEST_RIGHT
vehicle want's to change to right lane
Definition: MSVehicle.h:200
bool isLeader(const MSLink *link, const MSVehicle *veh, const double gap) const
whether the given vehicle must be followed at the given junction
Definition: MSVehicle.cpp:7077
void computeFurtherLanes(MSLane *enteredLane, double pos, bool collision=false)
updates myFurtherLanes on lane insertion or after collision
Definition: MSVehicle.cpp:5326
MSLane * getMutableLane() const
Returns the lane the vehicle is on Non const version indicates that something volatile is going on.
Definition: MSVehicle.h:592
std::pair< const MSLane *, double > getLanePosAfterDist(double distance) const
return lane and position along bestlanes at the given distance
Definition: MSVehicle.cpp:6211
SUMOTime myCollisionImmunity
amount of time for which the vehicle is immune from collisions
Definition: MSVehicle.h:1934
bool passingMinor() const
decide whether the vehicle is passing a minor link or has comitted to do so
Definition: MSVehicle.cpp:7061
void updateWaitingTime(double vNext)
Updates the vehicle's waiting time counters (accumulated and consecutive)
Definition: MSVehicle.cpp:3936
void enterLaneAtLaneChange(MSLane *enteredLane)
Update when the vehicle enters a new lane in the laneChange step.
Definition: MSVehicle.cpp:5240
BaseInfluencer & getBaseInfluencer()
Returns the velocity/lane influencer.
Definition: MSVehicle.cpp:6947
Influencer & getInfluencer()
Definition: MSVehicle.cpp:6939
double getRightSideOnLane() const
Get the lateral position of the vehicles right side on the lane:
Definition: MSVehicle.cpp:6406
bool unsafeLinkAhead(const MSLane *lane) const
whether the vehicle may safely move to the given lane with regard to upcoming links
Definition: MSVehicle.cpp:6632
double getCurrentApparentDecel() const
get apparent deceleration based on vType parameters and current acceleration
Definition: MSVehicle.cpp:7346
double updateFurtherLanes(std::vector< MSLane * > &furtherLanes, std::vector< double > &furtherLanesPosLat, const std::vector< MSLane * > &passedLanes)
update a vector of further lanes and return the new backPos
Definition: MSVehicle.cpp:4676
DriveItemVector myLFLinkLanesPrev
planned speeds from the previous step for un-registering from junctions after the new container is fi...
Definition: MSVehicle.h:2010
std::vector< std::vector< LaneQ > > myBestLanes
Definition: MSVehicle.h:1895
void setActionStepLength(double actionStepLength, bool resetActionOffset=true)
Sets the action steplength of the vehicle.
Definition: MSVehicle.cpp:1382
double getLateralPositionOnLane() const
Get the vehicle's lateral position on the lane.
Definition: MSVehicle.h:416
double getSlope() const
Returns the slope of the road at vehicle's position in degrees.
Definition: MSVehicle.cpp:1189
bool myActionStep
The flag myActionStep indicates whether the current time step is an action point for the vehicle.
Definition: MSVehicle.h:1875
const Position getBackPosition() const
Definition: MSVehicle.cpp:1469
bool congested() const
Definition: MSVehicle.cpp:1399
void loadState(const SUMOSAXAttributes &attrs, const SUMOTime offset)
Loads the state of this vehicle from the given description.
Definition: MSVehicle.cpp:7260
SUMOTime myTimeSinceStartup
duration of driving (speed > SUMO_const_haltingSpeed) after the last halting eposide
Definition: MSVehicle.h:1944
double getSpeed() const
Returns the vehicle's current speed.
Definition: MSVehicle.h:493
void setApproachingForAllLinks(const SUMOTime t)
Register junction approaches for all link items in the current plan.
Definition: MSVehicle.cpp:5083
SUMOTime getAccumulatedWaitingTime() const
Returns the SUMOTime waited (speed was lesser than 0.1m/s) within the last t millisecs.
Definition: MSVehicle.h:706
SUMOTime remainingStopDuration() const
Returns the remaining stop duration for a stopped vehicle or 0.
Definition: MSVehicle.cpp:1587
bool keepStopping(bool afterProcessing=false) const
Returns whether the vehicle is stopped and must continue to do so.
Definition: MSVehicle.cpp:1573
void workOnIdleReminders()
cycle through vehicle devices invoking notifyIdle
Definition: MSVehicle.cpp:1151
static std::vector< MSLane * > myEmptyLaneVector
Definition: MSVehicle.h:1902
Position myCachedPosition
Definition: MSVehicle.h:1936
bool replaceRoute(ConstMSRoutePtr 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.
Definition: MSVehicle.cpp:1093
MSVehicle::ManoeuvreType getManoeuvreType() const
accessor function to myManoeuvre equivalent
Definition: MSVehicle.cpp:7402
double checkReversal(bool &canReverse, double speedThreshold=SUMO_const_haltingSpeed, double seen=0) const
Definition: MSVehicle.cpp:3960
void removePassedDriveItems()
Erase passed drive items from myLFLinkLanes (and unregister approaching information for corresponding...
Definition: MSVehicle.cpp:3703
const std::vector< MSLane * > & getFurtherLanes() const
Definition: MSVehicle.h:845
const std::vector< LaneQ > & getBestLanes() const
Returns the description of best lanes to use in order to continue the route.
Definition: MSVehicle.cpp:5528
std::vector< double > myFurtherLanesPosLat
lateral positions on further lanes
Definition: MSVehicle.h:1914
bool checkActionStep(const SUMOTime t)
Returns whether the vehicle is supposed to take action in the current simulation step Updates myActio...
Definition: MSVehicle.cpp:1993
const MSCFModel & getCarFollowModel() const
Returns the vehicle's car following model definition.
Definition: MSVehicle.h:973
Position validatePosition(Position result, double offset=0) const
ensure that a vehicle-relative position is not invalid
Definition: MSVehicle.cpp:1324
void loadPreviousApproaching(MSLink *link, bool setRequest, SUMOTime arrivalTime, double arrivalSpeed, double arrivalSpeedBraking, double dist, double leaveSpeed)
Definition: MSVehicle.cpp:7310
bool keepClear(const MSLink *link) const
decide whether the given link must be kept clear
Definition: MSVehicle.cpp:7005
bool manoeuvreIsComplete() const
accessor function to myManoeuvre equivalent
Definition: MSVehicle.cpp:7535
double processNextStop(double currentVelocity)
Processes stops, returns the velocity needed to reach the stop.
Definition: MSVehicle.cpp:1608
double myAngle
the angle in radians (
Definition: MSVehicle.h:1928
bool ignoreRed(const MSLink *link, bool canBrake) const
decide whether a red (or yellow light) may be ignore
Definition: MSVehicle.cpp:7017
double getPositionOnLane() const
Get the vehicle's position along the lane.
Definition: MSVehicle.h:377
void updateTimeLoss(double vNext)
Updates the vehicle's time loss.
Definition: MSVehicle.cpp:3948
MSDevice_DriverState * myDriverState
This vehicle's driver state.
Definition: MSVehicle.h:1869
bool joinTrainPart(MSVehicle *veh)
try joining the given vehicle to the rear of this one (to resolve joinTriggered)
Definition: MSVehicle.cpp:1925
MSLane * myLane
The lane the vehicle is on.
Definition: MSVehicle.h:1883
bool onFurtherEdge(const MSEdge *edge) const
whether this vehicle has its back (and no its front) on the given edge
Definition: MSVehicle.cpp:6755
double processTraCISpeedControl(double vSafe, double vNext)
Check for speed advices from the traci client and adjust the speed vNext in the current (euler) / aft...
Definition: MSVehicle.cpp:3674
Manoeuvre myManoeuvre
Definition: MSVehicle.h:1348
double getLateralOverlap() const
return the amount by which the vehicle extends laterally outside it's primary lane
Definition: MSVehicle.cpp:6614
double getAngle() const
Returns the vehicle's direction in radians.
Definition: MSVehicle.h:736
bool handleCollisionStop(MSStop &stop, const double distToStop)
Definition: MSVehicle.cpp:6852
bool hasInfluencer() const
whether the vehicle is individually influenced (via TraCI or special parameters)
Definition: MSVehicle.h:1691
MSDevice_Friction * myFrictionDevice
This vehicle's friction perception.
Definition: MSVehicle.h:1872
double getPreviousSpeed() const
Returns the vehicle's speed before the previous time step.
Definition: MSVehicle.h:501
MSCFModel::VehicleVariables * getCarFollowVariables() const
Returns the vehicle's car following model variables.
Definition: MSVehicle.h:994
MSVehicle()
invalidated default constructor
bool joinTrainPartFront(MSVehicle *veh)
try joining the given vehicle to the front of this one (to resolve joinTriggered)
Definition: MSVehicle.cpp:1946
void updateActionOffset(const SUMOTime oldActionStepLength, const SUMOTime newActionStepLength)
Process an updated action step length value (only affects the vehicle's action offset,...
Definition: MSVehicle.cpp:2009
double getBrakeGap(bool delayed=false) const
get distance for coming to a stop (used for rerouting checks)
Definition: MSVehicle.cpp:1987
void executeFractionalMove(double dist)
move vehicle forward by the given distance during insertion
Definition: MSVehicle.cpp:4532
LaneChangeMode
modes for resolving conflicts between external control (traci) and vehicle control over lane changing...
Definition: MSVehicle.h:1156
@ LC_NOCONFLICT
Definition: MSVehicle.h:1158
virtual void drawOutsideNetwork(bool)
register vehicle for drawing while outside the network
Definition: MSVehicle.h:1842
void initDevices()
Definition: MSVehicle.cpp:1036
State myState
This Vehicles driving state (pos and speed)
Definition: MSVehicle.h:1866
double getCenterOnEdge(const MSLane *lane=0) const
Get the vehicle's lateral position on the edge of the given lane (or its current edge if lane == 0)
Definition: MSVehicle.cpp:6442
void setLateralPositionOnLane(double posLat)
Definition: MSVehicle.h:420
void adaptToLeader(const std::pair< const MSVehicle *, double > leaderInfo, double seen, DriveProcessItem *const lastLink, double &v, double &vLinkPass) const
Definition: MSVehicle.cpp:3060
void activateReminders(const MSMoveReminder::Notification reason, const MSLane *enteredLane=0)
"Activates" all current move reminder
Definition: MSVehicle.cpp:5147
double getDistanceToPosition(double destPos, const MSEdge *destEdge) const
Definition: MSVehicle.cpp:6228
void switchOnSignal(int signal)
Switches the given signal on.
Definition: MSVehicle.h:1175
static bool overlap(const MSVehicle *veh1, const MSVehicle *veh2)
Definition: MSVehicle.h:764
int getLaneIndex() const
Definition: MSVehicle.cpp:6391
void updateParkingState()
update state while parking
Definition: MSVehicle.cpp:4642
DriveItemVector myLFLinkLanes
container for the planned speeds in the current step
Definition: MSVehicle.h:2007
void updateDriveItems()
Check whether the drive items (myLFLinkLanes) are up to date, and update them if required.
Definition: MSVehicle.cpp:3757
Position getVelocityVector() const
Returns the vehicle's direction in radians.
Definition: MSVehicle.h:744
SUMOTime myJunctionEntryTime
time at which the current junction was entered
Definition: MSVehicle.h:1939
The car-following model and parameter.
Definition: MSVehicleType.h:63
double getLengthWithGap() const
Get vehicle's length including the minimum gap [m].
double getActionStepLengthSecs() const
Returns this type's default action step length in seconds.
const MSCFModel & getCarFollowModel() const
Returns the vehicle type's car following model definition (const version)
SUMOTime getActionStepLength() const
Returns this type's default action step length.
Static storage of an output device and its base (abstract) implementation.
Definition: OutputDevice.h:61
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:37
static const Position INVALID
used to indicate that a position is valid
Definition: Position.h:300
A list of positions.
Encapsulated SAX-Attributes.
Representation of a vehicle.
Definition: SUMOVehicle.h:62
Definition of vehicle stop (position and duration)
Structure representing possible vehicle parameter.
Drive process items represent bounds on the safe velocity corresponding to the upcoming links.
Definition: MSVehicle.h:1951
DriveProcessItem(MSLink *link, double vPass, double vWait, bool setRequest, SUMOTime arrivalTime, double arrivalSpeed, double arrivalSpeedBraking, double distance, double leaveSpeed)
Definition: MSVehicle.h:1964
double getLeaveSpeed() const
Definition: MSVehicle.h:1997
DriveProcessItem(double vWait, double distance, double _availableSpace=0)
constructor if the link shall not be passed
Definition: MSVehicle.h:1980
void adaptLeaveSpeed(const double v)
Definition: MSVehicle.h:1990
Container for state and parameters of the gap control.
Definition: MSVehicle.h:1379
bool active
Whether the gap control is active.
Definition: MSVehicle.h:1410
static std::map< const MSVehicle *, GapControlState * > refVehMap
stores reference vehicles currently in use by a gapController
Definition: MSVehicle.h:1421
SUMOTime lastUpdate
Time of the last update of the gap control.
Definition: MSVehicle.h:1416
double changeRate
Rate by which the current time and space headways are changed towards the target value....
Definition: MSVehicle.h:1404
double addGapTarget
Target value for the desired space headway.
Definition: MSVehicle.h:1399
static GapControlVehStateListener vehStateListener
Definition: MSVehicle.h:1424
double timeHeadwayIncrement
cache storage for the headway increments of the current operation
Definition: MSVehicle.h:1418
double tauOriginal
Original value for the desired headway (will be reset after duration has expired)
Definition: MSVehicle.h:1391
double tauCurrent
Current, interpolated value for the desired time headway.
Definition: MSVehicle.h:1393
double remainingDuration
Remaining duration for keeping the target headway.
Definition: MSVehicle.h:1401
void activate(double tauOriginal, double tauTarget, double additionalGap, double duration, double changeRate, double maxDecel, const MSVehicle *refVeh)
Start gap control with given params.
Definition: MSVehicle.cpp:317
double addGapCurrent
Current, interpolated value for the desired space headway.
Definition: MSVehicle.h:1397
static void cleanup()
Static cleanup (removes vehicle state listener)
Definition: MSVehicle.cpp:311
double tauTarget
Target value for the desired time headway.
Definition: MSVehicle.h:1395
void deactivate()
Stop gap control.
Definition: MSVehicle.cpp:347
const MSVehicle * referenceVeh
reference vehicle for the gap - if it is null, the current leader on the ego's lane is used as a refe...
Definition: MSVehicle.h:1408
double maxDecel
Maximal deceleration to be applied due to the adapted headway.
Definition: MSVehicle.h:1406
bool gapAttained
Whether the desired gap was attained during the current activity phase (induces the remaining duratio...
Definition: MSVehicle.h:1412
const MSVehicle * prevLeader
The last recognized leader.
Definition: MSVehicle.h:1414
static void init()
Static initalization (adds vehicle state listener)
Definition: MSVehicle.cpp:300
A structure representing the best lanes for continuing the current route starting at 'lane'.
Definition: MSVehicle.h:864
double length
The overall length which may be driven when using this lane without a lane change.
Definition: MSVehicle.h:868
bool allowsContinuation
Whether this lane allows to continue the drive.
Definition: MSVehicle.h:878
double nextOccupation
As occupation, but without the first lane.
Definition: MSVehicle.h:874
std::vector< MSLane * > bestContinuations
Definition: MSVehicle.h:884
MSLane * lane
The described lane.
Definition: MSVehicle.h:866
double currentLength
The length which may be driven on this lane.
Definition: MSVehicle.h:870
int bestLaneOffset
The (signed) number of lanes to be crossed to get to the lane which allows to continue the drive.
Definition: MSVehicle.h:876
double occupation
The overall vehicle sum on consecutive lanes which can be passed without a lane change.
Definition: MSVehicle.h:872