NBLoadedTLDef.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
/****************************************************************************/
// A loaded (complete) traffic light logic
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <vector>
#include <string>
#include <set>
#include "NBTrafficLightDefinition.h"
#include "NBNode.h"
#include <utils/common/SUMOTime.h>
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class NBLoadedTLDef : public NBTrafficLightDefinition {
public:
    class SignalGroup : public Named {
    public:
        SignalGroup(const std::string& id);
 
        ~SignalGroup();
 
        void addConnection(const NBConnection& c);
 
        void addPhaseBegin(SUMOTime time, TLColor color);
 
        void setYellowTimes(SUMOTime tRedYellowe, SUMOTime tYellow);
 
        std::vector<SUMOTime> getTimes(SUMOTime cycleDuration) const;
 
        void sortPhases();
 
        int getLinkNo() const;
 
        bool mayDrive(SUMOTime time) const;
 
        bool hasYellow(SUMOTime time) const;
 
        bool containsIncoming(NBEdge* from) const;
 
        void remapIncoming(NBEdge* which, const EdgeVector& by);
 
        bool containsOutgoing(NBEdge* to) const;
 
        void remapOutgoing(NBEdge* which, const EdgeVector& by);
 
        const NBConnection& getConnection(int pos) const;
 
        void patchTYellow(SUMOTime tyellow, bool forced);
 
        void remap(NBEdge* removed, int removedLane, NBEdge* by, int byLane);
 
        class PhaseDef {
        public:
            PhaseDef(SUMOTime time, TLColor color)
                : myTime(time), myColor(color) { }
 
            SUMOTime myTime;
            TLColor myColor;
        };
 
    private:
        NBConnectionVector myConnections;
        std::vector<PhaseDef> myPhases;
        SUMOTime myTRedYellow, myTYellow;
    };
 
 
 
    typedef std::map<std::string, SignalGroup*> SignalGroupCont;
 
 
    NBLoadedTLDef(const NBEdgeCont& ec, const std::string& id,
                  const std::vector<NBNode*>& junctions, SUMOTime offset,
                  TrafficLightType type);
 
 
    NBLoadedTLDef(const NBEdgeCont& ec, const std::string& id, NBNode* junction, SUMOTime offset,
                  TrafficLightType type);
 
 
    NBLoadedTLDef(const NBEdgeCont& ec, const std::string& id, SUMOTime offset,
                  TrafficLightType type);
 
 
    ~NBLoadedTLDef();
 
 
    void setCycleDuration(SUMOTime cycleDur);
 
 
    void addSignalGroup(const std::string& id);
 
 
    bool addToSignalGroup(const std::string& groupid,
                          const NBConnection& connection);
 
 
    bool addToSignalGroup(const std::string& groupid,
                          const NBConnectionVector& connections);
 
 
    void addSignalGroupPhaseBegin(const std::string& groupid,
                                  SUMOTime time, TLColor color);
 
 
    void setSignalYellowTimes(const std::string& groupid,
                              SUMOTime tRedYellow, SUMOTime tYellow);
 
 
 
    void setTLControllingInformation() const;
 
 
    void remapRemoved(NBEdge* removed,
                      const EdgeVector& incoming, const EdgeVector& outgoing);
 
    /* initialize myNeedsContRelation and set myNeedsContRelationReady to true */
    void initNeedsContRelation() const;
 
    int getMaxIndex();
 
 
 
protected:
 
    NBTrafficLightLogic* myCompute(int brakingTimeSeconds);
 
    void setParticipantsInformation();
 
 
    void collectNodes();
 
 
    void collectLinks();
 
 
    bool mustBrake(const NBConnection& possProhibited,
                   const std::string& state,
                   int strmpos) const;
 
 
    void replaceRemoved(NBEdge* removed, int removedLane,
                        NBEdge* by, int byLane, bool incoming);
 
private:
    std::string buildPhaseState(const SUMOTime time) const;
 
    // pointer to the NBEdgeCont for checking edges
    const NBEdgeCont* myEdgeCont;
 
 
private:
    SignalGroupCont mySignalGroups;
 
    SUMOTime myCycleDuration;
 
 
};