MSDevice_Routing.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
// Copyright (C) 2007-2018 German Aerospace Center (DLR) and others.
// This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v2.0
// which accompanies this distribution, and is available at
// http://www.eclipse.org/legal/epl-v20.html
// SPDX-License-Identifier: EPL-2.0
/****************************************************************************/
// A device that performs vehicle rerouting based on current edge speeds
/****************************************************************************/
#ifndef MSDevice_Routing_h
#define MSDevice_Routing_h


// ===========================================================================
// included modules
// ===========================================================================
#include <config.h>

#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 && myAdaptationInterval >= 0;
    }

    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 saveState(OutputDevice& out) const;

    void loadState(const SUMOSAXAttributes& attrs);

    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);

    static void initEdgeWeights();

    static void initWeightUpdate();

    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, SUMOAbstractRouterPermissions<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

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