81 oc.
addSynonyme(
"device.rerouting.period",
"device.routing.period",
true);
82 oc.
addDescription(
"device.rerouting.period",
"Routing",
"The period with which the vehicle shall be rerouted");
85 oc.
addSynonyme(
"device.rerouting.pre-period",
"device.routing.pre-period",
true);
86 oc.
addDescription(
"device.rerouting.pre-period",
"Routing",
"The rerouting period before depart");
89 oc.
addSynonyme(
"device.rerouting.adaptation-weight",
"device.routing.adaptation-weight",
true);
90 oc.
addDescription(
"device.rerouting.adaptation-weight",
"Routing",
"The weight of prior edge weights for exponential moving average");
93 oc.
addSynonyme(
"device.rerouting.adaptation-steps",
"device.routing.adaptation-steps",
true);
94 oc.
addDescription(
"device.rerouting.adaptation-steps",
"Routing",
"The number of steps for moving average weight of prior edge weights");
97 oc.
addSynonyme(
"device.rerouting.adaptation-interval",
"device.routing.adaptation-interval",
true);
98 oc.
addDescription(
"device.rerouting.adaptation-interval",
"Routing",
"The interval for updating the edge weights");
101 oc.
addSynonyme(
"device.rerouting.with-taz",
"device.routing.with-taz",
true);
102 oc.
addSynonyme(
"device.rerouting.with-taz",
"with-taz");
103 oc.
addDescription(
"device.rerouting.with-taz",
"Routing",
"Use zones (districts) as routing start- and endpoints");
106 oc.
addDescription(
"device.rerouting.init-with-loaded-weights",
"Routing",
"Use weight files given with option --weight-files for initializing edge weights");
109 oc.
addDescription(
"device.rerouting.shortest-path-file",
"Routing",
"Initialize lookup table for astar from the given distance matrix");
112 oc.
addDescription(
"device.rerouting.threads",
"Routing",
"The number of parallel execution threads used for rerouting");
115 oc.
addDescription(
"device.rerouting.output",
"Routing",
"Save adapting weights to FILE");
128 if (oc.
getInt(
"device.rerouting.adaptation-steps") > 0 && !oc.
isDefault(
"device.rerouting.adaptation-weight")) {
129 WRITE_ERROR(
"Only one of the options 'device.rerouting.adaptation-steps' or 'device.rerouting.adaptation-weight' may be given.");
132 if (oc.
getFloat(
"weights.random-factor") < 1) {
133 WRITE_ERROR(
"weights.random-factor cannot be less than 1");
137 WRITE_ERROR(
"Negative value for device.rerouting.adaptation-interval!");
140 if (oc.
getFloat(
"device.rerouting.adaptation-weight") < 0. ||
141 oc.
getFloat(
"device.rerouting.adaptation-weight") > 1.) {
142 WRITE_ERROR(
"The value for device.rerouting.adaptation-weight must be between 0 and 1!");
146 if (oc.
getInt(
"device.rerouting.threads") > 1) {
147 WRITE_ERROR(
"Parallel routing is only possible when compiled with Fox.");
160 if (!needRerouting && oc.
getFloat(
"device.rerouting.probability") == 0 && !oc.
isSet(
"device.rerouting.explicit")) {
173 const bool useLoaded = oc.
getBool(
"device.rerouting.init-with-loaded-weights");
174 const double currentSecond =
SIMTIME;
175 for (MSEdgeVector::const_iterator i = edges.begin(); i != edges.end(); ++i) {
176 while ((*i)->getNumericalID() >= (int)
myEdgeSpeeds.size()) {
185 myEdgeSpeeds[(*i)->getNumericalID()] = (*i)->getMeanSpeed();
198 if (myAdaptationWeight < 1. && myAdaptationInterval > 0) {
201 }
else if (period > 0) {
202 WRITE_WARNING(
"Rerouting is useless if the edge weights do not get updated!");
263 const std::pair<const MSEdge*, const MSEdge*> key = std::make_pair(source, dest);
308 std::map<std::pair<const MSEdge*, const MSEdge*>,
const MSRoute*>::iterator it =
myCachedRoutes.begin();
310 it->second->release();
316 for (MSEdgeVector::const_iterator i = edges.begin(); i != edges.end(); ++i) {
317 const int id = (*i)->getNumericalID();
318 const double currSpeed = (*i)->getMeanSpeed();
326 for (MSEdgeVector::const_iterator i = edges.begin(); i != edges.end(); ++i) {
327 const int id = (*i)->getNumericalID();
328 const double currSpeed = (*i)->getMeanSpeed();
341 for (MSEdgeVector::const_iterator i = edges.begin(); i != edges.end(); ++i) {
342 const int id = (*i)->getNumericalID();
362 const bool needThread = (
myRouter == 0 && myThreadPool.isFull());
364 const bool needThread =
true;
368 const std::string routingAlgorithm = oc.
getString(
"routing-algorithm");
370 if (routingAlgorithm ==
"dijkstra") {
371 if (mayHaveRestrictions) {
378 }
else if (routingAlgorithm ==
"astar") {
379 if (mayHaveRestrictions) {
381 const AStar::LookupTable* lookup = 0;
382 if (oc.
isSet(
"device.rerouting.shortest-path-file")) {
388 const AStar::LookupTable* lookup = 0;
389 if (oc.
isSet(
"device.rerouting.shortest-path-file")) {
394 }
else if (routingAlgorithm ==
"CH") {
396 if (mayHaveRestrictions) {
403 }
else if (routingAlgorithm ==
"CHWrapper") {
409 throw ProcessError(
"Unknown routing algorithm '" + routingAlgorithm +
"'!");
415 if (myThreadPool.size() < numThreads) {
416 new WorkerThread(myThreadPool,
myRouter);
418 if (myThreadPool.size() < numThreads) {
422 if (myThreadPool.size() > 0) {
423 myThreadPool.add(
new RoutingTask(
myHolder, currentTime, onInit));
448 if (myThreadPool.size() > 0) {
451 myThreadPool.clear();
464 MSDevice_Routing::waitForAll() {
465 if (myThreadPool.size() > 0) {
466 myThreadPool.waitAll();
476 myVehicle.reroute(myTime, static_cast<WorkerThread*>(context)->getRouter(), myOnInit,
myWithTaz);
477 const MSEdge* source = *myVehicle.getRoute().begin();
478 const MSEdge* dest = myVehicle.getRoute().getLastEdge();
480 const std::pair<const MSEdge*, const MSEdge*> key = std::make_pair(source, dest);
484 myVehicle.getRoute().addReference();
Computes the shortest path through a contracted network.
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.
OutputDevice & writeAttr(const SumoXMLAttr attr, const T &val)
writes a named attribute
void prohibit(const std::vector< E *> &toProhibit)
virtual bool replaceRoute(const MSRoute *route, bool onInit=false, int offset=0, bool addStops=true)=0
Replaces the current route by the given one.
const int VEHPARS_FORCE_REROUTE
int getInt(const std::string &name) const
Returns the int-value of the named option (only for Option_Integer)
static double myRandomizeWeightsFactor
Whether to disturb edge weights dynamically.
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.
SUMOVehicle & myHolder
The vehicle that stores the device.
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.
Computes the shortest path through a network using the A* algorithm.
weights: time range begin
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).
const MSEdge * getLastEdge() const
returns the destination edge
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.
double getLength() const
return the length of the edge
int getNumericalID() const
Returns the numerical id of the edge.
#define WRITE_WARNING(msg)
Computes the shortest path through a network using the Dijkstra algorithm.
static OptionsCont & getOptions()
Retrieves the options.
static std::vector< std::vector< double > > myPastEdgeSpeeds
The container of edge speeds.
static double myAdaptationWeight
Information which weight prior edge efforts have.
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.
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'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
The edge is a district edge.
Representation of a vehicle.
static double getTravelTime(const MSEdge *const e, const SUMOVehicle *const v, double t)
Returns the travel time to pass an edge.
MSEventControl * getBeginOfTimestepEvents()
Returns the event control for events executed at the begin of a time step.
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.
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.
double getMinimumTravelTime(const SUMOVehicle *const veh) const
returns the minimum travel time for the given vehicle
SUMOTime depart
The vehicle's departure time.
virtual void addEvent(Command *operation, SUMOTime execTimeStep=-1)
Adds an Event.
A wrapper for a Command function.
SUMOTime getCurrentTimeStep() const
Returns the current simulation step.
SUMOTime string2time(const std::string &r)
static double rand()
Returns a random real number in [0, 1)
static std::vector< double > myEdgeSpeeds
The container of edge speeds.
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.
EdgeBasicFunction getPurpose() const
Returns the edge type (EdgeBasicFunction)
double getFloat(const std::string &name) const
Returns the double-value of the named option (only for Option_Float)
begin/end of the description of an edge
MSEventControl * getEndOfTimestepEvents()
Returns the event control for events executed at the end of a time step.
Abstract in-vehicle device.
static bool equippedByDefaultAssignmentOptions(const OptionsCont &oc, const std::string &deviceName, SUMOVehicle &v)
Determines whether a vehicle should get a certain device.
A pool of worker threads which distributes the tasks and collects the results.
The vehicle has departed (was inserted into the network)
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.
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)
A storage for options typed value containers)
MSEventControl * getInsertionEvents()
Returns the event control for insertion events.
static void buildVehicleDevices(SUMOVehicle &v, std::vector< MSDevice *> &into)
Build devices for the given vehicle, if needed.
bool notifyEnter(SUMOVehicle &veh, MSMoveReminder::Notification reason, const MSLane *enteredLane=0)
Computes a new route on vehicle insertion.
const MSEdgeVector & getEdges() const
Returns loaded edges.
bool wasSet(int what) const
Returns whether the given parameter was set.
an aggreagated-output interval
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.
Static storage of an output device and its base (abstract) implementation.
static void cleanup()
deletes the router instance
static bool checkOptions(OptionsCont &oc)
checks MSDevice_Routing-options
bool closeTag()
Closes the most recently opened tag.
A thread repeatingly calculating incoming tasks.
MSEdgeControl & getEdgeControl()
Returns the edge control.
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.
std::vector< MSEdge * > MSEdgeVector
void addDescription(const std::string &name, const std::string &subtopic, const std::string &description)
Adds a description for an option.
static double getAssumedSpeed(const MSEdge *edge)
return current travel speed assumption
static SUMOAbstractRouter< MSEdge, SUMOVehicle > & getRouterTT(const MSEdgeVector &prohibited=MSEdgeVector())
return the router instance
static SUMOTime myLastAdaptation
Information when the last edge weight adaptation occured.
Representation of a lane in the micro simulation.
virtual const std::string & getID() const =0
Get the vehicle's ID.
static double getEffort(const MSEdge *const e, const SUMOVehicle *const v, double t)
Returns the effort to pass an edge.
OutputDevice & openTag(const std::string &xmlElement)
Opens an XML tag.
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.