Car Flow Simulation

;define global variables
globals [
  number-of-lanes        ; number of lanes on the road
  lanes                  ; a list of the y coordinates of different lanes
  road-length-m          ; length of the road in m
  frame-rate             ; number of images(ticks) per second
  max-speed-kmh          ; max-authorised speed for all cars in km/h
  max-accel-kmhs         ; max possible acceleration in km/h/s
  max-decel-kmhs         ; upper bound for deceleration
  min-decel-kmhs         ; lower bound for deceleration
  reactivity-time        ; reactivity time in case of danger in second
  conv-kmh-patch         ; conversion from km/h to patch
  conv-kmh-dist-security ; conversion of km/h into security distance in patch unit
  average-speed          ; average top-speed and initial speed of normal cars
  variance-speed         ; max delta around average top-speed and initial speed for normal car
  ticks-change-lane      ; number of ticks necessary to overtake or cute-back
  dy-move                ; delta y patch when overtaking
  dist-min-between-car   ; minimum distance between cars in m
  dist-min-patch         ; minimal distance between 2 car in patch unit
  config-file            ; filepath of the config file
  truck-file             ; filepath of the truck file
  late-create-cars       ; number of cars to be created as soon as possible to reach the expected flow
  ticks-between-cars     ; number of ticks between each creation of a car in "flow" mode
  min-speed-flow         ; minimal speed when creating a car in "flow mode"
  rate-accel             ; rate of change around the average acceleration for the cars
  rate-decel             ; rate of change around the average decelaration for the cars
  rate-react-time        ; rate of change around the average reactivity time for the cars
  previous-flow?         ; memorize the last value for flow? variable
  previous-accel         ; memorize the last value for acceleration variable
  previous-decel         ; memorize the last value for deceleration variable
  previous-reac-time     ; memorize the last value for reactivity-time variable
]

;two kinds of turtle
;cars   : "normal" cars
;trucks : used to introduce perturbetaion in the normal flow
breed [cars car ]
breed [trucks truck ]

; common parameters to all the turtles
turtles-own [
  speed             ; the current speed of the car
  top-speed         ; the maximum speed of the car (different for all cars)
  target-lane       ; the desired lane of the car
  patience          ; the driver's current level of patience
  patience-car      ; level of patience of the car
  overtaking?       ; overtaking in progress
  cut-back?         ; cut-back in progress
  mvt-step          ; current mouvement step (during overtake or cut-back)
  default-color     ; default color when not selected
  mode-flow         ; define is the car is in "mode flow" or "mode loop"
  car-accel         ; car specific acceleration in km/h/s
  car-decel         ; car specific deceleration in km/h/s
  car-reac-time     ; car specific reaction-time in second
  change-lane?      ; turtle can change of lane ?
]

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;   BEFORE SETUP  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;reset config/truck file and sliders/button parameters to default value

to reset
  set truck-config "None"
  set truck-file FALSE
  set config-file FALSE
  set number-of-cars 30
  set acceleration 10
  set previous-accel acceleration
  set deceleration 35
  set previous-decel deceleration
  set max-patience 20
  set flow? TRUE             ; new cars by flow or by number
  set previous-flow? flow?
  set flow-cars 1200         ; flow of cars arriving
end 

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;   SETUP PHASE   ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to setup
  ; the global variables are not cleared to keep the config file name and truck file name
  ; the other global variables are initialised either with the file or the init-constant/calculate constant procedure
  clear-ticks clear-turtles clear-patches clear-drawing clear-all-plots clear-output
  set-default-shape cars "car"
  set-default-shape trucks "truck"

  ; if a config-file has been selected before setup then use this config file
  ; only for desktop version of netlogo
  ifelse config-file != FALSE and config-file != 0 and file-exists? config-file [
    load-config-file
  ]
  ; if not use the standard values for init
  [ init-constant ]
  ; calculate usefull variables
  calculate-constant
  ; draw the road
  draw-road
  ; if a truck-file has been selected before setup then use this truck file otherwise no truck is created
  ; only for desktop version of netlogo
  ifelse truck-config = "None" [
    if truck-file != FALSE and truck-file != 0 and file-exists? truck-file [
      load-truck-file
    ]
  ]
  ; initialise with one of the 2 availables truck config
  [ init-truck ]

  ;if "mode loop" create the number of cars expected
  if flow? = FALSE [ create-cars-nb ]

  ;reset time
  reset-ticks
