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>
33#include <microsim/MSGlobals.h>
34#include <microsim/MSEdge.h>
35#include <microsim/MSLane.h>
36#include <microsim/MSNet.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
72double
73MEVehicle::getBackPositionOnLane(const MSLane* /* lane */) const {
75}
76
77
78double
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
86double
88 const MSLane* const lane = getEdge()->getLanes()[0];
90}
91
92
93double
95 const MSLane* const lane = getEdge()->getLanes()[0];
97}
98
99
101MEVehicle::getPosition(const double offset) const {
102 const MSLane* const lane = getEdge()->getLanes()[0];
103 return lane->geometryPositionAtOffset(getPositionOnLane() + offset);
104}
105
106
107double
109 if (getWaitingTime() > 0 || isStopped()) {
110 return 0;
111 } else {
112 return getAverageSpeed();
113 }
114}
115
116
117double
119 return mySegment != nullptr ? MIN2(mySegment->getLength() / STEPS2TIME(myEventTime - myLastEntryTime), getEdge()->getVehicleMaxSpeed(this)) : 0;
120}
121
122
123double
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
132double
134 earliestArrival = MAX2(myEventTime, earliestArrival - DELTA_T); // event times have subsecond resolution
135 return mySegment->getLength() / STEPS2TIME(earliestArrival - myLastEntryTime);
136}
137
138
139bool
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
157bool
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
167bool
169 return getSegment() != nullptr;
170}
171
172
173bool
175 return false;
176}
177
178
179void
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 speed, getWaitingTime(),
187 // @note: dist is not used by meso (getZipperSpeed is never called)
188 getSegment()->getLength(), 0);
189 }
190}
191
192
193bool
194MEVehicle::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
215 const SUMOTime initialTime = time;
216 bool hadStop = false;
217 for (MSStop& stop : myStops) {
218 if (stop.joinTriggered) {
219 WRITE_WARNINGF(TL("Join stops are not available in meso yet (vehicle '%', segment '%')."),
220 getID(), mySegment->getID());
221 continue;
222 }
223 if (stop.edge != myCurrEdge || stop.segment != mySegment) {
224 break;
225 }
226 const SUMOTime cur = time;
227 if (stop.duration > 0) { // it might be a triggered stop with duration -1
228 time += stop.duration;
229 }
230 if (stop.pars.until > time) {
231 // @note: this assumes the stop is reached at time. With the way this is called in MESegment (time == entryTime),
232 // travel time is overestimated of the stop is not at the start of the segment
233 time = stop.pars.until;
234 }
235 if (MSGlobals::gUseStopEnded && stop.pars.ended >= 0) {
236 time = MAX2(cur, stop.pars.ended);
237 }
238 if (!stop.reached) {
239 stop.reached = true;
240 stop.pars.started = myLastEntryTime;
241 stop.endBoarding = stop.pars.extension >= 0 ? time + stop.pars.extension : SUMOTime_MAX;
242 if (MSStopOut::active()) {
243 if (!hadStop) {
245 } else {
246 WRITE_WARNINGF(TL("Vehicle '%' has multiple stops on segment '%', time=% (stop-output will be merged)."),
247 getID(), mySegment->getID(), time2string(time));
248 }
249 }
250 }
251 if (stop.triggered || stop.containerTriggered || stop.joinTriggered) {
252 time = MAX2(time, cur + DELTA_T);
253 }
254 hadStop = true;
255 }
256 MSDevice_Tripinfo* tripinfo = static_cast<MSDevice_Tripinfo*>(getDevice(typeid(MSDevice_Tripinfo)));
257 if (tripinfo != nullptr) {
258 tripinfo->updateStopTime(time - initialTime);
259 }
260 return time;
261}
262
263
264bool
266 if (isStopped()) {
267 const SUMOTime now = SIMSTEP;
268 MSStop& stop = myStops.front();
269 stop.pars.ended = now;
270 for (const auto& rem : myMoveReminders) {
271 rem.first->notifyStopEnded();
272 }
273 if (MSStopOut::active()) {
275 }
276 myPastStops.push_back(stop.pars);
280 }
281 myStops.pop_front();
282 if (myEventTime > now) {
283 // if this is an aborted stop we need to change the event time of the vehicle
284 if (MSGlobals::gMesoNet->removeLeaderCar(this)) {
285 myEventTime = now + 1;
286 MSGlobals::gMesoNet->addLeaderCar(this, nullptr);
287 }
288 }
289 return true;
290 }
291 return false;
292}
293
294
295double
298 for (const MSStop& stop : myStops) {
299 if (stop.reached) {
300 time += stop.duration;
301 if (stop.pars.until > time) {
302 // @note: this assumes the stop is reached at time. With the way this is called in MESegment (time == entryTime),
303 // travel time is overestimated of the stop is not at the start of the segment
304 time = stop.pars.until;
305 }
306 } else {
307 break;
308 }
309 }
310 return STEPS2TIME(time - myLastEntryTime);
311}
312
313
314void
316 assert(isStopped());
317 double lastPos = 0;
318 bool hadStop = false;
319 while (!myStops.empty()) {
320 MSStop& stop = myStops.front();
321 if (stop.edge != myCurrEdge || stop.segment != mySegment || stop.pars.endPos <= lastPos) {
322 break;
323 }
324 lastPos = stop.pars.endPos;
325 MSNet* const net = MSNet::getInstance();
326 SUMOTime dummy = -1; // boarding- and loading-time are not considered
327 if (net->hasPersons()) {
328 net->getPersonControl().loadAnyWaiting(&mySegment->getEdge(), this, dummy, dummy);
329 }
330 if (net->hasContainers()) {
331 net->getContainerControl().loadAnyWaiting(&mySegment->getEdge(), this, dummy, dummy);
332 }
333 if (hadStop && MSStopOut::active()) {
335 }
337 hadStop = true;
338 }
340}
341
342
343bool
345 if (mySegment == nullptr) {
346 return true;
347 }
348 MSNet* const net = MSNet::getInstance();
349 SUMOTime dummy = -1; // boarding- and loading-time are not considered
350 for (MSStop& stop : myStops) {
351 if (!stop.reached) {
352 break;
353 }
354 if (net->getCurrentTimeStep() > stop.endBoarding) {
355 stop.triggered = false;
356 stop.containerTriggered = false;
360 }
361 }
362 if (stop.triggered) {
363 if (getVehicleType().getPersonCapacity() == getPersonNumber()) {
364 // we could not check this on entering the segment because there may be persons who still want to leave
365 WRITE_WARNING("Vehicle '" + getID() + "' ignores triggered stop on lane '" + stop.lane->getID() + "' due to capacity constraints.");
366 stop.triggered = false;
370 }
371 } else if (!net->hasPersons() || !net->getPersonControl().loadAnyWaiting(&mySegment->getEdge(), this, dummy, dummy)) {
375 }
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;
387 }
388 } else if (!net->hasContainers() || !net->getContainerControl().loadAnyWaiting(&mySegment->getEdge(), this, dummy, dummy)) {
392 }
393 return false;
394 }
395 }
396 if (stop.joinTriggered) {
397 // TODO do something useful here
398 return false;
399 }
400 }
401 return mySegment->isOpen(this);
402}
403
404
405double
407 if (mySegment == nullptr) {
408 return 0;
409 } else {
410 return STEPS2TIME(mySegment->getLinkPenalty(this));
411 }
412}
413
414
415void
417 for (MoveReminderCont::iterator i = myMoveReminders.begin(); i != myMoveReminders.end(); ++i) {
418 if (i->first == rem) {
421 getLastEntryTime(), currentTime, exitTime, false);
422#ifdef _DEBUG
423 if (myTraceMoveReminders) {
424 traceMoveReminder("notifyMove", i->first, i->second, true);
425 }
426#endif
427 return;
428 }
429 }
430}
431
432
433void
434MEVehicle::updateDetectors(SUMOTime currentTime, const bool isLeave, const MSMoveReminder::Notification reason) {
435 // segments of the same edge have the same reminder so no cleaning up must take place
436 const bool cleanUp = isLeave && (reason != MSMoveReminder::NOTIFICATION_SEGMENT);
437 for (MoveReminderCont::iterator rem = myMoveReminders.begin(); rem != myMoveReminders.end();) {
438 if (currentTime != getLastEntryTime()) {
439 rem->first->updateDetector(*this, mySegment->getIndex() * mySegment->getLength(),
441 getLastEntryTime(), currentTime, getEventTime(), cleanUp);
442#ifdef _DEBUG
443 if (myTraceMoveReminders) {
444 traceMoveReminder("notifyMove", rem->first, rem->second, true);
445 }
446#endif
447 }
448 if (!isLeave || rem->first->notifyLeave(*this, mySegment->getLength(), reason)) {
449#ifdef _DEBUG
450 if (isLeave && myTraceMoveReminders) {
451 traceMoveReminder("notifyLeave", rem->first, rem->second, true);
452 }
453#endif
454 ++rem;
455 } else {
456#ifdef _DEBUG
457 if (myTraceMoveReminders) {
458 traceMoveReminder("remove", rem->first, rem->second, false);
459 }
460#endif
461 rem = myMoveReminders.erase(rem);
462 }
463 }
466 }
467}
468
469
472 if (myInfluencer == nullptr) {
474 }
475 return *myInfluencer;
476}
477
478
481 return myInfluencer;
482}
483
484
485void
488 MSGlobals::gMesoNet->changeSegment(this, MSNet::getInstance()->getCurrentTimeStep(), nullptr, reason);
489}
490
491double
492MEVehicle::getRightSideOnEdge(const MSLane* /*lane*/) const {
493 if (mySegment == nullptr || mySegment->getIndex() >= getEdge()->getNumLanes()) {
494 return 0;
495 }
496 const MSLane* lane = getEdge()->getLanes()[mySegment->getIndex()];
497 return lane->getRightSideOnEdge() + lane->getWidth() * 0.5 - 0.5 * getVehicleType().getWidth();
498
499}
500
501
502void
504 if (mySegment != nullptr && MESegment::isInvalid(mySegment)) {
505 // segment is vaporization target, do not write this vehicle
506 return;
507 }
509 assert(mySegment == nullptr || *myCurrEdge == &mySegment->getEdge());
510 std::vector<SUMOTime> internals;
511 internals.push_back(myParameter->parametersSet);
512 internals.push_back(myDeparture);
513 internals.push_back((SUMOTime)distance(myRoute->begin(), myCurrEdge));
514 internals.push_back((SUMOTime)myDepartPos * 1000); // store as mm
515 internals.push_back(mySegment == nullptr ? (SUMOTime) - 1 : (SUMOTime)mySegment->getIndex());
516 internals.push_back((SUMOTime)getQueIndex());
517 internals.push_back(myEventTime);
518 internals.push_back(myLastEntryTime);
519 internals.push_back(myBlockTime);
520 out.writeAttr(SUMO_ATTR_STATE, toString(internals));
521 // save past stops
523 stop.write(out, false);
524 // do not write started and ended twice
525 if ((stop.parametersSet & STOP_STARTED_SET) == 0) {
526 out.writeAttr(SUMO_ATTR_STARTED, time2string(stop.started));
527 }
528 if ((stop.parametersSet & STOP_ENDED_SET) == 0) {
529 out.writeAttr(SUMO_ATTR_ENDED, time2string(stop.ended));
530 }
531 out.closeTag();
532 }
533 // save upcoming stops
534 for (const MSStop& stop : myStops) {
535 stop.write(out);
536 }
537 // save parameters
539 for (MSDevice* dev : myDevices) {
540 dev->saveState(out);
541 }
542 out.closeTag();
543}
544
545
546void
548 if (attrs.hasAttribute(SUMO_ATTR_POSITION)) {
549 throw ProcessError("Error: Invalid vehicles in state (may be a micro state)!");
550 }
551 int routeOffset;
552 int segIndex;
553 int queIndex;
554 std::istringstream bis(attrs.getString(SUMO_ATTR_STATE));
556 bis >> myDeparture;
557 bis >> routeOffset;
558 bis >> myDepartPos;
559 bis >> segIndex;
560 bis >> queIndex;
561 bis >> myEventTime;
562 bis >> myLastEntryTime;
563 bis >> myBlockTime;
564 myDepartPos /= 1000.; // was stored as mm
565 if (hasDeparted()) {
566 myDeparture -= offset;
567 myEventTime -= offset;
568 myLastEntryTime -= offset;
569 myCurrEdge = myRoute->begin() + routeOffset;
570 if (segIndex >= 0) {
572 while (seg->getIndex() != (int)segIndex) {
573 seg = seg->getNextSegment();
574 assert(seg != 0);
575 }
576 setSegment(seg, queIndex);
577 if (queIndex == MESegment::PARKING_QUEUE) {
578 MSGlobals::gMesoNet->addLeaderCar(this, nullptr);
579 }
580 } else {
581 // on teleport
582 setSegment(nullptr, 0);
583 assert(myEventTime != SUMOTime_MIN);
584 MSGlobals::gMesoNet->addLeaderCar(this, nullptr);
585 }
586 // see MSBaseVehicle constructor
589 }
590 }
591 if (myBlockTime != SUMOTime_MAX) {
592 myBlockTime -= offset;
593 }
594 std::istringstream dis(attrs.getString(SUMO_ATTR_DISTANCE));
596}
597
598
599/****************************************************************************/
long long int SUMOTime
Definition: GUI.h:36
#define WRITE_WARNINGF(...)
Definition: MsgHandler.h:266
#define WRITE_WARNING(msg)
Definition: MsgHandler.h:265
#define TL(string)
Definition: MsgHandler.h:282
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:54
#define SIMSTEP
Definition: SUMOTime.h:60
#define SUMOTime_MAX
Definition: SUMOTime.h:33
#define SUMOTime_MIN
Definition: SUMOTime.h:34
@ GIVEN
The speed is given.
const int VEHPARS_FORCE_REROUTE
const int STOP_ENDED_SET
const int STOP_STARTED_SET
@ 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:71
T MAX2(T a, T b)
Definition: StdDefs.h:77
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
static const int PARKING_QUEUE
Definition: MESegment.h:52
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:231
const MSEdge & getEdge() const
Returns the edge this segment belongs to.
Definition: MESegment.h:348
int getIndex() const
Returns the running index of the segment in the edge (0 is the most upstream).
Definition: MESegment.h:215
static bool isInvalid(const MESegment *segment)
whether the given segment is 0 or encodes vaporization
Definition: MESegment.h:432
MESegment * getNextSegment() const
Returns the following segment on the same edge (0 if it is the last).
Definition: MESegment.h:223
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:378
void onRemovalFromNet(const MSMoveReminder::Notification reason)
Called when the vehicle is removed from the network.
Definition: MEVehicle.cpp:486
void updateDetectorForWriting(MSMoveReminder *rem, SUMOTime currentTime, SUMOTime exitTime)
Updates a single vehicle detector if present.
Definition: MEVehicle.cpp:416
BaseInfluencer & getBaseInfluencer()
Returns the velocity/lane influencer.
Definition: MEVehicle.cpp:471
double getCurrentStoppingTimeSeconds() const
Returns the delay that is accrued due to option –meso-tls-penalty or –meso-minor-penalty.
Definition: MEVehicle.cpp:296
bool mayProceed()
Returns whether the vehicle is allowed to pass the next junction, checks also for triggered stops.
Definition: MEVehicle.cpp:344
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:315
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:434
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:269
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:381
BaseInfluencer * myInfluencer
An instance of a velocity/lane influencing instance; built in "getInfluencer".
Definition: MEVehicle.h:387
void setApproaching(MSLink *link)
registers vehicle with the given link
Definition: MEVehicle.cpp:180
void saveState(OutputDevice &out)
Saves the states of a vehicle.
Definition: MEVehicle.cpp:503
MESegment * getSegment() const
Returns the current segment the vehicle is on.
Definition: MEVehicle.h:239
MESegment * mySegment
The segment the vehicle is at.
Definition: MEVehicle.h:372
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:292
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:547
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:406
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:265
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:384
double getRightSideOnEdge(const MSLane *) const
Get the vehicle's lateral position on the edge of the given lane (or its current edge if lane == 0)
Definition: MEVehicle.cpp:492
The base class for microscopic and mesoscopic vehicles.
Definition: MSBaseVehicle.h:55
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.
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
bool myAmRegisteredAsWaiting
Whether this vehicle is registered as waiting for a person or container (for deadlock-recognition)
const SUMOVehicleParameter * myParameter
This vehicle's parameter.
const MSVehicleType & getVehicleType() const
Returns the vehicle's type definition.
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
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:658
void removeWaiting(const SUMOVehicle *vehicle) const
Removes a vehicle from the list of waiting vehicles.
Definition: MSEdge.cpp:1312
static MELoop * gMesoNet
mesoscopic simulation infrastructure
Definition: MSGlobals.h:109
static bool gUseStopEnded
whether the simulation should replay previous stop times
Definition: MSGlobals.h:130
Representation of a lane in the micro simulation.
Definition: MSLane.h:84
const PositionVector & getShape() const
Returns this lane's shape.
Definition: MSLane.h:506
double getVehicleMaxSpeed(const SUMOTrafficObject *const veh) const
Returns the lane's maximum speed, given a vehicle's speed limit adaptation.
Definition: MSLane.h:547
double getRightSideOnEdge() const
Definition: MSLane.h:1118
double interpolateLanePosToGeometryPos(double lanePos) const
Definition: MSLane.h:527
double getWidth() const
Returns the lane's width.
Definition: MSLane.h:590
const Position geometryPositionAtOffset(double offset, double lateralOffset=0) const
Definition: MSLane.h:533
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:183
virtual MSTransportableControl & getContainerControl()
Returns the container control.
Definition: MSNet.cpp:1105
SUMOTime getCurrentTimeStep() const
Returns the current simulation step.
Definition: MSNet.h:321
bool hasContainers() const
Returns whether containers are simulated.
Definition: MSNet.h:412
bool hasPersons() const
Returns whether persons are simulated.
Definition: MSNet.h:396
MSVehicleControl & getVehicleControl()
Returns the vehicle control.
Definition: MSNet.h:379
virtual MSTransportableControl & getPersonControl()
Returns the person control.
Definition: MSNet.cpp:1096
MSRouteIterator end() const
Returns the end of the list of edges to pass.
Definition: MSRoute.cpp:80
MSRouteIterator begin() const
Returns the begin of the list of edges to pass.
Definition: MSRoute.cpp:74
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 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
static MSStopOut * getInstance()
Definition: MSStopOut.h:60
bool loadAnyWaiting(const MSEdge *edge, SUMOVehicle *vehicle, SUMOTime &timeToLoadNext, SUMOTime &stopDuration)
load any applicable transportables Loads any person / container that is waiting on that edge for the ...
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:63
double getWidth() const
Get the width which vehicles of this class shall have when being drawn.
SUMOVehicleClass getVehicleClass() const
Get this vehicle type's vehicle class.
double getMaxSpeed() const
Get vehicle's (technical) maximum speed [m/s].
const std::string & getID() const
Returns the name of the vehicle type.
Definition: MSVehicleType.h:91
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:251
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.cpp:94
Encapsulated SAX-Attributes.
virtual std::string getString(int id, bool *isPresent=nullptr) const =0
Returns the string-value of the named (by its enum-value) attribute.
virtual bool hasAttribute(int id) const =0
Returns the information whether the named (by its enum-value) attribute is within the current list.
Definition of vehicle stop (position and duration)
SUMOTime ended
the time at which this stop was ended
double endPos
The stopping position end.
Structure representing possible vehicle parameter.
int parametersSet
Information for the router which parameter were set, TraCI may modify this (when changing color)
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