1 /****************************************************************************/ 2 // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo 3 // Copyright (C) 2002-2019 German Aerospace Center (DLR) and others. 4 // This program and the accompanying materials 5 // are made available under the terms of the Eclipse Public License v2.0 6 // which accompanies this distribution, and is available at 7 // http://www.eclipse.org/legal/epl-v20.html 8 // SPDX-License-Identifier: EPL-2.0 9 /****************************************************************************/ 10 /// @file MSLink.h 11 /// @author Daniel Krajzewicz 12 /// @author Jakob Erdmann 13 /// @author Michael Behrisch 14 /// @date Sept 2002 15 /// @version $Id$ 16 /// 17 // A connnection between lanes 18 /****************************************************************************/ 19 #ifndef MSLink_h 20 #define MSLink_h 21 22 23 // =========================================================================== 24 // included modules 25 // =========================================================================== 26 #include <config.h> 27 28 #include <vector> 29 #include <set> 30 #include <utils/common/SUMOTime.h> 31 #include <utils/common/SUMOVehicleClass.h> 32 #include <utils/vehicle/SUMOVehicle.h> 33 #include <utils/xml/SUMOXMLDefinitions.h> 34 35 36 // =========================================================================== 37 // class declarations 38 // =========================================================================== 39 class MSLane; 40 class MSJunction; 41 class MSVehicle; 42 class MSPerson; 43 class OutputDevice; 44 class MSTrafficLightLogic; 45 46 47 // =========================================================================== 48 // class definitions 49 // =========================================================================== 50 /** 51 * @class MSLinks 52 * @brief A connnection between lanes 53 * 54 * A link is basically a connection between two lanes, stored within the 55 * originating (the one that is being left) lane and pointing to the 56 * approached lane. When using inner-junction simulation, additionally 57 * a "via-lane" is stored, the one that is used to cross the junction 58 * and which represents the links shape. 59 * 60 * Because right-of-way rules are controlled by the junctions, the link 61 * stores the information about where to write information about approaching 62 * vehicles (the "request") and where to get the information whether the 63 * vehicle really may drive (the "respond"). 64 * 65 * Because a link is a connection over a junction, it basically also has a 66 * length. This length is needed to assure that vehicles have the correct halting 67 * distance before approaching the link. In the case of using internal lanes, 68 * the link's length is 0. 69 */ 70 class MSLink { 71 public: 72 73 // distance to link in m below which adaptation for zipper-merging should take place 74 static const double ZIPPER_ADAPT_DIST; 75 76 struct LinkLeader { 77 LinkLeader(MSVehicle* _veh, double _gap, double _distToCrossing, bool _fromLeft = true) : vehAndGapLinkLeader78 vehAndGap(std::make_pair(_veh, _gap)), 79 distToCrossing(_distToCrossing), 80 fromLeft(_fromLeft) { 81 } 82 83 std::pair<MSVehicle*, double> vehAndGap; 84 double distToCrossing; 85 bool fromLeft; 86 }; 87 88 typedef std::vector<LinkLeader> LinkLeaders; 89 90 /** @struct ApproachingVehicleInformation 91 * @brief A structure holding the information about vehicles approaching a link 92 */ 93 struct ApproachingVehicleInformation { 94 /** @brief Constructor 95 * @param[in] waitingTime The time during which the vehicle is waiting at this link 96 * this needs to be placed here because MSVehicle::myWaitingTime is updated in between 97 * calls to opened() causing order dependencies 98 **/ ApproachingVehicleInformationApproachingVehicleInformation99 ApproachingVehicleInformation(const SUMOTime _arrivalTime, const SUMOTime _leavingTime, 100 const double _arrivalSpeed, const double _leaveSpeed, 101 const bool _willPass, 102 const SUMOTime _arrivalTimeBraking, 103 const double _arrivalSpeedBraking, 104 const SUMOTime _waitingTime, 105 const double _dist 106 ) : 107 arrivalTime(_arrivalTime), leavingTime(_leavingTime), 108 arrivalSpeed(_arrivalSpeed), leaveSpeed(_leaveSpeed), 109 willPass(_willPass), 110 arrivalTimeBraking(_arrivalTimeBraking), 111 arrivalSpeedBraking(_arrivalSpeedBraking), 112 waitingTime(_waitingTime), 113 dist(_dist) { 114 } 115 116 /// @brief The time the vehicle's front arrives at the link 117 const SUMOTime arrivalTime; 118 /// @brief The estimated time at which the vehicle leaves the link 119 const SUMOTime leavingTime; 120 /// @brief The estimated speed with which the vehicle arrives at the link (for headway computation) 121 const double arrivalSpeed; 122 /// @brief The estimated speed with which the vehicle leaves the link (for headway computation) 123 const double leaveSpeed; 124 /// @brief Whether the vehicle wants to pass the link (@todo: check semantics) 125 const bool willPass; 126 /// @brief The time the vehicle's front arrives at the link if it starts braking 127 const SUMOTime arrivalTimeBraking; 128 /// @brief The estimated speed with which the vehicle arrives at the link if it starts braking(for headway computation) 129 const double arrivalSpeedBraking; 130 /// @brief The waiting duration at the current link 131 const SUMOTime waitingTime; 132 /// @brief The distance up to the current link 133 const double dist; 134 135 private: 136 /// invalidated assignment operator 137 ApproachingVehicleInformation& operator=(const ApproachingVehicleInformation& s); 138 139 }; 140 141 142 /** @brief Constructor for simulation which uses internal lanes 143 * 144 * @param[in] succLane The lane approached by this link 145 * @param[in] via The lane to use within the junction 146 * @param[in] dir The direction of this link 147 * @param[in] state The state of this link 148 * @param[in] length The length of this link 149 */ 150 MSLink(MSLane* predLane, MSLane* succLane, MSLane* via, LinkDirection dir, LinkState state, double length, double foeVisibilityDistance, bool keepClear, MSTrafficLightLogic* logic, int tlLinkIdx); 151 152 153 /// @brief Destructor 154 ~MSLink(); 155 156 157 /** @brief Sets the request information 158 * 159 * Because traffic lights and junction logics are loaded after links, 160 * we have to assign the information about the right-of-way 161 * requests and responses after the initialisation. 162 * @todo Unsecure! 163 */ 164 void setRequestInformation(int index, bool hasFoes, bool isCont, 165 const std::vector<MSLink*>& foeLinks, const std::vector<MSLane*>& foeLanes, 166 MSLane* internalLaneBefore = 0); 167 168 /// @brief add walkingarea as foe (when entering the junction) addWalkingAreaFoe(const MSLane * lane)169 void addWalkingAreaFoe(const MSLane* lane) { 170 myWalkingAreaFoe = lane; 171 } 172 173 /// @brief add walkingarea as foe (when leaving the junction) addWalkingAreaFoeExit(const MSLane * lane)174 void addWalkingAreaFoeExit(const MSLane* lane) { 175 myWalkingAreaFoeExit = lane; 176 } 177 178 /// @brief get walkingarea as foes getWalkingAreaFoe()179 const MSLane* getWalkingAreaFoe() { 180 return myWalkingAreaFoe; 181 } getWalkingAreaFoeExit()182 const MSLane* getWalkingAreaFoeExit() { 183 return myWalkingAreaFoeExit; 184 } 185 186 /** @brief Sets the information about an approaching vehicle 187 * 188 * The information is stored in myApproachingVehicles. 189 */ 190 void setApproaching(const SUMOVehicle* approaching, const SUMOTime arrivalTime, 191 const double arrivalSpeed, const double leaveSpeed, const bool setRequest, 192 const SUMOTime arrivalTimeBraking, const double arrivalSpeedBraking, 193 const SUMOTime waitingTime, double dist); 194 195 /** @brief Sets the information about an approaching vehicle */ 196 void setApproaching(const SUMOVehicle* approaching, ApproachingVehicleInformation ai); 197 198 /// @brief removes the vehicle from myApproachingVehicles 199 void removeApproaching(const SUMOVehicle* veh); 200 201 void addBlockedLink(MSLink* link); 202 203 /* @brief return information about this vehicle if it is registered as 204 * approaching (dummy values otherwise) 205 * @note used for visualisation of link items */ 206 ApproachingVehicleInformation getApproaching(const SUMOVehicle* veh) const; 207 208 /// @brief return all approaching vehicles getApproaching()209 const std::map<const SUMOVehicle*, const ApproachingVehicleInformation, ComparatorNumericalIdLess>& getApproaching() const { 210 return myApproachingVehicles; 211 } 212 213 /** @brief Returns the information whether the link may be passed 214 * 215 * Valid after the junctions have set their reponds 216 * 217 * @param[in] collectFoes If a vector is passed, all blocking foes are collected and inserted into this vector 218 * @return Whether this link may be passed. 219 */ 220 bool opened(SUMOTime arrivalTime, double arrivalSpeed, double leaveSpeed, double vehicleLength, 221 double impatience, double decel, SUMOTime waitingTime, 222 double posLat = 0, 223 std::vector<const SUMOVehicle*>* collectFoes = 0, 224 bool ignoreRed = false, 225 const SUMOVehicle* ego = 0) const; 226 227 /** @brief Returns the information whether this link is blocked 228 * Valid after the vehicles have set their requests 229 * @param[in] arrivalTime The arrivalTime of the vehicle who checks for an approaching foe 230 * @param[in] leaveTime The leaveTime of the vehicle who checks for an approaching foe 231 * @param[in] arrivalSpeed The speed with which the checking vehicle plans to arrive at the link 232 * @param[in] leaveSpeed The speed with which the checking vehicle plans to leave the link 233 * @param[in] sameTargetLane Whether the link that calls this method has the same target lane as this link 234 * @param[in] impatience The impatience of the checking vehicle 235 * @param[in] decel The maximum deceleration of the checking vehicle 236 * @param[in] waitingTime The waiting time of the checking vehicle 237 * @param[in] collectFoes If a vector is passed the return value is always False, instead all blocking foes are collected and inserted into this vector 238 * @return Whether this link is blocked 239 * @note Since this needs to be called without a SUMOVehicle (TraCI), we cannot simply pass the checking vehicle itself 240 **/ 241 bool blockedAtTime(SUMOTime arrivalTime, SUMOTime leaveTime, double arrivalSpeed, double leaveSpeed, 242 bool sameTargetLane, double impatience, double decel, SUMOTime waitingTime, 243 std::vector<const SUMOVehicle*>* collectFoes = 0, const SUMOVehicle* ego = 0) const; 244 245 isBlockingAnyone()246 bool isBlockingAnyone() const { 247 return myApproachingVehicles.size() != 0; 248 } 249 250 bool willHaveBlockedFoe() const; 251 252 253 254 /** @brief Returns the information whether a vehicle is approaching on one of the link's foe streams 255 * 256 * Valid after the vehicles have set their requests 257 * @param[in] arrivalTime The arrivalTime of the vehicle who checks for an approaching foe 258 * @param[in] leaveTime The leaveTime of the vehicle who checks for an approaching foe 259 * @param[in] speed The speed with which the checking vehicle plans to leave the link 260 * @param[in] decel The maximum deceleration of the checking vehicle 261 * @return Whether a foe of this link is approaching 262 */ 263 bool hasApproachingFoe(SUMOTime arrivalTime, SUMOTime leaveTime, double speed, double decel) const; 264 getJunction()265 MSJunction* getJunction() const { 266 return myJunction; 267 } 268 269 270 /** @brief Returns the current state of the link 271 * 272 * @return The current state of this link 273 */ getState()274 LinkState getState() const { 275 return myState; 276 } 277 278 279 /** @brief Returns the off-state for the link 280 * 281 * @return The current state of this link 282 */ getOffState()283 LinkState getOffState() const { 284 return myOffState; 285 } 286 287 288 //@brief Returns the time of the last state change getLastStateChange()289 inline SUMOTime getLastStateChange() const { 290 return myLastStateChange; 291 } 292 293 294 /** @brief Returns the direction the vehicle passing this link take 295 * 296 * @return The direction of this link 297 */ 298 LinkDirection getDirection() const; 299 300 301 /** @brief Sets the current tl-state 302 * 303 * @param[in] state The current state of the link 304 * @param[in] t The time of the state change 305 */ 306 void setTLState(LinkState state, SUMOTime t); 307 308 309 /** @brief Returns the connected lane 310 * 311 * @return The lane approached by this link 312 */ 313 MSLane* getLane() const; 314 315 316 /** @brief Returns the respond index (for visualization) 317 * 318 * @return The respond index for this link 319 */ getIndex()320 inline int getIndex() const { 321 return myIndex; 322 } 323 324 /** @brief Returns the TLS index */ getTLIndex()325 inline int getTLIndex() const { 326 return myTLIndex; 327 } 328 329 /** @brief Returns the TLS index */ getTLLogic()330 inline const MSTrafficLightLogic* getTLLogic() const { 331 return myLogic; 332 } 333 334 /** @brief Returns whether this link is a major link 335 * @return Whether the link has a large priority 336 */ havePriority()337 inline bool havePriority() const { 338 return myState >= 'A' && myState <= 'Z'; 339 } 340 341 /** @brief Returns whether this link is blocked by a red (or redyellow) traffic light 342 * @return Whether the link has a red light 343 */ haveRed()344 inline bool haveRed() const { 345 return myState == LINKSTATE_TL_RED || myState == LINKSTATE_TL_REDYELLOW; 346 } 347 haveYellow()348 inline bool haveYellow() const { 349 return myState == LINKSTATE_TL_YELLOW_MINOR || myState == LINKSTATE_TL_YELLOW_MAJOR; 350 } 351 isTLSControlled()352 inline bool isTLSControlled() const { 353 return myLogic != 0; 354 } 355 356 /** @brief Returns the length of this link 357 * 358 * @return The length of this link 359 */ getLength()360 double getLength() const { 361 return myLength; 362 } 363 364 365 /** @brief Returns the distance on the approaching lane from which an 366 * approaching vehicle is able to see all relevant foes and 367 * may accelerate if the link is minor and no foe is approaching. 368 * 369 * @return The foe-visibility-distance 370 */ getFoeVisibilityDistance()371 double getFoeVisibilityDistance() const { 372 return myFoeVisibilityDistance; 373 } 374 375 376 /** @brief Returns whether this link belongs to a junction where more than one edge is incoming 377 * 378 * @return Whether any foe links exist 379 */ hasFoes()380 bool hasFoes() const { 381 return myHasFoes; 382 } 383 384 // @brief return whether the vehicle may continute past this link to wait within the intersection 385 bool isCont() const; 386 387 388 /// @brief whether the junction after this link must be kept clear keepClear()389 bool keepClear() const { 390 return myKeepClear; 391 } 392 393 /// @brief whether this is a link past an internal junction which currently has priority 394 bool lastWasContMajor() const; 395 396 /** @brief Returns the cumulative length of all internal lanes after this link 397 * @return sum of the lengths of all internal lanes following this link 398 */ 399 double getInternalLengthsAfter() const; 400 401 /** @brief Returns the cumulative length of all internal lanes before this link 402 * @return sum of the lengths of all internal lanes before this link 403 */ 404 double getInternalLengthsBefore() const; 405 406 /** @brief Returns the sum of the lengths along internal lanes following this link 407 * to the crossing with the given foe lane, if the lane is no foe 408 * lane to any of the internal lanes, INVALID_DOUBLE is returned. 409 * @see getLengthBeforeCrossing() 410 */ 411 double getLengthsBeforeCrossing(const MSLane* foeLane) const; 412 413 414 /** @brief Returns the internal length from the beginning of the link's internal lane before 415 * to the crossing with the given foe lane if applicable, if the lane is no foe 416 * lane to the link, INVALID_DOUBLE is returned. 417 * @see getLengthsBeforeCrossing() 418 */ 419 double getLengthBeforeCrossing(const MSLane* foeLane) const; 420 421 422 /** @brief Returns the following inner lane 423 * 424 * @return The inner lane to use to cross the junction 425 */ 426 MSLane* getViaLane() const; 427 428 /** @brief Returns all potential link leaders (vehicles on foeLanes) 429 * Valid during the planMove() phase 430 * @param[in] ego The ego vehicle that is looking for leaders 431 * @param[in] dist The distance of the vehicle who is asking about the leader to this link 432 * @param[out] blocking Return blocking pedestrians if a vector is given 433 * @param[in] isShadowLink whether this link is a shadowLink for ego 434 * @return The all vehicles on foeLanes and their (virtual) distances to the asking vehicle 435 */ 436 LinkLeaders getLeaderInfo(const MSVehicle* ego, double dist, std::vector<const MSPerson*>* collectBlockers = 0, bool isShadowLink = false) const; 437 438 /// @brief check for persons on walkingarea in the path of ego vehicle 439 void checkWalkingAreaFoe(const MSVehicle* ego, const MSLane* foeLane, std::vector<const MSPerson*>* collectBlockers, LinkLeaders& result) const; 440 441 /// @brief return the speed at which ego vehicle must approach the zipper link 442 double getZipperSpeed(const MSVehicle* ego, const double dist, double vSafe, 443 SUMOTime arrivalTime, 444 std::vector<const SUMOVehicle*>* collectFoes) const; 445 446 /// @brief return the via lane if it exists and the lane otherwise 447 MSLane* getViaLaneOrLane() const; 448 449 /// @brief return the internalLaneBefore if it exists and the laneBefore otherwise 450 const MSLane* getLaneBefore() const; 451 452 /// @brief return myInternalLaneBefore (always 0 when compiled without internal lanes) 453 const MSLane* getInternalLaneBefore() const; 454 455 /// @brief return the expected time at which the given vehicle will clear the link 456 SUMOTime getLeaveTime(const SUMOTime arrivalTime, const double arrivalSpeed, const double leaveSpeed, const double vehicleLength) const; 457 458 /// @brief write information about all approaching vehicles to the given output device 459 void writeApproaching(OutputDevice& od, const std::string fromLaneID) const; 460 461 /// @brief return the link that is parallel to this lane or 0 462 MSLink* getParallelLink(int direction) const; 463 464 /// @brief return whether the fromLane of this link is an internal lane 465 bool fromInternalLane() const; 466 467 /// @brief return whether the toLane of this link is an internal lane and fromLane is a normal lane 468 bool isEntryLink() const; 469 470 /// @brief return whether this link enters the conflict area (not a continuation link) 471 bool isConflictEntryLink() const; 472 473 /// @brief return whether the fromLane of this link is an internal lane and toLane is a normal lane 474 bool isExitLink() const; 475 476 /// @brief return whether the fromLane of this link is an internal lane and its incoming lane is also an internal lane 477 bool isExitLinkAfterInternalJunction() const; 478 479 /// @brief returns the corresponding exit link for entryLinks to a junction. 480 MSLink* getCorrespondingExitLink() const; 481 482 /// @brief return whether the fromLane and the toLane of this link are internal lanes 483 bool isInternalJunctionLink() const; 484 485 /** @brief Returns the time penalty for passing a tls-controlled link (meso) */ getMesoTLSPenalty()486 SUMOTime getMesoTLSPenalty() const { 487 return myMesoTLSPenalty; 488 } 489 490 /** @brief Returns the average proportion of green time to cycle time */ getGreenFraction()491 double getGreenFraction() const { 492 return myGreenFraction; 493 } 494 495 /** @brief Sets the time penalty for passing a tls-controlled link (meso) */ setMesoTLSPenalty(const SUMOTime penalty)496 void setMesoTLSPenalty(const SUMOTime penalty) { 497 myMesoTLSPenalty = penalty; 498 } 499 500 /** @brief Sets the green fraction for passing a tls-controlled link (meso) */ setGreenFraction(const double fraction)501 void setGreenFraction(const double fraction) { 502 myGreenFraction = fraction; 503 } 504 getFoeLanes()505 const std::vector<const MSLane*>& getFoeLanes() const { 506 return myFoeLanes; 507 } 508 getLengthsBehindCrossing()509 const std::vector<std::pair<double, double> >& getLengthsBehindCrossing() const { 510 return myLengthsBehindCrossing; 511 } 512 getFoeLinks()513 const std::vector<MSLink*>& getFoeLinks() const { 514 return myFoeLinks; 515 } 516 517 /// @brief initialize parallel links (to be called after all links are loaded) 518 void initParallelLinks(); 519 520 /// @brief return lateral shift that must be applied when passing this link getLateralShift()521 double getLateralShift() { 522 return myLateralShift; 523 } 524 525 private: 526 /// @brief return whether the given vehicles may NOT merge safely unsafeMergeSpeeds(double leaderSpeed,double followerSpeed,double leaderDecel,double followerDecel)527 static inline bool unsafeMergeSpeeds(double leaderSpeed, double followerSpeed, double leaderDecel, double followerDecel) { 528 // XXX mismatch between continuous an discrete deceleration 529 return (leaderSpeed * leaderSpeed / leaderDecel) <= (followerSpeed * followerSpeed / followerDecel); 530 } 531 532 /// @brief returns whether the given lane may still be occupied by a vehicle currently on it 533 static bool maybeOccupied(MSLane* lane); 534 535 /// @brief whether fllower could stay behind leader (possibly by braking) 536 static bool couldBrakeForLeader(double followDist, double leaderDist, const MSVehicle* follow, const MSVehicle* leader); 537 538 MSLink* computeParallelLink(int direction); 539 540 bool blockedByFoe(const SUMOVehicle* veh, const ApproachingVehicleInformation& avi, 541 SUMOTime arrivalTime, SUMOTime leaveTime, double arrivalSpeed, double leaveSpeed, 542 bool sameTargetLane, double impatience, double decel, SUMOTime waitingTime, 543 const SUMOVehicle* ego) const; 544 545 /// @brief figure out whether the cont status remains in effect when switching off the tls 546 bool checkContOff() const; 547 548 /// @brief check if the lane intersects with a foe cont-lane 549 bool contIntersect(const MSLane* lane, const MSLane* foe); 550 551 private: 552 /// @brief The lane behind the junction approached by this link 553 MSLane* myLane; 554 555 /// @brief The lane approaching this link 556 MSLane* myLaneBefore; 557 558 std::map<const SUMOVehicle*, const ApproachingVehicleInformation, ComparatorNumericalIdLess> myApproachingVehicles; 559 std::set<MSLink*> myBlockedFoeLinks; 560 561 /// @brief The position within this respond 562 int myIndex; 563 564 /// @brief the traffic light index 565 const int myTLIndex; 566 567 /// @brief the controlling logic or 0 568 const MSTrafficLightLogic* myLogic; 569 570 /// @brief The state of the link 571 LinkState myState; 572 /// @brief The state of the link when switching of traffic light control 573 const LinkState myOffState; 574 575 /// @brief The time of the last state change 576 SUMOTime myLastStateChange; 577 578 /// @brief An abstract (hopefully human readable) definition of the link's direction 579 LinkDirection myDirection; 580 581 /// @brief The length of the link 582 /// @note This is not equal to the result of getInternalLengthsAfter for links with more than one internal lane. 583 double myLength; 584 585 /// @brief distance from which an approaching vehicle is able to 586 /// see all relevant foes and may accelerate if the link is minor 587 /// and no foe is approaching. Defaults to 4.5m. 588 double myFoeVisibilityDistance; 589 590 /// @brief Whether any foe links exist 591 bool myHasFoes; 592 593 // @brief whether vehicles may continue past this link to wait within the intersection 594 bool myAmCont; 595 // @brief whether vehicles may continue past this link to wait within the intersection after switching of the traffic light at this intersection 596 bool myAmContOff; 597 598 // @brief whether vehicles must keep the intersection clear if there is a downstream jam 599 bool myKeepClear; 600 601 /// @brief The following junction-internal lane if used 602 MSLane* const myInternalLane; 603 604 /* @brief The preceding junction-internal lane, only used at 605 * - exit links (from internal lane to normal lane) 606 * - internal junction links (from internal lane to internal lane) 607 */ 608 const MSLane* myInternalLaneBefore; 609 610 /// @brief penalty time at tls for mesoscopic simulation 611 SUMOTime myMesoTLSPenalty; 612 /// @brief green fraction at tls for mesoscopic simulation 613 double myGreenFraction; 614 615 /// @brief lateral shift to be applied when passing this link 616 double myLateralShift; 617 618 /* @brief lengths after the crossing point with foeLane 619 * (lengthOnThis, lengthOnFoe) 620 * (index corresponds to myFoeLanes) 621 * empty vector for entry links 622 * */ 623 std::vector<std::pair<double, double> > myLengthsBehindCrossing; 624 625 // TODO: documentation 626 std::vector<MSLink*> myFoeLinks; 627 std::vector<const MSLane*> myFoeLanes; 628 629 /// @brief walkingArea that must be checked when entering the intersection 630 const MSLane* myWalkingAreaFoe; 631 /// @brief walkingArea that must be checked when leaving the intersection 632 const MSLane* myWalkingAreaFoeExit; 633 634 /// @brief whether on of myFoeLanes is a crossing 635 bool myHavePedestrianCrossingFoe; 636 637 /* @brief Links with the same origin lane and the same destination edge that may 638 be in conflict for sublane simulation */ 639 std::vector<MSLink*> mySublaneFoeLinks; 640 /* @brief Links with the same origin lane and different destination edge that may 641 be in conflict for sublane simulation */ 642 std::vector<MSLink*> mySublaneFoeLinks2; 643 644 /* @brief Internal Lanes with the same origin lane and the same destination edge that may 645 be in conflict for sublane simulation */ 646 std::vector<MSLane*> mySublaneFoeLanes; 647 648 static const SUMOTime myLookaheadTime; 649 static const SUMOTime myLookaheadTimeZipper; 650 651 MSLink* myParallelRight; 652 MSLink* myParallelLeft; 653 654 /// @brief the junction to which this link belongs 655 MSJunction* myJunction; 656 657 /// invalidated copy constructor 658 MSLink(const MSLink& s); 659 660 /// invalidated assignment operator 661 MSLink& operator=(const MSLink& s); 662 663 }; 664 665 666 #endif 667 668 /****************************************************************************/ 669 670