Education as a signal of ability Final

breed [ workers worker ]
breed [ firms firm ]

globals [
  tiers ;; stores the who of workers with certain levels of education
  req-education ;; stores the required education of workers for each tier
]

patches-own [
  tier-nbr
  firm-nbr
]

workers-own [
  offer ;; the greatest amount of money the worker has been offered
  pemployer ;; the potential employer of the worker
  ability
  salary
  education
  utility
  employer
  ecost
  expected-utility ;; expected utility of each tier
]

firms-own [
  sales ;; yearly sales the firm raises per tier
  cost ;; cost of operating per tier
  marginal-cost
  marginal-benefit
  wage-schedule ;; wage schedule
  revenue ;; revenue
]

to setup
  ca ;; clear all
  set tiers n-values types [ (list 1) ]
  set req-education n-values types [ 0 ]
  set-default-shape workers "person"
  setup-patches
  setup-workers ;; worker setup procedure
  setup-firms ;; firm setup procedure
  update-tiers
  setup-expected-utility
end 

to setup-workers
  create-workers number-of-workers[
    setxy random-xcor random-ycor
    set ability ((random types) * 4 + 1)
    set education random-float types * 2
    set pemployer nobody
    set expected-utility n-values types [ 0 ]
    set color scale-color blue ability 0 (types * 4 + 1)
  ]
end 

to setup-firms
  create-firms number-of-firms [
    set revenue n-values types [0]
    set cost n-values types [0]
    set sales n-values types [0]
    set marginal-cost n-values types [0]
    set marginal-benefit n-values types [0]
    set size 2
    set hidden? true
    setup-wage-schedule
  ]
end 

to setup-expected-utility
  ask workers [
    foreach n-values types [?] [
      let expected-wage item ? [wage-schedule] of one-of firms
      let expected-educ item ? req-education
      set expected-utility replace-item ? expected-utility 
      ( expected-wage - expected-educ ^ education-difficulty / ability )
    ]
  ]
end 

to setup-patches
  let yinterval (max-pycor - min-pycor) / number-of-firms
  let xinterval (max-pxcor - min-pxcor) / types
  foreach n-values number-of-firms [?] [
    let i ? + 1
    ask patches with [pycor - min-pycor <= i * yinterval and pycor - min-pycor >= (i - 1) * yinterval ] [
      set pcolor 3 + ? * 10
      set firm-nbr item ? n-values number-of-firms [? + number-of-workers] 
    ]]
  foreach n-values types [?] [
    let i (? + 1)
    ask patches with [pxcor - min-pxcor <= i * xinterval and pxcor - min-pxcor >= (i - 1) * xinterval ] [
      set tier-nbr ?
    ]
    ask patches [
      set pcolor scale-color pcolor tier-nbr -2 (number-of-firms + 3)
  ]]
end 

;; we must assume that firms will give higher wages to people with more education

to setup-wage-schedule ;; firm procedure
  set wage-schedule n-values types [random-float types * initial-wage-difference]
  foreach n-values (types - 1) [?] 
  [ if ((item (? + 1) wage-schedule) - (item ? wage-schedule) < initial-wage-difference) [ setup-wage-schedule ] ]
end 

to-report tier-of-worker [ n ] ;; reports the tier of the worker given his who number
  foreach tiers 
  [ if (member? [who] of worker n ? = true) [ report position ? tiers ] ]
end 

to-report workers-in-tier [ n ] ;; reports an agentset of the nth tier
  report workers with [ member? [who] of self item n tiers ]
end 

;; From here the go procedure
;;  First, workers start with their initial values of education. Then, firms go and 
;;  make offers to workers. Next, workers accetp the highest offer. Now, workers and firms 
;;  calculate their utilities.

to go
  ask firms 
  [ update-tiers
    offer-wage ]
  ask workers 
  [ accept-offer
    update-utility
    update-expected-utility 
    ;move 
    ]
  ask firms 
  [ observe-performance 
    update-wage-schedule ]
  ask workers [ 
    update-education 
    move
  ]
  update-plots
  tick
end 

to move 
  foreach n-values types [?] [
    ask workers-in-tier ? [
      if ([tier-nbr] of patch-here != tier-of-worker who) 
      [ move-to one-of patches with [tier-nbr = tier-of-worker [who] of myself] ]
      ifelse (employer != nobody)
      [ if ([firm-nbr] of patch-here != [who] of employer )
        [ move-to one-of patches with [tier-nbr = tier-of-worker [who] of myself and firm-nbr = [who] of [employer] of myself]] ]
      [ setxy min-pxcor min-pycor ] ;do nothing
      ]
    ]
end 

to get-education
  set education education + 1
  set ecost education ^ education-difficulty / ability
end 

to update-tiers ;; need to check if this works!!
  foreach n-values (types - 1) [?] [
    let a item ? req-education
    let b item (? + 1) req-education
    let this-tier [who] of workers with [education < b and education >= a]
    set tiers replace-item ? tiers this-tier
  ]
  let last-req last req-education
  let last-tier [who] of workers with [education >= last-req]
  set tiers replace-item (types - 1) tiers last-tier
  ;; now set the minimum level of education for each tier
  foreach n-values types  [?] [
;    if (any? workers-in-tier ?)
    set req-education replace-item ? req-education (0 + tier-length * ?) 
;    [ set mean-education-of-tiers replace-item ? req-education (mean [education] of workers-in-tier ?) ]
  ]
end 

