---trafficmanagementmendoza.nlogo

NETLOGO

            ]  
            [
              ;; reservation can be made
              ;; sets the reservation variables of the turtle and makes the reservation of the tiles
              set reservation-time i
              set reservation-xcor xpoint-before-reaching-intersection
              set reservation-ycor ypoint-before-reaching-intersection
              set reservation-speed speed
              set reservation-made true
              set reservation-tiles tiles-to-reserve
              reserve tiles-to-reserve      ;makes the reservation of the tiles
              set result true      
            ]            
          ]
        report result
end 

to reserve [list-tiles-to-reserve]
;; reserves the tiles in the intersection at the time the vehicle will pass by them
   foreach list-tiles-to-reserve
   [
     set tiles replace-item (item 0 ?) tiles (replace-item (item 1 ?) (item (item 0 ?) tiles) lput (item 2 ?) (item (item 1 ?) (item (item 0 ?) tiles)))    
   ]
end

to-report vehicle-ahead
;; reports the vehicle ahead of the calling turtle
  let result 0
  let turtles-ahead 0
  let myxcor xcor
  let myycor ycor
  if breed = south
  [
    set turtles-ahead turtles with [(xcor = myxcor) and (ycor < myycor)]
    set result max-one-of turtles-ahead [ycor]
  ]
  if breed = north
  [
    set turtles-ahead turtles with [(xcor = myxcor) and (ycor > myycor)]
    set result min-one-of turtles-ahead [ycor]
  ]
  if breed = east
  [
    set turtles-ahead turtles with [(ycor = myycor) and (xcor > myxcor)]
    set result min-one-of turtles-ahead [xcor]
  ]  
  if breed = west
  [
    set turtles-ahead turtles with [(ycor = myycor) and (xcor < myxcor)]
    set result max-one-of turtles-ahead [xcor]
  ]  
  report result
end 

