TE3

globals [
  tick-advance-amount               ; how much we advance the tick counter this time through
  max-tick-advance-amount           ; the largest tick-advance-amount is allowed to be
  init-avg-speed init-avg-energy    ; initial averages
  avg-speed avg-energy              ; current average
  avg-energy-green
  avg-energy-orange
  avg-energy-purple
  avg-energy-gray
  particle-size
  toggle-red-state
  toggle-green-state
  min-particle-energy
  max-particle-energy
  particles-to-add
  initial-gas-temperature

  #-green-particles
  #-orange-particles
  #-purple-particles
  green-label
  orange-label
  purple-label

]

breed [ particles particle ]
breed [ walls wall ]
breed [ flashes flash ]
breed [ erasers eraser ]
breed [ arrowheads arrowhead ]

erasers-own [ pressure? ]
flashes-own [ birthday ]

particles-own [
  speed mass energy          ; particles info
  last-collision
  color-type
]

walls-own [
  energy
  valve-1?
  valve-2?
  pressure?
  my-pxcor
  my-pycor
  my-heading
  distance-advance
  color-type
]

to setup
  clear-all
  reset-ticks
  set particle-size 1.0
  set max-tick-advance-amount 0.02

  set  #-green-particles 0
  set #-orange-particles 0
  set #-purple-particles 0
  set green-label ""
  set orange-label ""
  set purple-label ""

  set particles-to-add 2
  set initial-gas-temperature 500

  set-default-shape flashes "square2"
    set-default-shape walls "circle"
 ; set-default-shape walls "square2"
  set-default-shape erasers "eraser"
  set-default-shape arrowheads "default"

  set min-particle-energy 100
  set max-particle-energy 500  ;(.5 ) * ( max-dist-in-tick-advance-amount  / max-tick-advance-amount ) ^ 2

  create-erasers 1 [
    set hidden? true
    set pressure? true
    set size 1.2
    set color [255 255 255 100]
  ]

  make-box
  ask walls [recolorshade-walls]

  make-particles

  ask particles [ apply-speed-visualization ]

  set init-avg-speed avg-speed
  set init-avg-energy avg-energy

  update-variables
  do-plots
end 

to go
  mouse-action


    ask walls [transfer-energy]

    ask walls [calculate-distance-advance-amount]
    ask walls [apply-vibration-motion-visualization]
 do-plots





  tick-advance tick-advance-amount
  calculate-tick-advance-amount

 ; ask flashes [ apply-flash-visualization ]
 ; ask particles [ apply-speed-visualization ]
  ask walls [recolorshade-walls]
  update-variables

  display
end 

to calculate-distance-advance-amount
   set distance-advance (distance-advance + (tick-advance-amount * (energy) * 9))
   ;show distance-advance
end 

to-report avg-energy-green-l
  let report-value "N/A"
  if avg-energy-green != 0 [set report-value avg-energy-green]
  report report-value
end 

to-report avg-energy-purple-l
  let report-value "N/A"
  if avg-energy-purple != 0 [set report-value avg-energy-purple]
  report report-value
end 

to-report avg-energy-orange-l
  let report-value "N/A"
  if avg-energy-orange != 0 [set report-value avg-energy-orange]
  report report-value
end 

to update-variables
  if any? particles [
    set avg-speed  mean [ speed ] of particles
    set avg-energy mean [ energy ] of particles
  ]
  let green-particles walls with [ color-type = 55 ]
  let orange-particles walls with [ color-type = 25 ]
  let purple-particles walls with [ color-type = 115 ]

  set #-green-particles count green-particles
  set #-orange-particles count  orange-particles
  set #-purple-particles count  purple-particles

  ifelse #-orange-particles > 0 [
    set avg-energy-orange mean [ energy ] of walls with [ color-type = 25 ]
    set orange-label avg-energy-orange
  ]
  [set orange-label "N/A"]

  ifelse  #-green-particles > 0  [
    set avg-energy-green mean [ energy ] of walls with [ color-type = 55 ]
    set green-label avg-energy-green
  ]
  [set green-label "N/A"]

  ifelse #-purple-particles > 0  [
    set avg-energy-purple mean [ energy ] of walls with [ color-type = 115 ]
    set purple-label avg-energy-purple
  ]
  [set purple-label "N/A"]
