NEMAController.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
/****************************************************************************/
// An actuated NEMA-phase-compliant traffic light logic
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <utility>
#include <vector>
#include <bitset>
#include <map>
#include <set>
#include <microsim/MSEventControl.h>
#include <microsim/traffic_lights/MSTrafficLightLogic.h>
#include "MSSimpleTrafficLightLogic.h"
#include "microsim/output/MSE2Collector.h"
#include "MSPhaseDefinition.h"
 
 
// ===========================================================================
// class declarations
// ===========================================================================
class NLDetectorBuilder;
class MSE2Collector;
class NEMAPhase;
class PhaseTransitionLogic;
 
// ===========================================================================
// Enumeration
// ===========================================================================
enum class LightState {
    RedXfer,
    Red,
    Yellow,
    Green,
    GreenXfer,
    GreenRest,
};
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class NEMALogic : public MSSimpleTrafficLightLogic {
public:
 
    typedef NEMAPhase* PhasePtr;
 
    typedef std::map<MSLane*, MSE2Collector*> LaneDetectorMap;
 
    typedef std::map<MSE2Collector*, MSLane*, ComparatorIdLess> DetectorLaneMap;
 
    // Small structure for storing two ring transitions and the average distance
    struct transitionInfo {
        PhaseTransitionLogic* p1;
        PhaseTransitionLogic* p2;
        float distance;
    };
 
    enum controllerType {
        Type170,
        TS2
    };
 
    const std::string lightHeadPriority = "GgyuOs";
 
    typedef std::vector<transitionInfo> TransitionPairs;
 
    NEMALogic(MSTLLogicControl& tlcontrol,
              const std::string& id, const std::string& programID,
              const SUMOTime offset,
              const MSSimpleTrafficLightLogic::Phases& phases,
              int step, SUMOTime delay,
              const std::map<std::string, std::string>& parameter,
              const std::string& basePath);
 
 
    void init(NLDetectorBuilder& nb) override;
 
    ~NEMALogic();
 
    SUMOTime trySwitch() override;
 
 
    const MSPhaseDefinition& getCurrentPhaseDef() const override;
 
 
    void activateProgram() override;
    void deactivateProgram() override;
 
    bool showDetectors() const {
        return myShowDetectors;
    }
 
    void setShowDetectors(bool show);
 
    std::map<std::string, double> getDetectorStates() const override;
 
    void getNextPhases(TransitionPairs& transitions);
 
    SUMOTime ModeCycle(SUMOTime a, SUMOTime b);
 
 
    void getLaneInfoFromNEMAState(std::string state, StringVector& laneIDs, IntVector& stateIndex);
 
    void setNewMaxGreens(std::vector<double> newMaxGreens);
 
    void setNewSplits(std::vector<double> newSplits);
 
    void setNewCycleLength(double newCycleLength);
 
    void setNewOffset(double newOffset);
 
    SUMOTime getCurrentCycleLength() {
        return myCycleLength;
    }
 
    void setParameter(const std::string& key, const std::string& value) override;
 
    const std::string getParameter(const std::string& key, const std::string defaultValue = "") const override;
 
    inline SUMOTime getCurrentTime(void) const {
        return simTime;
    }
 
    // /// @brief Wrapper Function to Simplify Accessing Offset Cycle Time
    // inline SUMOTime getCurrentOffsetTime(void) const {return simTime - cycleRefPoint - offset; };
 
    inline SUMOTime getTimeInCycle() const {
        return (simTime - cycleRefPoint - offset) % myCycleLength;
    }
 
 
    void setActivePhase(PhasePtr phase);
 
    inline PhasePtr getActivePhase(int ringNum) {
        return myActivePhaseObjs[ringNum];
    }
 
    std::vector<PhasePtr> getPhasesByRing(int ringNum);
 
    PhasePtr getPhaseObj(int phaseNum, int ringNum = -1);
 
    inline std::vector<PhasePtr> getPhaseObjs(void) {
        return myPhaseObjs;
    }
 
    int measureRingDistance(int p1, int p2, int ringNum);
 
    inline bool isType170(void) const {
        return myControllerType == Type170;
    }
 
    PhasePtr getOtherPhase(PhasePtr p);
 
    bool coordinateMode;
 
    void implementTraciChanges(void);
 
    PhasePtr coordinatePhaseObjs[2];
 
protected:
 
    bool queuedTraciChanges;
 
    SUMOTime offset;
    SUMOTime myNextOffset;
 
    SUMOTime myCycleLength;
    SUMOTime myNextCycleLength;
 
    SUMOTime simTime = 0;
 
    int myNumberRings;
 
    int myPhaseStrLen = -1;
 
    inline void setCurrentTime(void) {
        simTime = MSNet::getInstance()->getCurrentTimeStep();
    }
 
    PhasePtr myActivePhaseObjs[2] = { nullptr, nullptr };
 
    std::vector<PhasePtr > myPhaseObjs;
 
    PhasePtr defaultBarrierPhases[2][2];
 
    void constructTimingAndPhaseDefs(std::string& barriers, std::string& coordinates,
                                     std::string& ring1, std::string& ring2);
 
    std::string composeLightString();
 
    bool vectorContainsPhase(std::vector<int> v, int phaseNum);
 
    // create a small datatype for mapping detector to phase index
    // This is the one copied from MSActuatedTrafficLightLogic
    // not used in our controller, but it is here for meeting the SUMO default traffic logic light check
    // this one and related could be removed with extra efforts
    struct DetectorInfo {
        DetectorInfo(MSE2Collector* _det, int numPhases) :
            det(_det),
            servedPhase(numPhases, false)
        {}
        MSE2Collector* det;
        SUMOTime lastGreenTime = 0;
        std::vector<bool> servedPhase;
    };
    typedef std::vector<std::vector<DetectorInfo*>> detectorMap;
    detectorMap myDetectorForPhase;
    std::vector<DetectorInfo> myDetectorInfoVector;
 
 
    bool hasMajor(const std::string& state, const LaneVector& lanes) const;
 
    std::vector<int> readParaFromString(std::string s);
 
    bool isLeftTurnLane(const MSLane* const lane) const;
 
    int string2int(std::string s);
 
    LaneDetectorMap myLaneDetectorMap;
 
    std::map<std::string, int> myLanePhaseMap;
 
    DetectorLaneMap myDetectorLaneMap;
 
    double myDetectorLength;
 
    double myDetectorLengthLeftTurnLane;
 
    bool myShowDetectors;
 
    std::string myFile;
 
    SUMOTime myFreq;
 
    std::string myVehicleTypes;
 
    /*
    {
        {3,4,1,2},
        {7,8,5,6}
    }
    */
    std::vector<std::vector<int>> rings;
 
    /*
    {
        {1 : PhaseDetectorInfo{
                detectors: {det1, det2, ...},
                crossPhaseDetector: 6
            },
        },
        {2 : ...
    }
    */
    // std::map<int, PhaseDetectorInfo> phase2DetectorMap;
    std::map<int, std::vector<std::string>> phase2ControllerLanesMap;
 
    bool fixForceOff;
    SUMOTime cycleRefPoint;// missing update
    bool whetherOutputState;
    bool ignoreErrors;
 
    PhaseTransitionLogic* getDefaultTransition(PhaseTransitionLogic* t, PhaseTransitionLogic* ot);
 
    // Store the cabinet type
    controllerType myControllerType;
 
    controllerType parseControllerType(std::string inputType);
 
    MSPhaseDefinition myPhase;
 
    void error_handle_not_set(std::string param_variable, std::string param_name);
 
    void validate_timing();
 
    void calculateForceOffsTS2();
    void calculateForceOffs170();
 
    void calculateForceOffs() {
        switch (myControllerType) {
            case Type170:
                return calculateForceOffs170();
            case TS2:
                return calculateForceOffsTS2();
            default:
                return calculateForceOffs170();
        }
    }
 
 
    void calculateInitialPhasesTS2();
    void calculateInitialPhases170();
    void calculateInitialPhases() {
        switch (myControllerType) {
            case Type170:
                return calculateInitialPhases170();
            case TS2:
                return calculateInitialPhasesTS2();
            default:
                // Default to Type170
                return calculateInitialPhases170();
        }
    }
};
 
 
class NEMAPhase {
public:
    typedef NEMAPhase* PhasePtr;
 
