MSRoutingEngine.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2007-2026 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/MSEdge.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 SUMOAbstractRouter<MSEdge, SUMOVehicle>::Prohibitions Prohibitions;
 
    static void initWeightConstants(const OptionsCont& oc);
 
    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 bool haveExtras() {
        return myHaveExtras;
    }
 
    static inline void applyExtras(const MSEdge* const e, const SUMOVehicle* const v, SUMOTime step, double& effort) {
        if (gWeightsRandomFactor != 1.) {
            long long int key = v->getRandomSeed() ^ e->getNumericalID();
            if (myDynamicRandomness) {
                key ^= step;
            }
            effort *= (1 + RandHelper::randHash(key) * (gWeightsRandomFactor - 1));
        }
        if (myPriorityFactor != 0) {
            // lower priority should result in higher effort (and the edge with
            // minimum priority receives a factor of 1 + myPriorityFactor
            const double relativeInversePrio = 1 - ((e->getPriority() - myMinEdgePriority) / myEdgePriorityRange);
            effort *= 1 + relativeInversePrio * myPriorityFactor;
        }
        if (gRoutingPreferences) {
            effort /= MSNet::getInstance()->getPreference(e->getRoutingType(), v->getVTypeParameter());
        }
    }
 
    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 bool hasBikeSpeeds() {
        return myBikeSpeeds;
    }
 
    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 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;
    };
 
#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::pair<const MSEdge*, const MSEdge*>, ConstMSRoutePtr> myCachedRoutes;
 
    static double myPriorityFactor;
 
    static double myMinEdgePriority;
    static double myEdgePriorityRange;
 
    static bool myDynamicRandomness;
 
    static bool myHaveExtras;
 
#ifdef HAVE_FOX
    static FXMutex myRouteCacheMutex;
#endif
 
private:
    MSRoutingEngine(const MSRoutingEngine&);
 
    MSRoutingEngine& operator=(const MSRoutingEngine&);
 
 
};