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-2013 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  myTeleports(0),
66  myTotalDepartureDelay(0),
67  myTotalTravelTime(0),
68  myDefaultVTypeMayBeDeleted(true),
69  myWaitingForPerson(0),
70  myScale(-1) {
71  SUMOVTypeParameter defType;
74  if (oc.isSet("incremental-dua-step")) {
75  myScale = oc.getInt("incremental-dua-step") / static_cast<SUMOReal>(oc.getInt("incremental-dua-base"));
76  }
77  if (oc.isSet("scale")) {
78  myScale = oc.getFloat("scale");
79  }
80 }
81 
82 
84  // delete vehicles
85  for (VehicleDictType::iterator i = myVehicleDict.begin(); i != myVehicleDict.end(); ++i) {
86  delete(*i).second;
87  }
88  myVehicleDict.clear();
89  // delete vehicle type distributions
90  for (VTypeDistDictType::iterator i = myVTypeDistDict.begin(); i != myVTypeDistDict.end(); ++i) {
91  delete(*i).second;
92  }
93  myVTypeDistDict.clear();
94  // delete vehicle types
95  for (VTypeDictType::iterator i = myVTypeDict.begin(); i != myVTypeDict.end(); ++i) {
96  delete(*i).second;
97  }
98  myVTypeDict.clear();
99 }
100 
101 
104  const MSRoute* route,
105  const MSVehicleType* type) {
106  myLoadedVehNo++;
107  MSVehicle* built = new MSVehicle(defs, route, type, type->computeChosenSpeedDeviation(myVehicleParamsRNG), myLoadedVehNo - 1);
109  return built;
110 }
111 
112 
113 void
115  assert(myRunningVehNo > 0);
116  for (std::vector<MSDevice*>::const_iterator i = veh->getDevices().begin(); i != veh->getDevices().end(); ++i) {
117  (*i)->generateOutput();
118  }
119  if (OptionsCont::getOptions().isSet("tripinfo-output")) {
120  OutputDevice::getDeviceByOption("tripinfo-output").closeTag();
121  }
122  myTotalTravelTime += STEPS2TIME(MSNet::getInstance()->getCurrentTimeStep() - veh->getDeparture());
123  myRunningVehNo--;
125  deleteVehicle(veh);
126 }
127 
128 
129 void
131  if (getDepartedVehicleNo() == 0) {
132  od << -1.;
133  } else {
135  }
136 }
137 
138 
139 void
141  if (myEndedVehNo == 0) {
142  od << -1.;
143  } else {
145  }
146 }
147 
148 
149 void
151  ++myRunningVehNo;
154 }
155 
156 
157 void
158 MSVehicleControl::setState(int runningVehNo, int endedVehNo, SUMOReal totalDepartureDelay, SUMOReal totalTravelTime) {
159  myRunningVehNo = runningVehNo;
160  myEndedVehNo = endedVehNo;
161  myTotalDepartureDelay = totalDepartureDelay;
162  myTotalTravelTime = totalTravelTime;
163 }
164 
165 
166 void
170  // save vehicle types
171  for (VTypeDictType::iterator it = myVTypeDict.begin(); it != myVTypeDict.end(); ++it) {
172  it->second->getParameter().write(out);
173  }
174  for (VTypeDistDictType::iterator it = myVTypeDistDict.begin(); it != myVTypeDistDict.end(); ++it) {
176  out.writeAttr(SUMO_ATTR_VTYPES, (*it).second->getVals());
177  out.writeAttr(SUMO_ATTR_PROBS, (*it).second->getProbs());
178  out.closeTag();
179  }
180  for (VehicleDictType::iterator it = myVehicleDict.begin(); it != myVehicleDict.end(); ++it) {
181  (*it).second->saveState(out);
182  }
183 }
184 
185 
186 bool
187 MSVehicleControl::addVehicle(const std::string& id, SUMOVehicle* v) {
188  VehicleDictType::iterator it = myVehicleDict.find(id);
189  if (it == myVehicleDict.end()) {
190  // id not in myVehicleDict.
191  myVehicleDict[id] = v;
192  return true;
193  }
194  return false;
195 }
196 
197 
199 MSVehicleControl::getVehicle(const std::string& id) const {
200  VehicleDictType::const_iterator it = myVehicleDict.find(id);
201  if (it == myVehicleDict.end()) {
202  return 0;
203  }
204  return it->second;
205 }
206 
207 
208 void
210  myEndedVehNo++;
211  if (discard) {
212  myDiscarded++;
213  }
214  myVehicleDict.erase(veh->getID());
215  delete veh;
216 }
217 
218 
221  return myVehicleDict.begin();
222 }
223 
224 
227  return myVehicleDict.end();
228 }
229 
230 
231 bool
232 MSVehicleControl::checkVType(const std::string& id) {
233  if (id == DEFAULT_VTYPE_ID) {
235  delete myVTypeDict[id];
236  myVTypeDict.erase(myVTypeDict.find(id));
238  } else {
239  return false;
240  }
241  } else {
242  if (myVTypeDict.find(id) != myVTypeDict.end() || myVTypeDistDict.find(id) != myVTypeDistDict.end()) {
243  return false;
244  }
245  }
246  return true;
247 }
248 
249 bool
251  if (checkVType(vehType->getID())) {
252  myVTypeDict[vehType->getID()] = vehType;
253  return true;
254  }
255  return false;
256 }
257 
258 
259 bool
260 MSVehicleControl::addVTypeDistribution(const std::string& id, RandomDistributor<MSVehicleType*>* vehTypeDistribution) {
261  if (checkVType(id)) {
262  myVTypeDistDict[id] = vehTypeDistribution;
263  return true;
264  }
265  return false;
266 }
267 
268 
269 bool
270 MSVehicleControl::hasVTypeDistribution(const std::string& id) const {
271  return myVTypeDistDict.find(id) != myVTypeDistDict.end();
272 }
273 
274 
276 MSVehicleControl::getVType(const std::string& id) {
277  VTypeDictType::iterator it = myVTypeDict.find(id);
278  if (it == myVTypeDict.end()) {
279  VTypeDistDictType::iterator it2 = myVTypeDistDict.find(id);
280  if (it2 == myVTypeDistDict.end()) {
281  return 0;
282  }
283  return it2->second->get(&myVehicleParamsRNG);
284  }
285  if (id == DEFAULT_VTYPE_ID) {
287  }
288  return it->second;
289 }
290 
291 
292 void
293 MSVehicleControl::insertVTypeIDs(std::vector<std::string>& into) const {
294  into.reserve(into.size() + myVTypeDict.size() + myVTypeDistDict.size());
295  for (VTypeDictType::const_iterator i = myVTypeDict.begin(); i != myVTypeDict.end(); ++i) {
296  into.push_back((*i).first);
297  }
298  for (VTypeDistDictType::const_iterator i = myVTypeDistDict.begin(); i != myVTypeDistDict.end(); ++i) {
299  into.push_back((*i).first);
300  }
301 }
302 
303 
304 void
305 MSVehicleControl::addWaiting(const MSEdge* const edge, SUMOVehicle* vehicle) {
306  if (myWaiting.find(edge) == myWaiting.end()) {
307  myWaiting[edge] = std::vector<SUMOVehicle*>();
308  }
309  myWaiting[edge].push_back(vehicle);
310 }
311 
312 
313 void
314 MSVehicleControl::removeWaiting(const MSEdge* const edge, SUMOVehicle* vehicle) {
315  if (myWaiting.find(edge) != myWaiting.end()) {
316  std::vector<SUMOVehicle*>::iterator it = std::find(myWaiting[edge].begin(), myWaiting[edge].end(), vehicle);
317  if (it != myWaiting[edge].end()) {
318  myWaiting[edge].erase(it);
319  }
320  }
321 }
322 
323 
325 MSVehicleControl::getWaitingVehicle(const MSEdge* const edge, const std::set<std::string>& lines) {
326  if (myWaiting.find(edge) != myWaiting.end()) {
327  for (std::vector<SUMOVehicle*>::const_iterator it = myWaiting[edge].begin(); it != myWaiting[edge].end(); ++it) {
328  const std::string& line = (*it)->getParameter().line == "" ? (*it)->getParameter().id : (*it)->getParameter().line;
329  if (lines.count(line)) {
330  return (*it);
331  }
332  }
333  }
334  return 0;
335 }
336 
337 
338 void
340  for (VehicleDictType::iterator i = myVehicleDict.begin(); i != myVehicleDict.end(); ++i) {
341  WRITE_WARNING("Vehicle " + i->first + " aborted waiting for a person that will never come.");
342  }
343 }
344 
345 
346 bool
348  frac = frac < 0 ? myScale : frac;
349  if (frac < 0) {
350  return true;
351  }
352  const unsigned int resolution = 1000;
353  const unsigned int intFrac = (unsigned int)floor(frac * resolution + 0.5);
354  // the vehicle in question has already been loaded, hence the '-1'
355  // apply % twice to avoid integer overflow
356  return (((myLoadedVehNo - 1) % resolution) * intFrac) % resolution < intFrac;
357 }
358 
359 /****************************************************************************/
360