MSRoutingEngine.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2007-2025 German Aerospace Center (DLR) and others.
// This program and the accompanying materials are made available under the
// terms of the Eclipse Public License 2.0 which is available at
// https://www.eclipse.org/legal/epl-2.0/
// This Source Code may also be made available under the following Secondary
// Licenses when the conditions for such availability set forth in the Eclipse
// Public License 2.0 are satisfied: GNU General Public License, version 2
// or later which is available at
// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
/****************************************************************************/
// A device that performs vehicle rerouting based on current edge speeds
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <set>
#include <vector>
#include <map>
#include <thread>
#include <utils/common/SUMOTime.h>
#include <utils/common/WrappingCommand.h>
#include <utils/router/AStarRouter.h>
#include <microsim/MSRouterDefs.h>
 
#ifdef HAVE_FOX
#include <utils/foxtools/MFXWorkerThread.h>
#endif
 
 
// ===========================================================================
// class declarations
// ===========================================================================
class MSTransportable;
class SUMOSAXAttributes;
 
// ===========================================================================
// class definitions
// ===========================================================================
class MSRoutingEngine {
public:
    typedef std::map<const MSEdge*, double> Prohibitions;
 
    static void initWeightUpdate();
 
    static void initEdgeWeights(SUMOVehicleClass svc, SUMOTime lastAdaption = -1, int index = -1);
 
    static bool hasEdgeUpdates() {
        return myEdgeWeightSettingCommand != nullptr;
    }
 
    static SUMOTime getLastAdaptation() {
        return myLastAdaptation;
    }
 
    static ConstMSRoutePtr getCachedRoute(const std::pair<const MSEdge*, const MSEdge*>& key);
 
    static void initRouter(SUMOVehicle* vehicle = nullptr);
 
    static void reroute(SUMOVehicle& vehicle, const SUMOTime currentTime, const std::string& info,
                        const bool onInit = false, const bool silent = false, const Prohibitions& prohibited = {});
 
    static void reroute(MSTransportable& t, const SUMOTime currentTime, const std::string& info,
                        const bool onInit = false, const bool silent = false, const Prohibitions& prohibited = {});
 
    static void setEdgeTravelTime(const MSEdge* const edge, const double travelTime);
 
    static void cleanup();
 
    static bool isEnabled() {
        return !myWithTaz && myAdaptationInterval >= 0;
    }
 
    static MSVehicleRouter& getRouterTT(const int rngIndex,
                                        SUMOVehicleClass svc,
                                        const Prohibitions& prohibited = {});
 
    static MSTransportableRouter& getIntermodalRouterTT(const int rngIndex,
            const Prohibitions& prohibited = {});
 
    static double getEffort(const MSEdge* const e, const SUMOVehicle* const v, double t);
    static double getEffortBike(const MSEdge* const e, const SUMOVehicle* const v, double t);
    static double getEffortExtra(const MSEdge* const e, const SUMOVehicle* const v, double t);
    static SUMOAbstractRouter<MSEdge, SUMOVehicle>::Operation myEffortFunc;
 
    static double getAssumedSpeed(const MSEdge* edge, const SUMOVehicle* veh);
 
    static bool withTaz() {
        return myWithTaz;
    }
 
    static void addEdgeTravelTime(const MSEdge& edge, const SUMOTime travelTime);
 
    static void initGUIThreadRNG();
 
    static void saveState(OutputDevice& out);
 
    static void loadState(const SUMOSAXAttributes& attrs);
 
#ifdef HAVE_FOX
    static void waitForAll();
#endif
 
 
private:
#ifdef HAVE_FOX
    class RoutingTask : public MFXWorkerThread::Task {
    public:
        RoutingTask(SUMOVehicle& v, const SUMOTime time, const std::string& info,
                    const bool onInit, const bool silent, const Prohibitions& prohibited)
            : myVehicle(v), myTime(time), myInfo(info), myOnInit(onInit), mySilent(silent), myProhibited(prohibited) {}
        void run(MFXWorkerThread* context);
    private:
        SUMOVehicle& myVehicle;
        const SUMOTime myTime;
        const std::string myInfo;
        const bool myOnInit;
        const bool mySilent;
        const Prohibitions myProhibited;
    private:
        RoutingTask& operator=(const RoutingTask&) = delete;
    };
 
    class InitTask : public MFXWorkerThread::Task {
    public:
        InitTask() {}
        void run(MFXWorkerThread* context);
    private:
        RoutingTask& operator=(const RoutingTask&) = delete;
    };
#endif
 
 
    static SUMOTime adaptEdgeEfforts(SUMOTime currentTime);
 
    static double patchSpeedForTurns(const MSEdge* edge, double currSpeed);
 
    static void _initEdgeWeights(std::vector<double>& edgeSpeeds, std::vector<std::vector<double> >& pastEdgeSpeeds);
 
    static SumoRNG* getThreadRNG();
 
private:
    static Command* myEdgeWeightSettingCommand;
 
    static double myAdaptationWeight;
 
    static SUMOTime myAdaptationInterval;
 
    static SUMOTime myLastAdaptation;
 
    static int myAdaptationSteps;
 
    static int myAdaptationStepsIndex;
 
    typedef std::pair<SUMOTime, int> TimeAndCount;
 
    static std::vector<double> myEdgeSpeeds;
    static std::vector<double> myEdgeBikeSpeeds;
 
    static std::vector<TimeAndCount> myEdgeTravelTimes;
 
    static std::vector<std::vector<double> > myPastEdgeSpeeds;
    static std::vector<std::vector<double> > myPastEdgeBikeSpeeds;
 
    static bool myWithTaz;
 
    static bool myBikeSpeeds;
 
    static MSRouterProvider* myRouterProvider;
 
    static std::map<std::thread::id, SumoRNG*> myThreadRNGs;
    static bool myHaveRoutingThreads;
 
    static std::map<std::pair<const MSEdge*, const MSEdge*>, ConstMSRoutePtr> myCachedRoutes;
 
    static double myPriorityFactor;
 
    static double myMinEdgePriority;
    static double myEdgePriorityRange;
 
#ifdef HAVE_FOX
    static FXMutex myRouteCacheMutex;
#endif
 
private:
    MSRoutingEngine(const MSRoutingEngine&);
 
    MSRoutingEngine& operator=(const MSRoutingEngine&);
 
 
};