SUMO - Simulation of Urban MObility
MSDevice_Routing.cpp
Go to the documentation of this file.
1 /****************************************************************************/
11 // A device that performs vehicle rerouting based on current edge speeds
12 /****************************************************************************/
13 // SUMO, Simulation of Urban MObility; see http://sumo.dlr.de/
14 // Copyright (C) 2007-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 // included modules
27 // ===========================================================================
28 #ifdef _MSC_VER
29 #include <windows_config.h>
30 #else
31 #include <config.h>
32 #endif
33 
34 #include "MSDevice_Routing.h"
35 #include <microsim/MSNet.h>
36 #include <microsim/MSLane.h>
37 #include <microsim/MSEdge.h>
38 #include <microsim/MSEdgeControl.h>
39 #include <microsim/MSGlobals.h>
45 #include <utils/vehicle/CHRouter.h>
47 
48 #ifdef CHECK_MEMORY_LEAKS
49 #include <foreign/nvwa/debug_new.h>
50 #endif // CHECK_MEMORY_LEAKS
51 
52 
53 // ===========================================================================
54 // static member variables
55 // ===========================================================================
56 std::vector<SUMOReal> MSDevice_Routing::myEdgeSpeeds;
57 std::vector<std::vector<SUMOReal> > MSDevice_Routing::myPastEdgeSpeeds;
65 std::map<std::pair<const MSEdge*, const MSEdge*>, const MSRoute*> MSDevice_Routing::myCachedRoutes;
69 #ifdef HAVE_FOX
70 FXWorkerThread::Pool MSDevice_Routing::myThreadPool;
71 #endif
72 
73 
74 // ===========================================================================
75 // method definitions
76 // ===========================================================================
77 // ---------------------------------------------------------------------------
78 // static initialisation methods
79 // ---------------------------------------------------------------------------
80 void
82  insertDefaultAssignmentOptions("rerouting", "Routing", oc);
83 
84  oc.doRegister("device.rerouting.period", new Option_String("0", "TIME"));
85  oc.addSynonyme("device.rerouting.period", "device.routing.period", true);
86  oc.addDescription("device.rerouting.period", "Routing", "The period with which the vehicle shall be rerouted");
87 
88  oc.doRegister("device.rerouting.pre-period", new Option_String("1", "TIME"));
89  oc.addSynonyme("device.rerouting.pre-period", "device.routing.pre-period", true);
90  oc.addDescription("device.rerouting.pre-period", "Routing", "The rerouting period before depart");
91 
92  oc.doRegister("device.rerouting.adaptation-weight", new Option_Float(.5));
93  oc.addSynonyme("device.rerouting.adaptation-weight", "device.routing.adaptation-weight", true);
94  oc.addDescription("device.rerouting.adaptation-weight", "Routing", "The weight of prior edge weights for exponential moving average");
95 
96  oc.doRegister("device.rerouting.adaptation-steps", new Option_Integer(0));
97  oc.addSynonyme("device.rerouting.adaptation-steps", "device.routing.adaptation-steps", true);
98  oc.addDescription("device.rerouting.adaptation-steps", "Routing", "The number of steps for moving average weight of prior edge weights");
99 
100  oc.doRegister("device.rerouting.adaptation-interval", new Option_String("1", "TIME"));
101  oc.addSynonyme("device.rerouting.adaptation-interval", "device.routing.adaptation-interval", true);
102  oc.addDescription("device.rerouting.adaptation-interval", "Routing", "The interval for updating the edge weights");
103 
104  oc.doRegister("device.rerouting.with-taz", new Option_Bool(false));
105  oc.addSynonyme("device.rerouting.with-taz", "device.routing.with-taz", true);
106  oc.addSynonyme("device.rerouting.with-taz", "with-taz");
107  oc.addDescription("device.rerouting.with-taz", "Routing", "Use zones (districts) as routing start- and endpoints");
108 
109  oc.doRegister("device.rerouting.init-with-loaded-weights", new Option_Bool(false));
110  oc.addDescription("device.rerouting.init-with-loaded-weights", "Routing", "Use weight files given with option --weight-files for initializing edge weights");
111 
112  oc.doRegister("device.rerouting.shortest-path-file", new Option_FileName());
113  oc.addDescription("device.rerouting.shortest-path-file", "Routing", "Initialize lookup table for astar from the given distance matrix");
114 
115  oc.doRegister("device.rerouting.threads", new Option_Integer(0));
116  oc.addDescription("device.rerouting.threads", "Routing", "The number of parallel execution threads used for rerouting");
117 
118  oc.doRegister("device.rerouting.output", new Option_FileName());
119  oc.addDescription("device.rerouting.output", "Routing", "Save adapting weights to FILE");
120 
122  myEdgeSpeeds.clear();
124  myAdaptationSteps = -1;
125  myLastAdaptation = -1;
126 }
127 
128 
129 bool
131  if (oc.getInt("device.rerouting.adaptation-steps") > 0 && !oc.isDefault("device.rerouting.adaptation-weight")) {
132  WRITE_ERROR("Only one of the options 'device.rerouting.adaptation-steps' or 'device.rerouting.adaptation-weight' may be given.");
133  return false;
134  }
135  return true;
136 }
137 
138 
139 void
140 MSDevice_Routing::buildVehicleDevices(SUMOVehicle& v, std::vector<MSDevice*>& into) {
142  bool needRerouting = v.getParameter().wasSet(VEHPARS_FORCE_REROUTE);
143  needRerouting |= equippedByDefaultAssignmentOptions(oc, "rerouting", v);
144  if (!needRerouting && oc.getFloat("device.rerouting.probability") == 0 && !oc.isSet("device.rerouting.explicit")) {
145  // no route computation is modelled
146  return;
147  }
148  if (needRerouting) {
149  // route computation is enabled
150  myWithTaz = oc.getBool("device.rerouting.with-taz");
151  const SUMOTime period = string2time(oc.getString("device.rerouting.period"));
152  const SUMOTime prePeriod = string2time(oc.getString("device.rerouting.pre-period"));
153  // initialise edge efforts if not done before
154  if (myEdgeSpeeds.size() == 0) {
155  myAdaptationSteps = oc.getInt("device.rerouting.adaptation-steps");
157  const bool useLoaded = oc.getBool("device.rerouting.init-with-loaded-weights");
158  const SUMOReal currentSecond = SIMTIME;
159  for (MSEdgeVector::const_iterator i = edges.begin(); i != edges.end(); ++i) {
160  while ((*i)->getNumericalID() >= (int)myEdgeSpeeds.size()) {
161  myEdgeSpeeds.push_back(0);
162  if (myAdaptationSteps > 0) {
163  myPastEdgeSpeeds.push_back(std::vector<SUMOReal>());
164  }
165  }
166  if (useLoaded) {
167  myEdgeSpeeds[(*i)->getNumericalID()] = (*i)->getLength() / MSNet::getTravelTime(*i, 0, currentSecond);
168  } else {
169  myEdgeSpeeds[(*i)->getNumericalID()] = (*i)->getMeanSpeed();
170  }
171  if (myAdaptationSteps > 0) {
172  myPastEdgeSpeeds[(*i)->getNumericalID()] = std::vector<SUMOReal>(myAdaptationSteps, myEdgeSpeeds[(*i)->getNumericalID()]);
173  }
174  }
176  myRandomizeWeightsFactor = oc.getFloat("weights.random-factor");
177  if (myRandomizeWeightsFactor < 1) {
178  WRITE_ERROR("weights.random-factor cannot be less than 1");
179  }
180 #ifndef HAVE_FOX
181  if (oc.getInt("device.rerouting.threads") > 1) {
182  WRITE_ERROR("Parallel routing is only possible when compiled with Fox.");
183  }
184 #endif
185  }
186  // make the weights be updated
187  if (myAdaptationInterval == -1) {
188  myAdaptationInterval = string2time(oc.getString("device.rerouting.adaptation-interval"));
189  if (myAdaptationInterval < 0) {
190  WRITE_ERROR("Negative value for device.rerouting.adaptation-interval!");
191  }
192  myAdaptationWeight = oc.getFloat("device.rerouting.adaptation-weight");
193  if (myAdaptationWeight < 0. || myAdaptationWeight > 1.) {
194  WRITE_ERROR("The value for device.rerouting.adaptation-weight must be between 0 and 1!");
195  }
196  if (myAdaptationWeight < 1. && myAdaptationInterval > 0) {
200  } else if (period > 0) {
201  WRITE_WARNING("Rerouting is useless if the edge weights do not get updated!");
202  }
203  OutputDevice::createDeviceByOption("device.rerouting.output", "weights", "meandata_file.xsd");
204  }
205  // build the device
206  into.push_back(new MSDevice_Routing(v, "routing_" + v.getID(), period, prePeriod));
207  }
208 }
209 
210 
211 // ---------------------------------------------------------------------------
212 // MSDevice_Routing-methods
213 // ---------------------------------------------------------------------------
214 MSDevice_Routing::MSDevice_Routing(SUMOVehicle& holder, const std::string& id,
215  SUMOTime period, SUMOTime preInsertionPeriod)
216  : MSDevice(holder, id), myPeriod(period), myPreInsertionPeriod(preInsertionPeriod), myLastRouting(-1), mySkipRouting(-1), myRerouteCommand(0) {
218  // we do always a pre insertion reroute for trips to fill the best lanes of the vehicle with somehow meaningful values (especially for deaprtLane="best")
220  // if we don't update the edge weights, we might as well reroute now and hopefully use our threads better
221  const SUMOTime execTime = myEdgeWeightSettingCommand == 0 ? 0 : holder.getParameter().depart;
223  myRerouteCommand, execTime,
225  }
226 }
227 
228 
230  // make the rerouting command invalid if there is one
231  if (myRerouteCommand != 0 && MSNet::getInstance()->getInsertionEvents() != 0) {
233  }
234 }
235 
236 
237 bool
240  // clean up pre depart rerouting
241  if (myPreInsertionPeriod > 0) {
243  }
244  myRerouteCommand = 0;
245  // build repetition trigger if routing shall be done more often
246  if (myPeriod > 0) {
249  myRerouteCommand, myPeriod + MSNet::getInstance()->getCurrentTimeStep(),
251  }
252  }
253  return false;
254 }
255 
256 
257 SUMOTime
259  if (mySkipRouting == currentTime) {
260  return DELTA_T;
261  }
262  const MSEdge* source = *myHolder.getRoute().begin();
263  const MSEdge* dest = myHolder.getRoute().getLastEdge();
265  const std::pair<const MSEdge*, const MSEdge*> key = std::make_pair(source, dest);
266  if (myCachedRoutes.find(key) != myCachedRoutes.end()) {
267  if (myCachedRoutes[key]->size() > 2) {
269  return myPreInsertionPeriod;
270  } else {
271  WRITE_WARNING("No route for vehicle '" + myHolder.getID() + "' found.");
272  return myPreInsertionPeriod;
273  }
274  }
275  }
276  reroute(currentTime, true);
277  return myPreInsertionPeriod;
278 }
279 
280 
281 SUMOTime
283  reroute(currentTime);
284  return myPeriod;
285 }
286 
287 
288 SUMOReal
289 MSDevice_Routing::getEffort(const MSEdge* const e, const SUMOVehicle* const v, SUMOReal) {
290  const int id = e->getNumericalID();
291  if (id < (int)myEdgeSpeeds.size()) {
292  SUMOReal effort = MAX2(e->getLength() / myEdgeSpeeds[id], e->getMinimumTravelTime(v));
293  if (myRandomizeWeightsFactor != 1) {
295  }
296  return effort;
297  }
298  return 0;
299 }
300 
301 
302 SUMOReal
304  return edge->getLength() / getEffort(edge, 0, 0);
305 }
306 
307 
308 SUMOTime
310  if (MSNet::getInstance()->getVehicleControl().getDepartedVehicleNo() == 0) {
311  return myAdaptationInterval;
312  }
313  std::map<std::pair<const MSEdge*, const MSEdge*>, const MSRoute*>::iterator it = myCachedRoutes.begin();
314  for (; it != myCachedRoutes.end(); ++it) {
315  it->second->release();
316  }
317  myCachedRoutes.clear();
319  if (myAdaptationSteps > 0) {
320  // moving average
321  for (MSEdgeVector::const_iterator i = edges.begin(); i != edges.end(); ++i) {
322  const int id = (*i)->getNumericalID();
323  const SUMOReal currSpeed = (*i)->getMeanSpeed();
325  myPastEdgeSpeeds[id][myAdaptationStepsIndex] = currSpeed;
326  }
328  } else {
329  // exponential moving average
330  const SUMOReal newWeightFactor = (SUMOReal)(1. - myAdaptationWeight);
331  for (MSEdgeVector::const_iterator i = edges.begin(); i != edges.end(); ++i) {
332  const int id = (*i)->getNumericalID();
333  const SUMOReal currSpeed = (*i)->getMeanSpeed();
334  if (currSpeed != myEdgeSpeeds[id]) {
335  myEdgeSpeeds[id] = myEdgeSpeeds[id] * myAdaptationWeight + currSpeed * newWeightFactor;
336  }
337  }
338  }
339  myLastAdaptation = currentTime + DELTA_T; // because we run at the end of the time step
340  if (OptionsCont::getOptions().isSet("device.rerouting.output")) {
341  OutputDevice& dev = OutputDevice::getDeviceByOption("device.rerouting.output");
343  dev.writeAttr(SUMO_ATTR_ID, "device.rerouting");
344  dev.writeAttr(SUMO_ATTR_BEGIN, STEPS2TIME(currentTime));
346  for (MSEdgeVector::const_iterator i = edges.begin(); i != edges.end(); ++i) {
347  const int id = (*i)->getNumericalID();
348  dev.openTag(SUMO_TAG_EDGE);
349  dev.writeAttr(SUMO_ATTR_ID, (*i)->getID());
350  dev.writeAttr("traveltime", (*i)->getLength() / myEdgeSpeeds[id]);
351  dev.closeTag();
352  }
353  dev.closeTag();
354  }
355  return myAdaptationInterval;
356 }
357 
358 
359 void
360 MSDevice_Routing::reroute(const SUMOTime currentTime, const bool onInit) {
361  //check whether the weights did change since the last reroute
363  return;
364  }
365  myLastRouting = currentTime;
366 #ifdef HAVE_FOX
367  const bool needThread = (myRouter == 0 && myThreadPool.isFull());
368 #else
369  const bool needThread = true;
370 #endif
371  if (needThread && myRouter == 0) {
373  const std::string routingAlgorithm = oc.getString("routing-algorithm");
374  const bool mayHaveRestrictions = MSNet::getInstance()->hasPermissions() || oc.getInt("remote-port") != 0;
375  if (routingAlgorithm == "dijkstra") {
376  if (mayHaveRestrictions) {
379  } else {
382  }
383  } else if (routingAlgorithm == "astar") {
384  if (mayHaveRestrictions) {
386  const AStar::LookupTable* lookup = 0;
387  if (oc.isSet("device.rerouting.shortest-path-file")) {
388  lookup = AStar::createLookupTable(oc.getString("device.rerouting.shortest-path-file"), (int)MSEdge::getAllEdges().size());
389  }
390  myRouter = new AStar(MSEdge::getAllEdges(), true, &MSDevice_Routing::getEffort, lookup);
391  } else {
393  const AStar::LookupTable* lookup = 0;
394  if (oc.isSet("device.rerouting.shortest-path-file")) {
395  lookup = AStar::createLookupTable(oc.getString("device.rerouting.shortest-path-file"), (int)MSEdge::getAllEdges().size());
396  }
397  myRouter = new AStar(MSEdge::getAllEdges(), true, &MSDevice_Routing::getEffort, lookup);
398  }
399  } else if (routingAlgorithm == "CH") {
401  if (mayHaveRestrictions) {
403  MSEdge::getAllEdges(), true, &MSDevice_Routing::getEffort, myHolder.getVClass(), weightPeriod, true);
404  } else {
406  MSEdge::getAllEdges(), true, &MSDevice_Routing::getEffort, myHolder.getVClass(), weightPeriod, false);
407  }
408  } else if (routingAlgorithm == "CHWrapper") {
409  const SUMOTime begin = string2time(oc.getString("begin"));
412  MSEdge::getAllEdges(), true, &MSDevice_Routing::getEffort, begin, weightPeriod);
413  } else {
414  throw ProcessError("Unknown routing algorithm '" + routingAlgorithm + "'!");
415  }
416  }
417 #ifdef HAVE_FOX
418  if (needThread) {
419  const int numThreads = OptionsCont::getOptions().getInt("device.rerouting.threads");
420  if (myThreadPool.size() < numThreads) {
421  new WorkerThread(myThreadPool, myRouter);
422  }
423  if (myThreadPool.size() < numThreads) {
424  myRouter = 0;
425  }
426  }
427  if (myThreadPool.size() > 0) {
428  myThreadPool.add(new RoutingTask(myHolder, currentTime, onInit));
429  return;
430  }
431 #endif
432  myHolder.reroute(currentTime, *myRouter, onInit, myWithTaz);
433 }
434 
435 
438  if (myRouterWithProhibited == 0) {
441  }
442  myRouterWithProhibited->prohibit(prohibited);
443  return *myRouterWithProhibited;
444 }
445 
446 
447 
448 void
450  delete myRouterWithProhibited;
452 #ifdef HAVE_FOX
453  if (myThreadPool.size() > 0) {
454  // we cannot wait for the static destructor to do the cleanup
455  // because the output devices are gone by then
456  myThreadPool.clear();
457  // router deletion is done in thread destructor
458  myRouter = 0;
459  return;
460  }
461 #endif
462  delete myRouter;
463  myRouter = 0;
464 }
465 
466 
467 #ifdef HAVE_FOX
468 void
469 MSDevice_Routing::waitForAll() {
470  if (myThreadPool.size() > 0) {
471  myThreadPool.waitAll();
472  }
473 }
474 
475 
476 // ---------------------------------------------------------------------------
477 // MSDevice_Routing::RoutingTask-methods
478 // ---------------------------------------------------------------------------
479 void
480 MSDevice_Routing::RoutingTask::run(FXWorkerThread* context) {
481  myVehicle.reroute(myTime, static_cast<WorkerThread*>(context)->getRouter(), myOnInit, myWithTaz);
482  const MSEdge* source = *myVehicle.getRoute().begin();
483  const MSEdge* dest = myVehicle.getRoute().getLastEdge();
485  const std::pair<const MSEdge*, const MSEdge*> key = std::make_pair(source, dest);
486  lock();
488  MSDevice_Routing::myCachedRoutes[key] = &myVehicle.getRoute();
489  myVehicle.getRoute().addReference();
490  }
491  unlock();
492  }
493 }
494 #endif
495 
496 
497 /****************************************************************************/
498 
Computes the shortest path through a contracted network.
Definition: CHRouter.h:74
SUMOTime myPeriod
The period with which a vehicle shall be rerouted.
void doRegister(const std::string &name, Option *v)
Adds an option under the given name.
Definition: OptionsCont.cpp:86
OutputDevice & writeAttr(const SumoXMLAttr attr, const T &val)
writes a named attribute
Definition: OutputDevice.h:257
void prohibit(const std::vector< E *> &toProhibit)
long long int SUMOTime
Definition: SUMOTime.h:43
const int VEHPARS_FORCE_REROUTE
int getInt(const std::string &name) const
Returns the int-value of the named option (only for Option_Integer)
SUMOTime mySkipRouting
The time for which routing may be skipped because we cannot be inserted.
virtual const MSRoute & getRoute() const =0
Returns the current route.
static SUMOTime adaptEdgeEfforts(SUMOTime currentTime)
Adapt edge efforts by the current edge states.
bool hasPermissions() const
Returns whether the network has specific vehicle class permissions.
Definition: MSNet.h:174
SUMOVehicle & myHolder
The vehicle that stores the device.
Definition: MSDevice.h:158
static SUMOTime myAdaptationInterval
At which time interval the edge weights get updated.
SUMOTime myLastRouting
The last time a routing took place.
MSDevice_Routing(SUMOVehicle &holder, const std::string &id, SUMOTime period, SUMOTime preInsertionPeriod)
Constructor.
Notification
Definition of a vehicle state.
static SUMOReal rand()
Returns a random real number in [0, 1)
Definition: RandHelper.h:62
Computes the shortest path through a network using the A* algorithm.
Definition: AStarRouter.h:71
SUMOTime myPreInsertionPeriod
The period with which a vehicle shall be rerouted before insertion.
static int myAdaptationSteps
The number of steps for averaging edge speeds (ring-buffer)
static MSNet * getInstance()
Returns the pointer to the unique instance of MSNet (singleton).
Definition: MSNet.cpp:159
T MAX2(T a, T b)
Definition: StdDefs.h:75
SUMOTime DELTA_T
Definition: SUMOTime.cpp:39
const MSEdge * getLastEdge() const
returns the destination edge
Definition: MSRoute.cpp:96
SUMOTime wrappedRerouteCommandExecute(SUMOTime currentTime)
Performs rerouting after a period.
bool getBool(const std::string &name) const
Returns the boolean-value of the named option (only for Option_Bool)
static Command * myEdgeWeightSettingCommand
The weights adaptation/overwriting command.
bool isDefault(const std::string &name) const
Returns the information whether the named option has still the default value.
Base (microsim) event class.
Definition: Command.h:61
int getNumericalID() const
Returns the numerical id of the edge.
Definition: MSEdge.h:275
SUMOReal getMinimumTravelTime(const SUMOVehicle *const veh) const
returns the minimum travel time for the given vehicle
Definition: MSEdge.h:448
#define WRITE_WARNING(msg)
Definition: MsgHandler.h:200
Computes the shortest path through a network using the Dijkstra algorithm.
static OptionsCont & getOptions()
Retrieves the options.
Definition: OptionsCont.cpp:69
#define SIMTIME
Definition: SUMOTime.h:70
void addSynonyme(const std::string &name1, const std::string &name2, bool isDeprecated=false)
Adds a synonyme for an options name (any order)
A road/street connecting two junctions.
Definition: MSEdge.h:80
bool isSet(const std::string &name, bool failOnNonExistant=true) const
Returns the information whether the named option is set.
virtual SUMOVehicleClass getVClass() const =0
Returns the vehicle&#39;s access class.
static void insertOptions(OptionsCont &oc)
Inserts MSDevice_Routing-options.
static bool myWithTaz
whether taz shall be used at initial rerouting
void reroute(const SUMOTime currentTime, const bool onInit=false)
initiate the rerouting, create router / thread pool on first use
#define max(a, b)
Definition: polyfonts.c:65
The edge is a district edge.
Definition: MSEdge.h:99
Representation of a vehicle.
Definition: SUMOVehicle.h:66
MSEventControl * getBeginOfTimestepEvents()
Returns the event control for events executed at the begin of a time step.
Definition: MSNet.h:400
virtual void reroute(SUMOTime t, SUMOAbstractRouter< MSEdge, SUMOVehicle > &router, const bool onInit=false, const bool withTaz=false)=0
Performs a rerouting using the given router.
static SUMOReal getTravelTime(const MSEdge *const e, const SUMOVehicle *const v, SUMOReal t)
Returns the travel time to pass an edge.
Definition: MSNet.cpp:141
std::string getString(const std::string &name) const
Returns the string-value of the named option (only for Option_String)
static std::map< std::pair< const MSEdge *, const MSEdge * >, const MSRoute * > myCachedRoutes
The container of pre-calculated routes.
SUMOTime depart
The vehicle&#39;s departure time.
#define STEPS2TIME(x)
Definition: SUMOTime.h:65
A wrapper for a Command function.
Definition: StaticCommand.h:49
SUMOTime getCurrentTimeStep() const
Returns the current simulation step.
Definition: MSNet.h:254
SUMOTime string2time(const std::string &r)
Definition: SUMOTime.cpp:46
WrappingCommand< MSDevice_Routing > * myRerouteCommand
The (optional) command responsible for rerouting.
static void insertDefaultAssignmentOptions(const std::string &deviceName, const std::string &optionsTopic, OptionsCont &oc)
Adds common command options that allow to assign devices to vehicles.
Definition: MSDevice.cpp:94
EdgeBasicFunction getPurpose() const
Returns the edge type (EdgeBasicFunction)
Definition: MSEdge.h:249
virtual SUMOTime addEvent(Command *operation, SUMOTime execTimeStep, AdaptType type)
Adds an Event.
static SUMOReal getEffort(const MSEdge *const e, const SUMOVehicle *const v, SUMOReal t)
Returns the effort to pass an edge.
MSEventControl * getEndOfTimestepEvents()
Returns the event control for events executed at the end of a time step.
Definition: MSNet.h:410
#define WRITE_ERROR(msg)
Definition: MsgHandler.h:206
Abstract in-vehicle device.
Definition: MSDevice.h:69
static bool equippedByDefaultAssignmentOptions(const OptionsCont &oc, const std::string &deviceName, SUMOVehicle &v)
Determines whether a vehicle should get a certain device.
Definition: MSDevice.cpp:108
static SUMOReal getAssumedSpeed(const MSEdge *edge)
return current travel speed assumption
A pool of worker threads which distributes the tasks and collects the results.
The vehicle has departed (was inserted into the network)
An integer-option.
Definition: Option.h:313
void deschedule()
Marks this Command as being descheduled.
static SUMOAbstractRouter< MSEdge, SUMOVehicle > * myRouter
The router to use.
static const MSEdgeVector & getAllEdges()
Returns all edges with a numerical id.
Definition: MSEdge.cpp:706
static OutputDevice & getDeviceByOption(const std::string &name)
Returns the device described by the option.
virtual const SUMOVehicleParameter & getParameter() const =0
Returns the vehicle&#39;s parameter (including departure definition)
SUMOReal getLength() const
return the length of the edge
Definition: MSEdge.h:591
A storage for options typed value containers)
Definition: OptionsCont.h:99
virtual bool replaceRoute(const MSRoute *route, bool onInit=false, int offset=0)=0
Replaces the current route by the given one.
MSEventControl * getInsertionEvents()
Returns the event control for insertion events.
Definition: MSNet.h:420
static std::vector< SUMOReal > myEdgeSpeeds
The container of edge speeds.
static void buildVehicleDevices(SUMOVehicle &v, std::vector< MSDevice *> &into)
Build devices for the given vehicle, if needed.
const MSEdgeVector & getEdges() const
Returns loaded edges.
bool wasSet(int what) const
Returns whether the given parameter was set.
bool notifyEnter(SUMOVehicle &veh, MSMoveReminder::Notification reason)
Computes a new route on vehicle insertion.
static bool createDeviceByOption(const std::string &optionName, const std::string &rootElement="", const std::string &schemaFile="")
Creates the device using the output definition stored in the named option.
~MSDevice_Routing()
Destructor.
Patch the time in a way that it is at least as high as the simulation begin time. ...
Static storage of an output device and its base (abstract) implementation.
Definition: OutputDevice.h:71
static void cleanup()
deletes the router instance
static bool checkOptions(OptionsCont &oc)
checks MSDevice_Routing-options
bool closeTag()
Closes the most recently opened tag.
#define SUMOReal
Definition: config.h:213
A thread repeatingly calculating incoming tasks.
MSEdgeControl & getEdgeControl()
Returns the edge control.
Definition: MSNet.h:350
static AStarRouter< MSEdge, SUMOVehicle, prohibited_withPermissions< MSEdge, SUMOVehicle > > * myRouterWithProhibited
The router to use by rerouter elements.
MSRouteIterator begin() const
Returns the begin of the list of edges to pass.
Definition: MSRoute.cpp:78
static SUMOReal myAdaptationWeight
Information which weight prior edge efforts have.
std::vector< MSEdge * > MSEdgeVector
Definition: MSEdge.h:77
static SUMOReal myRandomizeWeightsFactor
Whether to disturb edge weights dynamically.
void addDescription(const std::string &name, const std::string &subtopic, const std::string &description)
Adds a description for an option.
static SUMOAbstractRouter< MSEdge, SUMOVehicle > & getRouterTT(const MSEdgeVector &prohibited=MSEdgeVector())
return the router instance
static SUMOTime myLastAdaptation
Information when the last edge weight adaptation occured.
virtual const std::string & getID() const =0
Get the vehicle&#39;s ID.
OutputDevice & openTag(const std::string &xmlElement)
Opens an XML tag.
static std::vector< std::vector< SUMOReal > > myPastEdgeSpeeds
The container of edge speeds.
SUMOReal getFloat(const std::string &name) const
Returns the SUMOReal-value of the named option (only for Option_Float)
SUMOTime preInsertionReroute(const SUMOTime currentTime)
Performs rerouting before insertion into the network.
static int myAdaptationStepsIndex
The current index in the pastEdgeSpeed ring-buffer.
Computes the shortest path through a contracted network.