Eclipse SUMO - Simulation of Urban MObility
MEVehicle.cpp
Go to the documentation of this file.
1 /****************************************************************************/
2 // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3 // Copyright (C) 2001-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 /****************************************************************************/
19 // A vehicle from the mesoscopic point of view
20 /****************************************************************************/
21 #include <config.h>
22 
23 #include <iostream>
24 #include <cassert>
25 #include <utils/common/StdDefs.h>
33 #include <microsim/MSGlobals.h>
34 #include <microsim/MSEdge.h>
35 #include <microsim/MSLane.h>
36 #include <microsim/MSNet.h>
37 #include <microsim/MSVehicleType.h>
38 #include <microsim/MSLink.h>
39 #include <microsim/MSStop.h>
43 #include "MELoop.h"
44 #include "MEVehicle.h"
45 #include "MESegment.h"
46 
47 
48 // ===========================================================================
49 // method definitions
50 // ===========================================================================
52  MSVehicleType* type, const double speedFactor) :
53  MSBaseVehicle(pars, route, type, speedFactor),
54  mySegment(nullptr),
55  myQueIndex(0),
56  myEventTime(SUMOTime_MIN),
57  myLastEntryTime(SUMOTime_MIN),
58  myBlockTime(SUMOTime_MAX),
59  myInfluencer(nullptr) {
60  if (!(*myCurrEdge)->isTazConnector()) {
61  if ((*myCurrEdge)->allowedLanes(type->getVehicleClass()) == nullptr) {
62  throw ProcessError("Vehicle '" + pars->id + "' is not allowed to depart on any lane of edge '" + (*myCurrEdge)->getID() + "'.");
63  }
64  if (pars->departSpeedProcedure == DepartSpeedDefinition::GIVEN && pars->departSpeed > type->getMaxSpeed() + SPEED_EPS) {
65  throw ProcessError("Departure speed for vehicle '" + pars->id +
66  "' is too high for the vehicle type '" + type->getID() + "'.");
67  }
68  }
69 }
70 
71 
72 double
73 MEVehicle::getBackPositionOnLane(const MSLane* /* lane */) const {
75 }
76 
77 
78 double
80 // the following interpolation causes problems with arrivals and calibrators
81 // const double fracOnSegment = MIN2(double(1), STEPS2TIME(MSNet::getInstance()->getCurrentTimeStep() - myLastEntryTime) / STEPS2TIME(myEventTime - myLastEntryTime));
82  return mySegment == nullptr ? 0 : (double(mySegment->getIndex()) /* + fracOnSegment */) * mySegment->getLength();
83 }
84 
85 
86 double
88  const MSLane* const lane = getEdge()->getLanes()[0];
90 }
91 
92 
93 double
95  const MSLane* const lane = getEdge()->getLanes()[0];
97 }
98 
99 
100 Position
101 MEVehicle::getPosition(const double offset) const {
102  const MSLane* const lane = getEdge()->getLanes()[0];
103  return lane->geometryPositionAtOffset(getPositionOnLane() + offset);
104 }
105 
106 
107 double
109  if (getWaitingTime() > 0) {
110  return 0;
111  } else {
112  return getAverageSpeed();
113  }
114 }
115 
116 
117 double
119  return mySegment != nullptr ? mySegment->getLength() / STEPS2TIME(myEventTime - myLastEntryTime) : 0;
120 }
121 
122 
123 double
126  const double v = getSpeed();
127  return MIN2(link->getViaLaneOrLane()->getVehicleMaxSpeed(this),
128  (double)sqrt(2 * link->getLength() * getVehicleType().getCarFollowModel().getMaxAccel() + v * v));
129 }
130 
131 
132 double
133 MEVehicle::getConservativeSpeed(SUMOTime& earliestArrival) const {
134  earliestArrival = MAX2(myEventTime, earliestArrival - DELTA_T); // event times have subsecond resolution
135  return mySegment->getLength() / STEPS2TIME(earliestArrival - myLastEntryTime);
136 }
137 
138 
139 bool
141  // vehicle has just entered a new edge. Position is 0
142  if (myCurrEdge == myRoute->end() - 1 || (myParameter->arrivalEdge >= 0 && getRoutePosition() >= myParameter->arrivalEdge)) { // may happen during teleport
143  return true;
144  }
145  ++myCurrEdge;
146  if ((*myCurrEdge)->isVaporizing()) {
147  return true;
148  }
149  // update via
150  if (myParameter->via.size() > 0 && (*myCurrEdge)->getID() == myParameter->via.front()) {
151  myParameter->via.erase(myParameter->via.begin());
152  }
153  return hasArrived();
154 }
155 
156 
157 bool
159  // mySegment may be 0 due to teleporting or arrival
160  return (myCurrEdge == myRoute->end() - 1 || (myParameter->arrivalEdge >= 0 && getRoutePosition() >= myParameter->arrivalEdge)) && (
161  (mySegment == nullptr)
163  || getPositionOnLane() > myArrivalPos - POSITION_EPS);
164 }
165 
166 
167 bool
169  return getSegment() != nullptr;
170 }
171 
172 
173 bool
175  return false;
176 }
177 
178 
179 void
181  if (link != nullptr) {
182  const double speed = getSpeed();
183  link->setApproaching(this, getEventTime() + (link->getState() == LINKSTATE_ALLWAY_STOP ?
184  (SUMOTime)RandHelper::rand((int)2) : 0), // tie braker
185  speed, speed, true,
186  getEventTime(), speed, getWaitingTime(),
187  // @note: dist is not used by meso (getZipperSpeed is never called)
188  getSegment()->getLength(), 0);
189  }
190 }
191 
192 
193 bool
194 MEVehicle::replaceRoute(const MSRoute* newRoute, const std::string& info, bool onInit, int offset, bool addRouteStops, bool removeStops, std::string* msgReturn) {
195  MSLink* const oldLink = mySegment != nullptr ? mySegment->getLink(this) : nullptr;
196  if (MSBaseVehicle::replaceRoute(newRoute, info, onInit, offset, addRouteStops, removeStops, msgReturn)) {
197  if (mySegment != nullptr) {
198  MSLink* const newLink = mySegment->getLink(this);
199  // update approaching vehicle information
200  if (oldLink != newLink) {
201  if (oldLink != nullptr) {
202  oldLink->removeApproaching(this);
203  }
204  setApproaching(newLink);
205  }
206  }
207  return true;
208  }
209  return false;
210 }
211 
212 
213 SUMOTime
215  const SUMOTime initialTime = time;
216  bool hadStop = false;
217  MSNet* const net = MSNet::getInstance();
218  SUMOTime dummy = -1; // boarding- and loading-time are not considered
219  for (MSStop& stop : myStops) {
220  if (stop.edge != myCurrEdge || stop.segment != mySegment) {
221  break;
222  }
223  const SUMOTime cur = time;
224  if (stop.duration > 0) { // it might be a triggered stop with duration -1
225  time += stop.duration;
226  }
227  if (stop.pars.until > time) {
228  // @note: this assumes the stop is reached at time. With the way this is called in MESegment (time == entryTime),
229  // travel time is overestimated of the stop is not at the start of the segment
230  time = stop.pars.until;
231  }
232  if (MSGlobals::gUseStopEnded && stop.pars.ended >= 0) {
233  time = MAX2(cur, stop.pars.ended);
234  }
235  if (!stop.reached) {
236  stop.reached = true;
237  stop.pars.started = myLastEntryTime;
238 
239  if (MSStopOut::active()) {
240  if (!hadStop) {
242  } else {
243  WRITE_WARNINGF("Vehicle '%' has multiple stops on segment '%', time=% (stop-output will be merged).",
244  getID(), mySegment->getID(), time2string(time));
245  }
246  }
247  }
248  if (stop.triggered || stop.containerTriggered || stop.joinTriggered) {
249  bool wait = true;
250  if (stop.triggered && net->hasPersons()) {
251  wait = !net->getPersonControl().boardAnyWaiting(&mySegment->getEdge(), this, dummy, dummy);
252  }
253  if (stop.containerTriggered && net->hasContainers()) {
254  wait = !net->getContainerControl().loadAnyWaiting(&mySegment->getEdge(), this, dummy, dummy);
255  }
257  if (wait) {
259  } else {
260  stop.triggered = false;
261  stop.containerTriggered = false;
262  }
263  time = MAX2(time, cur + DELTA_T);
264  }
265  hadStop = true;
266  }
267  MSDevice_Tripinfo* tripinfo = static_cast<MSDevice_Tripinfo*>(getDevice(typeid(MSDevice_Tripinfo)));
268  if (tripinfo != nullptr) {
269  tripinfo->updateStopTime(time - initialTime);
270  }
271  return time;
272 }
273 
274 
275 bool
277  if (isStopped()) {
278  MSStop& stop = myStops.front();
279  MSDevice_Vehroutes* vehroutes = static_cast<MSDevice_Vehroutes*>(getDevice(typeid(MSDevice_Vehroutes)));
280  if (vehroutes != nullptr) {
281  vehroutes->stopEnded(stop.pars);
282  }
283  if (MSStopOut::active()) {
285  }
286  SUMOVehicleParameter::Stop pars = stop.pars;
287 // pars.depart = MSNet::getInstance()->getCurrentTimeStep();
288  myPastStops.emplace_back(pars);
289  if (stop.triggered || stop.containerTriggered || stop.joinTriggered) {
291  }
292  myStops.pop_front();
293  if (myEventTime > SIMSTEP) {
294  // if this is an aborted stop we need to change the event time of the vehicle
295  if (MSGlobals::gMesoNet->removeLeaderCar(this)) {
296  myEventTime = SIMSTEP + 1;
297  MSGlobals::gMesoNet->addLeaderCar(this, nullptr);
298  }
299  }
300  return true;
301  }
302  return false;
303 }
304 
305 
306 double
308  SUMOTime time = myLastEntryTime;
309  for (const MSStop& stop : myStops) {
310  if (stop.reached) {
311  time += stop.duration;
312  if (stop.pars.until > time) {
313  // @note: this assumes the stop is reached at time. With the way this is called in MESegment (time == entryTime),
314  // travel time is overestimated of the stop is not at the start of the segment
315  time = stop.pars.until;
316  }
317  } else {
318  break;
319  }
320  }
321  return STEPS2TIME(time - myLastEntryTime);
322 }
323 
324 
325 void
327  assert(isStopped());
328  double lastPos = 0;
329  bool hadStop = false;
330  while (!myStops.empty()) {
331  MSStop& stop = myStops.front();
332  if (stop.edge != myCurrEdge || stop.segment != mySegment || stop.pars.endPos <= lastPos) {
333  break;
334  }
335  lastPos = stop.pars.endPos;
336  MSNet* const net = MSNet::getInstance();
337  SUMOTime dummy = -1; // boarding- and loading-time are not considered
338  if (net->hasPersons()) {
339  net->getPersonControl().boardAnyWaiting(&mySegment->getEdge(), this, dummy, dummy);
340  }
341  if (net->hasContainers()) {
342  net->getContainerControl().loadAnyWaiting(&mySegment->getEdge(), this, dummy, dummy);
343  }
344  if (hadStop && MSStopOut::active()) {
346  }
348  hadStop = true;
349  }
351 }
352 
353 
354 bool
356  if (mySegment == nullptr) {
357  return true;
358  }
359  /*if (checkStop(myLastEntryTime) > myEventTime) {
360  // TODO refactor function to return expected time of continuation
361  return false;
362  }*/
363  MSNet* const net = MSNet::getInstance();
364  SUMOTime dummy = -1; // boarding- and loading-time are not considered
365  for (MSStop& stop : myStops) {
366  if (!stop.reached) {
367  break;
368  }
369  if (stop.triggered) {
370  if (getVehicleType().getPersonCapacity() == getPersonNumber()) {
371  // we could not check this on entering the segment because there may be persons who still want to leave
372  WRITE_WARNING("Vehicle '" + getID() + "' ignores triggered stop on lane '" + stop.lane->getID() + "' due to capacity constraints.");
373  stop.triggered = false;
375  } else if (!net->hasPersons() || !net->getPersonControl().boardAnyWaiting(&mySegment->getEdge(), this, dummy, dummy)) {
376  return false;
377  }
378  }
379  if (stop.containerTriggered) {
380  if (getVehicleType().getContainerCapacity() == getContainerNumber()) {
381  // we could not check this on entering the segment because there may be containers who still want to leave
382  WRITE_WARNING("Vehicle '" + getID() + "' ignores container triggered stop on lane '" + stop.lane->getID() + "' due to capacity constraints.");
383  stop.containerTriggered = false;
385  } else if (!net->hasContainers() || !net->getContainerControl().loadAnyWaiting(&mySegment->getEdge(), this, dummy, dummy)) {
386  return false;
387  }
388  }
389  if (stop.joinTriggered) {
390  return false;
391  }
392  }
393  return mySegment->isOpen(this);
394 }
395 
396 
397 double
399  if (mySegment == nullptr) {
400  return 0;
401  } else {
402  return STEPS2TIME(mySegment->getLinkPenalty(this));
403  }
404 }
405 
406 
407 void
409  for (MoveReminderCont::iterator i = myMoveReminders.begin(); i != myMoveReminders.end(); ++i) {
410  if (i->first == rem) {
412  (mySegment->getIndex() + 1) * mySegment->getLength(),
413  getLastEntryTime(), currentTime, exitTime, false);
414 #ifdef _DEBUG
415  if (myTraceMoveReminders) {
416  traceMoveReminder("notifyMove", i->first, i->second, true);
417  }
418 #endif
419  return;
420  }
421  }
422 }
423 
424 
425 void
426 MEVehicle::updateDetectors(SUMOTime currentTime, const bool isLeave, const MSMoveReminder::Notification reason) {
427  // segments of the same edge have the same reminder so no cleaning up must take place
428  const bool cleanUp = isLeave && (reason != MSMoveReminder::NOTIFICATION_SEGMENT);
429  for (MoveReminderCont::iterator rem = myMoveReminders.begin(); rem != myMoveReminders.end();) {
430  if (currentTime != getLastEntryTime()) {
431  rem->first->updateDetector(*this, mySegment->getIndex() * mySegment->getLength(),
432  (mySegment->getIndex() + 1) * mySegment->getLength(),
433  getLastEntryTime(), currentTime, getEventTime(), cleanUp);
434 #ifdef _DEBUG
435  if (myTraceMoveReminders) {
436  traceMoveReminder("notifyMove", rem->first, rem->second, true);
437  }
438 #endif
439  }
440  if (!isLeave || rem->first->notifyLeave(*this, mySegment->getLength(), reason)) {
441 #ifdef _DEBUG
442  if (isLeave && myTraceMoveReminders) {
443  traceMoveReminder("notifyLeave", rem->first, rem->second, true);
444  }
445 #endif
446  ++rem;
447  } else {
448 #ifdef _DEBUG
449  if (myTraceMoveReminders) {
450  traceMoveReminder("remove", rem->first, rem->second, false);
451  }
452 #endif
453  rem = myMoveReminders.erase(rem);
454  }
455  }
457  myOdometer += getEdge()->getLength();
458  }
459 }
460 
461 
464  if (myInfluencer == nullptr) {
466  }
467  return *myInfluencer;
468 }
469 
470 
473  return myInfluencer;
474 }
475 
476 
477 void
480  MSGlobals::gMesoNet->changeSegment(this, MSNet::getInstance()->getCurrentTimeStep(), nullptr, reason);
481 }
482 
483 void
485  if (mySegment != nullptr && MESegment::isInvalid(mySegment)) {
486  // segment is vaporization target, do not write this vehicle
487  return;
488  }
490  assert(mySegment == nullptr || *myCurrEdge == &mySegment->getEdge());
491  std::vector<SUMOTime> internals;
492  internals.push_back(myDeparture);
493  internals.push_back((SUMOTime)distance(myRoute->begin(), myCurrEdge));
494  internals.push_back((SUMOTime)myDepartPos * 1000); // store as mm
495  internals.push_back(mySegment == nullptr ? (SUMOTime) - 1 : (SUMOTime)mySegment->getIndex());
496  internals.push_back((SUMOTime)getQueIndex());
497  internals.push_back(myEventTime);
498  internals.push_back(myLastEntryTime);
499  internals.push_back(myBlockTime);
500  out.writeAttr(SUMO_ATTR_STATE, toString(internals));
501  // save past stops
503  stop.write(out, false);
504  out.writeAttr(SUMO_ATTR_STARTED, time2string(stop.started));
505  out.writeAttr(SUMO_ATTR_ENDED, time2string(stop.ended));
506  out.closeTag();
507  }
508  // save upcoming stops
509  for (const MSStop& stop : myStops) {
510  stop.write(out);
511  }
512  // save parameters
513  myParameter->writeParams(out);
514  for (MSDevice* dev : myDevices) {
515  dev->saveState(out);
516  }
517  out.closeTag();
518 }
519 
520 
521 void
522 MEVehicle::loadState(const SUMOSAXAttributes& attrs, const SUMOTime offset) {
523  if (attrs.hasAttribute(SUMO_ATTR_POSITION)) {
524  throw ProcessError("Error: Invalid vehicles in state (may be a micro state)!");
525  }
526  int routeOffset;
527  int segIndex;
528  int queIndex;
529  std::istringstream bis(attrs.getString(SUMO_ATTR_STATE));
530  bis >> myDeparture;
531  bis >> routeOffset;
532  bis >> myDepartPos;
533  bis >> segIndex;
534  bis >> queIndex;
535  bis >> myEventTime;
536  bis >> myLastEntryTime;
537  bis >> myBlockTime;
538  myDepartPos /= 1000.; // was stored as mm
539  if (hasDeparted()) {
540  myDeparture -= offset;
541  myEventTime -= offset;
542  myLastEntryTime -= offset;
543  myCurrEdge = myRoute->begin() + routeOffset;
544  if (segIndex >= 0) {
546  while (seg->getIndex() != (int)segIndex) {
547  seg = seg->getNextSegment();
548  assert(seg != 0);
549  }
550  setSegment(seg, queIndex);
551  } else {
552  // on teleport
553  setSegment(nullptr, 0);
554  assert(myEventTime != SUMOTime_MIN);
555  MSGlobals::gMesoNet->addLeaderCar(this, nullptr);
556  }
557  // see MSBaseVehicle constructor
560  }
561  }
562  if (myBlockTime != SUMOTime_MAX) {
563  myBlockTime -= offset;
564  }
565  std::istringstream dis(attrs.getString(SUMO_ATTR_DISTANCE));
566  dis >> myOdometer >> myNumberReroutes;
567 }
568 
569 
570 /****************************************************************************/
#define WRITE_WARNINGF(...)
Definition: MsgHandler.h:281
#define WRITE_WARNING(msg)
Definition: MsgHandler.h:280
SUMOTime DELTA_T
Definition: SUMOTime.cpp:37
std::string time2string(SUMOTime t)
convert SUMOTime to string
Definition: SUMOTime.cpp:68
#define STEPS2TIME(x)
Definition: SUMOTime.h:53
#define SIMSTEP
Definition: SUMOTime.h:59
#define SUMOTime_MAX
Definition: SUMOTime.h:33
#define SUMOTime_MIN
Definition: SUMOTime.h:34
long long int SUMOTime
Definition: SUMOTime.h:32
@ GIVEN
The speed is given.
const int VEHPARS_FORCE_REROUTE
@ LINKSTATE_ALLWAY_STOP
This is an uncontrolled, all-way stop link.
@ SUMO_ATTR_STARTED
@ SUMO_ATTR_ENDED
@ SUMO_ATTR_DISTANCE
@ SUMO_ATTR_POSITION
@ SUMO_ATTR_STATE
The state of a link.
T MIN2(T a, T b)
Definition: StdDefs.h:74
T MAX2(T a, T b)
Definition: StdDefs.h:80
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:46
SUMOTime changeSegment(MEVehicle *veh, SUMOTime leaveTime, MESegment *const toSegment, MSMoveReminder::Notification reason, const bool ignoreLink=false) const
change to the next segment this handles combinations of the following cases: (ending / continuing rou...
Definition: MELoop.cpp:79
MESegment * getSegmentForEdge(const MSEdge &e, double pos=0)
Get the segment for a given edge at a given position.
Definition: MELoop.cpp:314
bool removeLeaderCar(MEVehicle *v)
Removes the given car from the leading vehicles.
Definition: MELoop.cpp:225
void addLeaderCar(MEVehicle *veh, MSLink *link)
Adds the given car to the leading vehicles.
Definition: MELoop.cpp:212
A single mesoscopic segment (cell)
Definition: MESegment.h:49
bool isOpen(const MEVehicle *veh) const
Returns whether the vehicle may use the next link.
Definition: MESegment.cpp:440
SUMOTime getLinkPenalty(const MEVehicle *veh) const
Returns the penalty time for passing a link (if using gMesoTLSPenalty > 0 or gMesoMinorPenalty > 0)
Definition: MESegment.cpp:806
MSLink * getLink(const MEVehicle *veh, bool tlsPenalty=false) const
Returns the link the given car will use when passing the next junction.
Definition: MESegment.cpp:411
double getLength() const
Returns the length of the segment in meters.
Definition: MESegment.h:235
MESegment * getNextSegment() const
Returns the following segment on the same edge (0 if it is the last).
Definition: MESegment.h:227
const MSEdge & getEdge() const
Returns the edge this segment belongs to.
Definition: MESegment.h:352
int getIndex() const
Returns the running index of the segment in the edge (0 is the most upstream).
Definition: MESegment.h:219
static bool isInvalid(const MESegment *segment)
whether the given segment is 0 or encodes vaporization
Definition: MESegment.h:436
double getConservativeSpeed(SUMOTime &earliestArrival) const
Returns the vehicle's estimated speed taking into account delays.
Definition: MEVehicle.cpp:133
Position getPosition(const double offset=0) const
Return current position (x/y, cartesian)
Definition: MEVehicle.cpp:101
double getAverageSpeed() const
Returns the vehicle's estimated average speed on the segment assuming no further delays.
Definition: MEVehicle.cpp:118
double getAngle() const
Returns the vehicle's direction in degrees.
Definition: MEVehicle.cpp:87
double getBackPositionOnLane(const MSLane *lane) const
Get the vehicle's position relative to the given lane.
Definition: MEVehicle.cpp:73
SUMOTime myEventTime
The (planned) time of leaving the segment (cell)
Definition: MEVehicle.h:372
void onRemovalFromNet(const MSMoveReminder::Notification reason)
Called when the vehicle is removed from the network.
Definition: MEVehicle.cpp:478
void updateDetectorForWriting(MSMoveReminder *rem, SUMOTime currentTime, SUMOTime exitTime)
Updates a single vehicle detector if present.
Definition: MEVehicle.cpp:408
BaseInfluencer & getBaseInfluencer()
Returns the velocity/lane influencer.
Definition: MEVehicle.cpp:463
double getCurrentStoppingTimeSeconds() const
Returns the delay that is accrued due to option –meso-tls-penalty or –meso-minor-penalty.
Definition: MEVehicle.cpp:307
bool mayProceed()
Returns whether the vehicle is allowed to pass the next junction, checks also for triggered stops.
Definition: MEVehicle.cpp:355
double estimateLeaveSpeed(const MSLink *link) const
Returns the vehicle's estimated speed after driving accross the link.
Definition: MEVehicle.cpp:124
void processStop()
ends the current stop and performs loading/unloading
Definition: MEVehicle.cpp:326
bool hasArrived() const
Returns whether this vehicle has already arived (reached the arrivalPosition on its final edge)
Definition: MEVehicle.cpp:158
MEVehicle(SUMOVehicleParameter *pars, const MSRoute *route, MSVehicleType *type, const double speedFactor)
Constructor.
Definition: MEVehicle.cpp:51
bool moveRoutePointer()
Update when the vehicle enters a new edge in the move step.
Definition: MEVehicle.cpp:140
SUMOTime checkStop(SUMOTime time)
Returns until when to stop at the current segment and sets the information that the stop has been rea...
Definition: MEVehicle.cpp:214
void updateDetectors(SUMOTime currentTime, const bool isLeave, const MSMoveReminder::Notification reason=MSMoveReminder::NOTIFICATION_JUNCTION)
Updates all vehicle detectors.
Definition: MEVehicle.cpp:426
virtual bool isIdling() const
Returns whether the vehicle is trying to re-enter the net.
Definition: MEVehicle.cpp:174
SUMOTime getLastEntryTime() const
Returns the time the vehicle entered the current segment.
Definition: MEVehicle.h:263
double getPositionOnLane() const
Get the vehicle's position along the lane.
Definition: MEVehicle.cpp:79
SUMOTime myLastEntryTime
The time the vehicle entered its current segment.
Definition: MEVehicle.h:375
BaseInfluencer * myInfluencer
An instance of a velocity/lane influencing instance; built in "getInfluencer".
Definition: MEVehicle.h:381
void setApproaching(MSLink *link)
registers vehicle with the given link
Definition: MEVehicle.cpp:180
MESegment * getSegment() const
Returns the current segment the vehicle is on.
Definition: MEVehicle.h:239
void saveState(OutputDevice &out)
Saves the states of a vehicle.
Definition: MEVehicle.cpp:484
MESegment * mySegment
The segment the vehicle is at.
Definition: MEVehicle.h:366
int getQueIndex() const
Returns the index of the que the vehicle is in.
Definition: MEVehicle.h:247
SUMOTime getWaitingTime() const
Returns the duration for which the vehicle was blocked.
Definition: MEVehicle.h:286
bool replaceRoute(const MSRoute *route, const std::string &info, bool onInit=false, int offset=0, bool addRouteStops=true, bool removeStops=true, std::string *msgReturn=nullptr)
Replaces the current route by the given one.
Definition: MEVehicle.cpp:194
void loadState(const SUMOSAXAttributes &attrs, const SUMOTime offset)
Loads the state of this vehicle from the given description.
Definition: MEVehicle.cpp:522
virtual void setSegment(MESegment *s, int idx=0)
Sets the current segment the vehicle is at together with its que.
Definition: MEVehicle.h:230
double getCurrentLinkPenaltySeconds() const
Returns the delay that is accrued due to option –meso-tls-penalty or –meso-minor-penalty.
Definition: MEVehicle.cpp:398
SUMOTime getEventTime() const
Returns the (planned) time at which the vehicle leaves his current cell.
Definition: MEVehicle.h:221
bool isOnRoad() const
Returns the information whether the vehicle is on a road (is simulated)
Definition: MEVehicle.cpp:168
bool resumeFromStopping()
Definition: MEVehicle.cpp:276
double getSpeed() const
Returns the vehicle's estimated speed assuming no delays.
Definition: MEVehicle.cpp:108
double getSlope() const
Returns the slope of the road at vehicle's position in degrees.
Definition: MEVehicle.cpp:94
SUMOTime myBlockTime
The time at which the vehicle was blocked on its current segment.
Definition: MEVehicle.h:378
The base class for microscopic and mesoscopic vehicles.
Definition: MSBaseVehicle.h:51
MSVehicleDevice * getDevice(const std::type_info &type) const
Returns a device of the given type if it exists or 0.
std::list< MSStop > myStops
The vehicle's list of stops.
void calculateArrivalParams(bool onInit)
(Re-)Calculates the arrival position and lane from the vehicle parameters
MoveReminderCont myMoveReminders
Currently relevant move reminders.
double myDepartPos
The real depart position.
std::vector< MSVehicleDevice * > myDevices
The devices this vehicle has.
double getLength() const
Returns the vehicle's length.
const MSEdge * getEdge() const
Returns the edge the vehicle is currently at.
int getPersonNumber() const
Returns the number of persons.
MSRouteIterator myCurrEdge
Iterator to current route-edge.
bool hasDeparted() const
Returns whether this vehicle has already departed.
const MSRoute * myRoute
This vehicle's route.
const MSVehicleType & getVehicleType() const
Returns the vehicle's type definition.
virtual bool replaceRoute(const MSRoute *route, const std::string &info, bool onInit=false, int offset=0, bool addStops=true, bool removeStops=true, std::string *msgReturn=nullptr)
Replaces the current route by the given one.
SUMOTime myDeparture
The real departure time.
std::vector< SUMOVehicleParameter::Stop > myPastStops
The list of stops that the vehicle has already reached.
int getRoutePosition() const
return index of edge within route
const SUMOVehicleParameter * myParameter
This vehicle's parameter.
bool isStopped() const
Returns whether the vehicle is at a stop.
int myNumberReroutes
The number of reroutings.
double myArrivalPos
The position on the destination lane where the vehicle stops.
virtual void saveState(OutputDevice &out)
Saves the (common) state of a vehicle.
double myOdometer
A simple odometer to keep track of the length of the route already driven.
int getContainerNumber() const
Returns the number of containers.
A device which collects info on the vehicle trip (mainly on departure and arrival)
void updateStopTime(const SUMOTime time)
update stopping time for meso
A device which collects info on the vehicle trip (mainly on departure and arrival)
void stopEnded(const SUMOVehicleParameter::Stop &stop)
Abstract in-vehicle / in-person device.
Definition: MSDevice.h:61
const std::vector< MSLane * > & getLanes() const
Returns this edge's lanes.
Definition: MSEdge.h:168
double getLength() const
return the length of the edge
Definition: MSEdge.h:641
void removeWaiting(const SUMOVehicle *vehicle) const
Removes a vehicle from the list of waiting vehicles.
Definition: MSEdge.cpp:1239
static MELoop * gMesoNet
mesoscopic simulation infrastructure
Definition: MSGlobals.h:100
static bool gUseStopEnded
whether the simulation should replay previous stop times
Definition: MSGlobals.h:121
Representation of a lane in the micro simulation.
Definition: MSLane.h:82
double getVehicleMaxSpeed(const SUMOTrafficObject *const veh) const
Returns the lane's maximum speed, given a vehicle's speed limit adaptation.
Definition: MSLane.h:519
const PositionVector & getShape() const
Returns this lane's shape.
Definition: MSLane.h:478
double interpolateLanePosToGeometryPos(double lanePos) const
Definition: MSLane.h:499
const Position geometryPositionAtOffset(double offset, double lateralOffset=0) const
Definition: MSLane.h:505
Something on a lane to be noticed about vehicle movement.
Notification
Definition of a vehicle state.
@ NOTIFICATION_SEGMENT
The vehicle changes the segment (meso only)
@ NOTIFICATION_JUNCTION
The vehicle arrived at a junction.
@ NOTIFICATION_TELEPORT
The vehicle is being teleported.
void updateDetector(SUMOTrafficObject &veh, double entryPos, double leavePos, SUMOTime entryTime, SUMOTime currentTime, SUMOTime leaveTime, bool cleanUp)
The simulated network and simulation perfomer.
Definition: MSNet.h:88
static MSNet * getInstance()
Returns the pointer to the unique instance of MSNet (singleton).
Definition: MSNet.cpp:174
virtual MSTransportableControl & getContainerControl()
Returns the container control.
Definition: MSNet.cpp:1068
MSVehicleControl & getVehicleControl()
Returns the vehicle control.
Definition: MSNet.h:376
bool hasContainers() const
Returns whether containers are simulated.
Definition: MSNet.h:409
bool hasPersons() const
Returns whether persons are simulated.
Definition: MSNet.h:393
virtual MSTransportableControl & getPersonControl()
Returns the person control.
Definition: MSNet.cpp:1059
MSRouteIterator end() const
Returns the end of the list of edges to pass.
Definition: MSRoute.cpp:75
MSRouteIterator begin() const
Returns the begin of the list of edges to pass.
Definition: MSRoute.cpp:69
Definition: MSStop.h:44
bool triggered
whether an arriving person lets the vehicle continue
Definition: MSStop.h:69
bool containerTriggered
whether an arriving container lets the vehicle continue
Definition: MSStop.h:71
bool joinTriggered
whether coupling another vehicle (train) the vehicle continue
Definition: MSStop.h:73
const MESegment * segment
The segment to stop at (mesosim only)
Definition: MSStop.h:52
MSRouteIterator edge
The edge in the route to stop at.
Definition: MSStop.h:48
const SUMOVehicleParameter::Stop pars
The stop parameter.
Definition: MSStop.h:65
static MSStopOut * getInstance()
Definition: MSStopOut.h:60
static bool active()
Definition: MSStopOut.h:54
void stopStarted(const SUMOVehicle *veh, int numPersons, int numContainers, SUMOTime time)
Definition: MSStopOut.cpp:66
void stopEnded(const SUMOVehicle *veh, const SUMOVehicleParameter::Stop &stop, const std::string &laneOrEdgeID, bool simEnd=false)
Definition: MSStopOut.cpp:102
bool boardAnyWaiting(const MSEdge *edge, SUMOVehicle *vehicle, SUMOTime &timeToBoardNextPerson, SUMOTime &stopDuration)
board any applicable persons Boards any people who wait on that edge for the given vehicle and remove...
bool loadAnyWaiting(const MSEdge *edge, SUMOVehicle *vehicle, SUMOTime &timeToLoadNextContainer, SUMOTime &stopDuration)
load any applicable containers Loads any container that is waiting on that edge for the given vehicle...
void registerOneWaiting()
increases the count of vehicles waiting for a transport to allow recognition of person / container re...
void unregisterOneWaiting()
decreases the count of vehicles waiting for a transport to allow recognition of person / container re...
The car-following model and parameter.
Definition: MSVehicleType.h:62
SUMOVehicleClass getVehicleClass() const
Get this vehicle type's vehicle class.
double getMaxSpeed() const
Get vehicle's maximum speed [m/s].
const std::string & getID() const
Returns the name of the vehicle type.
Definition: MSVehicleType.h:90
double getLength() const
Get vehicle's length [m].
const std::string & getID() const
Returns the id.
Definition: Named.h:74
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:248
bool closeTag(const std::string &comment="")
Closes the most recently opened tag and optionally adds a comment.
void writeParams(OutputDevice &device) const
write Params in the given outputdevice
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:37
double rotationAtOffset(double pos) const
Returns the rotation at the given length.
double slopeDegreeAtOffset(double pos) const
Returns the slope at the given length.
static double rand(SumoRNG *rng=nullptr)
Returns a random real number in [0, 1)
Definition: RandHelper.h:119
Encapsulated SAX-Attributes.
virtual bool hasAttribute(int id) const =0
Returns the information whether the named (by its enum-value) attribute is within the current list.
virtual std::string getString(int id) const =0
Returns the string-value of the named (by its enum-value) attribute.
Definition of vehicle stop (position and duration)
double endPos
The stopping position end.
Structure representing possible vehicle parameter.
double departSpeed
(optional) The initial speed of the vehicle
std::vector< std::string > via
List of the via-edges the vehicle must visit.
DepartSpeedDefinition departSpeedProcedure
Information how the vehicle's initial speed shall be chosen.
std::string id
The vehicle's id.
bool wasSet(int what) const
Returns whether the given parameter was set.
int arrivalEdge
(optional) The final edge within the route of the vehicle