LCOV - code coverage report
Current view: top level - src/mesosim - MESegment.cpp (source / functions) Coverage Total Hit
Test: lcov.info Lines: 99.3 % 405 402
Test Date: 2026-10-12 15:53:19 Functions: 97.6 % 41 40

            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    MESegment.cpp
      15              : /// @author  Daniel Krajzewicz
      16              : /// @date    Tue, May 2005
      17              : ///
      18              : // A single mesoscopic segment (cell)
      19              : /****************************************************************************/
      20              : #include <config.h>
      21              : 
      22              : #include <algorithm>
      23              : #include <limits>
      24              : #include <utils/common/StdDefs.h>
      25              : #include <microsim/MSGlobals.h>
      26              : #include <microsim/MSEdge.h>
      27              : #include <microsim/MSJunction.h>
      28              : #include <microsim/MSNet.h>
      29              : #include <microsim/MSLane.h>
      30              : #include <microsim/MSLink.h>
      31              : #include <microsim/MSMoveReminder.h>
      32              : #include <microsim/traffic_lights/MSTrafficLightLogic.h>
      33              : #include <microsim/traffic_lights/MSDriveWay.h>
      34              : #include <microsim/traffic_lights/MSRailSignalControl.h>
      35              : #include <microsim/output/MSXMLRawOut.h>
      36              : #include <microsim/output/MSDetectorFileOutput.h>
      37              : #include <microsim/MSVehicleControl.h>
      38              : #include <microsim/devices/MSDevice.h>
      39              : #include <utils/common/FileHelpers.h>
      40              : #include <utils/common/MsgHandler.h>
      41              : #include <utils/iodevices/OutputDevice.h>
      42              : #include <utils/common/RandHelper.h>
      43              : #include "MEVehicle.h"
      44              : #include "MELoop.h"
      45              : #include "MESegment.h"
      46              : 
      47              : #define DEFAULT_VEH_LENGTH_WITH_GAP (SUMOVTypeParameter::getDefault().length + SUMOVTypeParameter::getDefault().minGap)
      48              : // avoid division by zero when driving very slowly
      49              : #define MESO_MIN_SPEED (0.05)
      50              : 
      51              : //#define DEBUG_OPENED
      52              : //#define DEBUG_JAMTHRESHOLD
      53              : //#define DEBUG_COND (getID() == "blocker")
      54              : //#define DEBUG_COND (true)
      55              : #define DEBUG_COND (myEdge.isSelected())
      56              : #define DEBUG_COND2(obj) ((obj != 0 && (obj)->isSelected()))
      57              : 
      58              : 
      59              : // ===========================================================================
      60              : // static member definition
      61              : // ===========================================================================
      62              : MSEdge MESegment::myDummyParent("MESegmentDummyParent", -1, SumoXMLEdgeFunc::UNKNOWN, "", "", "", -1, 0);
      63              : MESegment MESegment::myVaporizationTarget("vaporizationTarget");
      64              : SVCPermissions MESegment::myMultiModalWarnings(0);
      65              : const double MESegment::DO_NOT_PATCH_JAM_THRESHOLD(std::numeric_limits<double>::max());
      66              : const std::string MESegment::OVERRIDE_TLS_PENALTIES("meso.tls.control");
      67              : 
      68              : 
      69              : // ===========================================================================
      70              : // MESegment::Queue method definitions
      71              : // ===========================================================================
      72              : MEVehicle*
      73     26773496 : MESegment::Queue::remove(MEVehicle* v) {
      74     26773496 :     myOccupancy -= v->getVehicleType().getLengthWithGap();
      75              :     assert(std::find(myVehicles.begin(), myVehicles.end(), v) != myVehicles.end());
      76     26773496 :     if (v == myVehicles.back()) {
      77              :         myVehicles.pop_back();
      78     26767191 :         if (myVehicles.empty()) {
      79      8471752 :             myOccupancy = 0.;
      80              :         } else {
      81     18295439 :             return myVehicles.back();
      82              :         }
      83              :     } else {
      84         6305 :         myVehicles.erase(std::find(myVehicles.begin(), myVehicles.end(), v));
      85              :     }
      86              :     return nullptr;
      87              : }
      88              : 
      89              : void
      90       132502 : MESegment::Queue::addDetector(MSMoveReminder* data) {
      91       132502 :     myDetectorData.push_back(data);
      92       138252 :     for (MEVehicle* const v : myVehicles) {
      93         5750 :         v->addReminder(data);
      94              :     }
      95       132502 : }
      96              : 
      97              : void
      98     26816156 : MESegment::Queue::addReminders(MEVehicle* veh) const {
      99     36521620 :     for (MSMoveReminder* rem : myDetectorData) {
     100      9705464 :         veh->addReminder(rem);
     101              :     }
     102     26816156 : }
     103              : 
     104              : // ===========================================================================
     105              : // MESegment method definitions
     106              : // ===========================================================================
     107       727403 : MESegment::MESegment(const std::string& id,
     108              :                      const MSEdge& parent, MESegment* next,
     109              :                      const double length, const double speed,
     110              :                      const int idx,
     111              :                      const bool multiQueue,
     112       727403 :                      const MesoEdgeType& edgeType):
     113       727403 :     Named(id), myEdge(parent), myNextSegment(next),
     114       727403 :     myLength(length), myIndex(idx),
     115       727403 :     myTau_length(TIME2STEPS(1) / MAX2(MESO_MIN_SPEED, speed)),
     116       727403 :     myNumVehicles(0),
     117       727403 :     myLastHeadway(TIME2STEPS(-1)),
     118       727403 :     myMeanSpeed(speed),
     119      1454461 :     myLastMeanSpeedUpdate(SUMOTime_MIN) {
     120              : 
     121              :     const std::vector<MSLane*>& lanes = parent.getLanes();
     122              :     int usableLanes = 0;
     123              :     SVCPermissions maxAllow = 0;
     124       727403 :     SVCPermissions minAllow = SVCAll;
     125      1580231 :     for (MSLane* const l : lanes) {
     126       852828 :         const SVCPermissions allow = MSEdge::getMesoPermissions(l->getPermissions());
     127       852828 :         if (multiQueue) {
     128       111152 :             myQueues.push_back(Queue(allow));
     129              :         }
     130       852828 :         if (allow != 0) {
     131       799547 :             usableLanes++;
     132       799547 :             maxAllow |= allow;
     133       799547 :             minAllow &= allow;
     134              :         }
     135              :     }
     136       727403 :     if (usableLanes == 0) {
     137              :         // cars won't drive here. Give sensible tau values capacity for the ignored classes
     138              :         usableLanes = 1;
     139              :     }
     140       727403 :     if (multiQueue) {
     141        23701 :         if (next == nullptr) {
     142       110053 :             for (const MSEdge* const edge : parent.getSuccessors()) {
     143        86705 :                 if (edge->isTazConnector()) {
     144          284 :                     continue;
     145              :                 }
     146        86421 :                 const std::vector<MSLane*>* const allowed = parent.allowedLanes(*edge);
     147              :                 assert(allowed != nullptr);
     148              :                 assert(allowed->size() > 0);
     149       180811 :                 for (MSLane* const l : *allowed) {
     150        94390 :                     std::vector<MSLane*>::const_iterator it = std::find(lanes.begin(), lanes.end(), l);
     151        94390 :                     myFollowerMap[edge] |= (1 << distance(lanes.begin(), it));
     152              :                 }
     153              :             }
     154              :         }
     155        23701 :         myQueueCapacity = length;
     156              :     } else {
     157       703702 :         myQueues.push_back(Queue(parent.getPermissions()));
     158       703702 :         maxAllow &= ~minAllow;
     159       703702 :         if ((maxAllow & ~myMultiModalWarnings) != 0) {
     160          164 :             WRITE_WARNINGF("Mismodelled capacity on edge '%'. Not all lanes are usable by vClass '%'. Use option --meso-lane-queue or add unused class to option --meso-ignore-lanes-by-vclass.",
     161              :                     myEdge.getID(), getVehicleClassNames(maxAllow & ~myMultiModalWarnings));
     162           41 :             myMultiModalWarnings |= maxAllow;
     163              :         }
     164              :     }
     165              : 
     166       727403 :     initSegment(edgeType, parent, length * usableLanes);
     167       727403 : }
     168              : 
     169              : void
     170       727403 : MESegment::initSegment(const MesoEdgeType& edgeType, const MSEdge& parent, const double capacity) {
     171              : 
     172       727403 :     myCapacity = capacity;
     173       727403 :     if (myQueues.size() == 1) {
     174       704176 :         const double laneScale = capacity / myLength;
     175       704176 :         myQueueCapacity = capacity;
     176       704176 :         myTau_length = TIME2STEPS(1) / MAX2(MESO_MIN_SPEED, myMeanSpeed) / laneScale;
     177              :         // Eissfeldt p. 90 and 151 ff.
     178       704176 :         myTau_ff = (SUMOTime)((double)edgeType.tauff / laneScale);
     179       704176 :         myTau_fj = (SUMOTime)((double)edgeType.taufj / laneScale);
     180       704176 :         myTau_jf = (SUMOTime)((double)edgeType.taujf / laneScale);
     181       704176 :         myTau_jj = (SUMOTime)((double)edgeType.taujj / laneScale);
     182              :     } else {
     183        23227 :         myTau_ff = edgeType.tauff;
     184        23227 :         myTau_fj = edgeType.taufj;
     185        23227 :         myTau_jf = edgeType.taujf;
     186        23227 :         myTau_jj = edgeType.taujj;
     187              :     }
     188              : 
     189       727403 :     myJunctionControl = myNextSegment == nullptr && (edgeType.junctionControl || MELoop::isEnteringRoundabout(parent));
     190       726627 :     myTLSPenalty = ((edgeType.tlsPenalty > 0 || edgeType.tlsFlowPenalty > 0) &&
     191              :                     // only apply to the last segment of a tls-controlled edge
     192       727763 :                     myNextSegment == nullptr && (
     193          298 :                         parent.getToJunction()->getType() == SumoXMLNodeType::TRAFFIC_LIGHT ||
     194          298 :                         parent.getToJunction()->getType() == SumoXMLNodeType::TRAFFIC_LIGHT_NOJUNCTION ||
     195              :                         parent.getToJunction()->getType() == SumoXMLNodeType::TRAFFIC_LIGHT_RIGHT_ON_RED));
     196              : 
     197              :     // only apply to the last segment of an uncontrolled edge that has at least 1 minor link
     198      1455126 :     myCheckMinorPenalty = (edgeType.minorPenalty > 0 &&
     199          320 :                            myNextSegment == nullptr &&
     200              :                            parent.getToJunction()->getType() != SumoXMLNodeType::TRAFFIC_LIGHT &&
     201              :                            parent.getToJunction()->getType() != SumoXMLNodeType::TRAFFIC_LIGHT_NOJUNCTION &&
     202       727581 :                            parent.getToJunction()->getType() != SumoXMLNodeType::TRAFFIC_LIGHT_RIGHT_ON_RED &&
     203          178 :                            parent.hasMinorLink());
     204       727403 :     myMinorPenalty = edgeType.minorPenalty;
     205       727403 :     myOvertaking = edgeType.overtaking && myCapacity > myLength;
     206              : 
     207              :     //std::cout << getID() << " myMinorPenalty=" << myMinorPenalty << " myTLSPenalty=" << myTLSPenalty << " myJunctionControl=" << myJunctionControl << " myOvertaking=" << myOvertaking << "\n";
     208              : 
     209       727403 :     recomputeJamThreshold(edgeType.jamThreshold);
     210       727403 : }
     211              : 
     212        46389 : MESegment::MESegment(const std::string& id):
     213              :     Named(id),
     214        46389 :     myEdge(myDummyParent), // arbitrary edge needed to supply the needed reference
     215        46389 :     myNextSegment(nullptr), myLength(0), myIndex(0),
     216        46389 :     myTau_ff(0), myTau_fj(0), myTau_jf(0), myTau_jj(0),
     217        46389 :     myTLSPenalty(false),
     218        46389 :     myCheckMinorPenalty(false),
     219        46389 :     myMinorPenalty(0),
     220        46389 :     myJunctionControl(false),
     221        46389 :     myOvertaking(false),
     222        46389 :     myTau_length(1) {
     223        46389 : }
     224              : 
     225              : 
     226              : void
     227         1922 : MESegment::updatePermissions() {
     228         1922 :     if (myQueues.size() > 1) {
     229           82 :         for (MSLane* lane : myEdge.getLanes()) {
     230           60 :             myQueues[lane->getIndex()].setPermissions(lane->getPermissions());
     231              :         }
     232              :     } else {
     233         1900 :         myQueues.back().setPermissions(myEdge.getPermissions());
     234              :     }
     235         1922 : }
     236              : 
     237              : 
     238              : void
     239       728451 : MESegment::recomputeJamThreshold(double jamThresh) {
     240       728451 :     if (jamThresh == DO_NOT_PATCH_JAM_THRESHOLD) {
     241              :         return;
     242              :     }
     243       728451 :     if (jamThresh < 0) {
     244              :         // compute based on speed
     245       728435 :         myJamThreshold = jamThresholdForSpeed(myEdge.getSpeedLimit(), jamThresh);
     246              :     } else {
     247              :         // compute based on specified percentage
     248           16 :         myJamThreshold = jamThresh * myCapacity;
     249              :     }
     250              : }
     251              : 
     252              : 
     253              : double
     254      4909762 : MESegment::jamThresholdForSpeed(double speed, double jamThresh) const {
     255              :     // vehicles driving freely at maximum speed should not jam
     256              :     // we compute how many vehicles could possible enter the segment until the first vehicle leaves
     257              :     // and multiply by the space these vehicles would occupy
     258              :     // the jamThresh parameter is scale the resulting value
     259      4909762 :     if (speed == 0) {
     260              :         return std::numeric_limits<double>::max();  // never jam. Irrelevant at speed 0 anyway
     261              :     }
     262              : #ifdef DEBUG_JAMTHRESHOLD
     263              :     if (true || DEBUG_COND) {
     264              :         std::cout << "jamThresholdForSpeed seg=" << getID() << " speed=" << speed << " jamThresh=" << jamThresh << " ffVehs=" << std::ceil(myLength / (-jamThresh * speed * STEPS2TIME(tauWithVehLength(myTau_ff, DEFAULT_VEH_LENGTH_WITH_GAP)))) << " thresh=" << std::ceil(myLength / (-jamThresh * speed * STEPS2TIME(tauWithVehLength(myTau_ff, DEFAULT_VEH_LENGTH_WITH_GAP)))) * DEFAULT_VEH_LENGTH_WITH_GAP
     265              :                   << "\n";
     266              :     }
     267              : #endif
     268      4909543 :     return std::ceil(myLength / (-jamThresh * speed * STEPS2TIME(tauWithVehLength(myTau_ff, DEFAULT_VEH_LENGTH_WITH_GAP, 1.)))) * DEFAULT_VEH_LENGTH_WITH_GAP;
     269              : }
     270              : 
     271              : 
     272              : void
     273       129084 : MESegment::addDetector(MSMoveReminder* data, int queueIndex) {
     274       129084 :     if (queueIndex == -1) {
     275       254992 :         for (Queue& q : myQueues) {
     276       129205 :             q.addDetector(data);
     277              :         }
     278              :     } else {
     279              :         assert(queueIndex < (int)myQueues.size());
     280         3297 :         myQueues[queueIndex].addDetector(data);
     281              :     }
     282       129084 : }
     283              : 
     284              : 
     285              : /*
     286              : void
     287              : MESegment::removeDetector(MSMoveReminder* data) {
     288              :     std::vector<MSMoveReminder*>::iterator it = std::find(myDetectorData.begin(), myDetectorData.end(), data);
     289              :     if (it != myDetectorData.end()) {
     290              :         myDetectorData.erase(it);
     291              :     }
     292              :     for (const Queue& q : myQueues) {
     293              :         for (MEVehicle* const v : q.getVehicles()) {
     294              :             v->removeReminder(data);
     295              :         }
     296              :     }
     297              : }
     298              : */
     299              : 
     300              : 
     301              : void
     302      6428950 : MESegment::prepareDetectorForWriting(MSMoveReminder& data, int queueIndex) {
     303      6428950 :     const SUMOTime currentTime = MSNet::getInstance()->getCurrentTimeStep();
     304      6428950 :     if (queueIndex == -1) {
     305     12884412 :         for (const Queue& q : myQueues) {
     306              :             SUMOTime earliestExitTime = currentTime;
     307      7763959 :             for (std::vector<MEVehicle*>::const_reverse_iterator i = q.getVehicles().rbegin(); i != q.getVehicles().rend(); ++i) {
     308      1307897 :                 const SUMOTime exitTime = MAX2(earliestExitTime, (*i)->getEventTime());
     309      1307897 :                 (*i)->updateDetectorForWriting(&data, currentTime, exitTime);
     310      1307897 :                 earliestExitTime = exitTime + tauWithVehLength(myTau_ff, (*i)->getVehicleType().getLengthWithGap(), (*i)->getVehicleType().getCarFollowModel().getHeadwayTime());
     311              :             }
     312              :         }
     313              :     } else {
     314              :         SUMOTime earliestExitTime = currentTime;
     315          612 :         for (std::vector<MEVehicle*>::const_reverse_iterator i = myQueues[queueIndex].getVehicles().rbegin(); i != myQueues[queueIndex].getVehicles().rend(); ++i) {
     316           12 :             const SUMOTime exitTime = MAX2(earliestExitTime, (*i)->getEventTime());
     317           12 :             (*i)->updateDetectorForWriting(&data, currentTime, exitTime);
     318           12 :             earliestExitTime = exitTime + tauWithVehLength(myTau_ff, (*i)->getVehicleType().getLengthWithGap(), (*i)->getVehicleType().getCarFollowModel().getHeadwayTime());
     319              :         }
     320              :     }
     321      6428950 : }
     322              : 
     323              : 
     324              : SUMOTime
     325    621192487 : MESegment::hasSpaceFor(const MEVehicle* const veh, const SUMOTime entryTime, int& qIdx, const bool init) const {
     326              :     SUMOTime earliestEntry = SUMOTime_MAX;
     327    621192487 :     qIdx = 0;
     328    621192487 :     if (myNumVehicles == 0 && myQueues.size() == 1) {
     329              :         // we have always space for at least one vehicle
     330    518563466 :         if (myQueues.front().allows(veh->getVClass())) {
     331              :             return entryTime;
     332              :         }  else {
     333              :             return earliestEntry;
     334              :         }
     335              :     }
     336    102629021 :     const SUMOVehicleClass svc = veh->getVClass();
     337              :     int minSize = std::numeric_limits<int>::max();
     338    104132787 :     const MSEdge* const succ = myNextSegment == nullptr ? veh->succEdge(veh->getEdge() == &myEdge ? 1 : 2) : nullptr;
     339    277856260 :     for (int i = 0; i < (int)myQueues.size(); i++) {
     340    175227239 :         const Queue& q = myQueues[i];
     341    175227239 :         const double newOccupancy = q.size() == 0 ? 0. : q.getOccupancy() + veh->getVehicleType().getLengthWithGap();
     342    175227239 :         if (newOccupancy <= myQueueCapacity) { // we must ensure that occupancy remains below capacity
     343     60690262 :             if (succ == nullptr || myFollowerMap.count(succ) == 0 || ((myFollowerMap.find(succ)->second & (1 << i)) != 0)) {
     344     41767610 :                 if (q.allows(svc) && q.size() < minSize) {
     345     26579279 :                     if (init) {
     346              :                         // regular insertions and initial insertions must respect different constraints:
     347      8179530 :                         if (veh->getInsertionChecks() == (int)InsertionCheck::NONE || hasSpaceForInsertion(q, i, newOccupancy, entryTime)) {
     348      4938172 :                             qIdx = i;
     349              :                             minSize = q.size();
     350              :                         }
     351     18399749 :                     } else if (entryTime >= q.getEntryBlockTime()) {
     352     18129900 :                         qIdx = i;
     353              :                         minSize = q.size();
     354              :                     } else {
     355              :                         earliestEntry = MIN2(earliestEntry, q.getEntryBlockTime());
     356              :                     }
     357              :                 }
     358              :             }
     359              :         }
     360              :     }
     361    102629021 :     if (minSize == std::numeric_limits<int>::max()) {
     362              :         return earliestEntry;
     363              :     }
     364              :     return entryTime;
     365              : }
     366              : 
     367              : 
     368              : bool
     369      8179486 : MESegment::hasSpaceForInsertion(const Queue& q, int /*qIdx*/, double newOccupancy, SUMOTime /*entryTime*/) const {
     370              :     // - regular insertions must respect entryBlockTime
     371              :     // - initial insertions should not cause additional jamming
     372              :     // - inserted vehicle should be able to continue at the current speed
     373      8179486 :     if (q.getOccupancy() <= myJamThreshold && !hasBlockedLeader() && !myTLSPenalty) {
     374      3998159 :         return newOccupancy <= myJamThreshold;
     375              :     } else {
     376      4181327 :         return newOccupancy <= jamThresholdForSpeed(getMeanSpeed(false), -1);
     377              :     }
     378              : }
     379              : 
     380              : 
     381              : bool
     382      2765544 : MESegment::initialise(MEVehicle* veh, SUMOTime time) {
     383      2765544 :     int qIdx = 0;
     384      2765544 :     if (hasSpaceFor(veh, time, qIdx, true) == time) {
     385       866965 :         const bool isRail = veh->isRail();
     386              :         // see MSLane::isInsertionSuccess
     387        24921 :         if (isRail && veh->getInsertionChecks() != (int)InsertionCheck::NONE
     388        24902 :                 && veh->getParameter().departProcedure != DepartDefinition::SPLIT
     389        24902 :                 && MSRailSignalControl::isSignalized(veh->getVClass())
     390       891858 :                 && isRailwayOrShared(myEdge.getPermissions())) {
     391        24887 :             const MSDriveWay* dw = MSDriveWay::getDepartureDriveway(veh);
     392              :             MSEdgeVector occupied;
     393        24887 :             if (dw->foeDriveWayOccupied(false, veh, occupied)) {
     394        22688 :                 myEdge.getLanes()[0]->setParameter("insertionBlocked:" + veh->getID(), dw->getID());
     395              :                 return false;
     396              :             }
     397        24887 :         }
     398       844277 :         receive(veh, qIdx, time, true);
     399       844277 :         if (isRail) {
     400         4466 :             myEdge.getLanes()[0]->unsetParameter("insertionConstraint:" + veh->getID());
     401              :             //unsetParameter("insertionOrder:" + veh->getID());
     402              :             //unsetParameter("insertionBlocked:" + veh->getID());
     403              :             //// rail_signal (not traffic_light) requires approach information for
     404              :             //// switching correctly at the start of the next simulation step
     405              :             //if (firstRailSignal != nullptr && firstRailSignal->getJunction()->getType() == SumoXMLNodeType::RAIL_SIGNAL) {
     406              :             //    veh->registerInsertionApproach(firstRailSignal, firstRailSignalDist);
     407              :             //}
     408              :         }
     409       844277 :         return true;
     410              :     }
     411              :     return false;
     412              : }
     413              : 
     414              : 
     415              : double
     416     29771960 : MESegment::getMeanSpeed(bool useCached) const {
     417     29771960 :     const SUMOTime currentTime = MSNet::getInstance()->getCurrentTimeStep();
     418     29771960 :     if (currentTime != myLastMeanSpeedUpdate || !useCached) {
     419     29669554 :         myLastMeanSpeedUpdate = currentTime;
     420              :         double v = 0;
     421              :         int count = 0;
     422     61508648 :         for (const Queue& q : myQueues) {
     423     31839094 :             const SUMOTime tau = q.getOccupancy() < myJamThreshold ? myTau_ff : myTau_jf;
     424     31839094 :             SUMOTime earliestExitTime = currentTime;
     425     31839094 :             count += q.size();
     426    185589494 :             for (std::vector<MEVehicle*>::const_reverse_iterator veh = q.getVehicles().rbegin(); veh != q.getVehicles().rend(); ++veh) {
     427    153750400 :                 v += (*veh)->getConservativeSpeed(earliestExitTime); // earliestExitTime is updated!
     428    153750400 :                 earliestExitTime += tauWithVehLength(tau, (*veh)->getVehicleType().getLengthWithGap(), (*veh)->getVehicleType().getCarFollowModel().getHeadwayTime());
     429              :             }
     430              :         }
     431     29669554 :         if (count == 0) {
     432           30 :             myMeanSpeed = myEdge.getSpeedLimit();
     433              :         } else {
     434     29669524 :             myMeanSpeed = v / (double) count;
     435              :         }
     436              :     }
     437     29771960 :     return myMeanSpeed;
     438              : }
     439              : 
     440              : 
     441              : void
     442         5226 : MESegment::resetCachedSpeeds() {
     443         5226 :     myLastMeanSpeedUpdate = SUMOTime_MIN;
     444         5226 : }
     445              : 
     446              : void
     447        11953 : MESegment::writeVehicles(OutputDevice& of) const {
     448        24082 :     for (const Queue& q : myQueues) {
     449        14162 :         for (const MEVehicle* const veh : q.getVehicles()) {
     450         2033 :             MSXMLRawOut::writeVehicle(of, *veh);
     451              :         }
     452              :     }
     453        11953 : }
     454              : 
     455              : 
     456              : MEVehicle*
     457     26773496 : MESegment::removeCar(MEVehicle* v, SUMOTime leaveTime, const MSMoveReminder::Notification reason) {
     458     26773496 :     Queue& q = myQueues[v->getQueIndex()];
     459              :     // One could be tempted to do  v->setSegment(next); here but position on lane will be invalid if next == 0
     460     26773496 :     v->updateDetectors(leaveTime, v->getEventTime(), true, reason);
     461     26773496 :     myNumVehicles--;
     462     26773496 :     myEdge.lock();
     463     26773496 :     MEVehicle* nextLeader = q.remove(v);
     464     26773496 :     myEdge.invalidateMesoCache();
     465     26773496 :     myEdge.unlock();
     466     26773496 :     return nextLeader;
     467              : }
     468              : 
     469              : 
     470              : SUMOTime
     471        13691 : MESegment::getNextInsertionTime(SUMOTime earliestEntry) const {
     472              :     // since we do not know which queue will be used we give a conservative estimate
     473              :     SUMOTime earliestLeave = earliestEntry;
     474              :     SUMOTime latestEntry = -1;
     475        27647 :     for (const Queue& q : myQueues) {
     476              :         earliestLeave = MAX2(earliestLeave, q.getBlockTime());
     477              :         latestEntry = MAX2(latestEntry, q.getEntryBlockTime());
     478              :     }
     479        13691 :     if (myEdge.getSpeedLimit() == 0) {
     480           12 :         return MAX2(earliestEntry, latestEntry);    // FIXME: This line is just an adhoc-fix to avoid division by zero (Leo)
     481              :     } else {
     482        13679 :         return MAX3(earliestEntry, earliestLeave - TIME2STEPS(myLength / myEdge.getSpeedLimit()), latestEntry);
     483              :     }
     484              : }
     485              : 
     486              : 
     487              : MSLink*
     488    621270968 : MESegment::getLink(const MEVehicle* veh, bool penalty) const {
     489    621270968 :     if (myJunctionControl || penalty) {
     490    518487664 :         const MSEdge* const nextEdge = veh->succEdge(1);
     491    518487664 :         if (nextEdge == nullptr || veh->getQueIndex() == PARKING_QUEUE) {
     492              :             return nullptr;
     493              :         }
     494              :         // try to find any link leading to our next edge, start with the lane pointed to by the que index
     495    517135761 :         const MSLane* const bestLane = myEdge.getLanes()[veh->getQueIndex()];
     496   1219599650 :         for (MSLink* const link : bestLane->getLinkCont()) {
     497   1217798770 :             if (&link->getLane()->getEdge() == nextEdge) {
     498              :                 return link;
     499              :             }
     500              :         }
     501              :         // this is for the non-multique case, maybe we should use caching here !!!
     502      5112543 :         for (const MSLane* const lane : myEdge.getLanes()) {
     503      3710924 :             if (lane != bestLane) {
     504      6240155 :                 for (MSLink* const link : lane->getLinkCont()) {
     505      4727046 :                     if (&link->getLane()->getEdge() == nextEdge) {
     506              :                         return link;
     507              :                     }
     508              :                 }
     509              :             }
     510              :         }
     511              :     }
     512              :     return nullptr;
     513              : }
     514              : 
     515              : 
     516              : bool
     517     26997904 : MESegment::isOpen(const MEVehicle* veh) const {
     518              : #ifdef DEBUG_OPENED
     519              :     if (DEBUG_COND || DEBUG_COND2(veh)) {
     520              :         gDebugFlag1 = true;
     521              :         std::cout << SIMTIME << " opened seg=" << getID() << " veh=" << Named::getIDSecure(veh)
     522              :                   << " tlsPenalty=" << myTLSPenalty;
     523              :         const MSLink* link = getLink(veh);
     524              :         if (link == 0) {
     525              :             std::cout << " link=0";
     526              :         } else {
     527              :             std::cout << " prio=" << link->havePriority()
     528              :                       << " override=" << limitedControlOverride(link)
     529              :                       << " isOpen=" << link->opened(veh->getEventTime(), veh->getSpeed(), veh->estimateLeaveSpeed(link),
     530              :                                                     veh->getVehicleType().getLengthWithGap(), veh->getImpatience(),
     531              :                                                     veh->getVehicleType().getCarFollowModel().getMaxDecel(), veh->getWaitingTime(),
     532              :                                                     0, nullptr, false, veh)
     533              :                       << " et=" << veh->getEventTime()
     534              :                       << " v=" << veh->getSpeed()
     535              :                       << " vLeave=" << veh->estimateLeaveSpeed(link)
     536              :                       << " impatience=" << veh->getImpatience()
     537              :                       << " tWait=" << veh->getWaitingTime();
     538              :         }
     539              :         std::cout << "\n";
     540              :         gDebugFlag1 = false;
     541              :     }
     542              : #endif
     543     26997904 :     if (myTLSPenalty) {
     544              :         // XXX should limited control take precedence over tls penalty?
     545              :         return true;
     546              :     }
     547     26945756 :     const MSLink* link = getLink(veh);
     548              :     return (link == nullptr
     549      3095641 :             || link->havePriority()
     550      1334375 :             || limitedControlOverride(link)
     551     28278943 :             || link->opened(veh->getEventTime(), veh->getSpeed(), veh->estimateLeaveSpeed(link),
     552      1333187 :                             veh->getVehicleType().getLengthWithGap(), veh->getImpatience(),
     553      1333187 :                             veh->getVehicleType().getCarFollowModel().getMaxDecel(), veh->getWaitingTime(),
     554              :                             0, nullptr, false, veh));
     555              : }
     556              : 
     557              : 
     558              : bool
     559      1338587 : MESegment::limitedControlOverride(const MSLink* link) const {
     560              :     assert(link != nullptr);
     561      1338587 :     if (!MSGlobals::gMesoLimitedJunctionControl) {
     562              :         return false;
     563              :     }
     564              :     // if the target segment of this link is not saturated junction control is disabled
     565              :     const MSEdge& targetEdge = link->getLane()->getEdge();
     566        11236 :     const MESegment* target = MSGlobals::gMesoNet->getSegmentForEdge(targetEdge);
     567        11236 :     return (target->getBruttoOccupancy() * 2 < target->myJamThreshold) && !targetEdge.isRoundabout();
     568              : }
     569              : 
     570              : 
     571              : SUMOTime
     572     25967770 : MESegment::computeHeadway(Queue& /*q*/, const Queue& qNext, const MESegment* const next, const MEVehicle* veh) const {
     573     25967770 :     const bool nextFree = qNext.getOccupancy() <= next->myJamThreshold;
     574              :     const SUMOTime tau = (!veh->wasJammed()
     575     25967770 :             ? (nextFree ? myTau_ff : myTau_fj)
     576       720880 :             : (nextFree ? myTau_jf : getTauJJ((double)qNext.size(), next->myQueueCapacity, next->myJamThreshold)));
     577              :     assert(tau >= 0);
     578     25967770 :     SUMOTime headway = tauWithVehLength(tau, veh->getVehicleType().getLengthWithGap(), veh->getVehicleType().getCarFollowModel().getHeadwayTime());
     579     25967770 :     if (myTLSPenalty) {
     580        52148 :         const MSLink* const tllink = getLink(veh, true);
     581        52148 :         if (tllink != nullptr && tllink->isTLSControlled()) {
     582              :             assert(tllink->getGreenFraction() > 0);
     583        49540 :             headway = (SUMOTime)((double)headway / tllink->getGreenFraction());
     584              :         }
     585              :     }
     586     25967770 :     return headway;
     587              : }
     588              : 
     589              : 
     590              : void
     591     26773496 : MESegment::send(MEVehicle* veh, MESegment* const next, const int nextQIdx, SUMOTime time, const MSMoveReminder::Notification reason) {
     592     26773496 :     Queue& q = myQueues[veh->getQueIndex()];
     593              :     assert(isInvalid(next) || time >= q.getBlockTime());
     594     26773496 :     MSLink* const link = getLink(veh);
     595     26773496 :     if (link != nullptr) {
     596      2076356 :         link->removeApproaching(veh);
     597              :     }
     598     26773496 :     if (veh->isStopped()) {
     599         8434 :         veh->processStop();
     600              :     }
     601     26773496 :     MEVehicle* lc = removeCar(veh, time, reason); // new leaderCar
     602              :     q.setBlockTime(time);
     603     26773496 :     if (myEdge.isNormal() && myCapacity >= 22.5 ) {
     604     20480837 :         veh->markJammed(q.getOccupancy() > myJamThreshold);
     605              :     }
     606              :     if (!isInvalid(next)) {
     607     25967770 :         myLastHeadway = computeHeadway(q, next->myQueues[nextQIdx], next, veh);
     608     25967770 :         q.setBlockTime(time + myLastHeadway);
     609              :     }
     610     26773496 :     if (lc != nullptr) {
     611              :         lc->setEventTime(MAX2(lc->getEventTime(), q.getBlockTime()));
     612     18295439 :         MSGlobals::gMesoNet->addLeaderCar(lc, getLink(lc));
     613              :     }
     614     26773496 : }
     615              : 
     616              : 
     617              : SUMOTime
     618       189079 : MESegment::getTauJJ(double nextQueueSize, double nextQueueCapacity, double nextJamThreshold) const {
     619              :     // compute coefficients for the jam-jam headway function
     620              :     // this function models the effect that "empty space" needs to move
     621              :     // backwards through the downstream segment before the upstream segment may
     622              :     // send annother vehicle.
     623              :     // this allows jams to clear and move upstream.
     624              :     // the headway function f(x) depends on the number of vehicles in the
     625              :     // downstream segment x
     626              :     // f is a linear function that passes through the following fixed points:
     627              :     // f(n_jam_threshold) = tau_jf_withLength (for continuity)
     628              :     // f(headwayCapacity) = myTau_jj * headwayCapacity
     629              : 
     630       189079 :     const SUMOTime tau_jf_withLength = tauWithVehLength(myTau_jf, DEFAULT_VEH_LENGTH_WITH_GAP, 1.);
     631              :     // number of vehicles that fit into the NEXT queue (could be larger than expected with DEFAULT_VEH_LENGTH_WITH_GAP!)
     632       189079 :     const double headwayCapacity = MAX2(nextQueueSize, nextQueueCapacity / DEFAULT_VEH_LENGTH_WITH_GAP);
     633              :     // number of vehicles above which the NEXT queue is jammed
     634       189079 :     const double n_jam_threshold = headwayCapacity * nextJamThreshold / nextQueueCapacity;
     635              : 
     636              :     // slope a and axis offset b for the jam-jam headway function
     637              :     // solving f(x) = a * x + b
     638       189079 :     const double a = (STEPS2TIME(myTau_jj) * headwayCapacity - STEPS2TIME(tau_jf_withLength)) / (headwayCapacity - n_jam_threshold);
     639       189079 :     const double b = headwayCapacity * (STEPS2TIME(myTau_jj) - a);
     640              : 
     641              :     // it is only well defined for nextQueueSize >= n_jam_threshold (which may not be the case for longer vehicles), so we take the MAX
     642       189079 :     return TIME2STEPS(a * MAX2(nextQueueSize, n_jam_threshold) + b);
     643              : }
     644              : 
     645              : 
     646              : bool
     647      1213208 : MESegment::overtake() {
     648      1213232 :     return myOvertaking && RandHelper::rand() > (getBruttoOccupancy() / myCapacity);
     649              : }
     650              : 
     651              : 
     652              : void
     653     26821961 : MESegment::addReminders(MEVehicle* veh) const {
     654     26821961 :     if (veh->getQueIndex() != PARKING_QUEUE) {
     655     26816156 :         myQueues[veh->getQueIndex()].addReminders(veh);
     656              :     }
     657     26821961 : }
     658              : 
     659              : 
     660              : void
     661     26818375 : MESegment::receive(MEVehicle* veh, const int qIdx, SUMOTime time, const bool isDepart, const bool isTeleport, const bool newEdge) {
     662     26818375 :     const double speed = isDepart ? -1 : MAX2(veh->getSpeed(), MESO_MIN_SPEED); // on the previous segment
     663     26818375 :     veh->setSegment(this); // for arrival checking
     664              :     veh->setLastEntryTime(time);
     665              :     veh->setBlockTime(SUMOTime_MAX);
     666     26818375 :     if (!isDepart && (
     667              :                 // arrival on entering a new edge
     668      5072308 :                 (newEdge && myEdge.isNormal() && veh->moveRoutePointer())
     669              :                 // arrival on entering a new segment
     670     25973939 :                 || veh->hasArrived())) {
     671              :         // route has ended
     672        15412 :         veh->setEventTime(time + TIME2STEPS(myLength / speed)); // for correct arrival speed
     673        15412 :         addReminders(veh);
     674        15412 :         veh->activateReminders(MSMoveReminder::NOTIFICATION_JUNCTION);
     675        30720 :         veh->updateDetectors(time, veh->getEventTime(), true,
     676        15412 :                              veh->getEdge()->isVaporizing() ? MSMoveReminder::NOTIFICATION_VAPORIZED_VAPORIZER : MSMoveReminder::NOTIFICATION_ARRIVED);
     677        15412 :         MSNet::getInstance()->getVehicleControl().scheduleVehicleRemoval(veh);
     678        15412 :         return;
     679              :     }
     680              :     assert(veh->getEdge() == &getEdge() || getEdge().isInternal());
     681              :     // route continues
     682     26802963 :     Queue& q = myQueues[qIdx];
     683     26802963 :     const double maxSpeedOnEdge = veh->getEdge()->getLanes()[qIdx]->getVehicleMaxSpeed(veh);
     684              :     const double uspeed = MAX2(maxSpeedOnEdge, MESO_MIN_SPEED);
     685              :     std::vector<MEVehicle*>& cars = q.getModifiableVehicles();
     686              :     MEVehicle* newLeader = nullptr; // first vehicle in the current queue
     687     26802963 :     const SUMOTime stopTime = veh->checkStop(time);
     688     26802963 :     SUMOTime tleave = MAX2(stopTime + TIME2STEPS(myLength / uspeed) + getLinkPenalty(veh), q.getBlockTime());
     689     26802963 :     if (veh->isStopped()) {
     690        14981 :         myEdge.addWaiting(veh);
     691              :     }
     692     26802963 :     if (veh->isParking()) {
     693              :         // parking stops should take at least 1ms
     694         5805 :         veh->setEventTime(MAX2(stopTime, veh->getEventTime() + 1));
     695         5805 :         veh->setSegment(this, PARKING_QUEUE);
     696         5805 :         myEdge.getLanes()[0]->addParking(veh);  // TODO for GUI only
     697              :     } else {
     698     26797158 :         myEdge.lock();
     699     26797158 :         if (cars.empty()) {
     700      8478542 :             cars.push_back(veh);
     701              :             newLeader = veh;
     702              :         } else {
     703     18318616 :             SUMOTime leaderOut = cars[0]->getEventTime();
     704     18318616 :             if (!isDepart && leaderOut > tleave && overtake()) {
     705           20 :                 if (cars.size() == 1) {
     706            4 :                     MSGlobals::gMesoNet->removeLeaderCar(cars[0]);
     707              :                     newLeader = veh;
     708              :                 }
     709           20 :                 cars.insert(cars.begin() + 1, veh);
     710              :             } else {
     711     18318596 :                 tleave = MAX2(leaderOut + tauWithVehLength(myTau_ff, cars[0]->getVehicleType().getLengthWithGap(), cars[0]->getVehicleType().getCarFollowModel().getHeadwayTime()), tleave);
     712     18318596 :                 cars.insert(cars.begin(), veh);
     713              :             }
     714              :         }
     715     26797158 :         myEdge.invalidateMesoCache();
     716     26797158 :         myEdge.unlock();
     717     26797158 :         myNumVehicles++;
     718     26797158 :         if (!isDepart && !isTeleport) {
     719              :             // departs and teleports could take place anywhere on the edge so they should not block regular flow
     720              :             // the -1 facilitates interleaving of multiple streams
     721     25952280 :             q.setEntryBlockTime(time + tauWithVehLength(myTau_ff, veh->getVehicleType().getLengthWithGap(), veh->getVehicleType().getCarFollowModel().getHeadwayTime()) - 1);
     722              :         }
     723     26797158 :         q.setOccupancy(MIN2(myQueueCapacity, q.getOccupancy() + veh->getVehicleType().getLengthWithGap()));
     724              :         veh->setEventTime(tleave);
     725              :         veh->setUnqueuedEventTime(tleave);
     726     26797158 :         veh->setSegment(this, qIdx);
     727              :     }
     728     26802963 :     addReminders(veh);
     729     26802963 :     if (isDepart) {
     730       844277 :         veh->onDepart();
     731       844277 :         veh->activateReminders(MSMoveReminder::NOTIFICATION_DEPARTED);
     732     25958686 :     } else if (newEdge) {
     733      5072149 :         veh->activateReminders(MSMoveReminder::NOTIFICATION_JUNCTION);
     734              :     } else {
     735     20886537 :         veh->activateReminders(MSMoveReminder::NOTIFICATION_SEGMENT);
     736              :     }
     737     26802963 :     if (veh->isParking()) {
     738         5825 :         MSGlobals::gMesoNet->addLeaderCar(veh, nullptr);
     739              :     } else {
     740     26797138 :         if (newLeader != nullptr) {
     741      8478528 :             MSGlobals::gMesoNet->addLeaderCar(newLeader, getLink(newLeader));
     742              :         }
     743              :     }
     744              : }
     745              : 
     746              : 
     747              : bool
     748         8778 : MESegment::vaporizeAnyCar(SUMOTime currentTime, const MSDetectorFileOutput* filter) {
     749         9330 :     for (const Queue& q : myQueues) {
     750         8804 :         if (q.size() > 0) {
     751         8252 :             for (MEVehicle* const veh : q.getVehicles()) {
     752         8252 :                 if (filter->vehicleApplies(*veh)) {
     753         8252 :                     MSGlobals::gMesoNet->removeLeaderCar(veh);
     754         8252 :                     MSGlobals::gMesoNet->changeSegment(veh, currentTime + 1, &myVaporizationTarget, MSMoveReminder::NOTIFICATION_VAPORIZED_CALIBRATOR);
     755              :                     return true;
     756              :                 }
     757              :             }
     758              :         }
     759              :     }
     760              :     return false;
     761              : }
     762              : 
     763              : 
     764              : void
     765          352 : MESegment::setSpeedForQueue(double newSpeed, SUMOTime currentTime, SUMOTime blockTime, const std::vector<MEVehicle*>& vehs) {
     766          352 :     MEVehicle* v = vehs.back();
     767              :     SUMOTime oldEarliestExitTime = currentTime;
     768              :     const SUMOTime oldExit = MAX2(oldEarliestExitTime, v->getEventTime());
     769          352 :     v->updateDetectors(currentTime, oldExit, false);
     770          352 :     oldEarliestExitTime = oldExit + tauWithVehLength(myTau_ff, v->getVehicleType().getLengthWithGap(), v->getVehicleType().getCarFollowModel().getHeadwayTime());
     771          352 :     SUMOTime newEvent = MAX2(newArrival(v, newSpeed, currentTime), blockTime);
     772          352 :     if (v->getEventTime() != newEvent) {
     773          332 :         MSGlobals::gMesoNet->removeLeaderCar(v);
     774              :         v->setEventTime(newEvent);
     775          332 :         MSGlobals::gMesoNet->addLeaderCar(v, getLink(v));
     776              :     }
     777         1077 :     for (std::vector<MEVehicle*>::const_reverse_iterator i = vehs.rbegin() + 1; i != vehs.rend(); ++i) {
     778          725 :         const SUMOTime oldExitTime = MAX2(oldEarliestExitTime, (*i)->getEventTime());
     779          725 :         (*i)->updateDetectors(currentTime, oldExitTime, false);
     780          725 :         const SUMOTime minTau = tauWithVehLength(myTau_ff, (*i)->getVehicleType().getLengthWithGap(), (*i)->getVehicleType().getCarFollowModel().getHeadwayTime());
     781          725 :         oldEarliestExitTime = oldExitTime + minTau;
     782          725 :         newEvent = MAX2(newArrival(*i, newSpeed, currentTime), newEvent + minTau);
     783          725 :         (*i)->setEventTime(newEvent);
     784              :     }
     785          352 : }
     786              : 
     787              : 
     788              : SUMOTime
     789         1077 : MESegment::newArrival(const MEVehicle* const v, double newSpeed, SUMOTime currentTime) {
     790              :     // since speed is only an upper bound, pos may be too optimistic
     791         1077 :     const double pos = MIN2(myLength, STEPS2TIME(currentTime - v->getLastEntryTime()) * v->getSpeed());
     792              :     // traveltime may not be 0
     793         1104 :     double tt = (myLength - pos) / MAX2(newSpeed, MESO_MIN_SPEED);
     794         1077 :     return currentTime + MAX2(TIME2STEPS(tt), SUMOTime(1));
     795              : }
     796              : 
     797              : 
     798              : void
     799         1048 : MESegment::setSpeed(double newSpeed, SUMOTime currentTime, double jamThresh, int qIdx) {
     800         1048 :     recomputeJamThreshold(jamThresh);
     801              :     //myTau_length = MAX2(MESO_MIN_SPEED, newSpeed) * myEdge.getLanes().size() / TIME2STEPS(1);
     802              :     int i = 0;
     803         2194 :     for (const Queue& q : myQueues) {
     804         1146 :         if (q.size() != 0) {
     805          386 :             if (qIdx == -1 || qIdx == i) {
     806          352 :                 setSpeedForQueue(newSpeed, currentTime, q.getBlockTime(), q.getVehicles());
     807              :             }
     808              :         }
     809         1146 :         i++;
     810              :     }
     811         1048 : }
     812              : 
     813              : 
     814              : SUMOTime
     815    510729472 : MESegment::getEventTime() const {
     816              :     SUMOTime result = SUMOTime_MAX;
     817   1021862736 :     for (const Queue& q : myQueues) {
     818    511133264 :         if (q.size() != 0 && q.getVehicles().back()->getEventTime() < result) {
     819              :             result = q.getVehicles().back()->getEventTime();
     820              :         }
     821              :     }
     822    510729472 :     if (result < SUMOTime_MAX) {
     823      2175282 :         return result;
     824              :     }
     825              :     return -1;
     826              : }
     827              : 
     828              : 
     829              : void
     830        11928 : MESegment::saveState(OutputDevice& out) const {
     831              :     bool write = false;
     832        23063 :     for (const Queue& q : myQueues) {
     833        12407 :         if (q.getBlockTime() != -1 || !q.getVehicles().empty()) {
     834              :             write = true;
     835              :             break;
     836              :         }
     837              :     }
     838        11928 :     if (write) {
     839         1272 :         out.openTag(SUMO_TAG_SEGMENT).writeAttr(SUMO_ATTR_ID, getID());
     840         2602 :         for (const Queue& q : myQueues) {
     841         1330 :             out.openTag(SUMO_TAG_VIEWSETTINGS_VEHICLES);
     842         1330 :             out.writeAttr(SUMO_ATTR_TIME, toString<SUMOTime>(q.getBlockTime()));
     843         1330 :             out.writeAttr(SUMO_ATTR_BLOCKTIME, toString<SUMOTime>(q.getEntryBlockTime()));
     844         1330 :             out.writeAttr(SUMO_ATTR_VALUE, q.getVehicles());
     845         2660 :             out.closeTag();
     846              :         }
     847         2544 :         out.closeTag();
     848              :     }
     849        11928 : }
     850              : 
     851              : 
     852              : void
     853          398 : MESegment::clearState() {
     854          836 :     for (Queue& q : myQueues) {
     855              :         q.getModifiableVehicles().clear();
     856              :     }
     857          398 : }
     858              : 
     859              : void
     860         1161 : MESegment::loadState(const std::vector<SUMOVehicle*>& vehs, const SUMOTime blockTime, const SUMOTime entryBlockTime, const int queIdx) {
     861         1161 :     Queue& q = myQueues[queIdx];
     862         1657 :     for (SUMOVehicle* veh : vehs) {
     863          496 :         MEVehicle* v = static_cast<MEVehicle*>(veh);
     864              :         assert(v->getSegment() == this || myEdge.isInternal());
     865          496 :         if (myEdge.isInternal()) {
     866           15 :             v->setSegment(this, v->getQueIndex());
     867              :         }
     868          496 :         q.getModifiableVehicles().push_back(v);
     869          496 :         myNumVehicles++;
     870          496 :         q.setOccupancy(q.getOccupancy() + v->getVehicleType().getLengthWithGap());
     871          496 :         addReminders(v);
     872              :     }
     873         1161 :     if (q.size() != 0) {
     874              :         // add the last vehicle of this queue
     875              :         // !!! one question - what about the previously added vehicle? Is it stored twice?
     876          257 :         MEVehicle* veh = q.getVehicles().back();
     877          257 :         MSGlobals::gMesoNet->addLeaderCar(veh, getLink(veh));
     878              :     }
     879              :     q.setBlockTime(blockTime);
     880              :     q.setEntryBlockTime(entryBlockTime);
     881         1161 :     q.setOccupancy(MIN2(q.getOccupancy(), myQueueCapacity));
     882         1161 : }
     883              : 
     884              : 
     885              : std::vector<const MEVehicle*>
     886          122 : MESegment::getVehicles() const {
     887              :     std::vector<const MEVehicle*> result;
     888          316 :     for (const Queue& q : myQueues) {
     889          194 :         result.insert(result.end(), q.getVehicles().begin(), q.getVehicles().end());
     890              :     }
     891          122 :     return result;
     892            0 : }
     893              : 
     894              : 
     895              : bool
     896      4032441 : MESegment::hasBlockedLeader() const {
     897      8116115 :     for (const Queue& q : myQueues) {
     898      4117682 :         if (q.size() > 0 && q.getVehicles().back()->getWaitingTime() > 0) {
     899              :             return true;
     900              :         }
     901              :     }
     902              :     return false;
     903              : }
     904              : 
     905              : 
     906              : double
     907            0 : MESegment::getFlow() const {
     908            0 :     return 3600 * getCarNumber() * getMeanSpeed() / myLength;
     909              : }
     910              : 
     911              : 
     912              : SUMOTime
     913     26802963 : MESegment::getLinkPenalty(const MEVehicle* veh) const {
     914     26802963 :     const MSLink* link = getLink(veh, myTLSPenalty || myCheckMinorPenalty);
     915     26802963 :     if (link != nullptr) {
     916              :         SUMOTime result = 0;
     917      2131234 :         if (link->isTLSControlled() && myTLSPenalty) {
     918              :             result += link->getMesoTLSPenalty();
     919              :         }
     920              :         // minor tls links may get an additional penalty
     921       419661 :         if (!link->havePriority() &&
     922              :                 // do not apply penalty on top of tLSPenalty
     923      2131234 :                 !myTLSPenalty &&
     924              :                 // do not apply penalty if limited control is active
     925       383761 :                 (!MSGlobals::gMesoLimitedJunctionControl || limitedControlOverride(link))) {
     926       380639 :             result += myMinorPenalty;
     927              :         }
     928      2131234 :         return result;
     929              :     } else {
     930              :         return 0;
     931              :     }
     932              : }
     933              : 
     934              : 
     935              : double
     936            9 : MESegment::getWaitingSeconds() const {
     937              :     double result = 0;
     938           22 :     for (const Queue& q : myQueues) {
     939              :         // @note: only the leader currently accumulates waitingTime but this might change in the future
     940           16 :         for (const MEVehicle* veh : q.getVehicles()) {
     941            3 :             result += veh->getWaitingSeconds();
     942              :         }
     943              :     }
     944            9 :     return result;
     945              : }
     946              : 
     947              : 
     948              : /****************************************************************************/
        

Generated by: LCOV version 2.0-1