LCOV - code coverage report
Current view: top level - src/microsim - MSEdge.cpp (source / functions) Coverage Total Hit
Test: lcov.info Lines: 96.1 % 823 791
Test Date: 2026-10-12 15:53:19 Functions: 95.6 % 91 87

            Line data    Source code
       1              : /****************************************************************************/
       2              : // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
       3              : // Copyright (C) 2001-2026 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              : /****************************************************************************/
      14              : /// @file    MSEdge.cpp
      15              : /// @author  Christian Roessel
      16              : /// @author  Jakob Erdmann
      17              : /// @author  Christoph Sommer
      18              : /// @author  Daniel Krajzewicz
      19              : /// @author  Laura Bieker
      20              : /// @author  Michael Behrisch
      21              : /// @author  Sascha Krieg
      22              : /// @date    Tue, 06 Mar 2001
      23              : ///
      24              : // A road/street connecting two junctions
      25              : /****************************************************************************/
      26              : #include <config.h>
      27              : 
      28              : #include <algorithm>
      29              : #include <iostream>
      30              : #include <cassert>
      31              : #ifdef HAVE_FOX
      32              : #include <utils/common/ScopedLocker.h>
      33              : #endif
      34              : #include <utils/common/StringTokenizer.h>
      35              : #include <utils/options/OptionsCont.h>
      36              : #include <microsim/devices/MSRoutingEngine.h>
      37              : #include <mesosim/MELoop.h>
      38              : #include <mesosim/MESegment.h>
      39              : #include <mesosim/MEVehicle.h>
      40              : #include "MSInsertionControl.h"
      41              : #include "MSJunction.h"
      42              : #include "MSLane.h"
      43              : #include "MSLaneChanger.h"
      44              : #include "MSLaneChangerSublane.h"
      45              : #include "MSLink.h"
      46              : #include "MSGlobals.h"
      47              : #include "MSNet.h"
      48              : #include "MSVehicle.h"
      49              : #include "MSLeaderInfo.h"
      50              : #include <microsim/transportables/MSTransportable.h>
      51              : #include "MSEdgeWeightsStorage.h"
      52              : #include "MSEdge.h"
      53              : 
      54              : #define BEST_LANE_LOOKAHEAD 3000.0
      55              : 
      56              : // ===========================================================================
      57              : // static member definitions
      58              : // ===========================================================================
      59              : MSEdge::DictType MSEdge::myDict;
      60              : MSEdgeVector MSEdge::myEdges;
      61              : SVCPermissions MSEdge::myMesoIgnoredVClasses(0);
      62              : DepartLaneDefinition MSEdge::myDefaultDepartLaneDefinition(DepartLaneDefinition::DEFAULT);
      63              : int MSEdge::myDefaultDepartLane(0);
      64              : 
      65              : // ===========================================================================
      66              : // member method definitions
      67              : // ===========================================================================
      68      2041942 : MSEdge::MSEdge(const std::string& id, int numericalID,
      69              :                const SumoXMLEdgeFunc function,
      70              :                const std::string& streetName,
      71              :                const std::string& edgeType,
      72              :                const std::string& routingType,
      73              :                int priority,
      74      2041942 :                double distance) :
      75      2041942 :     Named(id), myNumericalID(numericalID), myLanes(nullptr),
      76      2041942 :     myLaneChanger(nullptr), myFunction(function), myVaporizationRequests(0),
      77      2041942 :     myLastFailedInsertionTime(-1),
      78      2041942 :     myFromJunction(nullptr), myToJunction(nullptr),
      79      2041942 :     myHaveTransientPermissions(false),
      80      2041942 :     myOtherTazConnector(nullptr),
      81      2041942 :     myStreetName(streetName),
      82      2041942 :     myEdgeType(edgeType),
      83      2041942 :     myRoutingType(routingType),
      84      2041942 :     myPriority(priority),
      85      2041942 :     myDistance(distance),
      86      2041942 :     myWidth(0.),
      87      2041942 :     myLength(0.),
      88      2041942 :     myEmptyTraveltime(0.),
      89      2041942 :     myTimePenalty(0.),
      90      2041942 :     myAmDelayed(false),
      91      2041942 :     myAmRoundabout(false),
      92      2041942 :     myAmFringe(true),
      93      4083884 :     myBidiEdge(nullptr)
      94      2041942 : { }
      95              : 
      96              : 
      97      3525302 : MSEdge::~MSEdge() {
      98      2026417 :     delete myLaneChanger;
      99      2026417 :     delete myReversedRoutingEdge;
     100      2026417 :     delete myRailwayRoutingEdge;
     101     13657387 : }
     102              : 
     103              : 
     104              : void
     105      1902641 : MSEdge::initialize(const std::vector<MSLane*>* lanes) {
     106              :     assert(lanes != 0);
     107      1902641 :     myLanes = std::shared_ptr<const std::vector<MSLane*> >(lanes);
     108      1902641 :     if (myFunction == SumoXMLEdgeFunc::CONNECTOR) {
     109        72116 :         myCombinedPermissions = SVCAll;
     110              :     }
     111      4099497 :     for (MSLane* const lane : *lanes) {
     112      2196856 :         lane->setRightSideOnEdge(myWidth, (int)mySublaneSides.size());
     113      2196856 :         MSLeaderInfo ahead(lane->getWidth());
     114      5114897 :         for (int j = 0; j < ahead.numSublanes(); ++j) {
     115      2918041 :             mySublaneSides.push_back(myWidth + j * MSGlobals::gLateralResolution);
     116              :         }
     117      2196856 :         myWidth += lane->getWidth();
     118      2196856 :     }
     119      1902641 : }
     120              : 
     121              : 
     122      1951436 : void MSEdge::recalcCache() {
     123      1951436 :     if (myLanes->empty()) {
     124              :         return;
     125              :     }
     126      1951436 :     myLength = myLanes->front()->getLength();
     127      3902872 :     myEmptyTraveltime = myLength / MAX2(getSpeedLimit(), NUMERICAL_EPS);
     128      1951436 :     if (isNormal() && (MSGlobals::gUseMesoSim || MSGlobals::gTLSPenalty > 0)) {
     129              :         SUMOTime minorPenalty = 0;
     130       196608 :         bool haveTLSPenalty = MSGlobals::gTLSPenalty > 0;
     131       196608 :         if (MSGlobals::gUseMesoSim) {
     132       196470 :             const MESegment::MesoEdgeType& edgeType = MSNet::getInstance()->getMesoType(getEdgeType());
     133       196470 :             minorPenalty = edgeType.minorPenalty;
     134       196470 :             haveTLSPenalty = edgeType.tlsPenalty > 0;
     135              :         }
     136       196608 :         if (haveTLSPenalty || minorPenalty > 0) {
     137              :             // add tls penalties to the minimum travel time
     138              :             SUMOTime minPenalty = -1;
     139         2654 :             for (const MSLane* const l : *myLanes) {
     140         4254 :                 for (const MSLink* const link : l->getLinkCont()) {
     141         2466 :                     if (link->getLane()->isWalkingArea() && link->getLaneBefore()->isNormal()) {
     142           72 :                         continue;
     143              :                     }
     144         2394 :                     SUMOTime linkPenalty = link->isTLSControlled() ? link->getMesoTLSPenalty() : (link->havePriority() ? 0 : minorPenalty);
     145         2394 :                     if (minPenalty == -1) {
     146              :                         minPenalty = linkPenalty;
     147              :                     } else {
     148              :                         minPenalty = MIN2(minPenalty, linkPenalty);
     149              :                     }
     150              :                 }
     151              :             }
     152          866 :             if (minPenalty > 0) {
     153          292 :                 myEmptyTraveltime += STEPS2TIME(minPenalty);
     154          292 :                 myTimePenalty = STEPS2TIME(minPenalty);
     155              :             }
     156              :         }
     157      1754828 :     } else if (isCrossing() && MSGlobals::gTLSPenalty > 0) {
     158              :         // penalties are recorded for the entering link
     159          128 :         for (const auto& ili : myLanes->front()->getIncomingLanes()) {
     160           64 :             double penalty = STEPS2TIME(ili.viaLink->getMesoTLSPenalty());
     161           64 :             if (!ili.viaLink->haveOffPriority()) {
     162            0 :                 penalty = MAX2(penalty, MSGlobals::gMinorPenalty);
     163              :             }
     164           64 :             if (penalty > 0) {
     165           24 :                 myEmptyTraveltime += penalty;
     166           24 :                 myTimePenalty = penalty;
     167              :             }
     168              :         }
     169      1754764 :     } else if (isInternal() && MSGlobals::gUsingInternalLanes) {
     170      1038338 :         const MSLink* link = myLanes->front()->getIncomingLanes()[0].viaLink;
     171      1038338 :         if (!link->isTLSControlled() && !link->havePriority()) {
     172       514057 :             if (link->isTurnaround()) {
     173       196513 :                 myEmptyTraveltime += MSGlobals::gTurnaroundPenalty;
     174       196513 :                 myTimePenalty = MSGlobals::gTurnaroundPenalty;
     175              :             } else {
     176       317544 :                 myEmptyTraveltime += MSGlobals::gMinorPenalty;
     177       317544 :                 myTimePenalty = MSGlobals::gMinorPenalty;
     178              :             }
     179              :         }
     180              :     }
     181              : }
     182              : 
     183              : 
     184              : void
     185           48 : MSEdge::resetTAZ(MSJunction* junction) {
     186              :     mySuccessors.clear();
     187              :     myPredecessors.clear();
     188          832 :     for (const MSEdge* edge : junction->getIncoming()) {
     189          784 :         if (!edge->isInternal()) {
     190          144 :             MSEdgeVector& succ = const_cast<MSEdgeVector&>(edge->mySuccessors);
     191              :             MSConstEdgePairVector& succVia = const_cast<MSConstEdgePairVector&>(edge->myViaSuccessors);
     192          144 :             MSEdgeVector& pred = const_cast<MSEdgeVector&>(edge->myPredecessors);
     193          144 :             auto it = std::find(succ.begin(), succ.end(), this);
     194          144 :             auto it2 = std::find(succVia.begin(), succVia.end(), std::make_pair(const_cast<const MSEdge*>(this), (const MSEdge*)nullptr));
     195          144 :             auto it3 = std::find(pred.begin(), pred.end(), this);
     196          144 :             if (it != succ.end()) {
     197              :                 succ.erase(it);
     198              :                 succVia.erase(it2);
     199              :             }
     200          144 :             if (it3 != pred.end()) {
     201              :                 pred.erase(it3);
     202              :             }
     203              :         }
     204              :     }
     205           48 : }
     206              : 
     207              : void
     208      1827995 : MSEdge::closeBuilding() {
     209      4021898 :     for (MSLane* const lane : *myLanes) {
     210      5209078 :         for (MSLink* const link : lane->getLinkCont()) {
     211      3015175 :             link->initParallelLinks();
     212              :             MSLane* const toL = link->getLane();
     213              :             MSLane* const viaL = link->getViaLane();
     214      3015175 :             if (toL != nullptr) {
     215              :                 MSEdge& to = toL->getEdge();
     216      3015175 :                 if (std::find(mySuccessors.begin(), mySuccessors.end(), &to) == mySuccessors.end()) {
     217      2811788 :                     mySuccessors.push_back(&to);
     218      5623576 :                     myViaSuccessors.push_back(std::make_pair(&to, (viaL == nullptr ? nullptr : &viaL->getEdge())));
     219              :                 }
     220      3015175 :                 if (std::find(to.myPredecessors.begin(), to.myPredecessors.end(), this) == to.myPredecessors.end()) {
     221      2811788 :                     to.myPredecessors.push_back(this);
     222              :                 }
     223      3015175 :                 if (link->getDirection() != LinkDirection::TURN) {
     224      2350405 :                     myAmFringe = false;
     225              :                 }
     226              :             }
     227      3015175 :             if (viaL != nullptr) {
     228              :                 MSEdge& to = viaL->getEdge();
     229      1062925 :                 if (std::find(to.myPredecessors.begin(), to.myPredecessors.end(), this) == to.myPredecessors.end()) {
     230       980984 :                     to.myPredecessors.push_back(this);
     231              :                 }
     232              :             }
     233              :         }
     234      2193903 :         lane->checkBufferType();
     235              :     }
     236      1827995 :     std::sort(mySuccessors.begin(), mySuccessors.end(), by_id_sorter());
     237      1827995 :     rebuildAllowedLanes(true);
     238      1827995 :     recalcCache();
     239              : 
     240              :     // extend lookup table for sublane model after all edges are read
     241      1827995 :     if (myLanes->back()->getOpposite() != nullptr) {
     242         8494 :         MSLane* opposite = myLanes->back()->getOpposite();
     243         8494 :         MSLeaderInfo ahead(opposite->getWidth());
     244        23054 :         for (int j = 0; j < ahead.numSublanes(); ++j) {
     245        14560 :             mySublaneSides.push_back(myWidth + j * MSGlobals::gLateralResolution);
     246              :         }
     247         8494 :     }
     248      1827995 : }
     249              : 
     250              : 
     251              : void
     252      1827987 : MSEdge::postLoadInitLaneChanger() {
     253      1827987 :     if (myLaneChanger != nullptr) {
     254       448715 :         myLaneChanger->postloadInitLC();
     255              :     }
     256      1827987 : }
     257              : 
     258              : void
     259      1827995 : MSEdge::buildLaneChanger() {
     260      1827995 :     if (!myLanes->empty()) {
     261      1827995 :         const bool allowChanging = allowsLaneChanging();
     262      1827995 :         if (MSGlobals::gLateralResolution > 0) {
     263              :             // may always initiate sublane-change
     264       185558 :             if (!isInternal() || MSGlobals::gUsingInternalLanes) {
     265       185343 :                 myLaneChanger = new MSLaneChangerSublane(myLanes.get(), allowChanging);
     266              :             }
     267              :         } else {
     268      1642437 :             if (MSGlobals::gLaneChangeDuration > 0) {
     269         4985 :                 myLaneChanger = new MSLaneChanger(myLanes.get(), allowChanging);
     270      1637452 :             } else if (myLanes->size() > 1 || canChangeToOpposite()) {
     271       258395 :                 myLaneChanger = new MSLaneChanger(myLanes.get(), allowChanging);
     272              :             }
     273              :         }
     274              :     }
     275      1827995 : }
     276              : 
     277              : 
     278              : bool
     279      1827995 : MSEdge::allowsLaneChanging() const {
     280      1827995 :     if (isInternal() && MSGlobals::gUsingInternalLanes) {
     281              :         // allow changing only if all links leading to this internal lane have priority
     282              :         // or they are controlled by a traffic light
     283      1544139 :         for (const MSLane* const lane : *myLanes) {
     284      1059464 :             const MSLink* const link = lane->getLogicalPredecessorLane()->getLinkTo(lane);
     285              :             assert(link != nullptr);
     286              :             const LinkState state = link->getState();
     287       485453 :             if ((state == LINKSTATE_MINOR && lane->getBidiLane() == nullptr)
     288       574437 :                     || state == LINKSTATE_EQUAL
     289       574437 :                     || state == LINKSTATE_STOP
     290              :                     || state == LINKSTATE_ALLWAY_STOP
     291      1059464 :                     || state == LINKSTATE_DEADEND) {
     292              :                 return false;
     293              :             }
     294              :         }
     295              :     }
     296              :     return true;
     297              : }
     298              : 
     299              : 
     300              : void
     301     19110416 : MSEdge::addToAllowed(const SVCPermissions permissions, std::shared_ptr<const std::vector<MSLane*> > allowedLanes, AllowedLanesCont& laneCont) const {
     302     19110416 :     if (!allowedLanes->empty()) {
     303              :         // recheck whether we had this list to save memory
     304     18827623 :         for (auto& allowed : laneCont) {
     305     17778144 :             if (*allowed.second == *allowedLanes) {
     306     13419709 :                 allowed.first |= permissions;
     307              :                 return;
     308              :             }
     309              :         }
     310      1049479 :         laneCont.push_back(std::make_pair(permissions, allowedLanes));
     311              :     }
     312              : }
     313              : 
     314              : 
     315              : SVCPermissions
     316      3048805 : MSEdge::getMesoPermissions(SVCPermissions p, SVCPermissions ignoreIgnored) {
     317      3048805 :     SVCPermissions ignored = myMesoIgnoredVClasses & ~ignoreIgnored;
     318      3048805 :     return (p | ignored) == ignored ? 0 : p;
     319              : }
     320              : 
     321              : 
     322              : void
     323      1829469 : MSEdge::rebuildAllowedLanes(const bool onInit, bool updateVehicles) {
     324              :     // hadPermissionChanges() only tracks transient (rerouter/TraCI-temporary)
     325              :     // changes; a permanent change (e.g. traci.lane.setDisallowed /
     326              :     // traci.edge.setAllowed) goes straight through MSLane::setPermissions and
     327              :     // never registers there. Comparing the aggregated permissions before and
     328              :     // after this rebuild catches that case too.
     329      1829469 :     const SVCPermissions oldMinimumPermissions = myMinimumPermissions;
     330      1829469 :     const SVCPermissions oldCombinedPermissions = myCombinedPermissions;
     331              :     // rebuild myMinimumPermissions and myCombinedPermissions
     332      1829469 :     myMinimumPermissions = SVCAll;
     333      1829469 :     myCombinedPermissions = 0;
     334              :     bool lanesChangedPermission = false;
     335      4025446 :     for (MSLane* const lane : *myLanes) {
     336              :         // same dedicated lanes are ignored in meso to avoid capacity errors.
     337              :         // Here we have to make sure that vehicles which are set to depart on
     338              :         // such lanes trigger an error.
     339      2195977 :         SVCPermissions allow = getMesoPermissions(lane->getPermissions(), SVC_PEDESTRIAN);
     340      2195977 :         myMinimumPermissions &= allow;
     341      2195977 :         myCombinedPermissions |= allow;
     342      2195977 :         lanesChangedPermission |= lane->hadPermissionChanges();
     343              :     }
     344      1829469 :     if (!onInit && !myHaveTransientPermissions && lanesChangedPermission) {
     345          963 :         myHaveTransientPermissions = true;
     346              :         // backup original structures when first needed
     347          963 :         myOrigAllowed = myAllowed;
     348              :         myOrigAllowedTargets = myAllowedTargets;
     349              :         myOrigClassesViaSuccessorMap = myClassesViaSuccessorMap;
     350              :     }
     351         1474 :     if (!onInit && (lanesChangedPermission
     352          347 :                     || myMinimumPermissions != oldMinimumPermissions
     353           26 :                     || myCombinedPermissions != oldCombinedPermissions)) {
     354              :         // a runtime permission change (closure / re-opening, transient or
     355              :         // permanent) must reach the CCH metric even though the speed table
     356              :         // does not move
     357         1448 :         MSRoutingEngine::invalidateCCHEdge(this);
     358              :     }
     359              :     // rebuild myAllowed
     360              :     myAllowed.clear();
     361      1829469 :     if (myCombinedPermissions != myMinimumPermissions) {
     362       170281 :         myAllowed.push_back(std::make_pair(SVC_IGNORING, myLanes));
     363      5789554 :         for (SVCPermissions vclass = SVC_PRIVATE; vclass <= SUMOVehicleClass_MAX; vclass *= 2) {
     364      5619273 :             if ((myCombinedPermissions & vclass) == vclass) {
     365              :                 std::shared_ptr<std::vector<MSLane*> > allowedLanes = std::make_shared<std::vector<MSLane*> >();
     366     11933694 :                 for (MSLane* const lane : *myLanes) {
     367      8079466 :                     if (lane->allowsVehicleClass((SUMOVehicleClass)vclass)) {
     368      4077420 :                         allowedLanes->push_back(lane);
     369              :                     }
     370              :                 }
     371      7708456 :                 addToAllowed(vclass, allowedLanes, myAllowed);
     372              :             }
     373              :         }
     374              :     }
     375      1829469 :     if (onInit) {
     376      1827995 :         myOriginalMinimumPermissions = myMinimumPermissions;
     377      1827995 :         myOriginalCombinedPermissions = myCombinedPermissions;
     378              :     } else {
     379         1474 :         rebuildAllowedTargets(updateVehicles);
     380         3743 :         for (MSEdge* pred : myPredecessors) {
     381         2269 :             if (myHaveTransientPermissions && !pred->myHaveTransientPermissions) {
     382         1352 :                 pred->myOrigAllowed = pred->myAllowed;
     383              :                 pred->myOrigAllowedTargets = pred->myAllowedTargets;
     384              :                 pred->myOrigClassesViaSuccessorMap = pred->myClassesViaSuccessorMap;
     385         1352 :                 pred->myHaveTransientPermissions = true;
     386              :             }
     387         2269 :             pred->rebuildAllowedTargets(updateVehicles);
     388              :         }
     389         1474 :         if (MSGlobals::gUseMesoSim) {
     390         2283 :             for (MESegment* s = MSGlobals::gMesoNet->getSegmentForEdge(*this); s != nullptr; s = s->getNextSegment()) {
     391         1922 :                 s->updatePermissions();
     392              :             }
     393              :         }
     394         3548 :         for (MSLane* const lane : *myLanes) {
     395         4193 :             for (MSLink* link : lane->getLinkCont()) {
     396         2119 :                 link->updatePermissions();
     397              :             }
     398         4353 :             for (auto ili : lane->getIncomingLanes()) {
     399         2279 :                 ili.viaLink->updatePermissions();
     400              :             }
     401              :         }
     402              :     }
     403      1829469 : }
     404              : 
     405              : 
     406              : void
     407      1832720 : MSEdge::rebuildAllowedTargets(const bool updateVehicles) {
     408              :     myAllowedTargets.clear();
     409      4651493 :     for (const MSEdge* target : mySuccessors) {
     410              :         bool universalMap = true; // whether the mapping for SVC_IGNORING is also valid for all vehicle classes
     411              :         std::shared_ptr<std::vector<MSLane*> > allLanes = std::make_shared<std::vector<MSLane*> >();
     412              :         // compute the mapping for SVC_IGNORING
     413      6417437 :         for (MSLane* const lane : *myLanes) {
     414              :             SVCPermissions combinedTargetPermissions = 0;
     415     10223478 :             for (const MSLink* const link : lane->getLinkCont()) {
     416      6624814 :                 if (&link->getLane()->getEdge() == target) {
     417      3023370 :                     allLanes->push_back(lane);
     418      3023370 :                     combinedTargetPermissions |= link->getLane()->getPermissions();
     419      3023370 :                     if (link->getViaLane() != nullptr &&
     420      1064960 :                             ((lane->getPermissions() & link->getLane()->getPermissions()) != link->getViaLane()->getPermissions())) {
     421              :                         // custom connection permissions
     422              :                         universalMap = false;
     423              :                     }
     424              :                 }
     425              :             }
     426      3598664 :             if (combinedTargetPermissions == 0 || (lane->getPermissions() & combinedTargetPermissions) != lane->getPermissions()) {
     427              :                 universalMap = false;
     428              :             }
     429              :         }
     430      2818773 :         if (universalMap) {
     431      2297625 :             if (myAllowed.empty()) {
     432              :                 // we have no lane specific permissions
     433      4526806 :                 myAllowedTargets[target].push_back(std::make_pair(myMinimumPermissions, myLanes));
     434              :             } else {
     435       134624 :                 for (const auto& i : myAllowed) {
     436       301206 :                     addToAllowed(i.first, i.second, myAllowedTargets[target]);
     437              :                 }
     438              :             }
     439              :         } else {
     440      1042296 :             addToAllowed(SVC_IGNORING, allLanes, myAllowedTargets[target]);
     441              :             // compute the vclass specific mapping
     442     17719032 :             for (SVCPermissions vclass = SVC_PRIVATE; vclass <= SUMOVehicleClass_MAX; vclass *= 2) {
     443     17197884 :                 if ((myCombinedPermissions & vclass) == vclass) {
     444              :                     std::shared_ptr<std::vector<MSLane*> > allowedLanes = std::make_shared<std::vector<MSLane*> >();
     445     45482803 :                     for (MSLane* const lane : *myLanes) {
     446     30848165 :                         if (lane->allowsVehicleClass((SUMOVehicleClass)vclass)) {
     447     59348679 :                             for (const MSLink* const link : lane->getLinkCont()) {
     448     38801482 :                                 if (link->getLane()->allowsVehicleClass((SUMOVehicleClass)vclass) && &link->getLane()->getEdge() == target && (link->getViaLane() == nullptr || link->getViaLane()->allowsVehicleClass((SUMOVehicleClass)vclass))) {
     449     10357351 :                                     allowedLanes->push_back(lane);
     450              :                                 }
     451              :                             }
     452              :                         }
     453              :                     }
     454     43903914 :                     addToAllowed(vclass, allowedLanes, myAllowedTargets[target]);
     455              :                 }
     456              :             }
     457              :         }
     458              :     }
     459      1832720 :     if (updateVehicles) {
     460         3014 :         for (const MSLane* const lane : *myLanes) {
     461         1774 :             const MSLane::VehCont& vehs = lane->getVehiclesSecure();
     462         4583 :             for (MSVehicle* veh : vehs) {
     463         2809 :                 veh->updateBestLanes(true);
     464              :             }
     465         1774 :             lane->releaseVehicles();
     466              :         }
     467              :     }
     468              :     myClassesSuccessorMap.clear();
     469              :     myClassesViaSuccessorMap.clear();
     470      1832720 : }
     471              : 
     472              : 
     473              : // ------------ Access to the edge's lanes
     474              : MSLane*
     475          774 : MSEdge::leftLane(const MSLane* const lane) const {
     476          774 :     return parallelLane(lane, 1);
     477              : }
     478              : 
     479              : 
     480              : MSLane*
     481          400 : MSEdge::rightLane(const MSLane* const lane) const {
     482          400 :     return parallelLane(lane, -1);
     483              : }
     484              : 
     485              : 
     486              : MSLane*
     487     84936745 : MSEdge::parallelLane(const MSLane* const lane, int offset, bool includeOpposite) const {
     488     84936745 :     const int resultIndex = lane->getIndex() + offset;
     489     84936745 :     if (resultIndex >= getNumLanes() && includeOpposite) {
     490     20800003 :         const MSEdge* opposite = getOppositeEdge();
     491     20800003 :         if (opposite != nullptr && resultIndex < getNumLanes() + opposite->getNumLanes()) {
     492      1382023 :             return opposite->getLanes()[opposite->getNumLanes() + getNumLanes() - resultIndex - 1];
     493              :         }
     494              :         return nullptr;
     495     64136742 :     } else if (resultIndex >= (int)myLanes->size() || resultIndex < 0) {
     496              :         return nullptr;
     497              :     } else {
     498     39246210 :         return (*myLanes)[resultIndex];
     499              :     }
     500              : }
     501              : 
     502              : 
     503              : const std::vector<MSLane*>*
     504     93205145 : MSEdge::allowedLanes(const MSEdge& destination, SUMOVehicleClass vclass, bool ignoreTransientPermissions) const {
     505     93205145 :     const auto& targets = ignoreTransientPermissions && myHaveTransientPermissions ? myOrigAllowedTargets : myAllowedTargets;
     506              :     AllowedLanesByTarget::const_iterator i = targets.find(&destination);
     507     93205145 :     if (i != targets.end()) {
     508     90299909 :         for (const auto& allowed : i->second) {
     509     90149706 :             if ((allowed.first & vclass) == vclass) {
     510              :                 return allowed.second.get();
     511              :             }
     512              :         }
     513              :     }
     514              :     return nullptr;
     515              : }
     516              : 
     517              : 
     518              : const std::vector<MSLane*>*
     519    274650227 : MSEdge::allowedLanes(SUMOVehicleClass vclass) const {
     520    274650227 :     if ((myMinimumPermissions & vclass) == vclass) {
     521     43700795 :         return myLanes.get();
     522              :     } else {
     523    230949432 :         if ((myCombinedPermissions & vclass) == vclass) {
     524    461894981 :             for (const auto& allowed : myAllowed) {
     525    461894981 :                 if ((allowed.first & vclass) == vclass) {
     526              :                     return allowed.second.get();
     527              :                 }
     528              :             }
     529              :         }
     530         2269 :         return nullptr;
     531              :     }
     532              : }
     533              : 
     534              : 
     535              : const std::vector<MSLane*>*
     536   2181387769 : MSEdge::allowedLanes(SUMOVehicleClass vclass, bool ignoreTransientPermissions) const {
     537   2181387769 :     const SVCPermissions& minP = ignoreTransientPermissions ? myOriginalMinimumPermissions : myMinimumPermissions;
     538   2181387769 :     if ((minP & vclass) == vclass) {
     539    643864697 :         return myLanes.get();
     540              :     } else {
     541   1537523072 :         const SVCPermissions comP = ignoreTransientPermissions ? myOriginalCombinedPermissions : myCombinedPermissions;
     542   1537523072 :         if ((comP & vclass) == vclass) {
     543   1537522992 :             const AllowedLanesCont& allowedCont = ignoreTransientPermissions && myHaveTransientPermissions ? myOrigAllowed : myAllowed;
     544   3080775802 :             for (const auto& allowed : allowedCont) {
     545   3080775802 :                 if ((allowed.first & vclass) == vclass) {
     546              :                     return allowed.second.get();
     547              :                 }
     548              :             }
     549              :         }
     550           80 :         return nullptr;
     551              :     }
     552              : }
     553              : 
     554              : 
     555              : // ------------
     556              : SUMOTime
     557          434 : MSEdge::incVaporization(SUMOTime) {
     558          434 :     ++myVaporizationRequests;
     559          434 :     return 0;
     560              : }
     561              : 
     562              : 
     563              : SUMOTime
     564          279 : MSEdge::decVaporization(SUMOTime) {
     565          279 :     --myVaporizationRequests;
     566          279 :     return 0;
     567              : }
     568              : 
     569              : 
     570              : MSLane*
     571    218258909 : MSEdge::getFreeLane(const std::vector<MSLane*>* allowed, const SUMOVehicleClass vclass, double departPos) const {
     572    218258909 :     if (allowed == nullptr) {
     573    183556784 :         allowed = allowedLanes(vclass);
     574              :     }
     575              :     MSLane* res = nullptr;
     576    183556784 :     if (allowed != nullptr) {
     577              :         double largestGap = 0;
     578              :         MSLane* resByGap = nullptr;
     579              :         double leastOccupancy = std::numeric_limits<double>::max();
     580    460063714 :         for (std::vector<MSLane*>::const_iterator i = allowed->begin(); i != allowed->end(); ++i) {
     581    241807066 :             const double occupancy = (*i)->getBruttoOccupancy();
     582    241807066 :             if (occupancy < leastOccupancy) {
     583    226181308 :                 res = (*i);
     584              :                 leastOccupancy = occupancy;
     585              :             }
     586    241807066 :             const MSVehicle* last = (*i)->getLastFullVehicle();
     587    241807066 :             const double lastGap = (last != nullptr ? last->getPositionOnLane() : myLength) - departPos;
     588    241807066 :             if (lastGap > largestGap) {
     589              :                 largestGap = lastGap;
     590     58544387 :                 resByGap = (*i);
     591              :             }
     592              :         }
     593    218256648 :         if (resByGap != nullptr) {
     594              :             //if (res != resByGap) std::cout << SIMTIME << " edge=" << getID() << " departPos=" << departPos << " res=" << Named::getIDSecure(res) << " resByGap=" << Named::getIDSecure(resByGap) << " largestGap=" << largestGap << "\n";
     595              :             res = resByGap;
     596              :         }
     597              :     }
     598    218258909 :     return res;
     599              : }
     600              : 
     601              : 
     602              : MSLane*
     603    839182466 : MSEdge::getProbableLane(const std::vector<MSLane*>* allowed, const SUMOVehicleClass vclass, double departPos, double maxSpeed) const {
     604    839182466 :     if (allowed == nullptr) {
     605            0 :         allowed = allowedLanes(vclass);
     606              :     }
     607              :     MSLane* res = nullptr;
     608            0 :     if (allowed != nullptr) {
     609              :         double largestGap = 0;
     610              :         double largestSpeed = 0;
     611              :         MSLane* resByGap = nullptr;
     612              :         double leastOccupancy = std::numeric_limits<double>::max();
     613              :         int aIndex = 0;
     614   1684242010 :         for (std::vector<MSLane*>::const_iterator i = allowed->begin(); i != allowed->end(); ++i, aIndex++) {
     615    845059544 :             const double occupancy = (*i)->getBruttoOccupancy();
     616    845059544 :             if (occupancy < leastOccupancy) {
     617    844333059 :                 res = (*i);
     618              :                 leastOccupancy = occupancy;
     619              :             }
     620    845059544 :             const MSVehicle* last = (*i)->getLastFullVehicle();
     621    845059544 :             double lastGap = (last != nullptr ? last->getPositionOnLane() : myLength) - departPos;
     622              :             // never insert to the left of a vehicle with a larger speedFactor
     623    845059544 :             if (lastGap > largestGap && maxSpeed >= largestSpeed) {
     624              :                 largestGap = lastGap;
     625    799985248 :                 resByGap = (*i);
     626              :             }
     627    845059544 :             if (last != nullptr) {
     628    842810566 :                 largestSpeed = MAX2(largestSpeed, getVehicleMaxSpeed(last));
     629              :             }
     630              :         }
     631    839182466 :         if (resByGap != nullptr) {
     632              :             //if (res != resByGap) std::cout << SIMTIME << " edge=" << getID() << " departPos=" << departPos << " res=" << Named::getIDSecure(res) << " resByGap=" << Named::getIDSecure(resByGap) << " largestGap=" << largestGap << "\n";
     633              :             res = resByGap;
     634              :         }
     635              :     }
     636    839182466 :     return res;
     637              : }
     638              : 
     639              : 
     640              : double
     641   1058427580 : MSEdge::getDepartPosBound(const MSVehicle& veh, bool upper) const {
     642   1058427580 :     const SUMOVehicleParameter& pars = veh.getParameter();
     643              :     double pos = getLength();
     644              :     // determine the position
     645   1058427580 :     switch (pars.departPosProcedure) {
     646      9465894 :         case DepartPosDefinition::GIVEN:
     647      9465894 :             pos = pars.departPos;
     648      9465894 :             if (pos < 0.) {
     649      2289709 :                 pos += myLength;
     650              :             }
     651              :             break;
     652              :         case DepartPosDefinition::RANDOM:
     653              :             // could be any position on the edge
     654              :             break;
     655              :         case DepartPosDefinition::RANDOM_FREE:
     656              :             // could be any position on the edge due to multiple random attempts
     657              :             break;
     658              :         case DepartPosDefinition::FREE:
     659              :             // many candidate positions, upper bound could be computed exactly
     660              :             // with much effort
     661              :             break;
     662     11596506 :         case DepartPosDefinition::LAST:
     663     11596506 :             if (upper) {
     664       262332 :                 for (std::vector<MSLane*>::const_iterator i = myLanes->begin(); i != myLanes->end(); ++i) {
     665       177052 :                     MSVehicle* last = (*i)->getLastFullVehicle();
     666       177052 :                     if (last != nullptr) {
     667       152857 :                         pos = MIN2(pos, last->getPositionOnLane());
     668              :                     }
     669              :                 }
     670              :             } else {
     671              :                 pos = 0;
     672              :             }
     673              :             break;
     674    832161497 :         case DepartPosDefinition::BASE:
     675              :         case DepartPosDefinition::DEFAULT:
     676    832161497 :             if (!upper) {
     677              :                 pos = 0;
     678              :             }
     679              :             break;
     680           28 :         default:
     681           28 :             pos = MIN2(pos, veh.getVehicleType().getLength());
     682              :             break;
     683              :     }
     684   1058427580 :     return pos;
     685              : }
     686              : 
     687              : 
     688              : MSLane*
     689           46 : MSEdge::getDepartLaneMeso(SUMOVehicle& veh) const {
     690           46 :     if (veh.getParameter().departLaneProcedure == DepartLaneDefinition::GIVEN) {
     691            3 :         if ((int) myLanes->size() <= veh.getParameter().departLane || !(*myLanes)[veh.getParameter().departLane]->allowsVehicleClass(veh.getVehicleType().getVehicleClass())) {
     692            0 :             return nullptr;
     693              :         }
     694            3 :         return (*myLanes)[veh.getParameter().departLane];
     695              :     }
     696           43 :     return (*myLanes)[0];
     697              : }
     698              : 
     699              : 
     700              : MSLane*
     701   1768517559 : MSEdge::getDepartLane(MSVehicle& veh) const {
     702   1768517559 :     DepartLaneDefinition dld = veh.getParameter().departLaneProcedure;
     703   1768517559 :     int departLane = veh.getParameter().departLane;
     704   1768517559 :     if (dld == DepartLaneDefinition::DEFAULT) {
     705   1331137790 :         dld = myDefaultDepartLaneDefinition;
     706   1331137790 :         departLane = myDefaultDepartLane;
     707              :     }
     708   1768517559 :     switch (dld) {
     709    121181639 :         case DepartLaneDefinition::GIVEN:
     710    121181639 :             if ((int) myLanes->size() <= departLane || !(*myLanes)[departLane]->allowsVehicleClass(veh.getVClass())) {
     711           66 :                 return nullptr;
     712              :             }
     713    121181573 :             return (*myLanes)[departLane];
     714     91065002 :         case DepartLaneDefinition::RANDOM:
     715    182130004 :             return RandHelper::getRandomFrom(*allowedLanes(veh.getVehicleType().getVehicleClass()));
     716    183456227 :         case DepartLaneDefinition::FREE:
     717    183456227 :             return getFreeLane(nullptr, veh.getVehicleType().getVehicleClass(), getDepartPosBound(veh, false));
     718      4971244 :         case DepartLaneDefinition::ALLOWED_FREE:
     719      4971244 :             if (veh.getRoute().size() == 1) {
     720         5960 :                 return getFreeLane(nullptr, veh.getVehicleType().getVehicleClass(), getDepartPosBound(veh, false));
     721              :             } else {
     722      4965284 :                 return getFreeLane(allowedLanes(**(veh.getRoute().begin() + 1), veh.getVehicleType().getVehicleClass()), veh.getVehicleType().getVehicleClass(), getDepartPosBound(veh, false));
     723              :             }
     724    868717651 :         case DepartLaneDefinition::BEST_FREE:
     725              :         case DepartLaneDefinition::BEST_PROB: {
     726    868717651 :             veh.updateBestLanes(false, myLanes->front());
     727    868717651 :             const std::vector<MSVehicle::LaneQ>& bl = veh.getBestLanes();
     728              :             double bestLength = -1;
     729   2564827633 :             for (std::vector<MSVehicle::LaneQ>::const_iterator i = bl.begin(); i != bl.end(); ++i) {
     730   1696109982 :                 if ((*i).length > bestLength) {
     731              :                     bestLength = (*i).length;
     732              :                 }
     733              :             }
     734              :             // beyond a certain length, all lanes are suitable
     735              :             // however, we still need to check departPos to avoid unsuitable insertion
     736              :             // (this is only possible in some cases)
     737              :             double departPos = 0;
     738    868717651 :             if (bestLength > BEST_LANE_LOOKAHEAD) {
     739      1282458 :                 departPos = getDepartPosBound(veh);
     740      1282458 :                 bestLength = MIN2(bestLength - departPos, BEST_LANE_LOOKAHEAD);
     741              :             }
     742    868717651 :             std::vector<MSLane*>* bestLanes = new std::vector<MSLane*>();
     743   2564827633 :             for (std::vector<MSVehicle::LaneQ>::const_iterator i = bl.begin(); i != bl.end(); ++i) {
     744   1696109982 :                 if (((*i).length - departPos) >= bestLength) {
     745    876823991 :                     if (isInternal()) {
     746           32 :                         for (MSLane* lane : *myLanes) {
     747           20 :                             if (lane->getNormalSuccessorLane() == (*i).lane && lane->allowsVehicleClass(veh.getVClass())) {
     748           12 :                                 bestLanes->push_back(lane);
     749              :                             }
     750              :                         }
     751    876823979 :                     } else if ((*i).lane->allowsVehicleClass(veh.getVClass())) {
     752    876305639 :                         bestLanes->push_back((*i).lane);
     753              :                     }
     754              :                 }
     755              :             }
     756              :             MSLane* ret = nullptr;
     757    868717651 :             if (veh.getParameter().departLaneProcedure == DepartLaneDefinition::BEST_FREE) {
     758     29535185 :                 ret = getFreeLane(bestLanes, veh.getVehicleType().getVehicleClass(), getDepartPosBound(veh, false));
     759              :             } else {
     760    839182466 :                 ret = getProbableLane(bestLanes, veh.getVehicleType().getVehicleClass(), getDepartPosBound(veh, false), getVehicleMaxSpeed(&veh));
     761              :             }
     762    868717651 :             delete bestLanes;
     763    868717651 :             return ret;
     764              :         }
     765    499125796 :         case DepartLaneDefinition::DEFAULT:
     766              :         case DepartLaneDefinition::FIRST_ALLOWED:
     767    499125796 :             return getFirstAllowed(veh.getVehicleType().getVehicleClass());
     768              :         default:
     769              :             break;
     770              :     }
     771            0 :     if (!(*myLanes)[0]->allowsVehicleClass(veh.getVehicleType().getVehicleClass())) {
     772              :         return nullptr;
     773              :     }
     774            0 :     return (*myLanes)[0];
     775              : }
     776              : 
     777              : 
     778              : MSLane*
     779    500113844 : MSEdge::getFirstAllowed(SUMOVehicleClass vClass, bool defaultFirst, int routingMode) const {
     780    507927563 :     for (std::vector<MSLane*>::const_iterator i = myLanes->begin(); i != myLanes->end(); ++i) {
     781    506884883 :         if ((*i)->allowsVehicleClass(vClass, routingMode)) {
     782    499071164 :             return *i;
     783              :         }
     784              :     }
     785      1042680 :     return defaultFirst && !myLanes->empty() ? myLanes->front() : nullptr;
     786              : }
     787              : 
     788              : 
     789              : bool
     790   2825373435 : MSEdge::validateDepartSpeed(SUMOVehicle& v) const {
     791   2825373435 :     const SUMOVehicleParameter& pars = v.getParameter();
     792   2825373435 :     const MSVehicleType& type = v.getVehicleType();
     793   2825373435 :     if (pars.departSpeedProcedure == DepartSpeedDefinition::GIVEN) {
     794              :         // departSpeed could have been rounded down in the output
     795    150634477 :         double vMax = getVehicleMaxSpeed(&v) + SPEED_EPS;
     796    150634477 :         if (pars.departSpeed > vMax) {
     797              :             // check departLane (getVehicleMaxSpeed checks lane 0)
     798        19611 :             MSLane* departLane = MSGlobals::gMesoNet ? getDepartLaneMeso(v) : getDepartLane(dynamic_cast<MSVehicle&>(v));
     799        19611 :             if (departLane != nullptr) {
     800        19611 :                 vMax = departLane->getVehicleMaxSpeed(&v);
     801        19611 :                 if (pars.wasSet(VEHPARS_SPEEDFACTOR_SET)) {
     802              :                     // speedFactor could have been rounded down in the output
     803            7 :                     vMax *= (1 + SPEED_EPS);
     804              :                 }
     805              :                 // additive term must come after multiplication!
     806        19611 :                 vMax += SPEED_EPS;
     807        19611 :                 if (pars.departSpeed > vMax) {
     808        19597 :                     if (type.getSpeedFactor().getParameter(1) > 0.) {
     809        39156 :                         v.setChosenSpeedFactor(type.computeChosenSpeedDeviation(pars.speedFactor, nullptr, pars.departSpeed / MIN2(getSpeedLimit(), type.getDesiredMaxSpeed() - SPEED_EPS)));
     810        19578 :                         if (v.getChosenSpeedFactor() > type.getSpeedFactor().getParameter(0) + 2 * type.getSpeedFactor().getParameter(1)) {
     811              :                             // only warn for significant deviation
     812        33536 :                             WRITE_WARNINGF(TL("Choosing new speed factor % for vehicle '%' to match departure speed % (max %)."),
     813              :                                            toString(v.getChosenSpeedFactor()), pars.id, pars.departSpeed, vMax);
     814              :                         }
     815              :                     } else {
     816              :                         return false;
     817              :                     }
     818              :                 }
     819              :             }
     820              :         }
     821              :     }
     822              :     return true;
     823              : }
     824              : 
     825              : 
     826              : bool
     827   2825834882 : MSEdge::insertVehicle(SUMOVehicle& v, SUMOTime time, const bool checkOnly, const bool forceCheck) const {
     828              :     // when vaporizing, no vehicles are inserted, but checking needs to be successful to trigger removal
     829   2825816096 :     if (isVaporizing() || isTazConnector()
     830   5651185629 :             || v.getRouteValidity(true, checkOnly) != MSBaseVehicle::ROUTE_VALID) {
     831       484205 :         return checkOnly;
     832              :     }
     833   2825350489 :     const SUMOVehicleParameter& pars = v.getParameter();
     834   2825350489 :     if (!validateDepartSpeed(v)) {
     835           14 :         if (MSGlobals::gCheckRoutes) {
     836           21 :             throw ProcessError(TLF("Departure speed for vehicle '%' is too high for the departure edge '%', time=%.",
     837           21 :                                    pars.id, getID(), time2string(time)));
     838              :         } else {
     839           21 :             WRITE_WARNINGF(TL("Departure speed for vehicle '%' is too high for the departure edge '%', time=%."),
     840              :                            pars.id, getID(), time2string(time));
     841              :         }
     842              :     }
     843   2825350482 :     if (MSGlobals::gUseMesoSim) {
     844    584701194 :         if (!forceCheck && myLastFailedInsertionTime == time) {
     845              :             return false;
     846              :         }
     847              :         double pos = 0.0;
     848     82604025 :         switch (pars.departPosProcedure) {
     849       585580 :             case DepartPosDefinition::GIVEN:
     850       585580 :                 if (pars.departPos >= 0.) {
     851              :                     pos = pars.departPos;
     852              :                 } else {
     853         8397 :                     pos = pars.departPos + getLength();
     854              :                 }
     855       585580 :                 if (pos < 0 || pos > getLength()) {
     856            6 :                     WRITE_WARNINGF(TL("Invalid departPos % given for vehicle '%', time=%. Inserting at lane end instead."),
     857              :                                    pos, v.getID(), time2string(time));
     858              :                     pos = getLength();
     859              :                 }
     860              :                 break;
     861              :             case DepartPosDefinition::RANDOM:
     862              :             case DepartPosDefinition::RANDOM_FREE:
     863              :                 pos = RandHelper::rand(getLength());
     864        44186 :                 break;
     865              :             default:
     866              :                 break;
     867              :         }
     868              :         bool result = false;
     869     82604025 :         MESegment* segment = MSGlobals::gMesoNet->getSegmentForEdge(*this, pos);
     870              :         MEVehicle* veh = static_cast<MEVehicle*>(&v);
     871              :         int qIdx;
     872     82604025 :         if (pars.departPosProcedure == DepartPosDefinition::FREE) {
     873       453566 :             while (segment != nullptr && !result) {
     874       414994 :                 if (checkOnly) {
     875            6 :                     result = segment->hasSpaceFor(veh, time, qIdx, true) == time;
     876              :                 } else {
     877       414988 :                     result = segment->initialise(veh, time);
     878              :                 }
     879              :                 segment = segment->getNextSegment();
     880              :             }
     881              :         } else {
     882     82565453 :             if (checkOnly) {
     883     80228575 :                 result = segment->hasSpaceFor(veh, time, qIdx, true) == time;
     884              :             } else {
     885      2336878 :                 result = segment->initialise(veh, time);
     886              :             }
     887              :         }
     888     82604025 :         return result;
     889              :     }
     890   2240649288 :     if (checkOnly) {
     891    616349425 :         DepartLaneDefinition dld = v.getParameter().departLaneProcedure;
     892    616349425 :         if (dld == DepartLaneDefinition::DEFAULT) {
     893    564671655 :             dld = myDefaultDepartLaneDefinition;
     894              :         }
     895    616349425 :         switch (dld) {
     896     83595672 :             case DepartLaneDefinition::GIVEN:
     897              :             case DepartLaneDefinition::DEFAULT:
     898              :             case DepartLaneDefinition::FIRST_ALLOWED: {
     899     83595672 :                 MSLane* insertionLane = getDepartLane(static_cast<MSVehicle&>(v));
     900     83595672 :                 if (insertionLane == nullptr) {
     901      1555020 :                     WRITE_WARNINGF(TL("Could not insert vehicle '%' on any lane of edge '%', time=%."),
     902              :                                    v.getID(), getID(), time2string(time));
     903       518340 :                     return false;
     904              :                 }
     905     83077332 :                 const double occupancy = insertionLane->getBruttoOccupancy();
     906     83077332 :                 return (occupancy == 0 || occupancy * myLength + v.getVehicleType().getLengthWithGap() <= myLength ||
     907      6377716 :                         v.getParameter().departProcedure == DepartDefinition::SPLIT);
     908              :             }
     909    532753753 :             default:
     910    542024890 :                 for (std::vector<MSLane*>::const_iterator i = myLanes->begin(); i != myLanes->end(); ++i) {
     911    537991532 :                     const double occupancy = (*i)->getBruttoOccupancy();
     912    537991532 :                     if (occupancy == 0 || occupancy * myLength + v.getVehicleType().getLengthWithGap() <= myLength ||
     913      9271137 :                             v.getParameter().departProcedure == DepartDefinition::SPLIT) {
     914              :                         return true;
     915              :                     }
     916              :                 }
     917              :         }
     918              :         return false;
     919              :     }
     920   1624299863 :     MSLane* insertionLane = getDepartLane(static_cast<MSVehicle&>(v));
     921   1624299863 :     if (insertionLane == nullptr) {
     922              :         return false;
     923              :     }
     924              : 
     925   1623257183 :     if (!forceCheck) {
     926   1623257006 :         if (myLastFailedInsertionTime == time) {
     927              :             if (myFailedInsertionMemory.count(insertionLane->getIndex())) {
     928              :                 // A vehicle was already rejected for the proposed insertionLane in this timestep
     929              :                 return false;
     930              :             }
     931              :         } else {
     932              :             // last rejection occurred in a previous timestep, clear cache
     933              :             myFailedInsertionMemory.clear();
     934              :         }
     935              :     }
     936              : 
     937     13644228 :     bool success = insertionLane->insertVehicle(static_cast<MSVehicle&>(v));
     938              : 
     939     13644227 :     if (!success) {
     940              :         // constraints may enforce explicit re-ordering so we need to try other vehicles after failure
     941     20243016 :         if (!insertionLane->hasParameter("insertionOrder" + v.getID())) {
     942     10121361 :             myFailedInsertionMemory.insert(insertionLane->getIndex());
     943              :         }
     944              :     }
     945              :     return success;
     946              : }
     947              : 
     948              : 
     949              : void
     950     43601737 : MSEdge::changeLanes(SUMOTime t) const {
     951     43601737 :     if (myLaneChanger != nullptr) {
     952     43601737 :         myLaneChanger->laneChange(t);
     953              :     }
     954     43601737 : }
     955              : 
     956              : 
     957              : const MSEdge*
     958    509998799 : MSEdge::getInternalFollowingEdge(const MSEdge* followerAfterInternal, SUMOVehicleClass vClass) const {
     959              :     //@todo to be optimized
     960    513622053 :     for (const MSLane* const l : *myLanes) {
     961   1405900064 :         for (const MSLink* const link : l->getLinkCont()) {
     962   1402276810 :             if (&link->getLane()->getEdge() == followerAfterInternal) {
     963    508336524 :                 if (link->getViaLane() != nullptr) {
     964    507216260 :                     if (link->getViaLane()->allowsVehicleClass(vClass)) {
     965    507175772 :                         return &link->getViaLane()->getEdge();
     966              :                     } else {
     967        40488 :                         continue;
     968              :                     }
     969              :                 } else {
     970              :                     return nullptr; // network without internal links
     971              :                 }
     972              :             }
     973              :         }
     974              :     }
     975              :     return nullptr;
     976              : }
     977              : 
     978              : 
     979              : double
     980      1333459 : MSEdge::getInternalFollowingLengthTo(const MSEdge* followerAfterInternal, SUMOVehicleClass vClass) const {
     981              :     assert(followerAfterInternal != 0);
     982              :     assert(!followerAfterInternal->isInternal());
     983              :     double dist = 0.;
     984      1333459 :     const MSEdge* edge = getInternalFollowingEdge(followerAfterInternal, vClass);
     985              :     // Take into account non-internal lengths until next non-internal edge
     986      2489535 :     while (edge != nullptr && edge->isInternal()) {
     987      1156076 :         dist += edge->getLength();
     988      1156076 :         edge = edge->getInternalFollowingEdge(followerAfterInternal, vClass);
     989              :     }
     990      1333459 :     return dist;
     991              : }
     992              : 
     993              : 
     994              : const MSEdge*
     995       156608 : MSEdge::getNormalBefore() const {
     996              :     const MSEdge* result = this;
     997       165742 :     while (result->isInternal() && MSGlobals::gUsingInternalLanes) {
     998              :         assert(result->getPredecessors().size() == 1);
     999         9134 :         result = result->getPredecessors().front();
    1000              :     }
    1001       156608 :     return result;
    1002              : }
    1003              : 
    1004              : const MSEdge*
    1005      6277108 : MSEdge::getNormalSuccessor() const {
    1006              :     const MSEdge* result = this;
    1007     11775394 :     while (result->isInternal()) {
    1008              :         assert(result->getSuccessors().size() == 1);
    1009      5498286 :         result = result->getSuccessors().front();
    1010              :     }
    1011      6277108 :     return result;
    1012              : }
    1013              : 
    1014              : double
    1015    197157175 : MSEdge::getMeanSpeed() const {
    1016              :     double v = 0;
    1017              :     double totalNumVehs = 0;
    1018    197157175 :     if (MSGlobals::gUseMesoSim) {
    1019    247446963 :         for (MESegment* segment = MSGlobals::gMesoNet->getSegmentForEdge(*this); segment != nullptr; segment = segment->getNextSegment()) {
    1020              :             const int numVehs = segment->getCarNumber();
    1021    183057004 :             if (numVehs > 0) {
    1022     25443891 :                 v += numVehs * segment->getMeanSpeed();
    1023     25443891 :                 totalNumVehs += numVehs;
    1024              :             }
    1025              :         }
    1026     64389959 :         if (totalNumVehs == 0) {
    1027     55070974 :             return getLength() / myEmptyTraveltime; // may include tls-penalty
    1028              :         }
    1029              :     } else {
    1030    304769754 :         for (const MSLane* const lane : *myLanes) {
    1031              :             int numVehs = lane->getVehicleNumber();
    1032    172002538 :             if (numVehs == 0) {
    1033              :                 // take speed limit but with lowest possible weight
    1034              :                 numVehs = 1;
    1035              :             }
    1036    172002538 :             v += numVehs * lane->getMeanSpeed();
    1037    172002538 :             totalNumVehs += numVehs;
    1038              :         }
    1039    132767216 :         if (myBidiEdge != nullptr) {
    1040      8816144 :             for (const MSLane* const lane : myBidiEdge->getLanes()) {
    1041      4568625 :                 if (lane->getVehicleNumber() > 0) {
    1042              :                     // do not route across edges which are already occupied in reverse direction
    1043              :                     return 0;
    1044              :                 }
    1045              :             }
    1046              :         }
    1047    132446448 :         if (totalNumVehs == 0) {
    1048            0 :             return getSpeedLimit();
    1049              :         }
    1050              :     }
    1051    141765433 :     return v / totalNumVehs;
    1052              : }
    1053              : 
    1054              : 
    1055              : double
    1056           18 : MSEdge::getMeanFriction() const {
    1057              :     double f = 0.;
    1058           52 :     for (const MSLane* const lane : *myLanes) {
    1059           34 :         f += lane->getFrictionCoefficient();
    1060              :     }
    1061           18 :     if (!myLanes->empty()) {
    1062           18 :         return f / (double)myLanes->size();
    1063              :     }
    1064              :     return 1.;
    1065              : }
    1066              : 
    1067              : 
    1068              : double
    1069         1454 : MSEdge::getMeanSpeedBike() const {
    1070         1454 :     if (MSGlobals::gUseMesoSim) {
    1071              :         // no separate bicycle speeds in meso
    1072          362 :         return getMeanSpeed();
    1073              :     }
    1074              :     double v = 0;
    1075              :     double totalNumVehs = 0;
    1076         3606 :     for (const MSLane* const lane : *myLanes) {
    1077              :         const int numVehs = lane->getVehicleNumber();
    1078         2514 :         v += numVehs * lane->getMeanSpeedBike();
    1079         2514 :         totalNumVehs += numVehs;
    1080              :     }
    1081         1092 :     if (totalNumVehs == 0) {
    1082          546 :         return getSpeedLimit();
    1083              :     }
    1084          546 :     return v / totalNumVehs;
    1085              : }
    1086              : 
    1087              : 
    1088              : double
    1089        54680 : MSEdge::getCurrentTravelTime(double minSpeed) const {
    1090              :     assert(minSpeed > 0);
    1091        54680 :     if (!myAmDelayed) {
    1092        44593 :         return myEmptyTraveltime;
    1093              :     }
    1094        20174 :     return getLength() / MAX2(minSpeed, getMeanSpeed());
    1095              : }
    1096              : 
    1097              : 
    1098              : double
    1099            0 : MSEdge::getRoutingSpeed() const {
    1100            0 :     return MSRoutingEngine::getAssumedSpeed(this, nullptr);
    1101              : }
    1102              : 
    1103              : 
    1104              : bool
    1105      1902639 : MSEdge::dictionary(const std::string& id, MSEdge* ptr) {
    1106              :     const DictType::iterator it = myDict.lower_bound(id);
    1107      1902639 :     if (it == myDict.end() || it->first != id) {
    1108              :         // id not in myDict
    1109      1902639 :         myDict.emplace_hint(it, id, ptr);
    1110      3805318 :         while (ptr->getNumericalID() >= (int)myEdges.size()) {
    1111      1902679 :             myEdges.push_back(nullptr);
    1112              :         }
    1113      1902639 :         myEdges[ptr->getNumericalID()] = ptr;
    1114      1902639 :         return true;
    1115              :     }
    1116              :     return false;
    1117              : }
    1118              : 
    1119              : 
    1120              : MSEdge*
    1121      8939104 : MSEdge::dictionary(const std::string& id) {
    1122              :     const DictType::iterator it = myDict.find(id);
    1123      8939104 :     if (it == myDict.end()) {
    1124              :         return nullptr;
    1125              :     }
    1126      7033779 :     return it->second;
    1127              : }
    1128              : 
    1129              : 
    1130              : MSEdge*
    1131      3021681 : MSEdge::dictionaryHint(const std::string& id, const int startIdx) {
    1132              :     // this method is mainly useful when parsing connections from the net.xml which are sorted by "from" id
    1133      3021681 :     if (myEdges[startIdx] != nullptr && myEdges[startIdx]->getID() == id) {
    1134              :         return myEdges[startIdx];
    1135              :     }
    1136      1910465 :     if (startIdx + 1 < (int)myEdges.size() && myEdges[startIdx + 1] != nullptr && myEdges[startIdx + 1]->getID() == id) {
    1137              :         return myEdges[startIdx + 1];
    1138              :     }
    1139       625639 :     return dictionary(id);
    1140              : }
    1141              : 
    1142              : 
    1143              : const MSEdgeVector&
    1144       926243 : MSEdge::getAllEdges() {
    1145       926243 :     return myEdges;
    1146              : }
    1147              : 
    1148              : 
    1149              : void
    1150        43380 : MSEdge::clear() {
    1151      1930496 :     for (DictType::iterator i = myDict.begin(); i != myDict.end(); ++i) {
    1152      1887116 :         delete (*i).second;
    1153              :     }
    1154              :     myDict.clear();
    1155              :     myEdges.clear();
    1156        43380 : }
    1157              : 
    1158              : 
    1159              : void
    1160          285 : MSEdge::insertIDs(std::vector<std::string>& into) {
    1161        16016 :     for (DictType::iterator i = myDict.begin(); i != myDict.end(); ++i) {
    1162        15731 :         into.push_back((*i).first);
    1163              :     }
    1164          285 : }
    1165              : 
    1166              : 
    1167              : void
    1168       433561 : MSEdge::parseEdgesList(const std::string& desc, ConstMSEdgeVector& into,
    1169              :                        const std::string& rid) {
    1170       433561 :     StringTokenizer st(desc);
    1171       433561 :     parseEdgesList(st.getVector(), into, rid);
    1172       433561 : }
    1173              : 
    1174              : 
    1175              : void
    1176       433843 : MSEdge::parseEdgesList(const std::vector<std::string>& desc, ConstMSEdgeVector& into,
    1177              :                        const std::string& rid) {
    1178      1604572 :     for (std::vector<std::string>::const_iterator i = desc.begin(); i != desc.end(); ++i) {
    1179      1170778 :         const MSEdge* edge = MSEdge::dictionary(*i);
    1180              :         // check whether the edge exists
    1181      1170778 :         if (edge == nullptr) {
    1182           49 :             throw ProcessError("The edge '" + *i + "' within the route " + rid + " is not known."
    1183          147 :                                + "\n The route can not be build.");
    1184              :         }
    1185      1170729 :         into.push_back(edge);
    1186              :     }
    1187       433794 : }
    1188              : 
    1189              : 
    1190              : double
    1191      1846215 : MSEdge::getDistanceTo(const MSEdge* other, const bool doBoundaryEstimate) const {
    1192              :     assert(this != other);
    1193      1846215 :     if (doBoundaryEstimate) {
    1194        19315 :         return myBoundary.distanceTo2D(other->myBoundary);
    1195              :     }
    1196      1826900 :     if (isTazConnector()) {
    1197         1340 :         if (other->isTazConnector()) {
    1198          450 :             return myBoundary.distanceTo2D(other->myBoundary);
    1199              :         }
    1200          890 :         return myBoundary.distanceTo2D(other->getLanes()[0]->getShape()[0]);
    1201              :     }
    1202      1825560 :     if (other->isTazConnector()) {
    1203         5419 :         return other->myBoundary.distanceTo2D(getLanes()[0]->getShape()[-1]);
    1204              :     }
    1205      1820141 :     return getLanes()[0]->getShape()[-1].distanceTo2D(other->getLanes()[0]->getShape()[0]);
    1206              : }
    1207              : 
    1208              : 
    1209              : const Position
    1210         2402 : MSEdge::getStopPosition(const SUMOVehicleParameter::Stop& stop) {
    1211         2402 :     return MSLane::dictionary(stop.lane)->geometryPositionAtOffset((stop.endPos + stop.startPos) / 2.);
    1212              : }
    1213              : 
    1214              : 
    1215              : double
    1216     92813004 : MSEdge::getSpeedLimit() const {
    1217              :     // @note lanes might have different maximum speeds in theory
    1218     92813004 :     return myLanes->empty() ? 1 : getLanes()[0]->getSpeedLimit();
    1219              : }
    1220              : 
    1221              : 
    1222              : double
    1223          848 : MSEdge::getSpeedLimit(SUMOVehicleClass svc) const {
    1224              :     // @note lanes might have different maximum speeds in theory
    1225          848 :     return myLanes->empty() ? 1 : getLanes()[0]->getSpeedLimit(svc);
    1226              : }
    1227              : 
    1228              : 
    1229              : double
    1230      2014538 : MSEdge::getLengthGeometryFactor() const {
    1231      2014538 :     return myLanes->empty() ? 1 : getLanes()[0]->getLengthGeometryFactor();
    1232              : }
    1233              : 
    1234              : double
    1235   2084240873 : MSEdge::getVehicleMaxSpeed(const SUMOTrafficObject* const veh) const {
    1236              :     // @note lanes might have different maximum speeds in theory
    1237   2084240873 :     return myLanes->empty() ? 1 : getLanes()[0]->getVehicleMaxSpeed(veh);
    1238              : }
    1239              : 
    1240              : 
    1241              : void
    1242          205 : MSEdge::setMaxSpeed(const double val, const bool modified, const double jamThreshold) {
    1243              :     assert(val >= 0);
    1244          205 :     if (myLanes != nullptr) {
    1245          564 :         for (MSLane* const lane : *myLanes) {
    1246          359 :             lane->setMaxSpeed(val, modified, jamThreshold);
    1247              :         }
    1248              :     }
    1249          205 : }
    1250              : 
    1251              : 
    1252              : void
    1253      2558748 : MSEdge::addTransportable(MSTransportable* t) const {
    1254      2558748 :     if (t->isPerson()) {
    1255              :         myPersons.insert(t);
    1256              :     } else {
    1257              :         myContainers.insert(t);
    1258              :     }
    1259      2558748 : }
    1260              : 
    1261              : void
    1262      7611824 : MSEdge::removeTransportable(MSTransportable* t) const {
    1263      7611824 :     std::set<MSTransportable*, ComparatorNumericalIdLess>& tc = t->isPerson() ? myPersons : myContainers;
    1264              :     auto it = tc.find(t);
    1265      7611824 :     if (it != tc.end()) {
    1266              :         tc.erase(it);
    1267              :     }
    1268      7611824 : }
    1269              : 
    1270              : std::vector<MSTransportable*>
    1271     73092743 : MSEdge::getSortedPersons(SUMOTime timestep, bool includeRiding) const {
    1272     73092743 :     std::vector<MSTransportable*> result(myPersons.begin(), myPersons.end());
    1273     73092743 :     if (includeRiding) {
    1274      2896155 :         for (std::vector<MSLane*>::const_iterator i = myLanes->begin(); i != myLanes->end(); ++i) {
    1275      2042878 :             const MSLane::VehCont& vehs = (*i)->getVehiclesSecure();
    1276      3266518 :             for (MSLane::VehCont::const_iterator j = vehs.begin(); j != vehs.end(); ++j) {
    1277      1223640 :                 const std::vector<MSTransportable*>& persons = (*j)->getPersons();
    1278      1223640 :                 result.insert(result.end(), persons.begin(), persons.end());
    1279              :             }
    1280      2042878 :             (*i)->releaseVehicles();
    1281              :         }
    1282              :     }
    1283     73092743 :     sort(result.begin(), result.end(), transportable_by_position_sorter(timestep));
    1284     73092743 :     return result;
    1285            0 : }
    1286              : 
    1287              : 
    1288              : std::vector<MSTransportable*>
    1289     55965536 : MSEdge::getSortedContainers(SUMOTime timestep, bool /* includeRiding */) const {
    1290     55965536 :     std::vector<MSTransportable*> result(myContainers.begin(), myContainers.end());
    1291     55965536 :     sort(result.begin(), result.end(), transportable_by_position_sorter(timestep));
    1292     55965536 :     return result;
    1293            0 : }
    1294              : 
    1295              : 
    1296              : int
    1297      4999022 : MSEdge::transportable_by_position_sorter::operator()(const MSTransportable* const c1, const MSTransportable* const c2) const {
    1298      4999022 :     const double pos1 = c1->getCurrentStage()->getEdgePos(myTime);
    1299      4999022 :     const double pos2 = c2->getCurrentStage()->getEdgePos(myTime);
    1300      4999022 :     if (pos1 != pos2) {
    1301      4848868 :         return pos1 < pos2;
    1302              :     }
    1303       150154 :     return c1->getID() < c2->getID();
    1304              : }
    1305              : 
    1306              : 
    1307              : void
    1308       127252 : MSEdge::addSuccessor(MSEdge* edge, const MSEdge* via) {
    1309       127252 :     mySuccessors.push_back(edge);
    1310       127252 :     myViaSuccessors.push_back(std::make_pair(edge, via));
    1311       127252 :     if (isTazConnector() && edge->getFromJunction() != nullptr) {
    1312        63622 :         myBoundary.add(edge->getFromJunction()->getPosition());
    1313              :     }
    1314              : 
    1315       127252 :     edge->myPredecessors.push_back(this);
    1316       127252 :     if (edge->isTazConnector() && getToJunction() != nullptr) {
    1317        63630 :         edge->myBoundary.add(getToJunction()->getPosition());
    1318              :     }
    1319       127252 : }
    1320              : 
    1321              : 
    1322              : const MSEdgeVector&
    1323     54139695 : MSEdge::getSuccessors(SUMOVehicleClass vClass) const {
    1324     54139695 :     if (vClass == SVC_IGNORING || !MSNet::getInstance()->hasPermissions() || myFunction == SumoXMLEdgeFunc::CONNECTOR) {
    1325     54122493 :         return mySuccessors;
    1326              :     }
    1327              : #ifdef HAVE_FOX
    1328        17202 :     ScopedLocker<> lock(mySuccessorMutex, MSGlobals::gNumThreads > 1);
    1329              : #endif
    1330              :     std::map<SUMOVehicleClass, MSEdgeVector>::iterator i = myClassesSuccessorMap.find(vClass);
    1331        17202 :     if (i == myClassesSuccessorMap.end()) {
    1332              :         // instantiate vector
    1333         2230 :         myClassesSuccessorMap[vClass];
    1334              :         i = myClassesSuccessorMap.find(vClass);
    1335              :         // this vClass is requested for the first time. rebuild all successors
    1336        11467 :         for (MSEdgeVector::const_iterator it = mySuccessors.begin(); it != mySuccessors.end(); ++it) {
    1337         9237 :             if ((*it)->isTazConnector()) {
    1338          288 :                 i->second.push_back(*it);
    1339              :             } else {
    1340         8949 :                 const std::vector<MSLane*>* allowed = allowedLanes(**it, vClass);
    1341         8949 :                 if (allowed != nullptr && allowed->size() > 0) {
    1342         6723 :                     i->second.push_back(*it);
    1343              :                 }
    1344              :             }
    1345              :         }
    1346              :     }
    1347              :     // can use cached value
    1348        17202 :     return i->second;
    1349              : }
    1350              : 
    1351              : 
    1352              : const MSConstEdgePairVector&
    1353    203571471 : MSEdge::getViaSuccessors(SUMOVehicleClass vClass, bool ignoreTransientPermissions) const {
    1354    203571471 :     if (vClass == SVC_IGNORING || !MSNet::getInstance()->hasPermissions() || myFunction == SumoXMLEdgeFunc::CONNECTOR) {
    1355    197813930 :         return myViaSuccessors;
    1356              :     }
    1357              : #ifdef HAVE_FOX
    1358      5757541 :     ScopedLocker<> lock(mySuccessorMutex, MSGlobals::gNumThreads > 1);
    1359              : #endif
    1360      5757541 :     auto& viaMap = ignoreTransientPermissions && myHaveTransientPermissions ? myOrigClassesViaSuccessorMap : myClassesViaSuccessorMap;
    1361              :     auto i = viaMap.find(vClass);
    1362      5757541 :     if (i == viaMap.end()) {
    1363              :         // instantiate vector
    1364        70988 :         MSConstEdgePairVector& result = viaMap[vClass];
    1365              :         // this vClass is requested for the first time. rebuild all successors
    1366       278689 :         for (const auto& viaPair : myViaSuccessors) {
    1367       207701 :             if (viaPair.first->isTazConnector()) {
    1368         8314 :                 result.push_back(viaPair);
    1369              :             } else {
    1370       199387 :                 const std::vector<MSLane*>* allowed = allowedLanes(*viaPair.first, vClass, ignoreTransientPermissions);
    1371       199387 :                 if (allowed != nullptr && allowed->size() > 0) {
    1372       152581 :                     result.push_back(viaPair);
    1373              :                 }
    1374              :             }
    1375              :         }
    1376              :         i = viaMap.find(vClass);
    1377              :     }
    1378      5757541 :     return i->second;
    1379              : }
    1380              : 
    1381              : 
    1382              : void
    1383      1830302 : MSEdge::setJunctions(MSJunction* from, MSJunction* to) {
    1384      1830302 :     myFromJunction = from;
    1385      1830302 :     myToJunction = to;
    1386      1830302 :     if (!isTazConnector()) {
    1387      1830302 :         myBoundary.add(from->getPosition());
    1388      1830302 :         myBoundary.add(to->getPosition());
    1389              :     }
    1390      1830302 : }
    1391              : 
    1392              : 
    1393              : bool
    1394      3013007 : MSEdge::canChangeToOpposite() const {
    1395      3013007 :     return (!myLanes->empty() && myLanes->back()->getOpposite() != nullptr &&
    1396              :             // do not change on curved internal lanes
    1397              :             (!isInternal()
    1398         5979 :              || (MSGlobals::gUsingInternalLanes
    1399         5979 :                  && myLanes->back()->getIncomingLanes()[0].viaLink->getDirection() == LinkDirection::STRAIGHT)));
    1400              : }
    1401              : 
    1402              : 
    1403              : const MSEdge*
    1404     22561455 : MSEdge::getOppositeEdge() const {
    1405     22561455 :     if (!myLanes->empty() && myLanes->back()->getOpposite() != nullptr) {
    1406      2986240 :         return &(myLanes->back()->getOpposite()->getEdge());
    1407              :     } else {
    1408     19575215 :         return nullptr;
    1409              :     }
    1410              : }
    1411              : 
    1412              : 
    1413              : bool
    1414          178 : MSEdge::hasMinorLink() const {
    1415          354 :     for (const MSLane* const l : *myLanes) {
    1416          386 :         for (const MSLink* const link : l->getLinkCont()) {
    1417          210 :             if (!link->havePriority()) {
    1418              :                 return true;
    1419              :             }
    1420              :         }
    1421              :     }
    1422              :     return false;
    1423              : }
    1424              : 
    1425              : bool
    1426       242657 : MSEdge::hasChangeProhibitions(SUMOVehicleClass svc, int index) const {
    1427       242657 :     if (myLanes->size() == 1) {
    1428              :         return false;
    1429              :     }
    1430       334237 :     for (const MSLane* const l : *myLanes) {
    1431       228214 :         if (l->getIndex() <= index && !l->allowsChangingRight(svc) && l->getIndex() > 0) {
    1432              :             return true;
    1433       228170 :         } else if (l->getIndex() >= index && !l->allowsChangingLeft(svc) && l->getIndex() < (int)(myLanes->size() - 1)) {
    1434              :             return true;
    1435              :         }
    1436              :     }
    1437              :     return false;
    1438              : }
    1439              : 
    1440              : void
    1441       950026 : MSEdge::checkAndRegisterBiDirEdge(const std::string& bidiID) {
    1442       950026 :     if (bidiID != "") {
    1443        33058 :         myBidiEdge = dictionary(bidiID);
    1444        33058 :         if (myBidiEdge == nullptr) {
    1445            0 :             WRITE_ERRORF(TL("Bidi-edge '%' does not exist"), bidiID);
    1446              :         }
    1447        33058 :         setBidiLanes();
    1448       548168 :         return;
    1449              :     }
    1450       916968 :     if (getFunction() != SumoXMLEdgeFunc::NORMAL) {
    1451              :         return;
    1452              :     }
    1453              :     // legacy networks (no bidi attribute)
    1454       401858 :     ConstMSEdgeVector candidates = myToJunction->getOutgoing();
    1455      3204579 :     for (ConstMSEdgeVector::const_iterator it = candidates.begin(); it != candidates.end(); it++) {
    1456      2802721 :         if ((*it)->getToJunction() == myFromJunction) { //reverse edge
    1457       317142 :             if (myBidiEdge != nullptr && isSuperposable(*it)) {
    1458            0 :                 WRITE_WARNINGF(TL("Ambiguous superposable edges between junction '%' and '%'."), myToJunction->getID(), myFromJunction->getID());
    1459            0 :                 break;
    1460              :             }
    1461       317142 :             if (isSuperposable(*it)) {
    1462           26 :                 myBidiEdge = *it;
    1463           26 :                 setBidiLanes();
    1464              :             }
    1465              :         }
    1466              :     }
    1467       401858 : }
    1468              : 
    1469              : 
    1470              : void
    1471        33084 : MSEdge::setBidiLanes() {
    1472              :     assert(myBidiEdge != nullptr);
    1473        33084 :     if (getNumLanes() == 1 && myBidiEdge->getNumLanes() == 1) {
    1474              :         // the other way round is set when this method runs for the bidiEdge
    1475        31352 :         getLanes()[0]->setBidiLane(myBidiEdge->getLanes()[0]);
    1476              :     } else {
    1477              :         // find lanes with matching reversed shapes
    1478              :         int numBidiLanes = 0;
    1479         5262 :         for (MSLane* l1 : *myLanes) {
    1480        10794 :             for (MSLane* l2 : *myBidiEdge->myLanes) {
    1481         7264 :                 if (l1->getShape().reverse().almostSame(l2->getShape(), POSITION_EPS * 2)) {
    1482         1786 :                     l1->setBidiLane(l2);
    1483         1786 :                     numBidiLanes++;
    1484              :                 }
    1485              :             }
    1486              :         }
    1487              :         // warn only once for each pair
    1488         1732 :         if (numBidiLanes == 0 && getNumericalID() < myBidiEdge->getNumericalID()) {
    1489           15 :             WRITE_WARNINGF(TL("Edge '%' and bidi edge '%' have no matching bidi lanes"), getID(), myBidiEdge->getID());
    1490              :         }
    1491              :     }
    1492        33084 : }
    1493              : 
    1494              : 
    1495              : bool
    1496       317142 : MSEdge::isSuperposable(const MSEdge* other) {
    1497       317142 :     if (other == nullptr || other->getLanes().size() != myLanes->size()) {
    1498              :         return false;
    1499              :     }
    1500              :     std::vector<MSLane*>::const_iterator it1 = myLanes->begin();
    1501              :     std::vector<MSLane*>::const_reverse_iterator it2 = other->getLanes().rbegin();
    1502              :     do {
    1503       312328 :         if ((*it1)->getShape().reverse() != (*it2)->getShape()) {
    1504              :             return false;
    1505              :         }
    1506              :         it1++;
    1507              :         it2++;
    1508           26 :     } while (it1 != myLanes->end());
    1509              : 
    1510              :     return true;
    1511              : }
    1512              : 
    1513              : 
    1514              : void
    1515        77392 : MSEdge::addWaiting(SUMOVehicle* vehicle) const {
    1516              : #ifdef HAVE_FOX
    1517        77392 :     ScopedLocker<> lock(myWaitingMutex, MSGlobals::gNumSimThreads > 1);
    1518              : #endif
    1519        77392 :     myWaiting.push_back(vehicle);
    1520        77392 : }
    1521              : 
    1522              : 
    1523              : void
    1524        68702 : MSEdge::removeWaiting(const SUMOVehicle* vehicle) const {
    1525              : #ifdef HAVE_FOX
    1526        68702 :     ScopedLocker<> lock(myWaitingMutex, MSGlobals::gNumSimThreads > 1);
    1527              : #endif
    1528        68702 :     std::vector<SUMOVehicle*>::iterator it = std::find(myWaiting.begin(), myWaiting.end(), vehicle);
    1529        68702 :     if (it != myWaiting.end()) {
    1530        68091 :         myWaiting.erase(it);
    1531              :     }
    1532        68702 : }
    1533              : 
    1534              : 
    1535              : SUMOVehicle*
    1536       136920 : MSEdge::getWaitingVehicle(MSTransportable* transportable, const double position) const {
    1537              : #ifdef HAVE_FOX
    1538       136920 :     ScopedLocker<> lock(myWaitingMutex, MSGlobals::gNumSimThreads > 1);
    1539              : #endif
    1540       137227 :     for (SUMOVehicle* const vehicle : myWaiting) {
    1541        25737 :         if (transportable->isWaitingFor(vehicle)) {
    1542        28157 :             if (vehicle->isStoppedInRange(position, MSGlobals::gStopTolerance) ||
    1543         2517 :                     (!vehicle->hasDeparted() &&
    1544         2311 :                      (vehicle->getParameter().departProcedure == DepartDefinition::TRIGGERED ||
    1545           82 :                       vehicle->getParameter().departProcedure == DepartDefinition::CONTAINER_TRIGGERED))) {
    1546              :                 return vehicle;
    1547              :             }
    1548          210 :             if (!vehicle->isLineStop(position) && vehicle->allowsBoarding(transportable)) {
    1549          228 :                 WRITE_WARNING((transportable->isPerson() ? "Person '" : "Container '")
    1550              :                               + transportable->getID() + "' at edge '" + getID() + "' position " + toString(position) + " cannot use waiting vehicle '"
    1551              :                               + vehicle->getID() + "' at position " + toString(vehicle->getPositionOnLane()) + " because it is too far away.");
    1552              :             }
    1553              :         }
    1554              :     }
    1555              :     return nullptr;
    1556              : }
    1557              : 
    1558              : std::vector<const SUMOVehicle*>
    1559       143775 : MSEdge::getVehicles() const {
    1560              :     std::vector<const SUMOVehicle*> result;
    1561       143775 :     if (MSGlobals::gUseMesoSim) {
    1562          220 :         for (MESegment* segment = MSGlobals::gMesoNet->getSegmentForEdge(*this); segment != nullptr; segment = segment->getNextSegment()) {
    1563          122 :             std::vector<const MEVehicle*> segmentVehs = segment->getVehicles();
    1564          122 :             result.insert(result.end(), segmentVehs.begin(), segmentVehs.end());
    1565          122 :         }
    1566              :     } else {
    1567       384836 :         for (MSLane* lane : getLanes()) {
    1568       827546 :             for (auto veh : lane->getVehiclesSecure()) {
    1569       586436 :                 result.push_back(veh);
    1570              :             }
    1571       241110 :             lane->releaseVehicles();
    1572              :         }
    1573              :     }
    1574       143775 :     return result;
    1575            0 : }
    1576              : 
    1577              : int
    1578       632601 : MSEdge::getNumDrivingLanes() const {
    1579              :     int result = 0;
    1580       632601 :     SVCPermissions filter = SVCAll;
    1581       632601 :     if ((myCombinedPermissions & ~(SVC_PEDESTRIAN | SVC_WHEELCHAIR)) != 0) {
    1582              :         filter = ~(SVC_PEDESTRIAN | SVC_WHEELCHAIR);
    1583         3862 :     } else if ((myCombinedPermissions & (SVC_PEDESTRIAN | SVC_WHEELCHAIR)) != 0) {
    1584              :         // filter out green verge
    1585              :         filter = (SVC_PEDESTRIAN | SVC_WHEELCHAIR);
    1586              :     }
    1587      1426908 :     for (const MSLane* const l : *myLanes) {
    1588       794307 :         if ((l->getPermissions() & filter) != 0) {
    1589       703930 :             result++;
    1590              :         }
    1591              :     }
    1592       632601 :     return result;
    1593              : }
    1594              : 
    1595              : int
    1596          399 : MSEdge::getVehicleNumber() const {
    1597          399 :     return (int)getVehicles().size();
    1598              : }
    1599              : 
    1600              : 
    1601              : bool
    1602            0 : MSEdge::isEmpty() const {
    1603              :     /// more efficient than retrieving vehicle number
    1604            0 :     if (MSGlobals::gUseMesoSim) {
    1605            0 :         for (MESegment* segment = MSGlobals::gMesoNet->getSegmentForEdge(*this); segment != nullptr; segment = segment->getNextSegment()) {
    1606            0 :             if (segment->getCarNumber() > 0) {
    1607              :                 return false;
    1608              :             }
    1609              :         }
    1610              :     } else {
    1611            0 :         for (MSLane* lane : getLanes()) {
    1612            0 :             if (lane->getVehicleNumber() > 0) {
    1613              :                 return false;
    1614              :             }
    1615              :         }
    1616              :     }
    1617              :     return true;
    1618              : }
    1619              : 
    1620              : 
    1621              : double
    1622           14 : MSEdge::getWaitingSeconds() const {
    1623              :     double wtime = 0;
    1624           14 :     if (MSGlobals::gUseMesoSim) {
    1625           12 :         for (MESegment* segment = MSGlobals::gMesoNet->getSegmentForEdge(*this); segment != nullptr; segment = segment->getNextSegment()) {
    1626            9 :             wtime += segment->getWaitingSeconds();
    1627              :         }
    1628              :     } else {
    1629           34 :         for (MSLane* lane : getLanes()) {
    1630           23 :             wtime += lane->getWaitingSeconds();
    1631              :         }
    1632              :     }
    1633           14 :     return wtime;
    1634              : }
    1635              : 
    1636              : 
    1637              : double
    1638           22 : MSEdge::getOccupancy() const {
    1639           22 :     if (myLanes->size() == 0) {
    1640              :         return 0;
    1641              :     }
    1642           22 :     if (MSGlobals::gUseMesoSim) {
    1643              :         /// @note MESegment only tracks brutto occupancy so we compute this from sratch
    1644              :         double sum = 0;
    1645            8 :         for (const SUMOVehicle* veh : getVehicles()) {
    1646            4 :             sum += dynamic_cast<const MEVehicle*>(veh)->getVehicleType().getLength();
    1647            4 :         }
    1648            4 :         return sum / (myLength * (double)myLanes->size());
    1649              :     } else {
    1650              :         double sum = 0;
    1651           48 :         for (auto lane : getLanes()) {
    1652           30 :             sum += lane->getNettoOccupancy();
    1653              :         }
    1654           18 :         return sum / (double)myLanes->size();
    1655              :     }
    1656              : }
    1657              : 
    1658              : 
    1659              : double
    1660            0 : MSEdge::getFlow() const {
    1661            0 :     if (myLanes->size() == 0) {
    1662              :         return 0;
    1663              :     }
    1664              :     double flow = 0;
    1665            0 :     for (MESegment* segment = MSGlobals::gMesoNet->getSegmentForEdge(*this); segment != nullptr; segment = segment->getNextSegment()) {
    1666            0 :         flow += (double) segment->getCarNumber() * segment->getMeanSpeed();
    1667              :     }
    1668            0 :     return 3600 * flow / (*myLanes)[0]->getLength();
    1669              : }
    1670              : 
    1671              : 
    1672              : double
    1673            0 : MSEdge::getBruttoOccupancy() const {
    1674            0 :     if (myLanes->size() == 0) {
    1675              :         return 0;
    1676              :     }
    1677              :     double occ = 0;
    1678            0 :     for (MESegment* segment = MSGlobals::gMesoNet->getSegmentForEdge(*this); segment != nullptr; segment = segment->getNextSegment()) {
    1679            0 :         occ += segment->getBruttoOccupancy();
    1680              :     }
    1681            0 :     return occ / (*myLanes)[0]->getLength() / (double)(myLanes->size());
    1682              : }
    1683              : 
    1684              : double
    1685         4240 : MSEdge::getTravelTimeAggregated(const MSEdge* const edge, const SUMOVehicle* const veh, double /*time*/) {
    1686         4240 :     return edge->getLength() / MIN2(MSRoutingEngine::getAssumedSpeed(edge, veh), veh->getMaxSpeed());
    1687              : }
    1688              : 
    1689              : 
    1690              : void
    1691         2098 : MSEdge::inferEdgeType() {
    1692              :     // @note must be called after closeBuilding() to ensure successors and
    1693              :     // predecessors are set
    1694         2098 :     if (isInternal() && myEdgeType == "") {
    1695         1274 :         const std::string typeBefore = getNormalBefore()->getEdgeType();
    1696         1274 :         if (typeBefore != "") {
    1697          694 :             const std::string typeAfter = getNormalSuccessor()->getEdgeType();
    1698          694 :             if (typeBefore == typeAfter) {
    1699              :                 myEdgeType = typeBefore;
    1700          314 :             } else if (typeAfter != "") {
    1701           68 :                 MSNet* net = MSNet::getInstance();
    1702           68 :                 auto resBefore = net->getRestrictions(typeBefore);
    1703           68 :                 auto resAfter = net->getRestrictions(typeAfter);
    1704           68 :                 if (resBefore != nullptr && resAfter != nullptr) {
    1705              :                     // create new restrictions for this type-combination
    1706           96 :                     myEdgeType = typeBefore + "|" + typeAfter;
    1707           48 :                     if (net->getRestrictions(myEdgeType) == nullptr) {
    1708           48 :                         for (const auto& item : *resBefore) {
    1709           24 :                             const SUMOVehicleClass svc = item.first;
    1710           24 :                             const double speed = item.second;
    1711              :                             const auto it = (*resAfter).find(svc);
    1712           24 :                             if (it != (*resAfter).end()) {
    1713           24 :                                 const double speed2 = it->second;
    1714           24 :                                 const double newSpeed = (MSNet::getInstance()->hasJunctionHigherSpeeds()
    1715           24 :                                                          ? MAX2(speed, speed2) : (speed + speed2) / 2);
    1716           24 :                                 net->addRestriction(myEdgeType, svc, newSpeed);
    1717              :                             }
    1718              :                         }
    1719              :                     }
    1720              :                 }
    1721              :             }
    1722              :         }
    1723              :     }
    1724         2098 : }
    1725              : 
    1726              : 
    1727              : double
    1728         2178 : MSEdge::getDistanceAt(double pos) const {
    1729              :     // negative values of myDistances indicate descending kilometrage
    1730         2178 :     return fabs(myDistance + pos);
    1731              : }
    1732              : 
    1733              : 
    1734              : bool
    1735         3292 : MSEdge::hasTransientPermissions() const {
    1736         3292 :     return myHaveTransientPermissions;
    1737              : }
    1738              : 
    1739              : 
    1740              : std::pair<double, SUMOTime>
    1741    601244934 : MSEdge::getLastBlocked(int index) const {
    1742    601244934 :     if (myLaneChanger != nullptr) {
    1743    601244934 :         return myLaneChanger->getLastBlocked(index);
    1744              :     }
    1745            0 :     return std::make_pair(-1, -1);
    1746              : }
    1747              : 
    1748              : 
    1749              : double
    1750         3088 : MSEdge::getPreference(const SUMOVTypeParameter& pars) const {
    1751         6176 :     return MSNet::getInstance()->getPreference(getRoutingType(), pars);
    1752              : }
    1753              : 
    1754              : 
    1755              : void
    1756         7032 : MSEdge::clearState() {
    1757              :     myPersons.clear();
    1758              :     myContainers.clear();
    1759              :     myWaiting.clear();
    1760         7032 : }
    1761              : 
    1762              : 
    1763              : const std::map<const MEVehicle*, std::pair<double, int> >&
    1764      3941835 : MSEdge::getMesoPositions() const {
    1765              :     assert(MSGlobals::gUseMesoSim);
    1766      3941835 :     if (myLastCacheUpdate < SIMSTEP) {
    1767      3854048 :         myLastCacheUpdate = SIMSTEP;
    1768              :         auto old = std::move(myCachedMesoPos);
    1769              :         myCachedMesoPos.clear();  // moved-from map is valid-but-unspecified; make it defined-empty
    1770              :         int laneIndex = 0;
    1771      3854048 :         const double now = SIMTIME;
    1772      9164397 :         for (std::vector<MSLane*>::const_iterator msl = myLanes->begin(); msl != myLanes->end(); ++msl, ++laneIndex) {
    1773              :             // go through the vehicles
    1774              :             double segmentOffset = 0; // offset at start of current segment
    1775      5310349 :             for (MESegment* segment = MSGlobals::gMesoNet->getSegmentForEdge(*this);
    1776     10882672 :                     segment != nullptr; segment = segment->getNextSegment()) {
    1777              :                 const double segLength = segment->getLength();
    1778      5572323 :                 const double lanesCovered = segment->numQueues() == 1 ? std::round(segment->getCapacity() / segLength) : 1.;
    1779      5572323 :                 if (laneIndex < segment->numQueues()) {
    1780              :                     // make a copy so we don't have to worry about synchronization
    1781      4577391 :                     std::vector<MEVehicle*> queue = segment->getQueue(laneIndex);
    1782      4577391 :                     const int queueSize = (int)queue.size();
    1783              :                     SUMOTime earliestExitTime = segment->getQueueBlockTime(laneIndex);
    1784              :                     int overlap = 0;
    1785              :                     double prevPos = std::numeric_limits<double>::max();
    1786      9551069 :                     for (int i = 0; i < queueSize; ++i) {
    1787      4973678 :                         const MEVehicle* const veh = queue[queueSize - i - 1];
    1788              :                         earliestExitTime = MAX2(earliestExitTime, veh->getEventTime());
    1789      4973678 :                         const double vehLength = veh->getVehicleType().getLengthWithGap();
    1790      4973678 :                         double maxPos = segmentOffset + segLength;
    1791              :                         auto it = old.find(veh);
    1792      4973678 :                         const double oldPos = it != old.end() ? it->second.first : 0.;  // store the old position to prevent backwards moving vehicles
    1793      4973678 :                         if (i > 0) {
    1794      4634259 :                             earliestExitTime += segment->getMinTauWithVehLength(vehLength, veh->getVehicleType().getCarFollowModel().getHeadwayTime());
    1795      4634259 :                             maxPos = MIN2(maxPos, prevPos - vehLength / lanesCovered);
    1796              :                         }
    1797      4973678 :                         const double entry = veh->getLastEntryTimeSeconds();
    1798              :                         assert(STEPS2TIME(earliestExitTime) > entry);
    1799      4973678 :                         const double pos = MAX2(MIN2(segmentOffset + segLength * (now - entry) / (STEPS2TIME(earliestExitTime) - entry), maxPos), oldPos);
    1800              :                         // check if we overlap with the previous vehicle such that the gui has the chance to add some lateral offset
    1801      4973678 :                         if (overlap == 0 && prevPos - pos < vehLength) {
    1802      1063643 :                             overlap = lanesCovered > 1. ? -3 : -1;
    1803              :                         } else {
    1804              :                             overlap = 0;
    1805              :                         }
    1806      4973678 :                         myCachedMesoPos[veh] = std::make_pair(pos, overlap);
    1807              :                         prevPos = pos;
    1808              :                     }
    1809      4577391 :                 }
    1810      5572323 :                 segmentOffset += segLength;
    1811              :             }
    1812              :         }
    1813              :     }
    1814      3941835 :     return myCachedMesoPos;
    1815              : }
    1816              : 
    1817              : 
    1818              : double
    1819     11383568 : MSEdge::getMinLength() const {
    1820              :     double result = std::numeric_limits<double>::max();
    1821     32718546 :     for (const MSLane* l : *myLanes) {
    1822              :         result = MIN2(result, l->getLength());
    1823              :     }
    1824     11383568 :     return result;
    1825              : }
    1826              : 
    1827              : 
    1828              : /****************************************************************************/
        

Generated by: LCOV version 2.0-1