    struct PhaseDetectorInfo {
        PhaseDetectorInfo() :
            detectors(),
            cpdTarget(),
            cpdSource(),
            detectActive(),
            latching()
        {}
        PhaseDetectorInfo(bool latching, PhasePtr cpdSource, PhasePtr cpdTarget) :
            cpdTarget(cpdTarget),
            cpdSource(cpdSource),
            detectActive(false),
            latching(latching)
        {}
        std::vector<MSE2Collector*> detectors;
        PhasePtr cpdTarget;
        PhasePtr cpdSource;
        bool detectActive;
        bool latching;
    };
 
    // create a PhaseDetectorInfo type
    typedef PhaseDetectorInfo PhaseDetectorInfo;
 
    NEMAPhase(int phaseName,
              bool isBarrier,
              bool isGreenRest,
              bool isCoordinated,
              bool minRecall,
              bool maxRecall,
              bool fixForceOff,
              int barrierNum,
              int ringNum,
              IntVector phaseStringInds,
              MSPhaseDefinition* phase);
 
    ~NEMAPhase();
 
    inline LightState getCurrentState() const {
        return myLightState;
    }
    inline std::vector<MSE2Collector*> getDetectors() const {
        return myDetectorInfo.detectors;
    }
 
 
    inline void setDetectors(std::vector<MSE2Collector*> detectors) {
        myDetectorInfo.detectors = detectors;
    }
 
    inline bool isTransitionActive() const {
        return myLightState < LightState::Green;
    }
 
