SUMO - Simulation of Urban MObility
MEVehicle.cpp
Go to the documentation of this file.
1 /****************************************************************************/
7 // A vehicle from the mesoscopic point of view
8 /****************************************************************************/
9 // SUMO, Simulation of Urban MObility; see http://sumo.dlr.de/
10 // Copyright (C) 2001-2016 DLR (http://www.dlr.de/) and contributors
11 /****************************************************************************/
12 //
13 // This file is part of SUMO.
14 // SUMO is free software: you can redistribute it and/or modify
15 // it under the terms of the GNU General Public License as published by
16 // the Free Software Foundation, either version 3 of the License, or
17 // (at your option) any later version.
18 //
19 /****************************************************************************/
20 
21 
22 // ===========================================================================
23 // included modules
24 // ===========================================================================
25 #ifdef _MSC_VER
26 #include <windows_config.h>
27 #else
28 #include <config.h>
29 #endif
30 
31 #include <iostream>
32 #include <cassert>
33 #include <utils/common/StdDefs.h>
39 #include <microsim/MSGlobals.h>
40 #include <microsim/MSEdge.h>
41 #include <microsim/MSLane.h>
42 #include <microsim/MSNet.h>
43 #include <microsim/MSVehicleType.h>
44 #include <microsim/MSLink.h>
45 #include "MELoop.h"
46 #include "MEVehicle.h"
47 #include "MESegment.h"
48 
49 #ifdef CHECK_MEMORY_LEAKS
50 #include <foreign/nvwa/debug_new.h>
51 #endif // CHECK_MEMORY_LEAKS
52 
53 
54 // ===========================================================================
55 // method definitions
56 // ===========================================================================
58  const MSVehicleType* type, const SUMOReal speedFactor) :
59  MSBaseVehicle(pars, route, type, speedFactor),
60  mySegment(0),
61  myQueIndex(0),
62  myEventTime(SUMOTime_MIN),
63  myLastEntryTime(SUMOTime_MIN),
64  myBlockTime(SUMOTime_MAX) {
65  if ((*myCurrEdge)->getPurpose() != MSEdge::EDGEFUNCTION_DISTRICT) {
66  if ((*myCurrEdge)->allowedLanes(type->getVehicleClass()) == 0) {
67  throw ProcessError("Vehicle '" + pars->id + "' is not allowed to depart on any lane of its first edge.");
68  }
69  if (pars->departSpeedProcedure == DEPART_SPEED_GIVEN && pars->departSpeed > type->getMaxSpeed()) {
70  throw ProcessError("Departure speed for vehicle '" + pars->id +
71  "' is too high for the vehicle type '" + type->getID() + "'.");
72  }
73  }
74 }
75 
76 
79 // the following interpolation causes problems with arrivals and calibrators
80 // const SUMOReal fracOnSegment = MIN2(SUMOReal(1), STEPS2TIME(MSNet::getInstance()->getCurrentTimeStep() - myLastEntryTime) / STEPS2TIME(myEventTime - myLastEntryTime));
81  return (SUMOReal(mySegment->getIndex()) /* + fracOnSegment */) * mySegment->getLength();
82 }
83 
84 
87  const MSLane* const lane = getEdge()->getLanes()[0];
89 }
90 
91 
94  const MSLane* const lane = getEdge()->getLanes()[0];
96 }
97 
98 
100 MEVehicle::getPosition(const SUMOReal offset) const {
101  const MSLane* const lane = getEdge()->getLanes()[0];
102  return lane->geometryPositionAtOffset(getPositionOnLane() + offset);
103 }
104 
105 
106 SUMOReal
108  if (getWaitingTime() > 0) {
109  return 0;
110  } else {
111  return getAverageSpeed();
112  }
113 }
114 
115 
116 SUMOReal
119 }
120 
121 
122 SUMOReal
125  const SUMOReal v = getSpeed();
126  return MIN2(link->getViaLaneOrLane()->getVehicleMaxSpeed(this),
127  (SUMOReal)sqrt(2 * link->getLength() * getVehicleType().getCarFollowModel().getMaxAccel() + v * v));
128 }
129 
130 
131 SUMOReal
132 MEVehicle::getConservativeSpeed(SUMOTime& earliestArrival) const {
133  earliestArrival = MAX2(myEventTime, earliestArrival - DELTA_T); // event times have subsecond resolution
134  return mySegment->getLength() / STEPS2TIME(earliestArrival - myLastEntryTime);
135 }
136 
137 
138 bool
140  // vehicle has just entered a new edge. Position is 0
141  if (myCurrEdge == myRoute->end() - 1) { // may happen during teleport
142  return true;
143  }
144  ++myCurrEdge;
145  if ((*myCurrEdge)->isVaporizing()) {
146  return true;
147  }
148  return hasArrived();
149 }
150 
151 
152 bool
154  // mySegment may be 0 due to teleporting or arrival
155  return myCurrEdge == myRoute->end() - 1 && (
156  (mySegment == 0)
159 }
160 
161 bool
163  return getSegment() != 0;
164 }
165 
166 
167 bool
169  return false; // parking attribute of a stop is not yet evaluated /implemented
170 }
171 
172 
173 bool
174 MEVehicle::replaceRoute(const MSRoute* newRoute, bool onInit, int offset) {
175  const ConstMSEdgeVector& edges = newRoute->getEdges();
176  // assert the vehicle may continue (must not be "teleported" or whatever to another position)
177  if (!onInit && !newRoute->contains(*myCurrEdge)) {
178  return false;
179  }
180  MSLink* oldLink = 0;
181  MSLink* newLink = 0;
182  if (mySegment != 0) {
183  oldLink = mySegment->getLink(this);
184  }
185  // rebuild in-vehicle route information
186  if (onInit) {
187  myCurrEdge = newRoute->begin();
188  } else {
189  myCurrEdge = find(edges.begin() + offset, edges.end(), *myCurrEdge);
190  }
191  // check whether the old route may be deleted (is not used by anyone else)
192  newRoute->addReference();
193  myRoute->release();
194  // assign new route
195  myRoute = newRoute;
196  if (mySegment != 0) {
197  newLink = mySegment->getLink(this);
198  }
199  // update approaching vehicle information
200  if (oldLink != 0 && oldLink != newLink) {
201  oldLink->removeApproaching(this);
202  MELoop::setApproaching(this, newLink);
203  }
204  // update arrival definition
206  // save information that the vehicle was rerouted
209  return true;
210 }
211 
212 
213 bool
214 MEVehicle::addStop(const SUMOVehicleParameter::Stop& stopPar, std::string& /*errorMsg*/, SUMOTime /* untilOffset */) {
215  const MSEdge* const edge = MSEdge::dictionary(stopPar.lane.substr(0, stopPar.lane.rfind('_')));
216  assert(edge != 0);
217  MESegment* stopSeg = MSGlobals::gMesoNet->getSegmentForEdge(*edge, stopPar.endPos);
218  myStops[stopSeg] += stopPar.duration;
219  return true;
220 }
221 
222 
223 bool
225  return myStops.find(mySegment) != myStops.end();
226 }
227 
228 
229 bool
231  return false;
232 }
233 
234 
235 SUMOTime
236 MEVehicle::getStoptime(const MESegment* const seg) const {
237  if (myStops.find(seg) != myStops.end()) {
238  return myStops.find(seg)->second;
239  }
240  return 0;
241 }
242 
243 
244 const ConstMSEdgeVector
246  ConstMSEdgeVector result;
247  for (std::map<const MESegment* const, SUMOTime>::const_iterator iter = myStops.begin(); iter != myStops.end(); ++iter) {
248  result.push_back(&iter->first->getEdge());
249  }
250  return result;
251 }
252 
253 
254 bool
256  return mySegment == 0 || mySegment->isOpen(this);
257 }
258 
259 
260 void
262  for (MoveReminderCont::iterator i = myMoveReminders.begin(); i != myMoveReminders.end(); ++i) {
263  if (i->first == rem) {
265  (mySegment->getIndex() + 1) * mySegment->getLength(),
266  getLastEntryTime(), currentTime, exitTime, false);
267 #ifdef _DEBUG
268  if (myTraceMoveReminders) {
269  traceMoveReminder("notifyMove", i->first, i->second, true);
270  }
271 #endif
272  return;
273  }
274  }
275 }
276 
277 
278 void
279 MEVehicle::updateDetectors(SUMOTime currentTime, const bool isLeave, const MSMoveReminder::Notification reason) {
280  // segments of the same edge have the same reminder so no cleaning up must take place
281  const bool cleanUp = isLeave && (reason != MSMoveReminder::NOTIFICATION_SEGMENT);
282  for (MoveReminderCont::iterator rem = myMoveReminders.begin(); rem != myMoveReminders.end();) {
283  if (currentTime != getLastEntryTime()) {
284  rem->first->updateDetector(*this, mySegment->getIndex() * mySegment->getLength(),
285  (mySegment->getIndex() + 1) * mySegment->getLength(),
286  getLastEntryTime(), currentTime, getEventTime(), cleanUp);
287 #ifdef _DEBUG
288  if (myTraceMoveReminders) {
289  traceMoveReminder("notifyMove", rem->first, rem->second, true);
290  }
291 #endif
292  }
293  if (!isLeave || rem->first->notifyLeave(*this, mySegment->getLength(), reason)) {
294 #ifdef _DEBUG
295  if (isLeave && myTraceMoveReminders) {
296  traceMoveReminder("notifyLeave", rem->first, rem->second, true);
297  }
298 #endif
299  ++rem;
300  } else {
301 #ifdef _DEBUG
302  if (myTraceMoveReminders) {
303  traceMoveReminder("remove", rem->first, rem->second, false);
304  }
305 #endif
306  rem = myMoveReminders.erase(rem);
307  }
308  }
309 }
310 
311 
312 void
315  assert(mySegment == 0 || *myCurrEdge == &mySegment->getEdge());
316  std::vector<SUMOTime> internals;
317  internals.push_back(myDeparture);
318  internals.push_back((SUMOTime)distance(myRoute->begin(), myCurrEdge));
319  internals.push_back(mySegment == 0 ? (SUMOTime) - 1 : (SUMOTime)mySegment->getIndex());
320  internals.push_back((SUMOTime)getQueIndex());
321  internals.push_back(myEventTime);
322  internals.push_back(myLastEntryTime);
323  internals.push_back(myBlockTime);
324  out.writeAttr(SUMO_ATTR_STATE, toString(internals));
325  out.closeTag();
326 }
327 
328 
329 void
330 MEVehicle::loadState(const SUMOSAXAttributes& attrs, const SUMOTime offset) {
331  if (attrs.hasAttribute(SUMO_ATTR_POSITION)) {
332  throw ProcessError("Error: Invalid vehicles in state (may be a micro state)!");
333  }
334  unsigned int routeOffset;
335  int segIndex;
336  unsigned int queIndex;
337  std::istringstream bis(attrs.getString(SUMO_ATTR_STATE));
338  bis >> myDeparture;
339  bis >> routeOffset;
340  bis >> segIndex;
341  bis >> queIndex;
342  bis >> myEventTime;
343  bis >> myLastEntryTime;
344  bis >> myBlockTime;
345  if (hasDeparted()) {
346  myDeparture -= offset;
347  myEventTime -= offset;
348  myLastEntryTime -= offset;
349  myCurrEdge += routeOffset;
350  if (segIndex >= 0) {
352  while (seg->getIndex() != (unsigned int)segIndex) {
353  seg = seg->getNextSegment();
354  assert(seg != 0);
355  }
356  setSegment(seg, queIndex);
357  } else {
358  // on teleport
359  setSegment(0, 0);
360  assert(myEventTime != SUMOTime_MIN);
362  }
363  }
364  if (myBlockTime != SUMOTime_MAX) {
365  myBlockTime -= offset;
366  }
367 }
368 
369 
370 /****************************************************************************/
371 
void updateDetectorForWriting(MSMoveReminder *rem, SUMOTime currentTime, SUMOTime exitTime)
Updates a single vehicle detector if present.
Definition: MEVehicle.cpp:261
void loadState(const SUMOSAXAttributes &attrs, const SUMOTime offset)
Loads the state of this vehicle from the given description.
Definition: MEVehicle.cpp:330
OutputDevice & writeAttr(const SumoXMLAttr attr, const T &val)
writes a named attribute
Definition: OutputDevice.h:257
bool isParking() const
Returns whether the vehicle is parking.
Definition: MEVehicle.cpp:168
SUMOReal getMaxSpeed() const
Get vehicle&#39;s maximum speed [m/s].
long long int SUMOTime
Definition: SUMOTime.h:43
SUMOVehicleClass getVehicleClass() const
Get this vehicle type&#39;s vehicle class.
bool addStop(const SUMOVehicleParameter::Stop &stopPar, std::string &errorMsg, SUMOTime untilOffset=0)
Adds a stop.
Definition: MEVehicle.cpp:214
bool hasArrived() const
Returns whether this vehicle has already arived (reached the arrivalPosition on its final edge) ...
Definition: MEVehicle.cpp:153
SUMOReal rotationAtOffset(SUMOReal pos) const
Returns the rotation at the given length.
MoveReminderCont myMoveReminders
Current lane&#39;s move reminder.
SUMOReal myArrivalPos
The position on the destination lane where the vehicle stops.
const Position geometryPositionAtOffset(SUMOReal offset) const
Definition: MSLane.h:339
SUMOTime duration
The stopping duration.
const std::vector< MSLane * > & getLanes() const
Returns this edge&#39;s lanes.
Definition: MSEdge.h:185
SUMOReal getSlope() const
Returns the slope of the road at vehicle&#39;s position.
Definition: MEVehicle.cpp:93
SUMOTime getStoptime(const MESegment *const seg) const
Returns how long to stop at the given segment.
Definition: MEVehicle.cpp:236
void updateDetector(SUMOVehicle &veh, SUMOReal entryPos, SUMOReal leavePos, SUMOTime entryTime, SUMOTime currentTime, SUMOTime leaveTime, bool cleanUp)
SUMOReal departSpeed
(optional) The initial speed of the vehicle
bool isStoppedTriggered() const
Returns whether the vehicle is on a triggered stop.
Definition: MEVehicle.cpp:230
SUMOTime getWaitingTime() const
Returns the duration for which the vehicle was blocked.
Definition: MEVehicle.h:254
SUMOReal getSpeed() const
Returns the vehicle&#39;s estimated speed assuming no delays.
Definition: MEVehicle.cpp:107
Notification
Definition of a vehicle state.
static MSNet * getInstance()
Returns the pointer to the unique instance of MSNet (singleton).
Definition: MSNet.cpp:160
T MAX2(T a, T b)
Definition: StdDefs.h:75
SUMOTime getEventTime() const
Returns the (planned) time at which the vehicle leaves his current cell.
Definition: MEVehicle.h:189
SUMOTime DELTA_T
Definition: SUMOTime.cpp:39
const MSRoute * myRoute
This Vehicle&#39;s route.
unsigned int myNumberReroutes
The number of reroutings.
bool hasDeparted() const
Returns whether this vehicle has already departed.
static bool dictionary(const std::string &id, MSEdge *edge)
Inserts edge into the static dictionary Returns true if the key id isn&#39;t already in the dictionary...
Definition: MSEdge.cpp:578
unsigned int getIndex() const
Returns the running index of the segment in the edge (0 is the most upstream).
Definition: MESegment.h:150
The vehicle changes the segment (meso only)
std::vector< const MSEdge * > ConstMSEdgeVector
Definition: MSEdge.h:78
The base class for microscopic and mesoscopic vehicles.
Definition: MSBaseVehicle.h:52
SUMOTime getLastEntryTime() const
Returns the time the vehicle entered the current segment.
Definition: MEVehicle.h:231
SUMOReal getAverageSpeed() const
Returns the vehicle&#39;s estimated average speed on the segment assuming no further delays.
Definition: MEVehicle.cpp:117
const MSEdge & getEdge() const
Returns the edge this segment belongs to.
Definition: MESegment.h:272
SUMOReal getConservativeSpeed(SUMOTime &earliestArrival) const
Returns the vehicle&#39;s estimated speed taking into account delays.
Definition: MEVehicle.cpp:132
virtual bool hasAttribute(int id) const =0
Returns the information whether the named (by its enum-value) attribute is within the current list...
The speed is given.
The car-following model and parameter.
Definition: MSVehicleType.h:74
virtual void saveState(OutputDevice &out)
Saves the (common) state of a vehicle.
const MSCFModel & getCarFollowModel() const
Returns the vehicle type&#39;s car following model definition (const version)
virtual std::string getString(int id) const =0
Returns the string-value of the named (by its enum-value) attribute.
SUMOReal slopeDegreeAtOffset(SUMOReal pos) const
Returns the slope at the given length.
void calculateArrivalParams()
(Re-)Calculates the arrival position and lane from the vehicle parameters
The state of a link.
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:353
#define SUMOTime_MIN
Definition: SUMOTime.h:45
A road/street connecting two junctions.
Definition: MSEdge.h:80
bool isStopped() const
Returns whether the vehicle is at a stop.
Definition: MEVehicle.cpp:224
DepartSpeedDefinition departSpeedProcedure
Information how the vehicle&#39;s initial speed shall be chosen.
MESegment * getNextSegment() const
Returns the following segment on the same edge (0 if it is the last).
Definition: MESegment.h:158
The edge is a district edge.
Definition: MSEdge.h:99
The vehicle got a new route.
Definition: MSNet.h:538
bool isOnRoad() const
Returns the information whether the vehicle is on a road (is simulated)
Definition: MEVehicle.cpp:162
Encapsulated SAX-Attributes.
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:46
SUMOReal endPos
The stopping position end.
SUMOReal getLength() const
Returns the length of the segment in meters.
Definition: MESegment.h:166
Position getPosition(const SUMOReal offset=0) const
Return current position (x/y, cartesian)
Definition: MEVehicle.cpp:100
bool contains(const MSEdge *const edge) const
Definition: MSRoute.h:110
#define STEPS2TIME(x)
Definition: SUMOTime.h:65
const ConstMSEdgeVector & getEdges() const
Definition: MSRoute.h:128
T MIN2(T a, T b)
Definition: StdDefs.h:69
#define POSITION_EPS
Definition: config.h:187
SUMOTime myLastEntryTime
The time the vehicle entered its current segment.
Definition: MEVehicle.h:326
Something on a lane to be noticed about vehicle movement.
std::string toString(const T &t, std::streamsize accuracy=OUTPUT_ACCURACY)
Definition: ToString.h:54
void addReference() const
increments the reference counter for the route
Definition: MSRoute.cpp:103
void saveState(OutputDevice &out)
Saves the states of a vehicle.
Definition: MEVehicle.cpp:313
bool isOpen(const MEVehicle *veh) const
Returns whether the vehicle may use the next link.
Definition: MESegment.cpp:384
MESegment * mySegment
The segment the vehicle is at.
Definition: MEVehicle.h:317
static void setApproaching(MEVehicle *veh, MSLink *link)
registers vehicle with the given link
Definition: MELoop.cpp:215
std::string lane
The lane to stop at.
bool moveRoutePointer()
Update when the vehicle enters a new edge in the move step.
Definition: MEVehicle.cpp:139
SUMOReal getMaxAccel() const
Get the vehicle type&#39;s maximum acceleration [m/s^2].
Definition: MSCFModel.h:178
Structure representing possible vehicle parameter.
MSRouteIterator end() const
Returns the end of the list of edges to pass.
Definition: MSRoute.cpp:84
#define SUMOTime_MAX
Definition: SUMOTime.h:44
bool replaceRoute(const MSRoute *route, bool onInit=false, int offset=0)
Replaces the current route by the given one.
Definition: MEVehicle.cpp:174
size_t getQueIndex() const
Returns the index of the que the vehicle is in.
Definition: MEVehicle.h:215
SUMOReal interpolateLanePosToGeometryPos(SUMOReal lanePos) const
Definition: MSLane.h:333
A single mesoscopic segment (cell)
Definition: MESegment.h:57
Definition of vehicle stop (position and duration)
void updateDetectors(SUMOTime currentTime, const bool isLeave, const MSMoveReminder::Notification reason=MSMoveReminder::NOTIFICATION_JUNCTION)
Updates all vehicle detectors.
Definition: MEVehicle.cpp:279
const MSVehicleType & getVehicleType() const
Returns the vehicle&#39;s type definition.
Definition: MSBaseVehicle.h:93
MESegment * getSegmentForEdge(const MSEdge &e, SUMOReal pos=0)
Get the segment for a given edge at a given position.
Definition: MELoop.cpp:288
SUMOReal getPositionOnLane() const
Get the vehicle&#39;s position along the lane.
Definition: MEVehicle.cpp:78
const std::string & getID() const
Returns the name of the vehicle type.
std::map< const MESegment *const, SUMOTime > myStops
where to stop
Definition: MEVehicle.h:332
static MELoop * gMesoNet
mesoscopic simulation infrastructure
Definition: MSGlobals.h:99
void informVehicleStateListener(const SUMOVehicle *const vehicle, VehicleState to)
Informs all added listeners about a vehicle&#39;s state change.
Definition: MSNet.cpp:764
const PositionVector & getShape() const
Returns this lane&#39;s shape.
Definition: MSLane.h:322
Static storage of an output device and its base (abstract) implementation.
Definition: OutputDevice.h:71
bool closeTag()
Closes the most recently opened tag.
#define SUMOReal
Definition: config.h:213
SUMOTime myEventTime
The (planned) time of leaving the segment (cell)
Definition: MEVehicle.h:323
const ConstMSEdgeVector getStopEdges() const
Returns the list of still pending stop edges.
Definition: MEVehicle.cpp:245
MSRouteIterator myCurrEdge
Iterator to current route-edge.
virtual void setSegment(MESegment *s, size_t idx=0)
Sets the current segment the vehicle is at together with its que.
Definition: MEVehicle.h:198
const MSEdge * getEdge() const
Returns the edge the vehicle is currently at.
bool mayProceed() const
Returns whether the vehicle is allowed to pass the next junction.
Definition: MEVehicle.cpp:255
void release() const
deletes the route if there are no further references to it
Definition: MSRoute.cpp:109
SUMOReal getVehicleMaxSpeed(const SUMOVehicle *const veh) const
Returns the lane&#39;s maximum speed, given a vehicle&#39;s speed limit adaptation.
Definition: MSLane.h:353
SUMOTime myBlockTime
The time at which the vehicle was blocked on its current segment.
Definition: MEVehicle.h:329
Representation of a lane in the micro simulation.
Definition: MSLane.h:77
void addLeaderCar(MEVehicle *veh, MSLink *link)
Adds the given car to the leading vehicles.
Definition: MELoop.cpp:208
MESegment * getSegment() const
Returns the current segment the vehicle is on.
Definition: MEVehicle.h:207
SUMOReal estimateLeaveSpeed(const MSLink *link) const
Returns the vehicle&#39;s estimated speed after driving accross the link.
Definition: MEVehicle.cpp:123
SUMOReal getAngle() const
Returns the vehicle&#39;s direction in degrees.
Definition: MEVehicle.cpp:86
SUMOTime myDeparture
The real departure time.
MSRouteIterator begin() const
Returns the begin of the list of edges to pass.
Definition: MSRoute.cpp:78
std::string id
The vehicle&#39;s id.
MEVehicle(SUMOVehicleParameter *pars, const MSRoute *route, const MSVehicleType *type, const SUMOReal speedFactor)
Constructor.
Definition: MEVehicle.cpp:57