MSStoppingPlaceRerouter.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
/****************************************************************************/
// The MSStoppingPlaceRerouter provides an interface to structure the rerouting
// to the best StoppingPlace according to the evaluation components and
// associated weights.
/****************************************************************************/
#pragma once
#include <config.h>
#include <map>
#include <functional>
#include <utils/common/MsgHandler.h>
#include <utils/common/Named.h>
#include <utils/common/SUMOTime.h>
#include <utils/router/SUMOAbstractRouter.h>
#include <utils/xml/SUMOXMLDefinitions.h>
#include <microsim/MSNet.h>
#include <microsim/MSStop.h>
#include <microsim/MSStoppingPlace.h>
 
class MSEdge;
 
struct StoppingPlaceMemoryEntry {
    StoppingPlaceMemoryEntry() : blockedAtTime(-1), blockedAtTimeLocal(-1), score("") {}
 
    SUMOTime blockedAtTime;
    SUMOTime blockedAtTimeLocal;
    std::string score;
};
 
 
class StoppingPlaceMemory {
public:
    typedef std::map<const MSStoppingPlace*, StoppingPlaceMemoryEntry, ComparatorIdLess> StoppingPlaceMap;
 
    StoppingPlaceMemory() {}
 
    // Destructor
    virtual ~StoppingPlaceMemory() {}
 
    bool remove(MSStoppingPlace* id) {
        auto it = myMap.find(id);
        if (it == myMap.end()) {
            return false;
        } else {
            myMap.erase(it);
            return true;
        }
    }
 
    void clear() {
        myMap.clear();
    }
 
    int size() const {
        return (int)myMap.size();
    }
 
    void rememberBlockedStoppingPlace(const MSStoppingPlace* stoppingPlace, bool local) {
        myMap[stoppingPlace].blockedAtTime = SIMSTEP;
        if (local) {
            myMap[stoppingPlace].blockedAtTimeLocal = SIMSTEP;
        }
    }
 
    SUMOTime sawBlockedStoppingPlace(const MSStoppingPlace* stoppingPlace, bool local) const {
        auto it = myMap.find(stoppingPlace);
        if (it == myMap.end()) {
            return -1;
        } else {
            return local ? it->second.blockedAtTimeLocal : it->second.blockedAtTime;
        }
    }
 
    void rememberStoppingPlaceScore(const MSStoppingPlace* stoppingPlace, const std::string& score) {
        myMap[stoppingPlace].score = score;
    }
 
    void resetStoppingPlaceScores() {
        for (auto& item : myMap) {
            item.second.score = "";
        }
    }
 
    typename StoppingPlaceMap::const_iterator begin() const {
        return myMap.begin();
    }
 
    typename StoppingPlaceMap::const_iterator end() const {
        return myMap.end();
    }
 
private:
    StoppingPlaceMap myMap;
 
};
 
 
class MSStoppingPlaceRerouter {
public:
    typedef std::map<std::string, double> StoppingPlaceParamMap_t;
    typedef std::map<std::string, bool> StoppingPlaceParamSwitchMap_t;
    typedef std::map<MSStoppingPlace*, StoppingPlaceParamMap_t, ComparatorIdLess> StoppingPlaceMap_t;
    typedef std::pair<MSStoppingPlace*, bool> StoppingPlaceVisible;
    typedef std::map<const MSEdge*, double> Prohibitions;
 
    MSStoppingPlaceRerouter(std::string paramPrefix = "", bool checkValidity = false, StoppingPlaceParamMap_t addEvalParams = {}, StoppingPlaceParamSwitchMap_t addInvertParams = {});
 
    // Destructor
    virtual ~MSStoppingPlaceRerouter() {}
 
    MSStoppingPlace* rerouteStoppingPlace(MSStoppingPlace* destStoppingPlace, const std::vector<StoppingPlaceVisible>& stoppingPlaceCandidates, const std::vector<double>& probs, SUMOVehicle& veh,
                                          bool& newDestination, ConstMSEdgeVector& newRoute, StoppingPlaceParamMap_t& scores, const Prohibitions& closedEdges = {},
                                          const int insertStopIndex = 0, const bool keepCurrentStop = true);
    virtual bool evaluateDestination(SUMOVehicle& veh, double brakeGap, bool newDestination,
                                     MSStoppingPlace* alternative, double occupancy, double prob,
                                     SUMOAbstractRouter<MSEdge, SUMOVehicle>& router, StoppingPlaceMap_t& stoppingPlaces,
                                     std::map<MSStoppingPlace*, ConstMSEdgeVector>& newRoutes,
                                     std::map<MSStoppingPlace*, ConstMSEdgeVector>& stoppingPlaceApproaches,
                                     StoppingPlaceParamMap_t& maxValues,
                                     StoppingPlaceParamMap_t& addInput,
                                     const int insertStopIndex = 0,
                                     const bool keepCurrentStop = true);
 
