MSDevice_Routing.h

Go to the documentation of this file.

/****************************************************************************/
// A device that performs vehicle rerouting based on current edge speeds
/****************************************************************************/
// SUMO, Simulation of Urban MObility; see http://sumo.dlr.de/
// Copyright (C) 2007-2017 DLR (http://www.dlr.de/) and contributors
/****************************************************************************/
//
//   This file is part of SUMO.
//   SUMO is free software: you can redistribute it and/or modify
//   it under the terms of the GNU General Public License as published by
//   the Free Software Foundation, either version 3 of the License, or
//   (at your option) any later version.
//
/****************************************************************************/
#ifndef MSDevice_Routing_h
#define MSDevice_Routing_h


// ===========================================================================
// included modules
// ===========================================================================
#ifdef _MSC_VER
#include <windows_config.h>
#else
#include <config.h>
#endif

#include <set>
#include <vector>
#include <map>
#include <utils/common/SUMOTime.h>
#include <utils/common/WrappingCommand.h>
#include <utils/vehicle/SUMOAbstractRouter.h>
#include <utils/vehicle/AStarRouter.h>
#include <microsim/MSVehicle.h>
#include "MSDevice.h"

#ifdef HAVE_FOX
#include <utils/foxtools/FXWorkerThread.h>
#endif


// ===========================================================================
// class declarations
// ===========================================================================
class MSLane;

// ===========================================================================
// class definitions
// ===========================================================================
class MSDevice_Routing : public MSDevice {
public:
    static void insertOptions(OptionsCont& oc);

    static bool checkOptions(OptionsCont& oc);


    static void buildVehicleDevices(SUMOVehicle& v, std::vector<MSDevice*>& into);


    static void cleanup();

    static bool isEnabled() {
        return !myWithTaz && !myEdgeSpeeds.empty();
    }

    static SUMOAbstractRouter<MSEdge, SUMOVehicle>& getRouterTT(
        const MSEdgeVector& prohibited = MSEdgeVector());

#ifdef HAVE_FOX
    static void waitForAll();
    static void lock() {
        myThreadPool.lock();
    }
    static void unlock() {
        myThreadPool.unlock();
    }
    static bool isParallel() {
        return myThreadPool.size() > 0;
    }
#endif



public:
    ~MSDevice_Routing();




    bool notifyEnter(SUMOVehicle& veh, MSMoveReminder::Notification reason, const MSLane* enteredLane = 0);

    const std::string deviceName() const {
        return "rerouting";
    }


    void reroute(const SUMOTime currentTime, const bool onInit = false);


    void skipRouting(const SUMOTime currentTime) {
        mySkipRouting = currentTime;
    }

    static double getAssumedSpeed(const MSEdge* edge);

    std::string getParameter(const std::string& key) const;

    void setParameter(const std::string& key, const std::string& value);


private:
#ifdef HAVE_FOX

    class WorkerThread : public FXWorkerThread {
    public:
        WorkerThread(FXWorkerThread::Pool& pool,
                     SUMOAbstractRouter<MSEdge, SUMOVehicle>* router)
            : FXWorkerThread(pool), myRouter(router) {}
        SUMOAbstractRouter<MSEdge, SUMOVehicle>& getRouter() const {
            return *myRouter;
        }
        virtual ~WorkerThread() {
            stop();
            delete myRouter;
        }
    private:
        SUMOAbstractRouter<MSEdge, SUMOVehicle>* myRouter;
    };

    class RoutingTask : public FXWorkerThread::Task {
    public:
        RoutingTask(SUMOVehicle& v, const SUMOTime time, const bool onInit)
            : myVehicle(v), myTime(time), myOnInit(onInit) {}
        void run(FXWorkerThread* context);
    private:
        SUMOVehicle& myVehicle;
        const SUMOTime myTime;
        const bool myOnInit;
    private:
        RoutingTask& operator=(const RoutingTask&);
    };
#endif

    MSDevice_Routing(SUMOVehicle& holder, const std::string& id, SUMOTime period, SUMOTime preInsertionPeriod);


    SUMOTime preInsertionReroute(const SUMOTime currentTime);

    SUMOTime wrappedRerouteCommandExecute(SUMOTime currentTime);


    static double getEffort(const MSEdge* const e, const SUMOVehicle* const v, double t);




    static SUMOTime adaptEdgeEfforts(SUMOTime currentTime);


private:
    SUMOTime myPeriod;

    SUMOTime myPreInsertionPeriod;

    SUMOTime myLastRouting;

    SUMOTime mySkipRouting;

    WrappingCommand< MSDevice_Routing >* myRerouteCommand;

    static Command* myEdgeWeightSettingCommand;

    static std::vector<double> myEdgeSpeeds;

    static double myAdaptationWeight;

    static SUMOTime myAdaptationInterval;

    static SUMOTime myLastAdaptation;

    static int myAdaptationSteps;

    static int myAdaptationStepsIndex;

    static std::vector<std::vector<double> > myPastEdgeSpeeds;

    static bool myWithTaz;

    static std::map<std::pair<const MSEdge*, const MSEdge*>, const MSRoute*> myCachedRoutes;

    static SUMOAbstractRouter<MSEdge, SUMOVehicle>* myRouter;

    static AStarRouter<MSEdge, SUMOVehicle, prohibited_withPermissions<MSEdge, SUMOVehicle> >* myRouterWithProhibited;

    static double myRandomizeWeightsFactor;

#ifdef HAVE_FOX
    static FXWorkerThread::Pool myThreadPool;
#endif

private:
    MSDevice_Routing(const MSDevice_Routing&);

    MSDevice_Routing& operator=(const MSDevice_Routing&);


};


#endif

/****************************************************************************/