SUMO - Simulation of Urban MObility
MESegment.cpp
Go to the documentation of this file.
1 /****************************************************************************/
7 // A single mesoscopic segment (cell)
8 /****************************************************************************/
9 // SUMO, Simulation of Urban MObility; see http://sumo.dlr.de/
10 // Copyright (C) 2001-2016 DLR (http://www.dlr.de/) and contributors
11 /****************************************************************************/
12 //
13 // This file is part of SUMO.
14 // SUMO is free software: you can redistribute it and/or modify
15 // it under the terms of the GNU General Public License as published by
16 // the Free Software Foundation, either version 3 of the License, or
17 // (at your option) any later version.
18 //
19 /****************************************************************************/
20 
21 
22 // ===========================================================================
23 // included modules
24 // ===========================================================================
25 #ifdef _MSC_VER
26 #include <windows_config.h>
27 #else
28 #include <config.h>
29 #endif
30 
31 #include <algorithm>
32 #include <limits>
33 #include <utils/common/StdDefs.h>
34 #include <microsim/MSGlobals.h>
35 #include <microsim/MSEdge.h>
36 #include <microsim/MSJunction.h>
37 #include <microsim/MSNet.h>
38 #include <microsim/MSLane.h>
39 #include <microsim/MSLinkCont.h>
40 #include <microsim/MSVehicle.h>
49 #include "MEVehicle.h"
50 #include "MELoop.h"
51 #include "MESegment.h"
52 
53 #ifdef CHECK_MEMORY_LEAKS
54 #include <foreign/nvwa/debug_new.h>
55 #endif // CHECK_MEMORY_LEAKS
56 
57 #define DEFAULT_VEH_LENGHT_WITH_GAP 7.5f
58 // avoid division by zero when driving very slowly
59 #define MESO_MIN_SPEED ((SUMOReal)0.05)
60 
61 // ===========================================================================
62 // static member defintion
63 // ===========================================================================
64 MSEdge MESegment::myDummyParent("MESegmentDummyParent", -1, MSEdge::EDGEFUNCTION_UNKNOWN, "", "", -1);
65 MESegment MESegment::myVaporizationTarget("vaporizationTarget");
67 
68 // ===========================================================================
69 // method definitions
70 // ===========================================================================
71 MESegment::MESegment(const std::string& id,
72  const MSEdge& parent, MESegment* next,
73  SUMOReal length, SUMOReal speed,
74  int idx,
75  SUMOTime tauff, SUMOTime taufj,
76  SUMOTime taujf, SUMOTime taujj,
77  SUMOReal jamThresh, bool multiQueue, bool junctionControl,
78  SUMOReal lengthGeometryFactor) :
79  Named(id), myEdge(parent), myNextSegment(next),
80  myLength(length), myIndex(idx),
81  myTau_ff((SUMOTime)(tauff / parent.getLanes().size())),
82  myTau_fj((SUMOTime)(taufj / parent.getLanes().size())), // Eissfeldt p. 90 and 151 ff.
83  myTau_jf((SUMOTime)(taujf / parent.getLanes().size())),
84  myTau_jj((SUMOTime)(taujj / parent.getLanes().size())),
85  myTau_length(MAX2(MESO_MIN_SPEED, speed) * parent.getLanes().size() / TIME2STEPS(1)),
86  myHeadwayCapacity(length / DEFAULT_VEH_LENGHT_WITH_GAP * parent.getLanes().size())/* Eissfeldt p. 69 */,
87  myCapacity(length * parent.getLanes().size()),
88  myOccupancy(0.f),
89  myJunctionControl(junctionControl),
90  myTLSPenalty(MSGlobals::gMesoTLSPenalty > 0 && myNextSegment == 0 && (
91  parent.getToJunction()->getType() == NODETYPE_TRAFFIC_LIGHT ||
92  parent.getToJunction()->getType() == NODETYPE_TRAFFIC_LIGHT_NOJUNCTION ||
93  parent.getToJunction()->getType() == NODETYPE_TRAFFIC_LIGHT_RIGHT_ON_RED)),
94  myEntryBlockTime(SUMOTime_MIN),
95  myLengthGeometryFactor(lengthGeometryFactor),
96  myMeanSpeed(speed),
97  myLastMeanSpeedUpdate(SUMOTime_MIN) {
98  myCarQues.push_back(std::vector<MEVehicle*>());
99  myBlockTimes.push_back(-1);
100  const std::vector<MSLane*>& lanes = parent.getLanes();
101  if (multiQueue && lanes.size() > 1) {
102  int numFollower = parent.getNumSuccessors();
103  if (numFollower > 1) {
104  while (myCarQues.size() < lanes.size()) {
105  myCarQues.push_back(std::vector<MEVehicle*>());
106  myBlockTimes.push_back(-1);
107  }
108  for (int i = 0; i < numFollower; ++i) {
109  const MSEdge* edge = parent.getSuccessors()[i];
110  myFollowerMap[edge] = std::vector<int>();
111  const std::vector<MSLane*>* allowed = parent.allowedLanes(*edge);
112  assert(allowed != 0);
113  assert(allowed->size() > 0);
114  for (std::vector<MSLane*>::const_iterator j = allowed->begin(); j != allowed->end(); ++j) {
115  std::vector<MSLane*>::const_iterator it = find(lanes.begin(), lanes.end(), *j);
116  myFollowerMap[edge].push_back(distance(lanes.begin(), it));
117  }
118  }
119  }
120  }
121  recomputeJamThreshold(jamThresh);
122 }
123 
124 
125 MESegment::MESegment(const std::string& id):
126  Named(id),
127  myEdge(myDummyParent), // arbitrary edge needed to supply the needed reference
128  myNextSegment(0), myLength(0), myIndex(0),
129  myTau_ff(0), myTau_fj(0), myTau_jf(0), myTau_jj(0), myTau_length(1),
131  myTLSPenalty(false),
133 }
134 
135 
136 void
138  if (jamThresh == DO_NOT_PATCH_JAM_THRESHOLD) {
139  return;
140  }
141  if (jamThresh < 0) {
142  // compute based on speed
144  } else {
145  // compute based on specified percentage
146  myJamThreshold = jamThresh * myCapacity;
147  }
148 
149  // update coefficients for the jam-jam headway function
150  // this function models the effect that "empty space" needs to move
151  // backwards through the downstream segment before the upstream segment may
152  // send annother vehicle
153  // the headway function f(x) depends on the number of vehicles in the
154  // downstream segment x
155  // f is a linear function that passes through the following fixed points:
156  // f(n_jam_threshold) = myTau_jf (for continuity)
157  // f(myHeadwayCapacity) = myTau_jj & myHeadwayCapacity
158 
159  if (myJamThreshold < myCapacity) {
160  // jamming is possible
161  const SUMOReal n_jam_threshold = myHeadwayCapacity * myJamThreshold / myCapacity; // number of vehicles above which the segment is jammed
162  // solving f(x) = a * x + b
165 
166  // note that the original Eissfeldt model (p. 69) used different fixed points
167  // f(n_jam_threshold) = n_jam_threshold * myTau_jj
168  // f(myHeadwayCapacity) = myTau_jf * myHeadwayCapacity
169  //
170  // However, this systematically underestimates the backpropagation speed of the jam front (see #2244)
171  } else {
172  // dummy values. Should not be used
173  myA = 0;
174  myB = myTau_jf;
175  }
176 }
177 
178 
179 SUMOReal
181  // vehicles driving freely at maximum speed should not jam
182  // we compute how many vehicles could possible enter the segment until the first vehicle leaves
183  // and multiply by the space these vehicles would occupy
184  // the jamThresh parameter is scale the resulting value
185  if (speed == 0) {
186  return std::numeric_limits<double>::max(); // never jam. Irrelevant at speed 0 anyway
187  }
189  return std::ceil((myLength / (-jamThresh * speed * STEPS2TIME(myTau_ff + defaultLengthWithGap / myTau_length)))) * defaultLengthWithGap;
190 }
191 
192 
193 void
195  myDetectorData.push_back(data);
196  for (Queues::const_iterator k = myCarQues.begin(); k != myCarQues.end(); ++k) {
197  for (std::vector<MEVehicle*>::const_reverse_iterator i = k->rbegin(); i != k->rend(); ++i) {
198  (*i)->addReminder(data);
199  }
200  }
201 }
202 
203 
204 void
206  std::vector<MSMoveReminder*>::iterator it = find(
207  myDetectorData.begin(), myDetectorData.end(), data);
208  if (it != myDetectorData.end()) {
209  myDetectorData.erase(it);
210  }
211  for (Queues::const_iterator k = myCarQues.begin(); k != myCarQues.end(); ++k) {
212  for (std::vector<MEVehicle*>::const_reverse_iterator i = k->rbegin(); i != k->rend(); ++i) {
213  (*i)->removeReminder(data);
214  }
215  }
216 }
217 
218 
219 void
222  if (next == 0) {
224  } else if (next == &myVaporizationTarget) {
226  } else if (myNextSegment == 0) {
228  } else {
230  }
231  v->updateDetectors(currentTime, true, reason);
232 }
233 
234 
235 void
237  const SUMOTime currentTime = MSNet::getInstance()->getCurrentTimeStep();
238  for (Queues::const_iterator k = myCarQues.begin(); k != myCarQues.end(); ++k) {
239  SUMOTime earliestExitTime = currentTime;
240  for (std::vector<MEVehicle*>::const_reverse_iterator i = k->rbegin(); i != k->rend(); ++i) {
241  const SUMOTime exitTime = MAX2(earliestExitTime, (*i)->getEventTime());
242  (*i)->updateDetectorForWriting(&data, currentTime, exitTime);
243  earliestExitTime = exitTime + myTau_ff;
244  }
245  }
246 }
247 
248 
249 bool
250 MESegment::hasSpaceFor(const MEVehicle* veh, SUMOTime entryTime, bool init) const {
251  if (myOccupancy == 0.) {
252  // we have always space for at least one vehicle
253  return true;
254  }
255  const SUMOReal newOccupancy = myOccupancy + veh->getVehicleType().getLengthWithGap();
256  if (newOccupancy > myCapacity) {
257  // we must ensure that occupancy remains below capacity
258  return false;
259  }
260  // regular insertions and initial insertions must respect different constraints:
261  // - regular insertions must respect entryBlockTime
262  // - initial insertions should not cause additional jamming
263  if (init) {
264  // inserted vehicle should be able to continue at the current speed
265  return newOccupancy <= jamThresholdForSpeed(getMeanSpeed(false), -1);
266  }
267  // maintain propper spacing between inflow from different lanes
268  return entryTime >= myEntryBlockTime;
269 }
270 
271 
272 bool
274  if (hasSpaceFor(veh, time, true)) {
275  receive(veh, time, true);
276  // we can check only after insertion because insertion may change the route via devices
277  std::string msg;
278  if (MSGlobals::gCheckRoutes && !veh->hasValidRoute(msg)) {
279  throw ProcessError("Vehicle '" + veh->getID() + "' has no valid route. " + msg);
280  }
281  return true;
282  }
283  return false;
284 }
285 
286 
287 int
289  int total = 0;
290  for (Queues::const_iterator k = myCarQues.begin(); k != myCarQues.end(); ++k) {
291  total += (int)k->size();
292  }
293  return total;
294 }
295 
296 
297 SUMOReal
298 MESegment::getMeanSpeed(bool useCached) const {
299  const SUMOTime currentTime = MSNet::getInstance()->getCurrentTimeStep();
300  if (currentTime != myLastMeanSpeedUpdate || !useCached) {
301  myLastMeanSpeedUpdate = currentTime;
302  const SUMOTime tau = free() ? myTau_ff : myTau_jf;
303  SUMOReal v = 0;
304  int count = 0;
305  for (Queues::const_iterator k = myCarQues.begin(); k != myCarQues.end(); ++k) {
306  SUMOTime earliestExitTime = currentTime;
307  count += (int)k->size();
308  for (std::vector<MEVehicle*>::const_reverse_iterator veh = k->rbegin(); veh != k->rend(); ++veh) {
309  v += (*veh)->getConservativeSpeed(earliestExitTime); // earliestExitTime is updated!
310  earliestExitTime += tau;
311  }
312  }
313  if (count == 0) {
315  } else {
316  myMeanSpeed = v / (SUMOReal) count;
317  }
318  }
319  return myMeanSpeed;
320 }
321 
322 
323 void
325  for (Queues::const_iterator k = myCarQues.begin(); k != myCarQues.end(); ++k) {
326  for (std::vector<MEVehicle*>::const_iterator veh = k->begin(); veh != k->end(); ++veh) {
327  MSXMLRawOut::writeVehicle(of, *(*veh));
328  }
329  }
330 }
331 
332 
333 MEVehicle*
336  std::vector<MEVehicle*>& cars = myCarQues[v->getQueIndex()];
337  assert(std::find(cars.begin(), cars.end(), v) != cars.end());
338  // One could be tempted to do v->setSegment(next); here but position on lane will be invalid if next == 0
339  updateDetectorsOnLeave(v, leaveTime, next);
340  myEdge.lock();
341  if (v == cars.back()) {
342  cars.pop_back();
343  if (!cars.empty()) {
344  myEdge.unlock();
345  return cars.back();
346  }
347  } else {
348  cars.erase(std::find(cars.begin(), cars.end(), v));
349  }
350  myEdge.unlock();
351  return 0;
352 }
353 
354 
355 SUMOTime
356 MESegment::getTimeHeadway(bool predecessorIsFree, SUMOReal leaderLength) {
357  if (predecessorIsFree) {
358  return (free() ? myTau_ff : myTau_fj) + (SUMOTime)(leaderLength / myTau_length);
359  } else {
360  if (free()) {
361  return myTau_jf;
362  } else {
363  // the gap has to move from the start of the segment to its end
364  // this allows jams to clear and move upstream
365  return TIME2STEPS(myA * getCarNumber() + myB);
366  }
367  }
368 }
369 
370 
371 SUMOTime
373  // since we do not know which queue will be used we give a conservative estimate
374  SUMOTime earliestLeave = earliestEntry;
375  for (int i = 0; i < (int)myCarQues.size(); ++i) {
376  earliestLeave = MAX2(earliestLeave, myBlockTimes[i]);
377  }
378  if (myEdge.getSpeedLimit() == 0) {
379  return MAX2(earliestEntry, myEntryBlockTime); // FIXME: This line is just an adhoc-fix to avoid division by zero (Leo)
380  } else {
381  return MAX3(earliestEntry, earliestLeave - TIME2STEPS(myLength / myEdge.getSpeedLimit()), myEntryBlockTime);
382  }
383 }
384 
385 
386 MSLink*
387 MESegment::getLink(const MEVehicle* veh, bool tlsPenalty) const {
388  if (myJunctionControl || tlsPenalty) {
389  const MSEdge* const nextEdge = veh->succEdge(1);
390  if (nextEdge == 0) {
391  return 0;
392  }
393  // try to find any link leading to our next edge, start with the lane pointed to by the que index
394  const MSLane* const bestLane = myEdge.getLanes()[veh->getQueIndex()];
395  const MSLinkCont& links = bestLane->getLinkCont();
396  for (std::vector<MSLink*>::const_iterator j = links.begin(); j != links.end(); ++j) {
397  if (&(*j)->getLane()->getEdge() == nextEdge) {
398  return *j;
399  }
400  }
401  // this is for the non-multique case, maybe we should use caching here !!!
402  for (std::vector<MSLane*>::const_iterator l = myEdge.getLanes().begin(); l != myEdge.getLanes().end(); ++l) {
403  if ((*l) != bestLane) {
404  const MSLinkCont& links = (*l)->getLinkCont();
405  for (std::vector<MSLink*>::const_iterator j = links.begin(); j != links.end(); ++j) {
406  if (&(*j)->getLane()->getEdge() == nextEdge) {
407  return *j;
408  }
409  }
410  }
411  }
412  }
413  return 0;
414 }
415 
416 
417 bool
418 MESegment::isOpen(const MEVehicle* veh) const {
419  if (myTLSPenalty) {
420  // XXX should limited control take precedence over tls penalty?
421  return true;
422  }
423  const MSLink* link = getLink(veh);
424  return (link == 0
425  || link->havePriority()
426  || limitedControlOverride(link)
427  || link->opened(veh->getEventTime(), veh->getSpeed(), veh->estimateLeaveSpeed(link),
430 }
431 
432 
433 bool
435  assert(link != 0);
437  return false;
438  }
439  // if the target segment of this link is not saturated junction control is disabled
440  const MSEdge& targetEdge = link->getLane()->getEdge();
441  const MESegment* target = MSGlobals::gMesoNet->getSegmentForEdge(targetEdge);
442  return target->myOccupancy * 2 < target->myJamThreshold;
443 }
444 
445 
446 void
448  assert(isInvalid(next) || time >= myBlockTimes[veh->getQueIndex()]);
449  MSLink* link = getLink(veh);
450  if (link != 0) {
451  link->removeApproaching(veh);
452  }
453  MEVehicle* lc = removeCar(veh, time, next); // new leaderCar
454  myBlockTimes[veh->getQueIndex()] = time;
455  if (!isInvalid(next)) {
457  }
458  if (lc != 0) {
461  }
462 }
463 
464 bool
467 }
468 
469 
470 void
472  for (std::vector<MSMoveReminder*>::const_iterator i = myDetectorData.begin(); i != myDetectorData.end(); ++i) {
473  veh->addReminder(*i);
474  }
475 }
476 
477 void
478 MESegment::receive(MEVehicle* veh, SUMOTime time, bool isDepart, bool afterTeleport) {
479  const SUMOReal speed = isDepart ? -1 : MAX2(veh->getSpeed(), MESO_MIN_SPEED); // on the previous segment
480  veh->setSegment(this); // for arrival checking
481  veh->setLastEntryTime(time);
483  if (!isDepart && (
484  // arrival on entering a new edge
485  ((myIndex == 0 || afterTeleport) && veh->moveRoutePointer())
486  // arrival on entering a new segment
487  || veh->hasArrived())) {
488  // route has ended
489  veh->setEventTime(time + TIME2STEPS(myLength / speed)); // for correct arrival speed
490  addReminders(veh);
492  updateDetectorsOnLeave(veh, time, 0);
494  return;
495  }
496  // route continues
497  const SUMOReal maxSpeedOnEdge = veh->getEdge()->getVehicleMaxSpeed(veh);
498  const SUMOReal uspeed = MAX2(maxSpeedOnEdge, MESO_MIN_SPEED);
499  int nextQueIndex = 0;
500  if (myCarQues.size() > 1) {
501  const MSEdge* succ = veh->succEdge(1);
502  // succ may be invalid if called from initialise() with an invalid route
503  if (succ != 0 && myFollowerMap.count(succ) > 0) {
504  const std::vector<int>& indices = myFollowerMap[succ];
505  nextQueIndex = indices[0];
506  for (std::vector<int>::const_iterator i = indices.begin() + 1; i != indices.end(); ++i) {
507  if (myCarQues[*i].size() < myCarQues[nextQueIndex].size()) {
508  nextQueIndex = *i;
509  }
510  }
511  }
512  }
513  std::vector<MEVehicle*>& cars = myCarQues[nextQueIndex];
514  MEVehicle* newLeader = 0; // first vehicle in the current queue
515  SUMOTime tleave = MAX2(time + TIME2STEPS(myLength / uspeed) + veh->getStoptime(this) + getTLSPenalty(veh), myBlockTimes[nextQueIndex]);
516  myEdge.lock();
517  if (cars.empty()) {
518  cars.push_back(veh);
519  newLeader = veh;
520  } else {
521  SUMOTime leaderOut = cars[0]->getEventTime();
522  if (!isDepart && leaderOut > tleave && overtake()) {
523  if (cars.size() == 1) {
525  newLeader = veh;
526  }
527  cars.insert(cars.begin() + 1, veh);
528  } else {
529  tleave = MAX2(leaderOut + myTau_ff, tleave);
530  cars.insert(cars.begin(), veh);
531  }
532  }
533  myEdge.unlock();
534  if (!isDepart) {
535  // regular departs could take place anywhere on the edge so they should not block regular flow
536  // the -1 facilitates interleaving of multiple streams
537  myEntryBlockTime = time + myTau_ff - 1;
538  }
539  veh->setEventTime(tleave);
540  veh->setSegment(this, nextQueIndex);
542  addReminders(veh);
543  if (isDepart) {
544  veh->onDepart();
546  } else if (myIndex == 0 || afterTeleport) {
548  } else {
550  }
551  if (newLeader != 0) {
552  MSGlobals::gMesoNet->addLeaderCar(newLeader, getLink(newLeader));
553  }
554 }
555 
556 
557 bool
559  MEVehicle* remove = 0;
560  for (Queues::const_iterator k = myCarQues.begin(); k != myCarQues.end(); ++k) {
561  if (!k->empty()) {
562  // remove last in queue
563  remove = k->front();
564  if (k->size() == 1) {
566  }
568  return true;
569  }
570  }
571  return false;
572 }
573 
574 
575 void
576 MESegment::setSpeedForQueue(SUMOReal newSpeed, SUMOTime currentTime, SUMOTime blockTime, const std::vector<MEVehicle*>& vehs) {
577  MEVehicle* v = vehs.back();
578  v->updateDetectors(currentTime, false);
579  SUMOTime newEvent = MAX2(newArrival(v, newSpeed, currentTime), blockTime);
580  if (v->getEventTime() != newEvent) {
582  v->setEventTime(newEvent);
584  }
585  for (std::vector<MEVehicle*>::const_reverse_iterator i = vehs.rbegin() + 1; i != vehs.rend(); ++i) {
586  (*i)->updateDetectors(currentTime, false);
587  newEvent = MAX2(newArrival(*i, newSpeed, currentTime), newEvent + myTau_ff);
588  //newEvent = MAX2(newArrival(*i, newSpeed, currentTime), newEvent + myTau_ff + (SUMOTime)((*(i - 1))->getVehicleType().getLength() / myTau_length));
589  (*i)->setEventTime(newEvent);
590  }
591 }
592 
593 
594 SUMOTime
595 MESegment::newArrival(const MEVehicle* const v, SUMOReal newSpeed, SUMOTime currentTime) {
596  // since speed is only an upper bound pos may be to optimistic
597  const SUMOReal pos = MIN2(myLength, STEPS2TIME(currentTime - v->getLastEntryTime()) * v->getSpeed());
598  // traveltime may not be 0
599  return currentTime + MAX2(TIME2STEPS((myLength - pos) / newSpeed), SUMOTime(1));
600 }
601 
602 
603 void
604 MESegment::setSpeed(SUMOReal newSpeed, SUMOTime currentTime, SUMOReal jamThresh) {
605  recomputeJamThreshold(jamThresh);
606  //myTau_length = MAX2(MESO_MIN_SPEED, newSpeed) * myEdge.getLanes().size() / TIME2STEPS(1);
607  for (int i = 0; i < (int)myCarQues.size(); ++i) {
608  if (myCarQues[i].size() != 0) {
609  setSpeedForQueue(newSpeed, currentTime, myBlockTimes[i], myCarQues[i]);
610  }
611  }
612 }
613 
614 
615 SUMOTime
617  SUMOTime result = SUMOTime_MAX;
618  for (int i = 0; i < (int)myCarQues.size(); ++i) {
619  if (myCarQues[i].size() != 0 && myCarQues[i].back()->getEventTime() < result) {
620  result = myCarQues[i].back()->getEventTime();
621  }
622  }
623  if (result < SUMOTime_MAX) {
624  return result;
625  }
626  return -1;
627 }
628 
629 
630 void
633  for (int i = 0; i < (int)myCarQues.size(); ++i) {
636  out.closeTag();
637  }
638  out.closeTag();
639 }
640 
641 
642 void
643 MESegment::loadState(std::vector<std::string>& vehIds, MSVehicleControl& vc, const SUMOTime block, const int queIdx) {
644  for (std::vector<std::string>::const_iterator it = vehIds.begin(); it != vehIds.end(); ++it) {
645  MEVehicle* v = static_cast<MEVehicle*>(vc.getVehicle(*it));
646  assert(v != 0);
647  assert(v->getSegment() == this);
648  myCarQues[queIdx].push_back(v);
650  }
651  if (myCarQues[queIdx].size() != 0) {
652  // add the last vehicle of this queue
653  // !!! one question - what about the previously added vehicle? Is it stored twice?
654  MEVehicle* veh = myCarQues[queIdx].back();
656  }
657  myBlockTimes[queIdx] = block;
659 }
660 
661 
662 std::vector<const MEVehicle*>
664  std::vector<const MEVehicle*> result;
665  for (Queues::const_iterator k = myCarQues.begin(); k != myCarQues.end(); ++k) {
666  result.insert(result.end(), k->begin(), k->end());
667  }
668  return result;
669 }
670 
671 
672 SUMOReal
674  return 3600 * getCarNumber() * getMeanSpeed() / myLength;
675 }
676 
677 
678 SUMOTime
680  const MSLink* link = getLink(veh, myTLSPenalty);
681  if (link != 0 && link->isTLSControlled()) {
682  // only apply to the last segment of a tls-controlled edge
683  return link->getMesoTLSPenalty();
684  } else {
685  return 0;
686  }
687 }
688 
689 /****************************************************************************/
OutputDevice & writeAttr(const SumoXMLAttr attr, const T &val)
writes a named attribute
Definition: OutputDevice.h:257
bool changeSegment(MEVehicle *veh, SUMOTime leaveTime, MESegment *const toSegment, const bool ignoreLink=false)
change to the next segment this handles combinations of the following cases: (ending / continuing rou...
Definition: MELoop.cpp:91
static MESegment myVaporizationTarget
Definition: MESegment.h:487
MSEdge & getEdge() const
Returns the lane&#39;s edge.
Definition: MSLane.h:567
virtual void setSegment(MESegment *s, int idx=0)
Sets the current segment the vehicle is at together with its que.
Definition: MEVehicle.h:204
long long int SUMOTime
Definition: SUMOTime.h:43
SUMOReal getFlow() const
returns flow based on headway
Definition: MESegment.cpp:673
const SUMOReal myCapacity
The number of lanes * the length.
Definition: MESegment.h:450
bool hasArrived() const
Returns whether this vehicle has already arived (reached the arrivalPosition on its final edge) ...
Definition: MEVehicle.cpp:159
std::vector< const MEVehicle * > getVehicles() const
returns all vehicles (for debugging)
Definition: MESegment.cpp:663
A vehicle from the mesoscopic point of view.
Definition: MEVehicle.h:52
MEVehicle * removeCar(MEVehicle *v, SUMOTime leaveTime, MESegment *next)
Removes the given car from the edge&#39;s que.
Definition: MESegment.cpp:334
SUMOReal jamThresholdForSpeed(SUMOReal speed, SUMOReal jamThresh) const
compute jam threshold for the given speed and jam-threshold option
Definition: MESegment.cpp:180
bool overtake()
Definition: MESegment.cpp:465
bool initialise(MEVehicle *veh, SUMOTime time)
Inserts (emits) vehicle into the segment.
Definition: MESegment.cpp:273
MESegment(const std::string &id, const MSEdge &parent, MESegment *next, SUMOReal length, SUMOReal speed, int idx, SUMOTime tauff, SUMOTime taufj, SUMOTime taujf, SUMOTime taujj, SUMOReal jamThresh, bool multiQueue, bool junctionControl, SUMOReal lengthGeometryFactor)
constructor
Definition: MESegment.cpp:71
bool limitedControlOverride(const MSLink *link) const
whether the given link may be passed because the option meso-junction-control.limited is set ...
Definition: MESegment.cpp:434
const std::vector< MSLane * > & getLanes() const
Returns this edge&#39;s lanes.
Definition: MSEdge.h:192
SUMOReal getLengthWithGap() const
Get vehicle&#39;s length including the minimum gap [m].
SUMOReal getImpatience() const
Returns this vehicles impatience.
The vehicle arrived at a junction.
virtual void lock() const
grant exclusive access to the mesoscopic state
Definition: MSEdge.h:655
SUMOTime getStoptime(const MESegment *const seg) const
Returns how long to stop at the given segment.
Definition: MEVehicle.cpp:242
SUMOTime myEntryBlockTime
Definition: MESegment.h:479
static const SUMOReal DO_NOT_PATCH_JAM_THRESHOLD
Definition: MESegment.h:375
SUMOTime getWaitingTime() const
Returns the duration for which the vehicle was blocked.
Definition: MEVehicle.h:260
SUMOReal length
The physical vehicle length.
SUMOReal getSpeed() const
Returns the vehicle&#39;s estimated speed assuming no delays.
Definition: MEVehicle.cpp:113
Notification
Definition of a vehicle state.
static SUMOReal rand()
Returns a random real number in [0, 1)
Definition: RandHelper.h:62
std::vector< MSMoveReminder * > myDetectorData
The data collection for all kinds of detectors.
Definition: MESegment.h:465
SUMOReal myOccupancy
The occupied space (in m) on the segment.
Definition: MESegment.h:453
static MSNet * getInstance()
Returns the pointer to the unique instance of MSNet (singleton).
Definition: MSNet.cpp:159
T MAX2(T a, T b)
Definition: StdDefs.h:75
SUMOTime getEventTime() const
Returns the (planned) time at which the vehicle leaves his current cell.
Definition: MEVehicle.h:195
SUMOReal getMeanSpeed() const
wrapper to satisfy the FunctionBinding signature
Definition: MESegment.h:207
SUMOTime newArrival(const MEVehicle *const v, SUMOReal newSpeed, SUMOTime currentTime)
compute the new arrival time when switching speed
Definition: MESegment.cpp:595
The vehicle got vaporized.
The vehicle changes the segment (meso only)
void setSpeedForQueue(SUMOReal newSpeed, SUMOTime currentTime, SUMOTime blockTime, const std::vector< MEVehicle * > &vehs)
Definition: MESegment.cpp:576
#define TIME2STEPS(x)
Definition: SUMOTime.h:66
SUMOTime getCurrentTimeStep() const
Returns the current simulation step.
Definition: MSNet.h:254
SUMOTime getLastEntryTime() const
Returns the time the vehicle entered the current segment.
Definition: MEVehicle.h:237
static bool gMesoOvertaking
Definition: MSGlobals.h:96
bool hasValidRoute(std::string &msg, const MSRoute *route=0) const
Validates the current or given route.
T MAX3(T a, T b, T c)
Definition: StdDefs.h:89
void setBlockTime(const SUMOTime t)
Sets the time at which the vehicle was blocked.
Definition: MEVehicle.h:245
The purpose of the edge is not known.
Definition: MSEdge.h:91
Queues myCarQues
The car queues. Vehicles are inserted in the front and removed in the back.
Definition: MESegment.h:468
const MSCFModel & getCarFollowModel() const
Returns the vehicle type&#39;s car following model definition (const version)
void loadState(std::vector< std::string > &vehIDs, MSVehicleControl &vc, const SUMOTime blockTime, const int queIdx)
Loads the state of this segment with the given parameters.
Definition: MESegment.cpp:643
void removeLeaderCar(MEVehicle *v)
Removes the given car from the leading vehicles.
Definition: MELoop.cpp:228
MSLink * getLink(const MEVehicle *veh, bool tlsPenalty=false) const
Returns the link the given car will use when passing the next junction.
Definition: MESegment.cpp:387
#define SUMOTime_MIN
Definition: SUMOTime.h:45
A road/street connecting two junctions.
Definition: MSEdge.h:80
const SUMOReal myHeadwayCapacity
The capacity of the segment in number of cars, used only in time headway calculation This parameter h...
Definition: MESegment.h:447
#define max(a, b)
Definition: polyfonts.c:65
void receive(MEVehicle *veh, SUMOTime time, bool isDepart=false, bool afterTeleport=false)
Adds the vehicle to the segment, adapting its parameters.
Definition: MESegment.cpp:478
void writeVehicles(OutputDevice &of) const
Definition: MESegment.cpp:324
static bool gCheckRoutes
Definition: MSGlobals.h:78
SUMOTime myLastMeanSpeedUpdate
the time at which myMeanSpeed was last updated
Definition: MESegment.h:493
std::map< const MSEdge *, std::vector< int > > myFollowerMap
The follower edge to que index mapping for multi queue segments.
Definition: MESegment.h:471
bool free() const
return whether this segment is considered free as opposed to jammed
Definition: MESegment.h:347
const SUMOTime myTau_jf
Definition: MESegment.h:438
static bool isInvalid(const MESegment *segment)
whether the given segment is 0 or encodes vaporization
Definition: MESegment.h:338
MSVehicleControl & getVehicleControl()
Returns the vehicle control.
Definition: MSNet.h:307
static MSEdge myDummyParent
Definition: MESegment.h:486
void setLastEntryTime(SUMOTime t)
Sets the entry time for the current segment.
Definition: MEVehicle.h:229
void updateDetectorsOnLeave(MEVehicle *v, SUMOTime currentTime, MESegment *next)
Updates data of all detectors for a leaving vehicle.
Definition: MESegment.cpp:220
The vehicle arrived at its destination (is deleted)
#define STEPS2TIME(x)
Definition: SUMOTime.h:65
SUMOReal myTau_length
Headway paramter for computing gross time headyway from net time heawdway, length and edge speed...
Definition: MESegment.h:440
int getNumSuccessors() const
Returns the number of edges that may be reached from this edge.
Definition: MSEdge.h:342
T MIN2(T a, T b)
Definition: StdDefs.h:69
const SUMOReal myLength
The segment&#39;s length.
Definition: MESegment.h:432
void addDetector(MSMoveReminder *data)
Adds a data collector for a detector to this segment.
Definition: MESegment.cpp:194
Something on a lane to be noticed about vehicle movement.
SUMOReal getMaxDecel() const
Get the vehicle type&#39;s maximum deceleration [m/s^2].
Definition: MSCFModel.h:186
bool vaporizeAnyCar(SUMOTime currentTime)
tries to remove any car from this segment
Definition: MESegment.cpp:558
SUMOReal myJamThreshold
The space (in m) which needs to be occupied before the segment is considered jammed.
Definition: MESegment.h:462
SUMOReal getSpeedLimit() const
Returns the speed limit of the edge The speed limit of the first lane is retured; should probably be...
Definition: MSEdge.cpp:762
void removeDetector(MSMoveReminder *data)
Removes a data collector for a detector from this segment.
Definition: MESegment.cpp:205
Base class for objects which have an id.
Definition: Named.h:46
bool isOpen(const MEVehicle *veh) const
Returns whether the vehicle may use the next link.
Definition: MESegment.cpp:418
SUMOTime getTLSPenalty(const MEVehicle *veh) const
Returns the penalty time for passing a tls-controlled link (if using gMesoTLSPenalty > 0) ...
Definition: MESegment.cpp:679
bool moveRoutePointer()
Update when the vehicle enters a new edge in the move step.
Definition: MEVehicle.cpp:145
const MSEdge & myEdge
The microsim edge this segment belongs to.
Definition: MESegment.h:426
SUMOReal myA
slope and axis offset for the jam-jam headway function
Definition: MESegment.h:443
const SUMOTime myTau_jj
Definition: MESegment.h:438
void setSpeed(SUMOReal newSpeed, SUMOTime currentTime, SUMOReal jamThresh=DO_NOT_PATCH_JAM_THRESHOLD)
reset mySpeed and patch the speed of all vehicles in it. Also set/recompute myJamThreshold ...
Definition: MESegment.cpp:604
The vehicle has departed (was inserted into the network)
void scheduleVehicleRemoval(SUMOVehicle *veh)
Removes a vehicle after it has ended.
const bool myTLSPenalty
Whether tls penalty is enabled.
Definition: MESegment.h:459
MESegment * myNextSegment
The next segment of this edge, 0 if this is the last segment of this edge.
Definition: MESegment.h:429
const MSEdge * succEdge(int nSuccs) const
Returns the nSuccs&#39;th successor of edge the vehicle is currently at.
#define SUMOTime_MAX
Definition: SUMOTime.h:44
virtual void unlock() const
release exclusive access to the mesoscopic state
Definition: MSEdge.h:658
SUMOReal myB
Definition: MESegment.h:443
SUMOTime getEventTime() const
Returns the (planned) time at which the next vehicle leaves this segment.
Definition: MESegment.cpp:616
virtual void activateReminders(const MSMoveReminder::Notification reason)
"Activates" all current move reminder
A single mesoscopic segment (cell)
Definition: MESegment.h:57
const std::vector< MSLane * > * allowedLanes(const MSEdge &destination, SUMOVehicleClass vclass=SVC_IGNORING) const
Get the allowed lanes to reach the destination-edge.
Definition: MSEdge.cpp:301
bool hasSpaceFor(const MEVehicle *veh, SUMOTime entryTime, bool init=false) const
Returns whether the given vehicle would still fit into the segment.
Definition: MESegment.cpp:250
void onDepart()
Called when the vehicle is inserted into the network.
void updateDetectors(SUMOTime currentTime, const bool isLeave, const MSMoveReminder::Notification reason=MSMoveReminder::NOTIFICATION_JUNCTION)
Updates all vehicle detectors.
Definition: MEVehicle.cpp:295
int getQueIndex() const
Returns the index of the que the vehicle is in.
Definition: MEVehicle.h:221
const MSVehicleType & getVehicleType() const
Returns the vehicle&#39;s type definition.
Definition: MSBaseVehicle.h:97
MESegment * getSegmentForEdge(const MSEdge &e, SUMOReal pos=0)
Get the segment for a given edge at a given position.
Definition: MELoop.cpp:295
static MELoop * gMesoNet
mesoscopic simulation infrastructure
Definition: MSGlobals.h:102
const bool myJunctionControl
Whether junction control is enabled.
Definition: MESegment.h:456
SUMOVehicle * getVehicle(const std::string &id) const
Returns the vehicle with the given id.
void setEventTime(SUMOTime t, bool hasDelay=true)
Sets the (planned) time at which the vehicle leaves his current cell.
Definition: MEVehicle.h:183
int getCarNumber() const
Returns the total number of cars on the segment.
Definition: MESegment.cpp:288
const SUMOReal myLengthGeometryFactor
Definition: MESegment.h:482
const SUMOTime myTau_fj
Definition: MESegment.h:438
Static storage of an output device and its base (abstract) implementation.
Definition: OutputDevice.h:71
bool closeTag()
Closes the most recently opened tag.
#define SUMOReal
Definition: config.h:213
void saveState(OutputDevice &out)
Saves the state of this segment into the given stream.
Definition: MESegment.cpp:631
const MSEdgeVector & getSuccessors() const
Returns the following edges.
Definition: MSEdge.h:349
SUMOTime getNextInsertionTime(SUMOTime earliestEntry) const
return a time after earliestEntry at which a vehicle may be inserted at full speed ...
Definition: MESegment.cpp:372
SUMOReal getVehicleMaxSpeed(const SUMOVehicle *const veh) const
Returns the maximum speed the vehicle may use on this edge.
Definition: MSEdge.cpp:769
const MSEdge * getEdge() const
Returns the edge the vehicle is currently at.
std::vector< SUMOTime > myBlockTimes
The block times.
Definition: MESegment.h:474
const MSLinkCont & getLinkCont() const
returns the container with all links !!!
Definition: MSLane.cpp:1445
The class responsible for building and deletion of vehicles.
void prepareDetectorForWriting(MSMoveReminder &data)
Updates data of a detector for all vehicle queues.
Definition: MESegment.cpp:236
static void writeVehicle(OutputDevice &of, const MSBaseVehicle &veh)
Writes the dump of the given vehicle into the given device.
void send(MEVehicle *veh, MESegment *next, SUMOTime time)
Removes the vehicle from the segment, adapting its parameters.
Definition: MESegment.cpp:447
#define DEFAULT_VEH_LENGHT_WITH_GAP
Definition: MESegment.cpp:57
static const SUMOVTypeParameter & getDefault()
return the default parameters, this is a function due to the http://www.parashift.com/c++-faq/static-init-order.html
SUMOReal myMeanSpeed
the mean speed on this segment. Updated at event time or on demand
Definition: MESegment.h:490
#define MESO_MIN_SPEED
Definition: MESegment.cpp:59
const int myIndex
Running number of the segment in the edge.
Definition: MESegment.h:435
void addReminder(MSMoveReminder *rem)
Adds a MoveReminder dynamically.
Representation of a lane in the micro simulation.
Definition: MSLane.h:79
const SUMOTime myTau_ff
The time headway parameters, see the Eissfeldt thesis.
Definition: MESegment.h:438
static bool gMesoLimitedJunctionControl
Definition: MSGlobals.h:93
void addLeaderCar(MEVehicle *veh, MSLink *link)
Adds the given car to the leading vehicles.
Definition: MELoop.cpp:208
void addReminders(MEVehicle *veh) const
add this lanes MoveReminders to the given vehicle
Definition: MESegment.cpp:471
MESegment * getSegment() const
Returns the current segment the vehicle is on.
Definition: MEVehicle.h:213
SUMOReal estimateLeaveSpeed(const MSLink *link) const
Returns the vehicle&#39;s estimated speed after driving accross the link.
Definition: MEVehicle.cpp:129
OutputDevice & openTag(const std::string &xmlElement)
Opens an XML tag.
void recomputeJamThreshold(SUMOReal jamThresh)
compute a value for myJamThreshold if jamThresh is negative, compute a value which allows free flow a...
Definition: MESegment.cpp:137
const std::string & getID() const
Returns the name of the vehicle.
SUMOTime getTimeHeadway(bool predecessorIsFree, SUMOReal leaderLength)
Definition: MESegment.cpp:356
SUMOReal minGap
This class&#39; free space in front of the vehicle itself.