MSSwarmTrafficLightLogic.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2010-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 class for Swarm-based logics
/****************************************************************************/
#pragma once
#include <config.h>
 
#include "MSSOTLHiLevelTrafficLightLogic.h"
#include "MSSOTLPhasePolicy.h"
#include "MSSOTLPlatoonPolicy.h"
#include "MSSOTLMarchingPolicy.h"
#include "MSSOTLCongestionPolicy.h"
#include "MSSOTLPolicy3DStimulus.h"
#include "MSSOTLPolicy5DFamilyStimulus.h"
 
template<class T>
class CircularBuffer {
public:
    CircularBuffer(int size) :
        m_size(size), m_currentIndex(0), m_firstTime(true) {
        m_buffer = new T[m_size];
    }
 
    virtual ~CircularBuffer() {
        delete[] m_buffer;
    }
 
    bool addValue(const T newValue, T& replacedValue) {
        bool result = !m_firstTime;
        if (result) {
            replacedValue = m_buffer[m_currentIndex];
        }
        insert(newValue);
        return result;
    }
 
    void push_front(const T value) {
        insert(value);
    }
 
    T at(const int index) const {
        int idx = (m_currentIndex - 1 - index + m_size) % m_size;
        return m_buffer[idx];
    }
 
    T front() const {
        return at(0);
    }
 
    T back() const {
        return at(size() - 1);
    }
 
    int size() const {
        if (m_firstTime) {
            return m_currentIndex;
        }
        return m_size;
    }
 
    void clear() {
        m_currentIndex = 0;
        m_firstTime = true;
    }
 
private:
    T* m_buffer;
    int m_size;
    int m_currentIndex;
    bool m_firstTime;
 
    inline void insert(const T& value) {
        m_buffer[m_currentIndex++] = value;
        if (m_currentIndex == m_size) {
            m_currentIndex = 0;
            m_firstTime = false;
        }
    }
};
 
class MSSwarmTrafficLightLogic: public MSSOTLHiLevelTrafficLightLogic {
public:
    //****************************************************
    MSSwarmTrafficLightLogic(MSTLLogicControl& tlcontrol, const std::string& id,
                             const std::string& programID, const Phases& phases, int step,
                             SUMOTime delay,
                             const Parameterised::Map& parameters);
 
    ~MSSwarmTrafficLightLogic();
 
    void init(NLDetectorBuilder& nb);
 
    SUMOTime getMaxCongestionDuration() {
        return StringUtils::toInt(getParameter("MAX_CONGESTION_DUR", "120"));
    }
 
    double getPheroMaxVal() {
        return StringUtils::toDouble(getParameter("PHERO_MAXVAL", "10"));
    }
 
    double getBetaNo() {
        return StringUtils::toDouble(getParameter("BETA_NO", "0.99"));
    }
 
    double getGammaNo() {
        return StringUtils::toDouble(getParameter("GAMMA_NO", "1.0"));
    }
 
    double getBetaSp() {
        return StringUtils::toDouble(getParameter("BETA_SP", "0.99"));
    }
 
    double getGammaSp() {
        return StringUtils::toDouble(getParameter("GAMMA_SP", "1.0"));
    }
 
    double getChangePlanProbability() {
        return StringUtils::toDouble(getParameter("CHANGE_PLAN_PROBABILITY", "0.003"));
    }
 
    double getThetaMax() {
        return StringUtils::toDouble(getParameter("THETA_MAX", "0.8"));
    }
 
    double getThetaMin() {
        return StringUtils::toDouble(getParameter("THETA_MIN", "0.2"));
    }
 
    double getThetaInit() {
        return StringUtils::toDouble(getParameter("THETA_INIT", "0.5"));
    }
 
    double getLearningCox() {
        return StringUtils::toDouble(getParameter("LEARNING_COX", "0.0005"));
    }
 
    double getForgettingCox() {
        return StringUtils::toDouble(getParameter("FORGETTING_COX", "0.0005"));
    }
 
    double getScaleFactorDispersionIn() {
        return scaleFactorDispersionIn;
    }
 
    double getScaleFactorDispersionOut() {
        return scaleFactorDispersionOut;
    }
 
    const std::string getLogicType() const {
        return "swarmBasedTrafficLogic";
    }
 
protected:
    MSLaneId_PheromoneMap pheromoneInputLanes;
 
    MSLaneId_PheromoneMap pheromoneOutputLanes;
 
    SUMOTime lastThetaSensitivityUpdate;
 
    /*
     * This member has to contain the switching logic for SOTL policies
     */
 
    int decideNextPhase();
 
    bool canRelease();
 
    /*
     * Computes how much time will pass after decideNextPhase will be executed again
     */
    virtual SUMOTime computeReturnTime() {
 
        return DELTA_T;
 
    }
 
    void resetPheromone();
 