end 


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WALL INTERACTION;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to toggle-red-wall
  ifelse toggle-red-state = "closed" [
    ask walls with [ valve-1? ] [
      set hidden? true
    ]
    set toggle-red-state "open"
  ][
    ask walls with [ valve-1? ] [
      set hidden? false
    ]
    set toggle-red-state "closed"
  ]
end 

to toggle-green-wall
  ifelse toggle-green-state = "closed" [
    ask walls with [ valve-2? ] [
      set hidden? true
    ]
    set toggle-green-state "open"
  ][
    ask walls with [ valve-2?] [
      set hidden? false
    ]
    set toggle-green-state "closed"
  ]
end 

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAS MOLECULES MOVEMENT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to bounce  ; particles procedure
  ; get the coordinates of the patch we'll be on if we go forward 1
  let bounce-patch nobody
  let bounce-patches nobody
  let hit-angle 0
  let this-patch patch-here
  let new-px 0
  let new-py 0
  let visible-wall nobody
  let particle-energy energy

  set bounce-patch  min-one-of walls in-cone ((sqrt (2)) / 2) 180 with [ myself != this-patch ] [ distance myself ]

  if bounce-patch != nobody [
    let wall-energy [energy] of bounce-patch
    let energy-difference (particle-energy - wall-energy)
    set new-px [ pxcor ] of bounce-patch
    set new-py [ pycor ] of bounce-patch
    set visible-wall walls-on bounce-patch

    if any? visible-wall with [ not hidden? ]  [
      set hit-angle towards bounce-patch
      ifelse (hit-angle <= 135 and hit-angle >= 45) or (hit-angle <= 315 and hit-angle >= 225) [
        set heading (- heading)
      ][
        set heading (180 - heading)
      ]
      set energy (energy - (energy-difference / 4))
      set speed speed-from-energy
      ask bounce-patch [set energy (energy + (energy-difference / 4)) ]
      if true [; show-wall-hits? [
        ask patch new-px new-py [
          sprout 1 [
            set breed flashes
            set color gray - 2
            set birthday ticks
          ]
        ]
      ]
    ]
  ]
end 

to rewind-to-bounce  ; particles procedure
  ; attempts to deal with particle penetration by rewinding the particle path back to a point
  ; where it is about to hit a wall
  ; the particle path is reversed 49% of the previous tick-advance-amount it made,
  ; then particle collision with the wall is detected again.
  ; and the particle bounces off the wall using the remaining 51% of the tick-advance-amount.
  ; this use of slightly more of the tick-advance-amount for forward motion off the wall, helps
  ; insure the particle doesn't get stuck inside the wall on the bounce.

  let bounce-patch nobody
  let bounce-patches nobody
  let hit-angle 0
  let this-patch nobody
  let new-px 0
  let new-py 0
  let visible-wall nobody

  bk (speed) * tick-advance-amount * .49
  set this-patch  patch-here

  set bounce-patch  min-one-of walls in-cone ((sqrt (2)) / 2) 180 with [ self != this-patch ] [ distance myself ]

  if bounce-patch != nobody [

    set new-px [pxcor] of bounce-patch
    set new-py [pycor] of bounce-patch
    set visible-wall walls-on bounce-patch

    if any? visible-wall with [not hidden?] [
      set hit-angle towards bounce-patch

      ifelse (hit-angle <= 135 and hit-angle >= 45) or (hit-angle <= 315 and hit-angle >= 225) [
        set heading (- heading)
      ][
        set heading (180 - heading)
      ]

      if true [;[show-wall-hits? [
        ask patch new-px new-py [
          sprout 1 [
            set breed flashes
            set color gray - 2
            set birthday ticks
          ]
        ]
      ]
    ]
  ]
  fd (speed) * tick-advance-amount * .51
end 

to move  ; particles procedure
  if patch-ahead (speed * tick-advance-amount) != patch-here [ set last-collision nobody ]
  jump (speed * tick-advance-amount)
end 

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAS MOLECULES COLLISIONS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;from GasLab

to calculate-tick-advance-amount
  set tick-advance-amount max-tick-advance-amount
end 


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;  mouse interaction procedures
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to mouse-action
 let snap-xcor 0
 let snap-ycor 0
 let orig-xcor 0
 let orig-ycor 0
 let eraser-window-walls nobody
 let eraser-window-particles nobody

  ifelse mouse-down? [
    set orig-xcor mouse-xcor
    set orig-ycor mouse-ycor
    set snap-xcor round orig-xcor
    set snap-ycor round orig-ycor

    ask patches with [ pxcor = snap-xcor and pycor = snap-ycor ] [
      set eraser-window-walls  walls-here
     ; show eraser-window-walls
      set eraser-window-particles particles-here


      if mouse-interaction = "add green solid particles" [
        ask walls-here [ die ]
        sprout 1 [
          set breed walls set color-type green
          initialize-this-wall

        ]
      ]
      if mouse-interaction = "add orange solid particles" [
        ask walls-here [ die ]
        sprout 1 [
          set breed walls set color-type orange
          initialize-this-wall
        ]
      ]
      if mouse-interaction = "add purple solid particles" [
        ask walls-here [ die ]
        sprout 1 [
          set breed walls set color-type violet
          initialize-this-wall
        ]
      ]


      if mouse-interaction = "big eraser" [
        ask erasers [
          set hidden? false
          set shape "eraser"
          set color [255 255 255 100]
          setxy orig-xcor orig-ycor
        ]
     ;   show count  eraser-window-walls
        ask eraser-window-walls [ die ]
        ask eraser-window-particles [ die ]
      ]




      if mouse-interaction = "paint the particles purple"
        or mouse-interaction = "paint the particles orange"
        or mouse-interaction = "paint theparticles green" [

        ask erasers [
          set hidden? false
          set shape "spray paint"
          setxy orig-xcor orig-ycor
        ]
        ask eraser-window-walls [
          if mouse-interaction = "paint the particles purple"  [ set color-type 115 recolorshade-walls show 0]
          if mouse-interaction = "paint the particles orange" [ set color-type 25 recolorshade-walls ]
          if mouse-interaction = "paint the particles green" [ set  color-type 55 recolorshade-walls ]
          apply-speed-visualization
        ]



      ]

      if mouse-interaction = "speed up particles"  [

        ask erasers [
          set hidden? false
          set shape "spray paint"
          setxy orig-xcor orig-ycor
        ]
        ask eraser-window-particles [
          set energy (energy * 1.1)
          set energy limited-particle-energy
          set speed speed-from-energy
          apply-vibration-color-visualization
        ]
        ask eraser-window-walls [
          set energy (energy * 1.1)
          set energy limited-particle-energy
          apply-vibration-color-visualization
        ]



      ]

      if mouse-interaction = "slow down particles" [
        ask erasers [
          set hidden? false
          set shape "spray paint"
          setxy orig-xcor orig-ycor
        ]
        ask eraser-window-particles [
          set energy (energy / 1.1)
          set energy limited-particle-energy
          set speed speed-from-energy
          apply-speed-visualization
        ]
        ask eraser-window-walls [
          set energy (energy / 1.1)
          set energy limited-particle-energy
          apply-vibration-color-visualization
        ]
      ]
    ]
    ask particles with [ any? walls-here ] [ remove-from-walls ] ; deal with any walls drawn on top of particles
  ][
    ask erasers [ set hidden? true ]
  ]
end 


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; thermal energy transfer
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to transfer-energy
  let neighboring-walls walls-on neighbors4
  let my-energy energy

  if any? neighboring-walls [

  ask neighboring-walls [
    let energy-diff-to-neighbor (my-energy - energy)
    set energy (energy + (energy-diff-to-neighbor / 10))
  ]
  ]
end 

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; particle speed and flash visualization procedures
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to-report temp-scale
  report (16 * (energy / 500))
end 

to-report temp-scaled-1
  let new-scale sqrt sqrt temp-scale
  report new-scale
end 

to-report temp-scaled-2
  let new-scale sqrt  temp-scale
  report new-scale
end 

to-report temp-scaled-3
    let new-scale (155 * (temp-scale - 1) / 15)
  report new-scale
end 

to-report temp-scaled-4
    let new-scale (155 * (temp-scale - 1) / 15)
  report new-scale
end 

to apply-vibration-color-visualization

  ifelse true [
    let r-val 100 + temp-scaled-3
    let g-val 100 + (temp-scaled-3 / 2)
    let b-val 100 + (temp-scaled-3 / 2)
    let color-list (list r-val g-val b-val)
    set color color-list
  ]
  [
    let r-val 100 + temp-scaled-4
    let g-val 100 + (temp-scaled-4 / 2)
    let b-val 100 + (temp-scaled-4 / 2)
    let color-list (list r-val g-val b-val)
   ; show color-list
    set color color-list
  ]

  ;show size
end 

to apply-vibration-motion-visualization
  set xcor my-pxcor
  set ycor my-pycor
;  let rotate rotate + random-float 10  random-float 10
  set my-heading my-heading + random-float 10  - random-float 10
;  set heading my-heading
  let displacement (0.05 * ((energy / 100) ^ .75) *  sin (distance-advance))
 ; rt (360 * (ticks * temp-scaled-2 * 0.2))
  fd displacement


  set size 1.1


  ;show size
end 

to apply-flash-visualization
  set size (size * .95)
  if (ticks - birthday > 0.4)  [ die ]
end 

to apply-speed-visualization
 ; if visualize-speed? = "arrows" [ scale-arrowheads ]
 ; if visualize-speed? = "different shades" [ recolorshade-particles ]
 ; if visualize-speed? = "none" [ recolornone ]
end 

to color-particle-and-link
  let this-link my-out-links
  let this-color-type color-type
  set color this-color-type
  ask this-link [ set color this-color-type ]
end 

to scale-arrowheads
  let this-xcor xcor
  let this-ycor ycor
  let this-speed speed
  let this-heading heading
  let this-arrowhead out-link-neighbors
  let this-link my-out-links
  ask this-link [ set hidden? false ]
  ask this-arrowhead [
    set xcor this-xcor
    set ycor this-ycor
    set heading this-heading
    fd .5 + this-speed / 3
  ]
end 

to recolorshade-particles
  let this-link my-out-links
  ask this-link [ set hidden? true ]
  ifelse speed < 27 [
    set color color-type - 3 + speed / 3
  ][
    set color color-type + 4.999
  ]
end 

to recolorshade-walls
  ifelse energy < 500 [
    set color (color-type - 2.5 + (6 * (energy - 100) / 400))
  ][
    set color color-type + 3.5
  ]
end 

to recolornone
  let this-link my-out-links
  ask this-link [ set hidden? true ]
  set color color-type
end 

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;  initialization procedures
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to make-box
  let vertical-line -3

  if orange-width > 0 and orange-height > 0 [
    ask patches with [ ((pycor <= vertical-line) and (pycor > (vertical-line - orange-height)) ) and (pxcor >= (-1 * (orange-width / 2))  and (pxcor <  (orange-width / 2))) ] [
      sprout 1 [
        set breed walls set color-type orange initialize-this-wall set pressure? true
      ]
    ]
  ]
  if purple-width > 0 and purple-height > 0 [
    ask patches with [ ((pycor > vertical-line) and (pycor <= (purple-height + vertical-line)) ) and (pxcor >= (-1 * purple-width)  and (pxcor <  0)) ] [
      sprout 1 [
        set breed walls set color-type violet initialize-this-wall set pressure? true
      ]
    ]
  ]
  if green-width > 0 and green-height > 0 [
    ask patches with [ ((pycor > vertical-line) and (pycor <= (green-height + vertical-line)) ) and (pxcor < (green-width)  and (pxcor >=  0)) ] [
      sprout 1 [
        set breed walls set color-type green initialize-this-wall set pressure? true
      ]
    ]
  ]
end 

to initialize-this-wall
  set valve-1? false
  set valve-2? false
  set pressure? false
  if color-type = orange [set energy initial-temp-orange]
  if color-type = green [set energy initial-temp-green]
  if color-type = violet [set energy initial-temp-purple]
  set my-pxcor pxcor
  set my-pycor pycor
  set my-heading random 360
  set distance-advance 0
  set size 1.1
end 

to make-particles
 ; create-particles 1 [;initial-#-gas-particles [
 ;   setup-particles
 ;   random-position
 ; ]
end 

to setup-particles  ; particles procedure
  set shape "circle"
  set size particle-size
  set energy initial-gas-temperature
  set color-type 5
  set color color-type
  set mass (10)  ; atomic masses of oxygen atoms
  hatch 1 [
    set breed arrowheads
    set hidden? true
    create-link-from myself [ tie ]
  ]
  set speed speed-from-energy
  set last-collision nobody
end 


; Place particles at random, but they must not be placed on top of wall atoms.
; This procedure takes into account the fact that wall molecules could have two possible arrangements,
; i.e. high-surface area ot low-surface area.

to random-position ;; particles procedure
  let open-patches nobody
  let open-patch nobody
  set open-patches patches with [not any? turtles-here and pxcor != max-pxcor and pxcor != min-pxcor and pycor != min-pycor and pycor != max-pycor]
  set open-patch one-of open-patches

  ; Reuven added the following "if" so that we can get through setup without a runtime error.
  if open-patch = nobody [
    user-message "No open patches found.  Exiting."
    stop
  ]

  setxy ([ pxcor ] of open-patch) ([ pycor ] of open-patch)
end 


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; wall penetration error handling procedure
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; if particles actually end up within the wall

to remove-from-walls
  let this-wall walls-here with [ not hidden? ]

  if count this-wall != 0 [
    let available-patches patches with [ not any? walls-here ]
    let closest-patch nobody
    if (any? available-patches) [
      set closest-patch min-one-of available-patches [ distance myself ]
      set heading towards closest-patch
      setxy ([ pxcor ] of closest-patch)  ([ pycor ] of closest-patch)
    ]
  ]
end 


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GRAPHS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;



;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;REPORTERS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to-report speed-from-energy
  report sqrt (2 * energy / mass)
end 

to-report energy-from-speed
  report (mass * speed * speed / 2)
end 

to-report limited-particle-energy
  let limited-energy energy
  if limited-energy > max-particle-energy [ set limited-energy max-particle-energy ]
  if limited-energy < min-particle-energy [ set limited-energy min-particle-energy ]
  report limited-energy
end 

to-report vibration-displacement
end 

to do-plots
  set-current-plot "Temperature of solids"
  if #-purple-particles > 0 [
    set-current-plot-pen "purple"
    plotxy ticks avg-energy-purple
  ]
    if #-orange-particles > 0 [
    set-current-plot-pen "orange"
    plotxy ticks avg-energy-orange
  ]
      if #-green-particles > 0 [
    set-current-plot-pen "green"
    plotxy ticks avg-energy-green
  ]
end 



; Copyright 2006 Uri Wilensky.
; See Info tab for full copyright and license.