Topographic variability and stability in lake food webs

;A simplified Lake Michigan Foodweb with Obstacles
globals [

  reproduce-energy-mid
  distinction
  
  energy-from-phytoplankton ;; keep track of how much phytoplankton there is
  phytoplankton-regrowth-time ;; how quickly phytoplankton grows back
  start-percent-phytoplankton
  phytoplankton-growth-rate ;; odds of phytoplankton spreading
   
  zooplankton-food-filter 
  zooplankton-start-amount 
  zooplankton-gain-from-food 
  zooplankton-reproduce 
  zooplankton-reproduce-energy
  
  oshrimp-food-filter 
  oshrimp-start-amount 
  a-oshrimp-gain-from-food 
  a-oshrimp-reproduce 
  a-oshrimp-reproduce-energy
  
  mollusks-food-filter 
  mollusks-start-amount 
  mollusk-gain-from-food 
  mollusk-reproduce 
  mollusk-reproduce-energy

  burbot-food-filter 
  burbot-start-amount 
  a-burbot-gain-from-food 
  a-burbot-reproduce 
  a-burbot-reproduce-energy
  
  round_gobys-food-filter
  round_gobys-start-amount 
  round_goby-gain-from-food 
  round_goby-reproduce
  round_goby-reproduce-energy
  
  top_preds-food-filter 
  top_preds-start-amount 
  top_pred-gain-from-food 
  top_pred-reproduce
  top_pred-reproduce-energy

  ignore-zooplankton
  ignore-oshrimp
  ignore-mollusks
  ignore-burbot 
  ignore-round_gobys
  ignore-top_preds
  invalid-food-web invaded?
]

breed [ phytoplankton a-phytoplankton ]
breed [ zooplankton a-zooplankton ]
breed [ oshrimp a-oshrimp ] 
breed [ mollusks mollusk ]
breed [ round_gobys round_goby ]
breed [ top_preds top_pred ]
breed [ burbot a-burbot ]

turtles-own [ energy ] 
patches-own [ countdown has-roots ]

to initialize
  clear-turtles
  clear-all-plots
  reset-ticks
  tick
    
  set zooplankton-start-amount 100
  set oshrimp-start-amount 50
  set mollusks-start-amount 100
  set burbot-start-amount 5
  set round_gobys-start-amount 15
  set top_preds-start-amount 0

  set invalid-food-web false
  
  ifelse zooplankton-start-amount = 0
   [ set ignore-zooplankton true]
   [ set ignore-zooplankton false]
  ifelse oshrimp-start-amount = 0
   [ set ignore-oshrimp true]
   [ set ignore-oshrimp false]
  ifelse mollusks-start-amount = 0
   [ set ignore-mollusks true]
   [ set ignore-mollusks false]
  ifelse burbot-start-amount = 0
   [ set ignore-burbot true]
   [ set ignore-burbot false]
  ifelse round_gobys-start-amount = 0
   [ set ignore-round_gobys true]
   [ set ignore-round_gobys false]
   ifelse top_preds-start-amount = 0
   [ set ignore-top_preds true]
   [ set ignore-top_preds false]
  set zooplankton-food-filter ""
  set oshrimp-food-filter ""
  set mollusks-food-filter ""
  set burbot-food-filter ""
  set round_gobys-food-filter ""
  set distinction 0
  
  parse-food-web
  setup-constants

  ifelse not invalid-food-web [
    ;; set globals
    set start-percent-phytoplankton 10
    set energy-from-phytoplankton 3
    set phytoplankton-regrowth-time 37
    set phytoplankton-growth-rate 3
    
    set zooplankton-gain-from-food 40 ;; zooplankton
    set zooplankton-reproduce 55
    set zooplankton-reproduce-energy 45
    
    set a-oshrimp-gain-from-food 10
    set a-oshrimp-reproduce 38.9
    set a-oshrimp-reproduce-energy 65
    
    set mollusk-gain-from-food 35
    set mollusk-reproduce 39
    set mollusk-reproduce-energy 10
  
    set a-burbot-gain-from-food 35
    set a-burbot-reproduce 38.2
    set a-burbot-reproduce-energy 48
    
    set round_goby-gain-from-food 35
    set round_goby-reproduce 38.2
    set round_goby-reproduce-energy 65
    
    set invaded? false
    set top_pred-gain-from-food 75
    set top_preds-start-amount 15
    set top_pred-reproduce 5
    set top_pred-reproduce-energy 55
    
  
  ;; create the phytoplankton, then initialize their variables
    set-default-shape phytoplankton "phytoplankton"
    ask patches [
      if pcolor != black [set pcolor blue + 2]
      if random 100 < start-percent-phytoplankton 
      [ sprout-phytoplankton 1 [ init-phytoplankton rt random 90 fd 0.5] ]
      ]
  
  ;; create the zooplankton, then initialize their variables
    set-default-shape zooplankton "zooplankton"
    populate-zooplankton zooplankton-start-amount true
    
  ;; create the oshrimp, then initialize their variables
    set-default-shape oshrimp "oshrimp"
    populate-oshrimp oshrimp-start-amount true
    
  ;; create the mollusks, then initialize their variables
    set-default-shape mollusks "mollusk"
    populate-mollusks mollusks-start-amount true
  
  ;; create the burbot, then initialize their variables
    set-default-shape burbot "black fish"
    populate-burbot burbot-start-amount true
  
    set-default-shape round_gobys "roundgoby"
    populate-round_gobys round_gobys-start-amount true
    
    set-default-shape top_preds "big fish"
    
    update-plot
  ]
  [ ;; (for this model to work with NetLogo's new plotting features,
  ;; __clear-all-and-reset-ticks should be replaced with clear-all at
  ;; the beginning of your setup procedure and reset-ticks at the end
  ;; of the procedure.)
    set invalid-food-web true]
