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 : /****************************************************************************/
|