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 MSInductLoop.cpp
15 : /// @author Christian Roessel
16 : /// @author Daniel Krajzewicz
17 : /// @author Jakob Erdmann
18 : /// @author Sascha Krieg
19 : /// @author Michael Behrisch
20 : /// @author Laura Bieker
21 : /// @author Mirko Barthauer
22 : /// @date 2004-11-23
23 : ///
24 : // An unextended detector measuring at a fixed position on a fixed lane.
25 : /****************************************************************************/
26 : #include <config.h>
27 :
28 : #include "MSInductLoop.h"
29 : #include <cassert>
30 : #include <numeric>
31 : #include <utility>
32 : #ifdef HAVE_FOX
33 : #include <utils/common/ScopedLocker.h>
34 : #endif
35 : #include <utils/common/WrappingCommand.h>
36 : #include <utils/common/ToString.h>
37 : #include <microsim/MSEventControl.h>
38 : #include <microsim/MSLane.h>
39 : #include <microsim/MSEdge.h>
40 : #include <microsim/MSVehicle.h>
41 : #include <microsim/MSNet.h>
42 : #include <microsim/MSVehicleControl.h>
43 : #include <microsim/transportables/MSTransportable.h>
44 : #include <microsim/transportables/MSPModel.h>
45 : #include <mesosim/MELoop.h>
46 : #include <mesosim/MESegment.h>
47 : #include <mesosim/MEVehicle.h>
48 : #include <utils/common/MsgHandler.h>
49 : #include <utils/common/UtilExceptions.h>
50 : #include <utils/common/StringUtils.h>
51 : #include <utils/iodevices/OutputDevice.h>
52 :
53 : #define HAS_NOT_LEFT_DETECTOR -1
54 :
55 : //#define DEBUG_E1_NOTIFY_MOVE
56 :
57 : #define DEBUG_COND (true)
58 : //#define DEBUG_COND (isSelected())
59 : //#define DEBUG_COND (getID()=="")
60 :
61 : // ===========================================================================
62 : // method definitions
63 : // ===========================================================================
64 29950 : MSInductLoop::MSInductLoop(const std::string& id, MSLane* const lane,
65 : double positionInMeters,
66 : double length, std::string name,
67 : const std::string& vTypes,
68 : const std::string& nextEdges,
69 : int detectPersons,
70 29950 : const bool needLocking) :
71 : MSMoveReminder(id, lane),
72 : MSDetectorFileOutput(id, vTypes, nextEdges, detectPersons),
73 29946 : myName(name),
74 29946 : myPosition(positionInMeters),
75 29946 : myEndPosition(myPosition + length),
76 29946 : myNeedLock(needLocking || MSGlobals::gNumSimThreads > 1),
77 : // initialize in a way which doesn't impact actualted traffic lights at simulation start (yet doesn't look ugly in the outputs)
78 29946 : myLastLeaveTime(-3600),
79 29946 : myOverrideTime(-1),
80 29946 : myOverrideEntryTime(-1),
81 : myVehicleDataCont(),
82 : myVehiclesOnDet(),
83 29946 : myLastIntervalEnd(-1),
84 29950 : mySegment(nullptr) {
85 : assert(length >= 0);
86 : assert(myPosition >= 0 && myEndPosition <= myLane->getLength());
87 29946 : reset();
88 29946 : if (MSGlobals::gUseMesoSim) {
89 : // used by actuated tls
90 1586 : mySegment = MSGlobals::gMesoNet->getSegmentForEdge(lane->getEdge(), myPosition);
91 1586 : mySegment->addDetector(this);
92 1586 : mySegmentPos = myPosition - mySegment->getIndex() * mySegment->getLength();
93 : }
94 29950 : }
95 :
96 :
97 57442 : MSInductLoop::~MSInductLoop() {
98 87268 : }
99 :
100 :
101 : void
102 162858 : MSInductLoop::reset() {
103 : #ifdef HAVE_FOX
104 162858 : ScopedLocker<> lock(myNotificationMutex, myNeedLock);
105 : #endif
106 162858 : myEnteredVehicleNumber = 0;
107 162858 : myLastVehicleDataCont = myVehicleDataCont;
108 : myVehicleDataCont.clear();
109 162858 : myLastIntervalBegin = myLastIntervalEnd;
110 162858 : myLastIntervalEnd = SIMSTEP;
111 162858 : }
112 :
113 :
114 : bool
115 1405155 : MSInductLoop::notifyEnter(SUMOTrafficObject& veh, Notification reason, const MSLane* /* enteredLane */) {
116 : // vehicles must be kept if the "inductionloop" wants to detect passeengers
117 1405155 : if (!vehicleApplies(veh) && (veh.isPerson() || myDetectPersons <= (int)PersonMode::WALK)) {
118 : return false;
119 : }
120 1400203 : if (MSGlobals::gUseMesoSim) {
121 185718 : MEVehicle* mesoveh = dynamic_cast<MEVehicle*>(&veh);
122 : assert(mesoveh != nullptr);
123 : const MESegment* seg = mesoveh->getSegment();
124 185718 : if (seg != nullptr && (seg->numQueues() == 1 || mesoveh->getQueIndex() == myLane->getIndex())) {
125 161874 : const SUMOTime onSegTime = mesoveh->getEventTime() - mesoveh->getLastEntryTime();
126 : // extrapolate movement
127 161874 : const SUMOTime exLeaveTime = mesoveh->getLastEntryTime() + (SUMOTime)((double)onSegTime * mySegmentPos / seg->getLength());
128 : //std::cout << SIMTIME << " det=" << getID() << " veh=" << veh.getID() << " entry=" << STEPS2TIME(mesoveh->getLastEntryTime()) << " et=" << STEPS2TIME(mesoveh->getEventTime()) << " exLeaveTime=" << STEPS2TIME(exLeaveTime) << "\n";
129 161874 : myNextMesoLeaveTimes.push(exLeaveTime);
130 : }
131 185718 : return true;
132 : }
133 1214485 : if (reason != NOTIFICATION_JUNCTION) { // the junction case is handled in notifyMove
134 244941 : if (veh.getBackPositionOnLane(myLane) >= myPosition) {
135 : return false;
136 : }
137 242135 : if (veh.getPositionOnLane() >= myPosition) {
138 : #ifdef HAVE_FOX
139 1247 : ScopedLocker<> lock(myNotificationMutex, myNeedLock);
140 : #endif
141 1247 : myVehiclesOnDet[&veh] = SIMTIME;
142 1247 : myEnteredVehicleNumber++;
143 : }
144 : }
145 : return true;
146 : }
147 :
148 :
149 : bool
150 23842501 : MSInductLoop::notifyMove(SUMOTrafficObject& veh, double oldPos,
151 : double newPos, double newSpeed) {
152 23842501 : if (newPos < myPosition) {
153 : // detector not reached yet
154 : return true;
155 : }
156 2759979 : if (myDetectPersons > (int)PersonMode::WALK && !veh.isPerson()) {
157 : bool keep = false;
158 38 : MSBaseVehicle& v = dynamic_cast<MSBaseVehicle&>(veh);
159 76 : for (MSTransportable* p : v.getPersons()) {
160 38 : keep = notifyMove(*p, oldPos, newPos, newSpeed);
161 : }
162 38 : return keep;
163 : }
164 : #ifdef HAVE_FOX
165 2759941 : ScopedLocker<> lock(myNotificationMutex, myNeedLock);
166 : #endif
167 2759941 : const double oldSpeed = veh.getPreviousSpeed();
168 2759941 : if (newPos >= myPosition && oldPos < myPosition) {
169 : // entered the detector by move
170 1182711 : const double timeBeforeEnter = MSCFModel::passingTime(oldPos, myPosition, newPos, oldSpeed, newSpeed);
171 1182711 : myVehiclesOnDet[&veh] = SIMTIME + timeBeforeEnter;
172 1182711 : myEnteredVehicleNumber++;
173 : #ifdef DEBUG_E1_NOTIFY_MOVE
174 : if (DEBUG_COND) {
175 : std::cout << SIMTIME << " det=" << getID() << " enteredVeh=" << veh.getID() << "\n";
176 : }
177 : #endif
178 : }
179 2759941 : double oldBackPos = oldPos - veh.getVehicleType().getLength();
180 2759941 : double newBackPos = newPos - veh.getVehicleType().getLength();
181 2759941 : if (newBackPos > myEndPosition) {
182 : // vehicle passed the detector (it may have changed onto this lane somewhere past the detector)
183 : // assert(!MSGlobals::gSemiImplicitEulerUpdate || newSpeed > 0 || myVehiclesOnDet.find(&veh) == myVehiclesOnDet.end());
184 : // assertion is invalid in case of teleportation
185 1180383 : if (oldBackPos <= myEndPosition) {
186 : const std::map<SUMOTrafficObject*, double>::iterator it = myVehiclesOnDet.find(&veh);
187 1180379 : if (it != myVehiclesOnDet.end()) {
188 1180379 : const double entryTime = it->second;
189 1180379 : const double leaveTime = SIMTIME + MSCFModel::passingTime(oldBackPos, myEndPosition, newBackPos, oldSpeed, newSpeed);
190 : myVehiclesOnDet.erase(it);
191 : assert(entryTime <= leaveTime);
192 1180379 : myVehicleDataCont.push_back(VehicleData(veh, entryTime, leaveTime, false, myEndPosition - myPosition));
193 1180379 : myLastLeaveTime = leaveTime;
194 : #ifdef DEBUG_E1_NOTIFY_MOVE
195 : if (DEBUG_COND) {
196 : std::cout << SIMTIME << " det=" << getID() << " leftVeh=" << veh.getID() << " oldBackPos=" << oldBackPos << " newBackPos=" << newBackPos << "\n";
197 : }
198 : #endif
199 : } else {
200 : #ifdef DEBUG_E1_NOTIFY_MOVE
201 : if (DEBUG_COND) {
202 : std::cout << SIMTIME << " det=" << getID() << " leftVeh=" << veh.getID() << " oldBackPos=" << oldBackPos << " newBackPos=" << newBackPos << " (notFound)\n";
203 : }
204 : #endif
205 : }
206 : } else {
207 : // vehicle is already beyond the detector...
208 : // This can happen even if it is still registered in myVehiclesOnDet, e.g., after teleport.
209 4 : myVehiclesOnDet.erase(&veh);
210 : #ifdef DEBUG_E1_NOTIFY_MOVE
211 : if (DEBUG_COND) {
212 : std::cout << SIMTIME << " det=" << getID() << " leftVeh=" << veh.getID() << " oldBackPos=" << oldBackPos << " newBackPos=" << newBackPos << " (unusual)\n";
213 : }
214 : #endif
215 : }
216 1180383 : return false;
217 : }
218 : // vehicle stays on the detector
219 : return true;
220 : }
221 :
222 :
223 : bool
224 1044601 : MSInductLoop::notifyLeave(SUMOTrafficObject& veh, double lastPos, MSMoveReminder::Notification reason, const MSLane* /* enteredLane */) {
225 1044601 : if (veh.isPerson() && myDetectPersons != (int)PersonMode::NONE) {
226 3204 : const int lastDir = lastPos < 0 ? MSPModel::BACKWARD : MSPModel::FORWARD;
227 3204 : notifyMovePerson(dynamic_cast<MSTransportable*>(&veh), lastDir, lastPos);
228 : }
229 1044601 : if (MSGlobals::gUseMesoSim && reason <= MSMoveReminder::NOTIFICATION_SEGMENT && vehicleApplies(veh)) {
230 185556 : MEVehicle* mesoveh = dynamic_cast<MEVehicle*>(&veh);
231 : assert(mesoveh != nullptr);
232 : const MESegment* seg = mesoveh->getSegment();
233 185556 : if (seg != nullptr && (seg->numQueues() == 1 || mesoveh->getQueIndex() == myLane->getIndex())) {
234 : // interpolate movement + 1 extra second
235 : // We can only interpolate the passing time at the detector after the vehicle leaves the segment. Consequently our information is always out of date
236 : // (by the time the current vehicle left, the follower vehicle should already have reached the detector so the estimated time gap to the last detection is always too large)
237 : // the prior implementation used seg->getBlockTime() which included the headway which somewhat worked around this deficit by accident
238 173965 : const SUMOTime inLeaveTime = mesoveh->getEventTime() - TIME2STEPS((seg->getLength() - mySegmentPos - mesoveh->getLength()) / myLane->getSpeedLimit());
239 : //std::cout << SIMTIME << " det=" << getID() << " veh=" << veh.getID() << " et=" << STEPS2TIME(mesoveh->getEventTime()) << " inLeaveTime=" << STEPS2TIME(inLeaveTime) << "\n";
240 161723 : auto q = seg->getQueue(mesoveh->getQueIndex());
241 161723 : if (q.size() > 1 && vehicleApplies(*q[q.size() - 2])) {
242 147221 : myLastMesoLeaveTimes.push(inLeaveTime + TIME2STEPS(seg->getLastHeadwaySeconds()));
243 : //std::cout << " inLeaveTime2=" << (STEPS2TIME(inLeaveTime) + seg->getLastHeadwaySeconds()) << "\n";
244 : }
245 161723 : myLastMesoLeaveTimes.push(inLeaveTime);
246 161723 : myEnteredVehicleNumber++;
247 161723 : }
248 185556 : return false;
249 : }
250 859045 : if (reason != MSMoveReminder::NOTIFICATION_JUNCTION || (veh.isPerson() && myDetectPersons != (int)PersonMode::NONE)) {
251 : #ifdef HAVE_FOX
252 31584 : ScopedLocker<> lock(myNotificationMutex, myNeedLock);
253 : #endif
254 : const std::map<SUMOTrafficObject*, double>::iterator it = myVehiclesOnDet.find(&veh);
255 31584 : if (it != myVehiclesOnDet.end()) {
256 3562 : const double entryTime = it->second;
257 3562 : const double leaveTime = SIMTIME + TS;
258 : myVehiclesOnDet.erase(it);
259 3562 : myVehicleDataCont.push_back(VehicleData(veh, entryTime, leaveTime, true));
260 3562 : myLastLeaveTime = leaveTime;
261 : }
262 : return false;
263 : }
264 : return true;
265 : }
266 :
267 :
268 : double
269 146 : MSInductLoop::getSpeed(const int offset) const {
270 146 : const std::vector<VehicleData>& d = collectVehiclesOnDet(SIMSTEP - offset);
271 175 : return d.empty() ? -1. : std::accumulate(d.begin(), d.end(), 0.0, speedSum) / (double) d.size();
272 146 : }
273 :
274 :
275 : double
276 146 : MSInductLoop::getVehicleLength(const int offset) const {
277 146 : const std::vector<VehicleData>& d = collectVehiclesOnDet(SIMSTEP - offset);
278 175 : return d.empty() ? -1. : std::accumulate(d.begin(), d.end(), 0.0, lengthSum) / (double)d.size();
279 146 : }
280 :
281 :
282 : double
283 55946 : MSInductLoop::getOccupancy() const {
284 55946 : if (myOverrideTime >= 0) {
285 48 : return myOverrideTime < TS ? (TS - myOverrideTime) / TS * 100 : 0;
286 : }
287 55898 : const SUMOTime tbeg = SIMSTEP - DELTA_T;
288 : double occupancy = 0;
289 55898 : const double csecond = SIMTIME;
290 61783 : for (const VehicleData& i : collectVehiclesOnDet(tbeg, false, false, true)) {
291 5885 : const double leaveTime = i.leaveTimeM == HAS_NOT_LEFT_DETECTOR ? csecond : MIN2(i.leaveTimeM, csecond);
292 5885 : const double entryTime = MAX2(i.entryTimeM, STEPS2TIME(tbeg));
293 8697 : occupancy += MIN2(leaveTime - entryTime, TS);
294 55898 : }
295 55898 : return occupancy / TS * 100.;
296 : }
297 :
298 :
299 : double
300 3217 : MSInductLoop::getEnteredNumber(const int offset) const {
301 3217 : if (myOverrideTime >= 0) {
302 48 : return myOverrideTime < TS ? 1 : 0;
303 : }
304 3169 : return (double)collectVehiclesOnDet(SIMSTEP - offset, true, true).size();
305 : }
306 :
307 :
308 : std::vector<std::string>
309 970 : MSInductLoop::getVehicleIDs(const int offset) const {
310 : std::vector<std::string> ret;
311 1239 : for (const VehicleData& i : collectVehiclesOnDet(SIMSTEP - offset, true, true)) {
312 269 : ret.push_back(i.idM);
313 970 : }
314 970 : return ret;
315 0 : }
316 :
317 :
318 : double
319 1123693 : MSInductLoop::getTimeSinceLastDetection() const {
320 1123693 : if (myOverrideTime >= 0) {
321 : return myOverrideTime;
322 : }
323 1123645 : if (myVehiclesOnDet.size() != 0) {
324 : // detector is occupied
325 : return 0;
326 : }
327 1062305 : if (MSGlobals::gUseMesoSim) {
328 : //std::cout << SIMTIME << " det=" << getID() << " qBefore=" << myNextMesoLeaveTimes.size() << " last=" << STEPS2TIME(getLastDetectionTime()) << " qAfter=" << myNextMesoLeaveTimes.size() << " top=" << (myNextMesoLeaveTimes.empty() ? -1 : myNextMesoLeaveTimes.top()) << "\n";
329 440534 : return SIMTIME - STEPS2TIME(getLastDetectionTime());
330 : }
331 621771 : return SIMTIME - myLastLeaveTime;
332 : }
333 :
334 :
335 : void
336 16 : MSInductLoop::loadTimeSinceLastDetection(double time) {
337 16 : myLastLeaveTime = SIMTIME - time;
338 16 : }
339 :
340 :
341 : double
342 184760 : MSInductLoop::getOccupancyTime() const {
343 : #ifdef HAVE_FOX
344 184760 : ScopedLocker<> lock(myNotificationMutex, myNeedLock);
345 : #endif
346 184760 : if (myOverrideTime >= 0) {
347 0 : return SIMTIME - myOverrideEntryTime;
348 : }
349 184760 : if (myVehiclesOnDet.size() == 0) {
350 : // detector is unoccupied
351 : return 0;
352 : } else {
353 : double minEntry = std::numeric_limits<double>::max();
354 4530 : for (const auto& i : myVehiclesOnDet) {
355 2265 : minEntry = MIN2(i.second, minEntry);
356 : }
357 2265 : return SIMTIME - minEntry;
358 : }
359 : }
360 :
361 :
362 : double
363 2266 : MSInductLoop::getArrivalDelay() const {
364 : #ifdef HAVE_FOX
365 2266 : ScopedLocker<> lock(myNotificationMutex, myNeedLock);
366 : #endif
367 2266 : MSVehicleControl& vc = MSNet::getInstance()->getVehicleControl();
368 : double result = -INVALID_DOUBLE;
369 2294 : for (const auto& item : collectVehiclesOnDet(SIMSTEP - DELTA_T)) {
370 28 : SUMOVehicle* v = vc.getVehicle(item.idM);
371 28 : if (v != nullptr) {
372 28 : MSBaseVehicle* veh = dynamic_cast<MSBaseVehicle*>(v);
373 28 : double ad = veh->getStopArrivalDelay();
374 28 : if (ad != INVALID_DOUBLE) {
375 : result = MAX2(result, ad);
376 : }
377 : }
378 2266 : }
379 2266 : return result;
380 : }
381 :
382 :
383 : void
384 503224 : MSInductLoop::discardOldTimes(TimeQueue& tq, SUMOTime now) {
385 : // discard times in the past except for the latest one
386 503224 : SUMOTime last = tq.top();
387 503224 : if (tq.size() > 1) {
388 : tq.pop();
389 746784 : while (tq.size() > 0 && tq.top() < now) {
390 458530 : last = tq.top();
391 : tq.pop();
392 : }
393 288254 : tq.push(last);
394 : }
395 503224 : }
396 :
397 :
398 : SUMOTime
399 850626 : MSInductLoop::getLastDetectionTime() const {
400 850626 : if (myOverrideTime >= 0) {
401 0 : return SIMSTEP - TIME2STEPS(myOverrideTime);
402 : }
403 850626 : if (myVehiclesOnDet.size() != 0) {
404 12696 : return MSNet::getInstance()->getCurrentTimeStep();
405 : }
406 837930 : const SUMOTime now = SIMSTEP;
407 : if (MSGlobals::gUseMesoSim
408 572420 : && !myNextMesoLeaveTimes.empty()
409 1091322 : && myNextMesoLeaveTimes.top() < now) {
410 253066 : discardOldTimes(myNextMesoLeaveTimes, now);
411 253066 : SUMOTime last = myNextMesoLeaveTimes.top();
412 253066 : if (!myLastMesoLeaveTimes.empty() && myLastMesoLeaveTimes.top() < now) {
413 250158 : discardOldTimes(myLastMesoLeaveTimes, now);
414 250158 : last = MAX2(last, myLastMesoLeaveTimes.top());
415 : }
416 : //std::cout << SIMTIME << " det=" << getID() << " result=" << last << " last=" << myNextMesoLeaveTimes.top() << " last2=" << (myLastMesoLeaveTimes.size() > 0 ? myLastMesoLeaveTimes.top() : -1) << "\n";
417 253066 : return last;
418 : }
419 1014826 : return TIME2STEPS(myLastLeaveTime);
420 : }
421 :
422 :
423 : double
424 972 : MSInductLoop::getIntervalOccupancy(bool lastInterval) const {
425 : double occupancy = 0;
426 972 : const double csecond = lastInterval ? STEPS2TIME(myLastIntervalEnd) : SIMTIME;
427 972 : const double aggTime = csecond - STEPS2TIME(lastInterval ? myLastIntervalBegin : myLastIntervalEnd);
428 972 : if (aggTime == 0) {
429 : return 0;
430 : }
431 4040 : for (const VehicleData& i : collectVehiclesOnDet(myLastIntervalEnd, false, false, true, lastInterval)) {
432 3072 : const double leaveTime = i.leaveTimeM == HAS_NOT_LEFT_DETECTOR ? csecond : MIN2(i.leaveTimeM, csecond);
433 3072 : const double entryTime = MAX2(i.entryTimeM, STEPS2TIME(lastInterval ? myLastIntervalBegin : myLastIntervalEnd));
434 3072 : occupancy += MIN2(leaveTime - entryTime, aggTime);
435 968 : }
436 968 : return occupancy / aggTime * 100.;
437 : }
438 :
439 :
440 : double
441 972 : MSInductLoop::getIntervalMeanSpeed(bool lastInterval) const {
442 972 : const std::vector<VehicleData>& d = collectVehiclesOnDet(myLastIntervalEnd, false, false, false, lastInterval);
443 1644 : return d.empty() ? -1. : std::accumulate(d.begin(), d.end(), 0.0, speedSum) / (double) d.size();
444 972 : }
445 :
446 :
447 : int
448 972 : MSInductLoop::getIntervalVehicleNumber(bool lastInterval) const {
449 972 : return (int)collectVehiclesOnDet(myLastIntervalEnd, false, false, false, lastInterval).size();
450 : }
451 :
452 :
453 : std::vector<std::string>
454 972 : MSInductLoop::getIntervalVehicleIDs(bool lastInterval) const {
455 : std::vector<std::string> ret;
456 4044 : for (const VehicleData& i : collectVehiclesOnDet(myLastIntervalEnd, false, false, false, lastInterval)) {
457 3072 : ret.push_back(i.idM);
458 972 : }
459 972 : return ret;
460 0 : }
461 :
462 :
463 : void
464 20 : MSInductLoop::overrideTimeSinceDetection(double time) {
465 20 : myOverrideTime = time;
466 20 : if (time < 0) {
467 4 : myOverrideEntryTime = -1;
468 : } else {
469 16 : const double entryTime = MAX2(0.0, SIMTIME - time);
470 16 : if (myOverrideEntryTime >= 0) {
471 : // maintain earlier entry time to achive continous detection
472 12 : myOverrideEntryTime = MIN2(myOverrideEntryTime, entryTime);
473 : } else {
474 4 : myOverrideEntryTime = entryTime;
475 : }
476 : }
477 20 : }
478 :
479 : void
480 29942 : MSInductLoop::writeXMLDetectorProlog(OutputDevice& dev) const {
481 59884 : dev.writeXMLHeader("detector", "det_e1_file.xsd");
482 29942 : }
483 :
484 :
485 : void
486 132912 : MSInductLoop::writeXMLOutput(OutputDevice& dev, SUMOTime startTime, SUMOTime stopTime) {
487 132912 : if (dev.isNull()) {
488 29700 : reset();
489 29700 : return;
490 : }
491 103212 : const double t(STEPS2TIME(stopTime - startTime));
492 103212 : double occupancy = 0.;
493 : double speedSum = 0.;
494 : double lengthSum = 0.;
495 103212 : int contrib = 0;
496 : // to approximate the space mean speed
497 : double inverseSpeedSum = 0.;
498 1094090 : for (const VehicleData& vData : myVehicleDataCont) {
499 1977827 : const double timeOnDetDuringInterval = vData.leaveTimeM - MAX2(STEPS2TIME(startTime), vData.entryTimeM);
500 990878 : occupancy += MIN2(timeOnDetDuringInterval, t);
501 990878 : if (!vData.leftEarlyM) {
502 987864 : speedSum += vData.speedM;
503 : assert(vData.speedM > 0.);
504 987864 : inverseSpeedSum += 1. / vData.speedM;
505 987864 : lengthSum += vData.lengthM;
506 987864 : contrib++;
507 : }
508 : }
509 103212 : if (MSGlobals::gUseMesoSim) {
510 168 : contrib = myEnteredVehicleNumber;
511 : }
512 103212 : const double flow = (double)contrib / t * 3600.;
513 107383 : for (std::map< SUMOTrafficObject*, double >::const_iterator i = myVehiclesOnDet.begin(); i != myVehiclesOnDet.end(); ++i) {
514 8261 : occupancy += STEPS2TIME(stopTime) - MAX2(STEPS2TIME(startTime), i->second);
515 : }
516 103212 : occupancy *= 100. / t;
517 103212 : const double meanSpeed = contrib != 0 ? speedSum / (double)contrib : -1;
518 103212 : const double harmonicMeanSpeed = contrib != 0 ? (double)contrib / inverseSpeedSum : -1;
519 103212 : const double meanLength = contrib != 0 ? lengthSum / (double)contrib : -1;
520 206424 : dev.openTag(SUMO_TAG_INTERVAL).writeTime(SUMO_ATTR_BEGIN, startTime).writeTime(SUMO_ATTR_END, stopTime);
521 103212 : dev.writeAttr(SUMO_ATTR_ID, StringUtils::escapeXML(getID())).writeAttr("nVehContrib", contrib);
522 103212 : dev.writeAttr("flow", flow).writeAttr("occupancy", occupancy).writeAttr("speed", meanSpeed).writeAttr("harmonicMeanSpeed", harmonicMeanSpeed);
523 103212 : dev.writeAttr("length", meanLength).writeAttr("nVehEntered", myEnteredVehicleNumber).closeTag();
524 103212 : reset();
525 : }
526 :
527 :
528 : void
529 27632864 : MSInductLoop::detectorUpdate(const SUMOTime /* step */) {
530 27632864 : if (myDetectPersons == (int)PersonMode::NONE) {
531 : return;
532 : }
533 78592 : if (myLane->hasPedestrians()) {
534 202640 : for (MSTransportable* p : myLane->getEdge().getPersons()) {
535 183844 : if (p->getLane() != myLane || !vehicleApplies(*p)) {
536 28504 : continue;
537 : }
538 155340 : notifyMovePerson(p, p->getDirection(), p->getPositionOnLane());
539 : }
540 : }
541 : }
542 :
543 :
544 : void
545 158544 : MSInductLoop::notifyMovePerson(MSTransportable* p, int dir, double pos) {
546 158544 : if (personApplies(*p, dir)) {
547 114112 : const double newSpeed = p->getSpeed();
548 114112 : const double newPos = (dir == MSPModel::FORWARD
549 114112 : ? pos
550 : // position relative to detector
551 31992 : : myPosition - (pos - myPosition));
552 114112 : const double oldPos = newPos - SPEED2DIST(newSpeed);
553 114112 : if (oldPos - p->getVehicleType().getLength() <= myPosition) {
554 80988 : notifyMove(*p, oldPos, newPos, newSpeed);
555 : }
556 : }
557 158544 : }
558 :
559 :
560 : std::vector<MSInductLoop::VehicleData>
561 118985 : MSInductLoop::collectVehiclesOnDet(SUMOTime tMS, bool includeEarly, bool leaveTime, bool forOccupancy, bool lastInterval) const {
562 : #ifdef HAVE_FOX
563 118985 : ScopedLocker<> lock(myNotificationMutex, myNeedLock);
564 : #endif
565 118985 : const double t = STEPS2TIME(tMS);
566 : std::vector<VehicleData> ret;
567 1198389 : for (const VehicleData& i : myVehicleDataCont) {
568 1079404 : if ((includeEarly || !i.leftEarlyM) && (!lastInterval || i.entryTimeM < t)) {
569 1075636 : if (i.entryTimeM >= t || (leaveTime && i.leaveTimeM >= t)) {
570 6578 : ret.push_back(i);
571 : }
572 : }
573 : }
574 716516 : for (const VehicleData& i : myLastVehicleDataCont) {
575 597531 : if (includeEarly || !i.leftEarlyM) {
576 597531 : if ((!lastInterval && (i.entryTimeM >= t || (leaveTime && i.leaveTimeM >= t)))
577 8160 : || (lastInterval && i.leaveTimeM <= t + STEPS2TIME(myLastIntervalEnd - myLastIntervalBegin))) { // TODO: check duration of last interval
578 8689 : ret.push_back(i);
579 : }
580 : }
581 : }
582 129338 : for (const auto& i : myVehiclesOnDet) {
583 10353 : if ((!lastInterval && (i.second >= t || leaveTime || forOccupancy))
584 96 : || (lastInterval && i.second < t && t - i.second < STEPS2TIME(DELTA_T))) { // no need to check leave time, they are still on the detector
585 10249 : SUMOTrafficObject* const v = i.first;
586 10249 : VehicleData d(*v, i.second, HAS_NOT_LEFT_DETECTOR, false);
587 10249 : d.speedM = v->getSpeed();
588 10249 : ret.push_back(d);
589 : }
590 : }
591 118985 : return ret;
592 0 : }
593 :
594 :
595 1194190 : MSInductLoop::VehicleData::VehicleData(const SUMOTrafficObject& v, double entryTimestep,
596 1194190 : double leaveTimestep, const bool leftEarly, const double detLength)
597 1194190 : : idM(v.getID()), lengthM(v.getVehicleType().getLength()), entryTimeM(entryTimestep), leaveTimeM(leaveTimestep),
598 1204439 : speedM((v.getVehicleType().getLength() + detLength) / MAX2(leaveTimestep - entryTimestep, NUMERICAL_EPS)), typeIDM(v.getVehicleType().getID()),
599 1194190 : leftEarlyM(leftEarly) {}
600 :
601 :
602 : void
603 16 : MSInductLoop::clearState(SUMOTime time) {
604 16 : myLastLeaveTime = STEPS2TIME(time);
605 16 : myEnteredVehicleNumber = 0;
606 16 : myLastVehicleDataCont.clear();
607 16 : myVehicleDataCont.clear();
608 : myVehiclesOnDet.clear();
609 16 : }
610 :
611 : /****************************************************************************/
|