end 

;initialise the truck depending on the value of the chooser truck-config

to init-truck
  ifelse truck-config = "Closed lane" [
    ; setup trucks to simulate a closed lane
    let x 0
    let y last lanes
    ; fill half a lane with trucks to "close" the lane
    repeat (world-width - 1) / 2 [
      create-trucks 1 [
        set mode-flow flow?
        setxy x y
        set color white
        set default-color white
        set target-lane pycor
        set heading 90
        set top-speed 0
        set speed top-speed
        set car-accel acceleration
        set car-decel deceleration
        set car-reac-time reactivity-time
        set patience-car max-patience
        set patience patience-car
        set overtaking? FALSE         ; overtaking in progress
        set cut-back?   FALSE         ; cut-back in progress
        set mvt-step 0
        set change-lane? FALSE
      ]
      set x x + 1
    ]
  ]
  [
    ; setup truck to simulate a "One obstacle per lane"
    ; on each lane create a random truck
    foreach lanes [
      y ->
      let x (random (world-width - 1)) - (world-width - 1) / 2
      let truck-speed 0

      ; create the truck
      create-trucks 1 [
        set mode-flow flow?
        setxy x y
        set color white
        set default-color white
        set target-lane pycor
        set heading 90
        set top-speed truck-speed
        set speed top-speed
        set car-accel acceleration
        set car-decel deceleration
        set car-reac-time reactivity-time
        set patience-car max-patience
        set patience patience-car
        set overtaking? FALSE         ; overtaking in progress
        set cut-back?   FALSE         ; cut-back in progress
        set mvt-step 0
        set change-lane? FALSE
      ]
    ]
  ]
end 

; initialise the values (see glgobal for all the definitions)

to init-constant
  set number-of-lanes 3
  set frame-rate 25          ; number of images(ticks) per second
  set road-length-m 1000     ; length of the road in m
  set max-speed-kmh 130      ; max-authorised speed for all cars
  set max-accel-kmhs 10
  set reactivity-time 2      ; reactivity time in case of danger in second
  set average-speed 110      ; average top-speed and initial speed of normal cars
  set variance-speed 20      ; max delta around average top-speed and initial speed for normal car
  set ticks-change-lane 4    ; number of ticks necessary to change lane
  set dist-min-between-car 5 ; minimum distance between cars in m
  set min-speed-flow 80
  set rate-accel 0.1         ; rate of change around the average acceleration for the cars
  set rate-decel 0.1         ; rate of change around the average decelaration for the cars
  set rate-react-time 0.1    ; rate of change around the average reactivity time for the cars
end 

; load the constant values from the  file

to load-config-file
  file-open config-file
  let flow-binary file-read
  ifelse flow-binary = 1 [set flow? TRUE]
  [set flow? FALSE]
  set flow-cars file-read
  set number-of-cars file-read
  set acceleration file-read
  set deceleration file-read
  set max-patience file-read
  set number-of-lanes file-read
  set frame-rate file-read                   ; number of images(ticks) per second
  set road-length-m file-read                ; length of the road in m
  set max-speed-kmh file-read                ; max-authorised speed for all cars
  set max-accel-kmhs file-read
  set reactivity-time file-read              ; reactivity time in case of danger in second
  set average-speed file-read                ; average top-speed and initial speed of normal cars
  set variance-speed file-read               ; max delta around average top-speed and initial speed for normal car
  set ticks-change-lane file-read            ; number of ticks necessary to overtake
  set dist-min-between-car file-read
  set min-speed-flow file-read
  set rate-accel file-read                   ; rate of change around the average acceleration for the cars
  set rate-decel file-read                   ; rate of change around the average decelaration for the cars
  set rate-react-time file-read              ; rate of change around the average reactivity time for the cars
  file-close
