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 /****************************************************************************/
16 // The class for Swarm-based logics
17 /****************************************************************************/
18 #ifndef MSSwarmTrafficLightLogic_h
19 #define MSSwarmTrafficLightLogic_h
20 
21 // ===========================================================================
22 // included modules
23 // ===========================================================================
24 #include <config.h>
25 
26 //#define SWARM_DEBUG
29 #include "MSSOTLPhasePolicy.h"
30 #include "MSSOTLPlatoonPolicy.h"
31 #include "MSSOTLMarchingPolicy.h"
32 #include "MSSOTLCongestionPolicy.h"
33 #include "MSSOTLPolicy3DStimulus.h"
35 
36 template<class T>
38 public:
41  m_buffer = new T[m_size];
42  }
43 
44  virtual ~CircularBuffer() {
45  delete[] m_buffer;
46  }
47 
48  bool addValue(const T newValue, T& replacedValue) {
49  bool result = !m_firstTime;
50  if (result) {
51  replacedValue = m_buffer[m_currentIndex];
52  }
53  insert(newValue);
54  return result;
55  }
56 
57  void push_front(const T value) {
58  insert(value);
59  }
60 
61  T at(const int index) const {
62  int idx = (m_currentIndex - 1 - index + m_size) % m_size;
63  return m_buffer[idx];
64  }
65 
66  T front() const {
67  return at(0);
68  }
69 
70  T back() const {
71  return at(size() - 1);
72  }
73 
74  int size() const {
75  if (m_firstTime) {
76  return m_currentIndex;
77  }
78  return m_size;
79  }
80 
81  void clear() {
82  m_currentIndex = 0;
83  m_firstTime = true;
84  }
85 
86 private:
88  int m_size;
91 
92  inline void insert(const T& value) {
93  m_buffer[m_currentIndex++] = value;
94  if (m_currentIndex == m_size) {
95  m_currentIndex = 0;
96  m_firstTime = false;
97  }
98  }
99 };
100 
102 public:
103  //****************************************************
114  MSSwarmTrafficLightLogic(MSTLLogicControl& tlcontrol, const std::string& id,
115  const std::string& programID, const Phases& phases, int step,
116  SUMOTime delay,
117  const std::map<std::string, std::string>& parameters);
118 
120 
127  void init(NLDetectorBuilder& nb);
128 
130  return StringUtils::toInt(getParameter("MAX_CONGESTION_DUR", "120"));
131  }
132 
133  double getPheroMaxVal() {
134  return StringUtils::toDouble(getParameter("PHERO_MAXVAL", "10"));
135  }
136 
137  double getBetaNo() {
138  return StringUtils::toDouble(getParameter("BETA_NO", "0.99"));
139  }
140 
141  double getGammaNo() {
142  return StringUtils::toDouble(getParameter("GAMMA_NO", "1.0"));
143  }
144 
145  double getBetaSp() {
146  return StringUtils::toDouble(getParameter("BETA_SP", "0.99"));
147  }
148 
149  double getGammaSp() {
150  return StringUtils::toDouble(getParameter("GAMMA_SP", "1.0"));
151  }
152 
154  return StringUtils::toDouble(getParameter("CHANGE_PLAN_PROBABILITY", "0.003"));
155  }
156 
157  double getThetaMax() {
158  return StringUtils::toDouble(getParameter("THETA_MAX", "0.8"));
159  }
160 
161  double getThetaMin() {
162  return StringUtils::toDouble(getParameter("THETA_MIN", "0.2"));
163  }
164 
165  double getThetaInit() {
166  return StringUtils::toDouble(getParameter("THETA_INIT", "0.5"));
167  }
168 
169  double getLearningCox() {
170  return StringUtils::toDouble(getParameter("LEARNING_COX", "0.0005"));
171  }
172 
173  double getForgettingCox() {
174  return StringUtils::toDouble(getParameter("FORGETTING_COX", "0.0005"));
175  }
176 
179  }
180 
183  }
184 
188  const std::string getLogicType() const {
189  return "swarmBasedTrafficLogic";
190  }
192 
193 protected:
201 
209 
216 
217  /*
218  * This member has to contain the switching logic for SOTL policies
219  */
220 
221  int decideNextPhase();
222 
223  bool canRelease();
224 
225  /*
226  * Computes how much time will pass after decideNextPhase will be executed again
227  */
229 
230  return DELTA_T;
231 
232  }
233 
237  void resetPheromone();
238 
239  /*
240  * @return The average pheromone level regarding congestion on input lanes
241  */
242  double getPheromoneForInputLanes();
243 
244  /*
245  * @return The average pheromone level regarding congestion on output lanes
246  */
248 
249  /*
250  * @return The dispersion level regarding congestion on input lanes
251  */
252  double getDispersionForInputLanes(double average_phero_in);
253 
254  /*
255  * @return The dispersion level regarding congestion on output lanes
256  */
257  double getDispersionForOutputLanes(double average_phero_out);
258 
259  /*
260  * @return The difference between the current max phero value and the average phero of the other lanes
261  */
263 
264  /*
265  * @return The difference between the current max phero value and the average phero of the other lanes
266  */
273  void updatePheromoneLevels();
274 
278  void updatePheromoneLevels(MSLaneId_PheromoneMap&, std::string, const double, const double);
279 
285  void updateSensitivities();
286 
291  void decidePolicy();
292 
299  double calculatePhi(int factor);
300 
307  double calculateEtaDiff();
308 
309  double calculateEtaRatio();
310 
311  /*
312  * \brief Method to reset the map that stores if a lane is already been checked during the
313  * evaluation of eta.
314  */
315  void resetLaneCheck();
316  void choosePolicy(double phero_in, double phero_out, double dispersion_in, double dispersion_out);
317  void choosePolicy(double phero_in, double phero_out);
318 
319  std::string getPoliciesParam() {
320  return getParameter("POLICIES", "Platoon;Phase;Marching;Congestion");
321  }
322 
323  /*
324  * Reinforcement modes:
325  * 0-> elapsed time
326  * 1-> diff
327  * 2-> ratio
328  */
330  return StringUtils::toInt(getParameter("REIMODE", "0"));
331  }
332 
333  void initScaleFactorDispersionIn(int lanes_in) {
334  std::vector<double> phero_values;
335 
336  for (int i = 0; i < lanes_in / 2; i++) {
337  phero_values.push_back(getPheroMaxVal());
338  }
339  for (int i = lanes_in / 2; i < lanes_in; i++) {
340  phero_values.push_back(0.0);
341  }
342 
343  double sum_avg_tmp = 0;
344 
345  for (int i = 0; i < (int)phero_values.size(); i++) {
346  sum_avg_tmp += phero_values[i];
347  }
348 
349  double mean = sum_avg_tmp / phero_values.size();
350 
351  double sum_dev_tmp = 0;
352  for (int i = 0; i < (int)phero_values.size(); i++) {
353  sum_dev_tmp += pow(phero_values[i] - mean, 2);
354  }
355 
356  double deviation = sqrt(sum_dev_tmp / phero_values.size());
357 
358  scaleFactorDispersionIn = getPheroMaxVal() / deviation;
359  }
360 
361  void initScaleFactorDispersionOut(int lanes_out) {
362  std::vector<double> phero_values;
363 
364  for (int i = 0; i < lanes_out / 2; i++) {
365  phero_values.push_back(getPheroMaxVal());
366  }
367  for (int i = lanes_out / 2; i < lanes_out; i++) {
368  phero_values.push_back(0.0);
369  }
370 
371  double sum_avg_tmp = 0;
372  for (int i = 0; i < (int)phero_values.size(); i++) {
373  sum_avg_tmp += phero_values[i];
374  }
375  double mean = sum_avg_tmp / phero_values.size();
376 
377  double sum_dev_tmp = 0;
378 
379  for (int i = 0; i < (int)phero_values.size(); i++) {
380  sum_dev_tmp += pow(phero_values[i] - mean, 2);
381  }
382 
383  double deviation = sqrt(sum_dev_tmp / phero_values.size());
384 
386  }
387 
393  bool allowLine(MSLane*);
394 
395  bool logData;
396  std::ofstream swarmLogFile;
403 
416  bool skipEta;
422 
423  int carsIn;
424  int carsOut;
425  int inTarget;
432 
433 // For every lane its index. Esed to get the current lane state for the lane
434  std::map<std::string, std::vector<int> > m_laneIndexMap;
435  std::string getLaneLightState(const std::string& laneId);
436 // store the last message logged. if equal do not log it again
437  std::map<std::string, std::string> m_pheroLevelLog;
438 
439  //derivative
440  std::map<std::string, CircularBuffer<double>* > m_meanSpeedHistory;
441  std::map<std::string, CircularBuffer<double>* > m_derivativeHistory;
443  int m_losCounter;//los: loss of signal
446 
447 // double pheroBegin;
448 };
449 
450 
451 
452 
453 #endif
454 /****************************************************************************/
CircularBuffer
Definition: MSSwarmTrafficLightLogic.h:37
MSSwarmTrafficLightLogic::computeReturnTime
virtual SUMOTime computeReturnTime()
Definition: MSSwarmTrafficLightLogic.h:228
MSSwarmTrafficLightLogic::getScaleFactorDispersionIn
double getScaleFactorDispersionIn()
Definition: MSSwarmTrafficLightLogic.h:177
MSLane
Representation of a lane in the micro simulation.
Definition: MSLane.h:83
CircularBuffer::back
T back() const
Definition: MSSwarmTrafficLightLogic.h:70
MSSwarmTrafficLightLogic::calculateEtaRatio
double calculateEtaRatio()
Definition: MSSwarmTrafficLightLogic.cpp:870
MSSOTLPlatoonPolicy.h
MSSwarmTrafficLightLogic::getGammaNo
double getGammaNo()
Definition: MSSwarmTrafficLightLogic.h:141
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:416
DELTA_T
SUMOTime DELTA_T
Definition: SUMOTime.cpp:35
MSSwarmTrafficLightLogic::carsOut
int carsOut
Definition: MSSwarmTrafficLightLogic.h:424
MSSwarmTrafficLightLogic::initScaleFactorDispersionOut
void initScaleFactorDispersionOut(int lanes_out)
Definition: MSSwarmTrafficLightLogic.h:361
MSSwarmTrafficLightLogic::getBetaNo
double getBetaNo()
Definition: MSSwarmTrafficLightLogic.h:137
MSSwarmTrafficLightLogic::carsIn
int carsIn
Definition: MSSwarmTrafficLightLogic.h:423
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:313
MSTrafficLightLogic::Phases
std::vector< MSPhaseDefinition * > Phases
Definition of a list of phases, being the junction logic.
Definition: MSTrafficLightLogic.h:62
LaneIdVector
std::vector< std::string > LaneIdVector
Definition: MSSOTLDefinitions.h:77
LaneCheckMap
std::map< MSLane *, bool > LaneCheckMap
Definition: MSSOTLDefinitions.h:76
CircularBuffer::front
T front() const
Definition: MSSwarmTrafficLightLogic.h:66
MSSwarmTrafficLightLogic::targetLanes
LaneIdVector targetLanes
A copy of the target lanes of this phase.
Definition: MSSwarmTrafficLightLogic.h:411
MSSwarmTrafficLightLogic::~MSSwarmTrafficLightLogic
~MSSwarmTrafficLightLogic()
Definition: MSSwarmTrafficLightLogic.cpp:75
MSSwarmTrafficLightLogic::m_losMaxLimit
int m_losMaxLimit
Definition: MSSwarmTrafficLightLogic.h:444
MSSwarmTrafficLightLogic
Definition: MSSwarmTrafficLightLogic.h:101
SUMOTime
long long int SUMOTime
Definition: SUMOTime.h:35
MSSwarmTrafficLightLogic::decideNextPhase
int decideNextPhase()
Definition: MSSwarmTrafficLightLogic.cpp:216
CircularBuffer::size
int size() const
Definition: MSSwarmTrafficLightLogic.h:74
CircularBuffer::CircularBuffer
CircularBuffer(int size)
Definition: MSSwarmTrafficLightLogic.h:39
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:115
CircularBuffer::clear
void clear()
Definition: MSSwarmTrafficLightLogic.h:81
MSSwarmTrafficLightLogic::swarmLogFile
std::ofstream swarmLogFile
Definition: MSSwarmTrafficLightLogic.h:396
MSSOTLHiLevelTrafficLightLogic
A self-organizing high-level traffic light logic.
Definition: MSSOTLHiLevelTrafficLightLogic.h:45
MSSwarmTrafficLightLogic::allowLine
bool allowLine(MSLane *)
Check if a lane is allowed to be added to the maps pheromoneInputLanes and pheromoneOutputLanes Contr...
Definition: MSSwarmTrafficLightLogic.cpp:91
MSSwarmTrafficLightLogic::getBetaSp
double getBetaSp()
Definition: MSSwarmTrafficLightLogic.h:145
MSSwarmTrafficLightLogic::laneCheck
LaneCheckMap laneCheck
Map to check if a lane was already controlled during the elaboration of eta.
Definition: MSSwarmTrafficLightLogic.h:407
MSSOTLHiLevelTrafficLightLogic.h
MSSwarmTrafficLightLogic::m_pheroLevelLog
std::map< std::string, std::string > m_pheroLevelLog
Definition: MSSwarmTrafficLightLogic.h:437
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:401
MSSwarmTrafficLightLogic::getLearningCox
double getLearningCox()
Definition: MSSwarmTrafficLightLogic.h:169
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:71
MSSwarmTrafficLightLogic::getGammaSp
double getGammaSp()
Definition: MSSwarmTrafficLightLogic.h:149
MSSwarmTrafficLightLogic::initScaleFactorDispersionIn
void initScaleFactorDispersionIn(int lanes_in)
Definition: MSSwarmTrafficLightLogic.h:333
MSSwarmTrafficLightLogic::getThetaMax
double getThetaMax()
Definition: MSSwarmTrafficLightLogic.h:157
MSSwarmTrafficLightLogic::scaleFactorDispersionIn
double scaleFactorDispersionIn
Definition: MSSwarmTrafficLightLogic.h:430
CircularBuffer::addValue
bool addValue(const T newValue, T &replacedValue)
Definition: MSSwarmTrafficLightLogic.h:48
MSSwarmTrafficLightLogic::notTarget
int notTarget
Definition: MSSwarmTrafficLightLogic.h:426
MSSwarmTrafficLightLogic::getThetaMin
double getThetaMin()
Definition: MSSwarmTrafficLightLogic.h:161
MSSwarmTrafficLightLogic::m_laneIndexMap
std::map< std::string, std::vector< int > > m_laneIndexMap
Definition: MSSwarmTrafficLightLogic.h:434
MSSwarmTrafficLightLogic::getLaneLightState
std::string getLaneLightState(const std::string &laneId)
Definition: MSSwarmTrafficLightLogic.cpp:1146
MSSwarmTrafficLightLogic::m_losCounter
int m_losCounter
Definition: MSSwarmTrafficLightLogic.h:443
MSSwarmTrafficLightLogic::resetLaneCheck
void resetLaneCheck()
Definition: MSSwarmTrafficLightLogic.cpp:1063
MSSwarmTrafficLightLogic::inTarget
int inTarget
Definition: MSSwarmTrafficLightLogic.h:425
CircularBuffer::at
T at(const int index) const
Definition: MSSwarmTrafficLightLogic.h:61
CircularBuffer::m_currentIndex
int m_currentIndex
Definition: MSSwarmTrafficLightLogic.h:89
MSSwarmTrafficLightLogic::getThetaInit
double getThetaInit()
Definition: MSSwarmTrafficLightLogic.h:165
MSSwarmTrafficLightLogic::getReinforcementMode
int getReinforcementMode()
Definition: MSSwarmTrafficLightLogic.h:329
MSSwarmTrafficLightLogic::scaleFactorDispersionOut
double scaleFactorDispersionOut
Definition: MSSwarmTrafficLightLogic.h:431
MSSwarmTrafficLightLogic::logData
bool logData
Definition: MSSwarmTrafficLightLogic.h:395
MSSwarmTrafficLightLogic::resetPheromone
void resetPheromone()
Resets pheromone levels.
Definition: MSSwarmTrafficLightLogic.cpp:201
CircularBuffer::push_front
void push_front(const T value)
Definition: MSSwarmTrafficLightLogic.h:57
CircularBuffer::m_firstTime
bool m_firstTime
Definition: MSSwarmTrafficLightLogic.h:90
CircularBuffer::m_size
int m_size
Definition: MSSwarmTrafficLightLogic.h:88
MSSwarmTrafficLightLogic::getPoliciesParam
std::string getPoliciesParam()
Definition: MSSwarmTrafficLightLogic.h:319
MSSwarmTrafficLightLogic::getDispersionForOutputLanes
double getDispersionForOutputLanes(double average_phero_out)
Definition: MSSwarmTrafficLightLogic.cpp:549
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:208
MSSwarmTrafficLightLogic::gotTargetLane
bool gotTargetLane
When true indicates that we've already acquired the target lanes for this particular phase.
Definition: MSSwarmTrafficLightLogic.h:421
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:246
MSSwarmTrafficLightLogic::m_useVehicleTypesWeights
bool m_useVehicleTypesWeights
Definition: MSSwarmTrafficLightLogic.h:445
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:200
MSSwarmTrafficLightLogic::getLogicType
const std::string getLogicType() const
Returns the type of the logic as a string.
Definition: MSSwarmTrafficLightLogic.h:188
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:28
MSSwarmTrafficLightLogic::updatePheromoneLevels
void updatePheromoneLevels()
Update pheromone levels Pheromone on input lanes is costantly updated Pheromone follows a discrete-ti...
Definition: MSSwarmTrafficLightLogic.cpp:285
MSLaneId_PheromoneMap
std::map< std::string, double > MSLaneId_PheromoneMap
Definition: MSSOTLDefinitions.h:70
MSSOTLMarchingPolicy.h
MSSwarmTrafficLightLogic::getDistanceOfMaxPheroForInputLanes
double getDistanceOfMaxPheroForInputLanes()
Definition: MSSwarmTrafficLightLogic.cpp:564
CircularBuffer::~CircularBuffer
virtual ~CircularBuffer()
Definition: MSSwarmTrafficLightLogic.h:44
CircularBuffer::m_buffer
T * m_buffer
Definition: MSSwarmTrafficLightLogic.h:87
MSSwarmTrafficLightLogic::getMaxCongestionDuration
SUMOTime getMaxCongestionDuration()
Definition: MSSwarmTrafficLightLogic.h:129
MSSOTLCongestionPolicy.h
MSSwarmTrafficLightLogic::updateSensitivities
void updateSensitivities()
Definition: MSSwarmTrafficLightLogic.cpp:413
MSSwarmTrafficLightLogic::getChangePlanProbability
double getChangePlanProbability()
Definition: MSSwarmTrafficLightLogic.h:153
config.h
MSSwarmTrafficLightLogic::getForgettingCox
double getForgettingCox()
Definition: MSSwarmTrafficLightLogic.h:173
CircularBuffer::insert
void insert(const T &value)
Definition: MSSwarmTrafficLightLogic.h:92
MSSwarmTrafficLightLogic::congestion_steps
SUMOTime congestion_steps
Definition: MSSwarmTrafficLightLogic.h:402
MSSwarmTrafficLightLogic::m_derivativeAlpha
double m_derivativeAlpha
Definition: MSSwarmTrafficLightLogic.h:442
MSSwarmTrafficLightLogic::getDispersionForInputLanes
double getDispersionForInputLanes(double average_phero_in)
Definition: MSSwarmTrafficLightLogic.cpp:532
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:669
MSTLLogicControl
A class that stores and controls tls and switching of their programs.
Definition: MSTLLogicControl.h:60
MSSwarmTrafficLightLogic::lastThetaSensitivityUpdate
SUMOTime lastThetaSensitivityUpdate
Definition: MSSwarmTrafficLightLogic.h:215
MSSOTLPhasePolicy.h
MSSwarmTrafficLightLogic::getPheromoneForInputLanes
double getPheromoneForInputLanes()
Definition: MSSwarmTrafficLightLogic.cpp:498
MSSOTLPolicy5DFamilyStimulus.h
MSSwarmTrafficLightLogic::canRelease
bool canRelease()
Definition: MSSwarmTrafficLightLogic.cpp:1139
MSSwarmTrafficLightLogic::getPheroMaxVal
double getPheroMaxVal()
Definition: MSSwarmTrafficLightLogic.h:133
MSSwarmTrafficLightLogic::choosePolicy
void choosePolicy(double phero_in, double phero_out, double dispersion_in, double dispersion_out)
Definition: MSSwarmTrafficLightLogic.cpp:1088
MSSwarmTrafficLightLogic::calculateEtaDiff
double calculateEtaDiff()
Method that should calculate the valor of eta a coefficient to evaluate the current policy's work....
Definition: MSSwarmTrafficLightLogic.cpp:680
MSSwarmTrafficLightLogic::getDistanceOfMaxPheroForOutputLanes
double getDistanceOfMaxPheroForOutputLanes()
Definition: MSSwarmTrafficLightLogic.cpp:599
MSSwarmTrafficLightLogic::decidePolicy
void decidePolicy()
Decide the current policy according to pheromone levels The decision reflects on currentPolicy value.
Definition: MSSwarmTrafficLightLogic.cpp:633
MSSwarmTrafficLightLogic::getPheromoneForOutputLanes
double getPheromoneForOutputLanes()
Definition: MSSwarmTrafficLightLogic.cpp:516
NLDetectorBuilder
Builds detectors for microsim.
Definition: NLDetectorBuilder.h:56
MSSwarmTrafficLightLogic::getScaleFactorDispersionOut
double getScaleFactorDispersionOut()
Definition: MSSwarmTrafficLightLogic.h:181
MSSwarmTrafficLightLogic::m_meanSpeedHistory
std::map< std::string, CircularBuffer< double > * > m_meanSpeedHistory
Definition: MSSwarmTrafficLightLogic.h:440
MSSwarmTrafficLightLogic::m_derivativeHistory
std::map< std::string, CircularBuffer< double > * > m_derivativeHistory
Definition: MSSwarmTrafficLightLogic.h:441