    /*
     * @return The average pheromone level regarding congestion on input lanes
     */
    double getPheromoneForInputLanes();
 
    /*
     * @return The average pheromone level regarding congestion on output lanes
     */
    double getPheromoneForOutputLanes();
 
    /*
     * @return The dispersion level regarding congestion on input lanes
     */
    double getDispersionForInputLanes(double average_phero_in);
 
    /*
     * @return The dispersion level regarding congestion on output lanes
     */
    double getDispersionForOutputLanes(double average_phero_out);
 
    /*
     * @return The difference between the current max phero value and the average phero of the other lanes
     */
    double getDistanceOfMaxPheroForInputLanes();
 
    /*
     * @return The difference between the current max phero value and the average phero of the other lanes
     */
    double getDistanceOfMaxPheroForOutputLanes();
    void updatePheromoneLevels();
 
    void updatePheromoneLevels(MSLaneId_PheromoneMap&, std::string, const double, const double);
 
    void updateSensitivities();
 
    void decidePolicy();
 
    double calculatePhi(int factor);
 
    double calculateEtaDiff();
 
    double calculateEtaRatio();
 
    /*
     * \brief Method to reset the map that stores if a lane is already been checked during the
     * evaluation of eta.
     */
    void resetLaneCheck();
    void choosePolicy(double phero_in, double phero_out, double dispersion_in, double dispersion_out);
    void choosePolicy(double phero_in, double phero_out);
 
    std::string getPoliciesParam() {
        return getParameter("POLICIES", "Platoon;Phase;Marching;Congestion");
    }
 
    /*
     * Reinforcement modes:
     * 0-> elapsed time
     * 1-> diff
     * 2-> ratio
     */
    int getReinforcementMode() {
        return StringUtils::toInt(getParameter("REIMODE", "0"));
    }
 
    void initScaleFactorDispersionIn(int lanes_in) {
        std::vector<double> phero_values;
 
        for (int i = 0; i < lanes_in / 2; i++) {
            phero_values.push_back(getPheroMaxVal());
        }
        for (int i = lanes_in / 2; i < lanes_in; i++) {
            phero_values.push_back(0.0);
        }
 
        double sum_avg_tmp = 0;
 
        for (int i = 0; i < (int)phero_values.size(); i++) {
            sum_avg_tmp += phero_values[i];
        }
 
        const double mean = sum_avg_tmp / (double)phero_values.size();
 
        double sum_dev_tmp = 0;
        for (int i = 0; i < (int)phero_values.size(); i++) {
            sum_dev_tmp += pow(phero_values[i] - mean, 2);
        }
 
        const double deviation = sqrt(sum_dev_tmp / (double)phero_values.size());
 
        scaleFactorDispersionIn = getPheroMaxVal() / deviation;
    }
 
    void initScaleFactorDispersionOut(int lanes_out) {
        std::vector<double> phero_values;
 
        for (int i = 0; i < lanes_out / 2; i++) {
            phero_values.push_back(getPheroMaxVal());
        }
        for (int i = lanes_out / 2; i < lanes_out; i++) {
            phero_values.push_back(0.0);
        }
 
        double sum_avg_tmp = 0;
        for (int i = 0; i < (int)phero_values.size(); i++) {
            sum_avg_tmp += phero_values[i];
        }
        const double mean = sum_avg_tmp / (double)phero_values.size();
 
        double sum_dev_tmp = 0;
 
        for (int i = 0; i < (int)phero_values.size(); i++) {
            sum_dev_tmp += pow(phero_values[i] - mean, 2);
        }
 
        const double deviation = sqrt(sum_dev_tmp / (double)phero_values.size());
 
        scaleFactorDispersionOut = getPheroMaxVal() / deviation;
    }
 
    bool allowLine(MSLane*);
 
    bool logData;
    std::ofstream swarmLogFile;
    bool mustChange;
    SUMOTime congestion_steps;
 
    LaneCheckMap laneCheck;
    LaneIdVector targetLanes;
    bool skipEta;
    bool gotTargetLane;
 
    int carsIn;
    int carsOut;
    int inTarget;
    int notTarget;
    double scaleFactorDispersionIn;
    double scaleFactorDispersionOut;
 
//  For every lane its index. Esed to get the current lane state for the lane
    std::map<std::string, std::vector<int> > m_laneIndexMap;
    std::string getLaneLightState(const std::string& laneId);
//  store the last message logged. if equal do not log it again
    Parameterised::Map m_pheroLevelLog;
 
    //derivative
    std::map<std::string, CircularBuffer<double>* > m_meanSpeedHistory;
    std::map<std::string, CircularBuffer<double>* > m_derivativeHistory;
    double m_derivativeAlpha;
    int m_losCounter;//los: loss of signal
    int m_losMaxLimit;
    bool m_useVehicleTypesWeights;
 
//  double pheroBegin;
};