SUMO - Simulation of Urban MObility
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
MSVehicleControl.cpp
Go to the documentation of this file.
1 /****************************************************************************/
9 // The class responsible for building and deletion of vehicles
10 /****************************************************************************/
11 // SUMO, Simulation of Urban MObility; see http://sumo-sim.org/
12 // Copyright (C) 2001-2014 DLR (http://www.dlr.de/) and contributors
13 /****************************************************************************/
14 //
15 // This file is part of SUMO.
16 // SUMO is free software: you can redistribute it and/or modify
17 // it under the terms of the GNU General Public License as published by
18 // the Free Software Foundation, either version 3 of the License, or
19 // (at your option) any later version.
20 //
21 /****************************************************************************/
22 
23 
24 // ===========================================================================
25 // included modules
26 // ===========================================================================
27 #ifdef _MSC_VER
28 #include <windows_config.h>
29 #else
30 #include <config.h>
31 #endif
32 
33 #include "MSVehicleControl.h"
34 #include "MSVehicle.h"
35 #include "MSLane.h"
36 #include "MSNet.h"
39 #include <utils/common/RGBColor.h>
44 
45 #ifdef CHECK_MEMORY_LEAKS
46 #include <foreign/nvwa/debug_new.h>
47 #endif // CHECK_MEMORY_LEAKS
48 
49 
50 // ===========================================================================
51 // static members
52 // ===========================================================================
54 
55 
56 // ===========================================================================
57 // member method definitions
58 // ===========================================================================
60  myLoadedVehNo(0),
61  myRunningVehNo(0),
62  myEndedVehNo(0),
63  myDiscarded(0),
64  myCollisions(0),
65  myTeleportsJam(0),
66  myTeleportsYield(0),
67  myTeleportsWrongLane(0),
68  myTotalDepartureDelay(0),
69  myTotalTravelTime(0),
70  myDefaultVTypeMayBeDeleted(true),
71  myWaitingForPerson(0),
72  myScale(-1) {
73  SUMOVTypeParameter defType;
76  if (oc.isSet("incremental-dua-step")) {
77  myScale = oc.getInt("incremental-dua-step") / static_cast<SUMOReal>(oc.getInt("incremental-dua-base"));
78  }
79  if (oc.isSet("scale")) {
80  myScale = oc.getFloat("scale");
81  }
82 }
83 
84 
86  // delete vehicles
87  for (VehicleDictType::iterator i = myVehicleDict.begin(); i != myVehicleDict.end(); ++i) {
88  delete(*i).second;
89  }
90  myVehicleDict.clear();
91  // delete vehicle type distributions
92  for (VTypeDistDictType::iterator i = myVTypeDistDict.begin(); i != myVTypeDistDict.end(); ++i) {
93  delete(*i).second;
94  }
95  myVTypeDistDict.clear();
96  // delete vehicle types
97  for (VTypeDictType::iterator i = myVTypeDict.begin(); i != myVTypeDict.end(); ++i) {
98  delete(*i).second;
99  }
100  myVTypeDict.clear();
101 }
102 
103 
106  const MSRoute* route,
107  const MSVehicleType* type) {
108  myLoadedVehNo++;
109  MSVehicle* built = new MSVehicle(defs, route, type, type->computeChosenSpeedDeviation(myVehicleParamsRNG));
111  return built;
112 }
113 
114 
115 void
117  assert(myRunningVehNo > 0);
118  myTotalTravelTime += STEPS2TIME(MSNet::getInstance()->getCurrentTimeStep() - veh->getDeparture());
119  myRunningVehNo--;
121  for (std::vector<MSDevice*>::const_iterator i = veh->getDevices().begin(); i != veh->getDevices().end(); ++i) {
122  (*i)->generateOutput();
123  }
124  if (OptionsCont::getOptions().isSet("tripinfo-output")) {
125  OutputDevice::getDeviceByOption("tripinfo-output").closeTag();
126  }
127  deleteVehicle(veh);
128 }
129 
130 
131 void
133  ++myRunningVehNo;
136 }
137 
138 
139 void
140 MSVehicleControl::setState(int runningVehNo, int endedVehNo, SUMOReal totalDepartureDelay, SUMOReal totalTravelTime) {
141  myRunningVehNo = runningVehNo;
142  myEndedVehNo = endedVehNo;
143  myTotalDepartureDelay = totalDepartureDelay;
144  myTotalTravelTime = totalTravelTime;
145 }
146 
147 
148 void
152  // save vehicle types
153  for (VTypeDictType::iterator it = myVTypeDict.begin(); it != myVTypeDict.end(); ++it) {
154  it->second->getParameter().write(out);
155  }
156  for (VTypeDistDictType::iterator it = myVTypeDistDict.begin(); it != myVTypeDistDict.end(); ++it) {
158  out.writeAttr(SUMO_ATTR_VTYPES, (*it).second->getVals());
159  out.writeAttr(SUMO_ATTR_PROBS, (*it).second->getProbs());
160  out.closeTag();
161  }
162  for (VehicleDictType::iterator it = myVehicleDict.begin(); it != myVehicleDict.end(); ++it) {
163  (*it).second->saveState(out);
164  }
165 }
166 
167 
168 bool
169 MSVehicleControl::addVehicle(const std::string& id, SUMOVehicle* v) {
170  VehicleDictType::iterator it = myVehicleDict.find(id);
171  if (it == myVehicleDict.end()) {
172  // id not in myVehicleDict.
173  myVehicleDict[id] = v;
174  return true;
175  }
176  return false;
177 }
178 
179 
181 MSVehicleControl::getVehicle(const std::string& id) const {
182  VehicleDictType::const_iterator it = myVehicleDict.find(id);
183  if (it == myVehicleDict.end()) {
184  return 0;
185  }
186  return it->second;
187 }
188 
189 
190 void
192  myEndedVehNo++;
193  if (discard) {
194  myDiscarded++;
195  }
196  myVehicleDict.erase(veh->getID());
197  delete veh;
198 }
199 
200 
203  return myVehicleDict.begin();
204 }
205 
206 
209  return myVehicleDict.end();
210 }
211 
212 
213 bool
214 MSVehicleControl::checkVType(const std::string& id) {
215  if (id == DEFAULT_VTYPE_ID) {
217  delete myVTypeDict[id];
218  myVTypeDict.erase(myVTypeDict.find(id));
220  } else {
221  return false;
222  }
223  } else {
224  if (myVTypeDict.find(id) != myVTypeDict.end() || myVTypeDistDict.find(id) != myVTypeDistDict.end()) {
225  return false;
226  }
227  }
228  return true;
229 }
230 
231 bool
233  if (checkVType(vehType->getID())) {
234  myVTypeDict[vehType->getID()] = vehType;
235  return true;
236  }
237  return false;
238 }
239 
240 
241 bool
242 MSVehicleControl::addVTypeDistribution(const std::string& id, RandomDistributor<MSVehicleType*>* vehTypeDistribution) {
243  if (checkVType(id)) {
244  myVTypeDistDict[id] = vehTypeDistribution;
245  return true;
246  }
247  return false;
248 }
249 
250 
251 bool
252 MSVehicleControl::hasVTypeDistribution(const std::string& id) const {
253  return myVTypeDistDict.find(id) != myVTypeDistDict.end();
254 }
255 
256 
258 MSVehicleControl::getVType(const std::string& id) {
259  VTypeDictType::iterator it = myVTypeDict.find(id);
260  if (it == myVTypeDict.end()) {
261  VTypeDistDictType::iterator it2 = myVTypeDistDict.find(id);
262  if (it2 == myVTypeDistDict.end()) {
263  return 0;
264  }
265  return it2->second->get(&myVehicleParamsRNG);
266  }
267  if (id == DEFAULT_VTYPE_ID) {
269  }
270  return it->second;
271 }
272 
273 
274 void
275 MSVehicleControl::insertVTypeIDs(std::vector<std::string>& into) const {
276  into.reserve(into.size() + myVTypeDict.size() + myVTypeDistDict.size());
277  for (VTypeDictType::const_iterator i = myVTypeDict.begin(); i != myVTypeDict.end(); ++i) {
278  into.push_back((*i).first);
279  }
280  for (VTypeDistDictType::const_iterator i = myVTypeDistDict.begin(); i != myVTypeDistDict.end(); ++i) {
281  into.push_back((*i).first);
282  }
283 }
284 
285 
286 void
287 MSVehicleControl::addWaiting(const MSEdge* const edge, SUMOVehicle* vehicle) {
288  if (myWaiting.find(edge) == myWaiting.end()) {
289  myWaiting[edge] = std::vector<SUMOVehicle*>();
290  }
291  myWaiting[edge].push_back(vehicle);
292 }
293 
294 
295 void
296 MSVehicleControl::removeWaiting(const MSEdge* const edge, SUMOVehicle* vehicle) {
297  if (myWaiting.find(edge) != myWaiting.end()) {
298  std::vector<SUMOVehicle*>::iterator it = std::find(myWaiting[edge].begin(), myWaiting[edge].end(), vehicle);
299  if (it != myWaiting[edge].end()) {
300  myWaiting[edge].erase(it);
301  }
302  }
303 }
304 
305 
307 MSVehicleControl::getWaitingVehicle(const MSEdge* const edge, const std::set<std::string>& lines) {
308  if (myWaiting.find(edge) != myWaiting.end()) {
309  for (std::vector<SUMOVehicle*>::const_iterator it = myWaiting[edge].begin(); it != myWaiting[edge].end(); ++it) {
310  const std::string& line = (*it)->getParameter().line == "" ? (*it)->getParameter().id : (*it)->getParameter().line;
311  if (lines.count(line)) {
312  return (*it);
313  }
314  }
315  }
316  return 0;
317 }
318 
319 
320 void
322  for (VehicleDictType::iterator i = myVehicleDict.begin(); i != myVehicleDict.end(); ++i) {
323  WRITE_WARNING("Vehicle " + i->first + " aborted waiting for a person that will never come.");
324  }
325 }
326 
327 
328 bool
330  frac = frac < 0 ? myScale : frac;
331  if (frac < 0) {
332  return true;
333  }
334  const unsigned int resolution = 1000;
335  const unsigned int intFrac = (unsigned int)floor(frac * resolution + 0.5);
336  // the vehicle in question has already been loaded, hence the '-1'
337  // apply % twice to avoid integer overflow
338  return (((myLoadedVehNo - 1) % resolution) * intFrac) % resolution < intFrac;
339 }
340 
341 /****************************************************************************/
342 
The vehicle has departed (was inserted into the network)
Definition: MSNet.h:421
bool checkVType(const std::string &id)
Checks whether the vehicle type (distribution) may be added.
bool addVTypeDistribution(const std::string &id, RandomDistributor< MSVehicleType * > *vehTypeDistribution)
Adds a vehicle type distribution.
OutputDevice & writeAttr(const SumoXMLAttr attr, const T &val)
writes a named attribute
Definition: OutputDevice.h:256
void addWaiting(const MSEdge *const edge, SUMOVehicle *vehicle)
Representation of a vehicle in the micro simulation.
Definition: MSVehicle.h:77
virtual void deleteVehicle(SUMOVehicle *v, bool discard=false)
Deletes the vehicle.
SUMOReal myTotalDepartureDelay
The aggregated time vehicles had to wait for departure (in seconds)
constVehIt loadedVehBegin() const
Returns the begin of the internal vehicle map.
unsigned int myDiscarded
The number of vehicles which were discarded while loading.
SUMOReal myTotalTravelTime
The aggregated time vehicles needed to aacomplish their route (in seconds)
Structure representing possible vehicle parameter.
std::map< const MSEdge *const, std::vector< SUMOVehicle * > > myWaiting
the lists of waiting vehicles
MSVehicleType * getVType(const std::string &id=DEFAULT_VTYPE_ID)
Returns the named vehicle type or a sample from the named distribution.
MSVehicleControl()
Constructor.
static MSNet * getInstance()
Returns the pointer to the unique instance of MSNet (singleton).
Definition: MSNet.cpp:154
VehicleDictType myVehicleDict
Dictionary of vehicles.
virtual bool addVehicle(const std::string &id, SUMOVehicle *v)
Tries to insert the vehicle into the internal vehicle container.
VTypeDictType myVTypeDict
Dictionary of vehicle types.
void removeWaiting(const MSEdge *const edge, SUMOVehicle *vehicle)
SUMOReal getFloat(const std::string &name) const
Returns the SUMOReal-value of the named option (only for Option_Float)
void insertVTypeIDs(std::vector< std::string > &into) const
Inserts ids of all known vehicle types and vehicle type distributions to the given vector...
bool myDefaultVTypeMayBeDeleted
Whether no vehicle type was loaded.
constVehIt loadedVehEnd() const
Returns the end of the internal vehicle map.
const std::string DEFAULT_VTYPE_ID
static MSVehicleType * build(SUMOVTypeParameter &from)
Builds the microsim vehicle type described by the given parameter.
#define WRITE_WARNING(msg)
Definition: MsgHandler.h:196
The car-following model and parameter.
Definition: MSVehicleType.h:74
static OptionsCont & getOptions()
Retrieves the options.
Definition: OptionsCont.cpp:67
virtual SUMOVehicle * buildVehicle(SUMOVehicleParameter *defs, const MSRoute *route, const MSVehicleType *type)
Builds a vehicle, increases the number of built vehicles.
SUMOVehicle * getWaitingVehicle(const MSEdge *const edge, const std::set< std::string > &lines)
A road/street connecting two junctions.
Definition: MSEdge.h:73
#define STEPFLOOR(x)
Definition: SUMOTime.h:67
virtual const std::vector< MSDevice * > & getDevices() const =0
Returns this vehicle's devices.
The vehicle arrived at his destination (is deleted)
Definition: MSNet.h:427
void setState(int runningVehNo, int endedVehNo, SUMOReal totalDepartureDelay, SUMOReal totalTravelTime)
Sets the current state variables as loaded from the stream.
Representation of a vehicle.
Definition: SUMOVehicle.h:63
SUMOReal myScale
The scaling factor (especially for inc-dua)
SUMOTime depart
The vehicle's departure time.
#define STEPS2TIME(x)
Definition: SUMOTime.h:65
void saveState(OutputDevice &out)
Saves the current state into the given stream.
static MTRand myVehicleParamsRNG
A random number generator used to choose from vtype/route distributions and computing the speed facto...
unsigned int myEndedVehNo
The number of removed vehicles.
SUMOReal computeChosenSpeedDeviation(MTRand &rng, const SUMOReal minDevFactor=0.2) const
Computes and returns the speed deviation.
std::string line
The vehicle's line (mainly for public transport)
void abortWaiting()
removes any vehicles that are still waiting
The vehicle was built, but has not yet departed.
Definition: MSNet.h:419
bool addVType(MSVehicleType *vehType)
Adds a vehicle type.
void scheduleVehicleRemoval(SUMOVehicle *veh)
Removes a vehicle after it has ended.
Structure representing possible vehicle parameter.
VTypeDistDictType myVTypeDistDict
A distribution of vehicle types (probability->vehicle type)
virtual SUMOTime getDeparture() const =0
Returns this vehicle's real departure time.
static OutputDevice & getDeviceByOption(const std::string &name)
Returns the device described by the option.
virtual const SUMOVehicleParameter & getParameter() const =0
Returns the vehicle's parameter (including departure definition)
virtual ~MSVehicleControl()
Destructor.
A storage for options typed value containers)
Definition: OptionsCont.h:108
const std::string & getID() const
Returns the name of the vehicle type.
std::map< std::string, SUMOVehicle * >::const_iterator constVehIt
Definition of the internal vehicles map iterator.
void informVehicleStateListener(const SUMOVehicle *const vehicle, VehicleState to)
Informs all added listeners about a vehicle's state change.
Definition: MSNet.cpp:677
SUMOVehicle * getVehicle(const std::string &id) const
Returns the vehicle with the given id.
bool isInQuota(SUMOReal frac=-1) const
Returns the information whether the currently vehicle number shall be emitted considering that only f...
bool hasVTypeDistribution(const std::string &id) const
Asks for a vehicle type distribution.
Static storage of an output device and its base (abstract) implementation.
Definition: OutputDevice.h:70
bool closeTag()
Closes the most recently opened tag.
#define SUMOReal
Definition: config.h:215
void vehicleDeparted(const SUMOVehicle &v)
Informs this control about a vehicle's departure.
unsigned int myLoadedVehNo
The number of build vehicles.
int getInt(const std::string &name) const
Returns the int-value of the named option (only for Option_Integer)
virtual const std::string & getID() const =0
Get the vehicle's ID.
OutputDevice & openTag(const std::string &xmlElement)
Opens an XML tag.
unsigned int myRunningVehNo
The number of vehicles within the network (build and inserted but not removed)
bool isSet(const std::string &name, bool failOnNonExistant=true) const
Returns the information whether the named option is set.