MSTriggeredRerouter.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2001-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
/****************************************************************************/
// Reroutes vehicles passing an edge
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <string>
#include <vector>
#include <map>
#include <utils/common/Command.h>
#include <utils/common/Named.h>
#include <utils/xml/SUMOSAXHandler.h>
#include <utils/distribution/RandomDistributor.h>
#include <microsim/MSMoveReminder.h>
#include "MSStoppingPlaceRerouter.h"
 
 
// ===========================================================================
// class declarations
// ===========================================================================
class MSNet;
class MSLane;
class MSRoute;
class SUMOVehicle;
class MSBaseVehicle;
class MSParkingArea;
class MSRailSignal;
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class MSTriggeredRerouter :
    public Named, public MSMoveReminder,
    public SUMOSAXHandler, MSStoppingPlaceRerouter {
 
    friend class GUIEdge; // dynamic instantiation
 
public:
    MSTriggeredRerouter(const std::string& id, const MSEdgeVector& edges,
                        double prob, bool off, bool optional, SUMOTime timeThreshold,
                        const std::string& vTypes, const Position& pos, const double radius);
 
 
    virtual ~MSTriggeredRerouter();
 
    typedef std::map<const MSEdge*, RouterProhibition> Prohibitions;
 
    struct OvertakeLocation {
        MSEdgeVector main;
        ConstMSEdgeVector cMain;
        MSEdgeVector siding;
        ConstMSEdgeVector cSiding;
        MSRailSignal* sidingExit = nullptr;
        double sidingLength = 0;
        double minSaving;
        bool defer;
    };
 
    struct RerouteInterval {
        long long int id;
        SUMOTime begin;
        SUMOTime end;
        std::map<MSEdge*, std::pair<SVCPermissions, double> > closed;
        std::map<MSLane*, SVCPermissions> closedLanes;
        MSEdgeVector closedLanesAffected;
        RandomDistributor<MSEdge*> edgeProbs;
        RandomDistributor<ConstMSRoutePtr> routeProbs;
        RandomDistributor<MSStoppingPlaceRerouter::StoppingPlaceVisible> parkProbs;
        bool isVia = false;
        bool permissionsAllowAll = false;
 
        std::vector<OvertakeLocation> overtakeLocations;
        //}
 
        std::vector<MSStoppingPlaceRerouter::StoppingPlaceVisible> stopAlternatives;
        //}
 
        Prohibitions getClosed() const {
            Prohibitions v;
            for (const auto& settings : closed) {
                // no permissions are changed but edges are forbidden for all during routing
                v[settings.first].permissions = settings.second.first == SVCAll ? 0 : settings.second.first;
                if (settings.second.second != -1) {
                    // end time is known
                    v[settings.first].end = STEPS2TIME(settings.second.second);
                }
            }
            return v;
        }
 
        MSEdgeVector getClosedEdges() const {
            MSEdgeVector v;
            for (const auto& settings : closed) {
                v.push_back(settings.first);
            }
            return v;
        }
    };
 
    bool notifyEnter(SUMOTrafficObject& veh, MSMoveReminder::Notification reason, const MSLane* enteredLane = 0);
 
 
    bool notifyMove(SUMOTrafficObject& veh, double oldPos, double newPos, double newSpeed);
 
    bool notifyLeave(SUMOTrafficObject& veh, double lastPos, MSMoveReminder::Notification reason, const MSLane* enteredLane = 0);
 
    bool triggerRouting(SUMOTrafficObject& veh, MSMoveReminder::Notification reason);
 
    const RerouteInterval* getCurrentReroute(SUMOTime time, SUMOTrafficObject& obj) const;
 
    SUMOTime setPermissions(const SUMOTime currentTime);
 
    const RerouteInterval* getCurrentReroute(SUMOTime time) const;
 
    void setUserMode(bool val);
 
    void setUserUsageProbability(double prob);
 
    bool inUserMode() const;
 
    double getProbability() const;
 
    double getUserProbability() const;
 
    // @brief return whether this moveReminder triggers parking reroute
    bool isParkingRerouter() const {
        return myHaveParkProbs;
    }
 
    const Position& getPosition() {
        return myPosition;
    }
 
    double getStoppingPlaceOccupancy(MSStoppingPlace* sp);
 
    double getLastStepStoppingPlaceOccupancy(MSStoppingPlace* sp);
 
    double getStoppingPlaceCapacity(MSStoppingPlace* sp);
 
    void rememberBlockedStoppingPlace(SUMOVehicle& veh, const MSStoppingPlace* parkingArea, bool blocked);
 
    void rememberStoppingPlaceScore(SUMOVehicle& veh, MSStoppingPlace* parkingArea, const std::string& score);
 
    void resetStoppingPlaceScores(SUMOVehicle& veh);
 
    SUMOTime sawBlockedStoppingPlace(SUMOVehicle& veh, MSStoppingPlace* parkingArea, bool local);
 
    int getNumberStoppingPlaceReroutes(SUMOVehicle& veh);
 
    void setNumberStoppingPlaceReroutes(SUMOVehicle& veh, int value);
 
    MSParkingArea* rerouteParkingArea(const MSTriggeredRerouter::RerouteInterval* rerouteDef,
                                      SUMOVehicle& veh, bool& newDestination, ConstMSEdgeVector& newRoute);
 
    std::pair<const SUMOVehicle*, MSRailSignal*> overtakingTrain(
            const SUMOVehicle& veh,
            ConstMSEdgeVector::const_iterator mainStart,
            const OvertakeLocation& oloc,
            double& netSaving);
 
    void checkStopSwitch(MSBaseVehicle& veh, const MSTriggeredRerouter::RerouteInterval* def);
 
    static MSRailSignal* findSignal(ConstMSEdgeVector::const_iterator begin, ConstMSEdgeVector::const_iterator end);
 
    static MSRailSignal* getRailSignal(const MSEdge* edge);
 
    static const std::map<std::string, MSTriggeredRerouter*>& getInstances() {
        return myInstances;
    }
 
    static void checkParkingRerouteConsistency();
 
    static double getEvalDefaultWeight(std::string& paramName) {
        if (paramName == "") {
            return 1.;
        }
        return 0.;
    }
 
    static const double DEFAULT_MAXDELAY;
 
protected:
 
 
    virtual void myStartElement(int element,
                                const SUMOSAXAttributes& attrs);
 
 
    virtual void myEndElement(int element);
 
    bool applies(const SUMOTrafficObject& obj) const;
 
    void resetClosedEdges(bool hasReroutingDevice, const SUMOTrafficObject& o);
 
    static bool affected(const std::set<SUMOTrafficObject::NumericalID>& edgeIndices, const MSEdgeVector& closed);
 
protected:
    const MSEdgeVector myEdges;
 
    std::vector<RerouteInterval> myIntervals;
 
    double myProbability, myUserProbability;
 
    bool myAmInUserMode;
 
    bool myAmOptional;
 
    Position myPosition;
 
    double myRadius;
 
    // @brief waiting time threshold for activation
    SUMOTime myTimeThreshold;
 
    std::set<std::string> myVehicleTypes;
 
    RerouteInterval myParsedRerouteInterval;
 
    bool myHaveParkProbs;
 
    std::set<const MSStoppingPlace*> myBlockedStoppingPlaces;
 
    static MSEdge mySpecialDest_keepDestination;
    static MSEdge mySpecialDest_terminateRoute;
 
    static std::map<std::string, MSTriggeredRerouter*> myInstances;
 
private:
    MSTriggeredRerouter(const MSTriggeredRerouter&);
 
    MSTriggeredRerouter& operator=(const MSTriggeredRerouter&);
 
 
};