    virtual bool evaluateCustomComponents(SUMOVehicle& veh, double brakeGap, bool newDestination,
                                          MSStoppingPlace* alternative, double occupancy, double prob,
                                          SUMOAbstractRouter<MSEdge, SUMOVehicle>& router, StoppingPlaceParamMap_t& stoppingPlaceValues,
                                          ConstMSEdgeVector& newRoute,
                                          ConstMSEdgeVector& stoppingPlaceApproach,
                                          StoppingPlaceParamMap_t& maxValues,
                                          StoppingPlaceParamMap_t& addInput);
 
    virtual bool validComponentValues(StoppingPlaceParamMap_t& stoppingPlaceValues);
 
    virtual bool useStoppingPlace(MSStoppingPlace* stoppingPlace);
 
    virtual SUMOAbstractRouter<MSEdge, SUMOVehicle>& getRouter(SUMOVehicle& veh, const Prohibitions& prohibited = {});
 
    virtual double getStoppingPlaceOccupancy(MSStoppingPlace* stoppingPlace) = 0;
 
    virtual double getLastStepStoppingPlaceOccupancy(MSStoppingPlace* stoppingPlace) = 0;
 
    virtual double getStoppingPlaceCapacity(MSStoppingPlace* stoppingPlace) = 0;
 
    virtual void rememberBlockedStoppingPlace(SUMOVehicle& veh, const MSStoppingPlace* stoppingPlace, bool blocked) = 0;
 
    virtual void rememberStoppingPlaceScore(SUMOVehicle& veh, MSStoppingPlace* place, const std::string& score) = 0;
 
    virtual void resetStoppingPlaceScores(SUMOVehicle& veh) = 0;
 
    virtual SUMOTime sawBlockedStoppingPlace(SUMOVehicle& veh, MSStoppingPlace* place, bool local) = 0;
 
    virtual int getNumberStoppingPlaceReroutes(SUMOVehicle& veh) = 0;
 
    virtual void setNumberStoppingPlaceReroutes(SUMOVehicle& veh, int value) = 0;
 
    virtual StoppingPlaceParamMap_t collectWeights(SUMOVehicle& veh);
 
    double getWeight(SUMOVehicle& veh, const std::string param, const double defaultWeight, const bool warn = false);
 
    static void updateMaxValues(StoppingPlaceParamMap_t& stoppingPlaceValues, StoppingPlaceParamMap_t& maxValues);
 
    static double getTargetValue(const StoppingPlaceParamMap_t& absValues, const StoppingPlaceParamMap_t& maxValues, const StoppingPlaceParamMap_t& weights, const StoppingPlaceParamSwitchMap_t& norm, const StoppingPlaceParamSwitchMap_t& invert);
 
protected:
    void readEvaluationWeights(SUMOVehicle& veh, StoppingPlaceParamMap_t& stoppingPlaceParams, StoppingPlaceParamMap_t& stoppingPlaceDefaults, StoppingPlaceParamMap_t& maxValues) {
        for (auto& it : stoppingPlaceParams) {
            const double value = getWeight(veh, it.first, stoppingPlaceDefaults[it.first]);
            it.second = value;
            if (value > maxValues[it.first]) {
                maxValues[it.first] = value;
            }
        }
    }
 
    const MSRouteIterator determineRerouteOrigin(SUMOVehicle& veh, int insertStopIndex) {
        const int stopCount = (int)veh.getStops().size();
        if (insertStopIndex == 0 || stopCount == 0) {
            return veh.getRerouteOrigin();
        }
        // if the stop index is too high cap to route end
        const int stopIndex = MIN2(insertStopIndex, stopCount - 1);
        std::list<MSStop>::const_iterator it = veh.getStops().begin();
        std::advance(it, stopIndex);
        MSStop relevantStop = *it;
        return relevantStop.edge;
    }
 
private:
 
    MSStoppingPlaceRerouter() = delete;
 
protected:
    const std::string myParamPrefix;
    bool myCheckValidity;
    StoppingPlaceParamMap_t myEvalParams;
    StoppingPlaceParamSwitchMap_t myNormParams;
    StoppingPlaceParamSwitchMap_t myInvertParams;
};