MSActuatedTrafficLightLogic.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2002-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
/****************************************************************************/
// An actuated (adaptive) traffic light logic
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <utility>
#include <vector>
#include <bitset>
#include <map>
#include <microsim/MSEventControl.h>
#include <microsim/traffic_lights/MSTrafficLightLogic.h>
#include <microsim/output/MSDetectorControl.h>
#include <microsim/output/MSInductLoop.h>
#include "MSSimpleTrafficLightLogic.h"
 
 
// ===========================================================================
// class declarations
// ===========================================================================
class NLDetectorBuilder;
 
// ===========================================================================
// class definitions
// ===========================================================================
class MSActuatedTrafficLightLogic : public MSSimpleTrafficLightLogic {
public:
 
    typedef Parameterised::Map ConditionMap;
    typedef std::vector<std::tuple<std::string, std::string, std::string> > AssignmentMap;
 
    struct Function {
        Function(const std::string& _id = "", int _nArgs = -1):
            id(_id), nArgs(_nArgs) {}
        std::string id;
        int nArgs;
        AssignmentMap assignments;
    };
 
    typedef std::map<std::string, Function> FunctionMap;
 
 
    MSActuatedTrafficLightLogic(MSTLLogicControl& tlcontrol,
                                const std::string& id, const std::string& programID,
                                const SUMOTime offset,
                                const MSSimpleTrafficLightLogic::Phases& phases,
                                int step, SUMOTime delay,
                                const Parameterised::Map& parameter,
                                const std::string& basePath,
                                const ConditionMap& conditions = ConditionMap(),
                                const AssignmentMap& assignments = AssignmentMap(),
                                const FunctionMap& functions = FunctionMap());
 
 
    void init(NLDetectorBuilder& nb) override;
 
 
    ~MSActuatedTrafficLightLogic();
 
 
 
 
    SUMOTime trySwitch() override;
 
    SUMOTime getMinDur(int step = -1) const override;
    SUMOTime getMaxDur(int step = -1) const override;
    SUMOTime getEarliestEnd(int step = -1) const override;
    SUMOTime getLatestEnd(int step = -1) const override;
 
 
    void changeStepAndDuration(MSTLLogicControl& tlcontrol, SUMOTime simStep,
                               int step, SUMOTime stepDuration) override;
 
    void activateProgram() override;
    void deactivateProgram() override;
 
    bool showDetectors() const {
        return myShowDetectors;
    }
 
    void setShowDetectors(bool show);
 
    void saveState(OutputDevice& out) const override;
 
    void loadExtraState(const std::string& state) override;
 
    const std::string getParameter(const std::string& key, const std::string defaultValue = "") const override;
 
    void setParameter(const std::string& key, const std::string& value) override;
 
    std::map<std::string, double> getDetectorStates() const override;
 
    double getDetectorState(const std::string laneID) const override;
 
    std::map<std::string, double> getConditions() const override;
 
    void loadState(MSTLLogicControl& tlcontrol, SUMOTime t, int step, SUMOTime spentDuration, bool active) override;
 
protected:
    void initAttributeOverride();
    void initSwitchingRules();
 
    struct InductLoopInfo {
        InductLoopInfo(MSInductLoop* _loop, const MSLane* _lane, int numPhases, double _maxGap, double _jamThreshold):
            loop(_loop),
            lane(_lane),
            servedPhase(numPhases, false),
            maxGap(_maxGap),
            jamThreshold(_jamThreshold)
        {}
 
 
        bool isJammed() const {
            return jamThreshold > 0 && loop->getOccupancyTime() >= jamThreshold;
        }
 
        MSInductLoop* loop;
        const MSLane* lane;
        SUMOTime lastGreenTime = 0;
        std::vector<bool> servedPhase;
        double maxGap;
        double jamThreshold;
 
    };
 
    typedef std::vector<std::vector<InductLoopInfo*> > InductLoopMap;
 
 
    SUMOTime duration(const double detectionGap) const;
 