to-report intersection-is-free [time d xpoint-before-reaching-intersection ypoint-before-reaching-intersection]
;; if the tiles in the intersection that need to be reserved by the calling vehicle are free 
;; at the time the vehicle will cross them, this reporter reports a list containing 
;; the tiles and times of reservation
;; it reports an empty list otherwise
  let result []
  let free true
  let time-test time
  let x (- lanes * lane-width)  ;xcor of top-left corner of intersection
  let y lanes * lane-width ;ycor of top-left corner of intersection
  if breed = north
  [
            let xleft xpoint-before-reaching-intersection - cars-size / 2
            let xright xpoint-before-reaching-intersection + cars-size / 2
            let left-tile-number max (list 0 (floor ((xleft - x) / tile-width)) )
            let right-tile-number min (list (granularity - 1) (floor ((xright - x) / tile-width)) )
            let ytop 0
            let ybottom 0
            let top-tile-number 0
            let bottom-tile-number 0
            let counter1 0
            let counter2 0
            let yaux ypoint-before-reaching-intersection
            while [yaux - cars-size <= y]     ;/ 2
            [       
                set ytop yaux + cars-size / 2
                set ybottom yaux - cars-size / 2
                set top-tile-number max (list 0 floor ((y - ytop) / tile-height))
                set bottom-tile-number min (list (granularity - 1) floor ((y - ybottom) / tile-height))
                set counter1 top-tile-number                
                repeat bottom-tile-number - top-tile-number + 1
                [                                
                  set counter2 left-tile-number                  
                  repeat right-tile-number - left-tile-number + 1
                  [
                    if (counter2 <= granularity - 1) and (counter1 <= granularity - 1) 
                    [
                        set result lput (list counter2 counter1 time-test) result 
                        if (reserved-tiles counter2 counter1 time-test)
                            [set free false]        ;; if there is a tile already reserved, the reservation cannot be made
                    ]
                        set counter2 counter2 + 1
                  ]
                  set counter1 counter1 + 1
                ]
                set yaux yaux + d * second
                set time-test time-test + 1
            ]
  ]
  if breed = south
  [
            let xleft xpoint-before-reaching-intersection - cars-size / 2
            let xright xpoint-before-reaching-intersection + cars-size / 2
            let left-tile-number max (list 0 (floor ((xleft - x) / tile-width))  )
            let right-tile-number min (list (granularity - 1) (floor ((xright - x) / tile-width)) )
            let ytop 0
            let ybottom 0
            let top-tile-number 0
            let bottom-tile-number 0
            let counter1 0
            let counter2 0
            let yaux ypoint-before-reaching-intersection
            while [yaux + cars-size >= y - (lanes * 2 * lane-width)]     ;/ 2
            [                            
                set ytop yaux + cars-size / 2
                set ybottom yaux - cars-size / 2
                set top-tile-number max (list 0 floor ((y - ytop) / tile-height))
                set bottom-tile-number min (list (granularity - 1) floor ((y - ybottom) / tile-height))
                set counter1 top-tile-number                
                repeat bottom-tile-number - top-tile-number + 1
                [
                  set counter2 left-tile-number
                  repeat right-tile-number - left-tile-number + 1
                  [
                    if (counter2 <= granularity - 1) and (counter1 <= granularity - 1) 
                    [
                        set result lput (list counter2 counter1 time-test) result 
                        if (reserved-tiles counter2 counter1 time-test)
                            [set free false]    ;; if there is a tile already reserved, the reservation cannot be made
                    ]
                        set counter2 counter2 + 1
                  ]
                  set counter1 counter1 + 1
                ]
                set yaux yaux - d * second
                set time-test time-test + 1
            ]
  ]  
  if breed = east
  [  
            let xaux xpoint-before-reaching-intersection
            let ytop ypoint-before-reaching-intersection + cars-size / 2
            let ybottom ypoint-before-reaching-intersection - cars-size / 2
            let top-tile-number max (list 0 floor ((y - ytop) / tile-height))
            let bottom-tile-number min (list (granularity - 1) floor ((y - ybottom) / tile-height))
            let xleft 0
            let xright 0
            let left-tile-number 0
            let right-tile-number 0
            let counter1 0
            let counter2 0
            while [xaux - cars-size <= x + lanes * 2 * lane-width]
            [
                set xleft xaux - cars-size / 2
                set xright xaux + cars-size / 2
                set left-tile-number max (list 0 floor((xleft - x) / tile-width))
                set right-tile-number min (list (granularity - 1) floor((xright - x) / tile-width))
                set counter1 top-tile-number                
                repeat bottom-tile-number - top-tile-number + 1
                [
                  set counter2 left-tile-number
                  repeat right-tile-number - left-tile-number + 1
                  [
                    if (counter2 <= granularity - 1) and (counter1 <= granularity - 1) 
                    [
                        set result lput (list counter2 counter1 time-test) result 
                        if (reserved-tiles counter2 counter1 time-test)
                            [set free false]      ;; if there is a tile already reserved, the reservation cannot be made
                    ]
                        set counter2 counter2 + 1
                  ]
                  set counter1 counter1 + 1
                ]
                set xaux xaux + d * second
                set time-test time-test + 1
          ]
  ]

  if breed = west
  [  
            let xaux xpoint-before-reaching-intersection
            let ytop ypoint-before-reaching-intersection + cars-size / 2
            let ybottom ypoint-before-reaching-intersection - cars-size / 2            
            let top-tile-number max (list 0 floor ((y - ytop) / tile-height))
            let bottom-tile-number min (list (granularity - 1) floor ((y - ybottom) / tile-height))
            let xleft 0
            let xright 0
            let left-tile-number 0
            let right-tile-number 0
            let counter1 0
            let counter2 0
            while [xaux + cars-size / 2 >= x]
            [
                set xleft xaux - cars-size / 2
                set xright xaux + cars-size / 2
                set left-tile-number max (list 0 floor((xleft - x) / tile-width))
                set right-tile-number min (list (granularity - 1) floor((xright - x) / tile-width))
                set counter1 top-tile-number   
                repeat bottom-tile-number - top-tile-number + 1
                [
                  set counter2 left-tile-number
                  repeat right-tile-number - left-tile-number + 1
                  [
                    if (counter2 <= granularity - 1) and (counter1 <= granularity - 1) 
                    [
                        set result lput (list counter2 counter1 time-test) result 
                        if (reserved-tiles counter2 counter1 time-test)
                            [set free false]      ;; if there is a tile already reserved, the reservation cannot be made
                    ]
                        set counter2 counter2 + 1
                  ]
                  set counter1 counter1 + 1
                ]
                set xaux xaux - d * second
                set time-test time-test + 1
          ]
  ]
  if not free [set result []]
  report result
end

to-report reserved-tiles [x-num-tile y-num-tile time]
;; reports true if the tile (x-num-tile, y-num-tile) is reserved at the given time
;; false otherwise   
    let times-reserved item y-num-tile (item x-num-tile tiles)
    report member? time times-reserved 
end      
   
to-report next-green-period [param1]
;; reports the next time step at which the light will be green for the caller turtle 
;; param1 = distance-to-intersection / speed
  let result 100000000
  let current-time (clock / (1 / second))
  let d (current-time + param1) mod period
  ifelse (breed = north) or (breed = south)
  [
    ifelse d < (alpha * period)
      [ set result current-time + param1 ]
      [ set result current-time + param1 + period - d ]
  ]
  [ ifelse (d >= ((alpha + beta) * period)) and (d < ((1.0 - beta) * period))
    [ set result current-time + param1 ]
    [
      ifelse (d < (alpha + beta) * period)
      [ set result current-time + param1 + ((alpha + beta) * period - d)]
      [ set result current-time + param1 + (period - d) + (alpha + beta) * period]
    ]
  ]  
  report result
end 

