Eclipse SUMO - Simulation of Urban MObility
MSDevice_BTreceiver.cpp
Go to the documentation of this file.
1/****************************************************************************/
2// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3// Copyright (C) 2013-2022 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/****************************************************************************/
20// A BT Receiver
21/****************************************************************************/
22#include <config.h>
23
28#include <utils/geom/Position.h>
30#include <microsim/MSNet.h>
31#include <microsim/MSLane.h>
32#include <microsim/MSEdge.h>
33#include <microsim/MSVehicle.h>
37#include "MSDevice_Tripinfo.h"
38#include "MSDevice_BTreceiver.h"
39#include "MSDevice_BTsender.h"
40
41
42// ===========================================================================
43// static members
44// ===========================================================================
50std::map<std::string, MSDevice_BTreceiver::VehicleInformation*> MSDevice_BTreceiver::sVehicles;
51
52
53// ===========================================================================
54// method definitions
55// ===========================================================================
56// ---------------------------------------------------------------------------
57// static initialisation methods
58// ---------------------------------------------------------------------------
59
60void
62 insertDefaultAssignmentOptions("btreceiver", "Communication", oc);
63
64 oc.doRegister("device.btreceiver.range", new Option_Float(300));
65 oc.addDescription("device.btreceiver.range", "Communication", "The range of the bt receiver");
66
67 oc.doRegister("device.btreceiver.all-recognitions", new Option_Bool(false));
68 oc.addDescription("device.btreceiver.all-recognitions", "Communication", "Whether all recognition point shall be written");
69
70 oc.doRegister("device.btreceiver.offtime", new Option_Float(0.64));
71 oc.addDescription("device.btreceiver.offtime", "Communication", "The offtime used for calculating detection probability (in seconds)");
72
73 myWasInitialised = false;
74 myHasPersons = false;
75}
76
77
78void
79MSVehicleDevice_BTreceiver::buildVehicleDevices(SUMOVehicle& v, std::vector<MSVehicleDevice*>& into) {
81 if (equippedByDefaultAssignmentOptions(oc, "btreceiver", v, false)) {
82 MSVehicleDevice_BTreceiver* device = new MSVehicleDevice_BTreceiver(v, "btreceiver_" + v.getID());
83 into.push_back(device);
84 if (!myWasInitialised) {
85 new BTreceiverUpdate();
86 myWasInitialised = true;
87 myRange = oc.getFloat("device.btreceiver.range");
88 myOffTime = oc.getFloat("device.btreceiver.offtime");
89 sRecognitionRNG.seed(oc.getInt("seed"));
90 }
91 }
92}
93
94void
96 insertDefaultAssignmentOptions("btreceiver", "Communication", oc, true);
97}
98
99
100void
101MSTransportableDevice_BTreceiver::buildDevices(MSTransportable& t, std::vector<MSTransportableDevice*>& into) {
103 if (equippedByDefaultAssignmentOptions(oc, "btreceiver", t, false, true)) {
104 MSTransportableDevice_BTreceiver* device = new MSTransportableDevice_BTreceiver(t, "btreceiver_" + t.getID());
105 into.push_back(device);
106 myHasPersons = true;
107 if (!myWasInitialised) {
108 new BTreceiverUpdate();
109 myWasInitialised = true;
110 myRange = oc.getFloat("device.btreceiver.range");
111 myOffTime = oc.getFloat("device.btreceiver.offtime");
112 sRecognitionRNG.seed(oc.getInt("seed"));
113 }
114 }
115}
116
117// ---------------------------------------------------------------------------
118// MSDevice_BTreceiver::BTreceiverUpdate-methods
119// ---------------------------------------------------------------------------
122}
123
124
126 for (std::map<std::string, MSDevice_BTsender::VehicleInformation*>::const_iterator i = MSDevice_BTsender::sVehicles.begin(); i != MSDevice_BTsender::sVehicles.end(); ++i) {
127 (*i).second->amOnNet = false;
128 (*i).second->haveArrived = true;
129 }
130 for (std::map<std::string, MSDevice_BTreceiver::VehicleInformation*>::const_iterator i = MSDevice_BTreceiver::sVehicles.begin(); i != MSDevice_BTreceiver::sVehicles.end(); ++i) {
131 (*i).second->amOnNet = false;
132 (*i).second->haveArrived = true;
133 }
134 execute(MSNet::getInstance()->getCurrentTimeStep());
135}
136
137
140 // loop over equipped persons to update their positions
141 if (myHasPersons) {
143 for (MSTransportableControl::constVehIt i = c.loadedBegin(); i != c.loadedEnd(); ++i) {
144 MSTransportable* t = i->second;
148 if (snd) {
149 snd->notifyMove(*t, t->getPositionOnLane(), t->getPositionOnLane(), t->getSpeed());
150 if (MSDevice_BTsender::sVehicles[t->getID()]->route.back() != t->getEdge()) {
151 MSDevice_BTsender::sVehicles[t->getID()]->route.push_back(t->getEdge());
152 }
153 }
154 if (rec) {
155 rec->notifyMove(*t, t->getPositionOnLane(), t->getPositionOnLane(), t->getSpeed());
156 if (sVehicles[t->getID()]->route.back() != t->getEdge()) {
157 sVehicles[t->getID()]->route.push_back(t->getEdge());
158 }
159 }
160 }
161 }
162 }
163
164 // build rtree with senders
165 NamedRTree rt;
166 for (std::map<std::string, MSDevice_BTsender::VehicleInformation*>::const_iterator i = MSDevice_BTsender::sVehicles.begin(); i != MSDevice_BTsender::sVehicles.end(); ++i) {
168 Boundary b = vi->getBoxBoundary();
169 b.grow(POSITION_EPS);
170 const float cmin[2] = {(float) b.xmin(), (float) b.ymin()};
171 const float cmax[2] = {(float) b.xmax(), (float) b.ymax()};
172 rt.Insert(cmin, cmax, vi);
173 }
174
175 // check visibility for all receivers
177 bool allRecognitions = oc.getBool("device.btreceiver.all-recognitions");
178 bool haveOutput = oc.isSet("bt-output");
179 for (std::map<std::string, MSDevice_BTreceiver::VehicleInformation*>::iterator i = MSDevice_BTreceiver::sVehicles.begin(); i != MSDevice_BTreceiver::sVehicles.end();) {
180 // collect surrounding vehicles
182 Boundary b = vi->getBoxBoundary();
183 b.grow(vi->range);
184 const float cmin[2] = {(float) b.xmin(), (float) b.ymin()};
185 const float cmax[2] = {(float) b.xmax(), (float) b.ymax()};
186 std::set<const Named*> surroundingVehicles;
187 Named::StoringVisitor sv(surroundingVehicles);
188 rt.Search(cmin, cmax, sv);
189
190 // loop over surrounding vehicles, check visibility status
191 for (const Named* vehicle : surroundingVehicles) {
192 if ((*i).first == vehicle->getID()) {
193 // seeing oneself? skip
194 continue;
195 }
196 updateVisibility(*vi, *MSDevice_BTsender::sVehicles.find(vehicle->getID())->second);
197 }
198
199 if (vi->haveArrived) {
200 // vehicle has left the simulation; remove
201 if (haveOutput) {
202 writeOutput((*i).first, vi->seen, allRecognitions);
203 }
204 delete vi;
206 } else {
207 // vehicle is still in the simulation; reset state
208 vi->updates.erase(vi->updates.begin(), vi->updates.end() - 1);
209 ++i;
210 }
211 }
212
213 // remove arrived senders / reset state
214 for (std::map<std::string, MSDevice_BTsender::VehicleInformation*>::iterator i = MSDevice_BTsender::sVehicles.begin(); i != MSDevice_BTsender::sVehicles.end();) {
216 if (vi->haveArrived) {
217 delete vi;
219 } else {
220 vi->updates.erase(vi->updates.begin(), vi->updates.end() - 1);
221 ++i;
222 }
223 }
224 return DELTA_T;
225}
226
227
228void
231 const MSDevice_BTsender::VehicleState& receiverData = receiver.updates.back();
232 const MSDevice_BTsender::VehicleState& senderData = sender.updates.back();
233 if (!receiver.amOnNet || !sender.amOnNet) {
234 // at least one of the vehicles has left the simulation area for any reason
235 if (receiver.currentlySeen.find(sender.getID()) != receiver.currentlySeen.end()) {
236 leaveRange(receiver, receiverData, sender, senderData, 0);
237 }
238 }
239
240 const Position& oldReceiverPosition = receiver.updates.front().position;
241 const Position& oldSenderPosition = sender.updates.front().position;
242
243 // let the other's current position be the one obtained by applying the relative direction vector to the initial position
244 const Position senderDelta = senderData.position - oldSenderPosition;
245 const Position receiverDelta = receiverData.position - oldReceiverPosition;
246 const Position translatedSender = senderData.position - receiverDelta;
247 // find crossing points
248 std::vector<double> intersections;
249 GeomHelper::findLineCircleIntersections(oldReceiverPosition, receiver.range, oldSenderPosition, translatedSender, intersections);
250 switch (intersections.size()) {
251 case 0:
252 // no intersections -> other vehicle either stays within or beyond range
253 if (receiver.amOnNet && sender.amOnNet && receiverData.position.distanceTo(senderData.position) < receiver.range) {
254 if (receiver.currentlySeen.find(sender.getID()) == receiver.currentlySeen.end()) {
255 enterRange(0., receiverData, sender.getID(), senderData, receiver.currentlySeen);
256 } else {
257 addRecognitionPoint(SIMTIME, receiverData, senderData, receiver.currentlySeen[sender.getID()]);
258 }
259 } else {
260 if (receiver.currentlySeen.find(sender.getID()) != receiver.currentlySeen.end()) {
261 leaveRange(receiver, receiverData, sender, senderData, 0.);
262 }
263 }
264 break;
265 case 1: {
266 // one intersection -> other vehicle either enters or leaves the range
267 MSDevice_BTsender::VehicleState intersection1ReceiverData(receiverData);
268 intersection1ReceiverData.position = oldReceiverPosition + receiverDelta * intersections.front();
269 MSDevice_BTsender::VehicleState intersection1SenderData(senderData);
270 intersection1SenderData.position = oldSenderPosition + senderDelta * intersections.front();
271 if (receiver.currentlySeen.find(sender.getID()) != receiver.currentlySeen.end()) {
272 leaveRange(receiver, intersection1ReceiverData,
273 sender, intersection1SenderData, (intersections.front() - 1.) * TS);
274 } else {
275 enterRange((intersections.front() - 1.) * TS, intersection1ReceiverData,
276 sender.getID(), intersection1SenderData, receiver.currentlySeen);
277 }
278 }
279 break;
280 case 2:
281 // two intersections -> other vehicle enters and leaves the range
282 if (receiver.currentlySeen.find(sender.getID()) == receiver.currentlySeen.end()) {
283 MSDevice_BTsender::VehicleState intersectionReceiverData(receiverData);
284 intersectionReceiverData.position = oldReceiverPosition + receiverDelta * intersections.front();
285 MSDevice_BTsender::VehicleState intersectionSenderData(senderData);
286 intersectionSenderData.position = oldSenderPosition + senderDelta * intersections.front();
287 enterRange((intersections.front() - 1.) * TS, intersectionReceiverData,
288 sender.getID(), intersectionSenderData, receiver.currentlySeen);
289 intersectionReceiverData.position = oldReceiverPosition + receiverDelta * intersections.back();
290 intersectionSenderData.position = oldSenderPosition + senderDelta * intersections.back();
291 leaveRange(receiver, intersectionReceiverData,
292 sender, intersectionSenderData, (intersections.back() - 1.) * TS);
293 } else {
294 WRITE_WARNING("The vehicle '" + sender.getID() + "' cannot be in the range of vehicle '" + receiver.getID() + "', leave, and enter it in one step.");
295 }
296 break;
297 default:
298 WRITE_WARNING(TL("Nope, a circle cannot be crossed more often than twice by a line."));
299 break;
300 }
301}
302
303
304void
306 const std::string& senderID, const MSDevice_BTsender::VehicleState& senderState,
307 std::map<std::string, SeenDevice*>& currentlySeen) {
308 MeetingPoint mp(SIMTIME + atOffset, receiverState, senderState);
309 SeenDevice* sd = new SeenDevice(mp);
310 currentlySeen[senderID] = sd;
311 addRecognitionPoint(SIMTIME, receiverState, senderState, sd);
312}
313
314
315void
318 double tOffset) {
319 std::map<std::string, SeenDevice*>::iterator i = receiverInfo.currentlySeen.find(senderInfo.getID());
320 // check whether the other was recognized
321 addRecognitionPoint(SIMTIME + tOffset, receiverState, senderState, i->second);
322 // build leaving point
323 i->second->meetingEnd = new MeetingPoint(STEPS2TIME(MSNet::getInstance()->getCurrentTimeStep()) + tOffset, receiverState, senderState);
324 ConstMSEdgeVector::const_iterator begin = receiverInfo.route.begin() + i->second->meetingBegin.observerState.routePos;
325 ConstMSEdgeVector::const_iterator end = receiverInfo.route.begin() + receiverState.routePos + 1;
326 i->second->receiverRoute = toString<const MSEdge>(begin, end);
327 begin = senderInfo.route.begin() + i->second->meetingBegin.seenState.routePos;
328 end = senderInfo.route.begin() + senderState.routePos + 1;
329 i->second->senderRoute = toString<const MSEdge>(begin, end);
330 receiverInfo.seen[senderInfo.getID()].push_back(i->second);
331 receiverInfo.currentlySeen.erase(i);
332}
333
334
335double
337 const int phaseOffset = RandHelper::rand(2047, &sRecognitionRNG);
338 const bool interlaced = RandHelper::rand(&sRecognitionRNG) < 0.7;
339 const double delaySlots = RandHelper::rand(&sRecognitionRNG) * 15;
340 const int backoff = RandHelper::rand(backoffLimit, &sRecognitionRNG);
341 if (interlaced) {
342 return RandHelper::rand(&sRecognitionRNG) * 31 + backoff;
343 }
344 if (RandHelper::rand(31, &sRecognitionRNG) < 16) {
345 // correct train for f0
346 return delaySlots + backoff;
347 }
348 if (RandHelper::rand(30, &sRecognitionRNG) < 16) {
349 // correct train for f1
350 return 2048 - phaseOffset + delaySlots + backoff;
351 }
352 if (RandHelper::rand(29, &sRecognitionRNG) < 16) {
353 // f2 is in train A but has overlap with both trains
354 if (2 * 2048 - phaseOffset + backoff < 4096) {
355 return 2 * 2048 - phaseOffset + delaySlots + backoff;
356 }
357 // the following is wrong but should only happen in about 3% of the non-interlaced cases
358 return 2 * 2048 - phaseOffset + delaySlots + backoff;
359 }
360 return 2 * 2048 + delaySlots + backoff;
361}
362
363
364void
366 const MSDevice_BTsender::VehicleState& senderState,
367 SeenDevice* senderDevice) const {
368 if (senderDevice->nextView == -1.) {
369 senderDevice->nextView = senderDevice->lastView + inquiryDelaySlots(int(myOffTime / 0.000625 + .5)) * 0.000625;
370 }
371 if (tEnd > senderDevice->nextView) {
372 senderDevice->lastView = senderDevice->nextView;
373 MeetingPoint* mp = new MeetingPoint(tEnd, receiverState, senderState);
374 senderDevice->recognitionPoints.push_back(mp);
375 senderDevice->nextView = senderDevice->lastView + inquiryDelaySlots(int(myOffTime / 0.000625 + .5)) * 0.000625;
376 }
377}
378
379
380void
381MSDevice_BTreceiver::BTreceiverUpdate::writeOutput(const std::string& id, const std::map<std::string, std::vector<SeenDevice*> >& seen, bool allRecognitions) {
383 os.openTag("bt").writeAttr("id", id);
384 for (std::map<std::string, std::vector<SeenDevice*> >::const_iterator j = seen.begin(); j != seen.end(); ++j) {
385 const std::vector<SeenDevice*>& sts = (*j).second;
386 for (std::vector<SeenDevice*>::const_iterator k = sts.begin(); k != sts.end(); ++k) {
387 os.openTag("seen").writeAttr("id", (*j).first);
388 const MSDevice_BTsender::VehicleState& obsBeg = (*k)->meetingBegin.observerState;
389 const MSDevice_BTsender::VehicleState& seenBeg = (*k)->meetingBegin.seenState;
390 os.writeAttr("tBeg", (*k)->meetingBegin.t)
391 .writeAttr("observerPosBeg", obsBeg.position).writeAttr("observerSpeedBeg", obsBeg.speed)
392 .writeAttr("observerLaneIDBeg", obsBeg.laneID).writeAttr("observerLanePosBeg", obsBeg.lanePos)
393 .writeAttr("seenPosBeg", seenBeg.position).writeAttr("seenSpeedBeg", seenBeg.speed)
394 .writeAttr("seenLaneIDBeg", seenBeg.laneID).writeAttr("seenLanePosBeg", seenBeg.lanePos);
395 const MSDevice_BTsender::VehicleState& obsEnd = (*k)->meetingEnd->observerState;
396 const MSDevice_BTsender::VehicleState& seenEnd = (*k)->meetingEnd->seenState;
397 os.writeAttr("tEnd", (*k)->meetingEnd->t)
398 .writeAttr("observerPosEnd", obsEnd.position).writeAttr("observerSpeedEnd", obsEnd.speed)
399 .writeAttr("observerLaneIDEnd", obsEnd.laneID).writeAttr("observerLanePosEnd", obsEnd.lanePos)
400 .writeAttr("seenPosEnd", seenEnd.position).writeAttr("seenSpeedEnd", seenEnd.speed)
401 .writeAttr("seenLaneIDEnd", seenEnd.laneID).writeAttr("seenLanePosEnd", seenEnd.lanePos)
402 .writeAttr("observerRoute", (*k)->receiverRoute).writeAttr("seenRoute", (*k)->senderRoute);
403 for (std::vector<MeetingPoint*>::iterator l = (*k)->recognitionPoints.begin(); l != (*k)->recognitionPoints.end(); ++l) {
404 os.openTag("recognitionPoint").writeAttr("t", (*l)->t)
405 .writeAttr("observerPos", (*l)->observerState.position).writeAttr("observerSpeed", (*l)->observerState.speed)
406 .writeAttr("observerLaneID", (*l)->observerState.laneID).writeAttr("observerLanePos", (*l)->observerState.lanePos)
407 .writeAttr("seenPos", (*l)->seenState.position).writeAttr("seenSpeed", (*l)->seenState.speed)
408 .writeAttr("seenLaneID", (*l)->seenState.laneID).writeAttr("seenLanePos", (*l)->seenState.lanePos)
409 .closeTag();
410 if (!allRecognitions) {
411 break;
412 }
413 }
414 os.closeTag();
415 }
416 }
417 os.closeTag();
418}
419
420
421
422
423// ---------------------------------------------------------------------------
424// MSDevice_BTreceiver-methods
425// ---------------------------------------------------------------------------
426
428}
429
430
431bool
433 if (reason == MSMoveReminder::NOTIFICATION_DEPARTED && sVehicles.find(veh.getID()) == sVehicles.end()) {
434 sVehicles[veh.getID()] = new VehicleInformation(veh.getID(), myRange);
435 sVehicles[veh.getID()]->route.push_back(veh.getEdge());
436 }
437 if (reason == MSMoveReminder::NOTIFICATION_TELEPORT && sVehicles.find(veh.getID()) != sVehicles.end()) {
438 sVehicles[veh.getID()]->amOnNet = true;
439 }
441 sVehicles[veh.getID()]->route.push_back(veh.getEdge());
442 }
443 const std::string location = MSDevice_BTsender::getLocation(veh);
444 sVehicles[veh.getID()]->updates.push_back(MSDevice_BTsender::VehicleState(veh.getSpeed(), veh.getPosition(), location, veh.getPositionOnLane(), veh.getRoutePosition()));
445 return true;
446}
447
448
449bool
450MSDevice_BTreceiver::notifyMove(SUMOTrafficObject& veh, double /* oldPos */, double newPos, double newSpeed) {
451 if (sVehicles.find(veh.getID()) == sVehicles.end()) {
452 WRITE_WARNING("btreceiver: Can not update position of vehicle '" + veh.getID() + "' which is not on the road.");
453 return true;
454 }
455 const std::string location = MSDevice_BTsender::getLocation(veh);
456 sVehicles[veh.getID()]->updates.push_back(MSDevice_BTsender::VehicleState(newSpeed, veh.getPosition(), location, newPos, veh.getRoutePosition()));
457 return true;
458}
459
460
461bool
462MSDevice_BTreceiver::notifyLeave(SUMOTrafficObject& veh, double /* lastPos */, MSMoveReminder::Notification reason, const MSLane* /* enteredLane */) {
464 return true;
465 }
466 if (sVehicles.find(veh.getID()) == sVehicles.end()) {
467 WRITE_WARNING("btreceiver: Can not update position of vehicle '" + veh.getID() + "' which is not on the road.");
468 return true;
469 }
470 const std::string location = MSDevice_BTsender::getLocation(veh);
471 sVehicles[veh.getID()]->updates.push_back(MSDevice_BTsender::VehicleState(veh.getSpeed(), veh.getPosition(), location, veh.getPositionOnLane(), veh.getRoutePosition()));
473 sVehicles[veh.getID()]->amOnNet = false;
474 }
476 sVehicles[veh.getID()]->amOnNet = false;
477 sVehicles[veh.getID()]->haveArrived = true;
478 }
479 return true;
480}
481
482
483/****************************************************************************/
long long int SUMOTime
Definition: GUI.h:36
#define WRITE_WARNING(msg)
Definition: MsgHandler.h:265
#define TL(string)
Definition: MsgHandler.h:282
SUMOTime DELTA_T
Definition: SUMOTime.cpp:37
#define STEPS2TIME(x)
Definition: SUMOTime.h:54
#define TS
Definition: SUMOTime.h:41
#define SIMTIME
Definition: SUMOTime.h:61
A class that stores a 2D geometrical boundary.
Definition: Boundary.h:39
double ymin() const
Returns minimum y-coordinate.
Definition: Boundary.cpp:130
double xmin() const
Returns minimum x-coordinate.
Definition: Boundary.cpp:118
Boundary & grow(double by)
extends the boundary by the given amount
Definition: Boundary.cpp:300
double ymax() const
Returns maximum y-coordinate.
Definition: Boundary.cpp:136
double xmax() const
Returns maximum x-coordinate.
Definition: Boundary.cpp:124
static void findLineCircleIntersections(const Position &c, double radius, const Position &p1, const Position &p2, std::vector< double > &into)
Returns the positions the given circle is crossed by the given line.
Definition: GeomHelper.cpp:46
void leaveRange(VehicleInformation &receiverInfo, const MSDevice_BTsender::VehicleState &receiverState, MSDevice_BTsender::VehicleInformation &senderInfo, const MSDevice_BTsender::VehicleState &senderState, double tOffset)
Removes the sender from the currently seen devices to past episodes.
void writeOutput(const std::string &id, const std::map< std::string, std::vector< SeenDevice * > > &seen, bool allRecognitions)
Writes the output.
void addRecognitionPoint(const double tEnd, const MSDevice_BTsender::VehicleState &receiverState, const MSDevice_BTsender::VehicleState &senderState, SeenDevice *senderDevice) const
Adds a point of recognition.
void enterRange(double atOffset, const MSDevice_BTsender::VehicleState &receiverState, const std::string &senderID, const MSDevice_BTsender::VehicleState &senderState, std::map< std::string, SeenDevice * > &currentlySeen)
Informs the receiver about a sender entering it's radius.
void updateVisibility(VehicleInformation &receiver, MSDevice_BTsender::VehicleInformation &sender)
Rechecks the visibility for a given receiver/sender pair.
SUMOTime execute(SUMOTime currentTime)
Performs the update.
Holds the information about exact positions/speeds/time of the begin/end of a meeting.
Class representing a single seen device.
double nextView
Next possible recognition point.
double lastView
Last recognition point.
std::vector< MeetingPoint * > recognitionPoints
List of recognition points.
Stores the information of a vehicle.
std::map< std::string, SeenDevice * > currentlySeen
The map of devices seen by the vehicle at removal time.
std::map< std::string, std::vector< SeenDevice * > > seen
The past episodes of removed vehicle.
const double range
Recognition range of the vehicle.
static bool myWasInitialised
Whether the bt-system was already initialised.
static double inquiryDelaySlots(const int backoffLimit)
static double myRange
The range of the device.
bool notifyMove(SUMOTrafficObject &veh, double oldPos, double newPos, double newSpeed)
Checks whether the reminder still has to be notified about the vehicle moves.
static SumoRNG sRecognitionRNG
A random number generator used to determine whether the opposite was recognized.
static std::map< std::string, VehicleInformation * > sVehicles
The list of arrived receivers.
bool notifyEnter(SUMOTrafficObject &veh, MSMoveReminder::Notification reason, const MSLane *enteredLane=0)
Adds the vehicle to running vehicles if it (re-) enters the network.
static bool myHasPersons
Whether the bt-system includes persons.
bool notifyLeave(SUMOTrafficObject &veh, double lastPos, MSMoveReminder::Notification reason, const MSLane *enteredLane=0)
Moves (the known) vehicle from running to arrived vehicles' list.
static double myOffTime
The offtime of the device.
Stores the information of a vehicle.
bool amOnNet
Whether the vehicle is within the simulated network.
bool haveArrived
Whether the vehicle was removed from the simulation.
ConstMSEdgeVector route
List of edges travelled.
Boundary getBoxBoundary() const
Returns the boundary of passed positions.
std::vector< VehicleState > updates
List of position updates during last step.
A single movement state of the vehicle.
int routePos
The position in the route of the vehicle.
double speed
The speed of the vehicle.
Position position
The position of the vehicle.
double lanePos
The position at the lane of the vehicle.
std::string laneID
The lane the vehicle was at.
static std::string getLocation(const SUMOTrafficObject &o)
return either lane or edge id (depending on availability)
bool notifyMove(SUMOTrafficObject &veh, double oldPos, double newPos, double newSpeed)
Checks whether the reminder still has to be notified about the vehicle moves.
static std::map< std::string, VehicleInformation * > sVehicles
The list of arrived senders.
static void insertDefaultAssignmentOptions(const std::string &deviceName, const std::string &optionsTopic, OptionsCont &oc, const bool isPerson=false)
Adds common command options that allow to assign devices to vehicles.
Definition: MSDevice.cpp:144
static bool equippedByDefaultAssignmentOptions(const OptionsCont &oc, const std::string &deviceName, DEVICEHOLDER &v, bool outputOptionSet, const bool isPerson=false)
Determines whether a vehicle should get a certain device.
Definition: MSDevice.h:202
virtual void addEvent(Command *operation, SUMOTime execTimeStep=-1)
Adds an Event.
Representation of a lane in the micro simulation.
Definition: MSLane.h:84
Notification
Definition of a vehicle state.
@ NOTIFICATION_ARRIVED
The vehicle arrived at its destination (is deleted)
@ NOTIFICATION_DEPARTED
The vehicle has departed (was inserted into the network)
@ NOTIFICATION_JUNCTION
The vehicle arrived at a junction.
@ NOTIFICATION_TELEPORT
The vehicle is being teleported.
static MSNet * getInstance()
Returns the pointer to the unique instance of MSNet (singleton).
Definition: MSNet.cpp:183
MSEventControl * getEndOfTimestepEvents()
Returns the event control for events executed at the end of a time step.
Definition: MSNet.h:482
virtual MSTransportableControl & getPersonControl()
Returns the person control.
Definition: MSNet.cpp:1096
constVehIt loadedBegin() const
Returns the begin of the internal transportables map.
constVehIt loadedEnd() const
Returns the end of the internal transportables map.
std::map< std::string, MSTransportable * >::const_iterator constVehIt
Definition of the internal transportables map iterator.
static void insertOptions(OptionsCont &oc)
Inserts MSDevice_BTreceiver-options.
MSTransportableDevice_BTreceiver(MSTransportable &holder, const std::string &id)
Constructor.
static void buildDevices(MSTransportable &t, std::vector< MSTransportableDevice * > &into)
Build devices for the given vehicle, if needed.
virtual double getSpeed() const
the current speed of the transportable
MSTransportableDevice * getDevice(const std::type_info &type) const
Returns a device of the given type if it exists or 0.
double getPositionOnLane() const
Get the object's position along the lane.
MSStageType getCurrentStageType() const
the current stage type of the transportable
const MSEdge * getEdge() const
Returns the current edge.
MSVehicleDevice_BTreceiver(SUMOVehicle &holder, const std::string &id)
Constructor.
static void insertOptions(OptionsCont &oc)
Inserts MSDevice_BTreceiver-options.
static void buildVehicleDevices(SUMOVehicle &v, std::vector< MSVehicleDevice * > &into)
Build devices for the given vehicle, if needed.
Allows to store the object; used as context while traveling the rtree in TraCI.
Definition: Named.h:90
Base class for objects which have an id.
Definition: Named.h:54
const std::string & getID() const
Returns the id.
Definition: Named.h:74
A RT-tree for efficient storing of SUMO's Named objects.
Definition: NamedRTree.h:61
void Insert(const float a_min[2], const float a_max[2], Named *const &a_data)
Insert entry.
Definition: NamedRTree.h:79
int Search(const float a_min[2], const float a_max[2], const Named::StoringVisitor &c) const
Find all within search rectangle.
Definition: NamedRTree.h:112
A storage for options typed value containers)
Definition: OptionsCont.h:89
void addDescription(const std::string &name, const std::string &subtopic, const std::string &description)
Adds a description for an option.
void doRegister(const std::string &name, Option *v)
Adds an option under the given name.
Definition: OptionsCont.cpp:76
bool isSet(const std::string &name, bool failOnNonExistant=true) const
Returns the information whether the named option is set.
double getFloat(const std::string &name) const
Returns the double-value of the named option (only for Option_Float)
int getInt(const std::string &name) const
Returns the int-value of the named option (only for Option_Integer)
bool getBool(const std::string &name) const
Returns the boolean-value of the named option (only for Option_Bool)
static OptionsCont & getOptions()
Retrieves the options.
Definition: OptionsCont.cpp:59
Static storage of an output device and its base (abstract) implementation.
Definition: OutputDevice.h:61
OutputDevice & writeAttr(const SumoXMLAttr attr, const T &val)
writes a named attribute
Definition: OutputDevice.h:251
OutputDevice & openTag(const std::string &xmlElement)
Opens an XML tag.
static OutputDevice & getDeviceByOption(const std::string &name)
Returns the device described by the option.
bool closeTag(const std::string &comment="")
Closes the most recently opened tag and optionally adds a comment.
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:37
double distanceTo(const Position &p2) const
returns the euclidean distance in 3 dimension
Definition: Position.h:242
static double rand(SumoRNG *rng=nullptr)
Returns a random real number in [0, 1)
Definition: RandHelper.cpp:94
Representation of a vehicle, person, or container.
virtual double getSpeed() const =0
Returns the object's current speed.
virtual Position getPosition(const double offset=0) const =0
Return current position (x/y, cartesian)
virtual int getRoutePosition() const =0
return index of edge within route
virtual const MSEdge * getEdge() const =0
Returns the edge the object is currently at.
virtual double getPositionOnLane() const =0
Get the object's position along the lane.
Representation of a vehicle.
Definition: SUMOVehicle.h:60
static double sd[6]
Definition: odrSpiral.cpp:57