Eclipse SUMO - Simulation of Urban MObility
MSSwarmTrafficLightLogic.h
Go to the documentation of this file.
1 /****************************************************************************/
2 // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3 // Copyright (C) 2010-2019 German Aerospace Center (DLR) and others.
4 // This program and the accompanying materials
5 // are made available under the terms of the Eclipse Public License v2.0
6 // which accompanies this distribution, and is available at
7 // http://www.eclipse.org/legal/epl-v20.html
8 // SPDX-License-Identifier: EPL-2.0
9 /****************************************************************************/
15 // The class for Swarm-based logics
16 /****************************************************************************/
17 #ifndef MSSwarmTrafficLightLogic_h
18 #define MSSwarmTrafficLightLogic_h
19 
20 // ===========================================================================
21 // included modules
22 // ===========================================================================
23 #include <config.h>
24 
25 //#define SWARM_DEBUG
28 #include "MSSOTLPhasePolicy.h"
29 #include "MSSOTLPlatoonPolicy.h"
30 #include "MSSOTLMarchingPolicy.h"
31 #include "MSSOTLCongestionPolicy.h"
32 #include "MSSOTLPolicy3DStimulus.h"
34 
35 template<class T>
37 public:
40  m_buffer = new T[m_size];
41  }
42 
43  virtual ~CircularBuffer() {
44  delete[] m_buffer;
45  }
46 
47  bool addValue(const T newValue, T& replacedValue) {
48  bool result = !m_firstTime;
49  if (result) {
50  replacedValue = m_buffer[m_currentIndex];
51  }
52  insert(newValue);
53  return result;
54  }
55 
56  void push_front(const T value) {
57  insert(value);
58  }
59 
60  T at(const int index) const {
61  int idx = (m_currentIndex - 1 - index + m_size) % m_size;
62  return m_buffer[idx];
63  }
64 
65  T front() const {
66  return at(0);
67  }
68 
69  T back() const {
70  return at(size() - 1);
71  }
72 
73  int size() const {
74  if (m_firstTime) {
75  return m_currentIndex;
76  }
77  return m_size;
78  }
79 
80  void clear() {
81  m_currentIndex = 0;
82  m_firstTime = true;
83  }
84 
85 private:
87  int m_size;
90 
91  inline void insert(const T& value) {
92  m_buffer[m_currentIndex++] = value;
93  if (m_currentIndex == m_size) {
94  m_currentIndex = 0;
95  m_firstTime = false;
96  }
97  }
98 };
99 
101 public:
102  //****************************************************
113  MSSwarmTrafficLightLogic(MSTLLogicControl& tlcontrol, const std::string& id,
114  const std::string& programID, const Phases& phases, int step,
115  SUMOTime delay,
116  const std::map<std::string, std::string>& parameters);
117 
119 
126  void init(NLDetectorBuilder& nb);
127 
129  return StringUtils::toInt(getParameter("MAX_CONGESTION_DUR", "120"));
130  }
131 
132  double getPheroMaxVal() {
133  return StringUtils::toDouble(getParameter("PHERO_MAXVAL", "10"));
134  }
135 
136  double getBetaNo() {
137  return StringUtils::toDouble(getParameter("BETA_NO", "0.99"));
138  }
139 
140  double getGammaNo() {
141  return StringUtils::toDouble(getParameter("GAMMA_NO", "1.0"));
142  }
143 
144  double getBetaSp() {
145  return StringUtils::toDouble(getParameter("BETA_SP", "0.99"));
146  }
147 
148  double getGammaSp() {
149  return StringUtils::toDouble(getParameter("GAMMA_SP", "1.0"));
150  }
151 
153  return StringUtils::toDouble(getParameter("CHANGE_PLAN_PROBABILITY", "0.003"));
154  }
155 
156  double getThetaMax() {
157  return StringUtils::toDouble(getParameter("THETA_MAX", "0.8"));
158  }
159 
160  double getThetaMin() {
161  return StringUtils::toDouble(getParameter("THETA_MIN", "0.2"));
162  }
163 
164  double getThetaInit() {
165  return StringUtils::toDouble(getParameter("THETA_INIT", "0.5"));
166  }
167 
168  double getLearningCox() {
169  return StringUtils::toDouble(getParameter("LEARNING_COX", "0.0005"));
170  }
171 
172  double getForgettingCox() {
173  return StringUtils::toDouble(getParameter("FORGETTING_COX", "0.0005"));
174  }
175 
178  }
179 
182  }
183 
187  const std::string getLogicType() const {
188  return "swarmBasedTrafficLogic";
189  }
191 
192 protected:
200 
208 
215 
216  /*
217  * This member has to contain the switching logic for SOTL policies
218  */
219 
220  int decideNextPhase();
221 
222  bool canRelease();
223 
224  /*
225  * Computes how much time will pass after decideNextPhase will be executed again
226  */
228 
229  return DELTA_T;
230 
231  }
232 
236  void resetPheromone();
237 
238  /*
239  * @return The average pheromone level regarding congestion on input lanes
240  */
241  double getPheromoneForInputLanes();
242 
243  /*
244  * @return The average pheromone level regarding congestion on output lanes
245  */
247 
248  /*
249  * @return The dispersion level regarding congestion on input lanes
250  */
251  double getDispersionForInputLanes(double average_phero_in);
252 
253  /*
254  * @return The dispersion level regarding congestion on output lanes
255  */
256  double getDispersionForOutputLanes(double average_phero_out);
257 
258  /*
259  * @return The difference between the current max phero value and the average phero of the other lanes
260  */
262 
263  /*
264  * @return The difference between the current max phero value and the average phero of the other lanes
265  */
272  void updatePheromoneLevels();
273 
277  void updatePheromoneLevels(MSLaneId_PheromoneMap&, std::string, const double, const double);
278 
284  void updateSensitivities();
285 
290  void decidePolicy();
291 
298  double calculatePhi(int factor);
299 
306  double calculateEtaDiff();
307 
308  double calculateEtaRatio();
309 
310  /*
311  * \brief Method to reset the map that stores if a lane is already been checked during the
312  * evaluation of eta.
313  */
314  void resetLaneCheck();
315  void choosePolicy(double phero_in, double phero_out, double dispersion_in, double dispersion_out);
316  void choosePolicy(double phero_in, double phero_out);
317 
318  std::string getPoliciesParam() {
319  return getParameter("POLICIES", "Platoon;Phase;Marching;Congestion");
320  }
321 
322  /*
323  * Reinforcement modes:
324  * 0-> elapsed time
325  * 1-> diff
326  * 2-> ratio
327  */
329  return StringUtils::toInt(getParameter("REIMODE", "0"));
330  }
331 
332  void initScaleFactorDispersionIn(int lanes_in) {
333  std::vector<double> phero_values;
334 
335  for (int i = 0; i < lanes_in / 2; i++) {
336  phero_values.push_back(getPheroMaxVal());
337  }
338  for (int i = lanes_in / 2; i < lanes_in; i++) {
339  phero_values.push_back(0.0);
340  }
341 
342  double sum_avg_tmp = 0;
343 
344  for (int i = 0; i < (int)phero_values.size(); i++) {
345  sum_avg_tmp += phero_values[i];
346  }
347 
348  double mean = sum_avg_tmp / phero_values.size();
349 
350  double sum_dev_tmp = 0;
351  for (int i = 0; i < (int)phero_values.size(); i++) {
352  sum_dev_tmp += pow(phero_values[i] - mean, 2);
353  }
354 
355  double deviation = sqrt(sum_dev_tmp / phero_values.size());
356 
357  scaleFactorDispersionIn = getPheroMaxVal() / deviation;
358  }
359 
360  void initScaleFactorDispersionOut(int lanes_out) {
361  std::vector<double> phero_values;
362 
363  for (int i = 0; i < lanes_out / 2; i++) {
364  phero_values.push_back(getPheroMaxVal());
365  }
366  for (int i = lanes_out / 2; i < lanes_out; i++) {
367  phero_values.push_back(0.0);
368  }
369 
370  double sum_avg_tmp = 0;
371  for (int i = 0; i < (int)phero_values.size(); i++) {
372  sum_avg_tmp += phero_values[i];
373  }
374  double mean = sum_avg_tmp / phero_values.size();
375 
376  double sum_dev_tmp = 0;
377 
378  for (int i = 0; i < (int)phero_values.size(); i++) {
379  sum_dev_tmp += pow(phero_values[i] - mean, 2);
380  }
381 
382  double deviation = sqrt(sum_dev_tmp / phero_values.size());
383 
385  }
386 
392  bool allowLine(MSLane*);
393 
394  bool logData;
395  std::ofstream swarmLogFile;
402 
415  bool skipEta;
421 
422  int carsIn;
423  int carsOut;
424  int inTarget;
431 
432 // For every lane its index. Esed to get the current lane state for the lane
433  std::map<std::string, std::vector<int> > m_laneIndexMap;
434  std::string getLaneLightState(const std::string& laneId);
435 // store the last message logged. if equal do not log it again
436  std::map<std::string, std::string> m_pheroLevelLog;
437 
438  //derivative
439  std::map<std::string, CircularBuffer<double>* > m_meanSpeedHistory;
440  std::map<std::string, CircularBuffer<double>* > m_derivativeHistory;
442  int m_losCounter;//los: loss of signal
445 
446 // double pheroBegin;
447 };
448 
449 
450 
451 
452 #endif
453 /****************************************************************************/
CircularBuffer
Definition: MSSwarmTrafficLightLogic.h:36
MSSwarmTrafficLightLogic::computeReturnTime
virtual SUMOTime computeReturnTime()
Definition: MSSwarmTrafficLightLogic.h:227
MSSwarmTrafficLightLogic::getScaleFactorDispersionIn
double getScaleFactorDispersionIn()
Definition: MSSwarmTrafficLightLogic.h:176
MSLane
Representation of a lane in the micro simulation.
Definition: MSLane.h:82
CircularBuffer::back
T back() const
Definition: MSSwarmTrafficLightLogic.h:69
MSSwarmTrafficLightLogic::calculateEtaRatio
double calculateEtaRatio()
Definition: MSSwarmTrafficLightLogic.cpp:869
MSSOTLPlatoonPolicy.h
MSSwarmTrafficLightLogic::getGammaNo
double getGammaNo()
Definition: MSSwarmTrafficLightLogic.h:140
MSSwarmTrafficLightLogic::skipEta
bool skipEta
When true indicates that we can skip the evaluation of eta since we've a congestion policy that is la...
Definition: MSSwarmTrafficLightLogic.h:415
DELTA_T
SUMOTime DELTA_T
Definition: SUMOTime.cpp:36
MSSwarmTrafficLightLogic::carsOut
int carsOut
Definition: MSSwarmTrafficLightLogic.h:423
MSSwarmTrafficLightLogic::initScaleFactorDispersionOut
void initScaleFactorDispersionOut(int lanes_out)
Definition: MSSwarmTrafficLightLogic.h:360
MSSwarmTrafficLightLogic::getBetaNo
double getBetaNo()
Definition: MSSwarmTrafficLightLogic.h:136
MSSwarmTrafficLightLogic::carsIn
int carsIn
Definition: MSSwarmTrafficLightLogic.h:422
StringUtils::toDouble
static double toDouble(const std::string &sData)
converts a string into the double value described by it by calling the char-type converter
Definition: StringUtils.cpp:345
MSTrafficLightLogic::Phases
std::vector< MSPhaseDefinition * > Phases
Definition of a list of phases, being the junction logic.
Definition: MSTrafficLightLogic.h:61
LaneIdVector
std::vector< std::string > LaneIdVector
Definition: MSSOTLDefinitions.h:76
LaneCheckMap
std::map< MSLane *, bool > LaneCheckMap
Definition: MSSOTLDefinitions.h:75
CircularBuffer::front
T front() const
Definition: MSSwarmTrafficLightLogic.h:65
MSSwarmTrafficLightLogic::targetLanes
LaneIdVector targetLanes
A copy of the target lanes of this phase.
Definition: MSSwarmTrafficLightLogic.h:410
MSSwarmTrafficLightLogic::~MSSwarmTrafficLightLogic
~MSSwarmTrafficLightLogic()
Definition: MSSwarmTrafficLightLogic.cpp:74
MSSwarmTrafficLightLogic::m_losMaxLimit
int m_losMaxLimit
Definition: MSSwarmTrafficLightLogic.h:443
MSSwarmTrafficLightLogic
Definition: MSSwarmTrafficLightLogic.h:100
SUMOTime
long long int SUMOTime
Definition: SUMOTime.h:34
MSSwarmTrafficLightLogic::decideNextPhase
int decideNextPhase()
Definition: MSSwarmTrafficLightLogic.cpp:215
CircularBuffer::size
int size() const
Definition: MSSwarmTrafficLightLogic.h:73
CircularBuffer::CircularBuffer
CircularBuffer(int size)
Definition: MSSwarmTrafficLightLogic.h:38
MSSOTLPolicy3DStimulus.h
MSSwarmTrafficLightLogic::init
void init(NLDetectorBuilder &nb)
Initialises the tls with sensors on incoming and outgoing lanes Sensors are built in the simulation a...
Definition: MSSwarmTrafficLightLogic.cpp:114
CircularBuffer::clear
void clear()
Definition: MSSwarmTrafficLightLogic.h:80
MSSwarmTrafficLightLogic::swarmLogFile
std::ofstream swarmLogFile
Definition: MSSwarmTrafficLightLogic.h:395
MSSOTLHiLevelTrafficLightLogic
A self-organizing high-level traffic light logic.
Definition: MSSOTLHiLevelTrafficLightLogic.h:44
MSSwarmTrafficLightLogic::allowLine
bool allowLine(MSLane *)
Check if a lane is allowed to be added to the maps pheromoneInputLanes and pheromoneOutputLanes Contr...
Definition: MSSwarmTrafficLightLogic.cpp:90
MSSwarmTrafficLightLogic::getBetaSp
double getBetaSp()
Definition: MSSwarmTrafficLightLogic.h:144
MSSwarmTrafficLightLogic::laneCheck
LaneCheckMap laneCheck
Map to check if a lane was already controlled during the elaboration of eta.
Definition: MSSwarmTrafficLightLogic.h:406
MSSOTLHiLevelTrafficLightLogic.h
MSSwarmTrafficLightLogic::m_pheroLevelLog
std::map< std::string, std::string > m_pheroLevelLog
Definition: MSSwarmTrafficLightLogic.h:436
MSSwarmTrafficLightLogic::mustChange
bool mustChange
When true, indicates that the current policy MUST be changed. It's used to force the exit from the co...
Definition: MSSwarmTrafficLightLogic.h:400
MSSwarmTrafficLightLogic::getLearningCox
double getLearningCox()
Definition: MSSwarmTrafficLightLogic.h:168
Parameterised::getParameter
const std::string getParameter(const std::string &key, const std::string &defaultValue="") const
Returns the value for a given key.
Definition: Parameterised.cpp:72
MSSwarmTrafficLightLogic::getGammaSp
double getGammaSp()
Definition: MSSwarmTrafficLightLogic.h:148
MSSwarmTrafficLightLogic::initScaleFactorDispersionIn
void initScaleFactorDispersionIn(int lanes_in)
Definition: MSSwarmTrafficLightLogic.h:332
MSSwarmTrafficLightLogic::getThetaMax
double getThetaMax()
Definition: MSSwarmTrafficLightLogic.h:156
MSSwarmTrafficLightLogic::scaleFactorDispersionIn
double scaleFactorDispersionIn
Definition: MSSwarmTrafficLightLogic.h:429
CircularBuffer::addValue
bool addValue(const T newValue, T &replacedValue)
Definition: MSSwarmTrafficLightLogic.h:47
MSSwarmTrafficLightLogic::notTarget
int notTarget
Definition: MSSwarmTrafficLightLogic.h:425
MSSwarmTrafficLightLogic::getThetaMin
double getThetaMin()
Definition: MSSwarmTrafficLightLogic.h:160
MSSwarmTrafficLightLogic::m_laneIndexMap
std::map< std::string, std::vector< int > > m_laneIndexMap
Definition: MSSwarmTrafficLightLogic.h:433
MSSwarmTrafficLightLogic::getLaneLightState
std::string getLaneLightState(const std::string &laneId)
Definition: MSSwarmTrafficLightLogic.cpp:1145
MSSwarmTrafficLightLogic::m_losCounter
int m_losCounter
Definition: MSSwarmTrafficLightLogic.h:442
MSSwarmTrafficLightLogic::resetLaneCheck
void resetLaneCheck()
Definition: MSSwarmTrafficLightLogic.cpp:1062
MSSwarmTrafficLightLogic::inTarget
int inTarget
Definition: MSSwarmTrafficLightLogic.h:424
CircularBuffer::at
T at(const int index) const
Definition: MSSwarmTrafficLightLogic.h:60
CircularBuffer::m_currentIndex
int m_currentIndex
Definition: MSSwarmTrafficLightLogic.h:88
MSSwarmTrafficLightLogic::getThetaInit
double getThetaInit()
Definition: MSSwarmTrafficLightLogic.h:164
MSSwarmTrafficLightLogic::getReinforcementMode
int getReinforcementMode()
Definition: MSSwarmTrafficLightLogic.h:328
MSSwarmTrafficLightLogic::scaleFactorDispersionOut
double scaleFactorDispersionOut
Definition: MSSwarmTrafficLightLogic.h:430
MSSwarmTrafficLightLogic::logData
bool logData
Definition: MSSwarmTrafficLightLogic.h:394
MSSwarmTrafficLightLogic::resetPheromone
void resetPheromone()
Resets pheromone levels.
Definition: MSSwarmTrafficLightLogic.cpp:200
CircularBuffer::push_front
void push_front(const T value)
Definition: MSSwarmTrafficLightLogic.h:56
CircularBuffer::m_firstTime
bool m_firstTime
Definition: MSSwarmTrafficLightLogic.h:89
CircularBuffer::m_size
int m_size
Definition: MSSwarmTrafficLightLogic.h:87
MSSwarmTrafficLightLogic::getPoliciesParam
std::string getPoliciesParam()
Definition: MSSwarmTrafficLightLogic.h:318
MSSwarmTrafficLightLogic::getDispersionForOutputLanes
double getDispersionForOutputLanes(double average_phero_out)
Definition: MSSwarmTrafficLightLogic.cpp:548
MSSwarmTrafficLightLogic::pheromoneOutputLanes
MSLaneId_PheromoneMap pheromoneOutputLanes
This pheromone is an indicator of congestion on output lanes. Its levels refer to the average speed o...
Definition: MSSwarmTrafficLightLogic.h:207
MSSwarmTrafficLightLogic::gotTargetLane
bool gotTargetLane
When true indicates that we've already acquired the target lanes for this particular phase.
Definition: MSSwarmTrafficLightLogic.h:420
StringUtils::toInt
static int toInt(const std::string &sData)
converts a string into the integer value described by it by calling the char-type converter,...
Definition: StringUtils.cpp:278
MSSwarmTrafficLightLogic::m_useVehicleTypesWeights
bool m_useVehicleTypesWeights
Definition: MSSwarmTrafficLightLogic.h:444
MSSwarmTrafficLightLogic::pheromoneInputLanes
MSLaneId_PheromoneMap pheromoneInputLanes
This pheronome is an indicator of congestion on input lanes. Its levels refer to the average speed of...
Definition: MSSwarmTrafficLightLogic.h:199
MSSwarmTrafficLightLogic::getLogicType
const std::string getLogicType() const
Returns the type of the logic as a string.
Definition: MSSwarmTrafficLightLogic.h:187
MSSwarmTrafficLightLogic::MSSwarmTrafficLightLogic
MSSwarmTrafficLightLogic(MSTLLogicControl &tlcontrol, const std::string &id, const std::string &programID, const Phases &phases, int step, SUMOTime delay, const std::map< std::string, std::string > &parameters)
Constructor without sensors passed.
Definition: MSSwarmTrafficLightLogic.cpp:27
MSSwarmTrafficLightLogic::updatePheromoneLevels
void updatePheromoneLevels()
Update pheromone levels Pheromone on input lanes is costantly updated Pheromone follows a discrete-ti...
Definition: MSSwarmTrafficLightLogic.cpp:284
MSLaneId_PheromoneMap
std::map< std::string, double > MSLaneId_PheromoneMap
Definition: MSSOTLDefinitions.h:69
MSSOTLMarchingPolicy.h
MSSwarmTrafficLightLogic::getDistanceOfMaxPheroForInputLanes
double getDistanceOfMaxPheroForInputLanes()
Definition: MSSwarmTrafficLightLogic.cpp:563
CircularBuffer::~CircularBuffer
virtual ~CircularBuffer()
Definition: MSSwarmTrafficLightLogic.h:43
CircularBuffer::m_buffer
T * m_buffer
Definition: MSSwarmTrafficLightLogic.h:86
MSSwarmTrafficLightLogic::getMaxCongestionDuration
SUMOTime getMaxCongestionDuration()
Definition: MSSwarmTrafficLightLogic.h:128
MSSOTLCongestionPolicy.h
MSSwarmTrafficLightLogic::updateSensitivities
void updateSensitivities()
Definition: MSSwarmTrafficLightLogic.cpp:412
MSSwarmTrafficLightLogic::getChangePlanProbability
double getChangePlanProbability()
Definition: MSSwarmTrafficLightLogic.h:152
config.h
MSSwarmTrafficLightLogic::getForgettingCox
double getForgettingCox()
Definition: MSSwarmTrafficLightLogic.h:172
CircularBuffer::insert
void insert(const T &value)
Definition: MSSwarmTrafficLightLogic.h:91
MSSwarmTrafficLightLogic::congestion_steps
SUMOTime congestion_steps
Definition: MSSwarmTrafficLightLogic.h:401
MSSwarmTrafficLightLogic::m_derivativeAlpha
double m_derivativeAlpha
Definition: MSSwarmTrafficLightLogic.h:441
MSSwarmTrafficLightLogic::getDispersionForInputLanes
double getDispersionForInputLanes(double average_phero_in)
Definition: MSSwarmTrafficLightLogic.cpp:531
SwarmDebug.h
MSSwarmTrafficLightLogic::calculatePhi
double calculatePhi(int factor)
Method that should calculate the valor of phi a coefficient to amplify/attenuate eta based on a facto...
Definition: MSSwarmTrafficLightLogic.cpp:668
MSTLLogicControl
A class that stores and controls tls and switching of their programs.
Definition: MSTLLogicControl.h:59
MSSwarmTrafficLightLogic::lastThetaSensitivityUpdate
SUMOTime lastThetaSensitivityUpdate
Definition: MSSwarmTrafficLightLogic.h:214
MSSOTLPhasePolicy.h
MSSwarmTrafficLightLogic::getPheromoneForInputLanes
double getPheromoneForInputLanes()
Definition: MSSwarmTrafficLightLogic.cpp:497
MSSOTLPolicy5DFamilyStimulus.h
MSSwarmTrafficLightLogic::canRelease
bool canRelease()
Definition: MSSwarmTrafficLightLogic.cpp:1138
MSSwarmTrafficLightLogic::getPheroMaxVal
double getPheroMaxVal()
Definition: MSSwarmTrafficLightLogic.h:132
MSSwarmTrafficLightLogic::choosePolicy
void choosePolicy(double phero_in, double phero_out, double dispersion_in, double dispersion_out)
Definition: MSSwarmTrafficLightLogic.cpp:1087
MSSwarmTrafficLightLogic::calculateEtaDiff
double calculateEtaDiff()
Method that should calculate the valor of eta a coefficient to evaluate the current policy's work....
Definition: MSSwarmTrafficLightLogic.cpp:679
MSSwarmTrafficLightLogic::getDistanceOfMaxPheroForOutputLanes
double getDistanceOfMaxPheroForOutputLanes()
Definition: MSSwarmTrafficLightLogic.cpp:598
MSSwarmTrafficLightLogic::decidePolicy
void decidePolicy()
Decide the current policy according to pheromone levels The decision reflects on currentPolicy value.
Definition: MSSwarmTrafficLightLogic.cpp:632
MSSwarmTrafficLightLogic::getPheromoneForOutputLanes
double getPheromoneForOutputLanes()
Definition: MSSwarmTrafficLightLogic.cpp:515
NLDetectorBuilder
Builds detectors for microsim.
Definition: NLDetectorBuilder.h:55
MSSwarmTrafficLightLogic::getScaleFactorDispersionOut
double getScaleFactorDispersionOut()
Definition: MSSwarmTrafficLightLogic.h:180
MSSwarmTrafficLightLogic::m_meanSpeedHistory
std::map< std::string, CircularBuffer< double > * > m_meanSpeedHistory
Definition: MSSwarmTrafficLightLogic.h:439
MSSwarmTrafficLightLogic::m_derivativeHistory
std::map< std::string, CircularBuffer< double > * > m_derivativeHistory
Definition: MSSwarmTrafficLightLogic.h:440