SUMO - Simulation of Urban MObility
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
MSInsertionControl.cpp
Go to the documentation of this file.
1 /****************************************************************************/
11 // Inserts vehicles into the network when their departure time is reached
12 /****************************************************************************/
13 // SUMO, Simulation of Urban MObility; see http://sumo.dlr.de/
14 // Copyright (C) 2001-2016 DLR (http://www.dlr.de/) and contributors
15 /****************************************************************************/
16 //
17 // This file is part of SUMO.
18 // SUMO is free software: you can redistribute it and/or modify
19 // it under the terms of the GNU General Public License as published by
20 // the Free Software Foundation, either version 3 of the License, or
21 // (at your option) any later version.
22 //
23 /****************************************************************************/
24 
25 
26 // ===========================================================================
27 // included modules
28 // ===========================================================================
29 #ifdef _MSC_VER
30 #include <windows_config.h>
31 #else
32 #include <config.h>
33 #endif
34 
35 #include <iostream>
36 #include <algorithm>
37 #include <cassert>
38 #include <iterator>
40 #include "MSGlobals.h"
41 #include "MSInsertionControl.h"
42 #include "MSVehicle.h"
43 #include "MSLane.h"
44 #include "MSEdge.h"
45 #include "MSRouteHandler.h"
46 
47 #ifdef CHECK_MEMORY_LEAKS
48 #include <foreign/nvwa/debug_new.h>
49 #endif // CHECK_MEMORY_LEAKS
50 
51 
52 // ===========================================================================
53 // member method definitions
54 // ===========================================================================
56  SUMOTime maxDepartDelay,
57  bool checkEdgesOnce,
58  int maxVehicleNumber) :
59  myVehicleControl(vc),
60  myMaxDepartDelay(maxDepartDelay),
61  myCheckEdgesOnce(checkEdgesOnce),
62  myMaxVehicleNumber(maxVehicleNumber),
63  myPendingEmitsUpdateTime(SUMOTime_MIN) {
64 }
65 
66 
68  for (std::vector<Flow>::iterator i = myFlows.begin(); i != myFlows.end(); ++i) {
69  delete(i->pars);
70  }
71 }
72 
73 
74 void
76  myAllVeh.add(veh);
77 }
78 
79 
80 bool
82  if (myFlowIDs.count(pars->id) > 0) {
83  return false;
84  }
85  Flow flow;
86  flow.pars = pars;
87  flow.index = 0;
88  myFlows.push_back(flow);
89  myFlowIDs.insert(pars->id);
90  return true;
91 }
92 
93 
94 int
96  // check whether any vehicles shall be emitted within this time step
97  const bool havePreChecked = MSDevice_Routing::isEnabled();
98  if (myPendingEmits.empty() || (havePreChecked && myEmitCandidates.empty())) {
99  return 0;
100  }
101  int numEmitted = 0;
102  // we use buffering for the refused emits to save time
103  // for this, we have two lists; one contains previously refused emits, the second
104  // will be used to append those vehicles that will not be able to depart in this
105  // time step
107 
108  // go through the list of previously refused vehicles, first
109  MSVehicleContainer::VehicleVector::const_iterator veh;
110  for (veh = myPendingEmits.begin(); veh != myPendingEmits.end(); veh++) {
111  if (havePreChecked && (myEmitCandidates.count(*veh) == 0)) {
112  refusedEmits.push_back(*veh);
113  } else {
114  numEmitted += tryInsert(time, *veh, refusedEmits);
115  }
116  }
117  myEmitCandidates.clear();
118  myPendingEmits = refusedEmits;
119  return numEmitted;
120 }
121 
122 
123 int
125  MSVehicleContainer::VehicleVector& refusedEmits) {
126  assert(veh->getParameter().depart < time + DELTA_T);
127  const MSEdge& edge = *veh->getEdge();
128  if (veh->isOnRoad()) {
129  return 1;
130  }
131  if ((myMaxVehicleNumber < 0 || (int)MSNet::getInstance()->getVehicleControl().getRunningVehicleNo() < myMaxVehicleNumber)
132  && (!myCheckEdgesOnce || edge.getLastFailedInsertionTime() != time)
133  && edge.insertVehicle(*veh, time)) {
134  // Successful insertion
135  return 1;
136  }
137  if (myMaxDepartDelay >= 0 && time - veh->getParameter().depart > myMaxDepartDelay) {
138  // remove vehicles waiting too long for departure
139  myVehicleControl.deleteVehicle(veh, true);
140  } else if (edge.isVaporizing()) {
141  // remove vehicles if the edge shall be empty
142  myVehicleControl.deleteVehicle(veh, true);
143  } else if (myAbortedEmits.count(veh) > 0) {
144  // remove vehicles which shall not be inserted for some reason
145  myAbortedEmits.erase(veh);
146  myVehicleControl.deleteVehicle(veh, true);
147  } else {
148  // let the vehicle wait one step, we'll retry then
149  refusedEmits.push_back(veh);
150  }
151  edge.setLastFailedInsertionTime(time);
152  return 0;
153 }
154 
155 
156 void
157 MSInsertionControl::checkCandidates(SUMOTime time, const bool preCheck) {
158  while (myAllVeh.anyWaitingBefore(time + DELTA_T)) {
160  copy(top.begin(), top.end(), back_inserter(myPendingEmits));
161  myAllVeh.pop();
162  }
163  if (preCheck) {
164  MSVehicleContainer::VehicleVector::const_iterator veh;
165  for (veh = myPendingEmits.begin(); veh != myPendingEmits.end(); veh++) {
166  SUMOVehicle* const v = *veh;
167  const MSEdge* const edge = v->getEdge();
168  if ((!myCheckEdgesOnce || edge->getLastFailedInsertionTime() != time) && edge->insertVehicle(*v, time, true)) {
169  myEmitCandidates.insert(v);
170  } else {
171  MSDevice_Routing* dev = static_cast<MSDevice_Routing*>(v->getDevice(typeid(MSDevice_Routing)));
172  if (dev != 0) {
173  dev->skipRouting(time);
174  }
175  }
176  }
177  }
178 }
179 
180 
181 void
184  for (std::vector<Flow>::iterator i = myFlows.begin(); i != myFlows.end();) {
185  SUMOVehicleParameter* pars = i->pars;
186  bool tryEmitByProb = pars->repetitionProbability > 0;
187  while ((pars->repetitionProbability < 0
188  && pars->repetitionsDone < pars->repetitionNumber
189  && pars->depart + pars->repetitionsDone * pars->repetitionOffset < time + DELTA_T)
190  || (tryEmitByProb
191  && pars->depart < time + DELTA_T
192  && pars->repetitionEnd > time
193  // only call rand if all other conditions are met
194  && RandHelper::rand() < (pars->repetitionProbability * TS))
195  ) {
196  tryEmitByProb = false; // only emit one per step
197  SUMOVehicleParameter* newPars = new SUMOVehicleParameter(*pars);
198  newPars->id = pars->id + "." + toString(i->index);
199  newPars->depart = pars->repetitionProbability > 0 ? time : (SUMOTime)(pars->depart + pars->repetitionsDone * pars->repetitionOffset);
200  pars->repetitionsDone++;
201  // try to build the vehicle
202  if (vehControl.getVehicle(newPars->id) == 0) {
203  const MSRoute* route = MSRoute::dictionary(pars->routeid);
204  const MSVehicleType* vtype = vehControl.getVType(pars->vtypeid, MSRouteHandler::getParsingRNG());
205  SUMOVehicle* vehicle = vehControl.buildVehicle(newPars, route, vtype, false);
206  int quota = vehControl.getQuota();
207  if (quota > 0) {
208  vehControl.addVehicle(newPars->id, vehicle);
209  add(vehicle);
210  i->index++;
211  while (--quota > 0) {
212  SUMOVehicleParameter* quotaPars = new SUMOVehicleParameter(*pars);
213  quotaPars->id = pars->id + "." + toString(i->index);
214  quotaPars->depart = pars->repetitionProbability > 0 ? time : (SUMOTime)(pars->depart + pars->repetitionsDone * pars->repetitionOffset);
215  SUMOVehicle* vehicle = vehControl.buildVehicle(quotaPars, route, vtype, false);
216  vehControl.addVehicle(quotaPars->id, vehicle);
217  add(vehicle);
218  i->index++;
219  }
220  } else {
221  vehControl.deleteVehicle(vehicle, true);
222  }
223  } else {
224  // strange: another vehicle with the same id already exists
226  vehControl.discountStateLoaded();
227  break;
228  }
229  throw ProcessError("Another vehicle with the id '" + newPars->id + "' exists.");
230  }
231  }
232  if (pars->repetitionsDone == pars->repetitionNumber || (pars->repetitionProbability > 0 && pars->repetitionEnd <= time)) {
233  i = myFlows.erase(i);
235  delete pars;
236  } else {
237  ++i;
238  }
239  }
241 }
242 
243 
244 int
246  return (int)myPendingEmits.size();
247 }
248 
249 
250 int
252  return (int)myFlows.size();
253 }
254 
255 
256 void
258  myAbortedEmits.insert(veh);
259 }
260 
261 
262 void
264  myPendingEmits.erase(std::remove(myPendingEmits.begin(), myPendingEmits.end(), veh), myPendingEmits.end());
265  myAllVeh.remove(veh);
266 }
267 
268 
269 void
271  //clear out the refused vehicle list, deleting the vehicles entirely
272  MSVehicleContainer::VehicleVector::iterator veh;
273  for (veh = myPendingEmits.begin(); veh != myPendingEmits.end();) {
274  if ((*veh)->getRoute().getID() == route || route == "") {
275  myVehicleControl.deleteVehicle(*veh, true);
276  veh = myPendingEmits.erase(veh);
277  } else {
278  ++veh;
279  }
280  }
281 }
282 
283 
284 int
286  if (MSNet::getInstance()->getCurrentTimeStep() > myPendingEmitsUpdateTime) {
287  // updated pending emits (only once per time step)
288  myPendingEmitsForLane.clear();
289  for (MSVehicleContainer::VehicleVector::const_iterator veh = myPendingEmits.begin(); veh != myPendingEmits.end(); ++veh) {
290  const MSLane* lane = (*veh)->getLane();
291  if (lane != 0) {
292  myPendingEmitsForLane[lane]++;
293  } else {
294  // no (tentative) departLane was set, increase count for all
295  // lanes of the depart edge
296  const MSEdge* edge = (*veh)->getEdge();
297  const std::vector<MSLane*>& lanes = edge->getLanes();
298  for (std::vector<MSLane*>::const_iterator i = lanes.begin(); i != lanes.end(); ++i) {
299  myPendingEmitsForLane[*i]++;
300  }
301  }
302  }
304  }
305  return myPendingEmitsForLane[lane];
306 }
307 
308 /****************************************************************************/
309 
std::map< const MSLane *, int > myPendingEmitsForLane
the number of pending emits for each edge in the current time step
SUMOTime repetitionEnd
The time at which the flow ends (only needed when using repetitionProbability)
SUMOReal repetitionProbability
The probability for emitting a vehicle per second.
int getPendingFlowCount() const
Returns the number of flows that are still active.
virtual void deleteVehicle(SUMOVehicle *v, bool discard=false)
Deletes the vehicle.
long long int SUMOTime
Definition: SUMOTime.h:43
void descheduleDeparture(SUMOVehicle *veh)
stops trying to emit the given vehicle (and delete it)
void remove(SUMOVehicle *veh)
Removes a single vehicle.
bool insertVehicle(SUMOVehicle &v, SUMOTime time, const bool checkOnly=false) const
Tries to insert the given vehicle into the network.
Definition: MSEdge.cpp:472
int repetitionNumber
The number of times the vehicle shall be repeatedly inserted.
std::set< SUMOVehicle * > myAbortedEmits
Set of vehicles which shall not be inserted anymore.
std::string vtypeid
The vehicle's type id.
int getQuota(SUMOReal frac=-1) const
Returns the number of instances of the current vehicle that shall be emitted considering that "frac" ...
const std::vector< MSLane * > & getLanes() const
Returns this edge's lanes.
Definition: MSEdge.h:192
void checkCandidates(SUMOTime time, const bool preCheck)
Adds all vehicles that should have been emitted earlier to the refuse container.
virtual const MSEdge * getEdge() const =0
Returns the edge the vehicle is currently at.
static MTRand * getParsingRNG()
static bool gStateLoaded
Information whether a state has been loaded.
Definition: MSGlobals.h:92
static SUMOReal rand()
Returns a random real number in [0, 1)
Definition: RandHelper.h:62
A device that performs vehicle rerouting based on current edge speeds.
int repetitionsDone
The number of times the vehicle was already inserted.
MSVehicleContainer myAllVeh
All loaded vehicles sorted by their departure time.
static MSNet * getInstance()
Returns the pointer to the unique instance of MSNet (singleton).
Definition: MSNet.cpp:159
SUMOTime DELTA_T
Definition: SUMOTime.cpp:39
virtual bool addVehicle(const std::string &id, SUMOVehicle *v)
Tries to insert the vehicle into the internal vehicle container.
void skipRouting(const SUMOTime currentTime)
Labels the current time step as "unroutable".
#define TS
Definition: SUMOTime.h:52
SUMOTime getCurrentTimeStep() const
Returns the current simulation step.
Definition: MSNet.h:254
int getWaitingVehicleNo() const
Returns the number of waiting vehicles.
~MSInsertionControl()
Destructor.
SUMOTime repetitionOffset
The time offset between vehicle reinsertions.
The car-following model and parameter.
Definition: MSVehicleType.h:74
std::vector< SUMOVehicle * > VehicleVector
definition of a list of vehicles which have the same departure time
MSInsertionControl(MSVehicleControl &vc, SUMOTime maxDepartDelay, bool checkEdgesOnce, int maxVehicleNumber)
Constructor.
#define SUMOTime_MIN
Definition: SUMOTime.h:45
A road/street connecting two junctions.
Definition: MSEdge.h:80
void pop()
Removes the uppermost vehicle vector.
std::string routeid
The vehicle's route id.
Representation of a vehicle.
Definition: SUMOVehicle.h:66
int emitVehicles(SUMOTime time)
Emits vehicles that want to depart at the given time.
bool myCheckEdgesOnce
Whether an edge on which a vehicle could not depart should be ignored in the same step...
MSVehicleContainer::VehicleVector myPendingEmits
Buffers for vehicles that could not be inserted.
int tryInsert(SUMOTime time, SUMOVehicle *veh, MSVehicleContainer::VehicleVector &refusedEmits)
Tries to emit the vehicle.
MSVehicleControl & getVehicleControl()
Returns the vehicle control.
Definition: MSNet.h:307
virtual SUMOVehicle * buildVehicle(SUMOVehicleParameter *defs, const MSRoute *route, const MSVehicleType *type, const bool ignoreStopErrors, const bool fromRouteFile=true)
Builds a vehicle, increases the number of built vehicles.
SUMOTime depart
The vehicle's departure time.
SUMOTime myMaxDepartDelay
The maximum waiting time; vehicles waiting longer are deleted (-1: no deletion)
virtual bool isOnRoad() const =0
Returns the information whether the vehicle is on a road (is simulated)
void clearPendingVehicles(std::string &route)
clears out all pending vehicles from a route, "" for all routes
std::set< SUMOVehicle * > myEmitCandidates
Buffer for vehicles that may be inserted in the current step.
void add(SUMOVehicle *veh)
Adds a single vehicle.
std::string toString(const T &t, std::streamsize accuracy=OUTPUT_ACCURACY)
Definition: ToString.h:55
static bool isEnabled()
returns whether any routing actions take place
SUMOTime myPendingEmitsUpdateTime
Last time at which pending emits for each edge where counted.
const VehicleVector & top()
Returns the uppermost vehicle vector.
std::vector< Flow > myFlows
Container for periodical vehicle parameters.
void alreadyDeparted(SUMOVehicle *veh)
stops trying to emit the given vehicle (because it already departed)
int myMaxVehicleNumber
Storage for maximum vehicle number.
Structure representing possible vehicle parameter.
virtual const SUMOVehicleParameter & getParameter() const =0
Returns the vehicle's parameter (including departure definition)
MSVehicleControl & myVehicleControl
The assigned vehicle control (needed for vehicle re-insertion and deletion)
SUMOTime getLastFailedInsertionTime() const
Returns the last time a vehicle could not be inserted.
Definition: MSEdge.h:530
SUMOVehicle * getVehicle(const std::string &id) const
Returns the vehicle with the given id.
bool anyWaitingBefore(SUMOTime time) const
Returns the information whether any vehicles want to depart before the given time.
virtual MSDevice * getDevice(const std::type_info &type) const =0
Returns a device of the given type if it exists or 0.
The class responsible for building and deletion of vehicles.
int index
the running index
SUMOVehicleParameter * pars
The paramters.
void discountStateLoaded()
avoid counting a vehicle twice if it was loaded from state and route input
MSVehicleType * getVType(const std::string &id=DEFAULT_VTYPE_ID, MTRand *rng=0)
Returns the named vehicle type or a sample from the named distribution.
void add(SUMOVehicle *veh)
Adds a single vehicle for departure.
Representation of a lane in the micro simulation.
Definition: MSLane.h:79
std::set< std::string > myFlowIDs
Cache for periodical vehicle ids for quicker checking.
static void checkDist(const std::string &id)
Checks the distribution whether it is permanent and deletes it if not.
Definition: MSRoute.cpp:194
int getPendingEmits(const MSLane *lane)
return the number of pending emits for the given lane
void determineCandidates(SUMOTime time)
Checks for all vehicles whether they can be emitted.
std::string id
The vehicle's id.
static bool dictionary(const std::string &id, const MSRoute *route)
Adds a route to the dictionary.
Definition: MSRoute.cpp:122