MSTrafficLightLogic.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
/****************************************************************************/
// The parent class for traffic light logics
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <map>
#include <string>
#include <bitset>
#include <utils/common/Command.h>
#include <utils/common/Parameterised.h>
#include <microsim/MSLogicJunction.h>
#include <microsim/MSLink.h>
#include "MSPhaseDefinition.h"
 
 
// ===========================================================================
// class declarations
// ===========================================================================
class MSNet;
class MSLink;
class MSTLLogicControl;
class MSDetectorFileOutput;
class NLDetectorBuilder;
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class MSTrafficLightLogic : public Named, public Parameterised {
public:
 
    typedef std::vector<MSPhaseDefinition*> Phases;
 
    typedef std::vector<MSLink*> LinkVector;
 
    typedef std::vector<LinkVector> LinkVectorVector;
 
    typedef std::vector<MSLane*> LaneVector;
 
    typedef std::vector<LaneVector> LaneVectorVector;
 
    typedef std::vector<const SUMOVehicle*> VehicleVector;
 
 
public:
    MSTrafficLightLogic(MSTLLogicControl& tlcontrol,
                        const std::string& id,
                        const std::string& programID,
                        const SUMOTime offset,
                        const TrafficLightType logicType,
                        const SUMOTime delay,
                        const Parameterised::Map& parameters);
 
 
    virtual void init(NLDetectorBuilder& nb);
 
    void initMesoTLSPenalties();
 
    virtual ~MSTrafficLightLogic();
 
 
 
 
    virtual void addLink(MSLink* link, MSLane* lane, int pos);
 
    void ignoreLinkIndex(int pos);
 
 
    virtual void adaptLinkInformationFrom(const MSTrafficLightLogic& logic);
 
 
    std::map<MSLink*, LinkState> collectLinkStates() const;
 
 
    void resetLinkStates(const std::map<MSLink*, LinkState>& vals) const;
 
 
 
 
    virtual SUMOTime trySwitch() = 0;
 
    virtual void activateProgram();
    virtual void deactivateProgram();
 
    bool setTrafficLightSignals(SUMOTime t) const;
 
 
 
    const std::string& getProgramID() const {
        return myProgramID;
    }
 
 
    const LaneVectorVector& getLaneVectors() const {
        return myLanes;
    }
 
 
    const LaneVector& getLanesAt(int i) const {
        if (i < (int)myLanes.size()) {
            return myLanes[i];
        } else {
            return myEmptyLaneVector;
        }
    }
 
 
    const LinkVectorVector& getLinks() const {
        return myLinks;
    }
 
 
    const LinkVector& getLinksAt(int i) const {
        return myLinks[i];
    }
 
 
    int getLinkIndex(const MSLink* const link) const;
 
 
    virtual int getPhaseNumber() const = 0;
 
 
    virtual const Phases& getPhases() const = 0;
 
 
    virtual const MSPhaseDefinition& getPhase(int givenstep) const = 0;
 
    TrafficLightType getLogicType() const {
        return myLogicType;
    }
 
 
 
 
    virtual int getCurrentPhaseIndex() const = 0;
 
 
    virtual const MSPhaseDefinition& getCurrentPhaseDef() const = 0;
 
    virtual SUMOTime getMinDur(int step = -1) const;
    virtual SUMOTime getMaxDur(int step = -1) const;
    virtual SUMOTime getEarliestEnd(int step = -1) const;
    virtual SUMOTime getLatestEnd(int step = -1) const;
 
    SUMOTime getDefaultCycleTime() const {
        return myDefaultCycleTime;
    }
 
    SUMOTime getTimeInCycle() const;
 
    virtual SUMOTime mapTimeInCycle(SUMOTime t) const;
 
    int getNumLinks() const {
        return myNumLinks;
    }
 
    SUMOTime getNextSwitchTime() const;
 
 
    SUMOTime getSpentDuration(SUMOTime simStep = -1) const;
 
 
 
 
    virtual SUMOTime getPhaseIndexAtTime(SUMOTime simStep) const = 0;
 
 
    virtual SUMOTime getOffsetFromIndex(int index) const = 0;
 
 
    virtual int getIndexFromOffset(SUMOTime offset) const = 0;
 
 
    SUMOTime getOffset() const {
        return myOffset;
    }
 
 
    void addOverridingDuration(SUMOTime duration);
 
 
    void setCurrentDurationIncrement(SUMOTime delay);
 
 
    virtual void changeStepAndDuration(MSTLLogicControl& tlcontrol,
                                       SUMOTime simStep, int step, SUMOTime stepDuration) = 0;
 
 
    bool isSelected() const;
 
    bool isActive() const {
        return myAmActive;
    }
 
    virtual bool getsMajorGreen(int linkIndex) const;
 
 
    virtual std::map<std::string, double> getDetectorStates() const {
        return std::map<std::string, double>();
    }
 
    virtual std::map<std::string, double> getConditions() const {
        return std::map<std::string, double>();
    }
 
    virtual VehicleVector getBlockingVehicles(int linkIndex) {
        UNUSED_PARAMETER(linkIndex);
        return VehicleVector();
    }
 
    virtual VehicleVector getRivalVehicles(int linkIndex) {
        UNUSED_PARAMETER(linkIndex);
        return VehicleVector();
    }
 
    virtual VehicleVector getPriorityVehicles(int linkIndex) {
        UNUSED_PARAMETER(linkIndex);
        return VehicleVector();
    }
 
    virtual void saveState(OutputDevice& /*out*/) const {};
 
 
    virtual void loadState(MSTLLogicControl& tlcontrol, SUMOTime t, int step, SUMOTime spentDuration);
 
 
protected:
    class SwitchCommand : public Command {
    public:
        SwitchCommand(MSTLLogicControl& tlcontrol,
                      MSTrafficLightLogic* tlLogic,
                      SUMOTime nextSwitch);
 
        ~SwitchCommand();
 
        SUMOTime execute(SUMOTime currentTime);
 
 
        void deschedule(MSTrafficLightLogic* tlLogic);
 
 
        SUMOTime getNextSwitchTime() const {
            return myAssumedNextSwitch;
        }
 
        SUMOTime shiftTime(SUMOTime currentTime, SUMOTime execTime, SUMOTime newTime);
 
    private:
        MSTLLogicControl& myTLControl;
 
        MSTrafficLightLogic* myTLLogic;
 
        SUMOTime myAssumedNextSwitch;
 
        bool myAmValid;
 
    private:
        SwitchCommand(const SwitchCommand&);
 
        SwitchCommand& operator=(const SwitchCommand&);
 
    };
 
    SUMOTime computeCycleTime(const Phases& phases);
 
 
protected:
    const std::string myProgramID;
 
    SUMOTime myOffset;
 
    const TrafficLightType myLogicType;
 
    LinkVectorVector myLinks;
 
    LaneVectorVector myLanes;
 
    int myNumLinks;
 
    std::vector<SUMOTime> myOverridingTimes;
 
    SUMOTime myCurrentDurationIncrement;
 
    SwitchCommand* mySwitchCommand;
 
    SUMOTime myDefaultCycleTime;
 
    static const LaneVector myEmptyLaneVector;
 
    std::set<int> myIgnoredIndices;
 
    bool myAmActive;
 
private:
    MSTrafficLightLogic(const MSTrafficLightLogic& s);
 
    MSTrafficLightLogic& operator=(const MSTrafficLightLogic& s);
 
};