Eclipse SUMO - Simulation of Urban MObility
RODFNet.cpp
Go to the documentation of this file.
1/****************************************************************************/
2// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3// Copyright (C) 2001-2023 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/****************************************************************************/
21// A DFROUTER-network
22/****************************************************************************/
23#include <config.h>
24
25#include <cassert>
26#include <iostream>
27#include <map>
28#include <queue>
29#include <vector>
30#include <iterator>
31#include "RODFNet.h"
32#include "RODFDetector.h"
33#include "RODFRouteDesc.h"
34#include "RODFDetectorFlow.h"
35#include "RODFEdge.h"
36#include <cmath>
41
42
43// ===========================================================================
44// method definitions
45// ===========================================================================
46RODFNet::RODFNet(bool amInHighwayMode) :
47 RONet(), myAmInHighwayMode(amInHighwayMode),
48 mySourceNumber(0), mySinkNumber(0), myInBetweenNumber(0), myInvalidNumber(0),
49 myMaxSpeedFactorPKW(1),
50 myMaxSpeedFactorLKW(1),
51 myAvgSpeedFactorPKW(1),
52 myAvgSpeedFactorLKW(1) {
56}
57
58
60}
61
62
63bool
64RODFNet::isAllowed(const ROEdge* const edge) const {
65 return (!edge->isInternal() && !edge->isWalkingArea() && !edge->isCrossing() &&
67 find(myDisallowedEdges.begin(), myDisallowedEdges.end(), edge->getID()) == myDisallowedEdges.end());
68
69}
70
71
72void
74 for (const auto& rit : getEdgeMap()) {
75 ROEdge* const ce = rit.second;
76 if (!isAllowed(ce)) {
77 continue;
78 }
79 for (ROEdge* const help : ce->getSuccessors()) {
80 if (!isAllowed(help)) {
81 // blocked edges will not be used
82 continue;
83 }
84 if (!myKeepTurnarounds && help->getToJunction() == ce->getFromJunction()) {
85 // do not use turnarounds
86 continue;
87 }
88 // add the connection help->ce to myApproachingEdges
89 myApproachingEdges[help].push_back(ce);
90 // add the connection ce->help to myApproachingEdges
91 myApproachedEdges[ce].push_back(help);
92 }
93 }
94}
95
96
97void
99 myDetectorsOnEdges.clear();
100 myDetectorEdges.clear();
101 const std::vector<RODFDetector*>& dets = detcont.getDetectors();
102 for (std::vector<RODFDetector*>::const_iterator i = dets.begin(); i != dets.end(); ++i) {
103 ROEdge* e = getDetectorEdge(**i);
104 myDetectorsOnEdges[e].push_back((*i)->getID());
105 myDetectorEdges[(*i)->getID()] = e;
106 }
107}
108
109
110void
112 bool sourcesStrict) const {
113 PROGRESS_BEGIN_MESSAGE(TL("Computing detector types"));
114 const std::vector< RODFDetector*>& dets = detcont.getDetectors();
115 // build needed information. first
117 // compute detector types then
118 for (std::vector< RODFDetector*>::const_iterator i = dets.begin(); i != dets.end(); ++i) {
119 if (isSource(**i, detcont, sourcesStrict)) {
120 (*i)->setType(SOURCE_DETECTOR);
122 }
123 if (isDestination(**i, detcont)) {
124 (*i)->setType(SINK_DETECTOR);
125 mySinkNumber++;
126 }
127 if ((*i)->getType() == TYPE_NOT_DEFINED) {
128 (*i)->setType(BETWEEN_DETECTOR);
130 }
131 }
132 // recheck sources
133 for (std::vector< RODFDetector*>::const_iterator i = dets.begin(); i != dets.end(); ++i) {
134 if ((*i)->getType() == SOURCE_DETECTOR && isFalseSource(**i, detcont)) {
135 (*i)->setType(DISCARDED_DETECTOR);
138 }
139 }
140 // print results
142 WRITE_MESSAGE(TL("Computed detector types:"));
143 WRITE_MESSAGEF(TL(" % source detectors"), toString(mySourceNumber));
144 WRITE_MESSAGEF(TL(" % sink detectors"), toString(mySinkNumber));
145 WRITE_MESSAGEF(TL(" % in-between detectors"), toString(myInBetweenNumber));
146 WRITE_MESSAGEF(TL(" % invalid detectors"), toString(myInvalidNumber));
147}
148
149
150bool
152 const RODFDetectorCon& detectors) const {
153 assert(myDetectorsOnEdges.find(edge) != myDetectorsOnEdges.end());
154 const std::vector<std::string>& detIDs = myDetectorsOnEdges.find(edge)->second;
155 std::vector<std::string>::const_iterator i;
156 for (i = detIDs.begin(); i != detIDs.end(); ++i) {
157 const RODFDetector& det = detectors.getDetector(*i);
158 if (det.getType() != BETWEEN_DETECTOR) {
159 return false;
160 }
161 }
162 return true;
163}
164
165
166bool
168 const RODFDetectorCon& detectors) const {
169 assert(myDetectorsOnEdges.find(edge) != myDetectorsOnEdges.end());
170 const std::vector<std::string>& detIDs = myDetectorsOnEdges.find(edge)->second;
171 std::vector<std::string>::const_iterator i;
172 for (i = detIDs.begin(); i != detIDs.end(); ++i) {
173 const RODFDetector& det = detectors.getDetector(*i);
174 if (det.getType() == SOURCE_DETECTOR) {
175 return true;
176 }
177 }
178 return false;
179}
180
181
182
183void
185 bool keepUnfoundEnds,
186 bool keepShortestOnly,
187 ROEdgeVector& /*visited*/,
188 const RODFDetector& det, RODFRouteCont& into,
189 const RODFDetectorCon& detectors,
190 int maxFollowingLength,
191 ROEdgeVector& seen) const {
192 std::vector<RODFRouteDesc> unfoundEnds;
193 std::priority_queue<RODFRouteDesc, std::vector<RODFRouteDesc>, DFRouteDescByTimeComperator> toSolve;
194 std::map<ROEdge*, ROEdgeVector > dets2Follow;
195 dets2Follow[edge] = ROEdgeVector();
196 base.passedNo = 0;
197 double minDist = OptionsCont::getOptions().getFloat("min-route-length");
198 toSolve.push(base);
199 while (!toSolve.empty()) {
200 RODFRouteDesc current = toSolve.top();
201 toSolve.pop();
202 ROEdge* last = *(current.edges2Pass.end() - 1);
203 if (hasDetector(last)) {
204 if (dets2Follow.find(last) == dets2Follow.end()) {
205 dets2Follow[last] = ROEdgeVector();
206 }
207 for (ROEdgeVector::reverse_iterator i = current.edges2Pass.rbegin() + 1; i != current.edges2Pass.rend(); ++i) {
208 if (hasDetector(*i)) {
209 dets2Follow[*i].push_back(last);
210 break;
211 }
212 }
213 }
214
215 // do not process an edge twice
216 if (find(seen.begin(), seen.end(), last) != seen.end() && keepShortestOnly) {
217 continue;
218 }
219 seen.push_back(last);
220 // end if the edge has no further connections
221 if (!hasApproached(last)) {
222 // ok, no further connections to follow
223 current.factor = 1.;
224 double cdist = current.edges2Pass[0]->getFromJunction()->getPosition().distanceTo(current.edges2Pass.back()->getToJunction()->getPosition());
225 if (minDist < cdist) {
226 into.addRouteDesc(current);
227 }
228 continue;
229 }
230 // check for passing detectors:
231 // if the current last edge is not the one the detector is placed on ...
232 bool addNextNoFurther = false;
233 if (last != getDetectorEdge(det)) {
234 // ... if there is a detector ...
235 if (hasDetector(last)) {
236 if (!hasInBetweenDetectorsOnly(last, detectors)) {
237 // ... and it's not an in-between-detector
238 // -> let's add this edge and the following, but not any further
239 addNextNoFurther = true;
240 current.lastDetectorEdge = last;
241 current.duration2Last = (SUMOTime) current.duration_2;
242 current.distance2Last = current.distance;
243 current.endDetectorEdge = last;
244 if (hasSourceDetector(last, detectors)) {
246 }
247 current.factor = 1.;
248 double cdist = current.edges2Pass[0]->getFromJunction()->getPosition().distanceTo(current.edges2Pass.back()->getToJunction()->getPosition());
249 if (minDist < cdist) {
250 into.addRouteDesc(current);
251 }
252 continue;
253 } else {
254 // ... if it's an in-between-detector
255 // -> mark the current route as to be continued
256 current.passedNo = 0;
257 current.duration2Last = (SUMOTime) current.duration_2;
258 current.distance2Last = current.distance;
259 current.lastDetectorEdge = last;
260 }
261 }
262 }
263 // check for highway off-ramps
264 if (myAmInHighwayMode) {
265 // if it's beside the highway...
266 if (last->getSpeedLimit() < 19.4 && last != getDetectorEdge(det)) {
267 // ... and has more than one following edge
268 if (myApproachedEdges.find(last)->second.size() > 1) {
269 // -> let's add this edge and the following, but not any further
270 addNextNoFurther = true;
271 }
272
273 }
274 }
275 // check for missing end connections
276 if (!addNextNoFurther) {
277 // ... if this one would be processed, but already too many edge
278 // without a detector occurred
279 if (current.passedNo > maxFollowingLength) {
280 // mark not to process any further
281 WRITE_WARNINGF(TL("Could not close route for '%'"), det.getID());
282 unfoundEnds.push_back(current);
283 current.factor = 1.;
284 double cdist = current.edges2Pass[0]->getFromJunction()->getPosition().distanceTo(current.edges2Pass.back()->getToJunction()->getPosition());
285 if (minDist < cdist) {
286 into.addRouteDesc(current);
287 }
288 continue;
289 }
290 }
291 // ... else: loop over the next edges
292 const ROEdgeVector& appr = myApproachedEdges.find(last)->second;
293 bool hadOne = false;
294 for (int i = 0; i < (int)appr.size(); i++) {
295 if (find(current.edges2Pass.begin(), current.edges2Pass.end(), appr[i]) != current.edges2Pass.end()) {
296 // do not append an edge twice (do not build loops)
297 continue;
298 }
299 RODFRouteDesc t(current);
300 t.duration_2 += (appr[i]->getLength() / appr[i]->getSpeedLimit());
301 t.distance += appr[i]->getLength();
302 t.edges2Pass.push_back(appr[i]);
303 if (!addNextNoFurther) {
304 t.passedNo++;
305 toSolve.push(t);
306 } else {
307 if (!hadOne) {
308 t.factor = (double) 1. / (double) appr.size();
309 double cdist = current.edges2Pass[0]->getFromJunction()->getPosition().distanceTo(current.edges2Pass.back()->getToJunction()->getPosition());
310 if (minDist < cdist) {
311 into.addRouteDesc(t);
312 }
313 hadOne = true;
314 }
315 }
316 }
317 }
318 //
319 if (!keepUnfoundEnds) {
320 std::vector<RODFRouteDesc>::iterator i;
321 ConstROEdgeVector lastDetEdges;
322 for (i = unfoundEnds.begin(); i != unfoundEnds.end(); ++i) {
323 if (find(lastDetEdges.begin(), lastDetEdges.end(), (*i).lastDetectorEdge) == lastDetEdges.end()) {
324 lastDetEdges.push_back((*i).lastDetectorEdge);
325 } else {
326 bool ok = into.removeRouteDesc(*i);
327 assert(ok);
328 UNUSED_PARAMETER(ok); // only used for assertion
329 }
330 }
331 } else {
332 // !!! patch the factors
333 }
334 while (!toSolve.empty()) {
335// RODFRouteDesc d = toSolve.top();
336 toSolve.pop();
337// delete d;
338 }
339}
340
341
342void
343RODFNet::buildRoutes(RODFDetectorCon& detcont, bool keepUnfoundEnds, bool includeInBetween,
344 bool keepShortestOnly, int maxFollowingLength) const {
345 // build needed information first
347 // then build the routes
348 std::map<ROEdge*, RODFRouteCont* > doneEdges;
349 const std::vector< RODFDetector*>& dets = detcont.getDetectors();
350 for (std::vector< RODFDetector*>::const_iterator i = dets.begin(); i != dets.end(); ++i) {
351 ROEdge* e = getDetectorEdge(**i);
352 if (doneEdges.find(e) != doneEdges.end()) {
353 // use previously build routes
354 (*i)->addRoutes(new RODFRouteCont(*doneEdges[e]));
355 continue;
356 }
357 ROEdgeVector seen;
358 RODFRouteCont* routes = new RODFRouteCont();
359 doneEdges[e] = routes;
360 RODFRouteDesc rd;
361 rd.edges2Pass.push_back(e);
362 rd.duration_2 = (e->getLength() / e->getSpeedLimit());
363 rd.endDetectorEdge = nullptr;
364 rd.lastDetectorEdge = nullptr;
365 rd.distance = e->getLength();
366 rd.distance2Last = 0;
367 rd.duration2Last = 0;
368
369 rd.overallProb = 0;
370
371 ROEdgeVector visited;
372 visited.push_back(e);
373 computeRoutesFor(e, rd, 0, keepUnfoundEnds, keepShortestOnly,
374 visited, **i, *routes, detcont, maxFollowingLength, seen);
376 (*i)->addRoutes(routes);
377
378 // add routes to in-between detectors if wished
379 if (includeInBetween) {
380 // go through the routes
381 const std::vector<RODFRouteDesc>& r = routes->get();
382 for (std::vector<RODFRouteDesc>::const_iterator j = r.begin(); j != r.end(); ++j) {
383 const RODFRouteDesc& mrd = *j;
384 double duration = mrd.duration_2;
385 double distance = mrd.distance;
386 // go through each route's edges
387 ROEdgeVector::const_iterator routeend = mrd.edges2Pass.end();
388 for (ROEdgeVector::const_iterator k = mrd.edges2Pass.begin(); k != routeend; ++k) {
389 // check whether any detectors lies on the current edge
390 if (myDetectorsOnEdges.find(*k) == myDetectorsOnEdges.end()) {
391 duration -= (*k)->getLength() / (*k)->getSpeedLimit();
392 distance -= (*k)->getLength();
393 continue;
394 }
395 // go through the detectors
396 for (const std::string& l : myDetectorsOnEdges.find(*k)->second) {
397 const RODFDetector& m = detcont.getDetector(l);
398 if (m.getType() == BETWEEN_DETECTOR) {
399 RODFRouteDesc nrd;
400 copy(k, routeend, back_inserter(nrd.edges2Pass));
401 nrd.duration_2 = duration;
404 nrd.distance = distance;
407 nrd.overallProb = mrd.overallProb;
408 nrd.factor = mrd.factor;
409 ((RODFDetector&) m).addRoute(nrd);
410 }
411 }
412 duration -= (*k)->getLength() / (*k)->getSpeedLimit();
413 distance -= (*k)->getLength();
414 }
415 }
416 }
417
418 }
419}
420
421
422void
424 RODFDetectorFlows& flows,
425 SUMOTime startTime, SUMOTime endTime,
426 SUMOTime stepOffset) {
427 {
428 if (flows.knows(detector->getID())) {
429 const std::vector<FlowDef>& detFlows = flows.getFlowDefs(detector->getID());
430 for (std::vector<FlowDef>::const_iterator j = detFlows.begin(); j != detFlows.end(); ++j) {
431 if ((*j).qPKW > 0 || (*j).qLKW > 0) {
432 return;
433 }
434 }
435 }
436 }
437 // ok, there is no information for the whole time;
438 // lets find preceding detectors and rebuild the flows if possible
439 WRITE_WARNINGF(TL("Detector '%' has no flows.\n Trying to rebuild."), detector->getID());
440 // go back and collect flows
441 ROEdgeVector previous;
442 {
443 std::vector<IterationEdge> missing;
444 IterationEdge ie;
445 ie.depth = 0;
446 ie.edge = getDetectorEdge(*detector);
447 missing.push_back(ie);
448 bool maxDepthReached = false;
449 while (!missing.empty() && !maxDepthReached) {
450 IterationEdge last = missing.back();
451 missing.pop_back();
452 ROEdgeVector approaching = myApproachingEdges[last.edge];
453 for (ROEdgeVector::const_iterator j = approaching.begin(); j != approaching.end(); ++j) {
454 if (hasDetector(*j)) {
455 previous.push_back(*j);
456 } else {
457 ie.depth = last.depth + 1;
458 ie.edge = *j;
459 missing.push_back(ie);
460 if (ie.depth > 5) {
461 maxDepthReached = true;
462 }
463 }
464 }
465 }
466 if (maxDepthReached) {
467 WRITE_WARNING(TL(" Could not build list of previous flows."));
468 }
469 }
470 // Edges with previous detectors are now in "previous";
471 // compute following
472 ROEdgeVector latter;
473 {
474 std::vector<IterationEdge> missing;
475 for (ROEdgeVector::const_iterator k = previous.begin(); k != previous.end(); ++k) {
476 IterationEdge ie;
477 ie.depth = 0;
478 ie.edge = *k;
479 missing.push_back(ie);
480 }
481 bool maxDepthReached = false;
482 while (!missing.empty() && !maxDepthReached) {
483 IterationEdge last = missing.back();
484 missing.pop_back();
485 ROEdgeVector approached = myApproachedEdges[last.edge];
486 for (ROEdgeVector::const_iterator j = approached.begin(); j != approached.end(); ++j) {
487 if (*j == getDetectorEdge(*detector)) {
488 continue;
489 }
490 if (hasDetector(*j)) {
491 latter.push_back(*j);
492 } else {
493 IterationEdge ie;
494 ie.depth = last.depth + 1;
495 ie.edge = *j;
496 missing.push_back(ie);
497 if (ie.depth > 5) {
498 maxDepthReached = true;
499 }
500 }
501 }
502 }
503 if (maxDepthReached) {
504 WRITE_WARNING(TL(" Could not build list of latter flows."));
505 return;
506 }
507 }
508 // Edges with latter detectors are now in "latter";
509
510 // lets not validate them by now - surely this should be done
511 // for each time step: collect incoming flows; collect outgoing;
512 std::vector<FlowDef> mflows;
513 int index = 0;
514 for (SUMOTime t = startTime; t < endTime; t += stepOffset, index++) {
515 // collect incoming
516 FlowDef inFlow;
517 inFlow.qLKW = 0;
518 inFlow.qPKW = 0;
519 inFlow.vLKW = 0;
520 inFlow.vPKW = 0;
521 // !! time difference is missing
522 for (const ROEdge* const e : previous) {
523 const std::vector<FlowDef>& eflows = static_cast<const RODFEdge*>(e)->getFlows();
524 if (eflows.size() != 0) {
525 const FlowDef& srcFD = eflows[index];
526 inFlow.qLKW += srcFD.qLKW;
527 inFlow.qPKW += srcFD.qPKW;
528 inFlow.vLKW += srcFD.vLKW;
529 inFlow.vPKW += srcFD.vPKW;
530 }
531 }
532 inFlow.vLKW /= (double) previous.size();
533 inFlow.vPKW /= (double) previous.size();
534 // collect outgoing
535 FlowDef outFlow;
536 outFlow.qLKW = 0;
537 outFlow.qPKW = 0;
538 outFlow.vLKW = 0;
539 outFlow.vPKW = 0;
540 // !! time difference is missing
541 for (const ROEdge* const e : latter) {
542 const std::vector<FlowDef>& eflows = static_cast<const RODFEdge*>(e)->getFlows();
543 if (eflows.size() != 0) {
544 const FlowDef& srcFD = eflows[index];
545 outFlow.qLKW += srcFD.qLKW;
546 outFlow.qPKW += srcFD.qPKW;
547 outFlow.vLKW += srcFD.vLKW;
548 outFlow.vPKW += srcFD.vPKW;
549 }
550 }
551 outFlow.vLKW /= (double) latter.size();
552 outFlow.vPKW /= (double) latter.size();
553 //
554 FlowDef mFlow;
555 mFlow.qLKW = inFlow.qLKW - outFlow.qLKW;
556 mFlow.qPKW = inFlow.qPKW - outFlow.qPKW;
557 mFlow.vLKW = (inFlow.vLKW + outFlow.vLKW) / (double) 2.;
558 mFlow.vPKW = (inFlow.vPKW + outFlow.vPKW) / (double) 2.;
559 mflows.push_back(mFlow);
560 }
561 static_cast<RODFEdge*>(getDetectorEdge(*detector))->setFlows(mflows);
562 flows.setFlows(detector->getID(), mflows);
563}
564
565
566void
568 RODFDetectorFlows& flows,
569 SUMOTime startTime, SUMOTime endTime,
570 SUMOTime stepOffset) {
571 const std::vector<RODFDetector*>& dets = detectors.getDetectors();
572 for (std::vector<RODFDetector*>::const_iterator i = dets.begin(); i != dets.end(); ++i) {
573 // check whether there is at least one entry with a flow larger than zero
574 revalidateFlows(*i, flows, startTime, endTime, stepOffset);
575 }
576}
577
578
579
580void
582 RODFDetectorFlows& flows) {
583 const std::vector<RODFDetector*>& dets = detectors.getDetectors();
584 for (std::vector<RODFDetector*>::const_iterator i = dets.begin(); i != dets.end();) {
585 bool remove = true;
586 // check whether there is at least one entry with a flow larger than zero
587 if (flows.knows((*i)->getID())) {
588 remove = false;
589 }
590 if (remove) {
591 WRITE_MESSAGEF(TL("Removed detector '%' because no flows for him exist."), (*i)->getID());
592 flows.removeFlow((*i)->getID());
593 detectors.removeDetector((*i)->getID());
594 i = dets.begin();
595 } else {
596 i++;
597 }
598 }
599}
600
601
602
603void
605 RODFDetectorFlows& flows) {
606 const std::vector<RODFDetector*>& dets = detectors.getDetectors();
607 for (std::vector<RODFDetector*>::const_iterator i = dets.begin(); i != dets.end(); ++i) {
608 bool remove = true;
609 // check whether there is at least one entry with a flow larger than zero
610 if (flows.knows((*i)->getID())) {
611 remove = false;
612 }
613 if (remove) {
614 WRITE_MESSAGEF(TL("Detector '%' has no flow."), (*i)->getID());
615 }
616 }
617}
618
619
620
621ROEdge*
623 const std::string edgeName = SUMOXMLDefinitions::getEdgeIDFromLane(det.getLaneID());
624 ROEdge* ret = getEdge(edgeName);
625 if (ret == nullptr) {
626 throw ProcessError("Edge '" + edgeName + "' used by detector '" + det.getID() + "' is not known.");
627 }
628 return ret;
629}
630
631
632bool
634 return myApproachingEdges.find(edge) != myApproachingEdges.end()
635 && myApproachingEdges.find(edge)->second.size() != 0;
636}
637
638
639bool
641 return myApproachedEdges.find(edge) != myApproachedEdges.end()
642 && myApproachedEdges.find(edge)->second.size() != 0;
643}
644
645
646bool
648 return myDetectorsOnEdges.find(edge) != myDetectorsOnEdges.end()
649 && myDetectorsOnEdges.find(edge)->second.size() != 0;
650}
651
652
653const std::vector<std::string>&
655 return myDetectorsOnEdges.find(edge)->second;
656}
657
658
659double
661 if (det.getPos() >= 0) {
662 return det.getPos();
663 }
664 return getDetectorEdge(det)->getLength() + det.getPos();
665}
666
667bool
668RODFNet::isSource(const RODFDetector& det, const RODFDetectorCon& detectors,
669 bool strict) const {
670 ROEdgeVector seen;
671 return isSource(det, getDetectorEdge(det), seen, detectors, strict);
672}
673
674bool
675RODFNet::isFalseSource(const RODFDetector& det, const RODFDetectorCon& detectors) const {
676 ROEdgeVector seen;
677 return isFalseSource(det, getDetectorEdge(det), seen, detectors);
678}
679
680bool
681RODFNet::isDestination(const RODFDetector& det, const RODFDetectorCon& detectors) const {
682 ROEdgeVector seen;
683 return isDestination(det, getDetectorEdge(det), seen, detectors);
684}
685
686
687bool
689 ROEdgeVector& seen,
690 const RODFDetectorCon& detectors,
691 bool strict) const {
692 if (seen.size() == 1000) { // !!!
693 WRITE_WARNINGF(TL("Quitting checking for being a source for detector '%' due to seen edge limit."), det.getID());
694 return false;
695 }
696 if (edge == getDetectorEdge(det)) {
697 // maybe there is another detector at the same edge
698 // get the list of this/these detector(s)
699 const std::vector<std::string>& detsOnEdge = myDetectorsOnEdges.find(edge)->second;
700 for (std::vector<std::string>::const_iterator i = detsOnEdge.begin(); i != detsOnEdge.end(); ++i) {
701 if ((*i) == det.getID()) {
702 continue;
703 }
704 const RODFDetector& sec = detectors.getDetector(*i);
705 if (getAbsPos(sec) < getAbsPos(det)) {
706 // ok, there is another detector on the same edge and it is
707 // before this one -> no source
708 return false;
709 }
710 }
711 }
712 // it's a source if no edges are approaching the edge
713 if (!hasApproaching(edge)) {
714 if (edge != getDetectorEdge(det)) {
715 if (hasDetector(edge)) {
716 return false;
717 }
718 }
719 return true;
720 }
721 if (edge != getDetectorEdge(det)) {
722 // ok, we are at one of the edges in front
723 if (myAmInHighwayMode) {
724 if (edge->getSpeedLimit() >= 19.4) {
725 if (hasDetector(edge)) {
726 // we are still on the highway and there is another detector
727 return false;
728 }
729 // the next is a hack for the A100 scenario...
730 // We have to look into further edges herein edges
731 const ROEdgeVector& appr = myApproachingEdges.find(edge)->second;
732 int noOk = 0;
733 int noFalse = 0;
734 int noSkipped = 0;
735 for (int i = 0; i < (int)appr.size(); i++) {
736 if (!hasDetector(appr[i])) {
737 noOk++;
738 } else {
739 noFalse++;
740 }
741 }
742 if (noFalse + noSkipped == (int)appr.size()) {
743 return false;
744 }
745 }
746 }
747 }
748
749 if (myAmInHighwayMode) {
750 if (edge->getSpeedLimit() < 19.4 && edge != getDetectorEdge(det)) {
751 // we have left the highway already
752 // -> the detector will be a highway source
753 if (!hasDetector(edge)) {
754 return true;
755 }
756 }
757 }
758 if (myDetectorsOnEdges.find(edge) != myDetectorsOnEdges.end()
759 &&
760 myDetectorEdges.find(det.getID())->second != edge) {
761 return false;
762 }
763
764 // let's check the edges in front
765 const ROEdgeVector& appr = myApproachingEdges.find(edge)->second;
766 int numOk = 0;
767 int numFalse = 0;
768 int numSkipped = 0;
769 seen.push_back(edge);
770 for (int i = 0; i < (int)appr.size(); i++) {
771 bool had = std::find(seen.begin(), seen.end(), appr[i]) != seen.end();
772 if (!had) {
773 if (isSource(det, appr[i], seen, detectors, strict)) {
774 numOk++;
775 } else {
776 numFalse++;
777 }
778 } else {
779 numSkipped++;
780 }
781 }
782 if (strict) {
783 return numOk + numSkipped == (int)appr.size();
784 }
785 return numFalse + numSkipped != (int)appr.size();
786}
787
788
789bool
791 const RODFDetectorCon& detectors) const {
792 if (seen.size() == 1000) { // !!!
793 WRITE_WARNINGF(TL("Quitting checking for being a destination for detector '%' due to seen edge limit."), det.getID());
794 return false;
795 }
796 if (edge == getDetectorEdge(det)) {
797 // maybe there is another detector at the same edge
798 // get the list of this/these detector(s)
799 const std::vector<std::string>& detsOnEdge = myDetectorsOnEdges.find(edge)->second;
800 for (std::vector<std::string>::const_iterator i = detsOnEdge.begin(); i != detsOnEdge.end(); ++i) {
801 if ((*i) == det.getID()) {
802 continue;
803 }
804 const RODFDetector& sec = detectors.getDetector(*i);
805 if (getAbsPos(sec) > getAbsPos(det)) {
806 // ok, there is another detector on the same edge and it is
807 // after this one -> no destination
808 return false;
809 }
810 }
811 }
812 if (!hasApproached(edge)) {
813 if (edge != getDetectorEdge(det)) {
814 if (hasDetector(edge)) {
815 return false;
816 }
817 }
818 return true;
819 }
820 if (edge != getDetectorEdge(det)) {
821 // ok, we are at one of the edges coming behind
822 if (myAmInHighwayMode) {
823 if (edge->getSpeedLimit() >= 19.4) {
824 if (hasDetector(edge)) {
825 // we are still on the highway and there is another detector
826 return false;
827 }
828 }
829 }
830 }
831
832 if (myAmInHighwayMode) {
833 if (edge->getSpeedLimit() < 19.4 && edge != getDetectorEdge(det)) {
834 if (hasDetector(edge)) {
835 return true;
836 }
837 if (myApproachedEdges.find(edge)->second.size() > 1) {
838 return true;
839 }
840
841 }
842 }
843
844 if (myDetectorsOnEdges.find(edge) != myDetectorsOnEdges.end()
845 &&
846 myDetectorEdges.find(det.getID())->second != edge) {
847 return false;
848 }
849 const ROEdgeVector& appr = myApproachedEdges.find(edge)->second;
850 bool isall = true;
851 int no = 0;
852 seen.push_back(edge);
853 for (int i = 0; i < (int)appr.size() && isall; i++) {
854 bool had = std::find(seen.begin(), seen.end(), appr[i]) != seen.end();
855 if (!had) {
856 if (!isDestination(det, appr[i], seen, detectors)) {
857 no++;
858 isall = false;
859 }
860 }
861 }
862 return isall;
863}
864
865bool
867 const RODFDetectorCon& detectors) const {
868 if (seen.size() == 1000) { // !!!
869 WRITE_WARNINGF(TL("Quitting checking for being a false source for detector '%' due to seen edge limit."), det.getID());
870 return false;
871 }
872 seen.push_back(edge);
873 if (edge != getDetectorEdge(det)) {
874 // ok, we are at one of the edges coming behind
875 if (hasDetector(edge)) {
876 const std::vector<std::string>& dets = myDetectorsOnEdges.find(edge)->second;
877 for (std::vector<std::string>::const_iterator i = dets.begin(); i != dets.end(); ++i) {
878 if (detectors.getDetector(*i).getType() == SINK_DETECTOR) {
879 return false;
880 }
881 if (detectors.getDetector(*i).getType() == BETWEEN_DETECTOR) {
882 return false;
883 }
884 if (detectors.getDetector(*i).getType() == SOURCE_DETECTOR) {
885 return true;
886 }
887 }
888 } else {
889 if (myAmInHighwayMode && edge->getSpeedLimit() < 19.) {
890 return false;
891 }
892 }
893 }
894
895 if (myApproachedEdges.find(edge) == myApproachedEdges.end()) {
896 return false;
897 }
898
899 const ROEdgeVector& appr = myApproachedEdges.find(edge)->second;
900 bool isall = false;
901 for (int i = 0; i < (int)appr.size() && !isall; i++) {
902 //printf("checking %s->\n", appr[i].c_str());
903 bool had = std::find(seen.begin(), seen.end(), appr[i]) != seen.end();
904 if (!had) {
905 if (isFalseSource(det, appr[i], seen, detectors)) {
906 isall = true;
907 }
908 }
909 }
910 return isall;
911}
912
913
914void
916 const RODFDetectorCon& detectors,
917 SUMOTime startTime, SUMOTime endTime,
918 SUMOTime stepOffset) {
919 std::map<ROEdge*, std::vector<std::string>, idComp>::iterator i;
920 double speedFactorSumPKW = 0;
921 double speedFactorSumLKW = 0;
922 double speedFactorCountPKW = 0;
923 double speedFactorCountLKW = 0;
924 for (i = myDetectorsOnEdges.begin(); i != myDetectorsOnEdges.end(); ++i) {
925 ROEdge* into = (*i).first;
926 const double maxSpeedPKW = into->getVClassMaxSpeed(SVC_PASSENGER);
927 const double maxSpeedLKW = into->getVClassMaxSpeed(SVC_TRUCK);
928
929 const std::vector<std::string>& dets = (*i).second;
930 std::map<double, std::vector<std::string> > cliques;
931 std::vector<std::string>* maxClique = nullptr;
932 for (std::vector<std::string>::const_iterator j = dets.begin(); j != dets.end(); ++j) {
933 if (!flows.knows(*j)) {
934 continue;
935 }
936 const RODFDetector& det = detectors.getDetector(*j);
937 bool found = false;
938 for (std::map<double, std::vector<std::string> >::iterator k = cliques.begin(); !found && k != cliques.end(); ++k) {
939 if (fabs((*k).first - det.getPos()) < 1) {
940 (*k).second.push_back(*j);
941 if ((*k).second.size() > maxClique->size()) {
942 maxClique = &(*k).second;
943 }
944 found = true;
945 }
946 }
947 if (!found) {
948 cliques[det.getPos()].push_back(*j);
949 maxClique = &cliques[det.getPos()];
950 }
951 }
952 if (maxClique == nullptr) {
953 continue;
954 }
955 std::vector<FlowDef> mflows; // !!! reserve
956 for (SUMOTime t = startTime; t < endTime; t += stepOffset) {
957 FlowDef fd;
958 fd.qPKW = 0;
959 fd.qLKW = 0;
960 fd.vLKW = 0;
961 fd.vPKW = 0;
962 fd.fLKW = 0;
963 fd.isLKW = 0;
964 mflows.push_back(fd);
965 }
966 for (std::vector<std::string>::iterator l = maxClique->begin(); l != maxClique->end(); ++l) {
967 bool didWarn = false;
968 const std::vector<FlowDef>& dflows = flows.getFlowDefs(*l);
969 int index = 0;
970 for (SUMOTime t = startTime; t < endTime; t += stepOffset, index++) {
971 const FlowDef& srcFD = dflows[index];
972 FlowDef& fd = mflows[index];
973 fd.qPKW += srcFD.qPKW;
974 fd.qLKW += srcFD.qLKW;
975 fd.vLKW += srcFD.vLKW / (double) maxClique->size();
976 fd.vPKW += srcFD.vPKW / (double) maxClique->size();
977 fd.fLKW += srcFD.fLKW / (double) maxClique->size();
978 fd.isLKW += srcFD.isLKW / (double) maxClique->size();
979 const double speedFactorPKW = srcFD.vPKW / 3.6 / maxSpeedPKW;
980 const double speedFactorLKW = srcFD.vLKW / 3.6 / maxSpeedLKW;
983 speedFactorCountPKW += srcFD.qPKW;
984 speedFactorCountLKW += srcFD.qLKW;
985 speedFactorSumPKW += srcFD.qPKW * speedFactorPKW;
986 speedFactorSumLKW += srcFD.qLKW * speedFactorLKW;
987 if (!didWarn && srcFD.vPKW > 0 && srcFD.vPKW < 255 && srcFD.vPKW / 3.6 > into->getSpeedLimit()) {
988 WRITE_MESSAGE("Detected PKW speed (" + toString(srcFD.vPKW / 3.6, 3) + ") higher than allowed speed (" + toString(into->getSpeedLimit(), 3) + ") at '" + (*l) + "' on edge '" + into->getID() + "'.");
989 didWarn = true;
990 }
991 if (!didWarn && srcFD.vLKW > 0 && srcFD.vLKW < 255 && srcFD.vLKW / 3.6 > into->getSpeedLimit()) {
992 WRITE_MESSAGE("Detected LKW speed (" + toString(srcFD.vLKW / 3.6, 3) + ") higher than allowed speed (" + toString(into->getSpeedLimit(), 3) + ") at '" + (*l) + "' on edge '" + into->getID() + "'.");
993 didWarn = true;
994 }
995 }
996 }
997 static_cast<RODFEdge*>(into)->setFlows(mflows);
998 }
999 // @note: this assumes that the speedFactors are independent of location and time
1000 if (speedFactorCountPKW > 0) {
1001 myAvgSpeedFactorPKW = speedFactorSumPKW / speedFactorCountPKW;
1002 WRITE_MESSAGEF(TL("Average speedFactor for PKW is % maximum speedFactor is %."), toString(myAvgSpeedFactorPKW), toString(myMaxSpeedFactorPKW));
1003 }
1004 if (speedFactorCountLKW > 0) {
1005 myAvgSpeedFactorLKW = speedFactorSumLKW / speedFactorCountLKW;
1006 WRITE_MESSAGEF(TL("Average speedFactor for LKW is % maximum speedFactor is %."), toString(myAvgSpeedFactorLKW), toString(myMaxSpeedFactorLKW));
1007 }
1008
1009}
1010
1011
1012void
1014 // !!! this will not work when several detectors are lying on the same edge on different positions
1015
1016
1018 // for each detector, compute the lists of predecessor and following detectors
1019 std::map<std::string, ROEdge*>::const_iterator i;
1020 for (i = myDetectorEdges.begin(); i != myDetectorEdges.end(); ++i) {
1021 const RODFDetector& det = detectors.getDetector((*i).first);
1022 if (!det.hasRoutes()) {
1023 continue;
1024 }
1025 // mark current detectors
1026 std::vector<RODFDetector*> last;
1027 {
1028 const std::vector<std::string>& detNames = myDetectorsOnEdges.find((*i).second)->second;
1029 for (std::vector<std::string>::const_iterator j = detNames.begin(); j != detNames.end(); ++j) {
1030 last.push_back(&detectors.getModifiableDetector(*j));
1031 }
1032 }
1033 // iterate over the current detector's routes
1034 const std::vector<RODFRouteDesc>& routes = det.getRouteVector();
1035 for (std::vector<RODFRouteDesc>::const_iterator j = routes.begin(); j != routes.end(); ++j) {
1036 const ROEdgeVector& edges2Pass = (*j).edges2Pass;
1037 for (ROEdgeVector::const_iterator k = edges2Pass.begin() + 1; k != edges2Pass.end(); ++k) {
1038 if (myDetectorsOnEdges.find(*k) != myDetectorsOnEdges.end()) {
1039 const std::vector<std::string>& detNames = myDetectorsOnEdges.find(*k)->second;
1040 // ok, consecutive detector found
1041 for (std::vector<RODFDetector*>::iterator l = last.begin(); l != last.end(); ++l) {
1042 // mark as follower of current
1043 for (std::vector<std::string>::const_iterator m = detNames.begin(); m != detNames.end(); ++m) {
1044 detectors.getModifiableDetector(*m).addPriorDetector(*l);
1045 (*l)->addFollowingDetector(&detectors.getDetector(*m));
1046 }
1047 }
1048 last.clear();
1049 for (std::vector<std::string>::const_iterator m = detNames.begin(); m != detNames.end(); ++m) {
1050 last.push_back(&detectors.getModifiableDetector(*m));
1051 }
1052 }
1053 }
1054 }
1055 }
1056}
1057
1058
1059void
1062 std::map<ROEdge*, std::vector<std::string>, idComp>::iterator i;
1063 for (i = myDetectorsOnEdges.begin(); i != myDetectorsOnEdges.end(); ++i) {
1064 const std::vector<std::string>& dets = (*i).second;
1065 std::map<double, std::vector<std::string> > cliques;
1066 // compute detector cliques
1067 for (std::vector<std::string>::const_iterator j = dets.begin(); j != dets.end(); ++j) {
1068 const RODFDetector& det = detectors.getDetector(*j);
1069 bool found = false;
1070 for (std::map<double, std::vector<std::string> >::iterator k = cliques.begin(); !found && k != cliques.end(); ++k) {
1071 if (fabs((*k).first - det.getPos()) < 10.) {
1072 (*k).second.push_back(*j);
1073 found = true;
1074 }
1075 }
1076 if (!found) {
1077 cliques[det.getPos()] = std::vector<std::string>();
1078 cliques[det.getPos()].push_back(*j);
1079 }
1080 }
1081 // join detector cliques
1082 for (std::map<double, std::vector<std::string> >::iterator m = cliques.begin(); m != cliques.end(); ++m) {
1083 std::vector<std::string> clique = (*m).second;
1084 // do not join if only one
1085 if (clique.size() == 1) {
1086 continue;
1087 }
1088 std::string nid;
1089 for (std::vector<std::string>::iterator n = clique.begin(); n != clique.end(); ++n) {
1090 std::cout << *n << " ";
1091 if (n != clique.begin()) {
1092 nid = nid + "_";
1093 }
1094 nid = nid + *n;
1095 }
1096 std::cout << ":" << nid << std::endl;
1097 flows.mesoJoin(nid, (*m).second);
1098 detectors.mesoJoin(nid, (*m).second);
1099 }
1100 }
1101}
1102
1103
1104/****************************************************************************/
long long int SUMOTime
Definition: GUI.h:36
#define WRITE_WARNINGF(...)
Definition: MsgHandler.h:271
#define WRITE_MESSAGEF(...)
Definition: MsgHandler.h:273
#define WRITE_MESSAGE(msg)
Definition: MsgHandler.h:272
#define WRITE_WARNING(msg)
Definition: MsgHandler.h:270
#define TL(string)
Definition: MsgHandler.h:287
#define PROGRESS_DONE_MESSAGE()
Definition: MsgHandler.h:275
#define PROGRESS_BEGIN_MESSAGE(msg)
Definition: MsgHandler.h:274
@ BETWEEN_DETECTOR
An in-between detector.
Definition: RODFDetector.h:64
@ SINK_DETECTOR
Definition: RODFDetector.h:68
@ SOURCE_DETECTOR
A source detector.
Definition: RODFDetector.h:67
@ DISCARDED_DETECTOR
A detector which had to be discarded (!!!)
Definition: RODFDetector.h:61
@ TYPE_NOT_DEFINED
A not yet defined detector.
Definition: RODFDetector.h:58
std::vector< ROEdge * > ROEdgeVector
Definition: RODFRouteDesc.h:35
std::vector< const ROEdge * > ConstROEdgeVector
Definition: ROEdge.h:54
SUMOVehicleClass getVehicleClassID(const std::string &name)
Returns the class id of the abstract class given by its name.
@ SVC_TRUCK
vehicle is a large transport vehicle
@ SVC_PASSENGER
vehicle is a passenger car (a "normal" car)
#define UNUSED_PARAMETER(x)
Definition: StdDefs.h:30
T MAX2(T a, T b)
Definition: StdDefs.h:82
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:46
const std::string & getID() const
Returns the id.
Definition: Named.h:74
double getFloat(const std::string &name) const
Returns the double-value of the named option (only for Option_Float)
bool getBool(const std::string &name) const
Returns the boolean-value of the named option (only for Option_Bool)
const StringVector & getStringVector(const std::string &name) const
Returns the list of string-value of the named option (only for Option_StringVector)
static OptionsCont & getOptions()
Retrieves the options.
Definition: OptionsCont.cpp:60
A container for RODFDetectors.
Definition: RODFDetector.h:216
void mesoJoin(const std::string &nid, const std::vector< std::string > &oldids)
void removeDetector(const std::string &id)
const RODFDetector & getDetector(const std::string &id) const
RODFDetector & getModifiableDetector(const std::string &id) const
const std::vector< RODFDetector * > & getDetectors() const
A container for flows.
void setFlows(const std::string &detector_id, std::vector< FlowDef > &)
void mesoJoin(const std::string &nid, const std::vector< std::string > &oldids)
const std::vector< FlowDef > & getFlowDefs(const std::string &id) const
void removeFlow(const std::string &detector_id)
bool knows(const std::string &det_id) const
Class representing a detector within the DFROUTER.
Definition: RODFDetector.h:79
double getPos() const
Returns the position at which the detector lies.
Definition: RODFDetector.h:130
void addPriorDetector(const RODFDetector *det)
bool hasRoutes() const
const std::vector< RODFRouteDesc > & getRouteVector() const
RODFDetectorType getType() const
Returns the type of the detector.
Definition: RODFDetector.h:139
const std::string & getLaneID() const
Returns the id of the lane this detector is placed on.
Definition: RODFDetector.h:116
void buildEdgeFlowMap(const RODFDetectorFlows &flows, const RODFDetectorCon &detectors, SUMOTime startTime, SUMOTime endTime, SUMOTime stepOffset)
Definition: RODFNet.cpp:915
double myAvgSpeedFactorPKW
Definition: RODFNet.h:190
void computeTypes(RODFDetectorCon &dets, bool sourcesStrict) const
Definition: RODFNet.cpp:111
std::map< std::string, ROEdge * > myDetectorEdges
Definition: RODFNet.h:175
double myMaxSpeedFactorPKW
maximum speed factor in measurements
Definition: RODFNet.h:188
std::vector< std::string > myDisallowedEdges
List of ids of edges that shall not be used.
Definition: RODFNet.h:181
std::map< ROEdge *, std::vector< std::string >, idComp > myDetectorsOnEdges
Definition: RODFNet.h:174
void revalidateFlows(const RODFDetectorCon &detectors, RODFDetectorFlows &flows, SUMOTime startTime, SUMOTime endTime, SUMOTime stepOffset)
Definition: RODFNet.cpp:567
bool isFalseSource(const RODFDetector &det, const RODFDetectorCon &detectors) const
Definition: RODFNet.cpp:675
int myInBetweenNumber
Definition: RODFNet.h:178
bool hasApproached(ROEdge *edge) const
Definition: RODFNet.cpp:640
bool myKeepTurnarounds
Definition: RODFNet.h:185
~RODFNet()
Destructor.
Definition: RODFNet.cpp:59
void mesoJoin(RODFDetectorCon &detectors, RODFDetectorFlows &flows)
Definition: RODFNet.cpp:1060
int mySinkNumber
Definition: RODFNet.h:178
void buildDetectorEdgeDependencies(RODFDetectorCon &dets) const
Definition: RODFNet.cpp:98
int mySourceNumber
Definition: RODFNet.h:178
bool hasApproaching(ROEdge *edge) const
Definition: RODFNet.cpp:633
void buildRoutes(RODFDetectorCon &det, bool keepUnfoundEnds, bool includeInBetween, bool keepShortestOnly, int maxFollowingLength) const
Definition: RODFNet.cpp:343
RODFNet(bool amInHighwayMode)
Constructor.
Definition: RODFNet.cpp:46
bool isDestination(const RODFDetector &det, const RODFDetectorCon &detectors) const
Definition: RODFNet.cpp:681
void buildDetectorDependencies(RODFDetectorCon &detectors)
Definition: RODFNet.cpp:1013
SUMOVehicleClass myAllowedVClass
Definition: RODFNet.h:183
void removeEmptyDetectors(RODFDetectorCon &detectors, RODFDetectorFlows &flows)
Definition: RODFNet.cpp:581
bool isAllowed(const ROEdge *const edge) const
Definition: RODFNet.cpp:64
void computeRoutesFor(ROEdge *edge, RODFRouteDesc &base, int no, bool keepUnfoundEnds, bool keepShortestOnly, ROEdgeVector &visited, const RODFDetector &det, RODFRouteCont &into, const RODFDetectorCon &detectors, int maxFollowingLength, ROEdgeVector &seen) const
Definition: RODFNet.cpp:184
ROEdge * getDetectorEdge(const RODFDetector &det) const
Definition: RODFNet.cpp:622
double myMaxSpeedFactorLKW
Definition: RODFNet.h:189
bool hasSourceDetector(ROEdge *edge, const RODFDetectorCon &detectors) const
Definition: RODFNet.cpp:167
void buildApproachList()
Definition: RODFNet.cpp:73
std::map< ROEdge *, ROEdgeVector > myApproachingEdges
Map of edge name->list of names of this edge approaching edges.
Definition: RODFNet.h:169
bool myAmInHighwayMode
Definition: RODFNet.h:177
bool hasDetector(ROEdge *edge) const
Definition: RODFNet.cpp:647
const std::vector< std::string > & getDetectorList(ROEdge *edge) const
Definition: RODFNet.cpp:654
double getAbsPos(const RODFDetector &det) const
Definition: RODFNet.cpp:660
bool isSource(const RODFDetector &det, const RODFDetectorCon &detectors, bool strict) const
Definition: RODFNet.cpp:668
double myAvgSpeedFactorLKW
Definition: RODFNet.h:191
bool hasInBetweenDetectorsOnly(ROEdge *edge, const RODFDetectorCon &detectors) const
Definition: RODFNet.cpp:151
void reportEmptyDetectors(RODFDetectorCon &detectors, RODFDetectorFlows &flows)
Definition: RODFNet.cpp:604
std::map< ROEdge *, ROEdgeVector > myApproachedEdges
Map of edge name->list of names of edges approached by this edge.
Definition: RODFNet.h:172
int myInvalidNumber
Definition: RODFNet.h:178
A container for DFROUTER-routes.
Definition: RODFRouteCont.h:53
void addRouteDesc(RODFRouteDesc &desc)
Adds a route to the container.
std::vector< RODFRouteDesc > & get()
Returns the container of stored routes.
bool removeRouteDesc(RODFRouteDesc &desc)
Removes the given route description from the container.
A basic edge for routing applications.
Definition: ROEdge.h:70
double getVClassMaxSpeed(SUMOVehicleClass vclass) const
Returns the lane's maximum speed, given a vehicle's speed limit adaptation.
Definition: ROEdge.h:242
const RONode * getFromJunction() const
Definition: ROEdge.h:508
double getSpeedLimit() const
Returns the speed allowed on this edge.
Definition: ROEdge.h:230
bool isInternal() const
return whether this edge is an internal edge
Definition: ROEdge.h:150
SVCPermissions getPermissions() const
Definition: ROEdge.h:279
const ROEdgeVector & getSuccessors(SUMOVehicleClass vClass=SVC_IGNORING) const
Returns the following edges, restricted by vClass.
Definition: ROEdge.cpp:366
bool isWalkingArea() const
return whether this edge is walking area
Definition: ROEdge.h:160
double getLength() const
Returns the length of the edge.
Definition: ROEdge.h:215
bool isCrossing() const
return whether this edge is a pedestrian crossing
Definition: ROEdge.h:155
The router's network representation.
Definition: RONet.h:62
ROEdge * getEdge(const std::string &name) const
Retrieves an edge from the network.
Definition: RONet.h:157
const NamedObjectCont< ROEdge * > & getEdgeMap() const
Definition: RONet.h:409
static std::string getEdgeIDFromLane(const std::string laneID)
return edge id when given the lane ID
static double fd[10]
Definition: odrSpiral.cpp:99
Definition of the traffic during a certain time containing the flows and speeds.
double vPKW
double isLKW
double vLKW
double fLKW
double qLKW
double qPKW
comparator for maps using edges as key, used only in myDetectorsOnEdges to make tests comparable
Definition: RODFNet.h:162
A route within the DFROUTER.
Definition: RODFRouteDesc.h:44
double distance2Last
Definition: RODFRouteDesc.h:54
ROEdgeVector edges2Pass
The edges the route is made of.
Definition: RODFRouteDesc.h:46
const ROEdge * lastDetectorEdge
Definition: RODFRouteDesc.h:53
const ROEdge * endDetectorEdge
Definition: RODFRouteDesc.h:52
double duration_2
Definition: RODFRouteDesc.h:49
double overallProb
Definition: RODFRouteDesc.h:57
SUMOTime duration2Last
Definition: RODFRouteDesc.h:55