end 

to setup-constants
   set reproduce-energy-mid 75
end 

to go
  if 0 = ticks [ user-message "Please press the 'Setup' button" stop ]
  ifelse invalid-food-web [ user-message "You need to update your food web and press set up" stop ]
  [
  if not any? zooplankton and not ignore-zooplankton [
    ifelse user-yes-or-no? "No more zooplankton in this part of the harbor.\nHave a new zooplankton scuttle in?"
    [ populate-zooplankton 1 false ]
    [ set ignore-zooplankton true ]
  ]
  if not any? oshrimp and not ignore-oshrimp [
    ifelse user-yes-or-no? "No more oshrimp in this part of the harbor.\nHave a new oshrimp swim in?"
    [ populate-oshrimp 1 false ]
    [ set ignore-oshrimp true ]
  ]
  if not any? mollusks and not ignore-mollusks [
    ifelse user-yes-or-no? "No more mollusks in this part of the harbor.\nHave a new mollusk swim in?"
    [ populate-mollusks 1 false ]
    [ set ignore-mollusks true ]
  ]
  if not any? round_gobys and not ignore-round_gobys [
    ifelse user-yes-or-no? "No more round gobys in this part of the harbor.\nHave a new round goby swim in?"
    [ populate-round_gobys 1 false ]
    [ set ignore-round_gobys true ]
  ]
  if not any? top_preds and not ignore-top_preds [
    ifelse user-yes-or-no? "No more top preds in this part of the harbor.\nHave a new top pred swim in?"
    [ populate-top_preds 1 false ]
    [ set ignore-top_preds true ]
  ]
  if not any? burbot and not ignore-burbot [
    ifelse user-yes-or-no? "No more burbots in this part of the harbor.\nHave a new burbot swim in?"
    [ populate-burbot 1 false ]
    [ set ignore-burbot true ]
  ]
  ask zooplankton [
    moveslow
    set energy energy - 0.1
    eat zooplankton-food-filter
    death
    reproduce-zooplankton
  ]
  ask oshrimp [
    avoid-obstacles
    move
    set energy energy - 0.1
    eat oshrimp-food-filter
    death
    reproduce-oshrimp
    
  ]
  ask mollusks [
    moveslow
    set energy energy - 0.07
    eat mollusks-food-filter
    death
    reproduce-mollusks
  ]
  ask round_gobys [
    avoid-obstacles
    movefast
    set energy energy - 0.5
    eat round_gobys-food-filter
    death
    reproduce-round_gobys
     ]
  
  ask top_preds [
    avoid-obstacles
    movefaster
    set energy energy - 2
    eat top_preds-food-filter
    death
    reproduce-top_preds
      ]
  
  ask burbot [
    avoid-obstacles
    movefaster
    set energy energy - 0.5
    eat burbot-food-filter
    death
    reproduce-burbot
  ]

  grow-phytoplankton
  tick
  update-plot
  ]
end 

