MSDevice_StationFinder.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2001-2024 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 which triggers rerouting to nearby charging stations
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <utils/common/WrappingCommand.h>
#include <microsim/trigger/MSStoppingPlaceRerouter.h>
#include "MSVehicleDevice.h"
 
 
#define DEFAULT_SOC_INTERVAL 0.1
#define DEFAULT_ENERGY_PER_DISTANCE 200 // Wh/km
#define DEFAULT_AVG_WAITING_TIME 900. // s
#define DEFAULT_CHARGINGSTATION_VIEW_DIST 10 // m
#define DEFAULT_CONSUMPTION_ESTIMATE_HISTORY 10 // s
#define DEFAULT_OPPORTUNITY_INTERVAL 1800 // s
 
// ===========================================================================
// class declarations
// ===========================================================================
class MSDevice_Battery;
class MSStoppingPlace;
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class MSDevice_StationFinder : public MSVehicleDevice, MSStoppingPlaceRerouter {
public:
    enum ChargeType {
        CHARGETYPE_CHARGING,
        CHARGETYPE_BIDIRECTIONAL,
        CHARGETYPE_BATTERYEXCHANGE,
        CHARGETYPE_FUEL
    };
 
    enum ChargingStrategy {
        CHARGINGSTRATEGY_NONE,
        CHARGINGSTRATEGY_BALANCED,
        CHARGINGSTRATEGY_LATEST
    };
 
    enum RescueAction {
        RESCUEACTION_NONE,
        RESCUEACTION_REMOVE,
        RESCUEACTION_TOW
    };
 
    enum SearchState {
        SEARCHSTATE_NONE = 0,
        SEARCHSTATE_SUCCESSFUL,
        SEARCHSTATE_UNSUCCESSFUL,
        SEARCHSTATE_CHARGING,
        SEARCHSTATE_WAITING,
        SEARCHSTATE_BROKEN_DOWN
    };
 
    static void insertOptions(OptionsCont& oc);
 
 
    static void buildVehicleDevices(SUMOVehicle& v, std::vector<MSVehicleDevice*>& into);
 
    MSDevice_StationFinder(SUMOVehicle& holder);
 
    ~MSDevice_StationFinder();
 
 
    bool notifyMove(SUMOTrafficObject& veh, double oldPos, double newPos, double newSpeed) override;
 
    bool notifyIdle(SUMOTrafficObject& veh) override;
 
 
    void saveState(OutputDevice& out) const override;
 
    void loadState(const SUMOSAXAttributes& attrs) override;
 
    const std::string deviceName() const override {
        return "stationfinder";
    }
 
    const std::string getChargingStrategy() const {
        if (myChargingStrategy == CHARGINGSTRATEGY_NONE) {
            return "none";
        } else if (myChargingStrategy == CHARGINGSTRATEGY_BALANCED) {
            return "balanced";
        } else {
            return "latest";
        }
    }
 
    void generateOutput(OutputDevice* tripinfoOut) const override;
 
    void setBattery(MSDevice_Battery* battery) {
        myBattery = battery;
    }
 
    std::string getParameter(const std::string& key) const override;
 
    void setParameter(const std::string& key, const std::string& value) override;
 
    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) override;
 
    bool validComponentValues(StoppingPlaceParamMap_t& stoppingPlaceValues) override;
 
    bool useStoppingPlace(MSStoppingPlace* stoppingPlace) override;
 
    SUMOAbstractRouter<MSEdge, SUMOVehicle>& getRouter(SUMOVehicle& veh, const MSEdgeVector& prohibited) override;
 
    double getStoppingPlaceOccupancy(MSStoppingPlace* stoppingPlace) override;
 
    double getLastStepStoppingPlaceOccupancy(MSStoppingPlace* stoppingPlace) override;
 
    double getStoppingPlaceCapacity(MSStoppingPlace* stoppingPlace) override;
 
    void rememberBlockedStoppingPlace(SUMOVehicle& veh, const MSStoppingPlace* stoppingPlace, bool blocked) override;
 
    void rememberStoppingPlaceScore(SUMOVehicle& veh, MSStoppingPlace* place, const std::string& score) override;
 
    void resetStoppingPlaceScores(SUMOVehicle& veh) override;
 
    SUMOTime sawBlockedStoppingPlace(SUMOVehicle& veh, MSStoppingPlace* place, bool local) override;
 
    int getNumberStoppingPlaceReroutes(SUMOVehicle& veh) override;
 
    void setNumberStoppingPlaceReroutes(SUMOVehicle& veh, int value) override;
 
protected:
    void notifyMoveInternal(const SUMOTrafficObject& veh,
                            const double frontOnLane,
                            const double timeOnLane,
                            const double meanSpeedFrontOnLane,
                            const double meanSpeedVehicleOnLane,
                            const double travelledDistanceFrontOnLane,
                            const double travelledDistanceVehicleOnLane,
                            const double meanLengthOnLane) override;
 
private:
    MSChargingStation* findChargingStation(SUMOAbstractRouter<MSEdge,
                                           SUMOVehicle>& router,
                                           double expectedConsumption,
                                           StoppingPlaceParamMap_t& scores,
                                           bool constrainTT = true, bool skipVisited = true, bool skipOccupied = false, bool visible = false);
 
 
    bool rerouteToChargingStation(bool replace = false);
 
 
    bool planOpportunisticCharging();
 
 
    SUMOTime teleportToChargingStation(const SUMOTime currentTime);
 
    double estimateConsumption(const MSEdge* target = nullptr, const bool includeEmptySoC = true, const double stopDiscount = 0.) const;
 
    double freeSpaceAtChargingStation(MSChargingStation* cs) const;
 
    bool alreadyPlannedCharging();
 
    void initRescueCommand();
 
    void initChargeLimitCommand();
 
    SUMOTime updateChargeLimit(const SUMOTime currentTime);
 
    void implementChargingStrategy(SUMOTime begin, SUMOTime end, const double plannedCharge, const MSChargingStation* cs);
 
private:
    MSVehicle& myVeh;
 
    MSDevice_Battery* myBattery;
 
    MSStoppingPlace* myChargingStation;
 
    WrappingCommand<MSDevice_StationFinder>* myRescueCommand;
 
    WrappingCommand<MSDevice_StationFinder>* myChargeLimitCommand;
 
    std::vector<std::pair<SUMOTime, double>> myChargeLimits;
 
    SUMOTime myLastChargeCheck;
 
    SUMOTime myCheckInterval;
 
    SUMOTime myArrivalAtChargingStation;
 
    SUMOTime myLastSearch;
 
    SUMOTime myLastOpportunisticSearch;
 
    double myRescueTime;
 
    double myReserveFactor;
 
    double myEmptySoC;
 
    double myMaxEuclideanDistance;
 
    SUMOTime myRadius;
 
    SUMOTime myRepeatInterval;
 
    SUMOTime myWaitForCharge;
 
    SUMOTime myMinOpportunisticTime;
 
    double myUpdateSoC;
 
    double myMaxChargePower;
 
    double myTargetSoC;
 
    double mySearchSoC;
 
    double myOpportunitySoC;
 
    double myReplacePlannedStop;
 
    double myDistanceToOriginalStop;
 
    ChargeType myChargeType;
 
    ChargingStrategy myChargingStrategy;
 
    RescueAction myRescueAction;
 
    SearchState mySearchState = SEARCHSTATE_NONE;
 
private:
    MSDevice_StationFinder(const MSDevice_StationFinder&);
 
    MSDevice_StationFinder& operator=(const MSDevice_StationFinder&);
};