LCOV - code coverage report
Current view: top level - src/microsim/output - MSMeanData.cpp (source / functions) Coverage Total Hit
Test: lcov.info Lines: 96.6 % 414 400
Test Date: 2026-10-12 15:53:19 Functions: 89.7 % 39 35

            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    MSMeanData.cpp
      15              : /// @author  Daniel Krajzewicz
      16              : /// @author  Jakob Erdmann
      17              : /// @author  Michael Behrisch
      18              : /// @author  Laura Bieker
      19              : /// @author  Leonhard Luecken
      20              : /// @date    Mon, 10.05.2004
      21              : ///
      22              : // Data collector for edges/lanes
      23              : /****************************************************************************/
      24              : #include <config.h>
      25              : 
      26              : #include <limits>
      27              : #ifdef HAVE_FOX
      28              : #include <utils/common/ScopedLocker.h>
      29              : #endif
      30              : #include <utils/common/SUMOTime.h>
      31              : #include <utils/common/ToString.h>
      32              : #include <utils/common/StringTokenizer.h>
      33              : #include <utils/iodevices/OutputDevice.h>
      34              : #include <microsim/MSEdgeControl.h>
      35              : #include <microsim/MSEdge.h>
      36              : #include <microsim/MSLane.h>
      37              : #include <microsim/MSVehicle.h>
      38              : #include <microsim/cfmodels/MSCFModel.h>
      39              : #include <microsim/MSNet.h>
      40              : #include "MSMeanData_Amitran.h"
      41              : #include "MSMeanData.h"
      42              : 
      43              : #include <microsim/MSGlobals.h>
      44              : #include <mesosim/MESegment.h>
      45              : #include <mesosim/MELoop.h>
      46              : 
      47              : 
      48              : // ===========================================================================
      49              : // debug constants
      50              : // ===========================================================================
      51              : //#define DEBUG_NOTIFY_MOVE
      52              : //#define DEBUG_NOTIFY_ENTER
      53              : 
      54              : // ===========================================================================
      55              : // method definitions
      56              : // ===========================================================================
      57              : // ---------------------------------------------------------------------------
      58              : // MSMeanData::MeanDataValues - methods
      59              : // ---------------------------------------------------------------------------
      60      9155607 : MSMeanData::MeanDataValues::MeanDataValues(
      61              :     MSLane* const lane, const double length, const bool doAdd,
      62      9155607 :     const MSMeanData* const parent) :
      63     18311214 :     MSMoveReminder("meandata_" + (parent == nullptr ? "" : parent->getID() + "|") + (lane == nullptr ? "NULL" :  lane->getID()), lane, doAdd),
      64      9155607 :     myParent(parent),
      65      9155607 :     myLaneLength(length),
      66      9155607 :     sampleSeconds(0),
      67     27466821 :     travelledDistance(0) { }
      68              : 
      69              : 
      70      9154313 : MSMeanData::MeanDataValues::~MeanDataValues() {
      71      9154313 : }
      72              : 
      73              : 
      74              : bool
      75       692910 : MSMeanData::MeanDataValues::notifyEnter(SUMOTrafficObject& veh, MSMoveReminder::Notification reason, const MSLane* enteredLane) {
      76              : #ifdef DEBUG_NOTIFY_ENTER
      77              :     std::cout << "\n" << SIMTIME << " MSMeanData_Net::MSLaneMeanDataValues: veh '" << veh.getID() << "' enters lane '" << enteredLane->getID() << "'" << std::endl;
      78              : #else
      79              :     UNUSED_PARAMETER(enteredLane);
      80              : #endif
      81              :     UNUSED_PARAMETER(reason);
      82       692910 :     return myParent == nullptr || myParent->vehicleApplies(veh);
      83              : }
      84              : 
      85              : 
      86              : bool
      87    484010234 : MSMeanData::MeanDataValues::notifyMove(SUMOTrafficObject& veh, double oldPos, double newPos, double newSpeed) {
      88              :     // if the vehicle has arrived, the reminder must be kept so it can be
      89              :     // notified of the arrival subsequently
      90    484010234 :     const double oldSpeed = veh.getPreviousSpeed();
      91    484010234 :     double enterSpeed = MSGlobals::gSemiImplicitEulerUpdate ? newSpeed : oldSpeed; // NOTE: For the euler update, the vehicle is assumed to travel at constant speed for the whole time step
      92              :     double leaveSpeed = newSpeed, leaveSpeedFront = newSpeed;
      93              : 
      94              :     // These values will be further decreased below
      95    484010234 :     double timeOnLane = TS;
      96    484010234 :     double frontOnLane = oldPos > myLaneLength ? 0. : TS;
      97              :     bool ret = true;
      98              : 
      99              :     // entry and exit times (will be modified below)
     100              :     double timeBeforeEnter = 0.;
     101              :     double timeBeforeEnterBack = 0.;
     102    484010234 :     double timeBeforeLeaveFront = newPos <= myLaneLength ? TS : 0.;
     103              :     double timeBeforeLeave = TS;
     104              : 
     105              :     // Treat the case that the vehicle entered the lane in the last step
     106    484010234 :     if (oldPos < 0 && newPos >= 0) {
     107              :         // Vehicle was not on this lane in the last time step
     108     11272482 :         timeBeforeEnter = MSCFModel::passingTime(oldPos, 0, newPos, oldSpeed, newSpeed);
     109     11272482 :         timeOnLane = TS - timeBeforeEnter;
     110              :         frontOnLane = timeOnLane;
     111     11272482 :         enterSpeed = MSCFModel::speedAfterTime(timeBeforeEnter, oldSpeed, newPos - oldPos);
     112              :     }
     113              : 
     114    484010234 :     const double oldBackPos = oldPos - veh.getVehicleType().getLength();
     115    484010234 :     const double newBackPos = newPos - veh.getVehicleType().getLength();
     116              : 
     117              :     // Determine the time before the vehicle back enters
     118    484010234 :     if (oldBackPos < 0. && newBackPos > 0.) {
     119     11553428 :         timeBeforeEnterBack = MSCFModel::passingTime(oldBackPos, 0., newBackPos, oldSpeed, newSpeed);
     120    472456806 :     } else if (newBackPos <= 0) {
     121      7971130 :         timeBeforeEnterBack = TS;
     122              :     } else {
     123              :         timeBeforeEnterBack = 0.;
     124              :     }
     125              : 
     126              :     // Treat the case that the vehicle's back left the lane in the last step
     127    484010234 :     if (newBackPos > myLaneLength // vehicle's back has left the lane
     128     13006306 :             && oldBackPos <= myLaneLength) { // and hasn't left the lane before
     129              :         assert(!MSGlobals::gSemiImplicitEulerUpdate || newSpeed != 0); // how could it move across the lane boundary otherwise
     130              :         // (Leo) vehicle left this lane (it can also have skipped over it in one time step -> therefore we use "timeOnLane -= ..." and ( ... - timeOnLane) below)
     131     13006096 :         timeBeforeLeave = MSCFModel::passingTime(oldBackPos, myLaneLength, newBackPos, oldSpeed, newSpeed);
     132     13006096 :         const double timeAfterLeave = TS - timeBeforeLeave;
     133     13006096 :         timeOnLane -= timeAfterLeave;
     134     13006096 :         leaveSpeed = MSCFModel::speedAfterTime(timeBeforeLeave, oldSpeed, newPos - oldPos);
     135              :         // XXX: Do we really need this? Why would this "reduce rounding errors"? (Leo) Refs. #2579
     136     13006096 :         if (fabs(timeOnLane) < NUMERICAL_EPS) { // reduce rounding errors
     137              :             timeOnLane = 0.;
     138              :         }
     139     13006096 :         ret = veh.hasArrived();
     140              :     }
     141              : 
     142              :     // Treat the case that the vehicle's front left the lane in the last step
     143    484010234 :     if (newPos > myLaneLength && oldPos <= myLaneLength) {
     144              :         // vehicle's front has left the lane and has not left before
     145              :         assert(!MSGlobals::gSemiImplicitEulerUpdate || newSpeed != 0);
     146     14216073 :         timeBeforeLeaveFront = MSCFModel::passingTime(oldPos, myLaneLength, newPos, oldSpeed, newSpeed);
     147     14216073 :         const double timeAfterLeave = TS - timeBeforeLeaveFront;
     148     14216073 :         frontOnLane -= timeAfterLeave;
     149              :         // XXX: Do we really need this? Why would this "reduce rounding errors"? (Leo) Refs. #2579
     150     14216073 :         if (fabs(frontOnLane) < NUMERICAL_EPS) { // reduce rounding errors
     151              :             frontOnLane = 0.;
     152              :         }
     153     14216073 :         leaveSpeedFront = MSCFModel::speedAfterTime(timeBeforeLeaveFront, oldSpeed, newPos - oldPos);
     154              :     }
     155              : 
     156              :     assert(frontOnLane <= TS);
     157              :     assert(timeOnLane <= TS);
     158              : 
     159    484010234 :     if (timeOnLane < 0) {
     160            0 :         WRITE_ERRORF(TL("Negative vehicle step fraction for '%' on lane '%'."), veh.getID(), getLane()->getID());
     161            0 :         return veh.hasArrived();
     162              :     }
     163    484010234 :     if (timeOnLane == 0) {
     164        22013 :         return veh.hasArrived();
     165              :     }
     166              : 
     167              : #ifdef DEBUG_NOTIFY_MOVE
     168              :     std::stringstream ss;
     169              :     ss << "\n"
     170              :        << "lane length: " << myLaneLength
     171              :        << "\noldPos: " << oldPos
     172              :        << "\nnewPos: " << newPos
     173              :        << "\noldPosBack: " << oldBackPos
     174              :        << "\nnewPosBack: " << newBackPos
     175              :        << "\ntimeBeforeEnter: " << timeBeforeEnter
     176              :        << "\ntimeBeforeEnterBack: " << timeBeforeEnterBack
     177              :        << "\ntimeBeforeLeaveFront: " << timeBeforeLeaveFront
     178              :        << "\ntimeBeforeLeave: " << timeBeforeLeave;
     179              :     if (!(timeBeforeLeave >= MAX2(timeBeforeEnterBack, timeBeforeLeaveFront))
     180              :             || !(timeBeforeEnter <= MIN2(timeBeforeEnterBack, timeBeforeLeaveFront))) {
     181              :         WRITE_ERROR(ss.str());
     182              :     } else {
     183              :         std::cout << ss.str() << std::endl;
     184              :     }
     185              : 
     186              : #endif
     187              : 
     188              :     assert(timeBeforeEnter <= MIN2(timeBeforeEnterBack, timeBeforeLeaveFront));
     189              :     assert(timeBeforeLeave >= MAX2(timeBeforeEnterBack, timeBeforeLeaveFront));
     190              :     // compute average vehicle length on lane in last step
     191    483988221 :     double vehLength = veh.getVehicleType().getLength();
     192              :     // occupied lane length at timeBeforeEnter (resp. stepStart if already on lane)
     193    483988221 :     double lengthOnLaneAtStepStart = MAX2(0., MIN4(myLaneLength, vehLength, vehLength - (oldPos - myLaneLength), oldPos));
     194              :     // occupied lane length at timeBeforeLeave (resp. stepEnd if still on lane)
     195    483988221 :     double lengthOnLaneAtStepEnd = MAX2(0., MIN4(myLaneLength, vehLength, vehLength - (newPos - myLaneLength), newPos));
     196              :     double integratedLengthOnLane = 0.;
     197    483988221 :     if (timeBeforeEnterBack < timeBeforeLeaveFront) {
     198              :         // => timeBeforeLeaveFront>0, myLaneLength>vehLength
     199              :         // vehicle length on detector at timeBeforeEnterBack
     200    468042847 :         double lengthOnLaneAtBackEnter = MIN2(veh.getVehicleType().getLength(), newPos);
     201              :         // linear quadrature of occupancy between timeBeforeEnter and timeBeforeEnterBack
     202    468042847 :         integratedLengthOnLane += (timeBeforeEnterBack - timeBeforeEnter) * (lengthOnLaneAtBackEnter + lengthOnLaneAtStepStart) * 0.5;
     203              :         // linear quadrature of occupancy between timeBeforeEnterBack and timeBeforeLeaveFront
     204              :         // (vehicle is completely on the edge in between)
     205    468042847 :         integratedLengthOnLane += (timeBeforeLeaveFront - timeBeforeEnterBack) * vehLength;
     206              :         // and until vehicle leaves/stepEnd
     207    468042847 :         integratedLengthOnLane += (timeBeforeLeave - timeBeforeLeaveFront) * (vehLength + lengthOnLaneAtStepEnd) * 0.5;
     208     15945374 :     } else if (timeBeforeEnterBack >= timeBeforeLeaveFront) {
     209              :         // => myLaneLength <= vehLength or (timeBeforeLeaveFront == timeBeforeEnterBack == 0)
     210              :         // vehicle length on detector at timeBeforeLeaveFront
     211              :         double lengthOnLaneAtLeaveFront;
     212     15945374 :         if (timeBeforeLeaveFront == timeBeforeEnter) {
     213              :             // for the case that front already left
     214              :             lengthOnLaneAtLeaveFront = lengthOnLaneAtStepStart;
     215      7995728 :         } else if (timeBeforeLeaveFront == timeBeforeLeave) {
     216              :             // for the case that front doesn't leave in this step
     217              :             lengthOnLaneAtLeaveFront = lengthOnLaneAtStepEnd;
     218              :         } else {
     219              :             lengthOnLaneAtLeaveFront = myLaneLength;
     220              :         }
     221              : #ifdef DEBUG_NOTIFY_MOVE
     222              :         std::cout << "lengthOnLaneAtLeaveFront=" << lengthOnLaneAtLeaveFront << std::endl;
     223              : #endif
     224              :         // linear quadrature of occupancy between timeBeforeEnter and timeBeforeLeaveFront
     225     15945374 :         integratedLengthOnLane += (timeBeforeLeaveFront - timeBeforeEnter) * (lengthOnLaneAtLeaveFront + lengthOnLaneAtStepStart) * 0.5;
     226              :         // linear quadrature of occupancy between timeBeforeLeaveFront and timeBeforeEnterBack
     227     15945374 :         integratedLengthOnLane += (timeBeforeEnterBack - timeBeforeLeaveFront) * lengthOnLaneAtLeaveFront;
     228              :         // and until vehicle leaves/stepEnd
     229     15945374 :         integratedLengthOnLane += (timeBeforeLeave - timeBeforeEnterBack) * (lengthOnLaneAtLeaveFront + lengthOnLaneAtStepEnd) * 0.5;
     230              :     }
     231              : 
     232    483988221 :     double meanLengthOnLane = integratedLengthOnLane / TS;
     233              : #ifdef DEBUG_NOTIFY_MOVE
     234              :     std::cout << "Calculated mean length on lane '" << myLane->getID() << "' in last step as " << meanLengthOnLane
     235              :               << "\nlengthOnLaneAtStepStart=" << lengthOnLaneAtStepStart << ", lengthOnLaneAtStepEnd=" << lengthOnLaneAtStepEnd << ", integratedLengthOnLane=" << integratedLengthOnLane
     236              :               << std::endl;
     237              : #endif
     238              : 
     239              : //    // XXX: use this, when #2556 is fixed! Refs. #2575
     240              : //    const double travelledDistanceFrontOnLane = MAX2(0., MIN2(newPos, myLaneLength) - MAX2(oldPos, 0.));
     241              : //    const double travelledDistanceVehicleOnLane = MIN2(newPos, myLaneLength) - MAX2(oldPos, 0.) + MIN2(MAX2(0., newPos - myLaneLength), veh.getVehicleType().getLength());
     242              : //    // XXX: #2556 fixed for ballistic update
     243    483988221 :     const double travelledDistanceFrontOnLane = MSGlobals::gSemiImplicitEulerUpdate ? frontOnLane * newSpeed
     244    162629688 :             : MAX2(0., MIN2(newPos, myLaneLength) - MAX2(oldPos, 0.));
     245    565303065 :     const double travelledDistanceVehicleOnLane = MSGlobals::gSemiImplicitEulerUpdate ? timeOnLane * newSpeed
     246    162629688 :             : MIN2(newPos, myLaneLength) - MAX2(oldPos, 0.) + MIN2(MAX2(0., newPos - myLaneLength), veh.getVehicleType().getLength());
     247              : //    // XXX: no fix
     248              : //    const double travelledDistanceFrontOnLane = frontOnLane*newSpeed;
     249              : //    const double travelledDistanceVehicleOnLane = timeOnLane*newSpeed;
     250              : 
     251              : #ifdef HAVE_FOX
     252    483988221 :     ScopedLocker<> lock(myNotificationMutex, MSGlobals::gNumSimThreads > 1);
     253              : #endif
     254    483988221 :     notifyMoveInternal(veh, frontOnLane, timeOnLane, (enterSpeed + leaveSpeedFront) / 2., (enterSpeed + leaveSpeed) / 2., travelledDistanceFrontOnLane, travelledDistanceVehicleOnLane, meanLengthOnLane);
     255              :     return ret;
     256              : }
     257              : 
     258              : 
     259              : bool
     260      1183205 : MSMeanData::MeanDataValues::notifyLeave(SUMOTrafficObject& /*veh*/, double /*lastPos*/, MSMoveReminder::Notification reason, const MSLane* /* enteredLane */) {
     261      1183205 :     if (MSGlobals::gUseMesoSim) {
     262              :         return false; // reminder is re-added on every segment (@recheck for performance)
     263              :     }
     264      1028879 :     return reason == MSMoveReminder::NOTIFICATION_JUNCTION;
     265              : }
     266              : 
     267              : 
     268              : bool
     269      2951641 : MSMeanData::MeanDataValues::isEmpty() const {
     270      2951641 :     return sampleSeconds == 0;
     271              : }
     272              : 
     273              : 
     274              : void
     275            0 : MSMeanData::MeanDataValues::update() {
     276            0 : }
     277              : 
     278              : 
     279              : double
     280      1034752 : MSMeanData::MeanDataValues::getSamples() const {
     281      1034752 :     return sampleSeconds;
     282              : }
     283              : 
     284              : 
     285              : // ---------------------------------------------------------------------------
     286              : // MSMeanData::MeanDataValueTracker - methods
     287              : // ---------------------------------------------------------------------------
     288         2744 : MSMeanData::MeanDataValueTracker::MeanDataValueTracker(MSLane* const lane,
     289              :         const double length,
     290         2744 :         const MSMeanData* const parent)
     291         2744 :     : MSMeanData::MeanDataValues(lane, length, true, parent) {
     292         2744 :     myCurrentData.push_back(std::make_shared<TrackerEntry>(parent->createValuesSubData(lane, length, false)));
     293         2744 : }
     294              : 
     295              : 
     296         8232 : MSMeanData::MeanDataValueTracker::~MeanDataValueTracker() {}
     297              : 
     298              : 
     299              : void
     300       164304 : MSMeanData::MeanDataValueTracker::reset(bool afterWrite) {
     301       164304 :     if (afterWrite) {
     302        70360 :         if (!myCurrentData.empty()) {
     303        70360 :             myCurrentData.pop_front();
     304              :         }
     305              :     } else {
     306       187888 :         myCurrentData.push_back(std::make_shared<TrackerEntry>(myParent->createValuesSubData(myLane, myLaneLength, false)));
     307              :     }
     308       164304 : }
     309              : 
     310              : 
     311              : void
     312            0 : MSMeanData::MeanDataValueTracker::addTo(MSMeanData::MeanDataValues& val) const {
     313            0 :     myCurrentData.front()->myValues->addTo(val);
     314            0 : }
     315              : 
     316              : 
     317              : void
     318        14996 : MSMeanData::MeanDataValueTracker::notifyMoveInternal(const SUMOTrafficObject& veh, const double frontOnLane, const double timeOnLane, const double meanSpeedFrontOnLane, const double meanSpeedVehicleOnLane, const double travelledDistanceFrontOnLane, const double travelledDistanceVehicleOnLane, const double meanLengthOnLane) {
     319        14996 :     myTrackedData[&veh]->myValues->notifyMoveInternal(veh, frontOnLane, timeOnLane, meanSpeedFrontOnLane, meanSpeedVehicleOnLane, travelledDistanceFrontOnLane, travelledDistanceVehicleOnLane, meanLengthOnLane);
     320        14996 : }
     321              : 
     322              : 
     323              : bool
     324          784 : MSMeanData::MeanDataValueTracker::notifyLeave(SUMOTrafficObject& veh, double lastPos, MSMoveReminder::Notification reason, const MSLane* /* enteredLane */) {
     325          784 :     if (myParent == nullptr || reason != MSMoveReminder::NOTIFICATION_SEGMENT) {
     326          384 :         myTrackedData[&veh]->myNumVehicleLeft++;
     327              :     }
     328          784 :     return myTrackedData[&veh]->myValues->notifyLeave(veh, lastPos, reason);
     329              : }
     330              : 
     331              : 
     332              : bool
     333         3400 : MSMeanData::MeanDataValueTracker::notifyEnter(SUMOTrafficObject& veh, MSMoveReminder::Notification reason, const MSLane* enteredLane) {
     334              : #ifdef DEBUG_NOTIFY_ENTER
     335              :     std::cout << "\n" << SIMTIME << " MSMeanData::MeanDataValueTracker: veh '" << veh.getID() << "' enters lane '" << enteredLane->getID() << "'" << std::endl;
     336              : #else
     337              :     UNUSED_PARAMETER(enteredLane);
     338              : #endif
     339         3400 :     if (reason == MSMoveReminder::NOTIFICATION_SEGMENT) {
     340              :         return true;
     341              :     }
     342         5768 :     if (myParent->vehicleApplies(veh) && myTrackedData.find(&veh) == myTrackedData.end()) {
     343          504 :         myTrackedData[&veh] = myCurrentData.back();
     344          504 :         myTrackedData[&veh]->myNumVehicleEntered++;
     345          504 :         if (!myTrackedData[&veh]->myValues->notifyEnter(veh, reason)) {
     346            0 :             myTrackedData[&veh]->myNumVehicleLeft++;
     347            0 :             myTrackedData.erase(&veh);
     348            0 :             return false;
     349              :         }
     350              :         return true;
     351              :     }
     352              :     return false;
     353              : }
     354              : 
     355              : 
     356              : bool
     357        91696 : MSMeanData::MeanDataValueTracker::isEmpty() const {
     358        91696 :     return myCurrentData.front()->myValues->isEmpty();
     359              : }
     360              : 
     361              : 
     362              : void
     363          368 : MSMeanData::MeanDataValueTracker::write(OutputDevice& dev,
     364              :                                         const SumoXMLAttrMask& attributeMask,
     365              :                                         const SUMOTime period,
     366              :                                         const int numLanes,
     367              :                                         const double speedLimit,
     368              :                                         const double defaultTravelTime,
     369              :                                         const int /*numVehicles*/) const {
     370          368 :     myCurrentData.front()->myValues->write(dev, attributeMask, period, numLanes, speedLimit,
     371              :                                            defaultTravelTime,
     372              :                                            myCurrentData.front()->myNumVehicleEntered);
     373          368 : }
     374              : 
     375              : 
     376              : int
     377        63116 : MSMeanData::MeanDataValueTracker::getNumReady() const {
     378              :     int result = 0;
     379      1445056 :     for (const auto& it : myCurrentData) {
     380      1384592 :         if (it->myNumVehicleEntered == it->myNumVehicleLeft) {
     381      1381940 :             result++;
     382              :         } else {
     383              :             break;
     384              :         }
     385              :     }
     386        63116 :     return result;
     387              : }
     388              : 
     389              : 
     390              : double
     391          368 : MSMeanData::MeanDataValueTracker::getSamples() const {
     392          368 :     return myCurrentData.front()->myValues->getSamples();
     393              : }
     394              : 
     395              : 
     396              : // ---------------------------------------------------------------------------
     397              : // MSMeanData - methods
     398              : // ---------------------------------------------------------------------------
     399        24317 : MSMeanData::MSMeanData(const std::string& id,
     400              :                        const SUMOTime dumpBegin, const SUMOTime dumpEnd,
     401              :                        const bool useLanes, const std::string& excludeEmpty, const bool withInternal,
     402              :                        const bool trackVehicles,
     403              :                        const int detectPersons,
     404              :                        const double maxTravelTime,
     405              :                        const double minSamples,
     406              :                        const std::string& vTypes,
     407              :                        const std::string& writeAttributes,
     408              :                        const std::vector<MSEdge*>& edges,
     409        24317 :                        AggregateType aggregate) :
     410              :     MSDetectorFileOutput(id, vTypes, "", detectPersons),
     411        24317 :     myMinSamples(minSamples),
     412        24317 :     myMaxTravelTime(maxTravelTime),
     413        24317 :     myAmEdgeBased(!useLanes),
     414        24317 :     myDumpBegin(dumpBegin),
     415        24317 :     myDumpEnd(dumpEnd),
     416        24317 :     myInitTime(SUMOTime_MAX),
     417        24317 :     myLastResetTime(dumpBegin),
     418        24317 :     myEdges(edges),
     419          172 :     myDumpInternal(withInternal && MSGlobals::gUsingInternalLanes),
     420        24317 :     myTrackVehicles(trackVehicles),
     421        97268 :     myWrittenAttributes(OutputDevice::parseWrittenAttributes(StringTokenizer(writeAttributes).getVector(), "meandata '" + id + "'")),
     422        72951 :     myAggregate(aggregate) {
     423              :     try {
     424        24317 :         myDumpEmpty = !StringUtils::toBool(excludeEmpty);
     425           84 :     } catch (const BoolFormatException&) {
     426           84 :         if (excludeEmpty == "default" || excludeEmpty == "defaults") {
     427           78 :             myPrintDefaults = true;
     428            6 :         } else if (excludeEmpty == "modified") {
     429            6 :             myDumpEmpty = false;
     430            6 :             myPrintDefaults = true;
     431            6 :             myPrintModified = true;
     432              :         } else {
     433            0 :             throw;
     434              :         }
     435           84 :     }
     436        24317 : }
     437              : 
     438              : 
     439              : void
     440        23392 : MSMeanData::init() {
     441        23392 :     myInitTime = MSNet::getInstance()->getCurrentTimeStep();
     442        23392 :     if (myEdges.empty()) {
     443              :         // use all edges by default
     444       820251 :         for (MSEdge* const edge : MSNet::getInstance()->getEdgeControl().getEdges()) {
     445       796932 :             if ((myDumpInternal || !edge->isInternal()) &&
     446       530438 :                     ((detectsPersons() && myDumpInternal) || (!edge->isCrossing() && !edge->isWalkingArea()))) {
     447       352331 :                 myEdges.push_back(edge);
     448              :             }
     449              :         }
     450              :     }
     451              :     int index = 0;
     452       375844 :     for (MSEdge* edge : myEdges) {
     453       352452 :         myMeasures.push_back(std::vector<MeanDataValues*>());
     454       352452 :         myEdgeIndex[edge] = index++;
     455       352452 :         const std::vector<MSLane*>& lanes = edge->getLanes();
     456       352452 :         if (MSGlobals::gUseMesoSim) {
     457              :             MeanDataValues* data;
     458        30609 :             if (!myAmEdgeBased) {
     459           85 :                 for (MSLane* const lane : lanes) {
     460           52 :                     data = createValues(lane, lanes[0]->getLength(), false);
     461           52 :                     myMeasures.back().push_back(data);
     462           52 :                     MESegment* s = MSGlobals::gMesoNet->getSegmentForEdge(*edge);
     463          310 :                     while (s != nullptr) {
     464          258 :                         s->addDetector(data, lane->getIndex());
     465          258 :                         s->prepareDetectorForWriting(*data, lane->getIndex());
     466              :                         s = s->getNextSegment();
     467              :                     }
     468           52 :                     data->reset();
     469           52 :                     data->reset(true);
     470              :                 }
     471              :             } else {
     472        30576 :                 if (myTrackVehicles) {
     473          880 :                     data = new MeanDataValueTracker(nullptr, lanes[0]->getLength(), this);
     474              :                 } else {
     475        29696 :                     data = createValues(nullptr, lanes[0]->getLength(), false);
     476              :                 }
     477        61152 :                 data->setDescription("meandata_" + getID() + "|" + edge->getID());
     478        30576 :                 myMeasures.back().push_back(data);
     479        30576 :                 MESegment* s = MSGlobals::gMesoNet->getSegmentForEdge(*edge);
     480       153406 :                 while (s != nullptr) {
     481       122830 :                     s->addDetector(data);
     482       122830 :                     s->prepareDetectorForWriting(*data);
     483              :                     s = s->getNextSegment();
     484              :                 }
     485        30576 :                 data->reset();
     486        30576 :                 data->reset(true);
     487              :             }
     488              :             continue;
     489        30609 :         }
     490       321843 :         if (myAmEdgeBased && myTrackVehicles) {
     491          936 :             myMeasures.back().push_back(new MeanDataValueTracker(nullptr, lanes[0]->getLength(), this));
     492              :         }
     493       850453 :         for (MSLane* const lane : lanes) {
     494       528610 :             if (myTrackVehicles) {
     495         2016 :                 if (myAmEdgeBased) {
     496         1088 :                     lane->addMoveReminder(myMeasures.back().back());
     497              :                 } else {
     498          928 :                     myMeasures.back().push_back(new MeanDataValueTracker(lane, lane->getLength(), this));
     499              :                 }
     500              :             } else {
     501       526594 :                 myMeasures.back().push_back(createValues(lane, lane->getLength(), true));
     502              :             }
     503              :         }
     504              :     }
     505        23392 :     if (myAggregate == AggregateType::TAZ) {
     506          532 :         for (const MSEdge* e : MSEdge::getAllEdges()) {
     507          524 :             if (e->isTazConnector()) {
     508          188 :                 myTAZ.push_back(e);
     509              :             }
     510              :         }
     511              :     }
     512        23392 :     if (mySubData != nullptr) {
     513            6 :         mySubData->init();
     514            6 :         std::vector<std::vector<MeanDataValues*> >::const_iterator subMeasureList = mySubData->myMeasures.begin();
     515           48 :         for (const std::vector<MeanDataValues*>& valueList : myMeasures) {
     516              :             std::vector<MeanDataValues*>::const_iterator subMeasures = subMeasureList->begin();
     517           84 :             for (MeanDataValues* values : valueList) {
     518           42 :                 values->setSubData(*subMeasures);
     519              :                 subMeasures++;
     520              :             }
     521              :             subMeasureList++;
     522              :         }
     523              :     }
     524        23392 : }
     525              : 
     526              : 
     527        24268 : MSMeanData::~MSMeanData() {
     528       376183 :     for (const std::vector<MeanDataValues*>& valueList : myMeasures) {
     529       909992 :         for (MeanDataValues* const values : valueList) {
     530       558077 :             delete values;
     531              :         }
     532              :     }
     533        24268 :     delete mySubData;
     534        24268 : }
     535              : 
     536              : 
     537              : void
     538        12649 : MSMeanData::resetOnly(SUMOTime stopTime) {
     539              :     UNUSED_PARAMETER(stopTime);
     540        12649 :     if (MSGlobals::gUseMesoSim) {
     541              :         MSEdgeVector::iterator edge = myEdges.begin();
     542       117300 :         for (std::vector<std::vector<MeanDataValues*> >::const_iterator i = myMeasures.begin(); i != myMeasures.end(); ++i, ++edge) {
     543       113716 :             MESegment* s = MSGlobals::gMesoNet->getSegmentForEdge(**edge);
     544       227432 :             for (MeanDataValues* data : *i) {
     545       602292 :                 while (s != nullptr) {
     546       488576 :                     s->prepareDetectorForWriting(*data);
     547              :                     s = s->getNextSegment();
     548              :                 }
     549       113716 :                 data->reset();
     550              :             }
     551              :         }
     552              :         return;
     553              :     }
     554       257316 :     for (std::vector<std::vector<MeanDataValues*> >::const_iterator i = myMeasures.begin(); i != myMeasures.end(); ++i) {
     555       530014 :         for (std::vector<MeanDataValues*>::const_iterator j = (*i).begin(); j != (*i).end(); ++j) {
     556       281763 :             (*j)->reset();
     557              :         }
     558              :     }
     559              : }
     560              : 
     561              : 
     562              : std::string
     563       586825 : MSMeanData::getEdgeID(const MSEdge* const edge) {
     564       586825 :     return edge->getID();
     565              : }
     566              : 
     567              : 
     568              : void
     569          938 : MSMeanData::writeAggregated(OutputDevice& dev, SUMOTime startTime, SUMOTime stopTime) {
     570          938 :     if (myTrackVehicles) {
     571            0 :         throw ProcessError(TL("aggregated meanData output not yet implemented for trackVehicles"));
     572              :     }
     573              : 
     574              :     double edgeLengthSum = 0;
     575              :     int laneNumber = 0;
     576              :     double speedSum = 0;
     577              :     double totalTT = 0;
     578        42146 :     for (MSEdge* edge : myEdges) {
     579        41208 :         edgeLengthSum += edge->getLength();
     580        41208 :         laneNumber += edge->getNumDrivingLanes();
     581        41208 :         speedSum += edge->getSpeedLimit();
     582        41208 :         totalTT += edge->getLength() / edge->getSpeedLimit();
     583              :     }
     584          938 :     MeanDataValues* sumData = createValuesSubData(nullptr, edgeLengthSum, false);
     585        42146 :     for (const std::vector<MeanDataValues*>& edgeValues : myMeasures) {
     586        82440 :         for (MeanDataValues* meanData : edgeValues) {
     587        41232 :             meanData->addTo(*sumData);
     588        41232 :             if (!MSNet::getInstance()->skipFinalReset()) {
     589        41232 :                 meanData->reset();
     590              :             }
     591              :         }
     592              :     }
     593          938 :     if (MSGlobals::gUseMesoSim) {
     594        14040 :         for (int i = 0; i < (int)myEdges.size(); i++) {
     595        13728 :             MSEdge* edge = myEdges[i];
     596              :             std::vector<MeanDataValues*>& edgeValues = myMeasures[i];
     597        13728 :             MESegment* s = MSGlobals::gMesoNet->getSegmentForEdge(*edge);
     598        68640 :             while (s != nullptr) {
     599       109824 :                 for (MeanDataValues* meanData : edgeValues) {
     600        54912 :                     s->prepareDetectorForWriting(*meanData);
     601        54912 :                     meanData->addTo(*sumData);
     602        54912 :                     if (!MSNet::getInstance()->skipFinalReset()) {
     603        54912 :                         meanData->reset();
     604              :                     }
     605              :                 }
     606              :                 s = s->getNextSegment();
     607              :             }
     608              :         }
     609              :     }
     610              : 
     611          938 :     if (myDumpEmpty || !sumData->isEmpty()) {
     612         1864 :         writePrefix(dev, *sumData, SUMO_TAG_EDGE, "AGGREGATED");
     613          932 :         dev.writeAttr(SUMO_ATTR_NUMEDGES, myEdges.size());
     614         1864 :         for (MeanDataValues* data = sumData; data != nullptr; data = data->getSubData()) {
     615          932 :             data->write(dev, myWrittenAttributes, stopTime - startTime, laneNumber, speedSum / (double)myEdges.size(),
     616          932 :                         myPrintDefaults ? totalTT : -1.);
     617              :         }
     618         1864 :         dev.closeTag();
     619              :     }
     620          938 :     delete sumData;
     621          938 : }
     622              : 
     623              : 
     624              : void
     625           20 : MSMeanData::writeAggregatedTAZ(OutputDevice& dev, SUMOTime startTime, SUMOTime stopTime) {
     626           20 :     if (myTrackVehicles) {
     627            0 :         throw ProcessError(TL("aggregated meanData output not yet implemented for trackVehicles"));
     628              :     }
     629              : 
     630          568 :     for (const MSEdge* taz : myTAZ) {
     631              :         double edgeLengthSum = 0;
     632              :         int laneNumber = 0;
     633              :         double speedSum = 0;
     634              :         double totalTT = 0;
     635              :         std::set<const MSEdge*> connected;
     636         1348 :         for (const MSEdge* edge : taz->getSuccessors()) {
     637              :             connected.insert(edge);
     638              :         }
     639         1348 :         for (const MSEdge* edge : taz->getPredecessors()) {
     640              :             connected.insert(edge);
     641              :         }
     642         2148 :         for (const MSEdge* edge : connected) {
     643         1600 :             edgeLengthSum += edge->getLength();
     644         1600 :             laneNumber += edge->getNumDrivingLanes();
     645         1600 :             speedSum += edge->getSpeedLimit();
     646         1600 :             totalTT += edge->getLength() / edge->getSpeedLimit();
     647              :         }
     648          548 :         MeanDataValues* sumData = createValuesSubData(nullptr, edgeLengthSum, false);
     649        24404 :         for (int i = 0; i < (int)myEdges.size(); i++) {
     650        23856 :             MSEdge* edge = myEdges[i];
     651              :             if (connected.count(edge) != 0) {
     652              :                 std::vector<MeanDataValues*>& edgeValues = myMeasures[i];
     653         1600 :                 if (MSGlobals::gUseMesoSim) {
     654          528 :                     MESegment* s = MSGlobals::gMesoNet->getSegmentForEdge(*edge);
     655         2640 :                     while (s != nullptr) {
     656         4224 :                         for (MeanDataValues* meanData : edgeValues) {
     657         2112 :                             s->prepareDetectorForWriting(*meanData);
     658         2112 :                             meanData->addTo(*sumData);
     659              :                         }
     660              :                         s = s->getNextSegment();
     661              :                     }
     662              :                 } else {
     663         2160 :                     for (MeanDataValues* meanData : edgeValues) {
     664         1088 :                         meanData->addTo(*sumData);
     665              :                     }
     666              :                 }
     667              :             }
     668              :         }
     669          548 :         if (myDumpEmpty || !sumData->isEmpty()) {
     670          240 :             writePrefix(dev, *sumData, SUMO_TAG_EDGE, taz->getID());
     671           80 :             dev.writeAttr(SUMO_ATTR_NUMEDGES, connected.size());
     672          160 :             for (MeanDataValues* data = sumData; data != nullptr; data = data->getSubData()) {
     673           80 :                 data->write(dev, myWrittenAttributes, stopTime - startTime, laneNumber, speedSum / (double)connected.size(),
     674           80 :                             myPrintDefaults ? totalTT : -1.);
     675              :             }
     676          160 :             dev.closeTag();
     677              :         }
     678          548 :         delete sumData;
     679              :     }
     680              : 
     681           20 :     if (!MSNet::getInstance()->skipFinalReset()) {
     682          836 :         for (const std::vector<MeanDataValues*>& edgeValues : myMeasures) {
     683         1656 :             for (MeanDataValues* meanData : edgeValues) {
     684          840 :                 meanData->reset();
     685              :             }
     686              :         }
     687              :     }
     688           20 : }
     689              : 
     690              : 
     691              : void
     692     17902551 : MSMeanData::writeEdge(OutputDevice& dev,
     693              :                       const std::vector<MeanDataValues*>& edgeValues,
     694              :                       const MSEdge* const edge, SUMOTime startTime, SUMOTime stopTime) {
     695     17902551 :     if (MSGlobals::gUseMesoSim) {
     696              :         int idx = 0;
     697      2732723 :         for (MeanDataValues* const data : edgeValues) {
     698      1366385 :             MESegment* s = MSGlobals::gMesoNet->getSegmentForEdge(*edge);
     699      7015142 :             while (s != nullptr) {
     700      5649099 :                 s->prepareDetectorForWriting(*data, myAmEdgeBased ? -1 : idx);
     701              :                 s = s->getNextSegment();
     702              :             }
     703      1366385 :             idx++;
     704              :         }
     705      1366338 :         if (myAmEdgeBased) {
     706      1366291 :             MeanDataValues* const data = edgeValues.front();
     707      1366291 :             if (myDumpEmpty || (myPrintModified && edge->getLanes()[0]->isSpeedModified()) || !data->isEmpty()) {
     708        63761 :                 writePrefix(dev, *data, SUMO_TAG_EDGE, getEdgeID(edge));
     709       127546 :                 for (MeanDataValues* d = data; d != nullptr; d = d->getSubData()) {
     710        63785 :                     d->write(dev, myWrittenAttributes, stopTime - startTime,
     711              :                              edge->getNumDrivingLanes(),
     712              :                              edge->getSpeedLimit(),
     713        63785 :                              myPrintDefaults ? edge->getLength() / edge->getSpeedLimit() : -1.);
     714              :                 }
     715       127522 :                 dev.closeTag();
     716              :             }
     717      1366291 :             if (!MSNet::getInstance()->skipFinalReset()) {
     718      1366291 :                 data->reset(true);
     719              :             }
     720      1366291 :             return;
     721              :         }
     722              :     }
     723     16536260 :     if (!myAmEdgeBased) {
     724      8025831 :         bool writeCheck = myDumpEmpty;
     725      8025831 :         if (!writeCheck) {
     726     15612385 :             for (const MeanDataValues* const laneData : edgeValues) {
     727      7913688 :                 if (!laneData->isEmpty() || (myPrintModified && laneData->getLane()->isSpeedModified())) {
     728              :                     writeCheck = true;
     729              :                     break;
     730              :                 }
     731              :             }
     732              :         }
     733      7902124 :         if (writeCheck) {
     734       327134 :             dev.openTag(SUMO_TAG_EDGE).writeAttr(SUMO_ATTR_ID, edge->getID());
     735              :         }
     736     16171771 :         for (MeanDataValues* const laneData : edgeValues) {
     737              :             const MSLane* const lane = laneData->getLane();
     738      8145940 :             if (myDumpEmpty || (myPrintModified && lane->isSpeedModified()) || !laneData->isEmpty()) {
     739       871226 :                 writePrefix(dev, *laneData, SUMO_TAG_LANE, lane->getID());
     740       871226 :                 for (MeanDataValues* data = laneData; data != nullptr; data = data->getSubData()) {
     741       435613 :                     data->write(dev, myWrittenAttributes, stopTime - startTime, 1, lane->getSpeedLimit(),
     742       435613 :                                 myPrintDefaults ? lane->getLength() / lane->getSpeedLimit() : -1.);
     743              :                 }
     744       871226 :                 dev.closeTag();
     745              :             }
     746      8145940 :             if (!MSNet::getInstance()->skipFinalReset()) {
     747      8145940 :                 laneData->reset(true);
     748              :             }
     749              :         }
     750      8025831 :         if (writeCheck) {
     751       654268 :             dev.closeTag();
     752              :         }
     753              :     } else {
     754      8510429 :         if (myTrackVehicles) {
     755        22440 :             MeanDataValues* meanData = *edgeValues.begin();
     756        22440 :             if (myDumpEmpty || !meanData->isEmpty()) {
     757          160 :                 writePrefix(dev, *meanData, SUMO_TAG_EDGE, edge->getID());
     758          320 :                 for (MeanDataValues* data = meanData; data != nullptr; data = data->getSubData()) {
     759          160 :                     data->write(dev, myWrittenAttributes, stopTime - startTime, edge->getNumDrivingLanes(), edge->getSpeedLimit(),
     760          160 :                                 myPrintDefaults ? edge->getLength() / edge->getSpeedLimit() : -1.);
     761              :                 }
     762          320 :                 dev.closeTag();
     763              :             }
     764        22440 :             if (!MSNet::getInstance()->skipFinalReset()) {
     765        22440 :                 meanData->reset(true);
     766              :             }
     767              :         } else {
     768      8487989 :             MeanDataValues* sumData = createValuesSubData(nullptr, edge->getLength(), false);
     769      8487989 :             bool writeCheck = myDumpEmpty;
     770     17145520 :             for (MeanDataValues* const laneData : edgeValues) {
     771      8657531 :                 laneData->addTo(*sumData);
     772      8657531 :                 if (myPrintModified && laneData->getLane()->isSpeedModified()) {
     773              :                     writeCheck = true;
     774              :                 }
     775      8657531 :                 if (!MSNet::getInstance()->skipFinalReset()) {
     776      8657531 :                     laneData->reset();
     777              :                 }
     778              :             }
     779      8487989 :             if (writeCheck || !sumData->isEmpty()) {
     780       525796 :                 writePrefix(dev, *sumData, SUMO_TAG_EDGE, getEdgeID(edge));
     781      1051644 :                 for (MeanDataValues* data = sumData; data != nullptr; data = data->getSubData()) {
     782       525848 :                     data->write(dev, myWrittenAttributes, stopTime - startTime, edge->getNumDrivingLanes(), edge->getSpeedLimit(),
     783       525848 :                                 myPrintDefaults ? edge->getLength() / edge->getSpeedLimit() : -1.);
     784              :                 }
     785      1051591 :                 dev.closeTag();
     786              :             }
     787      8487988 :             delete sumData;
     788              :         }
     789              :     }
     790              : }
     791              : 
     792              : 
     793              : void
     794       438316 : MSMeanData::openInterval(OutputDevice& dev, const SUMOTime startTime, const SUMOTime stopTime) {
     795       438316 :     dev.openTag(SUMO_TAG_INTERVAL).writeAttr(SUMO_ATTR_BEGIN, time2string(startTime)).writeAttr(SUMO_ATTR_END, time2string(stopTime));
     796       438316 :     dev.writeAttr(SUMO_ATTR_ID, myID);
     797       438316 : }
     798              : 
     799              : 
     800              : void
     801      1023586 : MSMeanData::writePrefix(OutputDevice& dev, const MeanDataValues& values, const SumoXMLTag tag, const std::string id) const {
     802      1023586 :     dev.openTag(tag);
     803      1023586 :     dev.writeAttr(SUMO_ATTR_ID, id);
     804      1023586 :     dev.writeOptionalAttr(SUMO_ATTR_SAMPLEDSECONDS, values.getSamples(), myWrittenAttributes);
     805      1023586 : }
     806              : 
     807              : 
     808              : void
     809       449631 : MSMeanData::writeXMLOutput(OutputDevice& dev,
     810              :                            SUMOTime startTime, SUMOTime stopTime) {
     811              :     // check whether this dump shall be written for the current time
     812       449631 :     myLastResetTime = SIMSTEP;
     813       449631 :     int numReady = myDumpBegin < stopTime && myDumpEnd - DELTA_T >= startTime ? 1 : 0;
     814       449631 :     if (myTrackVehicles && myDumpBegin < stopTime) {
     815         2124 :         myPendingIntervals.push_back(std::make_pair(startTime, stopTime));
     816         2124 :         numReady = (int)myPendingIntervals.size();
     817        63312 :         for (std::vector<std::vector<MeanDataValues*> >::const_iterator i = myMeasures.begin(); i != myMeasures.end(); ++i) {
     818       124304 :             for (std::vector<MeanDataValues*>::const_iterator j = (*i).begin(); j != (*i).end(); ++j) {
     819        63116 :                 numReady = MIN2(numReady, ((MeanDataValueTracker*)*j)->getNumReady());
     820        63116 :                 if (numReady == 0) {
     821              :                     break;
     822              :                 }
     823              :             }
     824        63092 :             if (numReady == 0) {
     825              :                 break;
     826              :             }
     827              :         }
     828              :     }
     829       449631 :     const bool partialInterval = startTime < myInitTime;
     830       449631 :     if (numReady == 0 || myTrackVehicles || partialInterval) {
     831        12649 :         resetOnly(stopTime);
     832              :     }
     833       449631 :     if (partialInterval) {
     834              :         return;
     835              :     }
     836       888190 :     while (numReady-- > 0) {
     837       438570 :         if (!myPendingIntervals.empty()) {
     838         1588 :             startTime = myPendingIntervals.front().first;
     839         1588 :             stopTime = myPendingIntervals.front().second;
     840         1588 :             myPendingIntervals.pop_front();
     841              :         }
     842       438570 :         openInterval(dev, startTime, stopTime);
     843       438570 :         if (myAggregate == AggregateType::YES) {
     844          938 :             writeAggregated(dev, startTime, stopTime);
     845       437632 :         } else if (myAggregate == AggregateType::TAZ) {
     846           20 :             writeAggregatedTAZ(dev, startTime, stopTime);
     847              :         } else {
     848              :             MSEdgeVector::const_iterator edge = myEdges.begin();
     849     18340162 :             for (const std::vector<MeanDataValues*>& measures : myMeasures) {
     850     17902551 :                 writeEdge(dev, measures, *edge, startTime, stopTime);
     851              :                 ++edge;
     852              :             }
     853              :         }
     854       877138 :         dev.closeTag();
     855              :     }
     856              :     dev.flush();
     857              : }
     858              : 
     859              : 
     860              : void
     861        23364 : MSMeanData::writeXMLDetectorProlog(OutputDevice& dev) const {
     862        46728 :     dev.writeXMLHeader("meandata", "meandata_file.xsd");
     863        23364 : }
     864              : 
     865              : 
     866              : void
     867     26549423 : MSMeanData::detectorUpdate(const SUMOTime step) {
     868     26549423 :     if (step + DELTA_T == myDumpBegin) {
     869          639 :         init();
     870              :     }
     871     26549423 : }
     872              : 
     873              : 
     874              : const std::vector<MSMeanData::MeanDataValues*>*
     875         8524 : MSMeanData::getEdgeValues(const MSEdge* edge) const {
     876              :     auto it = myEdgeIndex.find(edge);
     877         8524 :     if (it != myEdgeIndex.end()) {
     878         8524 :         return &myMeasures[it->second];
     879              :     } else {
     880              :         return nullptr;
     881              :     }
     882              : }
     883              : 
     884              : 
     885              : const std::vector<MSMoveReminder*>
     886            1 : MSMeanData::getReminders() const {
     887              :     std::vector<MSMoveReminder*> result;
     888           45 :     for (auto vec : myMeasures) {
     889           44 :         result.insert(result.end(), vec.begin(), vec.end());
     890           44 :     }
     891            1 :     return result;
     892            0 : }
     893              : 
     894              : 
     895              : double
     896         8524 : MSMeanData::getAttributeValue(const MSLane* lane, SumoXMLAttr a, double defaultValue) const {
     897              :     double result = defaultValue;
     898         8524 :     const std::vector<MeanDataValues*>* edgeValues = getEdgeValues(&lane->getEdge());
     899         8524 :     if (edgeValues == nullptr) {
     900              :         return result;
     901              :     }
     902              :     MeanDataValues* values = nullptr;
     903         8524 :     if (!myAmEdgeBased) {
     904          720 :         values = (*edgeValues)[lane->getIndex()];
     905              :     } else {
     906         7804 :         MeanDataValues* sumData = createValuesSubData(nullptr, lane->getLength(), false);
     907        26316 :         for (MeanDataValues* meanData : (*edgeValues)) {
     908        18512 :             meanData->addTo(*sumData);
     909              :         }
     910              :         values = sumData;
     911              :     }
     912         8524 :     const SUMOTime period = SIMSTEP - myLastResetTime;
     913         8524 :     result = values->getAttributeValue(a, period, lane->getEdge().getNumLanes(), lane->getSpeedLimit());
     914         8524 :     if (myAmEdgeBased) {
     915         7804 :         delete values;
     916              :     }
     917              :     return result;
     918              : }
     919              : 
     920              : 
     921              : MSMeanData::MeanDataValues*
     922      8593967 : MSMeanData::createValuesSubData(MSLane* const lane, const double length, const bool doAdd) const {
     923      8593967 :     MeanDataValues* values = createValues(lane, length, doAdd);
     924      8593967 :     if (mySubData != nullptr) {
     925          280 :         values->setSubData(mySubData->createValues(lane, length, doAdd));
     926              :     }
     927      8593967 :     return values;
     928              : }
     929              : 
     930              : 
     931              : /****************************************************************************/
        

Generated by: LCOV version 2.0-1