MSDevice_ToC.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2013-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
/****************************************************************************/
// The ToC Device controls the transition of control between automated and manual driving.
//
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <random>
#include <queue>
#include "MSVehicleDevice.h"
#include <utils/common/SUMOTime.h>
#include <utils/common/WrappingCommand.h>
 
 
// ===========================================================================
// class declarations
// ===========================================================================
class SUMOVehicle;
class MSVehicle;
class Command_ToCTrigger;
class Command_ToCProcess;
class RGBColor;
 
// ===========================================================================
// class definitions
// ===========================================================================
class MSDevice_ToC : public MSVehicleDevice {
private:
    // All currently existing ToC device instances
    static std::set<MSDevice_ToC*, ComparatorNumericalIdLess> myInstances;
    // All files, that receive ToC output (TODO: check if required)
    static std::set<std::string> createdOutputFiles;
 
    struct OpenGapParams {
        double newTimeHeadway;
        double newSpaceHeadway;
        double changeRate;
        double maxDecel;
        bool active;
        OpenGapParams(double timegap, double spacing, double changeRate, double maxDecel, bool active) :
            newTimeHeadway(timegap), newSpaceHeadway(spacing), changeRate(changeRate), maxDecel(maxDecel), active(active)
        {};
    };
 
public:
    static void insertOptions(OptionsCont& oc);
 
 
    static void buildVehicleDevices(SUMOVehicle& v, std::vector<MSVehicleDevice*>& into);
 
    static const std::set<MSDevice_ToC*, ComparatorNumericalIdLess>& getInstances() {
        return myInstances;
    };
 
    static void cleanup();
 
private:
 
    enum ToCState {
        UNDEFINED = 0,
        MANUAL = 1,
        AUTOMATED = 2,
        PREPARING_TOC = 3, // this applies only to the transition AUTOMATED -> MANUAL !
        MRM = 4,
        RECOVERING = 5
    };
 
    static double getDynamicMRMProbability(const SUMOVehicle& v);
    static OpenGapParams getOpenGapParams(const SUMOVehicle& v);
 
    static ToCState _2ToCState(const std::string&);
    static std::string _2string(ToCState state);
 
 
public:
    ~MSDevice_ToC();
 
    const std::string deviceName() const override {
        return "toc";
    }
 
    bool notifyMove(SUMOTrafficObject& veh,
                    double oldPos,
                    double newPos,
                    double newSpeed) override;
 
    std::string getParameter(const std::string& key) const override;
 
    void setParameter(const std::string& key, const std::string& value) override;
 
 
    SUMOTime triggerMRM(SUMOTime t);
 
    SUMOTime triggerUpwardToC(SUMOTime t);
 
    SUMOTime triggerDownwardToC(SUMOTime t);
 
    SUMOTime ToCPreparationStep(SUMOTime t);
 
    SUMOTime MRMExecutionStep(SUMOTime t);
 
    SUMOTime awarenessRecoveryStep(SUMOTime t);
 
    void writeOutput();
 
    bool generatesOutput() {
        return myOutputFile != nullptr;
    }
 
    static SumoRNG* getResponseTimeRNG() {
        return &myResponseTimeRNG;
    }
private:
    MSDevice_ToC(SUMOVehicle& holder, const std::string& id, const std::string& outputFilename,
                 const std::string& manualType, const std::string& automatedType, SUMOTime responseTime, double recoveryRate,
                 double lcAbstinence, double initialAwareness, double mrmDecel,
                 double dynamicToCThreshold, double dynamicMRMProbability, double maxPreparationAccel,
                 bool mrmKeepRight, const std::string& mrmSafeSpot, SUMOTime mrmSafeSpotDuration, bool useColorScheme, OpenGapParams ogp);
 
    void initColorScheme();
 
    void setAwareness(double value);
 
    void setState(ToCState state);
 
    // @brief Sets the device holder's color corresponding to the current state
    void setVehicleColor();
 
    void requestToC(SUMOTime timeTillMRM, SUMOTime responseTime = -1000);
 
    void requestMRM();
 
    void switchHolderType(const std::string& targetTypeID);
 
    void descheduleMRM();
    void descheduleToC();
    void descheduleToCPreparation();
    void descheduleRecovery();
 
    void resetDeliberateLCs();
    void deactivateDeliberateLCs();
 
    bool isManuallyDriven();
    bool isAutomated();
 
    bool checkDynamicToC();
 
private:
 
    std::string myManualTypeID;
    std::string myAutomatedTypeID;
 
 
    SUMOTime myResponseTime;
    double myRecoveryRate;
    double myLCAbstinence;
    double myInitialAwareness;
 
    double myMRMDecel;
 
    double myCurrentAwareness;
 
    std::map<ToCState, RGBColor> myColorScheme;
 
    bool myUseColorScheme;
 
    ToCState myState;
 
 
    MSVehicle* myHolderMS;
 
    WrappingCommand<MSDevice_ToC>* myTriggerMRMCommand;
    WrappingCommand<MSDevice_ToC>* myTriggerToCCommand;
    WrappingCommand<MSDevice_ToC>* myRecoverAwarenessCommand;
    WrappingCommand<MSDevice_ToC>* myExecuteMRMCommand;
    WrappingCommand<MSDevice_ToC>* myPrepareToCCommand;
 
    OutputDevice* myOutputFile;
 
    std::queue<std::pair<SUMOTime, std::string> > myEvents;
 
    std::queue<std::pair<std::string, double> > myEventLanes;
 
    std::queue<std::pair<double, double>> myEventXY;
 
    int myPreviousLCMode;
 
    static int LCModeMRM;
 
    OpenGapParams myOpenGapParams;
 
    double myDynamicToCThreshold;
    // (Note that these MRMs will not induce full stops in most cases)
    double myMRMProbability;
    bool myDynamicToCActive;
    bool myIssuedDynamicToC;
    int myDynamicToCLane;
 
    bool myMRMKeepRight;
 
    std::string myMRMSafeSpot;
 
    SUMOTime myMRMSafeSpotDuration;
 
    double myMaxPreparationAccel;
 
    double myOriginalMaxAccel;
 
    static std::vector<double> lookupResponseTimeMRMProbs;
    static std::vector<double> lookupResponseTimeLeadTimes;
    static double responseTimeMean(double leadTime) {
        return MIN2(2 * sqrt(leadTime), 0.7 * leadTime);
    };
    static std::vector<std::vector<double> > lookupResponseTimeVariances;
 
    static SumoRNG myResponseTimeRNG;
 
    double sampleResponseTime(double leadTime) const;
 
    static double interpolateVariance(double leadTime, double pMRM);
 
private:
    MSDevice_ToC(const MSDevice_ToC&);
 
    MSDevice_ToC& operator=(const MSDevice_ToC&);
 
 
};