end 

; calculate the usefull constants

to calculate-constant
  set conv-kmh-patch (world-width / (3.6 * frame-rate * road-length-m ))                  ; conversion coefficient between km/h and patch
  set conv-kmh-dist-security ( world-width / ( 3.6 * road-length-m))                      ; conversion coefficient between speed(km/h) and security speed (patch/s unit)
  set max-decel-kmhs (max-speed-kmh / reactivity-time )                                   ; max decelaration in km/h/s
  set min-decel-kmhs (max-speed-kmh / reactivity-time )   / 2                             ; min decelaration in km/h/s
  set dy-move 2 / ticks-change-lane                                                       ; delta y patch when overtaking
  set late-create-cars 0                                                                  ; number of car to be created to achieve expected car flow
  set dist-min-patch dist-min-between-car * world-width / road-length-m
end 

; load truck config-file and create trucks

to load-truck-file
  file-open truck-file
  ; loop till the end of the file
  while [ not file-at-end? ] [
    ; for each truck read position on the road(x,y) and speed
    let x file-read
    let y file-read
    let truck-speed file-read
    let truck-change-lane file-read
    ifelse truck-change-lane = 1 [set truck-change-lane TRUE]
    [set truck-change-lane FALSE]
    ; transform the lane number into an index used in the lane list variable
    let lane-index (2 * y - 1 - number-of-lanes)

    ; create the truck
    create-trucks 1 [
      set mode-flow flow?
      setxy x lane-index
      set color white
      set default-color white
      set target-lane pycor
      set heading 90
      set top-speed truck-speed
      set speed top-speed
      set car-accel acceleration
      set car-decel deceleration
      set car-reac-time reactivity-time
      set patience-car max-patience
      set patience patience-car
      set overtaking? FALSE         ; overtaking in progress
      set cut-back?   FALSE         ; cut-back in progress
      set mvt-step 0
      set change-lane? truck-change-lane
    ]
  ]
  file-close
end 

; function used to draw the road on the view

to draw-road
  ask patches [
    ; the road is surrounded by green grass of varying shades
    set pcolor green - random-float 0.5
  ]
  ; build a list of number-of-lanes items, centered on 0 and spaced by 2 patches
  set lanes n-values number-of-lanes [ n -> (2 / 2 ) * (number-of-lanes - (n * 2) - 1) ]
  ask patches with [ abs pycor <= number-of-lanes * (2 / 2 ) ] [
    ; the road itself is varying shades of grey
    set pcolor grey - 2.5 + random-float 0.25
  ]
  ; draw the line on the road
  draw-road-lines
end 

; function to draw the lines on the road

to draw-road-lines
  let y (last lanes) - 1 ; start below the "lowest" lane
  while [ y <= first lanes + 1 ] [
    if not member? y lanes [
      ; draw lines on road patches that are not part of a lane
      ifelse abs y = number-of-lanes
        [ draw-line y yellow 0 ]  ; yellow for the sides of the road
        [ draw-line y white 0.5 ] ; dashed white between lanes
    ]
    set y y + 1 ; move up one patch
  ]
end 

; draw the line itself

to draw-line [ y line-color gap ]
  ; We use a temporary turtle to draw the line:
  ; - with a gap of zero, we get a continuous line;
  ; - with a gap greater than zero, we get a dasshed line.
  create-turtles 1 [
    setxy (min-pxcor - 0.5) y
    hide-turtle
    set color line-color
    set heading 90
    repeat world-width [
      pen-up
      forward gap
      pen-down
      forward (1 - gap)
    ]
    die
  ]
end 

; create the new cars in "mode loop" simulation
; use the "number-of-cars" slider to define when new cars
; should be created

to create-cars-nb
  let nb-cars number-of-cars / number-of-lanes
  foreach lanes [
    x -> create-cars-per-lane x nb-cars ]
end 

;create the cars on each lane