    SUMOTime getMinimumMinDuration(MSLane* lane, const std::set<int>& multiNextTargets) const;
 
    double gapControl();
 
 
    bool hasMajor(const std::string& state, const LaneVector& lanes) const;
 
    int decideNextPhase();
 
    int decideNextPhaseCustom(bool mustSwitch);
 
    double evalExpression(const std::string& condition) const;
 
    double evalTernaryExpression(double a, const std::string& o, double b, const std::string& condition) const;
 
    double evalAtomicExpression(const std::string& expr) const;
 
    double evalCustomFunction(const std::string& fun, const std::string& arg) const;
 
    void executeAssignments(const AssignmentMap& assignments, ConditionMap& conditions, const ConditionMap& forbidden = ConditionMap()) const;
 
    int getDetectorPriority(const InductLoopInfo& loopInfo) const;
 
    int getPhasePriority(int step) const;
 
    std::pair<int, SUMOTime> getTarget(int step) const;
 
    bool maxLinkDurationReached();
 
    bool canExtendLinkGreen(int target);
 
    SUMOTime getLinkMinDuration(int target) const;
 
    bool weakConflict(int linkIndex, const std::string& state) const;
 
    template<typename T, SumoXMLTag Tag>
    const T* retrieveDetExpression(const std::string& arg, const std::string& expr, bool tryPrefix) const {
        const T* det = dynamic_cast<const T*>(
                           MSNet::getInstance()->getDetectorControl().getTypedDetectors(Tag).get(
                               (tryPrefix ? myDetectorPrefix : "") + arg));
        if (det == nullptr) {
            if (tryPrefix) {
                // try again without prefix
                return retrieveDetExpression<T, Tag>(arg, expr, false);
            } else {
                throw ProcessError("Unknown detector '" + arg + "' in expression '" + expr + "'");
            }
        } else {
            return det;
        }
    }
 
    std::set<int> getMultiNextTargets() const;
 
    void initTargets(int step);
    void findTargets(int origStep, int n, SUMOTime priorTransition, std::map<int, SUMOTime>& found);
 
protected:
    InductLoopMap myInductLoopsForPhase;
    std::vector<std::vector<const MSLink*> > myCrossingsForPhase;
 
    std::vector<InductLoopInfo> myInductLoops;
 
    std::vector<const MSInductLoop*> myExtraLoops;
    std::vector<const MSE2Collector*> myExtraE2;
 
    double myMaxGap;
 
    double myJamThreshold;
 
    double myPassingTime;
 
    double myDetectorGap;
 
    SUMOTime myInactiveThreshold;
 
    bool myShowDetectors;
 
    bool myBuildAllDetectors;
 
    bool myHasMultiTarget;
 
    std::string myFile;
 
    SUMOTime myFreq;
 
    std::string myVehicleTypes;
 
    SUMOTime myLastTrySwitchTime;
 
    std::vector<SUMOTime> myLinkGreenTimes;
    std::vector<SUMOTime> myLinkRedTimes;
    std::vector<SUMOTime> myLinkMaxGreenTimes;
    std::vector<SUMOTime> myLinkMinGreenTimes;
 
    ConditionMap myConditions;
 
    AssignmentMap myAssignments;
 
    FunctionMap myFunctions;
 
    mutable std::vector<std::map<std::string, double> > myStack;
 
    std::set<std::string> myListedConditions;
 
    bool myTraCISwitch;
 
    struct SwitchingRules {
        bool enabled = false;
    };
 
    std::vector<SwitchingRules> mySwitchingRules;
 
    const std::string myDetectorPrefix;
 
    /* @brief for every actuated phase,
     * then for every target phase,
     * provide the list of green phases that are reached quickest from the target phase
     */
    std::map<int, std::map<int, std::vector<int> > > myTargets;
 
    static const std::vector<std::string> OPERATOR_PRECEDENCE;
};