    // Build a Map of Valid Transitions and store the detector-based information
    void init(NEMALogic* controller, int crossPhaseTarget, int crossPhaseSource, bool latching);
 
    void update(NEMALogic* controller);
 
    void exit(NEMALogic* controller, PhaseTransitionLogic* nextPhases[2]);
 
    void handleGreenRestOrTransfer(NEMALogic* controller, PhaseTransitionLogic* nextPhases[2]);
 
    void enterYellow(NEMALogic* controller);
 
    void handleRedXferOrNextPhase(NEMALogic* controller, PhaseTransitionLogic* nextPhases[2]);
 
    inline bool hasRecall(void) {
        return minRecall || maxRecall;
    }
 
    inline bool callActive(void) {
        return minRecall || maxRecall || myDetectorInfo.detectActive;
    }
 
    inline bool detectActive(void) {
        return myDetectorInfo.detectActive;
    }
 
    void checkMyDetectors(void);
 
    void clearMyDetectors(void);
 
    // Need-to-know Phase Settings
    int phaseName;
    bool isAtBarrier;
    bool isGreenRest;
    int barrierNum;
    bool coordinatePhase;
    bool minRecall;
    bool maxRecall;
    bool fixForceOff;
    int ringNum;
 
    bool lastDetectActive;
 
    SUMOTime greenRestTimer;
    SUMOTime greatestStartTime;
    SUMOTime forceOffTime;
 
    bool readyToSwitch;
 
    SUMOTime getTransitionTime(NEMALogic* controller);
 
    inline SUMOTime getTransitionTimeStateless(void) {
        return yellow + red;
    }
 
    inline PhasePtr getSequentialPriorPhase(void) {
        return sequentialPriorPhase;
    }
 
    inline void setSequentialPriorPhase(PhasePtr priorPhase) {
        sequentialPriorPhase = priorPhase;
    }
 
    std::vector<PhaseTransitionLogic*> trySwitch(NEMALogic* controller);
 
    PhaseTransitionLogic* getTransition(int toPhase);
 
    char getNEMAChar(int i);
 
    void recalculateTiming(void);
 
    inline void forceEnter(NEMALogic* controller) {
        enter(controller, sequentialPriorPhase);
    }
 
    inline bool controlledIndex(int i) {
        return std::count(myPhaseStringInds.begin(), myPhaseStringInds.end(), i) > 0;
    }
 
    SUMOTime yellow;
    SUMOTime red;
    SUMOTime minDuration;
    SUMOTime maxDuration;
    SUMOTime nextMaxDuration;
    SUMOTime vehExt;
 
    inline void cleanupExit(void) {
        transitionActive = false;
        readyToSwitch = false;
        myLightState = LightState::Red;
    }
 
    inline bool okay2ForceSwitch(NEMALogic* controller) {
        return readyToSwitch && !transitionActive && (getTransitionTime(controller) <= TIME2STEPS(0));
    }
 
private:
    MSPhaseDefinition* myCorePhase = nullptr;
 
    PhasePtr myInstance = nullptr;
    PhasePtr myLastPhaseInstance = nullptr;
    PhasePtr sequentialPriorPhase = nullptr;
 
    // Phase Knowledge Space
    LightState myLightState;
    PhaseDetectorInfo myDetectorInfo;
 
    SUMOTime maxGreenDynamic;
    SUMOTime myStartTime;
    SUMOTime myExpectedDuration;
    SUMOTime myLastEnd;
 
    IntVector myPhaseStringInds;
    std::string myGreenString;
    std::string myYellowString;
    std::string myRedString;
 
    SUMOTime calcVehicleExtension(SUMOTime duration);
 
    std::vector<PhaseTransitionLogic*> myTransitions;
 
    void enter(NEMALogic* controller, PhasePtr lastPhase);
 
    void setMyNEMAStates(void);
 
    bool transitionActive;
 
    PhaseTransitionLogic* lastTransitionDecision;
 
};
 
 
class PhaseTransitionLogic {
public:
    typedef NEMAPhase* PhasePtr;
 
    PhaseTransitionLogic(
        PhasePtr fromPhase,
        PhasePtr toPhase
    );
 
    bool okay(NEMALogic* controller);
 
    int getDistance(PhaseTransitionLogic* otherTrans);
    inline void setDistance(int d) {
        distance = d;
    }
    int distance;
 
    ~PhaseTransitionLogic() {};
 
    inline PhasePtr getToPhase(void) const {
        return toPhase;
    }
 
    inline PhasePtr getFromPhase(void) const {
        return fromPhase;
    }
 
private:
    PhasePtr fromPhase;
    PhasePtr toPhase;
 
    void buildLogic(void);
 
    bool fromBarrier(NEMALogic* controller);
 
    bool fromCoord(NEMALogic* controller);
 
    bool freeBase(NEMALogic* controller);
 
    bool coordBase(NEMALogic* controller);
};