to create-cars-per-lane [y-lane nb-cars]

  ; make sure we don't have too many cars for the room we have on the road
  let road-patches patches with [ pycor = y-lane ]

  create-cars (nb-cars) [
    move-to one-of free road-patches
    set target-lane pycor
    set heading 90
    set top-speed (average-speed  + (random-float (variance-speed)) * 2 - variance-speed)
    set speed  top-speed - variance-speed  +  (random-float variance-speed)
    set default-color car-color
    set color default-color
    set mode-flow FALSE
    set patience-car 2 + random max-patience
    set patience patience-car
    set car-accel acceleration * (1 + triangle-random rate-accel)
    set car-decel deceleration * (1 + triangle-random rate-decel)
    set car-reac-time reactivity-time * (1 + triangle-random rate-react-time)
    set overtaking? FALSE       ; overtaking in progress
    set cut-back?   FALSE      ; cut-back in progress
    set mvt-step 0
    set change-lane? auth-change-lane?
  ]
end 

; report the patches without any car

to-report free [ road-patches ]
  let this-car self
  report road-patches with [
    not any? turtles-here with [ self != this-car ]
  ]
end 

; calculate the triangle random number associated to number

to-report triangle-random [ number ]
  report (0.5 + random-float 0.5 - random-float 0.5) * number
end 

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;    GO PHASE   ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to go
  ;update variable that are using sliders value
  update-slider-variable

  ; create the cars on the road
  ; at each tick evaluate if new car need to be created depending on the requested number of cars
  ; car creation procedure depends on "mode flow" or "mode loop" simulation (see documentation)
  if flow? = TRUE [ create-cars-flow ]


  ; move forward cars and truck ... if possible
  ask turtles [ move-forward ]



  ; select the turtles that are not doing overtaking or cut-back and check if it can cut-back and check authorised to change lane ?
  ask turtles with [ not-moving and change-lane? = TRUE ] [ check-to-cut-back ]
  ; select the turtles that are not doing overtaking or cut-back and which patience is over, and check if it can overtake ?
  ; and check authorised to change lane
  ask turtles with [ patience <= 0 and not-moving and change-lane? = TRUE] [ check-target-lane ]

  ; depending on the previous check realise cut-back or overtaking (cut-back is prioritary)
  ask turtles with [ overtaking? = TRUE] [ move-to-target-lane ]
  ask turtles with [ cut-back? = TRUE] [ cut-to-target-lane ]

  ;move the clock
  tick
end 

; update the variable that are using sliders values

to update-slider-variable
  set ticks-between-cars (frame-rate * 3600 / flow-cars)
  ; if the average acceleration change, change it for all the cars
  if acceleration != previous-accel [
    ask cars [
      set car-accel acceleration * (1 + triangle-random rate-accel)
    ]
    ask trucks [
      set car-accel acceleration
    ]
  ]
  ; if the average deceleration change, change it for all the cars
  if deceleration != previous-decel [
    ask cars [
      set car-decel deceleration * (1 + triangle-random rate-decel)
    ]
    ask trucks [
      set car-decel deceleration
    ]
  ]

  ; if the flow-mode is changed
  if flow? != previous-flow? [
    ask turtles [
      set mode-flow flow?
    ]
    set previous-flow? flow?
  ]
end 

; create the new cars in "mode flow" simulation
; rely on flow "flow-cars" slider to define when new cars
; should be created