to offer-wage ;; firm procedure
  foreach n-values types [?] ;; for 1, 2, 3, ..., types. This is just a counting variable
  [
    let num ? ;; set num as a counting variable of the current number
    let w item num [wage-schedule] of self ;; wage-schedule = [w1 w2 w3]. num denotes current w.
    let T item num tiers ;; tiers = [T1 T2 T3]. num denotes current T
    foreach T [ ;; for T1, T2, ...
      ask worker ? [
        let temp w ;; offer wage of w
        if [offer] of self <= temp
        [ set offer temp 
          set pemployer myself ]]
  ]]
end 

to accept-offer 
    set salary offer
    set employer pemployer
;    set employed? true
    set pemployer nobody
    set offer 0
end 

to observe-performance ;; firm procedure
  foreach n-values types [?] [ ;; for each tier
    if (any? (workers-in-tier ?) with [employer = myself]) [
      let sum-salaries sum [salary] of (workers-in-tier ?) with [employer = myself]
      let sum-abilities sum [ability] of (workers-in-tier ?) with [employer = myself]
      let num-workers count (workers-in-tier ?) with [employer = myself]
      set cost replace-item ? cost sum-salaries
      set sales replace-item ? sales sum-abilities
      set marginal-cost replace-item ? marginal-cost (sum-salaries / num-workers)
      set marginal-benefit replace-item ? marginal-benefit (sum-abilities / num-workers)
    ]
  ]
  set revenue (map [?1 - ?2] sales cost)
end 

to update-wage-schedule ;; firm procedure
  foreach n-values types [?] [
    let sum-ability sum [ability] of workers-in-tier ? ;; workers with their who number included in subtier
    let sum-salary sum [salary] of workers-in-tier ?
    ;; this is for the profit maximizing firm that tries to balance the wages with costs
    if (firm-type = "equate sales and cost") 
    [ 
      if (sum-salary >= sum-ability) [ set wage-schedule replace-item ? wage-schedule (item ? wage-schedule - step-size) ]
      if (sum-salary < sum-ability) [ set wage-schedule replace-item ? wage-schedule (item ? wage-schedule + step-size) ] 
    ]
    ;; this is for the marginal firm
    if (firm-type = "marginal analysis") 
    [
      ifelse (item ? marginal-cost > item ? marginal-benefit) 
        [set wage-schedule replace-item ? wage-schedule (item ? wage-schedule - step-size) ]
        [if (item ? marginal-cost < item ? marginal-benefit)
          [ set wage-schedule replace-item ? wage-schedule (item ? wage-schedule + step-size) ] 
        ]
    ]
    ;; this is for the rewarding firm
    if (firm-type = "rewarding company") 
    [ 
      if (sum-salary >= sum-ability) [ set wage-schedule replace-item ? wage-schedule (item ? wage-schedule + step-size) ]
      if (any? workers-in-tier ? = false) [ set wage-schedule replace-item ? wage-schedule (item ? wage-schedule + step-size) ] 
    ]
    ;; this is for the penalizing firm
    if (firm-type = "punishing company")
    [
      if (sum-salary < sum-ability) [ set wage-schedule replace-item ? wage-schedule (item ? wage-schedule - step-size) ]
      if (any? workers-in-tier ? = false) [ set wage-schedule replace-item ? wage-schedule (item ? wage-schedule + step-size) ]
    ]
  ]
end 

to update-expected-utility
  foreach n-values types [?] [ ;; for n = [ 0 ... types ]
    ifelse (tier-of-worker who = ?) 
    ;; if the worker is in tier n
    [ set expected-utility replace-item ? expected-utility utility ];; set his expected utility 
    ;; if the worker is not in tier n
    [ if (any? workers-in-tier ?) [
      let mean-education item ? req-education 
      let observed-salary [salary] of one-of workers-in-tier ?
      let observed-utility (observed-salary - mean-education ^ education-difficulty / ability)
      set expected-utility replace-item ? expected-utility observed-utility ] ]
  ]
end 

to update-utility;; worker procedure
  set ecost education ^ education-difficulty / ability
  set utility salary - ecost
end 

;; workers optimize their education incrementally if they are in their highest earning bracket
;; but if not, they move to their highest earning bracket.

to update-education ;; worker procedure
  let my-tier tier-of-worker who
  let optimal-tier position (max expected-utility) expected-utility
  ifelse (optimal-tier = my-tier) 
  ;; if i am in the highest earning bracket
  [ ifelse (utility > 0) 
    [ if (education >= step-size and education > min [education] of workers-in-tier my-tier) [set education education - step-size ]]
    [ set education education + step-size ]  ]
  ;; if i am not in the highest earning bracket
  [ set education item optimal-tier req-education ]
end 

to update-plots
  set-current-plot "Wage vs. Tier"
  plot-pen-reset
  foreach n-values types [?] [
    if (any? workers-in-tier ?) 
    [ plotxy ? mean [salary] of workers-in-tier ? ]
  ]
  
  set-current-plot "Education vs Tiers"
  plot-pen-reset
  foreach n-values types [?] [
    if (any? workers-in-tier ?) 
    [ plotxy ? mean [education] of workers-in-tier ?]
  ]
  
  set-current-plot "Ability vs Tiers"
  plot-pen-reset
  foreach n-values types [?] [
    if (any? workers-in-tier ?) 
    [ plotxy ? mean [ability] of workers-in-tier ?]
  ]
  
  set-current-plot "Mean Educations"
  plot-pen-reset
  foreach n-values types [?] [
    if (any? workers-in-tier ?) 
    [ plotxy ? mean [education] of workers-in-tier ?]
  ]
  
  set-current-plot "Utilities by Firm"
  plot-pen-reset
  foreach n-values number-of-firms [?] [
    plotxy ? sum [revenue] of firm (? + number-of-workers)
  ]  
end