Line data    Source code

       1             : /****************************************************************************/
       2             : // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
       3             : // Copyright (C) 2013-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    MSSOTLTrafficLightLogic.h
      15             : /// @author  Gianfilippo Slager
      16             : /// @author      Anna Chiara Bellini
      17             : /// @author  Federico Caselli
      18             : /// @date    Apr 2013
      19             : ///
      20             : // The base abstract class for SOTL logics
      21             : /****************************************************************************/
      22             : #pragma once
      23             : #include <config.h>
      24             : 
      25             : #include <utils/common/RandHelper.h>
      26             : #include <utils/common/StringUtils.h>
      27             : #include <utils/common/SUMOTime.h>
      28             : #include "MSSimpleTrafficLightLogic.h"
      29             : #include "MSSOTLDefinitions.h"
      30             : #include "MSSOTLE2Sensors.h"
      31             : 
      32             : 
      33             : // ===========================================================================
      34             : // class declarations
      35             : // ===========================================================================
      36             : class MSPushButton;
      37             : 
      38             : 
      39             : // ===========================================================================
      40             : // class definitions
      41             : // ===========================================================================
      42             : 
      43             : /**
      44             :  * @class MSSOTLTrafficLightLogic
      45             :  * @brief A self-organizing traffic light logic
      46             :  *
      47             :  * The base class for SOTL traffic light which switches between
      48             :  * its phases and sets the lights to red in between.
      49             :  * Some functions are called with an information about the current step. This
      50             :  * is needed as a single logic may be used by many junctions and so the current
      51             :  * step is stored within them, not within methods.
      52             :  * Basically a SOTL logic overrides the natural flow of steps in order and length
      53             :  * according to sensors on input (and output) lanes
      54             :  */
      55             : class MSSOTLTrafficLightLogic: public MSSimpleTrafficLightLogic {
      56             : public:
      57             :     // typedef int CTS;
      58             : 
      59             :     /**
      60             :      * @brief Constructor without sensors passed
      61             :      * @param[in] tlcontrol The tls control responsible for this tls
      62             :      * @param[in] id This traffic light id
      63             :      * @param[in] programID This tls' sub-id (program id)
      64             :      * @param[in] logicType This tls' type (static, actuated etc.)
      65             :      * @param[in] phases Definitions of the phases
      66             :      * @param[in] step The initial phase index
      67             :      * @param[in] delay The time to wait before the first switch
      68             :      * @param[in] parameters Parameters defined for the tll
      69             :      */
      70             :     MSSOTLTrafficLightLogic(MSTLLogicControl& tlcontrol, const std::string& id,
      71             :                             const std::string& programID, const TrafficLightType logicType, const Phases& phases, int step,
      72             :                             SUMOTime delay,
      73             :                             const Parameterised::Map& parameters);
      74             : 
      75             :     /**
      76             :      * @brief Constructor with sensors passed
      77             :      * @param[in] tlcontrol The tls control responsible for this tls
      78             :      * @param[in] id This tls' id
      79             :      * @param[in] programID This tls' sub-id (program id)
      80             :      * @param[in] logicType This tls' type (static, actuated etc.)
      81             :      * @param[in] phases Definitions of the phases
      82             :      * @param[in] step The initial phase index
      83             :      * @param[in] delay The time to wait before the first switch
      84             :      * @param[in] parameters Parameters defined for the tll
      85             :      * @param[in] sensors The already defined sensor logic
      86             :      */
      87             :     MSSOTLTrafficLightLogic(MSTLLogicControl& tlcontrol, const std::string& id,
      88             :                             const std::string& programID, const TrafficLightType logicType, const Phases& phases, int step,
      89             :                             SUMOTime delay,
      90             :                             const Parameterised::Map& parameters,
      91             :                             MSSOTLSensors* sensors);
      92             : 
      93             :     /// @brief Destructor
      94             :     ~MSSOTLTrafficLightLogic();
      95             : 
      96             :     /**
      97             :      * @brief Initialises the tls with sensors on incoming and outgoing lanes
      98             :      * Sensors are built in the simulation according to the type of sensor specified in the simulation parameter
      99             :      * @param[in] nb The detector builder
     100             :      * @exception ProcessError If something fails on initialisation
     101             :      */
     102             :     void init(NLDetectorBuilder& nb);
     103             : 
     104             :     /*
     105             :      * This member implements the base operations for all SOTL logics.
     106             :      * SOTL politics are implementated through decidePhase() member
     107             :      * @see MSTrafficLightLogic::trySwitch
     108             :      */
     109             :     SUMOTime trySwitch();
     110             : 
     111             : protected:
     112             : 
     113             :     typedef std::map<const std::string, std::vector<MSPushButton*> > PhasePushButtons;
     114             :     PhasePushButtons m_pushButtons;
     115             : 
     116             :     void logStatus();
     117             :     /*
     118             :      * This member has to contain the switching logic for SOTL policies
     119             :      */
     120             : 
     121             :     virtual int decideNextPhase();
     122             : 
     123             :     virtual bool canRelease() = 0;
     124             : 
     125             :     SUMOTime getCurrentPhaseElapsed();
     126             : 
     127             :     /*
     128             :      * Count the number of vehicles approaching the target lanes for the given phase.
     129             :      * If the phase in not a target phase the function member will return 0.
     130             :      * @param[in] The target phase index
     131             :      */
     132             :     int countVehicles(MSPhaseDefinition phase);
     133             : 
     134             :     /*
     135             :      * Every target step except the one from the current chain is checked.
     136             :      * This is because the current chain is not eligible to be directly
     137             :      * targeted again, it would be unfair.
     138             :      * @return True if at least a target phase has passed the threshold for input cars-timesteps
     139             :      */
     140             :     bool isThresholdPassed();
     141             : 
     142             :     /**
     143             :      * @breef Checks the if the pushbutton was activated for the current stage
     144             :      * @return True if at least a push button was pressed
     145             :      */
     146             :     bool isPushButtonPressed();
     147             : 
     148      165652 :     int getThreshold() {
     149      331304 :         return StringUtils::toInt(getParameter("THRESHOLD", "10"));
     150             :     }
     151             : 
     152         192 :     double getSpeedThreshold() {
     153         384 :         return StringUtils::toDouble(getParameter("THRESHOLDSPEED", "2"));
     154             :     }
     155             : 
     156         192 :     double getInputSensorsLength() {
     157         384 :         return StringUtils::toDouble(getParameter("INSENSORSLENGTH", "100"));
     158             :     }
     159             : 
     160         192 :     double getOutputSensorsLength() {
     161         576 :         return StringUtils::toDouble(getParameter("OUTSENSORSLENGTH", "80"));
     162             :     }
     163             : 
     164             :     /*
     165             :      * Every target step except the one from the current chain is checked.
     166             :      * This is because the current chain is not eligible to be directly
     167             :      * targeted again, it would be unfair.
     168             :      * @return The index of the phase with the maximum value of cars-timesteps
     169             :      */
     170             :     int getPhaseIndexWithMaxCTS();
     171             : 
     172             :     MSSOTLSensors* getSensors() {
     173      518488 :         return mySensors;
     174             :     }
     175             : 
     176             :     /**
     177             :      *\brief Return the sensors that count the passage of vehicles in and out of the tl.
     178             :      */
     179             :     MSSOTLE2Sensors* getCountSensors() {
     180           0 :         return myCountSensors;
     181             :     }
     182             :     /*
     183             :      * Computes how much time will pass after decideNextPhase will be executed again
     184             :      */
     185      166344 :     virtual SUMOTime computeReturnTime() {
     186      166344 :         if (getCurrentPhaseDef().isTransient()) {
     187       13452 :             return getCurrentPhaseDef().duration;
     188             : 
     189             :         }
     190      152892 :         return DELTA_T;
     191             : 
     192             :     }
     193             : 
     194             :     /// @brief Forces a specific step
     195             :     void setStep(int step);
     196             : 
     197             : private:
     198             :     /*
     199             :      * Pointer to the sensor logic regarding the junction controlled by this SOTLTrafficLightLogic
     200             :      */
     201             :     MSSOTLSensors* mySensors;
     202             : 
     203             :     /*
     204             :      * Pointer to the sensor logic regarding the count of the vehicles that pass into a tl.
     205             :      */
     206             :     MSSOTLE2Sensors* myCountSensors;
     207             : 
     208             :     /*
     209             :      * When true means the class has responsibilities to intantiate and delete the SOTLSensors instance,
     210             :      * otherwise MSSOTLTrafficLightLogic::init and MSSOTLTrafficLightLogic::~MSSOTLTrafficLightLogic have not to affect SOTLSensors instance lifecycle
     211             :      */
     212             :     bool sensorsSelfBuilt;
     213             : 
     214             :     // The map to store the cars*timesteps for each target phase
     215             :     std::map<int, SUMOTime> targetPhasesCTS;
     216             : 
     217             :     //The map to store the time each target phase have been checked last
     218             :     //This helps to compute the timesteps to get the cars*timesteps value
     219             :     std::map<int, SUMOTime> lastCheckForTargetPhase;
     220             : 
     221             :     //Map to store how many selection rounds have been done from the last selection of the phase
     222             :     std::map<int, int> targetPhasesLastSelection;
     223             : 
     224             :     int getTargetPhaseMaxLastSelection() {
     225             :         //return 2 * targetPhasesCTS.size() - 1;
     226      173406 :         return (int)targetPhasesCTS.size() - 1;
     227             :     }
     228             : 
     229             :     /*
     230             :      * This member keeps track which is the current steps chain, i.e.
     231             :      * which is the last target phase executed (even if it is currently executed)
     232             :      * (a steps chain starts always with a target phase)
     233             :      */
     234             :     int lastChain;
     235             : 
     236             :     double decayThreshold;
     237             :     /*
     238             :      * @brief Check for phases compliancy
     239             :      */
     240             :     void checkPhases();
     241             : 
     242             :     /*
     243             :      * Find the first target phase and set the current step on it
     244             :      */
     245             :     void setToATargetPhase();
     246             : 
     247             :     /*
     248             :      * This function member helps to set up the map keeping track of target phases and associated timesteps
     249             :      */
     250             :     void setupCTS();
     251             : 
     252             :     /*
     253             :      * Updates the cars-timesteps counters for each target phase except the one belonging to the current steps chain
     254             :      */
     255             :     void updateCTS();
     256             : 
     257             :     /*
     258             :      * To reset the cars-timesteps counter when a target phase is newly selected
     259             :      * If phaseStep is not a target phase nothing happens
     260             :      */
     261             :     void resetCTS(int phaseStep);
     262             :     /*
     263             :      * TEST
     264             :      */
     265             :     void updateDecayThreshold();
     266             : 
     267             :     /*
     268             :      * Traffic threshold calculation mode:
     269             :      * 0-> cars times seconds
     270             :      * 1-> estimated cars times seconds
     271             :      * 2-> queue length
     272             :      */
     273      901000 :     int getMode() {
     274     1802000 :         return StringUtils::toInt(getParameter("MODE", "0"));
     275             :     }
     276             :     /*
     277             :      * Decay threshold that should be used in case of penetration rate != 100%
     278             :      * 0-> not active
     279             :      * 1-> active
     280             :      */
     281      590552 :     bool isDecayThresholdActivated() {
     282     1181104 :         return StringUtils::toBool(getParameter("DECAY_THRESHOLD", "0"));
     283             :     }
     284             : 
     285           0 :     double getDecayConstant() {
     286           0 :         return StringUtils::toDouble(getParameter("DECAY_CONSTANT", "-0.001"));
     287             :     }
     288             : 
     289             : };