to create-cars-flow

  let local-lanes lanes  ; list of lanes on the road

  ; check if it is time to create a car. If yes add one to the car to be created
  if remainder ticks int(ticks-between-cars) = 0 [ set late-create-cars late-create-cars + 1]
  let to-create late-create-cars

  ; try to create at maximum one car per lane at each tick
  set to-create min list to-create number-of-lanes
  ;if there are cars to be created
  if to-create > 0 [
     ; try to create the number of car needed
     repeat to-create [
        ; start creating the car
        create-cars 1 [
        set heading 90
        ; position the car on the left of the road
        setxy (- world-width / 2 + 0.5 ) last local-lanes
        set speed  0
        set car-reac-time reactivity-time * (1 + triangle-random rate-react-time)
        ; calculate the maximum of security distance
        let dist security-distance max-speed-kmh
        ;select the cars ahead that are in this maximum security distance
        let blocking-cars other turtles in-cone dist 0
        ; select the closest car inside this security distance
        let blocking-car min-one-of blocking-cars [ distance myself ]
        ; for closest car, calculate its distance
        ifelse  blocking-car != nobody [
          set top-speed (average-speed  + (random-float (variance-speed)) * 2 - variance-speed)
          set dist distance blocking-car
          set speed min list  ( speed-from-distance dist) (top-speed - variance-speed  +  (random-float variance-speed))
        ]
        [
          set top-speed (average-speed  + (random-float (variance-speed)) * 2 - variance-speed)
          set speed  top-speed - variance-speed  +  (random-float variance-speed)
        ]
        ; adapt the speed of the created car to this distance (used as a security distance)
        set speed speed-from-distance dist
        ; if the speed is too low (under min-speed-flow parameter)
        ; kill the created vehicule ... and try at next tick
        ifelse speed < min-speed-flow [
          die ] [
          ; finish the initialisation of the car
          set default-color car-color
          set color default-color
          set patience-car 2 + random max-patience
          set patience patience-car
          set car-accel acceleration * (1 + triangle-random rate-accel)
          set car-decel deceleration * (1 + triangle-random rate-decel)
          set overtaking? FALSE       ; overtaking in progress
          set cut-back?   FALSE      ; cut-back in progress
          set mvt-step 0
          set change-lane? auth-change-lane?
          ; decrease the number of car to be created
          set late-create-cars late-create-cars - 1
          set mode-flow flow?
        ]
      ]
      ; go to the next lane (on the left) if more cars need to be created
      set local-lanes but-last local-lanes
    ]
    ; if impossible to create enough cars to achieve right flow
    ; decrease min-speed-flow of 10 km/h
    if late-create-cars > number-of-lanes [
      set min-speed-flow min-speed-flow - 10
      if min-speed-flow < 10 [ set min-speed-flow 10]
    ]
  ]
end 



; report TRUE when a turtle is not overtaking or cutting back

to-report not-moving
 report (cut-back? = FALSE) and (overtaking? = FALSE)
end 

; procedure to define the moving forward of a turtle
; take in account other cars position to decide

to move-forward
  ; test if the car is in "mode flow" or "mode loop"
  ;let mode-flow FALSE
  ifelse (mode-flow = FALSE) [
    ; we are in mode loop, no need to take in account the "end of the road",
    ; netlogo do it since the world is closed
    ; list the cars inside the security distance
    let blocking-cars other turtles in-cone security-distance speed 0
    ; selected the closest car inside security distance
    let blocking-car min-one-of blocking-cars [ distance myself ]
    ; if there is a car inside security distance
    ifelse blocking-car != nobody [
      ;slow down to try to "rebuild" the security distance
      slow-down-car
      ; every time you slow down, you loose a little patience
      set patience patience - 1
    ]
    ;if the road is free
    [
      ;try to speed up
      speed-up-car;
    ]
    ; move forward of a value depending on your speed
    forward kmh-to-patch speed
  ]
  [
    ; we are in mode flow, we need to take in account the "end of the road",
    ; and to kill cars when they reach it

    ; calculate if we are at the end of the road
    let deltax kmh-to-patch speed
    ifelse xcor + dx > world-width / 2 [
      ; the turtle is at the end of the road, it is killed
      die
    ]
    [
      ;not yet at the end of the road
      ; list the cars inside the security distance; do not consider the closed world
      let blocking-cars other turtles in-cone min list (security-distance speed) (world-width / 2 - xcor) 0
      ; selected the closest car inside security distance
      let blocking-car min-one-of blocking-cars [ distance myself ]
      ; if there is a car inside security distance
      ifelse blocking-car != nobody [
        ;slow down to try to "rebuild" the security distance
        slow-down-car
        ; every time you hit the brakes, you loose a little patience
        set patience patience - 1
      ]
      ;if the road is free
      [
        ;try to speed up
        speed-up-car;
      ]
      ; move forward of a value depending on your speed
      forward kmh-to-patch speed
    ]
  ]
