Line data    Source code

       1             : /****************************************************************************/
       2             : // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
       3             : // Copyright (C) 2001-2024 German Aerospace Center (DLR) and others.
       4             : // This program and the accompanying materials are made available under the
       5             : // terms of the Eclipse Public License 2.0 which is available at
       6             : // https://www.eclipse.org/legal/epl-2.0/
       7             : // This Source Code may also be made available under the following Secondary
       8             : // Licenses when the conditions for such availability set forth in the Eclipse
       9             : // Public License 2.0 are satisfied: GNU General Public License, version 2
      10             : // or later which is available at
      11             : // https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
      12             : // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
      13             : /****************************************************************************/
      14             : /// @file    NBLoadedTLDef.h
      15             : /// @author  Daniel Krajzewicz
      16             : /// @author  Sascha Krieg
      17             : /// @date    Fri, 29.04.2005
      18             : ///
      19             : // A loaded (complete) traffic light logic
      20             : /****************************************************************************/
      21             : #pragma once
      22             : #include <config.h>
      23             : 
      24             : #include <vector>
      25             : #include <string>
      26             : #include <set>
      27             : #include "NBTrafficLightDefinition.h"
      28             : #include "NBNode.h"
      29             : #include <utils/common/SUMOTime.h>
      30             : 
      31             : 
      32             : // ===========================================================================
      33             : // class definitions
      34             : // ===========================================================================
      35             : /**
      36             :  * @class NBLoadedTLDef
      37             :  * @brief A loaded (complete) traffic light logic
      38             :  */
      39             : class NBLoadedTLDef : public NBTrafficLightDefinition {
      40             : public:
      41             :     /** @class SignalGroup
      42             :      * @brief A single signal group, may control several connections
      43             :      */
      44             :     class SignalGroup : public Named {
      45             :     public:
      46             :         /** @brief Constructor
      47             :          * @param[in] id The id of the signal group
      48             :          */
      49             :         SignalGroup(const std::string& id);
      50             : 
      51             :         /// @brief Destructor
      52             :         ~SignalGroup();
      53             : 
      54             :         /** @brief Inserts a controlled connection
      55             :          * @param[in] c The connection to be controlled by this signal group
      56             :          */
      57             :         void addConnection(const NBConnection& c);
      58             : 
      59             :         /** @brief Sets the begin of a phase
      60             :          * @param[in] time The time at which the phase starts
      61             :          * @param[in] color The color of this signal starting at the given time
      62             :          */
      63             :         void addPhaseBegin(SUMOTime time, TLColor color);
      64             : 
      65             :         /** @brief Sets the times for redyellow and yellow
      66             :          * @param[in] tRedYellowe The duration of the redyellow phase
      67             :          * @param[in] tYellow The duration of the yellow phase
      68             :          */
      69             :         void setYellowTimes(SUMOTime tRedYellowe, SUMOTime tYellow);
      70             : 
      71             :         /** @brief Returns the times at which the signal switches
      72             :          * @param[in] cycleDuration The duration of the complete cycle
      73             :          * @return The switch times of this signal
      74             :          */
      75             :         std::vector<SUMOTime> getTimes(SUMOTime cycleDuration) const;
      76             : 
      77             :         /** @brief Sorts the phases */
      78             :         void sortPhases();
      79             : 
      80             :         /** @brief Returns the number of links (connection) controlled by this signal
      81             :          * @return The number of links controlled by this signal
      82             :          */
      83             :         int getLinkNo() const;
      84             : 
      85             :         /** @brief Returns whether vehicles on controlled links may drive at the given time
      86             :          * @param[in] time The regarded time
      87             :          * @return Whether vehicles may drive at this time
      88             :          */
      89             :         bool mayDrive(SUMOTime time) const;
      90             : 
      91             :         /** @brief Returns whether controlled links have yellow at the given time
      92             :          * @param[in] time The regarded time
      93             :          * @return Whether controlled links are yellow at this time
      94             :          */
      95             :         bool hasYellow(SUMOTime time) const;
      96             : 
      97             :         /** @brief Returns whether this signal controls the given edge
      98             :          * @param[in] from The incoming edge
      99             :          * @return Whether this edge is controlled by this signal
     100             :          */
     101             :         bool containsIncoming(NBEdge* from) const;
     102             : 
     103             :         /** @brief Replaces the given incoming edge by the others given
     104             :          * @param[in] which The edge to replace
     105             :          * @param[in] by The replacements
     106             :          */
     107             :         void remapIncoming(NBEdge* which, const EdgeVector& by);
     108             : 
     109             :         /** @brief Returns whether this signal controls a connection where the given edge is the destination
     110             :          * @param[in] from The outgoing edge
     111             :          * @return Whether this edge's predecessing edge is controlled by this signal
     112             :          */
     113             :         bool containsOutgoing(NBEdge* to) const;
     114             : 
     115             :         /** @brief Replaces the given outgoing edge by the others given
     116             :          * @param[in] which The edge to replace
     117             :          * @param[in] by The replacements
     118             :          */
     119             :         void remapOutgoing(NBEdge* which, const EdgeVector& by);
     120             : 
     121             :         /** @brief Returns the connection at the given index
     122             :          * @param[in] pos The position within this signal
     123             :          * @return The connection at the given index
     124             :          */
     125             :         const NBConnection& getConnection(int pos) const;
     126             : 
     127             :         /** @brief Sets the yellow time
     128             :          * @param[in] tyellow The yellow time to set in seconds
     129             :          * @param[in] forced Whether resetting tyellow was forced by the user by setting "tls.yellow.patch-small"
     130             :          */
     131             :         void patchTYellow(SUMOTime tyellow, bool forced);
     132             : 
     133             :         /** @brief Replaces a removed edge/lane
     134             :          * @param[in] removed The edge to replace
     135             :          * @param[in] removedLane The lane of this edge to replace
     136             :          * @param[in] by The edge to insert instead
     137             :          * @param[in] byLane This edge's lane to insert instead
     138             :          */
     139             :         void remap(NBEdge* removed, int removedLane, NBEdge* by, int byLane);
     140             : 
     141             :         /** @class PhaseDef
     142             :          * @brief Definition of a single, loaded phase
     143             :          */
     144             :         class PhaseDef {
     145             :         public:
     146             :             /** @brief Constructor
     147             :              * @param[in] time The begin time of this phase
     148             :              * @param[in] color A signal's color from this time
     149             :              */
     150             :             PhaseDef(SUMOTime time, TLColor color)
     151         301 :                 : myTime(time), myColor(color) { }
     152             : 
     153             :             /// @brief The begin time of this phase
     154             :             SUMOTime myTime;
     155             :             /// @brief A signal's color from this time
     156             :             TLColor myColor;
     157             :         };
     158             : 
     159             :     private:
     160             :         /// @brief Connections controlled by this signal
     161             :         NBConnectionVector myConnections;
     162             :         /// @brief The phases of this signal
     163             :         std::vector<PhaseDef> myPhases;
     164             :         /// @brief The times of redyellow and yellow
     165             :         SUMOTime myTRedYellow, myTYellow;
     166             :     };
     167             : 
     168             : 
     169             : 
     170             :     /// @brief Definition of the container for signal groups
     171             :     typedef std::map<std::string, SignalGroup*> SignalGroupCont;
     172             : 
     173             : 
     174             :     /** @brief Constructor
     175             :      * @param[in] id The id of the tls
     176             :      * @param[in] junctions Junctions controlled by this tls
     177             :      * @param[in] offset The offset of the plan
     178             :      * @param[in] type The algorithm type for the computed traffic light
     179             :      */
     180             :     NBLoadedTLDef(const NBEdgeCont& ec, const std::string& id,
     181             :                   const std::vector<NBNode*>& junctions, SUMOTime offset,
     182             :                   TrafficLightType type);
     183             : 
     184             : 
     185             :     /** @brief Constructor
     186             :      * @param[in] id The id of the tls
     187             :      * @param[in] junction The junction controlled by this tls
     188             :      * @param[in] offset The offset of the plan
     189             :      * @param[in] type The algorithm type for the computed traffic light
     190             :      */
     191             :     NBLoadedTLDef(const NBEdgeCont& ec, const std::string& id, NBNode* junction, SUMOTime offset,
     192             :                   TrafficLightType type);
     193             : 
     194             : 
     195             :     /** @brief Constructor
     196             :      * @param[in] id The id of the tls
     197             :      * @param[in] offset The offset of the plan
     198             :      * @param[in] type The algorithm type for the computed traffic light
     199             :      */
     200             :     NBLoadedTLDef(const NBEdgeCont& ec, const std::string& id, SUMOTime offset,
     201             :                   TrafficLightType type);
     202             : 
     203             : 
     204             :     /// @brief Destructor
     205             :     ~NBLoadedTLDef();
     206             : 
     207             : 
     208             :     /** @brief Sets the duration of a cycle
     209             :      * @param[in] cycleDur The duration of the cycle
     210             :      */
     211             :     void setCycleDuration(SUMOTime cycleDur);
     212             : 
     213             : 
     214             :     /** @brief Adds a signal group
     215             :      * @param[in] id The id of the signal group
     216             :      */
     217             :     void addSignalGroup(const std::string& id);
     218             : 
     219             : 
     220             :     /** @brief Adds a connection to a signal group
     221             :      * @param[in] groupid The id of the signal group to add the connection to
     222             :      * @param[in] connection The connection to add
     223             :      */
     224             :     bool addToSignalGroup(const std::string& groupid,
     225             :                           const NBConnection& connection);
     226             : 
     227             : 
     228             :     /** @brief Adds a list of connections to a signal group
     229             :      * @param[in] groupid The id of the signal group to add the connections to
     230             :      * @param[in] connections The connections to add
     231             :      */
     232             :     bool addToSignalGroup(const std::string& groupid,
     233             :                           const NBConnectionVector& connections);
     234             : 
     235             : 
     236             :     /** @brief Sets the information about the begin of a phase
     237             :      * @param[in] groupid The id of the signal group to add the phase to
     238             :      * @param[in] time The time the phase starts at
     239             :      * @param[in] color The color of the signal during this phase
     240             :      */
     241             :     void addSignalGroupPhaseBegin(const std::string& groupid,
     242             :                                   SUMOTime time, TLColor color);
     243             : 
     244             : 
     245             :     /** @brief Sets the times the light is yellow or red/yellow
     246             :      * @param[in] groupid The id of the signal group to add the phase to
     247             :      * @param[in] tRedYellow The duration of redyellow
     248             :      * @param[in] tYellow The duration of yellow
     249             :      */
     250             :     void setSignalYellowTimes(const std::string& groupid,
     251             :                               SUMOTime tRedYellow, SUMOTime tYellow);
     252             : 
     253             : 
     254             :     /// @name Public methods from NBTrafficLightDefinition-interface
     255             :     /// @{
     256             : 
     257             :     /** @brief Informs edges about being controlled by a tls
     258             :      * @param[in] ec The container of edges
     259             :      * @see NBTrafficLightDefinition::setTLControllingInformation
     260             :      */
     261             :     void setTLControllingInformation() const;
     262             : 
     263             : 
     264             :     /** @brief Replaces occurrences of the removed edge in incoming/outgoing edges of all definitions
     265             :      * @param[in] removed The removed edge
     266             :      * @param[in] incoming The edges to use instead if an incoming edge was removed
     267             :      * @param[in] outgoing The edges to use instead if an outgoing edge was removed
     268             :      * @see NBTrafficLightDefinition::remapRemoved
     269             :      */
     270             :     void remapRemoved(NBEdge* removed,
     271             :                       const EdgeVector& incoming, const EdgeVector& outgoing);
     272             : 
     273             :     /* initialize myNeedsContRelation and set myNeedsContRelationReady to true */
     274             :     void initNeedsContRelation() const;
     275             : 
     276             :     ///@brief Returns the maximum index controlled by this traffic light
     277             :     int getMaxIndex();
     278             : 
     279             :     /// @}
     280             : 
     281             : 
     282             : protected:
     283             :     /// @name Protected methods from NBTrafficLightDefinition-interface
     284             :     /// @{
     285             : 
     286             :     /** @brief Computes the traffic light logic finally in dependence to the type
     287             :      * @param[in] brakingTime Duration a vehicle needs for braking in front of the tls in seconds
     288             :      * @return The computed logic
     289             :      * @see NBTrafficLightDefinition::myCompute
     290             :      */
     291             :     NBTrafficLightLogic* myCompute(int brakingTimeSeconds);
     292             : 
     293             :     /** @brief Builds the list of participating nodes/edges/links
     294             :      * @see NBTrafficLightDefinition::setParticipantsInformation
     295             :      */
     296             :     void setParticipantsInformation();
     297             : 
     298             : 
     299             :     /** @brief Collects the nodes participating in this traffic light
     300             :      * @see NBTrafficLightDefinition::collectNodes
     301             :      */
     302             :     void collectNodes();
     303             : 
     304             : 
     305             :     /** @brief Collects the links participating in this traffic light
     306             :      * @exception ProcessError If a link could not be found
     307             :      * @see NBTrafficLightDefinition::collectLinks
     308             :      */
     309             :     void collectLinks();
     310             : 
     311             : 
     312             :     /** @brief Returns the information whether a connection must brake, given a phase
     313             :      * @param[in] possProhibited The connection to investigate
     314             :      * @param[in] state The state
     315             :      * @param[in] strmpos The index of this connection within the masks
     316             :      * @return Whether the given connection must brake
     317             :      */
     318             :     bool mustBrake(const NBConnection& possProhibited,
     319             :                    const std::string& state,
     320             :                    int strmpos) const;
     321             : 
     322             : 
     323             :     /** @brief Replaces a removed edge/lane
     324             :      * @param[in] removed The edge to replace
     325             :      * @param[in] removedLane The lane of this edge to replace
     326             :      * @param[in] by The edge to insert instead
     327             :      * @param[in] byLane This edge's lane to insert instead
     328             :      * @see NBTrafficLightDefinition::replaceRemoved
     329             :      */
     330             :     void replaceRemoved(NBEdge* removed, int removedLane,
     331             :                         NBEdge* by, int byLane, bool incoming);
     332             :     /// @}
     333             : 
     334             : private:
     335             :     /** @brief Builds the phase for a given time
     336             :      * @param[in] ec The edge control to use
     337             :      * @param[in] time The time to build the phase for
     338             :      * @return The phase of this tls for the given time
     339             :      */
     340             :     std::string buildPhaseState(const SUMOTime time) const;
     341             : 
     342             :     // pointer to the NBEdgeCont for checking edges
     343             :     const NBEdgeCont* myEdgeCont;
     344             : 
     345             : 
     346             : private:
     347             :     /// @brief Controlled signal groups
     348             :     SignalGroupCont mySignalGroups;
     349             : 
     350             :     /// @brief The duration of a single cycle
     351             :     SUMOTime myCycleDuration;
     352             : 
     353             : 
     354             : };