Eclipse SUMO - Simulation of Urban MObility
MSLane.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-2022 German Aerospace Center (DLR) and others.
4// This program and the accompanying materials are made available under the
5// terms of the Eclipse Public License 2.0 which is available at
6// https://www.eclipse.org/legal/epl-2.0/
7// This Source Code may also be made available under the following Secondary
8// Licenses when the conditions for such availability set forth in the Eclipse
9// Public License 2.0 are satisfied: GNU General Public License, version 2
10// or later which is available at
11// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
12// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
13/****************************************************************************/
25// Representation of a lane in the micro simulation
26/****************************************************************************/
27#pragma once
28#include <config.h>
29
30#include <memory>
31#include <vector>
32#include <map>
33#include <deque>
34#include <cassert>
35#include <utils/common/Named.h>
42#include "MSGlobals.h"
43#include "MSLeaderInfo.h"
44#include "MSMoveReminder.h"
45#include "MSVehicle.h"
46
48#ifdef HAVE_FOX
50#endif
52
53
54// ===========================================================================
55// class declarations
56// ===========================================================================
57class MSEdge;
58class MSBaseVehicle;
59class MSLaneChanger;
60class MSLink;
63class OutputDevice;
64class MSLeaderInfo;
65class MSJunction;
66
67
68// ===========================================================================
69// type definitions
70// ===========================================================================
72typedef std::map<const MSLane*, std::pair<double, double> > LaneCoverageInfo;
73
74// ===========================================================================
75// class definitions
76// ===========================================================================
84class MSLane : public Named, public Parameterised {
85public:
87 public:
89 StoringVisitor(std::set<const Named*>& objects, const PositionVector& shape,
90 const double range, const int domain)
91 : myObjects(objects), myShape(shape), myRange(range), myDomain(domain) {}
92
94 void add(const MSLane* const l) const;
95
96 private:
98 std::set<const Named*>& myObjects;
100 const double myRange;
101 const int myDomain;
102
103 private:
106
109 };
110
112 friend class MSLaneChanger;
114
115 friend class MSQueueExport;
116 friend class AnyVehicleIterator;
117
119 typedef std::vector<MSVehicle*> VehCont;
120
121 // TODO: Better documentation
130 public:
132 const MSLane* lane,
133 int i1,
134 int i2,
135 int i3,
136 const int i1End,
137 const int i2End,
138 const int i3End,
139 bool downstream = true) :
140 myLane(lane),
141 myI1(i1),
142 myI2(i2),
143 myI3(i3),
144 myI1End(i1End),
145 myI2End(i2End),
146 myI3End(i3End),
147 myDownstream(downstream),
148 myDirection(downstream ? 1 : -1) {
149 }
150
151 bool operator== (AnyVehicleIterator const& other) const {
152 return (myI1 == other.myI1
153 && myI2 == other.myI2
154 && myI3 == other.myI3
155 && myI1End == other.myI1End
156 && myI2End == other.myI2End
157 && myI3End == other.myI3End);
158 }
159
160 bool operator!= (AnyVehicleIterator const& other) const {
161 return !(*this == other);
162 }
163
165 return **this;
166 }
167
168 const MSVehicle* operator*();
169
171
172 private:
173 bool nextIsMyVehicles() const;
174
178 int myI1;
180 int myI2;
182 int myI3;
193
194 };
195
196
197public:
206 };
207
223 MSLane(const std::string& id, double maxSpeed, double friction, double length, MSEdge* const edge,
224 int numericalID, const PositionVector& shape, double width,
225 SVCPermissions permissions,
226 SVCPermissions changeLeft, SVCPermissions changeRight,
227 int index, bool isRampAccel,
228 const std::string& type);
229
230
232 virtual ~MSLane();
233
235 inline int getThreadIndex() const {
237 }
238
240 inline int getRNGIndex() const {
241 return myRNGIndex;
242 }
243
245 SumoRNG* getRNG() const {
246 return &myRNGs[myRNGIndex];
247 }
248
250 static int getNumRNGs() {
251 return (int)myRNGs.size();
252 }
253
255 static void saveRNGStates(OutputDevice& out);
256
258 static void loadRNGState(int index, const std::string& state);
259
262
270 void addLink(MSLink* link);
271
276 void setOpposite(MSLane* oppositeLane);
278
279
280
283
290 virtual void addMoveReminder(MSMoveReminder* rem);
291
292
296 inline const std::vector< MSMoveReminder* >& getMoveReminders() const {
297 return myMoveReminders;
298 }
300
301
302
305
321 bool insertVehicle(MSVehicle& v);
322
323
342 bool isInsertionSuccess(MSVehicle* vehicle, double speed, double pos, double posLat,
343 bool recheckNextLanes,
344 MSMoveReminder::Notification notification);
345
346 // XXX: Documentation?
347 bool checkFailure(const MSVehicle* aVehicle, double& speed, double& dist, const double nspeed, const bool patchSpeed, const std::string errorMsg, InsertionCheck check) const;
348
352 bool lastInsertion(MSVehicle& veh, double mspeed, double posLat, bool patchSpeed);
353
361 bool freeInsertion(MSVehicle& veh, double speed, double posLat,
363
364
374 void forceVehicleInsertion(MSVehicle* veh, double pos, MSMoveReminder::Notification notification, double posLat = 0);
376
377
378
382
389 virtual double setPartialOccupation(MSVehicle* v);
390
394 virtual void resetPartialOccupation(MSVehicle* v);
395
398 virtual void setManeuverReservation(MSVehicle* v);
399
403 virtual void resetManeuverReservation(MSVehicle* v);
404
415 const MSLeaderInfo getLastVehicleInformation(const MSVehicle* ego, double latOffset, double minPos = 0, bool allowCached = true) const;
416
418 const MSLeaderInfo getFirstVehicleInformation(const MSVehicle* ego, double latOffset, bool onlyFrontOnLane, double maxPos = std::numeric_limits<double>::max(), bool allowCached = true) const;
419
421
424
429 int getVehicleNumber() const {
430 return (int)myVehicles.size();
431 }
432
438 return (int)myVehicles.size() + (int)myPartialVehicles.size();
439 }
440
446 return (int)myPartialVehicles.size();
447 }
448
449
456 virtual const VehCont& getVehiclesSecure() const {
457 return myVehicles;
458 }
459
460
463 return AnyVehicleIterator(this, 0, 0, 0,
464 (int)myVehicles.size(), (int)myPartialVehicles.size(), (int)myTmpVehicles.size(), true);
465 }
466
469 return AnyVehicleIterator(this, (int)myVehicles.size(), (int)myPartialVehicles.size(), (int)myTmpVehicles.size(),
470 (int)myVehicles.size(), (int)myPartialVehicles.size(), (int)myTmpVehicles.size(), true);
471 }
472
475 return AnyVehicleIterator(this, (int)myVehicles.size() - 1, (int)myPartialVehicles.size() - 1, (int)myTmpVehicles.size() - 1,
476 -1, -1, -1, false);
477 }
478
481 return AnyVehicleIterator(this, -1, -1, -1, -1, -1, -1, false);
482 }
483
486 virtual void releaseVehicles() const { }
488
489
490
493
494
498 inline int getNumericalID() const {
499 return myNumericalID;
500 }
501
502
506 inline const PositionVector& getShape() const {
507 return myShape;
508 }
509
511 inline double getLengthGeometryFactor() const {
513 }
514
516 inline bool isAccelLane() const {
517 return myIsRampAccel;
518 }
519
521 const std::string& getLaneType() const {
522 return myLaneType;
523 }
524
525 /* @brief fit the given lane position to a visibly suitable geometry position
526 * (lane length might differ from geometry length) */
527 inline double interpolateLanePosToGeometryPos(double lanePos) const {
528 return lanePos * myLengthGeometryFactor;
529 }
530
531 /* @brief fit the given lane position to a visibly suitable geometry position
532 * and return the coordinates */
533 inline const Position geometryPositionAtOffset(double offset, double lateralOffset = 0) const {
534 return myShape.positionAtOffset(interpolateLanePosToGeometryPos(offset), lateralOffset);
535 }
536
537 /* @brief fit the given geometry position to a valid lane position
538 * (lane length might differ from geometry length) */
539 inline double interpolateGeometryPosToLanePos(double geometryPos) const {
540 return geometryPos / myLengthGeometryFactor;
541 }
542
547 inline double getVehicleMaxSpeed(const SUMOTrafficObject* const veh) const {
548 if (myRestrictions != nullptr) {
549 std::map<SUMOVehicleClass, double>::const_iterator r = myRestrictions->find(veh->getVClass());
550 if (r != myRestrictions->end()) {
551 return MIN2(veh->getMaxSpeed(), r->second * veh->getChosenSpeedFactor());
552 }
553 }
554 return MIN2(veh->getMaxSpeed(), myMaxSpeed * veh->getChosenSpeedFactor());
555 }
556
557
561 inline double getSpeedLimit() const {
562 return myMaxSpeed;
563 }
564
568 inline double getFrictionCoefficient() const {
570 }
571
575 inline double getLength() const {
576 return myLength;
577 }
578
579
584 return myPermissions;
585 }
586
590 double getWidth() const {
591 return myWidth;
592 }
593
597 int getIndex() const {
598 return myIndex;
599 }
601
603 int getCrossingIndex() const;
604
605
608
616 virtual void planMovements(const SUMOTime t);
617
623 virtual void setJunctionApproaches(const SUMOTime t) const;
624
633 void updateLeaderInfo(const MSVehicle* veh, VehCont::reverse_iterator& vehPart, VehCont::reverse_iterator& vehRes, MSLeaderInfo& ahead) const;
634
645 virtual void executeMovements(const SUMOTime t);
646
648 virtual void integrateNewVehicles();
649
651 void updateLengthSum();
653
654
656 inline bool needsCollisionCheck() const {
658 }
659
661 inline void requireCollisionCheck() {
663 }
664
666 virtual void detectCollisions(SUMOTime timestep, const std::string& stage);
667
668
671 virtual bool appropriate(const MSVehicle* veh) const;
672
673
675 const std::vector<MSLink*>& getLinkCont() const {
676 return myLinks;
677 }
678
680 const MSLink* getLinkTo(const MSLane* const) const;
681
683 const MSLane* getInternalFollowingLane(const MSLane* const) const;
684
686 const MSLink* getEntryLink() const;
687
688
690 bool empty() const {
691 assert(myVehBuffer.size() == 0);
692 return myVehicles.empty();
693 }
694
698 void setMaxSpeed(double val);
699
703 void setFrictionCoefficient(double val);
704
708 void setLength(double val);
709
713 MSEdge& getEdge() const {
714 return *myEdge;
715 }
716
717
721 const MSEdge* getNextNormal() const;
722
723
729 const MSLane* getFirstInternalInConnection(double& offset) const;
730
731
734
745 static bool dictionary(const std::string& id, MSLane* lane);
746
747
754 static MSLane* dictionary(const std::string& id);
755
756
758 static void clear();
759
760
764 static int dictSize() {
765 return (int)myDict.size();
766 }
767
768
772 static void insertIDs(std::vector<std::string>& into);
773
774
779 template<class RTREE>
780 static void fill(RTREE& into);
781
782
784 static void initRNGs(const OptionsCont& oc);
786
787
788
789 // XXX: succLink does not exist... Documentation?
794 static std::vector<MSLink*>::const_iterator succLinkSec(const SUMOVehicle& veh,
795 int nRouteSuccs,
796 const MSLane& succLinkSource,
797 const std::vector<MSLane*>& conts);
798
799
802 inline bool isLinkEnd(std::vector<MSLink*>::const_iterator& i) const {
803 return i == myLinks.end();
804 }
805
808 inline bool isLinkEnd(std::vector<MSLink*>::iterator& i) {
809 return i == myLinks.end();
810 }
811
814 inline bool isEmpty() const {
815 return myVehicles.empty() && myPartialVehicles.empty();
816 }
817
819 bool isInternal() const;
820
822 bool isNormal() const;
823
826
829
832
833 /* @brief remove the vehicle from this lane
834 * @param[notify] whether moveReminders of the vehicle shall be triggered
835 */
836 virtual MSVehicle* removeVehicle(MSVehicle* remVehicle, MSMoveReminder::Notification notification, bool notify = true);
837
840
844 MSLane* getParallelLane(int offset, bool includeOpposite = true) const;
845
846
851 void setPermissions(SVCPermissions permissions, long long transientID);
852 void resetPermissions(long long transientID);
853 bool hadPermissionChanges() const;
854
855
856 inline bool allowsVehicleClass(SUMOVehicleClass vclass) const {
857 return (myPermissions & vclass) == vclass;
858 }
859
861 inline bool allowsChangingLeft(SUMOVehicleClass vclass) const {
862 return (myChangeLeft & vclass) == vclass;
863 }
864
866 inline bool allowsChangingRight(SUMOVehicleClass vclass) const {
867 return (myChangeRight & vclass) == vclass;
868 }
869
870 void addIncomingLane(MSLane* lane, MSLink* viaLink);
871
872
875 double length;
877 };
878
879 const std::vector<IncomingLaneInfo>& getIncomingLanes() const {
880 return myIncomingLanes;
881 }
882
883
884 void addApproachingLane(MSLane* lane, bool warnMultiCon);
885 inline bool isApproachedFrom(MSEdge* const edge) {
886 return myApproachingLanes.find(edge) != myApproachingLanes.end();
887 }
888 bool isApproachedFrom(MSEdge* const edge, MSLane* const lane);
889
891 double getVehicleStopOffset(const MSVehicle* veh) const;
892
894 const StopOffset& getLaneStopOffsets() const;
895
897 void setLaneStopOffset(const StopOffset& stopOffset);
898
906 };
907
909 MSLeaderDistanceInfo getFollowersOnConsecutive(const MSVehicle* ego, double backOffset,
910 bool allSublanes, double searchDist = -1, MinorLinkMode mLinkMode = FOLLOW_ALWAYS) const;
911
913 double getMissingRearGap(const MSVehicle* leader, double backOffset, double leaderSpeed) const;
914
927 std::pair<MSVehicle* const, double> getLeader(const MSVehicle* veh, const double vehPos, const std::vector<MSLane*>& bestLaneConts, double dist = -1, bool checkTmpVehicles = false) const;
928
951 std::pair<MSVehicle* const, double> getLeaderOnConsecutive(double dist, double seen,
952 double speed, const MSVehicle& veh, const std::vector<MSLane*>& bestLaneConts) const;
953
955 void getLeadersOnConsecutive(double dist, double seen, double speed, const MSVehicle* ego,
956 const std::vector<MSLane*>& bestLaneConts, MSLeaderDistanceInfo& result, bool oppositeDirection = false) const;
957
958
960 void addLeaders(const MSVehicle* vehicle, double vehPos, MSLeaderDistanceInfo& result, bool oppositeDirection = false);
961
962
980 std::pair<MSVehicle* const, double> getCriticalLeader(double dist, double seen, double speed, const MSVehicle& veh) const;
981
982 /* @brief return the partial vehicle closest behind ego or 0
983 * if no such vehicle exists */
984 MSVehicle* getPartialBehind(const MSVehicle* ego) const;
985
988
999 std::set<MSVehicle*> getSurroundingVehicles(double startPos, double downstreamDist, double upstreamDist, std::shared_ptr<LaneCoverageInfo> checkedLanes) const;
1000
1003 std::set<MSVehicle*> getVehiclesInRange(const double a, const double b) const;
1004
1006 std::vector<const MSJunction*> getUpcomingJunctions(double pos, double range, const std::vector<MSLane*>& contLanes) const;
1007
1009 std::vector<const MSLink*> getUpcomingLinks(double pos, double range, const std::vector<MSLane*>& contLanes) const;
1010
1015
1019 const MSLane* getNormalPredecessorLane() const;
1020
1023 MSLane* getLogicalPredecessorLane(const MSEdge& fromEdge) const;
1024
1025
1032
1033
1040
1043
1045 const std::vector<std::pair<const MSLane*, const MSEdge*> > getOutgoingViaLanes() const;
1046
1048 std::vector<const MSLane*> getNormalIncomingLanes() const;
1049
1051
1052
1056 double getMeanSpeed() const;
1057
1059 double getMeanSpeedBike() const;
1060
1064 double getWaitingSeconds() const;
1065
1066
1070 double getBruttoOccupancy() const;
1071
1072
1076 double getNettoOccupancy() const;
1077
1078
1082 inline double getBruttoVehLenSum() const {
1084 }
1085
1086
1091 template<PollutantsInterface::EmissionType ET>
1092 double getEmissions() const {
1093 double ret = 0;
1094 for (MSVehicle* const v : getVehiclesSecure()) {
1095 ret += v->getEmissions<ET>();
1096 }
1098 return ret;
1099 }
1100
1101
1105 double getHarmonoise_NoiseEmissions() const;
1107
1108 void setRightSideOnEdge(double value, int rightmostSublane) {
1109 myRightSideOnEdge = value;
1110 myRightmostSublane = rightmostSublane;
1111 }
1112
1114 void initRestrictions();
1115
1116 void checkBufferType();
1117
1118 double getRightSideOnEdge() const {
1119 return myRightSideOnEdge;
1120 }
1121
1123 return myRightmostSublane;
1124 }
1125
1126 double getCenterOnEdge() const {
1127 return myRightSideOnEdge + 0.5 * myWidth;
1128 }
1129
1131 void sortPartialVehicles();
1132
1135
1137 MSLane* getOpposite() const;
1138
1140 MSLane* getParallelOpposite() const;
1141
1143 double getOppositePos(double pos) const;
1144
1145 /* @brief find leader for a vehicle depending on the relative driving direction
1146 * @param[in] ego The ego vehicle
1147 * @param[in] dist The look-ahead distance when looking at consecutive lanes
1148 * @param[in] oppositeDir Whether the lane has the opposite driving direction of ego
1149 * @return the leader vehicle and it's gap to ego
1150 */
1151 std::pair<MSVehicle* const, double> getOppositeLeader(const MSVehicle* ego, double dist, bool oppositeDir, MinorLinkMode mLinkMode = MinorLinkMode::FOLLOW_NEVER) const;
1152
1153 /* @brief find follower for a vehicle that is located on the opposite of this lane
1154 * @param[in] ego The ego vehicle
1155 * @return the follower vehicle and it's gap to ego
1156 */
1157 std::pair<MSVehicle* const, double> getOppositeFollower(const MSVehicle* ego) const;
1158
1159
1167 std::pair<MSVehicle* const, double> getFollower(const MSVehicle* ego, double egoPos, double dist, MinorLinkMode mLinkMode) const;
1168
1169
1171 void addParking(MSBaseVehicle* veh);
1172
1174 virtual void removeParking(MSBaseVehicle* veh);
1175
1177 const std::set<const MSBaseVehicle*>& getParkingVehicles() const {
1178 return myParkingVehicles;
1179 }
1180
1182 virtual bool isSelected() const {
1183 return false;
1184 }
1185
1187 MSLane* getBidiLane() const;
1188
1190 bool mustCheckJunctionCollisions() const;
1191
1192#ifdef HAVE_FOX
1193 MFXWorkerThread::Task* getPlanMoveTask(const SUMOTime time) {
1194 mySimulationTask.init(&MSLane::planMovements, time);
1195 return &mySimulationTask;
1196 }
1197
1198 MFXWorkerThread::Task* getExecuteMoveTask(const SUMOTime time) {
1199 mySimulationTask.init(&MSLane::executeMovements, time);
1200 return &mySimulationTask;
1201 }
1202
1203 MFXWorkerThread::Task* getLaneChangeTask(const SUMOTime time) {
1204 mySimulationTask.init(&MSLane::changeLanes, time);
1205 return &mySimulationTask;
1206 }
1207#endif
1208
1209 std::vector<StopWatch<std::chrono::nanoseconds> >& getStopWatch() {
1210 return myStopWatch;
1211 }
1212
1213 void changeLanes(const SUMOTime time);
1214
1217
1225 void saveState(OutputDevice& out);
1226
1228 void clearState();
1229
1241 void loadState(const std::vector<std::string>& vehIDs, MSVehicleControl& vc);
1242
1243
1244 /* @brief helper function for state saving: checks whether any outgoing
1245 * links are being approached */
1246 bool hasApproaching() const;
1247
1249
1250
1258 void visit(const MSLane::StoringVisitor& cont) const {
1259 cont.add(this);
1260 }
1261
1263 bool hasPedestrians() const;
1264
1266 std::pair<const MSPerson*, double> nextBlocking(double minPos, double minRight, double maxLeft, double stopTime = 0, bool bidi = false) const;
1267
1269 double getSpaceTillLastStanding(const MSVehicle* ego, bool& foundStopped) const;
1270
1272 double getMaximumBrakeDist() const;
1273
1274 static void initCollisionOptions(const OptionsCont& oc);
1275
1277 return myCollisionAction;
1278 }
1279
1280 static const long CHANGE_PERMISSIONS_PERMANENT = 0;
1281 static const long CHANGE_PERMISSIONS_GUI = 1;
1282
1283protected:
1285 virtual void swapAfterLaneChange(SUMOTime t);
1286
1298 virtual void incorporateVehicle(MSVehicle* veh, double pos, double speed, double posLat,
1299 const MSLane::VehCont::iterator& at,
1301
1303 void detectPedestrianJunctionCollision(const MSVehicle* collider, const PositionVector& colliderBoundary, const MSLane* foeLane,
1304 SUMOTime timestep, const std::string& stage);
1305
1307 bool detectCollisionBetween(SUMOTime timestep, const std::string& stage, MSVehicle* collider, MSVehicle* victim,
1308 std::set<const MSVehicle*, ComparatorNumericalIdLess>& toRemove,
1309 std::set<const MSVehicle*, ComparatorNumericalIdLess>& toTeleport) const;
1310
1312 void handleCollisionBetween(SUMOTime timestep, const std::string& stage, const MSVehicle* collider, const MSVehicle* victim,
1313 double gap, double latGap,
1314 std::set<const MSVehicle*, ComparatorNumericalIdLess>& toRemove,
1315 std::set<const MSVehicle*, ComparatorNumericalIdLess>& toTeleport) const;
1316
1317 /* @brief determine depart speed and whether it may be patched
1318 * @param[in] veh The departing vehicle
1319 * @param[out] whether the speed may be patched to account for safety
1320 * @return the depart speed
1321 */
1322 double getDepartSpeed(const MSVehicle& veh, bool& patchSpeed);
1323
1324 /* @brief determine the lateral depart position
1325 * @param[in] veh The departing vehicle
1326 * @return the lateral depart position
1327 */
1328 double getDepartPosLat(const MSVehicle& veh);
1329
1332 double safeInsertionSpeed(const MSVehicle* veh, double seen, const MSLeaderInfo& leaders, double speed);
1333
1335 bool checkForPedestrians(const MSVehicle* aVehicle, double& speed, double& dist, double pos, bool patchSpeed) const;
1336
1338 bool hasApproaching(const std::vector<MSLink*>& links) const;
1339
1341 double getFractionalVehicleLength(bool brutto) const;
1342
1345
1348
1351
1364
1376
1380
1384
1392
1393 /* @brief list of vehicles that are parking near this lane
1394 * (not necessarily on the road but having reached their stop on this lane)
1395 * */
1396 std::set<const MSBaseVehicle*> myParkingVehicles;
1397
1399 double myLength;
1400
1402 const double myWidth;
1403
1408
1411
1416
1419
1423
1426
1428 const std::map<SUMOVehicleClass, double>* myRestrictions;
1429
1431 std::vector<IncomingLaneInfo> myIncomingLanes;
1432
1435
1438
1441
1444
1447
1450
1453
1456 std::vector<MSLink*> myLinks;
1457
1459 std::map<MSEdge*, std::vector<MSLane*> > myApproachingLanes;
1460
1465
1470
1473
1475 const bool myIsRampAccel;
1476
1478 const std::string myLaneType;
1479
1484
1487
1488 // @brief the ids of the opposite direction lane
1490
1491 // @brief transient changes in permissions
1492 std::map<long long, SVCPermissions> myPermissionChanges;
1493
1494 // @brief index of the associated thread-rng
1496
1498 typedef std::map< std::string, MSLane* > DictType;
1499
1502
1503 static std::vector<SumoRNG> myRNGs;
1504
1505private:
1507 std::vector< MSMoveReminder* > myMoveReminders;
1508
1516
1522 public:
1524 explicit vehicle_position_sorter(const MSLane* lane) :
1525 myLane(lane) {
1526 }
1527
1528
1534 int operator()(MSVehicle* v1, MSVehicle* v2) const;
1535
1537
1538 };
1539
1545 public:
1548 myLane(lane) {
1549 }
1550
1551
1557 int operator()(MSVehicle* v1, MSVehicle* v2) const;
1558
1560
1561 };
1562
1568 public:
1570 explicit by_connections_to_sorter(const MSEdge* const e);
1571
1573 int operator()(const MSEdge* const e1, const MSEdge* const e2) const;
1574
1575 private:
1576 const MSEdge* const myEdge;
1578 };
1579
1580
1581
1587 public:
1589 explicit incoming_lane_priority_sorter(const MSLane* targetLane);
1590
1592 int operator()(const IncomingLaneInfo& lane1, const IncomingLaneInfo& lane2) const;
1593
1594 private:
1595 const MSLane* const myLane;
1597 };
1598
1599
1605 public:
1607 explicit outgoing_lane_priority_sorter(const MSLane* sourceLane);
1608
1610 int operator()(const MSLink* link1, const MSLink* link2) const;
1611
1612 private:
1614 };
1615
1620 public:
1622 bool operator()(const IncomingLaneInfo& ili) const {
1623 return &(ili.lane->getEdge()) == myEdge;
1624 }
1625 private:
1626 const MSEdge* const myEdge;
1627 };
1628
1629#ifdef HAVE_FOX
1631 typedef void(MSLane::*Operation)(const SUMOTime);
1632
1637 class SimulationTask : public MFXWorkerThread::Task {
1638 public:
1639 SimulationTask(MSLane& l, const SUMOTime time)
1640 : myLane(l), myTime(time) {}
1641 void init(Operation operation, const SUMOTime time) {
1642 myOperation = operation;
1643 myTime = time;
1644 }
1645 void run(MFXWorkerThread* /*context*/) {
1646 try {
1647 (myLane.*(myOperation))(myTime);
1648 } catch (ProcessError& e) {
1649 WRITE_ERROR(e.what());
1650 }
1651 }
1652 private:
1653 Operation myOperation = nullptr;
1654 MSLane& myLane;
1655 SUMOTime myTime;
1656 private:
1658 SimulationTask& operator=(const SimulationTask&) = delete;
1659 };
1660
1661 SimulationTask mySimulationTask;
1663 mutable FXMutex myLeaderInfoMutex;
1665 mutable FXMutex myFollowerInfoMutex;
1667 mutable FXMutex myPartialOccupatorMutex;
1668#endif
1669 std::vector<StopWatch<std::chrono::nanoseconds> > myStopWatch;
1670
1671private:
1673 MSLane(const MSLane&) = delete;
1674
1676 MSLane& operator=(const MSLane&) = delete;
1677
1678
1679};
1680
1681// specialized implementation for speedup and avoiding warnings
1682#define LANE_RTREE_QUAL RTree<MSLane*, MSLane, float, 2, MSLane::StoringVisitor>
1683
1684template<>
1685inline float LANE_RTREE_QUAL::RectSphericalVolume(Rect* a_rect) {
1686 ASSERT(a_rect);
1687 const float extent0 = a_rect->m_max[0] - a_rect->m_min[0];
1688 const float extent1 = a_rect->m_max[1] - a_rect->m_min[1];
1689 return .78539816f * (extent0 * extent0 + extent1 * extent1);
1690}
1691
1692template<>
1693inline LANE_RTREE_QUAL::Rect LANE_RTREE_QUAL::CombineRect(Rect* a_rectA, Rect* a_rectB) {
1694 ASSERT(a_rectA && a_rectB);
1695 Rect newRect;
1696 newRect.m_min[0] = rtree_min(a_rectA->m_min[0], a_rectB->m_min[0]);
1697 newRect.m_max[0] = rtree_max(a_rectA->m_max[0], a_rectB->m_max[0]);
1698 newRect.m_min[1] = rtree_min(a_rectA->m_min[1], a_rectB->m_min[1]);
1699 newRect.m_max[1] = rtree_max(a_rectA->m_max[1], a_rectB->m_max[1]);
1700 return newRect;
1701}
long long int SUMOTime
Definition: GUI.h:36
std::map< const MSLane *, std::pair< double, double > > LaneCoverageInfo
Coverage info.
Definition: MSLane.h:72
#define WRITE_ERROR(msg)
Definition: MsgHandler.h:274
#define rtree_min(a, b)
Definition: RTree.h:20
#define rtree_max(a, b)
Definition: RTree.h:21
#define ASSERT
Definition: RTree.h:12
SUMOVehicleClass
Definition of vehicle classes to differ between different lane usage and authority types.
int SVCPermissions
bitset where each bit declares whether a certain SVC may use this edge/lane
InsertionCheck
different checking levels for vehicle insertion
LinkState
The right-of-way state of a link between two lanes used when constructing a NBTrafficLightLogic,...
T MIN2(T a, T b)
Definition: StdDefs.h:71
size_t size() const
Definition: MFXSynchQue.h:157
Abstract superclass of a task to be run with an index to keep track of pending tasks.
A thread repeatingly calculating incoming tasks.
The base class for microscopic and mesoscopic vehicles.
Definition: MSBaseVehicle.h:55
A road/street connecting two junctions.
Definition: MSEdge.h:77
static int gNumSimThreads
how many threads to use for simulation
Definition: MSGlobals.h:142
The base class for an intersection.
Definition: MSJunction.h:58
AnyVehicleIterator is a structure, which manages the iteration through all vehicles on the lane,...
Definition: MSLane.h:129
bool operator!=(AnyVehicleIterator const &other) const
Definition: MSLane.h:160
int myI2End
end index for myPartialVehicles
Definition: MSLane.h:186
int myI2
index for myPartialVehicles
Definition: MSLane.h:180
bool myDownstream
iteration direction
Definition: MSLane.h:190
const MSVehicle * operator->()
Definition: MSLane.h:164
bool nextIsMyVehicles() const
Definition: MSLane.cpp:196
int myI3
index for myTmpVehicles
Definition: MSLane.h:182
int myDirection
index delta
Definition: MSLane.h:192
AnyVehicleIterator & operator++()
Definition: MSLane.cpp:162
const MSLane * myLane
the lane that is being iterated
Definition: MSLane.h:176
bool operator==(AnyVehicleIterator const &other) const
Definition: MSLane.h:151
const MSVehicle * operator*()
Definition: MSLane.cpp:179
int myI3End
end index for myTmpVehicles
Definition: MSLane.h:188
AnyVehicleIterator(const MSLane *lane, int i1, int i2, int i3, const int i1End, const int i2End, const int i3End, bool downstream=true)
Definition: MSLane.h:131
int myI1End
end index for myVehicles
Definition: MSLane.h:184
int myI1
index for myVehicles
Definition: MSLane.h:178
StoringVisitor(const StoringVisitor &src)
invalidated copy constructor
void add(const MSLane *const l) const
Adds the given object to the container.
Definition: MSLane.cpp:115
StoringVisitor(std::set< const Named * > &objects, const PositionVector &shape, const double range, const int domain)
Constructor.
Definition: MSLane.h:89
StoringVisitor & operator=(const StoringVisitor &src)
invalidated assignment operator
const int myDomain
Definition: MSLane.h:101
std::set< const Named * > & myObjects
The container.
Definition: MSLane.h:98
const double myRange
Definition: MSLane.h:100
const PositionVector & myShape
Definition: MSLane.h:99
Sorts edges by their angle relative to the given edge (straight comes first)
Definition: MSLane.h:1567
by_connections_to_sorter(const MSEdge *const e)
constructor
Definition: MSLane.cpp:3165
const MSEdge *const myEdge
Definition: MSLane.h:1576
int operator()(const MSEdge *const e1, const MSEdge *const e2) const
comparing operator
Definition: MSLane.cpp:3172
bool operator()(const IncomingLaneInfo &ili) const
Definition: MSLane.h:1622
edge_finder(MSEdge *e)
Definition: MSLane.h:1621
const MSEdge *const myEdge
Definition: MSLane.h:1626
Sorts lanes (IncomingLaneInfos) by their priority or, if this doesn't apply, wrt. the angle differenc...
Definition: MSLane.h:1586
incoming_lane_priority_sorter(const MSLane *targetLane)
constructor
Definition: MSLane.cpp:3206
int operator()(const IncomingLaneInfo &lane1, const IncomingLaneInfo &lane2) const
comparing operator
Definition: MSLane.cpp:3211
Sorts lanes (their origin link) by the priority of their noninternal target edges or,...
Definition: MSLane.h:1604
outgoing_lane_priority_sorter(const MSLane *sourceLane)
constructor
Definition: MSLane.cpp:3284
int operator()(const MSLink *link1, const MSLink *link2) const
comparing operator
Definition: MSLane.cpp:3288
vehicle_natural_position_sorter(const MSLane *lane)
Constructor.
Definition: MSLane.h:1547
int operator()(MSVehicle *v1, MSVehicle *v2) const
Comparing operator.
Definition: MSLane.cpp:3154
Sorts vehicles by their position (descending)
Definition: MSLane.h:1521
int operator()(MSVehicle *v1, MSVehicle *v2) const
Comparing operator.
Definition: MSLane.cpp:3142
vehicle_position_sorter(const MSLane *lane)
Constructor.
Definition: MSLane.h:1524
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
std::vector< StopWatch< std::chrono::nanoseconds > > & getStopWatch()
Definition: MSLane.h:1209
void addApproachingLane(MSLane *lane, bool warnMultiCon)
Definition: MSLane.cpp:2537
bool detectCollisionBetween(SUMOTime timestep, const std::string &stage, MSVehicle *collider, MSVehicle *victim, std::set< const MSVehicle *, ComparatorNumericalIdLess > &toRemove, std::set< const MSVehicle *, ComparatorNumericalIdLess > &toTeleport) const
detect whether there is a collision between the two vehicles
Definition: MSLane.cpp:1783
MFXSynchQue< MSVehicle *, std::vector< MSVehicle * > > myVehBuffer
Buffer for vehicles that moved from their previous lane onto this one. Integrated after all vehicles ...
Definition: MSLane.h:1383
SVCPermissions myPermissions
The vClass permissions for this lane.
Definition: MSLane.h:1418
MSLane * myLogicalPredecessorLane
Definition: MSLane.h:1434
virtual void setJunctionApproaches(const SUMOTime t) const
Register junction approaches for all vehicles after velocities have been planned.
Definition: MSLane.cpp:1454
const std::vector< MSMoveReminder * > & getMoveReminders() const
Return the list of this lane's move reminders.
Definition: MSLane.h:296
std::set< const MSBaseVehicle * > myParkingVehicles
Definition: MSLane.h:1396
bool checkForPedestrians(const MSVehicle *aVehicle, double &speed, double &dist, double pos, bool patchSpeed) const
check whether pedestrians on this lane interfere with vehicle insertion
Definition: MSLane.cpp:4184
std::pair< MSVehicle *const, double > getFollower(const MSVehicle *ego, double egoPos, double dist, MinorLinkMode mLinkMode) const
Find follower vehicle for the given ego vehicle (which may be on the opposite direction lane)
Definition: MSLane.cpp:4022
std::pair< const MSPerson *, double > nextBlocking(double minPos, double minRight, double maxLeft, double stopTime=0, bool bidi=false) const
This is just a wrapper around MSPModel::nextBlocking. You should always check using hasPedestrians be...
Definition: MSLane.cpp:4178
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.
Definition: MSLane.cpp:2521
double myRightSideOnEdge
the combined width of all lanes with lower index on myEdge
Definition: MSLane.h:1481
const StopOffset & getLaneStopOffsets() const
Returns vehicle class specific stopOffsets.
Definition: MSLane.cpp:3434
virtual void removeParking(MSBaseVehicle *veh)
remove parking vehicle. This must be syncrhonized when running with GUI
Definition: MSLane.cpp:3329
virtual ~MSLane()
Destructor.
Definition: MSLane.cpp:282
bool insertVehicle(MSVehicle &v)
Tries to insert the given vehicle.
Definition: MSLane.cpp:630
const MSLeaderInfo getFirstVehicleInformation(const MSVehicle *ego, double latOffset, bool onlyFrontOnLane, double maxPos=std::numeric_limits< double >::max(), bool allowCached=true) const
analogue to getLastVehicleInformation but in the upstream direction
Definition: MSLane.cpp:1359
virtual void integrateNewVehicles()
Insert buffered vehicle into the real lane.
Definition: MSLane.cpp:2276
double myLength
Lane length [m].
Definition: MSLane.h:1399
bool isApproachedFrom(MSEdge *const edge)
Definition: MSLane.h:885
double getNettoOccupancy() const
Returns the netto (excluding minGaps) occupancy of this lane during the last step (including minGaps)
Definition: MSLane.cpp:3051
virtual MSVehicle * removeVehicle(MSVehicle *remVehicle, MSMoveReminder::Notification notification, bool notify=true)
Definition: MSLane.cpp:2503
int getCrossingIndex() const
return the index of the link to the next crossing if this is walkingArea, else -1
Definition: MSLane.cpp:3006
PositionVector myShape
The shape of the lane.
Definition: MSLane.h:1347
std::map< long long, SVCPermissions > myPermissionChanges
Definition: MSLane.h:1492
int getRNGIndex() const
returns the associated RNG index
Definition: MSLane.h:240
double getFrictionCoefficient() const
Returns the lane's friction coefficient.
Definition: MSLane.h:568
const std::map< SUMOVehicleClass, double > * myRestrictions
The vClass speed restrictions for this lane.
Definition: MSLane.h:1428
virtual void incorporateVehicle(MSVehicle *veh, double pos, double speed, double posLat, const MSLane::VehCont::iterator &at, MSMoveReminder::Notification notification=MSMoveReminder::NOTIFICATION_DEPARTED)
Inserts the vehicle into this lane, and informs it about entering the network.
Definition: MSLane.cpp:407
void initRestrictions()
initialized vClass-specific speed limits
Definition: MSLane.cpp:290
std::vector< MSMoveReminder * > myMoveReminders
This lane's move reminder.
Definition: MSLane.h:1507
MSLane & operator=(const MSLane &)=delete
invalidated assignment operator
bool hasApproaching() const
Definition: MSLane.cpp:3334
void addParking(MSBaseVehicle *veh)
add parking vehicle. This should only used during state loading
Definition: MSLane.cpp:3323
VehCont myTmpVehicles
Container for lane-changing vehicles. After completion of lane-change- process, the containers will b...
Definition: MSLane.h:1379
double getDepartSpeed(const MSVehicle &veh, bool &patchSpeed)
Definition: MSLane.cpp:553
MSLeaderInfo myFollowerInfo
followers on all sublanes as seen by vehicles on consecutive lanes (cached)
Definition: MSLane.h:1464
int getVehicleNumber() const
Returns the number of vehicles on this lane (for which this lane is responsible)
Definition: MSLane.h:429
static SUMOTime myCollisionStopTime
Definition: MSLane.h:1513
static CollisionAction myCollisionAction
the action to take on collisions
Definition: MSLane.h:1510
MSLane * myCanonicalSuccessorLane
Main successor lane,.
Definition: MSLane.h:1440
SVCPermissions myChangeLeft
The vClass permissions for changing from this lane.
Definition: MSLane.h:1421
void getLeadersOnConsecutive(double dist, double seen, double speed, const MSVehicle *ego, const std::vector< MSLane * > &bestLaneConts, MSLeaderDistanceInfo &result, bool oppositeDirection=false) const
Returns the immediate leaders and the distance to them (as getLeaderOnConsecutive but for the sublane...
Definition: MSLane.cpp:3664
std::vector< IncomingLaneInfo > myIncomingLanes
All direct predecessor lanes.
Definition: MSLane.h:1431
AnyVehicleIterator anyVehiclesEnd() const
end iterator for iterating over all vehicles touching this lane in downstream direction
Definition: MSLane.h:468
static void insertIDs(std::vector< std::string > &into)
Adds the ids of all stored lanes into the given vector.
Definition: MSLane.cpp:2231
bool hadPermissionChanges() const
Definition: MSLane.cpp:4165
void sortPartialVehicles()
sorts myPartialVehicles
Definition: MSLane.cpp:2303
double myFrictionCoefficient
Lane-wide friction coefficient [0..1].
Definition: MSLane.h:1415
MSVehicle * getFirstAnyVehicle() const
returns the first vehicle that is fully or partially on this lane
Definition: MSLane.cpp:2365
MSLane(const MSLane &)=delete
invalidated copy constructor
const MSLink * getEntryLink() const
Returns the entry link if this is an internal lane, else nullptr.
Definition: MSLane.cpp:2451
int getVehicleNumberWithPartials() const
Returns the number of vehicles on this lane (including partial occupators)
Definition: MSLane.h:437
static bool myCheckJunctionCollisions
Definition: MSLane.h:1511
static void clear()
Clears the dictionary.
Definition: MSLane.cpp:2222
double getBruttoVehLenSum() const
Returns the sum of lengths of vehicles, including their minGaps, which were on the lane during the la...
Definition: MSLane.h:1082
virtual void resetManeuverReservation(MSVehicle *v)
Unregisters a vehicle, which previously registered for maneuvering into this lane.
Definition: MSLane.cpp:389
SVCPermissions myOriginalPermissions
The original vClass permissions for this lane (before temporary modifications)
Definition: MSLane.h:1425
MSEdge *const myEdge
The lane's edge, for routing only.
Definition: MSLane.h:1410
double myNettoVehicleLengthSum
The current length of all vehicles on this lane, excluding their minGaps.
Definition: MSLane.h:1446
bool empty() const
Returns true if there is not a single vehicle on the lane.
Definition: MSLane.h:690
bool allowsChangingRight(SUMOVehicleClass vclass) const
Returns whether the given vehicle class may change left from this lane.
Definition: MSLane.h:866
static std::vector< MSLink * >::const_iterator succLinkSec(const SUMOVehicle &veh, int nRouteSuccs, const MSLane &succLinkSource, const std::vector< MSLane * > &conts)
Definition: MSLane.cpp:2379
double getMissingRearGap(const MSVehicle *leader, double backOffset, double leaderSpeed) const
return by how much further the leader must be inserted to avoid rear end collisions
Definition: MSLane.cpp:2562
double myMaxSpeed
Lane-wide speedlimit [m/s].
Definition: MSLane.h:1413
void saveState(OutputDevice &out)
Saves the state of this lane into the given stream.
Definition: MSLane.cpp:3344
const MSLink * getLinkTo(const MSLane *const) const
returns the link to the given lane or nullptr, if it is not connected
Definition: MSLane.cpp:2428
int myRightmostSublane
the index of the rightmost sublane of this lane on myEdge
Definition: MSLane.h:1483
const bool myIsRampAccel
whether this lane is an acceleration lane
Definition: MSLane.h:1475
virtual void planMovements(const SUMOTime t)
Compute safe velocities for all vehicles based on positions and speeds from the last time step....
Definition: MSLane.cpp:1414
static void saveRNGStates(OutputDevice &out)
save random number generator states to the given output device
Definition: MSLane.cpp:4233
void visit(const MSLane::StoringVisitor &cont) const
Callback for visiting the lane when traversing an RTree.
Definition: MSLane.h:1258
SUMOTime myFollowerInfoTime
time step for which myFollowerInfo was last updated
Definition: MSLane.h:1469
MSLeaderInfo myLeaderInfo
leaders on all sublanes as seen by approaching vehicles (cached)
Definition: MSLane.h:1462
bool isInsertionSuccess(MSVehicle *vehicle, double speed, double pos, double posLat, bool recheckNextLanes, MSMoveReminder::Notification notification)
Tries to insert the given vehicle with the given state (speed and pos)
Definition: MSLane.cpp:771
void forceVehicleInsertion(MSVehicle *veh, double pos, MSMoveReminder::Notification notification, double posLat=0)
Inserts the given vehicle at the given position.
Definition: MSLane.cpp:1259
double getVehicleStopOffset(const MSVehicle *veh) const
Returns vehicle class specific stopOffset for the vehicle.
Definition: MSLane.cpp:3421
static void initCollisionOptions(const OptionsCont &oc)
Definition: MSLane.cpp:4116
int myNumericalID
Unique numerical ID (set on reading by netload)
Definition: MSLane.h:1344
bool isAccelLane() const
return whether this lane is an acceleration lane
Definition: MSLane.h:516
VehCont myVehicles
The lane's vehicles. This container holds all vehicles that have their front (longitudinally) and the...
Definition: MSLane.h:1363
double getSpeedLimit() const
Returns the lane's maximum allowed speed.
Definition: MSLane.h:561
MSLeaderInfo getPartialBeyond() const
get all vehicles that are inlapping from consecutive edges
Definition: MSLane.cpp:3859
std::vector< MSVehicle * > VehCont
Container for vehicles.
Definition: MSLane.h:119
bool checkFailure(const MSVehicle *aVehicle, double &speed, double &dist, const double nspeed, const bool patchSpeed, const std::string errorMsg, InsertionCheck check) const
Definition: MSLane.cpp:739
static DictType myDict
Static dictionary to associate string-ids with objects.
Definition: MSLane.h:1501
static void fill(RTREE &into)
Fills the given RTree with lane instances.
Definition: MSLane.cpp:2239
double safeInsertionSpeed(const MSVehicle *veh, double seen, const MSLeaderInfo &leaders, double speed)
return the maximum safe speed for insertion behind leaders (a negative value indicates that safe inse...
Definition: MSLane.cpp:1270
std::vector< const MSJunction * > getUpcomingJunctions(double pos, double range, const std::vector< MSLane * > &contLanes) const
Returns all upcoming junctions within given range along the given (non-internal) continuation lanes m...
Definition: MSLane.cpp:3946
void addIncomingLane(MSLane *lane, MSLink *viaLink)
Definition: MSLane.cpp:2527
const MSEdge * getNextNormal() const
Returns the lane's follower if it is an internal lane, the edge of the lane otherwise.
Definition: MSLane.cpp:2175
void addLink(MSLink *link)
Delayed initialization.
Definition: MSLane.cpp:310
std::set< MSVehicle * > getVehiclesInRange(const double a, const double b) const
Returns all vehicles on the lane overlapping with the interval [a,b].
Definition: MSLane.cpp:3926
void enteredByLaneChange(MSVehicle *v)
Definition: MSLane.cpp:2999
double getDepartPosLat(const MSVehicle &veh)
Definition: MSLane.cpp:604
const std::string & getLaneType() const
return the type of this lane
Definition: MSLane.h:521
std::pair< MSVehicle *const, double > getOppositeLeader(const MSVehicle *ego, double dist, bool oppositeDir, MinorLinkMode mLinkMode=MinorLinkMode::FOLLOW_NEVER) const
Definition: MSLane.cpp:4045
int getThreadIndex() const
returns the associated thread index
Definition: MSLane.h:235
SVCPermissions getPermissions() const
Returns the vehicle class permissions for this lane.
Definition: MSLane.h:583
LinkState getIncomingLinkState() const
get the state of the link from the logical predecessor to this lane
Definition: MSLane.cpp:2957
void updateLengthSum()
updated current vehicle length sum (delayed to avoid lane-order-dependency)
Definition: MSLane.cpp:2155
const std::vector< IncomingLaneInfo > & getIncomingLanes() const
Definition: MSLane.h:879
static const long CHANGE_PERMISSIONS_PERMANENT
Definition: MSLane.h:1280
MSLane * getCanonicalPredecessorLane() const
Definition: MSLane.cpp:2912
void resetPermissions(long long transientID)
Definition: MSLane.cpp:4150
MSVehicle * getLastFullVehicle() const
returns the last vehicle for which this lane is responsible or 0
Definition: MSLane.cpp:2342
static void loadRNGState(int index, const std::string &state)
load random number generator state for the given rng index
Definition: MSLane.cpp:4243
const std::string myLaneType
the type of this lane
Definition: MSLane.h:1478
int myRNGIndex
Definition: MSLane.h:1495
VehCont myManeuverReservations
The vehicles which registered maneuvering into the lane within their current action step....
Definition: MSLane.h:1391
void addLeaders(const MSVehicle *vehicle, double vehPos, MSLeaderDistanceInfo &result, bool oppositeDirection=false)
get leaders for ego on the given lane
Definition: MSLane.cpp:3771
bool needsCollisionCheck() const
short-circut collision check if nothing changed since the last check
Definition: MSLane.h:656
static double myCheckJunctionCollisionMinGap
Definition: MSLane.h:1512
double getLength() const
Returns the lane's length.
Definition: MSLane.h:575
double myBruttoVehicleLengthSum
The current length of all vehicles on this lane, including their minGaps.
Definition: MSLane.h:1443
const PositionVector & getShape() const
Returns this lane's shape.
Definition: MSLane.h:506
std::vector< const MSLink * > getUpcomingLinks(double pos, double range, const std::vector< MSLane * > &contLanes) const
Returns all upcoming links within given range along the given (non-internal) continuation lanes measu...
Definition: MSLane.cpp:3957
const MSLane * getFirstInternalInConnection(double &offset) const
Returns 0 if the lane is not internal. Otherwise the first part of the connection (sequence of intern...
Definition: MSLane.cpp:2181
static int getNumRNGs()
return the number of RNGs
Definition: MSLane.h:250
void handleCollisionBetween(SUMOTime timestep, const std::string &stage, const MSVehicle *collider, const MSVehicle *victim, double gap, double latGap, std::set< const MSVehicle *, ComparatorNumericalIdLess > &toRemove, std::set< const MSVehicle *, ComparatorNumericalIdLess > &toTeleport) const
take action upon collision
Definition: MSLane.cpp:1886
double getMaximumBrakeDist() const
compute maximum braking distance on this lane
Definition: MSLane.cpp:2578
const MSLane * getInternalFollowingLane(const MSLane *const) const
returns the internal lane leading to the given lane or nullptr, if there is none
Definition: MSLane.cpp:2440
bool isLinkEnd(std::vector< MSLink * >::iterator &i)
Definition: MSLane.h:808
static std::vector< SumoRNG > myRNGs
Definition: MSLane.h:1503
bool allowsChangingLeft(SUMOVehicleClass vclass) const
Returns whether the given vehicle class may change left from this lane.
Definition: MSLane.h:861
virtual void swapAfterLaneChange(SUMOTime t)
moves myTmpVehicles int myVehicles after a lane change procedure
Definition: MSLane.cpp:2489
std::pair< MSVehicle *const, double > getCriticalLeader(double dist, double seen, double speed, const MSVehicle &veh) const
Returns the most dangerous leader and the distance to him.
Definition: MSLane.cpp:2782
StopOffset myLaneStopOffset
Definition: MSLane.h:1407
const MSLeaderInfo getLastVehicleInformation(const MSVehicle *ego, double latOffset, double minPos=0, bool allowCached=true) const
Returns the last vehicles on the lane.
Definition: MSLane.cpp:1303
static void initRNGs(const OptionsCont &oc)
initialize rngs
Definition: MSLane.cpp:4220
std::set< MSVehicle * > getSurroundingVehicles(double startPos, double downstreamDist, double upstreamDist, std::shared_ptr< LaneCoverageInfo > checkedLanes) const
Returns all vehicles closer than downstreamDist along the road network starting on the given position...
Definition: MSLane.cpp:3874
MSLane(const std::string &id, double maxSpeed, double friction, double length, MSEdge *const edge, int numericalID, const PositionVector &shape, double width, SVCPermissions permissions, SVCPermissions changeLeft, SVCPermissions changeRight, int index, bool isRampAccel, const std::string &type)
Constructor.
Definition: MSLane.cpp:232
void clearState()
Remove all vehicles before quick-loading state.
Definition: MSLane.cpp:3386
MSLane * myCanonicalPredecessorLane
Similar to LogicalPredecessorLane,.
Definition: MSLane.h:1437
bool myNeedsCollisionCheck
whether a collision check is currently needed
Definition: MSLane.h:1486
bool isLinkEnd(std::vector< MSLink * >::const_iterator &i) const
Definition: MSLane.h:802
bool allowsVehicleClass(SUMOVehicleClass vclass) const
Definition: MSLane.h:856
virtual double setPartialOccupation(MSVehicle *v)
Sets the information about a vehicle lapping into this lane.
Definition: MSLane.cpp:336
double getVehicleMaxSpeed(const SUMOTrafficObject *const veh) const
Returns the lane's maximum speed, given a vehicle's speed limit adaptation.
Definition: MSLane.h:547
double getRightSideOnEdge() const
Definition: MSLane.h:1118
void checkBufferType()
Definition: MSLane.cpp:298
std::pair< MSVehicle *const, double > getOppositeFollower(const MSVehicle *ego) const
Definition: MSLane.cpp:4073
bool hasPedestrians() const
whether the lane has pedestrians on it
Definition: MSLane.cpp:4171
const std::vector< std::pair< const MSLane *, const MSEdge * > > getOutgoingViaLanes() const
get the list of outgoing lanes
Definition: MSLane.cpp:2968
MSVehicle * getPartialBehind(const MSVehicle *ego) const
Definition: MSLane.cpp:3836
int getIndex() const
Returns the lane's index.
Definition: MSLane.h:597
void setLaneStopOffset(const StopOffset &stopOffset)
Set vehicle class specific stopOffsets.
Definition: MSLane.cpp:3440
double myBruttoVehicleLengthSumToRemove
The length of all vehicles that have left this lane in the current step (this lane,...
Definition: MSLane.h:1449
void leftByLaneChange(MSVehicle *v)
Definition: MSLane.cpp:2992
MSLane * getCanonicalSuccessorLane() const
Definition: MSLane.cpp:2936
void requireCollisionCheck()
require another collision check due to relevant changes in the simulation
Definition: MSLane.h:661
std::vector< StopWatch< std::chrono::nanoseconds > > myStopWatch
Definition: MSLane.h:1669
void setPermissions(SVCPermissions permissions, long long transientID)
Sets the permissions to the given value. If a transientID is given, the permissions are recored as te...
Definition: MSLane.cpp:4138
const double myWidth
Lane width [m].
Definition: MSLane.h:1402
bool lastInsertion(MSVehicle &veh, double mspeed, double posLat, bool patchSpeed)
inserts vehicle as close as possible to the last vehicle on this lane (or at the end of the lane if t...
Definition: MSLane.cpp:432
void changeLanes(const SUMOTime time)
Definition: MSLane.cpp:2169
double getOppositePos(double pos) const
return the corresponding position on the opposite lane
Definition: MSLane.cpp:4017
SVCPermissions myChangeRight
Definition: MSLane.h:1422
const double myLengthGeometryFactor
precomputed myShape.length / myLength
Definition: MSLane.h:1472
virtual void executeMovements(const SUMOTime t)
Executes planned vehicle movements with regards to right-of-way.
Definition: MSLane.cpp:2019
const std::set< const MSBaseVehicle * > & getParkingVehicles() const
retrieve the parking vehicles (see GUIParkingArea)
Definition: MSLane.h:1177
MSLane * getLogicalPredecessorLane() const
get the most likely precedecessor lane (sorted using by_connections_to_sorter). The result is cached ...
Definition: MSLane.cpp:2866
double getBruttoOccupancy() const
Returns the brutto (including minGaps) occupancy of this lane during the last step.
Definition: MSLane.cpp:3036
AnyVehicleIterator anyVehiclesUpstreamEnd() const
end iterator for iterating over all vehicles touching this lane in upstream direction
Definition: MSLane.h:480
int myIndex
The lane index.
Definition: MSLane.h:1350
double getCenterOnEdge() const
Definition: MSLane.h:1126
bool isNormal() const
Definition: MSLane.cpp:2336
double getMeanSpeedBike() const
get the mean speed of all bicycles on this lane
Definition: MSLane.cpp:3100
void updateLeaderInfo(const MSVehicle *veh, VehCont::reverse_iterator &vehPart, VehCont::reverse_iterator &vehRes, MSLeaderInfo &ahead) const
This updates the MSLeaderInfo argument with respect to the given MSVehicle. All leader-vehicles on th...
Definition: MSLane.cpp:1462
double getWaitingSeconds() const
Returns the overall waiting time on this lane.
Definition: MSLane.cpp:3066
void setMaxSpeed(double val)
Sets a new maximum speed for the lane (used by TraCI and MSCalibrator)
Definition: MSLane.cpp:2468
static bool dictionary(const std::string &id, MSLane *lane)
Static (sic!) container methods {.
Definition: MSLane.cpp:2199
virtual bool isSelected() const
whether this lane is selected in the GUI
Definition: MSLane.h:1182
void detectPedestrianJunctionCollision(const MSVehicle *collider, const PositionVector &colliderBoundary, const MSLane *foeLane, SUMOTime timestep, const std::string &stage)
detect whether a vehicle collids with pedestrians on the junction
Definition: MSLane.cpp:1743
virtual void detectCollisions(SUMOTime timestep, const std::string &stage)
Check if vehicles are too close.
Definition: MSLane.cpp:1515
std::vector< MSLink * > myLinks
Definition: MSLane.h:1456
MSVehicle * getLastAnyVehicle() const
returns the last vehicle that is fully or partially on this lane
Definition: MSLane.cpp:2351
bool isInternal() const
Definition: MSLane.cpp:2330
static const long CHANGE_PERMISSIONS_GUI
Definition: MSLane.h:1281
VehCont myPartialVehicles
The lane's partial vehicles. This container holds all vehicles that are partially on this lane but wh...
Definition: MSLane.h:1375
void sortManeuverReservations()
sorts myManeuverReservations
Definition: MSLane.cpp:2311
MinorLinkMode
determine whether/how getFollowers looks upstream beyond minor links
Definition: MSLane.h:902
@ FOLLOW_ONCOMING
Definition: MSLane.h:905
@ FOLLOW_ALWAYS
Definition: MSLane.h:904
@ FOLLOW_NEVER
Definition: MSLane.h:903
int getPartialVehicleNumber() const
Returns the number of vehicles partially on this lane (for which this lane is not responsible)
Definition: MSLane.h:445
double interpolateGeometryPosToLanePos(double geometryPos) const
Definition: MSLane.h:539
AnyVehicleIterator anyVehiclesUpstreamBegin() const
begin iterator for iterating over all vehicles touching this lane in upstream direction
Definition: MSLane.h:474
std::vector< const MSLane * > getNormalIncomingLanes() const
get the list of all direct (disregarding internal predecessors) non-internal predecessor lanes of thi...
Definition: MSLane.cpp:2978
virtual void resetPartialOccupation(MSVehicle *v)
Removes the information about a vehicle lapping into this lane.
Definition: MSLane.cpp:355
SumoRNG * getRNG() const
return the associated RNG
Definition: MSLane.h:245
void setOpposite(MSLane *oppositeLane)
Adds a neighbor to this lane.
Definition: MSLane.cpp:316
static int dictSize()
Returns the number of stored lanes.
Definition: MSLane.h:764
AnyVehicleIterator anyVehiclesBegin() const
begin iterator for iterating over all vehicles touching this lane in downstream direction
Definition: MSLane.h:462
double getHarmonoise_NoiseEmissions() const
Returns the sum of last step noise emissions.
Definition: MSLane.cpp:3125
std::pair< MSVehicle *const, double > getLeader(const MSVehicle *veh, const double vehPos, const std::vector< MSLane * > &bestLaneConts, double dist=-1, bool checkTmpVehicles=false) const
Returns the immediate leader of veh and the distance to veh starting on this lane.
Definition: MSLane.cpp:2589
static bool myExtrapolateSubstepDepart
Definition: MSLane.h:1515
MSLane * getOpposite() const
return the neighboring opposite direction lane for lane changing or nullptr
Definition: MSLane.cpp:4005
void setLength(double val)
Sets a new length for the lane (used by TraCI only)
Definition: MSLane.cpp:2482
std::map< MSEdge *, std::vector< MSLane * > > myApproachingLanes
All direct internal and direct (disregarding internal predecessors) non-internal predecessor lanes of...
Definition: MSLane.h:1459
virtual const VehCont & getVehiclesSecure() const
Returns the vehicles container; locks it for microsimulation.
Definition: MSLane.h:456
virtual void releaseVehicles() const
Allows to use the container for microsimulation again.
Definition: MSLane.h:486
bool mustCheckJunctionCollisions() const
whether this lane must check for junction collisions
Definition: MSLane.cpp:4265
double interpolateLanePosToGeometryPos(double lanePos) const
Definition: MSLane.h:527
virtual void setManeuverReservation(MSVehicle *v)
Registers the lane change intentions (towards this lane) for the given vehicle.
Definition: MSLane.cpp:378
MSLane * getBidiLane() const
retrieve bidirectional lane or nullptr
Definition: MSLane.cpp:4252
static double myCollisionMinGapFactor
Definition: MSLane.h:1514
bool isEmpty() const
Definition: MSLane.h:814
std::pair< MSVehicle *const, double > getLeaderOnConsecutive(double dist, double seen, double speed, const MSVehicle &veh, const std::vector< MSLane * > &bestLaneConts) const
Returns the immediate leader and the distance to him.
Definition: MSLane.cpp:2661
bool hasApproaching(const std::vector< MSLink * > &links) const
check whether any of the outgoing links are being approached
double getLengthGeometryFactor() const
return shape.length() / myLength
Definition: MSLane.h:511
SUMOTime myLeaderInfoTime
time step for which myLeaderInfo was last updated
Definition: MSLane.h:1467
MSLane * myOpposite
Definition: MSLane.h:1489
CollisionAction
Definition: MSLane.h:201
@ COLLISION_ACTION_NONE
Definition: MSLane.h:202
@ COLLISION_ACTION_WARN
Definition: MSLane.h:203
@ COLLISION_ACTION_TELEPORT
Definition: MSLane.h:204
@ COLLISION_ACTION_REMOVE
Definition: MSLane.h:205
MSLane * getParallelOpposite() const
return the opposite direction lane of this lanes edge or nullptr
Definition: MSLane.cpp:4011
std::map< std::string, MSLane * > DictType
definition of the static dictionary type
Definition: MSLane.h:1498
double getFractionalVehicleLength(bool brutto) const
return length of fractional vehicles on this lane
Definition: MSLane.cpp:3017
MSEdge & getEdge() const
Returns the lane's edge.
Definition: MSLane.h:713
double getSpaceTillLastStanding(const MSVehicle *ego, bool &foundStopped) const
return the empty space up to the last standing vehicle or the empty space on the whole lane if no veh...
Definition: MSLane.cpp:4271
double getEmissions() const
Returns the sum of last step emissions The value is always per 1s, so multiply by step length if nece...
Definition: MSLane.h:1092
const MSLane * getNormalPredecessorLane() const
get normal lane leading to this internal lane, for normal lanes, the lane itself is returned
Definition: MSLane.cpp:2891
int getNumericalID() const
Returns this lane's numerical id.
Definition: MSLane.h:498
void setRightSideOnEdge(double value, int rightmostSublane)
Definition: MSLane.h:1108
virtual bool appropriate(const MSVehicle *veh) const
Definition: MSLane.cpp:2255
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...
Definition: MSLane.cpp:3446
double getWidth() const
Returns the lane's width.
Definition: MSLane.h:590
const std::vector< MSLink * > & getLinkCont() const
returns the container with all links !!!
Definition: MSLane.h:675
bool freeInsertion(MSVehicle &veh, double speed, double posLat, MSMoveReminder::Notification notification=MSMoveReminder::NOTIFICATION_DEPARTED)
Tries to insert the given vehicle on any place.
Definition: MSLane.cpp:467
virtual void addMoveReminder(MSMoveReminder *rem)
Add a move-reminder to move-reminder container.
Definition: MSLane.cpp:326
int getRightmostSublane() const
Definition: MSLane.h:1122
double getMeanSpeed() const
Returns the mean speed on this lane.
Definition: MSLane.cpp:3079
double myNettoVehicleLengthSumToRemove
The length of all vehicles that have left this lane in the current step (this lane,...
Definition: MSLane.h:1452
friend class AnyVehicleIterator
Definition: MSLane.h:116
void loadState(const std::vector< std::string > &vehIDs, MSVehicleControl &vc)
Loads the state of this segment with the given parameters.
Definition: MSLane.cpp:3403
const Position geometryPositionAtOffset(double offset, double lateralOffset=0) const
Definition: MSLane.h:533
void setFrictionCoefficient(double val)
Sets a new friction coefficient for the lane [to be later (used by TraCI and MSCalibrator)].
Definition: MSLane.cpp:2475
static CollisionAction getCollisionAction()
Definition: MSLane.h:1276
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.
@ NOTIFICATION_DEPARTED
The vehicle has departed (was inserted into the network)
Export the queueing length in front of a junction (very experimental!)
Definition: MSQueueExport.h:47
The class responsible for building and deletion of vehicles.
Representation of a vehicle in the micro simulation.
Definition: MSVehicle.h:77
Base class for objects which have an id.
Definition: Named.h:54
A storage for options typed value containers)
Definition: OptionsCont.h:89
Static storage of an output device and its base (abstract) implementation.
Definition: OutputDevice.h:61
An upper class for objects with additional parameters.
Definition: Parameterised.h:41
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:37
A list of positions.
Position positionAtOffset(double pos, double lateralOffset=0) const
Returns the position at the given length.
Representation of a vehicle, person, or container.
virtual double getChosenSpeedFactor() const =0
virtual double getMaxSpeed() const =0
Returns the object's maximum speed (minimum of technical and desired maximum speed)
virtual SUMOVehicleClass getVClass() const =0
Returns the object's access class.
Representation of a vehicle.
Definition: SUMOVehicle.h:60
stop offset