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 1915067 : 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 1915067 : double distance) :
75 1915067 : Named(id), myNumericalID(numericalID), myLanes(nullptr),
76 1915067 : myLaneChanger(nullptr), myFunction(function), myVaporizationRequests(0),
77 1915067 : myLastFailedInsertionTime(-1),
78 1915067 : myFromJunction(nullptr), myToJunction(nullptr),
79 1915067 : myHaveTransientPermissions(false),
80 1915067 : myOtherTazConnector(nullptr),
81 1915067 : myStreetName(streetName),
82 1915067 : myEdgeType(edgeType),
83 1915067 : myRoutingType(routingType),
84 1915067 : myPriority(priority),
85 1915067 : myDistance(distance),
86 1915067 : myWidth(0.),
87 1915067 : myLength(0.),
88 1915067 : myEmptyTraveltime(0.),
89 1915067 : myTimePenalty(0.),
90 1915067 : myAmDelayed(false),
91 1915067 : myAmRoundabout(false),
92 1915067 : myAmFringe(true),
93 3830134 : myBidiEdge(nullptr)
94 1915067 : { }
95 :
96 :
97 3304086 : MSEdge::~MSEdge() {
98 1899662 : delete myLaneChanger;
99 1899662 : delete myReversedRoutingEdge;
100 1899662 : delete myRailwayRoutingEdge;
101 10902734 : }
102 :
103 :
104 : void
105 1782144 : MSEdge::initialize(const std::vector<MSLane*>* lanes) {
106 : assert(lanes != 0);
107 1782144 : myLanes = std::shared_ptr<const std::vector<MSLane*> >(lanes);
108 1782144 : if (myFunction == SumoXMLEdgeFunc::CONNECTOR) {
109 61474 : myCombinedPermissions = SVCAll;
110 : }
111 3855099 : for (MSLane* const lane : *lanes) {
112 2072955 : lane->setRightSideOnEdge(myWidth, (int)mySublaneSides.size());
113 2072955 : MSLeaderInfo ahead(lane->getWidth());
114 4845637 : for (int j = 0; j < ahead.numSublanes(); ++j) {
115 2772682 : mySublaneSides.push_back(myWidth + j * MSGlobals::gLateralResolution);
116 : }
117 2072955 : myWidth += lane->getWidth();
118 2072955 : }
119 1782144 : }
120 :
121 :
122 1806421 : void MSEdge::recalcCache() {
123 1806421 : if (myLanes->empty()) {
124 : return;
125 : }
126 1806421 : myLength = myLanes->front()->getLength();
127 3612842 : myEmptyTraveltime = myLength / MAX2(getSpeedLimit(), NUMERICAL_EPS);
128 1806421 : if (isNormal() && (MSGlobals::gUseMesoSim || MSGlobals::gTLSPenalty > 0)) {
129 : SUMOTime minorPenalty = 0;
130 177001 : bool haveTLSPenalty = MSGlobals::gTLSPenalty > 0;
131 177001 : if (MSGlobals::gUseMesoSim) {
132 176886 : const MESegment::MesoEdgeType& edgeType = MSNet::getInstance()->getMesoType(getEdgeType());
133 176886 : minorPenalty = edgeType.minorPenalty;
134 176886 : haveTLSPenalty = edgeType.tlsPenalty > 0;
135 : }
136 177001 : if (haveTLSPenalty || minorPenalty > 0) {
137 : // add tls penalties to the minimum travel time
138 : SUMOTime minPenalty = -1;
139 2555 : for (const MSLane* const l : *myLanes) {
140 4099 : for (const MSLink* const link : l->getLinkCont()) {
141 2387 : if (link->getLane()->isWalkingArea() && link->getLaneBefore()->isNormal()) {
142 60 : continue;
143 : }
144 2327 : SUMOTime linkPenalty = link->isTLSControlled() ? link->getMesoTLSPenalty() : (link->havePriority() ? 0 : minorPenalty);
145 2327 : if (minPenalty == -1) {
146 : minPenalty = linkPenalty;
147 : } else {
148 : minPenalty = MIN2(minPenalty, linkPenalty);
149 : }
150 : }
151 : }
152 843 : if (minPenalty > 0) {
153 285 : myEmptyTraveltime += STEPS2TIME(minPenalty);
154 285 : myTimePenalty = STEPS2TIME(minPenalty);
155 : }
156 : }
157 1629420 : } else if (isCrossing() && MSGlobals::gTLSPenalty > 0) {
158 : // penalties are recorded for the entering link
159 80 : for (const auto& ili : myLanes->front()->getIncomingLanes()) {
160 40 : double penalty = STEPS2TIME(ili.viaLink->getMesoTLSPenalty());
161 40 : if (!ili.viaLink->haveOffPriority()) {
162 0 : penalty = MAX2(penalty, MSGlobals::gMinorPenalty);
163 : }
164 40 : if (penalty > 0) {
165 20 : myEmptyTraveltime += penalty;
166 20 : myTimePenalty = penalty;
167 : }
168 : }
169 1629380 : } else if (isInternal() && MSGlobals::gUsingInternalLanes) {
170 740395 : const MSLink* link = myLanes->front()->getIncomingLanes()[0].viaLink;
171 740395 : if (!link->isTLSControlled() && !link->havePriority()) {
172 353475 : if (link->isTurnaround()) {
173 132192 : myEmptyTraveltime += MSGlobals::gTurnaroundPenalty;
174 132192 : myTimePenalty = MSGlobals::gTurnaroundPenalty;
175 : } else {
176 221283 : myEmptyTraveltime += MSGlobals::gMinorPenalty;
177 221283 : myTimePenalty = MSGlobals::gMinorPenalty;
178 : }
179 : }
180 : }
181 : }
182 :
183 :
184 : void
185 42 : MSEdge::resetTAZ(MSJunction* junction) {
186 : mySuccessors.clear();
187 : myPredecessors.clear();
188 728 : for (const MSEdge* edge : junction->getIncoming()) {
189 686 : if (!edge->isInternal()) {
190 126 : MSEdgeVector& succ = const_cast<MSEdgeVector&>(edge->mySuccessors);
191 : MSConstEdgePairVector& succVia = const_cast<MSConstEdgePairVector&>(edge->myViaSuccessors);
192 126 : MSEdgeVector& pred = const_cast<MSEdgeVector&>(edge->myPredecessors);
193 126 : auto it = std::find(succ.begin(), succ.end(), this);
194 126 : auto it2 = std::find(succVia.begin(), succVia.end(), std::make_pair(const_cast<const MSEdge*>(this), (const MSEdge*)nullptr));
195 126 : auto it3 = std::find(pred.begin(), pred.end(), this);
196 126 : if (it != succ.end()) {
197 : succ.erase(it);
198 : succVia.erase(it2);
199 : }
200 126 : if (it3 != pred.end()) {
201 : pred.erase(it3);
202 : }
203 : }
204 : }
205 42 : }
206 :
207 : void
208 1718152 : MSEdge::closeBuilding() {
209 3788166 : for (MSLane* const lane : *myLanes) {
210 4719181 : for (MSLink* const link : lane->getLinkCont()) {
211 2649167 : link->initParallelLinks();
212 : MSLane* const toL = link->getLane();
213 : MSLane* const viaL = link->getViaLane();
214 2649167 : if (toL != nullptr) {
215 : MSEdge& to = toL->getEdge();
216 2649167 : if (std::find(mySuccessors.begin(), mySuccessors.end(), &to) == mySuccessors.end()) {
217 2462006 : mySuccessors.push_back(&to);
218 4924012 : myViaSuccessors.push_back(std::make_pair(&to, (viaL == nullptr ? nullptr : &viaL->getEdge())));
219 : }
220 2649167 : if (std::find(to.myPredecessors.begin(), to.myPredecessors.end(), this) == to.myPredecessors.end()) {
221 2462006 : to.myPredecessors.push_back(this);
222 : }
223 2649167 : if (link->getDirection() != LinkDirection::TURN) {
224 2060035 : myAmFringe = false;
225 : }
226 : }
227 2649167 : if (viaL != nullptr) {
228 : MSEdge& to = viaL->getEdge();
229 811172 : if (std::find(to.myPredecessors.begin(), to.myPredecessors.end(), this) == to.myPredecessors.end()) {
230 740212 : to.myPredecessors.push_back(this);
231 : }
232 : }
233 : }
234 2070014 : lane->checkBufferType();
235 : }
236 1718152 : std::sort(mySuccessors.begin(), mySuccessors.end(), by_id_sorter());
237 1718152 : rebuildAllowedLanes(true);
238 1718152 : recalcCache();
239 :
240 : // extend lookup table for sublane model after all edges are read
241 1718152 : if (myLanes->back()->getOpposite() != nullptr) {
242 8276 : MSLane* opposite = myLanes->back()->getOpposite();
243 8276 : MSLeaderInfo ahead(opposite->getWidth());
244 22618 : for (int j = 0; j < ahead.numSublanes(); ++j) {
245 14342 : mySublaneSides.push_back(myWidth + j * MSGlobals::gLateralResolution);
246 : }
247 8276 : }
248 1718152 : }
249 :
250 :
251 : void
252 1718144 : MSEdge::postLoadInitLaneChanger() {
253 1718144 : if (myLaneChanger != nullptr) {
254 432283 : myLaneChanger->postloadInitLC();
255 : }
256 1718144 : }
257 :
258 : void
259 1718152 : MSEdge::buildLaneChanger() {
260 1718152 : if (!myLanes->empty()) {
261 1718152 : const bool allowChanging = allowsLaneChanging();
262 1718152 : if (MSGlobals::gLateralResolution > 0) {
263 : // may always initiate sublane-change
264 179805 : if (!isInternal() || MSGlobals::gUsingInternalLanes) {
265 179614 : myLaneChanger = new MSLaneChangerSublane(myLanes.get(), allowChanging);
266 : }
267 : } else {
268 1538347 : if (MSGlobals::gLaneChangeDuration > 0) {
269 3717 : myLaneChanger = new MSLaneChanger(myLanes.get(), allowChanging);
270 1534630 : } else if (myLanes->size() > 1 || canChangeToOpposite()) {
271 248960 : myLaneChanger = new MSLaneChanger(myLanes.get(), allowChanging);
272 : }
273 : }
274 : }
275 1718152 : }
276 :
277 :
278 : bool
279 1718152 : MSEdge::allowsLaneChanging() const {
280 1718152 : 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 1194973 : for (const MSLane* const lane : *myLanes) {
284 808453 : const MSLink* const link = lane->getLogicalPredecessorLane()->getLinkTo(lane);
285 : assert(link != nullptr);
286 : const LinkState state = link->getState();
287 345006 : if ((state == LINKSTATE_MINOR && lane->getBidiLane() == nullptr)
288 463681 : || state == LINKSTATE_EQUAL
289 463681 : || state == LINKSTATE_STOP
290 : || state == LINKSTATE_ALLWAY_STOP
291 808453 : || state == LINKSTATE_DEADEND) {
292 : return false;
293 : }
294 : }
295 : }
296 : return true;
297 : }
298 :
299 :
300 : void
301 17537912 : MSEdge::addToAllowed(const SVCPermissions permissions, std::shared_ptr<const std::vector<MSLane*> > allowedLanes, AllowedLanesCont& laneCont) const {
302 17537912 : if (!allowedLanes->empty()) {
303 : // recheck whether we had this list to save memory
304 17721168 : for (auto& allowed : laneCont) {
305 16729867 : if (*allowed.second == *allowedLanes) {
306 12516199 : allowed.first |= permissions;
307 : return;
308 : }
309 : }
310 991301 : laneCont.push_back(std::make_pair(permissions, allowedLanes));
311 : }
312 : }
313 :
314 :
315 : SVCPermissions
316 2843323 : MSEdge::getMesoPermissions(SVCPermissions p, SVCPermissions ignoreIgnored) {
317 2843323 : SVCPermissions ignored = myMesoIgnoredVClasses & ~ignoreIgnored;
318 2843323 : return (p | ignored) == ignored ? 0 : p;
319 : }
320 :
321 :
322 : void
323 1719605 : MSEdge::rebuildAllowedLanes(const bool onInit, bool updateVehicles) {
324 : // rebuild myMinimumPermissions and myCombinedPermissions
325 1719605 : myMinimumPermissions = SVCAll;
326 1719605 : myCombinedPermissions = 0;
327 : bool lanesChangedPermission = false;
328 3791606 : for (MSLane* const lane : *myLanes) {
329 : // same dedicated lanes are ignored in meso to avoid capacity errors.
330 : // Here we have to make sure that vehicles which are set to depart on
331 : // such lanes trigger an error.
332 2072001 : SVCPermissions allow = getMesoPermissions(lane->getPermissions(), SVC_PEDESTRIAN);
333 2072001 : myMinimumPermissions &= allow;
334 2072001 : myCombinedPermissions |= allow;
335 2072001 : lanesChangedPermission |= lane->hadPermissionChanges();
336 : }
337 1719605 : if (!onInit && !myHaveTransientPermissions && lanesChangedPermission) {
338 1002 : myHaveTransientPermissions = true;
339 : // backup original structures when first needed
340 1002 : myOrigAllowed = myAllowed;
341 : myOrigAllowedTargets = myAllowedTargets;
342 : myOrigClassesViaSuccessorMap = myClassesViaSuccessorMap;
343 : }
344 : // rebuild myAllowed
345 : myAllowed.clear();
346 1719605 : if (myCombinedPermissions != myMinimumPermissions) {
347 165485 : myAllowed.push_back(std::make_pair(SVC_IGNORING, myLanes));
348 5626490 : for (SVCPermissions vclass = SVC_PRIVATE; vclass <= SUMOVehicleClass_MAX; vclass *= 2) {
349 5461005 : if ((myCombinedPermissions & vclass) == vclass) {
350 : std::shared_ptr<std::vector<MSLane*> > allowedLanes = std::make_shared<std::vector<MSLane*> >();
351 11492643 : for (MSLane* const lane : *myLanes) {
352 7783908 : if (lane->allowsVehicleClass((SUMOVehicleClass)vclass)) {
353 3920768 : allowedLanes->push_back(lane);
354 : }
355 : }
356 7417470 : addToAllowed(vclass, allowedLanes, myAllowed);
357 : }
358 : }
359 : }
360 1719605 : if (onInit) {
361 1718152 : myOriginalMinimumPermissions = myMinimumPermissions;
362 1718152 : myOriginalCombinedPermissions = myCombinedPermissions;
363 : } else {
364 1453 : rebuildAllowedTargets(updateVehicles);
365 3692 : for (MSEdge* pred : myPredecessors) {
366 2239 : if (myHaveTransientPermissions && !pred->myHaveTransientPermissions) {
367 1392 : pred->myOrigAllowed = pred->myAllowed;
368 : pred->myOrigAllowedTargets = pred->myAllowedTargets;
369 : pred->myOrigClassesViaSuccessorMap = pred->myClassesViaSuccessorMap;
370 1392 : pred->myHaveTransientPermissions = true;
371 : }
372 2239 : pred->rebuildAllowedTargets(updateVehicles);
373 : }
374 1453 : if (MSGlobals::gUseMesoSim) {
375 2361 : for (MESegment* s = MSGlobals::gMesoNet->getSegmentForEdge(*this); s != nullptr; s = s->getNextSegment()) {
376 1986 : s->updatePermissions();
377 : }
378 : }
379 : }
380 1719605 : }
381 :
382 :
383 : void
384 1722858 : MSEdge::rebuildAllowedTargets(const bool updateVehicles) {
385 : myAllowedTargets.clear();
386 4191823 : for (const MSEdge* target : mySuccessors) {
387 : bool universalMap = true; // whether the mapping for SVC_IGNORING is also valid for all vehicle classes
388 : std::shared_ptr<std::vector<MSLane*> > allLanes = std::make_shared<std::vector<MSLane*> >();
389 : // compute the mapping for SVC_IGNORING
390 5651481 : for (MSLane* const lane : *myLanes) {
391 : SVCPermissions combinedTargetPermissions = 0;
392 9188952 : for (const MSLink* const link : lane->getLinkCont()) {
393 6006436 : if (&link->getLane()->getEdge() == target) {
394 2657199 : allLanes->push_back(lane);
395 2657199 : combinedTargetPermissions |= link->getLane()->getPermissions();
396 2657199 : if (link->getViaLane() != nullptr &&
397 813367 : ((lane->getPermissions() & link->getLane()->getPermissions()) != link->getViaLane()->getPermissions())) {
398 : // custom connection permissions
399 : universalMap = false;
400 : }
401 : }
402 : }
403 3182516 : if (combinedTargetPermissions == 0 || (lane->getPermissions() & combinedTargetPermissions) != lane->getPermissions()) {
404 : universalMap = false;
405 : }
406 : }
407 2468965 : if (universalMap) {
408 1995167 : if (myAllowed.empty()) {
409 : // we have no lane specific permissions
410 3922600 : myAllowedTargets[target].push_back(std::make_pair(myMinimumPermissions, myLanes));
411 : } else {
412 133574 : for (const auto& i : myAllowed) {
413 299121 : addToAllowed(i.first, i.second, myAllowedTargets[target]);
414 : }
415 : }
416 : } else {
417 947596 : addToAllowed(SVC_IGNORING, allLanes, myAllowedTargets[target]);
418 : // compute the vclass specific mapping
419 16109132 : for (SVCPermissions vclass = SVC_PRIVATE; vclass <= SUMOVehicleClass_MAX; vclass *= 2) {
420 15635334 : if ((myCombinedPermissions & vclass) == vclass) {
421 : std::shared_ptr<std::vector<MSLane*> > allowedLanes = std::make_shared<std::vector<MSLane*> >();
422 41282218 : for (MSLane* const lane : *myLanes) {
423 28026546 : if (lane->allowsVehicleClass((SUMOVehicleClass)vclass)) {
424 53247248 : for (const MSLink* const link : lane->getLinkCont()) {
425 34615075 : if (link->getLane()->allowsVehicleClass((SUMOVehicleClass)vclass) && &link->getLane()->getEdge() == target && (link->getViaLane() == nullptr || link->getViaLane()->allowsVehicleClass((SUMOVehicleClass)vclass))) {
426 9578863 : allowedLanes->push_back(lane);
427 : }
428 : }
429 : }
430 : }
431 39767016 : addToAllowed(vclass, allowedLanes, myAllowedTargets[target]);
432 : }
433 : }
434 : }
435 : }
436 1722858 : if (updateVehicles) {
437 3027 : for (const MSLane* const lane : *myLanes) {
438 1779 : const MSLane::VehCont& vehs = lane->getVehiclesSecure();
439 4223 : for (MSVehicle* veh : vehs) {
440 2444 : veh->updateBestLanes(true);
441 : }
442 1779 : lane->releaseVehicles();
443 : }
444 : }
445 : myClassesSuccessorMap.clear();
446 1722858 : }
447 :
448 :
449 : // ------------ Access to the edge's lanes
450 : MSLane*
451 774 : MSEdge::leftLane(const MSLane* const lane) const {
452 774 : return parallelLane(lane, 1);
453 : }
454 :
455 :
456 : MSLane*
457 400 : MSEdge::rightLane(const MSLane* const lane) const {
458 400 : return parallelLane(lane, -1);
459 : }
460 :
461 :
462 : MSLane*
463 82781501 : MSEdge::parallelLane(const MSLane* const lane, int offset, bool includeOpposite) const {
464 82781501 : const int resultIndex = lane->getIndex() + offset;
465 82781501 : if (resultIndex >= getNumLanes() && includeOpposite) {
466 20345579 : const MSEdge* opposite = getOppositeEdge();
467 20345579 : if (opposite != nullptr && resultIndex < getNumLanes() + opposite->getNumLanes()) {
468 1384485 : return opposite->getLanes()[opposite->getNumLanes() + getNumLanes() - resultIndex - 1];
469 : }
470 : return nullptr;
471 62435922 : } else if (resultIndex >= (int)myLanes->size() || resultIndex < 0) {
472 : return nullptr;
473 : } else {
474 39173841 : return (*myLanes)[resultIndex];
475 : }
476 : }
477 :
478 :
479 : const std::vector<MSLane*>*
480 80183239 : MSEdge::allowedLanes(const MSEdge& destination, SUMOVehicleClass vclass, bool ignoreTransientPermissions) const {
481 80183239 : const auto& targets = ignoreTransientPermissions && myHaveTransientPermissions ? myOrigAllowedTargets : myAllowedTargets;
482 : AllowedLanesByTarget::const_iterator i = targets.find(&destination);
483 80183239 : if (i != targets.end()) {
484 80185442 : for (const auto& allowed : i->second) {
485 80076967 : if ((allowed.first & vclass) == vclass) {
486 : return allowed.second.get();
487 : }
488 : }
489 : }
490 : return nullptr;
491 : }
492 :
493 :
494 : const std::vector<MSLane*>*
495 713771454 : MSEdge::allowedLanes(SUMOVehicleClass vclass) const {
496 713771454 : if ((myMinimumPermissions & vclass) == vclass) {
497 43503544 : return myLanes.get();
498 : } else {
499 670267910 : if ((myCombinedPermissions & vclass) == vclass) {
500 1340532497 : for (const auto& allowed : myAllowed) {
501 1340532497 : if ((allowed.first & vclass) == vclass) {
502 : return allowed.second.get();
503 : }
504 : }
505 : }
506 1989 : return nullptr;
507 : }
508 : }
509 :
510 :
511 : const std::vector<MSLane*>*
512 7008041794 : MSEdge::allowedLanes(SUMOVehicleClass vclass, bool ignoreTransientPermissions) const {
513 7008041794 : const SVCPermissions& minP = ignoreTransientPermissions ? myOriginalMinimumPermissions : myMinimumPermissions;
514 7008041794 : if ((minP & vclass) == vclass) {
515 634036259 : return myLanes.get();
516 : } else {
517 6374005535 : const SVCPermissions comP = ignoreTransientPermissions ? myOriginalCombinedPermissions : myCombinedPermissions;
518 6374005535 : if ((comP & vclass) == vclass) {
519 6374005463 : const AllowedLanesCont& allowedCont = ignoreTransientPermissions ? myOrigAllowed : myAllowed;
520 12753710337 : for (const auto& allowed : allowedCont) {
521 12753710337 : if ((allowed.first & vclass) == vclass) {
522 : return allowed.second.get();
523 : }
524 : }
525 : }
526 72 : return nullptr;
527 : }
528 : }
529 :
530 :
531 : // ------------
532 : SUMOTime
533 433 : MSEdge::incVaporization(SUMOTime) {
534 433 : ++myVaporizationRequests;
535 433 : return 0;
536 : }
537 :
538 :
539 : SUMOTime
540 282 : MSEdge::decVaporization(SUMOTime) {
541 282 : --myVaporizationRequests;
542 282 : return 0;
543 : }
544 :
545 :
546 : MSLane*
547 564575225 : MSEdge::getFreeLane(const std::vector<MSLane*>* allowed, const SUMOVehicleClass vclass, double departPos) const {
548 564575225 : if (allowed == nullptr) {
549 524862293 : allowed = allowedLanes(vclass);
550 : }
551 : MSLane* res = nullptr;
552 524862293 : if (allowed != nullptr) {
553 : double largestGap = 0;
554 : MSLane* resByGap = nullptr;
555 : double leastOccupancy = std::numeric_limits<double>::max();
556 1153534652 : for (std::vector<MSLane*>::const_iterator i = allowed->begin(); i != allowed->end(); ++i) {
557 588961408 : const double occupancy = (*i)->getBruttoOccupancy();
558 588961408 : if (occupancy < leastOccupancy) {
559 572368913 : res = (*i);
560 : leastOccupancy = occupancy;
561 : }
562 588961408 : const MSVehicle* last = (*i)->getLastFullVehicle();
563 588961408 : const double lastGap = (last != nullptr ? last->getPositionOnLane() : myLength) - departPos;
564 588961408 : if (lastGap > largestGap) {
565 : largestGap = lastGap;
566 67021601 : resByGap = (*i);
567 : }
568 : }
569 564573244 : if (resByGap != nullptr) {
570 : //if (res != resByGap) std::cout << SIMTIME << " edge=" << getID() << " departPos=" << departPos << " res=" << Named::getIDSecure(res) << " resByGap=" << Named::getIDSecure(resByGap) << " largestGap=" << largestGap << "\n";
571 : res = resByGap;
572 : }
573 : }
574 564575225 : return res;
575 : }
576 :
577 :
578 : MSLane*
579 3264820 : MSEdge::getProbableLane(const std::vector<MSLane*>* allowed, const SUMOVehicleClass vclass, double departPos, double maxSpeed) const {
580 3264820 : if (allowed == nullptr) {
581 0 : allowed = allowedLanes(vclass);
582 : }
583 : MSLane* res = nullptr;
584 0 : if (allowed != nullptr) {
585 : double largestGap = 0;
586 : double largestSpeed = 0;
587 : MSLane* resByGap = nullptr;
588 : double leastOccupancy = std::numeric_limits<double>::max();
589 : int aIndex = 0;
590 11504899 : for (std::vector<MSLane*>::const_iterator i = allowed->begin(); i != allowed->end(); ++i, aIndex++) {
591 8240079 : const double occupancy = (*i)->getBruttoOccupancy();
592 8240079 : if (occupancy < leastOccupancy) {
593 7576634 : res = (*i);
594 : leastOccupancy = occupancy;
595 : }
596 8240079 : const MSVehicle* last = (*i)->getLastFullVehicle();
597 8240079 : double lastGap = (last != nullptr ? last->getPositionOnLane() : myLength) - departPos;
598 : // never insert to the left of a vehicle with a larger speedFactor
599 8240079 : if (lastGap > largestGap && maxSpeed >= largestSpeed) {
600 : largestGap = lastGap;
601 4451509 : resByGap = (*i);
602 : }
603 8240079 : if (last != nullptr) {
604 8239171 : largestSpeed = MAX2(largestSpeed, getVehicleMaxSpeed(last));
605 : }
606 : }
607 3264820 : if (resByGap != nullptr) {
608 : //if (res != resByGap) std::cout << SIMTIME << " edge=" << getID() << " departPos=" << departPos << " res=" << Named::getIDSecure(res) << " resByGap=" << Named::getIDSecure(resByGap) << " largestGap=" << largestGap << "\n";
609 : res = resByGap;
610 : }
611 : }
612 3264820 : return res;
613 : }
614 :
615 :
616 : double
617 567915146 : MSEdge::getDepartPosBound(const MSVehicle& veh, bool upper) const {
618 567915146 : const SUMOVehicleParameter& pars = veh.getParameter();
619 : double pos = getLength();
620 : // determine the position
621 567915146 : switch (pars.departPosProcedure) {
622 1794481 : case DepartPosDefinition::GIVEN:
623 1794481 : pos = pars.departPos;
624 1794481 : if (pos < 0.) {
625 1699610 : pos += myLength;
626 : }
627 : break;
628 : case DepartPosDefinition::RANDOM:
629 : // could be any position on the edge
630 : break;
631 : case DepartPosDefinition::RANDOM_FREE:
632 : // could be any position on the edge due to multiple random attempts
633 : break;
634 : case DepartPosDefinition::FREE:
635 : // many candidate positions, upper bound could be computed exactly
636 : // with much effort
637 : break;
638 315819 : case DepartPosDefinition::LAST:
639 315819 : if (upper) {
640 472974 : for (std::vector<MSLane*>::const_iterator i = myLanes->begin(); i != myLanes->end(); ++i) {
641 321528 : MSVehicle* last = (*i)->getLastFullVehicle();
642 321528 : if (last != nullptr) {
643 278494 : pos = MIN2(pos, last->getPositionOnLane());
644 : }
645 : }
646 : } else {
647 : pos = 0;
648 : }
649 : break;
650 60659545 : case DepartPosDefinition::BASE:
651 : case DepartPosDefinition::DEFAULT:
652 60659545 : if (!upper) {
653 : pos = 0;
654 : }
655 : break;
656 20 : default:
657 20 : pos = MIN2(pos, veh.getVehicleType().getLength());
658 : break;
659 : }
660 567915146 : return pos;
661 : }
662 :
663 : MSLane*
664 43 : MSEdge::getDepartLaneMeso(SUMOVehicle& veh) const {
665 43 : if (veh.getParameter().departLaneProcedure == DepartLaneDefinition::GIVEN) {
666 3 : if ((int) myLanes->size() <= veh.getParameter().departLane || !(*myLanes)[veh.getParameter().departLane]->allowsVehicleClass(veh.getVehicleType().getVehicleClass())) {
667 0 : return nullptr;
668 : }
669 3 : return (*myLanes)[veh.getParameter().departLane];
670 : }
671 40 : return (*myLanes)[0];
672 : }
673 :
674 : MSLane*
675 6917064247 : MSEdge::getDepartLane(MSVehicle& veh) const {
676 6917064247 : DepartLaneDefinition dld = veh.getParameter().departLaneProcedure;
677 6917064247 : int departLane = veh.getParameter().departLane;
678 6917064247 : if (dld == DepartLaneDefinition::DEFAULT) {
679 6055675936 : dld = myDefaultDepartLaneDefinition;
680 6055675936 : departLane = myDefaultDepartLane;
681 : }
682 6917064247 : switch (dld) {
683 100838541 : case DepartLaneDefinition::GIVEN:
684 100838541 : if ((int) myLanes->size() <= departLane || !(*myLanes)[departLane]->allowsVehicleClass(veh.getVehicleType().getVehicleClass())) {
685 61 : return nullptr;
686 : }
687 100838480 : return (*myLanes)[departLane];
688 188879896 : case DepartLaneDefinition::RANDOM:
689 377759792 : return RandHelper::getRandomFrom(*allowedLanes(veh.getVehicleType().getVehicleClass()));
690 524761258 : case DepartLaneDefinition::FREE:
691 524761258 : return getFreeLane(nullptr, veh.getVehicleType().getVehicleClass(), getDepartPosBound(veh, false));
692 8219753 : case DepartLaneDefinition::ALLOWED_FREE:
693 8219753 : if (veh.getRoute().size() == 1) {
694 5960 : return getFreeLane(nullptr, veh.getVehicleType().getVehicleClass(), getDepartPosBound(veh, false));
695 : } else {
696 8213793 : return getFreeLane(allowedLanes(**(veh.getRoute().begin() + 1), veh.getVehicleType().getVehicleClass()), veh.getVehicleType().getVehicleClass(), getDepartPosBound(veh, false));
697 : }
698 34568357 : case DepartLaneDefinition::BEST_FREE:
699 : case DepartLaneDefinition::BEST_PROB: {
700 34568357 : veh.updateBestLanes(false, myLanes->front());
701 34568357 : const std::vector<MSVehicle::LaneQ>& bl = veh.getBestLanes();
702 : double bestLength = -1;
703 109011361 : for (std::vector<MSVehicle::LaneQ>::const_iterator i = bl.begin(); i != bl.end(); ++i) {
704 74443004 : if ((*i).length > bestLength) {
705 : bestLength = (*i).length;
706 : }
707 : }
708 : // beyond a certain length, all lanes are suitable
709 : // however, we still need to check departPos to avoid unsuitable insertion
710 : // (this is only possible in some cases)
711 : double departPos = 0;
712 34568357 : if (bestLength > BEST_LANE_LOOKAHEAD) {
713 365778 : departPos = getDepartPosBound(veh);
714 365778 : bestLength = MIN2(bestLength - departPos, BEST_LANE_LOOKAHEAD);
715 : }
716 34568357 : std::vector<MSLane*>* bestLanes = new std::vector<MSLane*>();
717 109011361 : for (std::vector<MSVehicle::LaneQ>::const_iterator i = bl.begin(); i != bl.end(); ++i) {
718 74443004 : if (((*i).length - departPos) >= bestLength) {
719 42187322 : if (isInternal()) {
720 32 : for (MSLane* lane : *myLanes) {
721 20 : if (lane->getNormalSuccessorLane() == (*i).lane) {
722 12 : bestLanes->push_back(lane);
723 : }
724 : }
725 : } else {
726 42187310 : bestLanes->push_back((*i).lane);
727 : }
728 : }
729 : }
730 : MSLane* ret = nullptr;
731 34568357 : if (veh.getParameter().departLaneProcedure == DepartLaneDefinition::BEST_FREE) {
732 31303537 : ret = getFreeLane(bestLanes, veh.getVehicleType().getVehicleClass(), getDepartPosBound(veh, false));
733 : } else {
734 3264820 : ret = getProbableLane(bestLanes, veh.getVehicleType().getVehicleClass(), getDepartPosBound(veh, false), getVehicleMaxSpeed(&veh));
735 : }
736 34568357 : delete bestLanes;
737 34568357 : return ret;
738 : }
739 6059796442 : case DepartLaneDefinition::DEFAULT:
740 : case DepartLaneDefinition::FIRST_ALLOWED:
741 6059796442 : return getFirstAllowed(veh.getVehicleType().getVehicleClass());
742 : default:
743 : break;
744 : }
745 0 : if (!(*myLanes)[0]->allowsVehicleClass(veh.getVehicleType().getVehicleClass())) {
746 : return nullptr;
747 : }
748 0 : return (*myLanes)[0];
749 : }
750 :
751 :
752 : MSLane*
753 6060553928 : MSEdge::getFirstAllowed(SUMOVehicleClass vClass, bool defaultFirst, int routingMode) const {
754 11591178928 : for (std::vector<MSLane*>::const_iterator i = myLanes->begin(); i != myLanes->end(); ++i) {
755 11591173928 : if ((*i)->allowsVehicleClass(vClass, routingMode)) {
756 6060548928 : return *i;
757 : }
758 : }
759 5000 : return defaultFirst && !myLanes->empty() ? myLanes->front() : nullptr;
760 : }
761 :
762 :
763 : bool
764 7560887132 : MSEdge::validateDepartSpeed(SUMOVehicle& v) const {
765 7560887132 : const SUMOVehicleParameter& pars = v.getParameter();
766 7560887132 : const MSVehicleType& type = v.getVehicleType();
767 7560887132 : if (pars.departSpeedProcedure == DepartSpeedDefinition::GIVEN) {
768 : // departSpeed could have been rounded down in the output
769 306266382 : double vMax = getVehicleMaxSpeed(&v) + SPEED_EPS;
770 306266382 : if (pars.departSpeed > vMax) {
771 : // check departLane (getVehicleMaxSpeed checks lane 0)
772 22595 : MSLane* departLane = MSGlobals::gMesoNet ? getDepartLaneMeso(v) : getDepartLane(dynamic_cast<MSVehicle&>(v));
773 22595 : if (departLane != nullptr) {
774 22595 : vMax = departLane->getVehicleMaxSpeed(&v);
775 22595 : if (pars.wasSet(VEHPARS_SPEEDFACTOR_SET)) {
776 : // speedFactor could have been rounded down in the output
777 7 : vMax *= (1 + SPEED_EPS);
778 : }
779 : // additive term must come after multiplication!
780 22595 : vMax += SPEED_EPS;
781 22595 : if (pars.departSpeed > vMax) {
782 22581 : if (type.getSpeedFactor().getParameter(1) > 0.) {
783 45124 : v.setChosenSpeedFactor(type.computeChosenSpeedDeviation(nullptr, pars.departSpeed / MIN2(getSpeedLimit(), type.getDesiredMaxSpeed() - SPEED_EPS)));
784 22562 : if (v.getChosenSpeedFactor() > type.getSpeedFactor().getParameter(0) + 2 * type.getSpeedFactor().getParameter(1)) {
785 : // only warn for significant deviation
786 37152 : WRITE_WARNINGF(TL("Choosing new speed factor % for vehicle '%' to match departure speed % (max %)."),
787 : toString(v.getChosenSpeedFactor()), pars.id, pars.departSpeed, vMax);
788 : }
789 : } else {
790 : return false;
791 : }
792 : }
793 : }
794 : }
795 : }
796 : return true;
797 : }
798 :
799 :
800 : bool
801 7561460356 : MSEdge::insertVehicle(SUMOVehicle& v, SUMOTime time, const bool checkOnly, const bool forceCheck) const {
802 : // when vaporizing, no vehicles are inserted, but checking needs to be successful to trigger removal
803 7561441570 : if (isVaporizing() || isTazConnector()
804 15122324795 : || v.getRouteValidity(true, checkOnly) != MSBaseVehicle::ROUTE_VALID) {
805 595984 : return checkOnly;
806 : }
807 7560864190 : const SUMOVehicleParameter& pars = v.getParameter();
808 7560864190 : if (!validateDepartSpeed(v)) {
809 14 : if (MSGlobals::gCheckRoutes) {
810 21 : throw ProcessError(TLF("Departure speed for vehicle '%' is too high for the departure edge '%', time=%.",
811 21 : pars.id, getID(), time2string(time)));
812 : } else {
813 21 : WRITE_WARNINGF(TL("Departure speed for vehicle '%' is too high for the departure edge '%', time=%."),
814 : pars.id, getID(), time2string(time));
815 : }
816 : }
817 7560864183 : if (MSGlobals::gUseMesoSim) {
818 503965988 : if (!forceCheck && myLastFailedInsertionTime == time) {
819 : return false;
820 : }
821 : double pos = 0.0;
822 28076030 : switch (pars.departPosProcedure) {
823 590055 : case DepartPosDefinition::GIVEN:
824 590055 : if (pars.departPos >= 0.) {
825 : pos = pars.departPos;
826 : } else {
827 8385 : pos = pars.departPos + getLength();
828 : }
829 590055 : if (pos < 0 || pos > getLength()) {
830 6 : WRITE_WARNINGF(TL("Invalid departPos % given for vehicle '%', time=%. Inserting at lane end instead."),
831 : pos, v.getID(), time2string(time));
832 : pos = getLength();
833 : }
834 : break;
835 : case DepartPosDefinition::RANDOM:
836 : case DepartPosDefinition::RANDOM_FREE:
837 : pos = RandHelper::rand(getLength());
838 50392 : break;
839 : default:
840 : break;
841 : }
842 : bool result = false;
843 28076030 : MESegment* segment = MSGlobals::gMesoNet->getSegmentForEdge(*this, pos);
844 : MEVehicle* veh = static_cast<MEVehicle*>(&v);
845 : int qIdx;
846 28076030 : if (pars.departPosProcedure == DepartPosDefinition::FREE) {
847 486418 : while (segment != nullptr && !result) {
848 447912 : if (checkOnly) {
849 6 : result = segment->hasSpaceFor(veh, time, qIdx, true) == time;
850 : } else {
851 447906 : result = segment->initialise(veh, time);
852 : }
853 : segment = segment->getNextSegment();
854 : }
855 : } else {
856 28037524 : if (checkOnly) {
857 26475813 : result = segment->hasSpaceFor(veh, time, qIdx, true) == time;
858 : } else {
859 1561711 : result = segment->initialise(veh, time);
860 : }
861 : }
862 28076027 : return result;
863 : }
864 7056898195 : if (checkOnly) {
865 2332323360 : switch (v.getParameter().departLaneProcedure) {
866 2142035955 : case DepartLaneDefinition::GIVEN:
867 : case DepartLaneDefinition::DEFAULT:
868 : case DepartLaneDefinition::FIRST_ALLOWED: {
869 2142035955 : MSLane* insertionLane = getDepartLane(static_cast<MSVehicle&>(v));
870 2142035955 : if (insertionLane == nullptr) {
871 0 : WRITE_WARNINGF(TL("Could not insert vehicle '%' on any lane of edge '%', time=%."),
872 : v.getID(), getID(), time2string(time));
873 0 : return false;
874 : }
875 2142035955 : const double occupancy = insertionLane->getBruttoOccupancy();
876 2142035955 : return (occupancy == 0 || occupancy * myLength + v.getVehicleType().getLengthWithGap() <= myLength ||
877 27575129 : v.getParameter().departProcedure == DepartDefinition::SPLIT);
878 : }
879 190287405 : default:
880 207894667 : for (std::vector<MSLane*>::const_iterator i = myLanes->begin(); i != myLanes->end(); ++i) {
881 199673152 : const double occupancy = (*i)->getBruttoOccupancy();
882 199673152 : if (occupancy == 0 || occupancy * myLength + v.getVehicleType().getLengthWithGap() <= myLength ||
883 17607262 : v.getParameter().departProcedure == DepartDefinition::SPLIT) {
884 : return true;
885 : }
886 : }
887 : }
888 : return false;
889 : }
890 4724574835 : MSLane* insertionLane = getDepartLane(static_cast<MSVehicle&>(v));
891 4724574835 : if (insertionLane == nullptr) {
892 : return false;
893 : }
894 :
895 4724569835 : if (!forceCheck) {
896 4724569658 : if (myLastFailedInsertionTime == time) {
897 : if (myFailedInsertionMemory.count(insertionLane->getIndex())) {
898 : // A vehicle was already rejected for the proposed insertionLane in this timestep
899 : return false;
900 : }
901 : } else {
902 : // last rejection occurred in a previous timestep, clear cache
903 : myFailedInsertionMemory.clear();
904 : }
905 : }
906 :
907 14680654 : bool success = insertionLane->insertVehicle(static_cast<MSVehicle&>(v));
908 :
909 14680651 : if (!success) {
910 : // constraints may enforce explicit re-ordering so we need to try other vehicles after failure
911 21911752 : if (!insertionLane->hasParameter("insertionOrder" + v.getID())) {
912 10955729 : myFailedInsertionMemory.insert(insertionLane->getIndex());
913 : }
914 : }
915 : return success;
916 : }
917 :
918 :
919 : void
920 45989854 : MSEdge::changeLanes(SUMOTime t) const {
921 45989854 : if (myLaneChanger != nullptr) {
922 45989854 : myLaneChanger->laneChange(t);
923 : }
924 45989854 : }
925 :
926 :
927 : const MSEdge*
928 2432366 : MSEdge::getInternalFollowingEdge(const MSEdge* followerAfterInternal, SUMOVehicleClass vClass) const {
929 : //@todo to be optimized
930 2946919 : for (const MSLane* const l : *myLanes) {
931 3538698 : for (const MSLink* const link : l->getLinkCont()) {
932 3024145 : if (&link->getLane()->getEdge() == followerAfterInternal) {
933 2134873 : if (link->getViaLane() != nullptr) {
934 1108902 : if (link->getViaLane()->allowsVehicleClass(vClass)) {
935 1106469 : return &link->getViaLane()->getEdge();
936 : } else {
937 2433 : continue;
938 : }
939 : } else {
940 : return nullptr; // network without internal links
941 : }
942 : }
943 : }
944 : }
945 : return nullptr;
946 : }
947 :
948 :
949 : double
950 1239008 : MSEdge::getInternalFollowingLengthTo(const MSEdge* followerAfterInternal, SUMOVehicleClass vClass) const {
951 : assert(followerAfterInternal != 0);
952 : assert(!followerAfterInternal->isInternal());
953 : double dist = 0.;
954 1239008 : const MSEdge* edge = getInternalFollowingEdge(followerAfterInternal, vClass);
955 : // Take into account non-internal lengths until next non-internal edge
956 2284565 : while (edge != nullptr && edge->isInternal()) {
957 1045557 : dist += edge->getLength();
958 1045557 : edge = edge->getInternalFollowingEdge(followerAfterInternal, vClass);
959 : }
960 1239008 : return dist;
961 : }
962 :
963 :
964 : const MSEdge*
965 146553 : MSEdge::getNormalBefore() const {
966 : const MSEdge* result = this;
967 154992 : while (result->isInternal() && MSGlobals::gUsingInternalLanes) {
968 : assert(result->getPredecessors().size() == 1);
969 8439 : result = result->getPredecessors().front();
970 : }
971 146553 : return result;
972 : }
973 :
974 : const MSEdge*
975 6507229 : MSEdge::getNormalSuccessor() const {
976 : const MSEdge* result = this;
977 12359915 : while (result->isInternal()) {
978 : assert(result->getSuccessors().size() == 1);
979 5852686 : result = result->getSuccessors().front();
980 : }
981 6507229 : return result;
982 : }
983 :
984 : double
985 149366764 : MSEdge::getMeanSpeed() const {
986 : double v = 0;
987 : double totalNumVehs = 0;
988 149366764 : if (MSGlobals::gUseMesoSim) {
989 164181003 : for (MESegment* segment = MSGlobals::gMesoNet->getSegmentForEdge(*this); segment != nullptr; segment = segment->getNextSegment()) {
990 : const int numVehs = segment->getCarNumber();
991 139056059 : if (numVehs > 0) {
992 24002262 : v += numVehs * segment->getMeanSpeed();
993 24002262 : totalNumVehs += numVehs;
994 : }
995 : }
996 25124944 : if (totalNumVehs == 0) {
997 17079304 : return getLength() / myEmptyTraveltime; // may include tls-penalty
998 : }
999 : } else {
1000 286720112 : for (const MSLane* const lane : *myLanes) {
1001 : int numVehs = lane->getVehicleNumber();
1002 162478292 : if (numVehs == 0) {
1003 : // take speed limit but with lowest possible weight
1004 : numVehs = 1;
1005 : }
1006 162478292 : v += numVehs * lane->getMeanSpeed();
1007 162478292 : totalNumVehs += numVehs;
1008 : }
1009 124241820 : if (myBidiEdge != nullptr) {
1010 8334090 : for (const MSLane* const lane : myBidiEdge->getLanes()) {
1011 4318354 : if (lane->getVehicleNumber() > 0) {
1012 : // do not route across edges which are already occupied in reverse direction
1013 : return 0;
1014 : }
1015 : }
1016 : }
1017 123939346 : if (totalNumVehs == 0) {
1018 0 : return getSpeedLimit();
1019 : }
1020 : }
1021 131984986 : return v / totalNumVehs;
1022 : }
1023 :
1024 :
1025 : double
1026 8 : MSEdge::getMeanFriction() const {
1027 : double f = 0.;
1028 32 : for (const MSLane* const lane : *myLanes) {
1029 24 : f += lane->getFrictionCoefficient();
1030 : }
1031 8 : if (!myLanes->empty()) {
1032 8 : return f / (double)myLanes->size();
1033 : }
1034 : return 1.;
1035 : }
1036 :
1037 :
1038 : double
1039 1272 : MSEdge::getMeanSpeedBike() const {
1040 1272 : if (MSGlobals::gUseMesoSim) {
1041 : // no separate bicycle speeds in meso
1042 362 : return getMeanSpeed();
1043 : }
1044 : double v = 0;
1045 : double totalNumVehs = 0;
1046 3005 : for (const MSLane* const lane : *myLanes) {
1047 : const int numVehs = lane->getVehicleNumber();
1048 2095 : v += numVehs * lane->getMeanSpeedBike();
1049 2095 : totalNumVehs += numVehs;
1050 : }
1051 910 : if (totalNumVehs == 0) {
1052 455 : return getSpeedLimit();
1053 : }
1054 455 : return v / totalNumVehs;
1055 : }
1056 :
1057 :
1058 : double
1059 55262 : MSEdge::getCurrentTravelTime(double minSpeed) const {
1060 : assert(minSpeed > 0);
1061 55262 : if (!myAmDelayed) {
1062 36852 : return myEmptyTraveltime;
1063 : }
1064 36820 : return getLength() / MAX2(minSpeed, getMeanSpeed());
1065 : }
1066 :
1067 :
1068 : double
1069 0 : MSEdge::getRoutingSpeed() const {
1070 0 : return MSRoutingEngine::getAssumedSpeed(this, nullptr);
1071 : }
1072 :
1073 :
1074 : bool
1075 1782142 : MSEdge::dictionary(const std::string& id, MSEdge* ptr) {
1076 : const DictType::iterator it = myDict.lower_bound(id);
1077 1782142 : if (it == myDict.end() || it->first != id) {
1078 : // id not in myDict
1079 1782142 : myDict.emplace_hint(it, id, ptr);
1080 3564318 : while (ptr->getNumericalID() >= (int)myEdges.size()) {
1081 1782176 : myEdges.push_back(nullptr);
1082 : }
1083 1782142 : myEdges[ptr->getNumericalID()] = ptr;
1084 1782142 : return true;
1085 : }
1086 : return false;
1087 : }
1088 :
1089 :
1090 : MSEdge*
1091 8195501 : MSEdge::dictionary(const std::string& id) {
1092 : const DictType::iterator it = myDict.find(id);
1093 8195501 : if (it == myDict.end()) {
1094 : return nullptr;
1095 : }
1096 6411327 : return it->second;
1097 : }
1098 :
1099 :
1100 : MSEdge*
1101 2655597 : MSEdge::dictionaryHint(const std::string& id, const int startIdx) {
1102 : // this method is mainly useful when parsing connections from the net.xml which are sorted by "from" id
1103 2655597 : if (myEdges[startIdx] != nullptr && myEdges[startIdx]->getID() == id) {
1104 : return myEdges[startIdx];
1105 : }
1106 1604501 : if (startIdx + 1 < (int)myEdges.size() && myEdges[startIdx + 1] != nullptr && myEdges[startIdx + 1]->getID() == id) {
1107 : return myEdges[startIdx + 1];
1108 : }
1109 517067 : return dictionary(id);
1110 : }
1111 :
1112 :
1113 : const MSEdgeVector&
1114 881381 : MSEdge::getAllEdges() {
1115 881381 : return myEdges;
1116 : }
1117 :
1118 :
1119 : void
1120 41359 : MSEdge::clear() {
1121 1808098 : for (DictType::iterator i = myDict.begin(); i != myDict.end(); ++i) {
1122 1766739 : delete (*i).second;
1123 : }
1124 : myDict.clear();
1125 : myEdges.clear();
1126 41359 : }
1127 :
1128 :
1129 : void
1130 285 : MSEdge::insertIDs(std::vector<std::string>& into) {
1131 16016 : for (DictType::iterator i = myDict.begin(); i != myDict.end(); ++i) {
1132 15731 : into.push_back((*i).first);
1133 : }
1134 285 : }
1135 :
1136 :
1137 : void
1138 411052 : MSEdge::parseEdgesList(const std::string& desc, ConstMSEdgeVector& into,
1139 : const std::string& rid) {
1140 411052 : StringTokenizer st(desc);
1141 411052 : parseEdgesList(st.getVector(), into, rid);
1142 411052 : }
1143 :
1144 :
1145 : void
1146 411331 : MSEdge::parseEdgesList(const std::vector<std::string>& desc, ConstMSEdgeVector& into,
1147 : const std::string& rid) {
1148 1560249 : for (std::vector<std::string>::const_iterator i = desc.begin(); i != desc.end(); ++i) {
1149 1148969 : const MSEdge* edge = MSEdge::dictionary(*i);
1150 : // check whether the edge exists
1151 1148969 : if (edge == nullptr) {
1152 51 : throw ProcessError("The edge '" + *i + "' within the route " + rid + " is not known."
1153 153 : + "\n The route can not be build.");
1154 : }
1155 1148918 : into.push_back(edge);
1156 : }
1157 411280 : }
1158 :
1159 :
1160 : double
1161 2147349 : MSEdge::getDistanceTo(const MSEdge* other, const bool doBoundaryEstimate) const {
1162 : assert(this != other);
1163 2147349 : if (doBoundaryEstimate) {
1164 19288 : return myBoundary.distanceTo2D(other->myBoundary);
1165 : }
1166 2128061 : if (isTazConnector()) {
1167 562 : if (other->isTazConnector()) {
1168 446 : return myBoundary.distanceTo2D(other->myBoundary);
1169 : }
1170 116 : return myBoundary.distanceTo2D(other->getLanes()[0]->getShape()[0]);
1171 : }
1172 2127499 : if (other->isTazConnector()) {
1173 5279 : return other->myBoundary.distanceTo2D(getLanes()[0]->getShape()[-1]);
1174 : }
1175 2122220 : return getLanes()[0]->getShape()[-1].distanceTo2D(other->getLanes()[0]->getShape()[0]);
1176 : }
1177 :
1178 :
1179 : const Position
1180 2429 : MSEdge::getStopPosition(const SUMOVehicleParameter::Stop& stop) {
1181 2429 : return MSLane::dictionary(stop.lane)->geometryPositionAtOffset((stop.endPos + stop.startPos) / 2.);
1182 : }
1183 :
1184 :
1185 : double
1186 89577765 : MSEdge::getSpeedLimit() const {
1187 : // @note lanes might have different maximum speeds in theory
1188 89577765 : return myLanes->empty() ? 1 : getLanes()[0]->getSpeedLimit();
1189 : }
1190 :
1191 :
1192 : double
1193 1884085 : MSEdge::getLengthGeometryFactor() const {
1194 1884085 : return myLanes->empty() ? 1 : getLanes()[0]->getLengthGeometryFactor();
1195 : }
1196 :
1197 : double
1198 518739859 : MSEdge::getVehicleMaxSpeed(const SUMOTrafficObject* const veh) const {
1199 : // @note lanes might have different maximum speeds in theory
1200 518739859 : return myLanes->empty() ? 1 : getLanes()[0]->getVehicleMaxSpeed(veh);
1201 : }
1202 :
1203 :
1204 : void
1205 203 : MSEdge::setMaxSpeed(const double val, const bool modified, const double jamThreshold) {
1206 : assert(val >= 0);
1207 203 : if (myLanes != nullptr) {
1208 560 : for (MSLane* const lane : *myLanes) {
1209 357 : lane->setMaxSpeed(val, modified, jamThreshold);
1210 : }
1211 : }
1212 203 : }
1213 :
1214 :
1215 : void
1216 1329206 : MSEdge::addTransportable(MSTransportable* t) const {
1217 1329206 : if (t->isPerson()) {
1218 : myPersons.insert(t);
1219 : } else {
1220 : myContainers.insert(t);
1221 : }
1222 1329206 : }
1223 :
1224 : void
1225 5329297 : MSEdge::removeTransportable(MSTransportable* t) const {
1226 5329297 : std::set<MSTransportable*, ComparatorNumericalIdLess>& tc = t->isPerson() ? myPersons : myContainers;
1227 : auto it = tc.find(t);
1228 5329297 : if (it != tc.end()) {
1229 : tc.erase(it);
1230 : }
1231 5329297 : }
1232 :
1233 : std::vector<MSTransportable*>
1234 4701702 : MSEdge::getSortedPersons(SUMOTime timestep, bool includeRiding) const {
1235 4701702 : std::vector<MSTransportable*> result(myPersons.begin(), myPersons.end());
1236 4701702 : if (includeRiding) {
1237 2895585 : for (std::vector<MSLane*>::const_iterator i = myLanes->begin(); i != myLanes->end(); ++i) {
1238 2042401 : const MSLane::VehCont& vehs = (*i)->getVehiclesSecure();
1239 3266035 : for (MSLane::VehCont::const_iterator j = vehs.begin(); j != vehs.end(); ++j) {
1240 1223634 : const std::vector<MSTransportable*>& persons = (*j)->getPersons();
1241 1223634 : result.insert(result.end(), persons.begin(), persons.end());
1242 : }
1243 2042401 : (*i)->releaseVehicles();
1244 : }
1245 : }
1246 4701702 : sort(result.begin(), result.end(), transportable_by_position_sorter(timestep));
1247 4701702 : return result;
1248 0 : }
1249 :
1250 :
1251 : std::vector<MSTransportable*>
1252 41392368 : MSEdge::getSortedContainers(SUMOTime timestep, bool /* includeRiding */) const {
1253 41392368 : std::vector<MSTransportable*> result(myContainers.begin(), myContainers.end());
1254 41392368 : sort(result.begin(), result.end(), transportable_by_position_sorter(timestep));
1255 41392368 : return result;
1256 0 : }
1257 :
1258 :
1259 : int
1260 5265427 : MSEdge::transportable_by_position_sorter::operator()(const MSTransportable* const c1, const MSTransportable* const c2) const {
1261 5265427 : const double pos1 = c1->getCurrentStage()->getEdgePos(myTime);
1262 5265427 : const double pos2 = c2->getCurrentStage()->getEdgePos(myTime);
1263 5265427 : if (pos1 != pos2) {
1264 5107639 : return pos1 < pos2;
1265 : }
1266 157788 : return c1->getID() < c2->getID();
1267 : }
1268 :
1269 :
1270 : void
1271 124697 : MSEdge::addSuccessor(MSEdge* edge, const MSEdge* via) {
1272 124697 : mySuccessors.push_back(edge);
1273 124697 : myViaSuccessors.push_back(std::make_pair(edge, via));
1274 124697 : if (isTazConnector() && edge->getFromJunction() != nullptr) {
1275 62345 : myBoundary.add(edge->getFromJunction()->getPosition());
1276 : }
1277 :
1278 124697 : edge->myPredecessors.push_back(this);
1279 124697 : if (edge->isTazConnector() && getToJunction() != nullptr) {
1280 62352 : edge->myBoundary.add(getToJunction()->getPosition());
1281 : }
1282 124697 : }
1283 :
1284 :
1285 : const MSEdgeVector&
1286 9080023 : MSEdge::getSuccessors(SUMOVehicleClass vClass) const {
1287 9080023 : if (vClass == SVC_IGNORING || !MSNet::getInstance()->hasPermissions() || myFunction == SumoXMLEdgeFunc::CONNECTOR) {
1288 9063045 : return mySuccessors;
1289 : }
1290 : #ifdef HAVE_FOX
1291 16978 : ScopedLocker<> lock(mySuccessorMutex, MSGlobals::gNumThreads > 1);
1292 : #endif
1293 : std::map<SUMOVehicleClass, MSEdgeVector>::iterator i = myClassesSuccessorMap.find(vClass);
1294 16978 : if (i == myClassesSuccessorMap.end()) {
1295 : // instantiate vector
1296 1934 : myClassesSuccessorMap[vClass];
1297 : i = myClassesSuccessorMap.find(vClass);
1298 : // this vClass is requested for the first time. rebuild all successors
1299 9219 : for (MSEdgeVector::const_iterator it = mySuccessors.begin(); it != mySuccessors.end(); ++it) {
1300 7285 : if ((*it)->isTazConnector()) {
1301 239 : i->second.push_back(*it);
1302 : } else {
1303 7046 : const std::vector<MSLane*>* allowed = allowedLanes(**it, vClass);
1304 7046 : if (allowed != nullptr && allowed->size() > 0) {
1305 5828 : i->second.push_back(*it);
1306 : }
1307 : }
1308 : }
1309 : }
1310 : // can use cached value
1311 16978 : return i->second;
1312 : }
1313 :
1314 :
1315 : const MSConstEdgePairVector&
1316 163242338 : MSEdge::getViaSuccessors(SUMOVehicleClass vClass, bool ignoreTransientPermissions) const {
1317 163242338 : if (vClass == SVC_IGNORING || !MSNet::getInstance()->hasPermissions() || myFunction == SumoXMLEdgeFunc::CONNECTOR) {
1318 156859942 : return myViaSuccessors;
1319 : }
1320 : #ifdef HAVE_FOX
1321 6382396 : ScopedLocker<> lock(mySuccessorMutex, MSGlobals::gNumThreads > 1);
1322 : #endif
1323 6382396 : auto& viaMap = ignoreTransientPermissions && myHaveTransientPermissions ? myOrigClassesViaSuccessorMap : myClassesViaSuccessorMap;
1324 : auto i = viaMap.find(vClass);
1325 6382396 : if (i != viaMap.end()) {
1326 : // can use cached value
1327 6330952 : return i->second;
1328 : }
1329 : // instantiate vector
1330 51444 : MSConstEdgePairVector& result = viaMap[vClass];
1331 : // this vClass is requested for the first time. rebuild all successors
1332 208099 : for (const auto& viaPair : myViaSuccessors) {
1333 156655 : if (viaPair.first->isTazConnector()) {
1334 6322 : result.push_back(viaPair);
1335 : } else {
1336 150333 : const std::vector<MSLane*>* allowed = allowedLanes(*viaPair.first, vClass, ignoreTransientPermissions);
1337 150333 : if (allowed != nullptr && allowed->size() > 0) {
1338 119918 : result.push_back(viaPair);
1339 : }
1340 : }
1341 : }
1342 : return result;
1343 : }
1344 :
1345 :
1346 : void
1347 1720459 : MSEdge::setJunctions(MSJunction* from, MSJunction* to) {
1348 1720459 : myFromJunction = from;
1349 1720459 : myToJunction = to;
1350 1720459 : if (!isTazConnector()) {
1351 1720459 : myBoundary.add(from->getPosition());
1352 1720459 : myBoundary.add(to->getPosition());
1353 : }
1354 1720459 : }
1355 :
1356 :
1357 : bool
1358 2847415 : MSEdge::canChangeToOpposite() const {
1359 2847415 : return (!myLanes->empty() && myLanes->back()->getOpposite() != nullptr &&
1360 : // do not change on curved internal lanes
1361 : (!isInternal()
1362 5663 : || (MSGlobals::gUsingInternalLanes
1363 5449 : && myLanes->back()->getIncomingLanes()[0].viaLink->getDirection() == LinkDirection::STRAIGHT)));
1364 : }
1365 :
1366 :
1367 : const MSEdge*
1368 22101000 : MSEdge::getOppositeEdge() const {
1369 22101000 : if (!myLanes->empty() && myLanes->back()->getOpposite() != nullptr) {
1370 2991869 : return &(myLanes->back()->getOpposite()->getEdge());
1371 : } else {
1372 19109131 : return nullptr;
1373 : }
1374 : }
1375 :
1376 :
1377 : bool
1378 178 : MSEdge::hasMinorLink() const {
1379 370 : for (const MSLane* const l : *myLanes) {
1380 290 : for (const MSLink* const link : l->getLinkCont()) {
1381 98 : if (!link->havePriority()) {
1382 : return true;
1383 : }
1384 : }
1385 : }
1386 : return false;
1387 : }
1388 :
1389 : bool
1390 209548 : MSEdge::hasChangeProhibitions(SUMOVehicleClass svc, int index) const {
1391 209548 : if (myLanes->size() == 1) {
1392 : return false;
1393 : }
1394 285397 : for (const MSLane* const l : *myLanes) {
1395 193803 : if (l->getIndex() <= index && !l->allowsChangingRight(svc) && l->getIndex() > 0) {
1396 : return true;
1397 193759 : } else if (l->getIndex() >= index && !l->allowsChangingLeft(svc) && l->getIndex() < (int)(myLanes->size() - 1)) {
1398 : return true;
1399 : }
1400 : }
1401 : return false;
1402 : }
1403 :
1404 : void
1405 905659 : MSEdge::checkAndRegisterBiDirEdge(const std::string& bidiID) {
1406 905659 : if (bidiID != "") {
1407 29008 : myBidiEdge = dictionary(bidiID);
1408 29008 : if (myBidiEdge == nullptr) {
1409 0 : WRITE_ERRORF(TL("Bidi-edge '%' does not exist"), bidiID);
1410 : }
1411 29008 : setBidiLanes();
1412 519344 : return;
1413 : }
1414 876651 : if (getFunction() != SumoXMLEdgeFunc::NORMAL) {
1415 : return;
1416 : }
1417 : // legacy networks (no bidi attribute)
1418 386315 : ConstMSEdgeVector candidates = myToJunction->getOutgoing();
1419 3069922 : for (ConstMSEdgeVector::const_iterator it = candidates.begin(); it != candidates.end(); it++) {
1420 2683607 : if ((*it)->getToJunction() == myFromJunction) { //reverse edge
1421 308314 : if (myBidiEdge != nullptr && isSuperposable(*it)) {
1422 0 : WRITE_WARNINGF(TL("Ambiguous superposable edges between junction '%' and '%'."), myToJunction->getID(), myFromJunction->getID());
1423 0 : break;
1424 : }
1425 308314 : if (isSuperposable(*it)) {
1426 26 : myBidiEdge = *it;
1427 26 : setBidiLanes();
1428 : }
1429 : }
1430 : }
1431 386315 : }
1432 :
1433 :
1434 : void
1435 29034 : MSEdge::setBidiLanes() {
1436 : assert(myBidiEdge != nullptr);
1437 29034 : if (getNumLanes() == 1 && myBidiEdge->getNumLanes() == 1) {
1438 : // the other way round is set when this method runs for the bidiEdge
1439 28496 : getLanes()[0]->setBidiLane(myBidiEdge->getLanes()[0]);
1440 : } else {
1441 : // find lanes with matching reversed shapes
1442 : int numBidiLanes = 0;
1443 1680 : for (MSLane* l1 : *myLanes) {
1444 3630 : for (MSLane* l2 : *myBidiEdge->myLanes) {
1445 2488 : if (l1->getShape().reverse().almostSame(l2->getShape(), POSITION_EPS * 2)) {
1446 592 : l1->setBidiLane(l2);
1447 592 : numBidiLanes++;
1448 : }
1449 : }
1450 : }
1451 : // warn only once for each pair
1452 538 : if (numBidiLanes == 0 && getNumericalID() < myBidiEdge->getNumericalID()) {
1453 15 : WRITE_WARNINGF(TL("Edge '%' and bidi edge '%' have no matching bidi lanes"), getID(), myBidiEdge->getID());
1454 : }
1455 : }
1456 29034 : }
1457 :
1458 :
1459 : bool
1460 308314 : MSEdge::isSuperposable(const MSEdge* other) {
1461 308314 : if (other == nullptr || other->getLanes().size() != myLanes->size()) {
1462 : return false;
1463 : }
1464 : std::vector<MSLane*>::const_iterator it1 = myLanes->begin();
1465 : std::vector<MSLane*>::const_reverse_iterator it2 = other->getLanes().rbegin();
1466 : do {
1467 303748 : if ((*it1)->getShape().reverse() != (*it2)->getShape()) {
1468 : return false;
1469 : }
1470 : it1++;
1471 : it2++;
1472 26 : } while (it1 != myLanes->end());
1473 :
1474 : return true;
1475 : }
1476 :
1477 :
1478 : void
1479 71864 : MSEdge::addWaiting(SUMOVehicle* vehicle) const {
1480 : #ifdef HAVE_FOX
1481 71864 : ScopedLocker<> lock(myWaitingMutex, MSGlobals::gNumSimThreads > 1);
1482 : #endif
1483 71864 : myWaiting.push_back(vehicle);
1484 71864 : }
1485 :
1486 :
1487 : void
1488 63330 : MSEdge::removeWaiting(const SUMOVehicle* vehicle) const {
1489 : #ifdef HAVE_FOX
1490 63330 : ScopedLocker<> lock(myWaitingMutex, MSGlobals::gNumSimThreads > 1);
1491 : #endif
1492 63330 : std::vector<SUMOVehicle*>::iterator it = std::find(myWaiting.begin(), myWaiting.end(), vehicle);
1493 63330 : if (it != myWaiting.end()) {
1494 63004 : myWaiting.erase(it);
1495 : }
1496 63330 : }
1497 :
1498 :
1499 : SUMOVehicle*
1500 77051 : MSEdge::getWaitingVehicle(MSTransportable* transportable, const double position) const {
1501 : #ifdef HAVE_FOX
1502 77051 : ScopedLocker<> lock(myWaitingMutex, MSGlobals::gNumSimThreads > 1);
1503 : #endif
1504 77356 : for (SUMOVehicle* const vehicle : myWaiting) {
1505 5134 : if (transportable->isWaitingFor(vehicle)) {
1506 7314 : if (vehicle->isStoppedInRange(position, MSGlobals::gStopTolerance) ||
1507 2275 : (!vehicle->hasDeparted() &&
1508 2069 : (vehicle->getParameter().departProcedure == DepartDefinition::TRIGGERED ||
1509 83 : vehicle->getParameter().departProcedure == DepartDefinition::CONTAINER_TRIGGERED))) {
1510 : return vehicle;
1511 : }
1512 210 : if (!vehicle->isLineStop(position) && vehicle->allowsBoarding(transportable)) {
1513 228 : WRITE_WARNING((transportable->isPerson() ? "Person '" : "Container '")
1514 : + transportable->getID() + "' at edge '" + getID() + "' position " + toString(position) + " cannot use waiting vehicle '"
1515 : + vehicle->getID() + "' at position " + toString(vehicle->getPositionOnLane()) + " because it is too far away.");
1516 : }
1517 : }
1518 : }
1519 : return nullptr;
1520 : }
1521 :
1522 : std::vector<const SUMOVehicle*>
1523 144435 : MSEdge::getVehicles() const {
1524 : std::vector<const SUMOVehicle*> result;
1525 144435 : if (MSGlobals::gUseMesoSim) {
1526 220 : for (MESegment* segment = MSGlobals::gMesoNet->getSegmentForEdge(*this); segment != nullptr; segment = segment->getNextSegment()) {
1527 122 : std::vector<const MEVehicle*> segmentVehs = segment->getVehicles();
1528 122 : result.insert(result.end(), segmentVehs.begin(), segmentVehs.end());
1529 122 : }
1530 : } else {
1531 386613 : for (MSLane* lane : getLanes()) {
1532 830639 : for (auto veh : lane->getVehiclesSecure()) {
1533 588412 : result.push_back(veh);
1534 : }
1535 242227 : lane->releaseVehicles();
1536 : }
1537 : }
1538 144435 : return result;
1539 0 : }
1540 :
1541 : int
1542 621961 : MSEdge::getNumDrivingLanes() const {
1543 : int result = 0;
1544 621961 : SVCPermissions filter = SVCAll;
1545 621961 : if ((myCombinedPermissions & ~(SVC_PEDESTRIAN | SVC_WHEELCHAIR)) != 0) {
1546 : filter = ~(SVC_PEDESTRIAN | SVC_WHEELCHAIR);
1547 2050 : } else if ((myCombinedPermissions & (SVC_PEDESTRIAN | SVC_WHEELCHAIR)) != 0) {
1548 : // filter out green verge
1549 : filter = (SVC_PEDESTRIAN | SVC_WHEELCHAIR);
1550 : }
1551 1401273 : for (const MSLane* const l : *myLanes) {
1552 779312 : if ((l->getPermissions() & filter) != 0) {
1553 689920 : result++;
1554 : }
1555 : }
1556 621961 : return result;
1557 : }
1558 :
1559 : int
1560 399 : MSEdge::getVehicleNumber() const {
1561 399 : return (int)getVehicles().size();
1562 : }
1563 :
1564 :
1565 : bool
1566 0 : MSEdge::isEmpty() const {
1567 : /// more efficient than retrieving vehicle number
1568 0 : if (MSGlobals::gUseMesoSim) {
1569 0 : for (MESegment* segment = MSGlobals::gMesoNet->getSegmentForEdge(*this); segment != nullptr; segment = segment->getNextSegment()) {
1570 0 : if (segment->getCarNumber() > 0) {
1571 : return false;
1572 : }
1573 : }
1574 : } else {
1575 0 : for (MSLane* lane : getLanes()) {
1576 0 : if (lane->getVehicleNumber() > 0) {
1577 : return false;
1578 : }
1579 : }
1580 : }
1581 : return true;
1582 : }
1583 :
1584 :
1585 : double
1586 14 : MSEdge::getWaitingSeconds() const {
1587 : double wtime = 0;
1588 14 : if (MSGlobals::gUseMesoSim) {
1589 12 : for (MESegment* segment = MSGlobals::gMesoNet->getSegmentForEdge(*this); segment != nullptr; segment = segment->getNextSegment()) {
1590 9 : wtime += segment->getWaitingSeconds();
1591 : }
1592 : } else {
1593 34 : for (MSLane* lane : getLanes()) {
1594 23 : wtime += lane->getWaitingSeconds();
1595 : }
1596 : }
1597 14 : return wtime;
1598 : }
1599 :
1600 :
1601 : double
1602 22 : MSEdge::getOccupancy() const {
1603 22 : if (myLanes->size() == 0) {
1604 : return 0;
1605 : }
1606 22 : if (MSGlobals::gUseMesoSim) {
1607 : /// @note MESegment only tracks brutto occupancy so we compute this from sratch
1608 : double sum = 0;
1609 8 : for (const SUMOVehicle* veh : getVehicles()) {
1610 4 : sum += dynamic_cast<const MEVehicle*>(veh)->getVehicleType().getLength();
1611 4 : }
1612 4 : return sum / (myLength * (double)myLanes->size());
1613 : } else {
1614 : double sum = 0;
1615 48 : for (auto lane : getLanes()) {
1616 30 : sum += lane->getNettoOccupancy();
1617 : }
1618 18 : return sum / (double)myLanes->size();
1619 : }
1620 : }
1621 :
1622 :
1623 : double
1624 0 : MSEdge::getFlow() const {
1625 0 : if (myLanes->size() == 0) {
1626 : return 0;
1627 : }
1628 : double flow = 0;
1629 0 : for (MESegment* segment = MSGlobals::gMesoNet->getSegmentForEdge(*this); segment != nullptr; segment = segment->getNextSegment()) {
1630 0 : flow += (double) segment->getCarNumber() * segment->getMeanSpeed();
1631 : }
1632 0 : return 3600 * flow / (*myLanes)[0]->getLength();
1633 : }
1634 :
1635 :
1636 : double
1637 0 : MSEdge::getBruttoOccupancy() const {
1638 0 : if (myLanes->size() == 0) {
1639 : return 0;
1640 : }
1641 : double occ = 0;
1642 0 : for (MESegment* segment = MSGlobals::gMesoNet->getSegmentForEdge(*this); segment != nullptr; segment = segment->getNextSegment()) {
1643 0 : occ += segment->getBruttoOccupancy();
1644 : }
1645 0 : return occ / (*myLanes)[0]->getLength() / (double)(myLanes->size());
1646 : }
1647 :
1648 : double
1649 4240 : MSEdge::getTravelTimeAggregated(const MSEdge* const edge, const SUMOVehicle* const veh, double /*time*/) {
1650 4240 : return edge->getLength() / MIN2(MSRoutingEngine::getAssumedSpeed(edge, veh), veh->getMaxSpeed());
1651 : }
1652 :
1653 :
1654 : void
1655 2098 : MSEdge::inferEdgeType() {
1656 : // @note must be called after closeBuilding() to ensure successors and
1657 : // predecessors are set
1658 2098 : if (isInternal() && myEdgeType == "") {
1659 1274 : const std::string typeBefore = getNormalBefore()->getEdgeType();
1660 1274 : if (typeBefore != "") {
1661 622 : const std::string typeAfter = getNormalSuccessor()->getEdgeType();
1662 622 : if (typeBefore == typeAfter) {
1663 : myEdgeType = typeBefore;
1664 244 : } else if (typeAfter != "") {
1665 60 : MSNet* net = MSNet::getInstance();
1666 60 : auto resBefore = net->getRestrictions(typeBefore);
1667 60 : auto resAfter = net->getRestrictions(typeAfter);
1668 60 : if (resBefore != nullptr && resAfter != nullptr) {
1669 : // create new restrictions for this type-combination
1670 80 : myEdgeType = typeBefore + "|" + typeAfter;
1671 40 : if (net->getRestrictions(myEdgeType) == nullptr) {
1672 40 : for (const auto& item : *resBefore) {
1673 20 : const SUMOVehicleClass svc = item.first;
1674 20 : const double speed = item.second;
1675 : const auto it = (*resAfter).find(svc);
1676 20 : if (it != (*resAfter).end()) {
1677 20 : const double speed2 = it->second;
1678 20 : const double newSpeed = (MSNet::getInstance()->hasJunctionHigherSpeeds()
1679 20 : ? MAX2(speed, speed2) : (speed + speed2) / 2);
1680 20 : net->addRestriction(myEdgeType, svc, newSpeed);
1681 : }
1682 : }
1683 : }
1684 : }
1685 : }
1686 : }
1687 : }
1688 2098 : }
1689 :
1690 :
1691 : double
1692 2178 : MSEdge::getDistanceAt(double pos) const {
1693 : // negative values of myDistances indicate descending kilometrage
1694 2178 : return fabs(myDistance + pos);
1695 : }
1696 :
1697 :
1698 : bool
1699 1081 : MSEdge::hasTransientPermissions() const {
1700 1081 : return myHaveTransientPermissions;
1701 : }
1702 :
1703 :
1704 : std::pair<double, SUMOTime>
1705 595076294 : MSEdge::getLastBlocked(int index) const {
1706 595076294 : if (myLaneChanger != nullptr) {
1707 595076294 : return myLaneChanger->getLastBlocked(index);
1708 : }
1709 0 : return std::make_pair(-1, -1);
1710 : }
1711 :
1712 :
1713 : double
1714 1631 : MSEdge::getPreference(const SUMOVTypeParameter& pars) const {
1715 3262 : return MSNet::getInstance()->getPreference(getRoutingType(), pars);
1716 : }
1717 :
1718 : void
1719 7032 : MSEdge::clearState() {
1720 : myPersons.clear();
1721 : myContainers.clear();
1722 : myWaiting.clear();
1723 7032 : }
1724 :
1725 : /****************************************************************************/
|