to populate-zooplankton [ census random? ]
  create-zooplankton census
  [
    set color blue
    set size 2  ;; easier to see
    set label-color blue - 2
    ifelse random?
    [ set energy random (2 * zooplankton-gain-from-food) ]
    [ set energy zooplankton-gain-from-food ]
    
     setxy random-xcor random-ycor
   
  ]
end 

to populate-mollusks [ census random? ]
  create-mollusks census
  [
    set color brown
    set size 1  ;; easier to see
    ifelse random?
    [ set energy random (2 * mollusk-gain-from-food) ]
    [ set energy mollusk-gain-from-food ]
   
    setxy random-xcor random-ycor
  ]
end 

to populate-oshrimp [ census random? ]
  create-oshrimp census
  [
    set color black
    set size 2  ;; easier to see
    ifelse random?
    [ set energy random (2 * a-oshrimp-gain-from-food) ]
    [ set energy a-oshrimp-gain-from-food ]
   
    setxy random-xcor random-ycor
    ask oshrimp with [ pcolor = black ] [ fd 15 ]
  ]
end 

to populate-burbot [ census random? ]
  create-burbot census
  [
    set color black
    set size 2  ;; easier to see
    ifelse random?
    [ set energy random (2 * a-burbot-gain-from-food) ]
    [ set energy a-burbot-gain-from-food ]
   
    setxy random-xcor random-ycor
    ask burbot with [ pcolor = black ] [ fd 15 ]
  ]
end 

to populate-round_gobys [ census random?]
  create-round_gobys census
  [
    set color red
    set size 2  ;; easier to see
    ifelse random?
    [ set energy random (2 * round_goby-gain-from-food) ]
    [ set energy round_goby-gain-from-food ]
    
    setxy random-xcor random-ycor 
    ask round_gobys with [ pcolor = black ] [ fd 15 ]
    
  ]
end 

to populate-top_preds [ census random?]
  create-top_preds census
  [
    set invaded? true
    set color yellow - 1
    set size 3  ;; easier to see
    ifelse random?
    [ set energy random (2 * top_pred-gain-from-food) ]
    [ set energy top_pred-gain-from-food ]
    
    setxy random-xcor random-ycor  
    ask top_preds with [ pcolor = black ] [ fd 15 ] 
  ]
end 

to avoid-obstacles
    if (any? patches in-cone 3 120 with [pcolor = black])
    [ rt 90 ] 
end 

to make-obstacle
  if mouse-down?
  [ ask patches
    [ if ((abs (pxcor - mouse-xcor)) < 4) and ((abs (pycor - mouse-ycor)) < 4)
      [ set pcolor black ]]]
  display
end 

to eraser
  if mouse-down?
  [ ask patches
    [ if ((abs (pxcor - mouse-xcor)) < 2) and ((abs (pycor - mouse-ycor)) < 2)
      [ set pcolor blue + 2 ]]]
  display
end 

to revert
  clear-all
  reset-ticks
  ask patches [ set pcolor blue + 2 ]
end 

to move  ;; turtle procedure
  if pcolor = black [fd 10]
  if pcolor != black
  [
  rt random 90
  lt random 90
  fd 0.5
  ]
end 

to moveslow  ;; turtle procedure
  rt random 45
  lt random 45
  fd 0.1
end 

to movesuperslow  ;; turtle procedure
  rt random 55
  lt random 55
  fd 0.05
end 

to movefast 
  if pcolor = black [fd 10]
  if pcolor != black
  [ 
  rt random 35
  lt random 35
  fd 1
  ]
end 

to movefaster
  if pcolor = black [fd 10]
  if pcolor != black
  [
  rt random 30
  lt random 30
  fd 2
  ]
end 

to eat [ is-food ] ; turtle routine
  if "" != is-food [
    let prey one-of turtles-here with [ run-result is-food ]
    if prey != nobody  and random-normal 10 5 > 2[
        eat-eat prey
    ]
  ]
end 

to eat-eat [prey] ; turtle routine
  set energy ( energy + [energy] of prey )
  ask prey [ die ]
end 

to reproduce-zooplankton  ;; zooplankton procedure
  if energy > zooplankton-reproduce-energy and random-normal 50 5 < zooplankton-reproduce [  ;; throw "dice" to see if you will reproduce
    set energy (energy / 2)                ;; divide energy between parent and offspring
    
    hatch 1 [ rt random-float 360 fd 1 ]   ;; hatch an offspring and move it forward 1 step
  ]
end 

