MSTLLogicControl.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2001-2026 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 class that stores and controls tls and switching of their programs
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <vector>
#include <map>
#include <utils/common/Command.h>
#include <utils/common/StdDefs.h>
#include <utils/xml/SUMOXMLDefinitions.h>
 
 
// ===========================================================================
// class declarations
// ===========================================================================
class MSTrafficLightLogic;
class MSLink;
class MSLane;
class MSPhaseDefinition;
class OutputDevice;
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class MSTLLogicControl {
public:
    class OnSwitchAction {
    public:
        virtual ~OnSwitchAction() {};
 
 
        virtual void execute() = 0;
 
    };
 
 
 
    class TLSLogicVariants {
    public:
        TLSLogicVariants();
 
        ~TLSLogicVariants();
 
        bool checkOriginalTLS() const;
 
        bool addLogic(const std::string& programID, MSTrafficLightLogic* logic, bool netWasLoaded,
                      bool isNewDefault = true);
 
        MSTrafficLightLogic* getLogic(const std::string& programID) const;
        void addSwitchCommand(OnSwitchAction* c);
        std::vector<MSTrafficLightLogic*> getAllLogics() const;
        void saveInitialStates();
        void saveState(OutputDevice& out);
        bool isActive(const MSTrafficLightLogic* tl) const;
        MSTrafficLightLogic* getActive() const;
 
        MSTrafficLightLogic* getDefault() const;
 
        void switchTo(MSTLLogicControl& tlc, const std::string& programID);
 
        void switchToLoaded(MSTrafficLightLogic* tl);
 
        /* @brief get logic by programID. For the special case "off"
         * instantiate an MSOffTrafficLightLogic */
        MSTrafficLightLogic* getLogicInstantiatingOff(MSTLLogicControl& tlc,
                const std::string& programID);
 
        /* @brief sets the state to the given string get for the special program "online"
         * this program is instantiated only once */
        void setStateInstantiatingOnline(MSTLLogicControl& tlc,
                                         const std::string& state);
 
 
        void executeOnSwitchActions() const;
        void addLink(MSLink* link, MSLane* lane, int pos);
        void ignoreLinkIndex(int pos);
 
    private:
        MSTrafficLightLogic* myCurrentProgram;
 
        MSTrafficLightLogic* myDefaultProgram;
 
        std::map<std::string, MSTrafficLightLogic*> myVariants;
 
        std::map<MSLink*, LinkState> myOriginalLinkStates;
 
        std::vector<OnSwitchAction*> mySwitchActions;
 
    private:
        TLSLogicVariants(const TLSLogicVariants&);
 
        TLSLogicVariants& operator=(const TLSLogicVariants&);
 
 
    };
 
 
    MSTLLogicControl();
 
    ~MSTLLogicControl();
 
    bool closeNetworkReading();
 
    void setTrafficLightSignals(SUMOTime t) const;
 
    std::vector<MSTrafficLightLogic*> getAllLogics() const;
 
    TLSLogicVariants& get(const std::string& id) const;
 
    MSTrafficLightLogic* get(const std::string& id, const std::string& programID) const;
 
    MSTrafficLightLogic* getActive(const std::string& id) const;
 
    std::vector<std::string> getAllTLIds() const;
 
    bool add(const std::string& id, const std::string& programID,
             MSTrafficLightLogic* logic, bool newDefault = true);
 
    bool knows(const std::string& id) const;
 
    bool isActive(const MSTrafficLightLogic* tl) const;
 
    void switchTo(const std::string& id, const std::string& programID);
 
 
    void addWAUT(SUMOTime refTime, const std::string& id,
                 const std::string& startProg, SUMOTime period);
 
 
    void addWAUTSwitch(const std::string& wautid, SUMOTime when,
                       const std::string& to);
 
 
    void addWAUTJunction(const std::string& wautid, const std::string& tls,
                         const std::string& proc, bool synchron);
 
 
    void closeWAUT(const std::string& wautid);
 
 
 
    void check2Switch(SUMOTime step);
 
 
    std::pair<SUMOTime, MSPhaseDefinition> getPhaseDef(const std::string& tlid) const;
 
    void switchOffAll();
 
    void saveState(OutputDevice& out);
 
    void clearState(SUMOTime time, bool quickReload = false);
 
 
 
protected:
    class SwitchInitCommand : public Command {
    public:
        SwitchInitCommand(MSTLLogicControl& p, const std::string& wautid, int index)
            : myParent(p), myWAUTID(wautid), myIndex(index) { }
 
 
        ~SwitchInitCommand() { }
 
 
 
 
        SUMOTime execute(SUMOTime) {
            return myParent.initWautSwitch(*this);
        }
 
 
 
        const std::string& getWAUTID() const {
            return myWAUTID;
        }
 
 
        int& getIndex() {
            return myIndex;
        }
 
 
    protected:
        MSTLLogicControl& myParent;
 
        std::string myWAUTID;
 
        int myIndex;
 
 
    private:
        SwitchInitCommand(const SwitchInitCommand&);
 
        SwitchInitCommand& operator=(const SwitchInitCommand&);
 
    };
 
 
 
public:
    SUMOTime initWautSwitch(SwitchInitCommand& cmd);
 
 
protected:
    struct WAUTSwitch {
        SUMOTime when;
        std::string to;
    };
 
 
    struct WAUTJunction {
        std::string junction;
        std::string procedure;
        bool synchron;
    };
 
 
    struct WAUT {
        std::string id;
        std::string startProg;
        SUMOTime refTime;
        SUMOTime period;
        std::vector<WAUTSwitch> switches;
        std::vector<WAUTJunction> junctions;
    };
 
 
    class WAUTSwitchProcedure {
    public:
        WAUTSwitchProcedure(MSTLLogicControl& control, WAUT& waut,
                            MSTrafficLightLogic* from, MSTrafficLightLogic* to,
                            bool synchron)
            : myFrom(from), myTo(to), mySwitchSynchron(synchron), myWAUT(waut), myControl(control) { }
 
 
        virtual ~WAUTSwitchProcedure() { }
 
 
        virtual bool trySwitch(SUMOTime step);
 
 
    protected:
        bool isPosAtGSP(SUMOTime currentTime, const MSTrafficLightLogic& logic);
 
        SUMOTime getDiffToStartOfPhase(MSTrafficLightLogic& logic, SUMOTime toTime);
 
        void switchToPos(SUMOTime simStep, MSTrafficLightLogic& logic, SUMOTime toTime);
 
        SUMOTime getGSPTime(const MSTrafficLightLogic& logic) const;
 
        virtual void adaptLogic(SUMOTime step) {
            UNUSED_PARAMETER(step);
        }
 
    protected:
        MSTrafficLightLogic* myFrom;
 
        MSTrafficLightLogic* myTo;
 
        bool mySwitchSynchron;
 
        WAUT& myWAUT;
 
        MSTLLogicControl& myControl;
 
 
    private:
        WAUTSwitchProcedure(const WAUTSwitchProcedure&);
 
        WAUTSwitchProcedure& operator=(const WAUTSwitchProcedure&);
 
    };
 
 
    class WAUTSwitchProcedure_JustSwitch : public WAUTSwitchProcedure {
    public:
        WAUTSwitchProcedure_JustSwitch(MSTLLogicControl& control, WAUT& waut,
                                       MSTrafficLightLogic* from, MSTrafficLightLogic* to,
                                       bool synchron);
 
        ~WAUTSwitchProcedure_JustSwitch();
 
        bool trySwitch(SUMOTime step);
 
    };
 
 
 
    class WAUTSwitchProcedure_GSP : public WAUTSwitchProcedure {
    public:
        WAUTSwitchProcedure_GSP(MSTLLogicControl& control, WAUT& waut,
                                MSTrafficLightLogic* from, MSTrafficLightLogic* to,
                                bool synchron);
 
        ~WAUTSwitchProcedure_GSP();
 
    protected:
        void adaptLogic(SUMOTime step);
 
    };
 
 
    class WAUTSwitchProcedure_Stretch : public WAUTSwitchProcedure {
    public:
        WAUTSwitchProcedure_Stretch(MSTLLogicControl& control, WAUT& waut,
                                    MSTrafficLightLogic* from, MSTrafficLightLogic* to,
                                    bool synchron);
 
        ~WAUTSwitchProcedure_Stretch();
 
    protected:
        void adaptLogic(SUMOTime step);
 
        void stretchLogic(SUMOTime step, SUMOTime startPos, SUMOTime allStretchTime);
 
        void cutLogic(SUMOTime step, SUMOTime startPos, SUMOTime allCutTime);
 
    protected:
        struct StretchRange {
            SUMOTime begin;
            SUMOTime end;
            double fac;
        };
 
    protected:
        std::vector<StretchRange> myStretchRanges;
    };
 
 
    struct WAUTSwitchProcess {
        std::string junction;
        MSTrafficLightLogic* from;
        MSTrafficLightLogic* to;
        WAUTSwitchProcedure* proc;
    };
 
 
    std::map<std::string, WAUT*> myWAUTs;
 
    std::vector<WAUTSwitchProcess> myCurrentlySwitched;
 
    std::map<std::string, TLSLogicVariants*> myLogics;
 
    bool myNetWasLoaded;
 
 
private:
    MSTLLogicControl(const MSTLLogicControl&);
 
    MSTLLogicControl& operator=(const MSTLLogicControl&);
 
};