end 


; return the closest car to the actual car looking in a direction,
;at a distance and with an open angle

to-report detect-car [ dist angle direction ]
  set heading direction
  let blocking-cars other turtles in-cone dist angle
  let blocking-car min-one-of blocking-cars [ distance myself ]
  set heading 90
  report blocking-car
end 

; reduce the speed of a car

to slow-down-car ; turtle procedure
  set speed (speed - car-decel / frame-rate)
  if speed < 0 [ set speed 0 ]
end 

; increase the speed of a car
; the speed can't be above top-speed
; if the top-speed expected is reach the patience is set to
; maximal value again

to speed-up-car ; turtle procedure
  set speed (speed + car-accel / frame-rate)
  if speed >= top-speed [
    set speed top-speed
    ; the road is free; your patience is max again
    set patience patience-car
  ]
end 

; check if the lane on the left is free
; in order to overtake

to check-target-lane ;
  ; if the car is not already on the left lane
  if ycor != first lanes [
    let my-position position ycor lanes
    ; define the position of the lane on the left
    set target-lane item (my-position - 1) lanes
    ;move temporary the turtle to check for overtaking
    hide-turtle
    let save-ycor ycor
    setxy xcor target-lane
    ; calculate the security distance available in case of overtaking
    let sec-dist security-distance speed
    ; front-car is the car in front inside distance security
    let front-car detect-car  sec-dist 0 90
    ; back car is the car behind inside distance security
    let back-car detect-car sec-dist 0 270
    ;come back to initial position
    setxy xcor save-ycor
    ; overtaking is possible if no car behind and no car ahead
    if (front-car = nobody) and (back-car = nobody) [
      set overtaking?  TRUE
      set patience patience-car
    ]
    show-turtle
  ]
end 

; check if the lane on the right is free
; in order to cut-back

to check-to-cut-back ;
  ; if the car is not already on the right lane
  if ycor != last lanes [
    let my-position position ycor lanes
    ; define the position of the lane on the right
    set target-lane item (my-position + 1) lanes

    ;move temporary the turtle to check for cutting back
    hide-turtle
    let save-ycor ycor
    setxy xcor target-lane
    ; calculate the security distance available in case of overtaking
    let sec-dist security-distance speed
    ; front-car is the car in front inside distance security
    let front-car detect-car  sec-dist 0 90
    ; back car is the car behind inside twice the minimal distance between cars
    let back-car detect-car (dist-min-patch * 2) 0 270
    setxy xcor save-ycor
    ; cut-back is possible if no car behind and no car ahead
    if (front-car = nobody) and (back-car = nobody) [
      set cut-back?  TRUE
      set patience patience-car
    ]
    show-turtle
  ]
end 
; realize the overtaking

to move-to-target-lane ;
  ; the over taking is done in ticks-change-lane ticks
  setxy xcor ycor + dy-move
  if ycor = target-lane [
    set overtaking? FALSE
  ]
end 

;realize the cut-back

to cut-to-target-lane ;
  ; the cut-back is done in ticks-change-lane ticks
  setxy xcor ycor - dy-move
  if ycor = target-lane [
    set cut-back? FALSE
  ]
end 

; convert km/h in patch/tick

to-report kmh-to-patch [ kmh ]
  report kmh * conv-kmh-patch
end 

; give the security distance for
; a given speed in km/h
; the result is in patch unit
; dist-min-patch is the minimum security distance between
; 2 cars

to-report security-distance [ kmh ]
  let dist  kmh * conv-kmh-dist-security * car-reac-time
  if dist < dist-min-patch [
    set dist  dist-min-patch ]
  report dist
end 

; convert a distance between car (patch unit)
; into the allowed speed in km/h

to-report speed-from-distance [ dist ]
  let to-speed  dist / ( conv-kmh-dist-security * car-reac-time)
  report to-speed
end 

; report a car color

to-report car-color
  ; give all cars a blueish color, but still make them distinguishable
  report one-of [ blue cyan sky ] + 1.5 + random-float 1.0
end