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