to-report green-light [turtle-breed]
;; reports true if the light is green for the "turtle-breed" direction
;; false otherwise
  let result false
  let current-time (clock / (1 / second))
  let d current-time mod period
  ifelse (turtle-breed = north) or (turtle-breed = south) 
  [set result (d < alpha * period)]
  [
    ifelse (turtle-breed = east) or (turtle-breed = west) 
    [set result ((d >= (alpha + beta) * period) and (d < (1.0 - beta) * period))]
    [if (turtle-breed = "none") [set result (not (d < alpha * period)) and (not ((d >= (alpha + beta) * period) and (d < (1.0 - beta) * period)))]]
  ]    
  report result
end 

to-report vehicle-ahead-too-close
;; reports true if the vehicle ahead of the caller if within "speed" distance (one second) ahead
;; false otherwise
  let result false
  let x 1
  repeat speed 
  [ 
    if (any? turtles-on patch-ahead x)
      [set result true] 
    set x x + 1 
  ] 
  report result
end
       
to accelerate
;; set acceleration to the acceleration-step
  set acceleration acceleration-step
end

to coast
;; set acceleration to 0 
  set acceleration 0
end

to decelerate
;; set acceleration to deceleration-step
  set acceleration (- 1 * deceleration-step)
end


;;;;;;;;;;;;;;;;;;;;;;;;;;
;;EXPERIMENTS PROCEDURES;;
;;;;;;;;;;;;;;;;;;;;;;;;;;

to experiment1
  set lanes  1
  set plotting false
  set model "Trafic Light"
  set period 10
  set beta 0
  set alpha 0.45    
  set spawn-probability-N  .001
  set spawn-probability-S  .001 
  set spawn-probability-E  0
  set spawn-probability-W  0 
  set ticks-by-second 50
  setup  
  set-current-plot "Figure a"  
  set-plot-x-range 10 200
  set-current-plot "Figure b"
  set-plot-x-range 10 200       
  while [period <= 200]   [     
    start-variables       
    ask turtles [die]
     while [clock <= 20000] [
        go      
     ] 
    do-plotting
   set period period + 1
  ]
  
end



to experiment2  
  set lanes  1
  set plotting false  
  set model "Trafic Light"
  set period 30
  set beta 0
  set alpha 0.1
  set spawn-probability-N  .001
  set spawn-probability-S  .001 
  set spawn-probability-E  0
  set spawn-probability-W  0
  set ticks-by-second 50   
  setup
  set-current-plot "Figure a"    
  set-plot-x-range 0.10 .89
  set-current-plot-pen "Theoretical" 
  set-plot-pen-interval 0.1
  set-current-plot-pen "Empirical"  
  set-plot-pen-interval 0.1
  set-current-plot "Figure b"
  set-plot-x-range 0.10 .89   
  set-current-plot-pen "Theoretical" 
  set-plot-pen-interval 0.1
  set-current-plot-pen "Empirical"  
  set-plot-pen-interval 0.1
  while [alpha <= .89]
  [
    start-variables 
    ask turtles [die]
     while [clock <= 20000] [
        go        
     ] 
    do-plotting  
   set alpha alpha + .1
  ]
end

to experiment3 
  set lanes  1
  set plotting false
 ;;Lists with the results of each experiment
  
  set model "Trafic Light"
  set period 10
  set beta 0 
  set alpha 0.45  
  set spawn-probability-N  .001
  set spawn-probability-S  .001 
  set spawn-probability-E  0
  set spawn-probability-W  0
  set ticks-by-second 50  
  setup     
  set list-Period10 []
  while [spawn-probability-N <= .02 ]
  [
    start-variables  
    ask turtles [die]
     while [clock <= 20000] [
        go              
     ] 
   set spawn-probability-N spawn-probability-N + .001
   set spawn-probability-S spawn-probability-N  
   set list-Period10 lput (total-delay / total-finished-cars) list-Period10
  ]
     

  set model "Trafic Light"
  set period 30
  set beta 0
  set alpha 0.45  
  set spawn-probability-N  .001
  set spawn-probability-S  .001 
  set spawn-probability-E  0
  set spawn-probability-W  0
  set ticks-by-second 50  
  ask turtles [die]        
  set list-Period30 []
  while [spawn-probability-N <= .02] 
  [
    start-variables  
    ask turtles [die]
     while [clock <= 20000] [
        go      
     ] 
   set spawn-probability-N spawn-probability-N + .001
   set spawn-probability-S spawn-probability-N + .001
   set list-Period30 lput (total-delay / total-finished-cars) list-Period30
  ] 
  
 
  set model "Trafic Light"
  set period 50
  set beta 0
  set alpha 0.45  
  set spawn-probability-N  .001
  set spawn-probability-S  .001 
  set spawn-probability-E  0
  set spawn-probability-W  0
  set ticks-by-second 50  
  ask turtles [die]    
  set list-Period50 [] 
  while [spawn-probability-N <= .02] 
  [
    start-variables  
    ask turtles [die]
     while [clock <= 20000] [
        go        
     ] 
   set spawn-probability-N spawn-probability-N + .001
   set spawn-probability-S spawn-probability-N