to reproduce-oshrimp  ;; a-oshrimp procedure
  if energy > a-oshrimp-reproduce-energy and random-normal 50 5 < a-oshrimp-reproduce [  ;; throw "dice" to see if you will reproduce
    set energy (energy / 2)               ;; divide energy between parent and offspring
    
    hatch 1 [ rt random-float 360 ]  ;; hatch an offspring and move it forward 1 step
  ]
end 

to reproduce-mollusks  ;; mollusk procedure
  if energy > mollusk-reproduce-energy and random-normal 50 5 < mollusk-reproduce [  ;; throw "dice" to see if you will reproduce
    set energy (energy / 2)               ;; divide energy between parent and offspring
    
    hatch 1 [ rt random-float 360 fd 1 ]  ;; hatch an offspring and move it forward 1 step
  ]
end 

to reproduce-burbot  ;; a-burbot procedure
  if energy > a-burbot-reproduce-energy and random-normal 50 5 <  a-burbot-reproduce   [  ;; throw "dice" to see if you will reproduce
    set energy (energy / 2)               ;; divide energy between parent and offspring
    
    hatch 1 [ rt random-float 360 fd 2 ]  ;; hatch an offspring and move it forward 1 step
  ]
end 

to reproduce-round_gobys  ;; round_goby procedure
  if energy > round_goby-reproduce-energy and random-normal 50 5 <  round_goby-reproduce  [  ;; throw "dice" to see if you will reproduce
    set energy (energy / 2)               ;; divide energy between parent and offspring
    
    hatch 1 [ rt random-float 360 fd 2]  ;; hatch an offspring and move it forward 1 step
  ]
end 

to reproduce-top_preds  ;; round_goby procedure
  if energy > top_pred-reproduce-energy and random-normal 50 5 < top_pred-reproduce [  ;; throw "dice" to see if you will reproduce
    set energy (energy / 2)               ;; divide energy between parent and offspring
    
    hatch 1 [ rt random-float 360 fd 1]  ;; hatch an offspring and move it forward 1 step
  ]
end 

to death  ;; turtle procedure
  ;; when energy dips below zero, die
  if energy < 0 [ die ]
end 

to setup-phytoplankton
  ask patches with [ has-roots ] [
    sprout-phytoplankton 1 [
      init-phytoplankton
    ]
  ]
end 

to init-phytoplankton
  set energy energy-from-phytoplankton
  set size 0.6
  set color green
end 

to grow-phytoplankton
  ask phytoplankton
  [
    ask patch-here [ ask neighbors [
      if ( 0 = count phytoplankton-here ) and  random-normal 50 5 < phytoplankton-regrowth-time [ 
        sprout-phytoplankton 1 [ init-phytoplankton fd 0.5 ]
      ]
    ] ]
  ]
end 

to update-plot
  set-current-plot "Population Size"
  set-current-plot-pen "phytoplankton / 4"
  plot count phytoplankton / 4  ;; divide by four to keep it within similar
                       ;; range as a-burbot and zooplankton populations
  set-current-plot-pen "Zooplankton"
  plot count zooplankton 
  set-current-plot-pen "Oshrimp"
  plot count oshrimp
  set-current-plot-pen "Mollusks"
  plot count mollusks
  set-current-plot-pen "Burbots"
  plot count burbot
  set-current-plot-pen "Round Gobys"
  plot count round_gobys
  set-current-plot-pen "Top Preds"
  plot count top_preds
end 


; ===============================================
; ====== food web parser functions ==============
; ===============================================

to parse-food-web
  let web_description to-lower-string Food-Web
  let temp ""
  while [ not empty? web_description ]
  [
    ifelse member? "\n" web_description
    [
      set temp substring web_description 0 ( position "\n" web_description )
      update_filter temp
      set web_description remove word temp "\n" web_description
    ]
    [
      update_filter web_description
      set web_description ""
    ]
  ]
  if not invalid-food-web [
    if not empty? burbot-food-filter [
      set burbot-food-filter word "(" word substring burbot-food-filter 4 length burbot-food-filter ")"
    ]
    if not empty? top_preds-food-filter [
      set top_preds-food-filter word "(" word substring top_preds-food-filter 4 length top_preds-food-filter ")"
    ]
    if not empty? round_gobys-food-filter [
      set round_gobys-food-filter word "(" word substring round_gobys-food-filter 4 length round_gobys-food-filter ")"
    ]
    if not empty? zooplankton-food-filter [
      set zooplankton-food-filter word "(" word substring zooplankton-food-filter 4 length zooplankton-food-filter ")"
    ]
    if not empty? oshrimp-food-filter [
      set oshrimp-food-filter word "(" word substring oshrimp-food-filter 4 length oshrimp-food-filter ")"
    ]
    if not empty? mollusks-food-filter [
      set mollusks-food-filter word "(" word substring mollusks-food-filter 4 length mollusks-food-filter ")"
    ]
  ]
end 

to update_filter [ update ]
  ;; this function could be improved by testing
  ;; update is of the form member? valid-species "eat/eats" valid-species
  ;; and then throw out impossibilites of cannibalism or phytoplankton predators

  let bb [ "burbot eat " "burbots eat " "burbot eats " ]
  let cf  [ "zooplankton eat " "zooplankton eats " ]
  let os  [ "oshrimp eat " "oshrimp eats " ]
  let mf  [ "mollusks eat " "mollusk eat " "mollusk eats " ]
  let rgf [ "round gobys eat " "round goby eat " "round goby eats " ]
  let tpf [ "top preds eat " "top pred eat " "top pred eats " ]
  let pf  [ "phytoplankton eat " "phytoplankton eats " ]
  
  let valid-species [ "phytoplankton" "zooplankton" "round gobys" "top preds" "mollusks"  "oshrimp" "burbot" ]

  let menu_item ""
  let match ""
  
  ifelse not predator-starts-string update valid-species [
    user-message word "The predator at line '" (word update "'. is misspelled") set invalid-food-web true 
  ]
  [
    set match multimatch bb update
    if match != ""
    [
      set burbot-food-filter check_web_item match update "burbot" valid-species burbot-food-filter
    ]
    set match multimatch rgf update
    if match != ""
    [
      set round_gobys-food-filter check_web_item match update "round gobys" valid-species round_gobys-food-filter
    ]
    set match multimatch tpf update
    if match != ""
    [
      set top_preds-food-filter check_web_item match update "top preds" valid-species top_preds-food-filter
    ]
    set match multimatch cf update
    if match != ""
    [
      set zooplankton-food-filter check_web_item match update "zooplankton" valid-species zooplankton-food-filter
    ]
    set match multimatch os update
    if match != ""
    [
      set oshrimp-food-filter check_web_item match update "oshrimp" valid-species oshrimp-food-filter
    ]
    set match multimatch mf update
    if match != ""
    [
      set mollusks-food-filter check_web_item match update "mollusks" valid-species mollusks-food-filter
    ]
    
    if "" != multimatch pf update
    [
      user-message "Biologically impossible. Please edit your food web."
      set invalid-food-web true
    ]
  ]
end 

to-report predator-starts-string [ s valid-species ]
  let length-of-longest-name length last sort-by [ length ?1 < length ?2 ] valid-species
  let test ""
  foreach n-values length-of-longest-name [item ? s] [ 
    set test word test ?
    if member? test valid-species [ report true ]
  ]
  report false
end 

to-report check_web_item [ match update predator valid-targets food-filter ]
    let menu_item remove match update
    if menu_item = predator
      [ user-message "No cannibalism. Please edit your food web." set invalid-food-web true ]
    if not member? menu_item valid-targets
      [ user-message word "The prey at line '" (word update "' is misspelled.") set invalid-food-web true ]
    ifelse not invalid-food-web
      [ set menu_item remove_spaces menu_item 
        report word food-filter word " or breed = " menu_item ]
      [ report food-filter ]
end 

; ======================================
; ====== String functions ==============
; ======================================

to-report multimatch [ testlist target ]
  let match ""
  set match filter [member? ? target] testlist
  ifelse not empty? match 
  [ report first match ]
  [ report "" ]
end 

to-report to-lower-string [s]
let lower ""
foreach n-values length s [item ? s] [ set lower word lower to-lower ? ]
report lower
end 

to-report to-lower [c] ; c is single character string
let i position c "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
report ifelse-value (is-number? i) [item i
"abcdefghijklmnopqrstuvwxyz"][c]
end 

to-report remove_spaces [string]
  while [ member? " " string ]
  [
    set string replace-item (position " " string) string "_"
  ]
  report string
end 

; Copyright 2010 Northwestern University's Office of STEM Eeducation Partnerships
; based on code by Uri Wilenksy (c) 1997
; The full copyright notice is in the Information tab.