;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Variable and Breed declarations ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

globals
[
  ;; holds the actual value used to determine how many patches should choose 
  ;; target-color.  this is set when the setup or rerun buttons are pressed.
  ;; if random-rerun? is true, this will be set to a random value from 0 to 100.
  ;; otherwise, this is set to whatever the current value of %-target-color is.
  real-%-target-color
  
  ;; Users guess the % of target-color in the population
  target-color  ;; set to green currently
  other-color  ;; set to blue currently
  hide-patch-color  ;; the color that patches are colored when they are not revealed

  ;; holds the number of patches in the observer's last sample
  num-patches-in-observer-sample
  ;;  holds the number of target color patches in the observer's last sample
  num-target-color-patches-in-observer-sample

  ;; if you were to segregate the patches by color, target-color to the left and
  ;; other-color to the right, you would create a contour line at appoximately
  ;; xcor-of-organize-contour
  xcor-of-organize-contour

  max-$$  ;; the starting value for $$-remaining for the clients
  
  ;; variables for storing various statistics of guesses
  guesses-list  ;; list of all the clients guesses for this current population
  guess-average  ;; the average of all the students' guesses
  averages-list  ;; list of all the averages since we last pressed rerun or setup
  
  ;; various indicators of procedure status.
  revealing?  ;; true if population is revealed; false otherwise
  can-collect-more-data?  ;; true if we want to collect more data for this population
  have-committed?  ;; true if the commit button has been pressed before the plot guesses button was
  have-plotted?  ;; true if we have already called plotted data for this population
  
  ;; quick start instructions variables:
  quick-start   ;; the current quickstart instruction displayed in the quickstart monitor
  qs-item       ;; the index of the current quickstart instruction
  qs-items      ;; the list of quickstart instructions
]
patches-own
[
  my-color  ;; variables for when user toggles between samples and reveal displays
  
  ;; a list of the users (including the observer/instructor/server and all active clients)
  ;; that have this patch in their current sample
  agents-with-me-in-sample
]
breeds
[
  frames     ;; cause patches to have a thin frame surrounding them
  gatherers  ;; turtles that execute the special distributions that deviate from normal distribution
  clients    ;; each student is assigned a turtle that monitors the student's input

  ;; if a student logs in late, get assigned a pending client until rerun or 
  ;; more data is pressed at which time it is converted into a client.
  pending-clients
]
clients-own
[
  user-id  ;; unique id, input by the client when they log in, to identify each student turtle
  temp-my-guess  ;; the current value of the my-guess-for-this-sample slider on the hubnet client
  final-my-guess  ;; the value of temp-my-guess when the accumulate-data is called
  my-sample-block-side  ;; the current value of the my-sample-block-side slider on the hubnet client
  my-sampling-allowance  ;; the current number of patches that the client can still sample
  have-sampled?  ;; true if the client has sampled in the graphics window
  temp-go-with-group-guess?  ;; the current value of the go-with-group-guess? switch on the hubnet client
  final-go-with-group-guess?  ;; the value that temp-go-with-group-guess? had when the commit button was pressed

  ;; holds the amount of money the clients have.  this can be set to max-$$ by
  ;; pressing the replenish $$ button
  $$-remaining
]

pending-clients-own
[
  user-id  ;; unique id, input by the client when they log in, to identify each student turtle
]
 

;;;;;;;;;;;;;;;;;;;;;
;; Setup Functions ;;
;;;;;;;;;;;;;;;;;;;;;

to startup
  hubnet-set-client-interface "COMPUTER" [ "clients/Sampler client.nlogo" ]
  hubnet-reset
  initialize true
  setup-quick-start
end

;; setup the model to be used
to initialize [ full-setup? ]
  no-display
  clear-plot
  initialize-variables
  initialize-patches
  hide-frames
  abonormality-distribution
  initialize-clients full-setup? ;; hubnet code
  display
end

;; initialize-variables when rerunning or setting up
to initialize-variables
  set revealing? false
  set max-$$ 100
  
  init-color-vars

  ;; the contour line between colors will be at a location proportionate to the 
  ;; real-%-target-color of screen-size-x.  for example, if real-%-target-color 
  ;; is 70 then about 70% of the Graphics Window will be solid target-color 
  ;; beginning from the left and extending to the right.
  set xcor-of-organize-contour (- screen-edge-x) + (real-%-target-color * screen-size-x / 100)
  set averages-list []

  ;; set values used by monitors
  set show-sample-%? false
  set show-pop-%? false
  
  start-over-variables
end

;; initialize the color-related variables
to init-color-vars
  set target-color 55
  set other-color 104
  set hide-patch-color 3
  ifelse random-rerun?
  [
    set real-%-target-color random 101
    set %-target-color 0
  ]
  [ set real-%-target-color %-target-color ]
end

;; initialize variables that are needed when collecting a set of data for the
;; current population
to start-over-variables
  set num-patches-in-observer-sample 0
  set num-target-color-patches-in-observer-sample 0
  set guesses-list []
  set guess-average 0
  set have-plotted? false
  set can-collect-more-data? false
  set have-committed? false
end

;; initialize patch variables
to initialize-patches
  set-default-shape frames "frame"
  ask patches
  [
    initialize-patch-colors
    set agents-with-me-in-sample []
    create-frames
  ]
end

;; initialize patches colors.  this is where the patches determine whether they 
;; are target-color or other-color
to initialize-patch-colors  ;; patch procedure
  set pcolor hide-patch-color  ;; default color of patches when not revealed
  ;; each patch "throws a die" to determine if it's target-color or other-color
  ifelse random-float 100.0 < real-%-target-color
  [ set my-color target-color ]
  [ set my-color other-color ]
end

;; each patch creates a frame which give the optional grid appearance
to create-frames  ;; patch procedure
  if not any? frames-here
  [
    sprout 1
    [
      set breed frames
      ht
    ]
  ]
end

;; ask all the frames to hide, even if grid? is true
to hide-frames
  ask frames
  [ ht ]
end

;; create and kill gatherers which modify the bi-linear random distribution of 
;; target-color and other-color patches in the population.  in other words, it 
;; creates turtles which clump like-colored patches
to abonormality-distribution
  create-custom-gatherers (4 + random 4)  ;; create gatherers
  [
    ht
    setxy (random-float screen-size-x) (random-float screen-size-y)
    rt random-float 360.0
    gather
    die
  ]
end

;; clump like-colored patches by swapping patch colors from progressively 
;; further patches around your location based on the abnormality slider
to gather  ;; gatherer procedure
  locals
  [
    index
    a-patch
    another-patch
  ]
  set index ( 20 * abnormality )
  while [ index > 0 ]
  [
    set a-patch random-one-of patches in-radius 16 with [ my-color = target-color ]
    set another-patch random-one-of patches in-radius 8 with [ my-color = other-color ]
    if (a-patch != nobody and another-patch != nobody)
    [ swap-my-color a-patch another-patch ]
    set index (index - 1)
  ]
end

;; swap my-colors between two patches
to swap-my-color [ a-patch another-patch ]
  locals [ color-buffer ]
  set color-buffer my-color-of a-patch
  set (my-color-of a-patch) (my-color-of another-patch)
  set (my-color-of another-patch) color-buffer
end

;; setup the model for use.  this kills all the turtles and should only be used 
;; with a new group
to setup
  if (user-yes-or-no? ("Are you sure you want to setup? This will cause all " + 
                      "data to be lost.  If you just want to start another " + 
                      "round of guesses then press MORE DATA and if you want " 
                      + " a new population then press RERUN"))
  [
    ;; use no-display here so that we aren't sending the graphics window 
    ;; to the clients while doing ca
    no-display
    ca
    initialize true ;; initialize turns back on the display
    setup-quick-start
  ]
end

;; setup the model for use.  this doesn't kill all the turtles and so should be 
;; used if you want to create a new population for the current set of clients.
to rerun
  if user-yes-or-no? "This will create a new population. Is this what you really want?"
  [ initialize false ]
end

;; setup the model for use.  this keeps the current population and set of 
;; turtles, but sets up the model so that more data can be collected on the 
;; current population.
to more-data
  if ( not any? clients ) or ( not can-collect-more-data? ) or ( not alert-no-rerun? )
  [ stop ]
  no-display
  start-over-patches
  set averages-list fput guess-average averages-list
  start-over-plot
  start-over-variables
  start-over-clients  ;; hubnet code
  ;; don't turn on the display if we are keeping the samples since 
  ;; otherwise all the clients could see everybody else's samples
  if not keep-samples?
  [ display ]
end

;; make sure that the user really wants to use the same population
to-report alert-no-rerun?
  report user-yes-or-no? ("You haven't pressed the RERUN button, so you'll have"
                          + " the same population.  Is this ok with you?")
end

;; prepare the patches to be sampled with the same population
to start-over-patches
  ask patches
  [
    set pcolor hide-patch-color
    ;; don't clear the agents-with-me-in-sample list if we are keeping the samples
    if not keep-samples?
    [ set agents-with-me-in-sample [] ]
  ]
  hide-frames
end

;; plot means and mean of means
to start-over-plot
  locals
  [ list-counter ]
  clear-plot
  set-current-plot-pen "means"
  set list-counter 0
  ;; plot a line for each item in averages-list
  repeat length averages-list                                
  [
    ppu
    plotxy (item list-counter averages-list)  0
    ppd
    plotxy (item list-counter averages-list) 25
    set list-counter list-counter + 1
  ]
  ;; if there are at least 2 items in averages-list, plot the mean of all the items
  if length averages-list > 1
  [
    set-current-plot-pen "mean-of-means"
    ppu
    plotxy mean averages-list 0
    ppd
    plotxy mean averages-list 25
  ]
end


;;;;;;;;;;;;;;;;;;;;;;;
;; Runtime Functions ;;
;;;;;;;;;;;;;;;;;;;;;;;

;; if the user clicks in the graphics window, take a sample where the click 
;; occurred.  the size of the sample depends upon the current value of the 
;; sample-block-side slider
to sample
  if mouse-down?
  [
    without-interruption
    [
      ;; we use no-display here for efficiency.  we assume that if the 
      ;; user is taking a sample then all clients should know about that 
      ;; sample.  this is why we turn the display back on at the end.
      no-display
      change-sample (round mouse-xcor) (round mouse-ycor) sample-block-side "observer"
      display
    ]
  ]
end

;; based on input, create the chosen sample and have all patches in it set pcolor to my-color
to change-sample [ x y block-side agent ]
  locals
  [
    ;; the patches in the currently chosen sample, if no sample has been chosen, 
    ;; this is nobody
    patches-in-sample
  ]
  set patches-in-sample nobody
  set revealing? false
  
  ;; designates all patches in a square around the mouse spot as being in the sample.
  ;; the sample-block side is set on the interface using the slider
  ask patch x y
  [ set patches-in-sample (in-rectangle patches ((block-side - 1) / 2)  ((block-side - 1) / 2) ) ]
  
  ;; hide all the patches and frames
  ask patches with [ true ]
  [ set pcolor hide-patch-color ]
  ask frames
  [ ht ]
  
  ;; show the patches their frames (if grid? is true) in the currently chosen sample
  ask patches-in-sample
  [
    set pcolor my-color
    ask frames-here
    [ set hidden? not grid? ]
  ]
  
  if keep-samples?
  [
    ;; show all the patches which were previously sampled while 
    ;; keep-samples? was true
    ask patches with [ member? agent agents-with-me-in-sample ]
    [ set pcolor my-color ]
     
    ask patches-in-sample
    [
      ;; add agent to my list of agents that have me in their samples
      ;; so that the agent will keep seeing me when taking subsequent
      ;; samples (if keep-samples? is true)
      if( not member? agent agents-with-me-in-sample )
      [ set agents-with-me-in-sample fput agent agents-with-me-in-sample ]
    ]
  ]
  if agent = "observer"
  [
    set num-patches-in-observer-sample count patches-in-sample
    set num-target-color-patches-in-observer-sample count patches-in-sample with [pcolor = target-color]
  ]
end

;; report the agentset within a box that has a width = (width/2 * 2) + 1
;; and a height = (height/2 * 2) + 1 and is centered on the calling agent
to-report in-rectangle [ patchset width/2 height/2 ]  ;; turtle and patch procedure
  ;; this procedure does not work with a non-patch-agentset variable
  if not is-patch-agentset? patchset
  [ report nobody ]
  report patchset with
  [
    pxcor <= (pxcor-of myself + width/2) and pxcor >= (pxcor-of myself - width/2) and
    pycor <= (pycor-of myself + height/2) and pycor >= (pycor-of myself - height/2)
  ]
end


to something [ agent ] ;; patch procedure
  
end

;; reveal the whole population - have all the patches show their 'true' colors
to reveal
  no-display
  set allow-student-sampling? false
  set num-patches-in-observer-sample 0
  set revealing? true
  if show-pop-%? 
  [
    hubnet-broadcast "Message for you" "The percentage of the target color in the population is " + real-%-target-color + "%"
  ]

  ;; grid? is the option to have frames around each patch
  ask frames
  [ set hidden? not grid? ]
  
  ask patches
  [
    ifelse organize?
    [
      ;; When we reveal the population with organize? true, we get a vertical 
      ;; contour in which patches with target-color are on the left and other 
      ;; patches are on the right
      ifelse pxcor < xcor-of-organize-contour
      [ set pcolor target-color ]
      [ set pcolor other-color ]
    ]
    [ set pcolor my-color ]
  ]
  display
end

;; reports the proportion of patches with target-color in this sample
to-report monitor-target-color-%-in-sample
  ifelse show-sample-%? and not revealing? and (target-color-%-in-sample >= 0)
  [
      report num-target-color-patches-in-observer-sample + "/" + 
             num-patches-in-observer-sample + "     = " + 
             (precision target-color-%-in-sample 1) + "%"
  ]
  [ report "N/A" ]
end

;; reports the proportion of patches with target-color in the current sample
;; if there has been no sample chosen yet, patches-in-sample is nobody.  so
;; report -1 as an error code.
to-report target-color-%-in-sample
  ifelse (num-patches-in-observer-sample = 0)
  [ report -1 ]
  [ report ( 100 * num-target-color-patches-in-observer-sample / num-patches-in-observer-sample ) ]
end

;; reports the proportion of patches with target-color in the current population
to-report target-color-%-in-population
  ifelse show-pop-%?
  [
    report count patches with [my-color = target-color] + "/" + 
            count patches + " ~= " +
            real-%-target-color + "%"
  ]
  [ report "N/A" ]
end 

;; report the ratio between the target-color amounts in the sample and in the population
to-report sample-predictability
  ifelse ( not (show-sample-%? and show-pop-%?) ) or revealing? or (target-color-%-in-sample < 0) or (real-%-target-color = 0)
  [ report "N/A" ]
  [ report target-color-%-in-sample / real-%-target-color ]
end

;; plot the clients' guesses.  also, if commit has been called, update the 
;; clients' $$-remaining
to plot-guesses
  if not continue?
  [ stop ]
  
  if not have-plotted?
  [ accumulate-data ]
  
  clear-client-messages  ;; hubnet code

  set-current-plot "Averages of Student Guesses"
  clear-plot
  set-current-plot-pen "guesses"
  set-histogram-num-bars 100 / cluster-guesses
  histogram-list guesses-list
  set-current-plot-pen "mean-of-guesses"
  ppu plotxy (mean guesses-list) plot-y-min
  ppd plotxy (mean guesses-list) plot-y-max
  set can-collect-more-data? true
  set have-plotted? true
  if have-committed?
  [ update-$$ ]
end

;; return true if a sufficient amount of students have submitted data.  the 
;; teacher has an opportunity either to help students who haven't submitted 
;; data or to just plow ahead.
to-report continue?
  locals
  [ continuing? ]
  set continuing? true
  
  if have-plotted?
  [ report true ]
  
  if not any? clients
  [
    user-message "None of your students have connected.  You must collect data before continuing with this action."
    set continuing? false
  ]
  if any? clients with [ final-my-guess = -1 ]  ;; there is at least 1 student that hasn't submitted data
  [
    ifelse count clients = count clients with [ final-my-guess = -1 ]  ;; nobody has submitted data
    [
      user-message "No clients have submitted data."
      set continuing? false
    ]
    [
      ;; some (but not all) clients haven't submitted data
      if user-yes-or-no? ("Please note that " + (count clients with [ final-my-guess = -1 ]) + 
          " students have not yet input new data.  Do you wish to include them in this round?")
      [ set continuing? false ]
    ]
  ]
  
  report continuing?
end

;; pools student data that you have collected from clients
to accumulate-data
  ;; get rid of -1 from the guesses-list since -1 is a default value and not a 
  ;; valid guess
  set guesses-list remove -1 (values-from clients [ final-my-guess ])
  set guess-average mean guesses-list
end

;; cause the final-go-with-group-guess? to be set for all the clients.
;; basically, make the clients commit to whether they are going with the group
;; guess
to commit
  ask clients
  [ set final-go-with-group-guess? temp-go-with-group-guess? ]
  if have-plotted? and not have-committed?
  [ update-$$ ]
  set have-committed? true
end

;; update $$-remaining for each of the clients' based on whether or not each 
;; one chose to go with the group's average guess
to update-$$
  locals
  [ group-error ]
  set group-error abs ( real-%-target-color - guess-average )
  ask clients
  [ update-client-$$ group-error ]
end

;; update the client's $$-remaining based on the value of final-go-with-group-guess?
to update-client-$$ [ group-error ]  ;; client procedure
  ifelse final-go-with-group-guess?
  [ update-$$-remaining group-error ]
  [ update-$$-remaining abs ( real-%-target-color - final-my-guess ) ]
  hubnet-send user-id "$$-remaining" $$-remaining
end

;; update the client's $$-remaining based on my-chosen-error and margin-of-error
to update-$$-remaining [ my-chosen-error ]  ;; client procedure
  if my-chosen-error > margin-of-error
  [ set $$-remaining round ( $$-remaining - abs ( my-chosen-error - margin-of-error ) ) ]
end

;; set $$-remaining of all clients to max-$$
to replenish-$$
  ask clients
  [ set $$-remaining max-$$ ]
  hubnet-broadcast "$$-remaining" max-$$
end

;; set my-sampling-allowance of all clients to total-sample-patches
to replenish-sampling-allowance
  ask clients
  [ set my-sampling-allowance total-sample-patches ]
  hubnet-broadcast "My sample allowance" total-sample-patches
  hubnet-broadcast "Message for you" "Your sampling allowance has been replenished!"
end

;; cause the graphics window to show all the samples that students have 
;; taken this far
to pool-samples
  ask patches
  [
    ifelse length agents-with-me-in-sample = 0
    [ set pcolor hide-patch-color ]
    [
      set pcolor my-color
      ;; put all the clients (including "observer") into agents-with-me-in-sample
      set agents-with-me-in-sample lput "observer" values-from clients [ self ]
    ]
  ]
  display
end


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Code for interacting with the clients     ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;; determines which client sent a command, and what the command was
to listen-clients
  ;; if a student can't set the block-size (before the first sample), then they 
  ;; shouldn't be able to change it (between samples) either.
  if not allow-student-set-block-side?
  [ set allow-student-change-block-side? false ]
  
  while [ hubnet-message-waiting? ]
  [
    hubnet-fetch-message
    ifelse hubnet-enter-message?
    [ create-client ]
    [
      ifelse hubnet-exit-message?
      [ remove-client ]
      [ execute-cmd ]
    ]
  ]
end

;; if no clients with this user-id exist, create a new client and initialize its 
;; variables.  if have-plotted? or have-committed? are true, create a 
;; pending-client instead of a client
to create-client
  if not any? clients with [ user-id = hubnet-message-source ]
  [
    ifelse have-plotted?
    [
      cct-pending-clients 1
      [ setup-client true hubnet-message-source ]
    ]
    [
      cct-clients 1
      [ setup-client false hubnet-message-source ]
    ]
  ]
end

;; setup a client or a pending-client depending upon pending?
to setup-client [ pending? id ]  ;; client or pending-client procedure
  ht
  set user-id id
  ifelse pending?
  [
    hubnet-send user-id "Message for you" 
                         ("You are not included in this round.  You will be " + 
                         "included later.")
  ]
  [
    init-client-vars
    ifelse allow-student-set-block-side?
    [ set my-sample-block-side 1 ]
    [ set my-sample-block-side sample-block-side ]
    set $$-remaining max-$$
    hubnet-send user-id "my-sample-block-side" sample-block-side
    hubnet-send user-id "$$-remaining" $$-remaining
    hubnet-send user-id "My sample allowance" my-sampling-allowance
    hubnet-send user-id "Message for you" "Your target color is GREEN.  Guess percentage GREEN."
  ]
end

;; set some client variables to appropriate defaults
to init-client-vars  ;; client or pending-client procedure
  set my-sampling-allowance total-sample-patches
  set temp-go-with-group-guess? false
  set final-go-with-group-guess? false
  set have-sampled? false
  set temp-my-guess 0
  set final-my-guess -1
end

;; ask any? clients with this user-id to die
to remove-client
  ask clients with [ user-id = hubnet-message-source ]
  [ die ]
end

;; based on what hubnet-message-tag is, execute some code
to execute-cmd
  if hubnet-message-tag = "my-guess-for-this-sample"
  [
    ask clients with [ user-id = hubnet-message-source ]
    [ set temp-my-guess hubnet-message ]
    stop
  ]
  if hubnet-message-tag = "input-guess"
  [
    ask clients with [ user-id = hubnet-message-source ]
    [
      set final-my-guess temp-my-guess
      if not have-plotted?
      [
        hubnet-send hubnet-message-source "Message for you" ("Thank you.  Your input is: " + final-my-guess )
      ]
    ]
    stop
  ]
  if hubnet-message-tag = "my-sample-block-side"
  [
    ask clients with [ user-id = hubnet-message-source ]
    [
      ifelse allow-student-set-block-side?
      [
        ifelse allow-student-change-block-side? or not have-sampled?
        [ set my-sample-block-side hubnet-message ]
        [
          ;; currently, due to a bug in hubnet, we must make sure that we 
          ;; ignore hubnet messages for sliders when the value being sent 
          ;; by the client is equal to the client's current value
          if hubnet-message != my-sample-block-side
          [
            hubnet-send hubnet-message-source "my-sample-block-side" my-sample-block-side
            hubnet-send hubnet-message-source "Message for you" "Sorry, you can't change your sample-block-side at this time"
          ]
        ]
      ]
      [
        ;; currently, due to a bug in hubnet, we must make sure that we 
        ;; ignore hubnet messages for sliders when the value being sent 
        ;; by the client is equal to the client's current value
        if hubnet-message != sample-block-side
        [
          hubnet-send hubnet-message-source "my-sample-block-side" sample-block-side
          hubnet-send hubnet-message-source "Message for you" "Sorry, we're all using the same sample-block-side at this time"
        ]
      ]
    ]
    stop
  ]
  if hubnet-message-tag = "go-with-group-guess?"
  [
    ask clients with [ user-id = hubnet-message-source ]
    [ set temp-go-with-group-guess? hubnet-message ]
    stop
  ]
  if hubnet-message-tag = "Graphics Window"
  [
    if not allow-student-sampling? [stop]
    no-display
    ask clients with [ user-id = hubnet-message-source ]
    [ client-sample ]
  ]
end

;; if clients are allowed to sample and this client's my-sampling-allowance is 
;; large enough to take a sample of my-sample-block-side^2, have the client take 
;; a sample of where at the location stored in hubnet-message up and update any 
;; the appropriate variables.
;; Note: the display should be turned off when calling this procedure otherwise, 
;; all connected clients will see the sample chosen by this client.
to client-sample  ;; client procedure
  locals
  [
    my-total
    patch-clicked-on
  ]
  without-interruption
  [
    if not allow-student-sampling? [stop]
    if not allow-student-set-block-side?
    [
      set my-sample-block-side sample-block-side
      hubnet-send hubnet-message-source "my-sample-block-side" sample-block-side
      hubnet-send hubnet-message-source "Message for you" "Sorry, you can't change my-sample-block-side at this time."
    ]
    set patch-clicked-on patch (round item 0 hubnet-message) (round item 1 hubnet-message)
    setxy pxcor-of patch-clicked-on pycor-of patch-clicked-on
    set my-total my-sampling-allowance - count 
        ( in-rectangle patches ((my-sample-block-side - 1) / 2) ((my-sample-block-side - 1) / 2) )
    ifelse my-total < 0
    [ hubnet-send hubnet-message-source "Message for you" "Sorry, that's more than your allowance." ]
    [
      change-sample pxcor pycor my-sample-block-side self
      set my-sampling-allowance my-total
      set have-sampled? true
      hubnet-send hubnet-message-source "Graphics Window" "Graphics Window"
      hubnet-send hubnet-message-source "My sample allowance" my-total
      hubnet-send hubnet-message-source "Message for you" ""
    ]
  ]
end

;; setup the clients so that they are ready to sample a new population
to initialize-clients [ full-setup? ]
  start-over-clients
  if full-setup?
  [ replenish-$$ ]
end

;; setup the clients for collecting another set of data for the current population
to start-over-clients
  convert-to-clients
  ask clients
  [ init-client-vars ]
  hubnet-broadcast "go-with-group-guess?" false
  hubnet-broadcast "My sample allowance" total-sample-patches
  hubnet-broadcast "my-guess-for-this-sample" 0
  hubnet-broadcast "Message for you" "Your target color is GREEN.  Guess percentage GREEN."
end

;; have all pending-clients become a client
to convert-to-clients
  ask pending-clients
  [
    set breed clients
    setup-client false user-id  ;; use false here since we have a real client now
  ]
end

;; erases any announcements which we previously sent to clients
to clear-client-messages
  ask clients
  [ hubnet-send user-id "Message for you" "" ]
end

;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Quick Start functions ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;

;; instructions to quickly setup the model, and clients to run this activity
to setup-quick-start
  set qs-item 0
  set qs-items
  [
    "SETUP initializes all variables but it also disconnects the users. You needn't press it now..."
    "use it only if you wish to begin the simulation again."
    "Normally, choose RERUN to initialize variables for using Sampler with the same class."
    "If you've just begun, see that the slider over the graphics window is set to 50% target color,"
    "and the RANDOM-RERUN? switch is set to Off and the ABNORMALITY slider is set to 0."
    "Note: the target color is green and the other color is blue."
    "Now press REVEAL POP. to see the current population:" "50% of the patches are green; you have 50% greenness."
    "Practice setting the population to a different percentage and distribution type by..."
    "setting the percentage green for the population by..." "setting the %-TARGET-COLOR slider over the graphics window."
    "ABNORMALITY controls how much the distribution of green deviates from 'normal'. Explore it."
    "If RANDOM-RERUN? is On then the computer will choose the percentage green for you."
    "That means that even you will not know the percentage green in population."
    "Press the RERUN button for a new population."
    "REVEAL POP. varies according to the values of ORGANIZE? and GRID?."
    "ORGANIZE? Off shows the colors where they are and organize On does color separation"
    "(see how the green/blue contour falls exactly under the %-TARGET-COLOR slider handle)"
    "GRID? On puts frames around the patches and GRID? Off does not."
    "SAMPLE allows you to reveal with the mouse square areas on the Graphics Window."
    "The size of these square samples depends on the value of the SAMPLE-BLOCK-SIDE slider."
    "Set KEEP-SAMPLE? to choose whether or not to keep successive samples displayed."
    "In your own preparation for class, in order to anticipate students' questions,"
    "you should practice by using RANDOM-RERUN? and taking samples."
    "Think the way your students would. There are many questions to be asked..."
    "and especially when you play with ABNORMALITY and get color clusters in your population."
    "Work on strategies for maximizing the accuracy AND efficiency of your sample measurement:"
    "Should you take small samples or big ones?; just one sample or many?; where from?"
    "To start off your students, do more or less what you did yourself:"
    "Set the sliders and switches as following:"
    "%-TARGET-COLOR 50; ABNORMALITY 0; RANDOM-RERUN?, ORGANIZE?, and GRID? Off."
    "Press REVEAL POP."
    "Now ask students 'What is this?' 'How green is this?', 'How could we figure out?'"
    "To show the class how green it is, set ORGANIZE? to On and press REVEAL POP."
    "Draw students' attention to the contour line..." "and how it compares to their guess on the slider above it:"
    "Did they over/under-guess?; by how much? How well did they do? Were they close enough?"
    "Try this with other %. Now you'll want students to open the HubNet client, login."
    "When they login, they should each see their own SAMPLER interface."
    "Now they can input their own guesses as long as COLLECT DATA is pressed."
    "COLLECT DATA imports values from all active participants -- always keep this pressed down."
    "Ask the students to set their sliders to their guesses and press their INPUT-GUESS buttons."
    "PLOT GUESSES calculates the statistics of participants' data and..." "displays them in the plot and monitors."
    "The logic of the $$ game is that students bet on either their own guess or the group guess;"
    "Press COMMIT to register each student's decision whether or not to go with the group guess."
    "Students each 'pay' for their error:" "As many points are deducted from their $$ as their guess was off."
    "But you can set the MARGIN-OF-ERROR slider to allow for more flexibility."
    "When the basic procedure is clear to students, switch On the ALLOW-STUDENT-SAMPLING?."
    "Students can sample as many patches as the sampling allowance is set to."
    "Press REPLENISH SAMPLING ALLOWANCE if you want to..." "reset all students to TOTAL-SAMPLING-ALLOWANCE."
    "Discuss individual and collaborative sampling strategies and..." "their relation to the histogram distribution." 
    "Good luck!"
   ]
   set quick-start (item qs-item qs-items)
end

;; view the next item in the quickstart monitor
to view-next-message
  set qs-item qs-item + 1
  if qs-item >= length qs-items
  [ set qs-item length qs-items - 1 ]
  set quick-start (item qs-item qs-items)
end

;; view the previous item in the quickstart monitor
to view-previous-message
  set qs-item qs-item - 1
  if qs-item < 0
  [ set qs-item 0 ]
  set quick-start (item qs-item qs-items)
end


; *** NetLogo Model Copyright Notice ***
;
; This activity and associated models and materials was created as part of the projects:
; PARTICIPATORY SIMULATIONS: NETWORK-BASED DESIGN FOR SYSTEMS LEARNING IN CLASSROOMS and 
; INTEGRATED SIMULATION AND MODELING ENVIRONMENT.
; These projects gratefully acknowledge the support of the 
; National Science Foundation (REPP & ROLE programs) -- grant numbers 
; REC #9814682 and REC-0126227.
;
; Copyright 2003 by Uri Wilensky. Updated 2003. All rights reserved.
;
; Permission to use, modify or redistribute this model is hereby granted,
; provided that both of the following requirements are followed:
; a) this copyright notice is included.
; b) this model will not be redistributed for profit without permission
;    from the copyright holders.
; Contact the copyright holders for appropriate licenses for redistribution 
; for profit.
;
; To refer to this model in academic publications, please use:
; Wilensky, U. (2003).  NetLogo HubNet Sampler model.
; http://ccl.northwestern.edu/netlogo/models/HubNetSampler.
; Center for Connected Learning and Computer-Based Modeling,
; Northwestern University, Evanston, IL.
;
; In other publications, please use:
; Copyright 1998 by Uri Wilensky.  All rights reserved.  See
; http://ccl.northwestern.edu/netlogo/models/HubNetSampler
; for terms of use.
;
; *** End of NetLogo Model Copyright Notice ***
@#$#@#$#@
GRAPHICS-WINDOW
27
43
403
440
30
30
6.0
1
10
1
1
1

CC-WINDOW
604
567
1037
680
Command Center

BUTTON
800
174
917
207
Plot Guesses
plot-guesses
NIL
1
T
OBSERVER
T

SLIDER
539
210
689
243
sample-block-side
sample-block-side
1
11
5
2
1
NIL

PLOT
6
441
529
599
Averages of Student Guesses
 %-target-color
# students
0.0
100.0
0.0
6.0
true
true
PENS
"guesses" 1.0 1 -65536 true
"mean-of-guesses" 1.0 0 -65281 true
"means" 1.0 0 -6524078 true
"mean-of-means" 1.0 0 -16711681 true

MONITOR
531
430
713
479
Target Color % in This Sample
monitor-target-color-%-in-sample
1
1

MONITOR
531
480
713
529
Target Color % in Population
target-color-%-in-population
3
1

BUTTON
408
175
537
208
Reveal Pop.
reveal
NIL
1
T
OBSERVER
T

SWITCH
539
175
689
208
organize?
organize?
1
1
-1000

SWITCH
691
175
781
208
grid?
grid?
1
1
-1000

MONITOR
81
600
164
649
# guesses
length guesses-list
0
1

MONITOR
165
600
269
649
mean this round
guess-average
1
1

MONITOR
472
600
573
649
mean all rounds
mean averages-list
1
1

MONITOR
398
600
471
649
# rounds
length averages-list
0
1

MONITOR
270
600
366
649
standard dev
standard-deviation guesses-list
3
1

MONITOR
6
600
80
649
# students
count clients
0
1

MONITOR
507
49
1036
98
Quick Start Instructions (more details in the Information tab and part-sims guide)
quick-start
3
1

BUTTON
914
99
1036
132
NEXT >>>
view-next-message
NIL
1
T
OBSERVER
T

BUTTON
794
99
912
132
<<< PREV
view-previous-message
NIL
1
T
OBSERVER
T

SWITCH
540
396
696
429
show-sample-%?
show-sample-%?
1
1
-1000

SWITCH
546
531
690
564
show-pop-%?
show-pop-%?
1
1
-1000

SWITCH
801
497
1036
530
allow-student-set-block-side?
allow-student-set-block-side?
0
1
-1000

SLIDER
801
429
1036
462
margin-of-error
margin-of-error
0
10
0
1
1
NIL

SLIDER
24
10
410
43
%-target-color
%-target-color
0
100
50
1
1
NIL

MONITOR
715
455
799
504
Sample/Pop
sample-predictability
2
1

BUTTON
408
140
537
173
Rerun
rerun
NIL
1
T
OBSERVER
T

SLIDER
120
650
269
683
cluster-guesses
cluster-guesses
1
10
1
1
1
NIL

BUTTON
408
210
537
243
Sample
sample
T
1
T
OBSERVER
T

SWITCH
539
244
689
277
keep-samples?
keep-samples?
1
1
-1000

BUTTON
859
208
976
241
More Data
more-data
NIL
1
T
OBSERVER
T

MONITOR
691
210
784
259
Sample Size
num-patches-in-observer-sample
3
1

BUTTON
859
140
976
173
Collect Data
listen-clients
T
1
T
OBSERVER
T

BUTTON
408
49
504
132
Setup
setup
NIL
1
T
OBSERVER
T

SLIDER
691
140
820
173
abnormality
abnormality
0
10
0
1
1
NIL

BUTTON
507
99
621
132
Reset Instructions
setup-quick-start
NIL
1
T
OBSERVER
T

BUTTON
801
325
1036
359
Replenish $$
replenish-$$
NIL
1
T
OBSERVER
T

SWITCH
801
532
1036
565
allow-student-change-block-side?
allow-student-change-block-side?
0
1
-1000

SWITCH
801
463
1036
496
allow-student-sampling?
allow-student-sampling?
1
1
-1000

BUTTON
408
244
537
277
Pool Samples
pool-samples
NIL
1
T
OBSERVER
T

SLIDER
801
395
1036
428
total-sample-patches
total-sample-patches
0
500
200
25
1
NIL

BUTTON
918
174
1035
207
Commit
commit
NIL
1
T
OBSERVER
T

BUTTON
801
360
1036
394
Replenish Sampling Allowance
replenish-sampling-allowance
NIL
1
T
OBSERVER
T

SWITCH
539
140
689
173
random-rerun?
random-rerun?
1
1
-1000

@#$#@#$#@
WHAT IS IT?
-----------
Sampler is a HubNet activity designed to be a learning environment for students to discover through teacher-guided activity the meaning and use of basic statistics concepts. Students take samples from a hidden population and learn the mathematics of statistics, such as mean, distribution, margin of error, etc. Statistics is presented as a task of making inferences about a population under conditions of uncertainty and limited resources. For example, if you wanted to know what percentage of students in your city speak a language other than English, how would you go about it? Would it be enough to measure the distribution of this variable in your own class? If yes, then how sure could you be that your statistic is representative of the whole city? If not, why not? Are there certain groups of people that it would make more sense to use as a sample? Are there other groups it would make no sense to use? For instance, would it make sense to stand outside a movie house that is showing a French film with no subtitles and ask each patron whether they speak a second language? Is this a representative sample? Should we look at certain parts of town? Would all parts of town be the same? Oh, and by the way, what is an average (a mean)? A variable? A value? What does it mean to measure a distribution of a variable within a population? 

Many students have a very difficult time understanding statistics--not only in middle and high school, but also in college and beyond. Yet on the other hand, there are certain visual-mental capabilities we all have--even very young children--that could be thought of as naive statistics. These capabilities are the proportional judgments we make constantly. We make proportional judgments when we need to decide how to maximize the utility of our actions. For instance, when we come to a new place we may say, "People in this town are very nice." How did we decide that? Or, "Don't buy fruit there--it's often overripe." How did we infer that? Or, "To get to school, take Main street--it's the fastest route in the morning; but drive back through High street, I find that's faster in the afternoon." SAMPLER uses a very simple case of proportional judgment as its metaphor of intuitive statistics: density of a target color within a selected part of the visual field.  


CAUTION
-------
SAMPLER was authored using several code features that have meanwhile been either improved, made obsolete, or otherwise modified in the ongoing process of developing NetLogo. We are currently working on updating these code features to make the procedures compatible with the current release of NetLogo. We expect these alterations to be completed by February 2004. In the meantime, you may encounter certain known problems when running SAMPLER with clients. These problems are not major and are confined to procedures involving 'mirroring,' that is, when students interact so as to import to their monitor's graphics-window features from the server. Put simply, when students take samples by clicking on their screen, it may be the case that they will sometimes also receive a sample taken by another student. These asynchronization issues are "bugs" and will be corrected in a later release of NetLogo. In the meantime, you can use SAMPLER but please inform your students that it is slightly "buggy." We appreciate your patience.


HOW DOES IT WORK?
-----------------
The teacher works in NetLogo and acts as the server for the students (the "clients") who each have their own client interface on their computer screens. Students see the teacher's interface projected on the classroom screen, and they can instruct the teacher to manipulate settings of the microworld that they do not have on their own client interfaces. The Graphics Window in the projected interface features a square "population" of 3761 patches. Individual patches are either green (target-color) or blue (other-color). The patches' color is the attribute we measure in SAMPLER. So, the SAMPLER color is a variable that can have one of two values: green or blue (a dichotomous variable, like a coin). In a basic SAMPLER activity, students and/or the teacher reveal(s) parts of or all the population and students discuss, approximate, take samples, and input their individual guesses as to the percentage of green patches within the revealed sector of the population. All participating students' inputs are collected, pooled, and represented in monitors and in the plot. Thus, each student constitutes a data-point agent and can experience their impact on the class statistics. 

Through collaboration, students are to achieve, as a class, the best possible approximation of the population.

The $$ game: At the beginning of every round and later, whenever the facilitator decides, all clients receive max-points, for instance $100. Now, students can bet either on their own guess or on the group guess. They pay 1 point for every percentile their bet is away from the truth or from the margin of error that they agree upon.  This is an optional feature.


HOW TO USE IT
-------------
QUICKSTART INSTRUCTIONS:
------------------------
SETUP initializes all variables but it also disconnects the users. You needn't press it now; use it only if you wish to begin the simulation again. Normally, choose RERUN to initialize variables for using Sampler with the same class. If you've just begun, see that the slider over the graphics window is set to 50% target color, and the RANDOM-RERUN? switch is set to Off and the ABNORMALITY slider is set to 0. Note: the target color is green and the other color is blue.

Now press REVEAL POP. to see the current population: 50% of the patches are green; you have 50% greenness. Practice setting the population to a different percentage and distribution type by setting the percentage green for the population by setting the %-TARGET-COLOR slider over the graphics window. ABNORMALITY controls how much the distribution of green deviates from 'normal'. Explore it.

If RANDOM-RERUN? is On then the computer will choose the percentage green for you. That means that even you will not know the percentage green in population. Press the RERUN button for a new population. REVEAL POP. varies according to the values of ORGANIZE? and GRID?. ORGANIZE? Off shows the colors where they are and ORGANIZE? On does color separation (see how the green/blue contour falls exactly under the %-TARGET-COLOR slider handle). GRID? On puts frames around the patches and GRID? Off does not. SAMPLE allows you to reveal with the mouse square areas on the Graphics Window. The size of these square samples depends on the value of the SAMPLE-BLOCK-SIDE slider. Set KEEP-SAMPLE? to choose whether or not to keep successive samples displayed.

In your own preparation for class, in order to anticipate students' questions, you should practice by using RANDOM-RERUN? and taking samples. Think the way your students would. There are many questions to be asked and especially when you play with ABNORMALITY and get color clusters in your population. Work on strategies for maximizing the accuracy AND efficiency of your sample measurement: Should you take small samples or big ones?; just one sample or many?; where from?

To start off your students, do more or less what you did yourself:
-Set the sliders and switches as following: %-TARGET-COLOR 50; ABNORMALITY 0; RANDOM-RERUN?, ORGANIZE?, and GRID? Off.
-Press REVEAL POP.
-Now ask students 'What is this?' 'How green is this?', 'How could we figure out?'
-To show the class how green it is, set ORGANIZE? to On and press REVEAL POP.
-Draw students' attention to the contour line and how it compares to their guess on the slider above it: Did they over/under-guess?; by how much? How well did they do? Were they close enough?
-Try this with other %.

Now you'll want students to open the HubNet client and login. When they login, they should each see their own SAMPLER interface. Now they can input their own guesses as long as COLLECT DATA is pressed. COLLECT DATA imports values from all active participants -- always keep this pressed down. Ask the students to set their sliders to their guesses and press their INPUT-GUESS buttons. PLOT GUESSES calculates the statistics of participants' data and displays them in the plot and monitors.

The logic of the $$ game is that students bet on either their own guess or the group guess; press COMMIT to register each student's decision whether or not to go with the group guess. Students each 'pay' for their error: As many points are deducted from their $$ as their guess was off. But you can set the MARGIN-OF-ERROR slider to allow for more flexibility.

When the basic procedure is clear to students, switch On the ALLOW-STUDENT-SAMPLING?. Students can sample as many patches as the sampling allowance is set to. Press REPLENISH SAMPLING ALLOWANCE if you want to reset all students to TOTAL-SAMPLING-ALLOWANCE. Discuss individual and collaborative sampling strategies and their relation to the histogram distribution. Good luck!

See the SAMPLER section of the Computer HubNet Participatory Simulations Guide for an in-depth lesson plan.

BUTTONS:
--------
SETUP - clears all turtles and patches and the plot. This button should only be pressed when starting out with a new group of users since all data is lost.
RERUN - creates a new population from which to sample. In creating this population, each patch has either a random (if RANDOM-RERUN? is true) or a user chosen (if RANDOM-RERUN? is false) percent chance of being green. The user chosen chance is set with the %-TARGET-COLOR slider. This button should be used to setup the model again for collecting data with a new population and the same users connected.
SAMPLE - allows the server to reveal mouse-selected square areas of SAMPLE-BLOCK-SIDE within the population. Set the KEEP-SAMPLES? switch to choose whether or not to keep successive samples.
COLLECT DATA - collects student samples and guess values from all active clients. Clients, if allowed to sample, can reveal as many patches as they have left in their sample allowance. One sample allowance unit allows you to reveal one patch.
POOL SAMPLES - shows all samples (from the clients and the server) at once
REVEAL POP. - shows all the patches' colors. If ORGANIZE? is false, the patches reveal whatever color they got when RERUN was pressed. If ORGANIZE? is true, the patches segregate themselves by color, green to the left and blue to the right. If GRID? is true, each of patches have a thin frame surrounding it.
PLOT GUESSES - histograms the collected guesses in the plot. Once you have plotted, guesses are no longer accepted for this population until RERUN or MORE DATA are pressed.
MORE DATA - prepares the model for another round of class guesses for this specific population. To create a new population, use the RERUN button.
REPLENISH SAMPLING ALLOWANCE - resets each of the client's sampling allowance to TOTAL-SAMPLE-PATCHES
COMMIT - collects students' current setting of their GO-WITH-GROUP? switch.  This is used for the $$ game, and is not needed if you are not doing the game.
REPLENISH $$ - resets each of the client's $$-REMAINING to the starting quantity
NEXT >>> - shows the next quick start instruction
<<< PREVIOUS - shows the previous quick start instruction
RESET INSTRUCTIONS - shows the first quick start instruction

SLIDERS:
--------
ABNORMALITY - slider controls to what extent the distribution deviates from 'normal' (for a given percent green you'll get larger clumps for a larger setting)
MARGIN-OF-ERROR - used for the $$ game. This determines how accurate the guess has to be in order to be correct. For example, if it's set at 3 and the greenness is 70 then you can guess between 67 and 73 and not have points taken off, but if you guess 74 or 66 you get 1 point off, etc.
TOTAL-SAMPLE-PATCHES - determines how much sampling allowance students get when it is replenished. When sampling, one sample allowance unit allows you to reveal one patch.
SAMPLE-BLOCK-SIDE - determines the side of the square that is revealed when sampling in the model. For instance, SAMPLE-BLOCK-SIDE of 5 gives a sample size of 25 patches. This value does not affect how big the samples are on the clients. They have their own versions of this slider.
CLUSTER-GUESSES - controls the histogram interval: the higher the setting, the higher the interval.

SWITCHES
--------
ALLOW-STUDENT-SAMPLING? - if true, students can sample; otherwise not.
ALLOW-STUDENT-SET-BLOCK-SIDE? - if true, students can only set the size of their samples before sampling for the first time that round; otherwise not.
ALLOW-STUDENT-CHANGE-BLOCK-SIDE? - if true, students can change the size of their samples between taking samples within a single round; otherwise not.
SHOW-SAMPLE-%? - controls whether or not the monitor TARGET COLOR % IN THIS SAMPLE will show current values
SHOW-POP-%? - controls whether or not the TARGET COLOR % IN POPULATION will show current values
ORGANIZE? - if true, when REVEAL is pressed, the green and blue colors will be segregated (green on the left).  If false, then when you press REVEAL, the colors will be not be organized.
GRID? - if true, each patch will have a thin frame around it to help you count them.  If false, then the frames will not be seen.
RANDOM-RERUN? - when RERUN is pressed, each patch has either a random (if RANDOM-RERUN? is true) or a user chosen (if RANDOM-RERUN? is false) percent chance of being green. The user chosen chance is set with the %-TARGET-COLOR slider. This button should be used to setup the model again for collecting data with a new population and the same users connected.
KEEP-SAMPLES? - when sampling, if true, old samples are still displayed.  If false, old samples are removed and cannot be seen.

MONITORS
--------
SAMPLE SIZE - shows the number of patches in the current sample chosen in the NetLogo model (the teacher's screen)
TARGET COLOR % IN THIS SAMPLE - shows the percentage of target color of the current sample chosen in the NetLogo model (the teacher's screen)
TARGET COLOR % IN POPULATION - shows the percentage of target color within the entire population
SAMPLE/POP - shows the quotient of TARGET COLOR % IN THIS SAMPLE and TARGET COLOR % IN POPULATION. So, in a sense, it tells you how indicative a sample is of the population statistic. If the quotient is exactly 1 then the sample can be said to be representative of the population. If the quotient is smaller than 1 then the sample under represents the population, and if the quotient is larger than 1 then the sample over represents the population statistic. Larger samples generally give quotients that are closer to 1.  Only when SHOW-SAMPLE-%? and SHOW-POP-%? are true does this monitor show any pertinent information.
# STUDENTS - shows how many students are actively connected to the NetLogo model (the teacher's screen)
# GUESSES - shows how many guesses were collected when you last pressed PLOT GUESSES.
MEAN THIS ROUND - shows the average of guesses that are currently plotted in the histogram.
STANDARD DEV - shows the standard deviation of guesses
# ROUNDS - shows how many rounds are represented in the plot. 
MEAN ALL ROUNDS - the cumulative average for all rounds per this population (since you last pressed RERUN). 

PLOTS
-----
AVERAGES OF STUDENT GUESSES- X-axis is %-TARGET-COLOR and Y-axis is # STUDENTS. Here you see four statistics as displayed by four different plot pens:
1. GUESSES: Students' collected guesses for a round represented in histograms.
2. MEAN-OF-GUESSES: the average value of guesses for the recent round
3. MEANS: the average values from successive rounds
4. MEAN-OF-MEANS: the average value of 'means'.


CLIENT INFORMATION
------------------
MY-GUESS-FOR-THIS-SAMPLE - students use this slider to set their guess value.
MY-SAMPLE-BLOCK-SIDE - students use this slider to set the size of their sample square
GO-WITH-GROUP-GUESS? - students use this switch to set whether or not they are committing themselves to go with the class average guess.
MESSAGE FOR YOU - displays messages sent from the server; these may be collective or for subsets of students.
MY SAMPLE ALLOWANCE - shows how many patches the student may still sample.
$$-REMAINING - shows how many dollar points the student still has left.
INPUT-GUESS - press this button to send to the server the guess that you have set on the MY-GUESS-FOR-THIS-SAMPLE slider.


THINGS TO NOTICE
----------------
When you press REVEAL in the organize-on option, the target-color and the other-color move to the left and the right of the screen, respectively, forming a contour line. The location of this contour line is comparable to two other elements on the interface: the contour line falls directly below the slider handle above it (if this was not a random run) and it relates similarly to the mean line in the plot. The reason we can compare these three features directly is because the 0 and 'whole' (100%) of each of these features are aligned. That is, the sliders, graphics window, and plot have all been placed carefully so as to subtend each other precisely. 

The abnormality distribution feature does not take much code to write, but is effective. Look at the code and try to understand it.


THINGS TO TRY
-------------
Set RANDOM-RERUN? to true and press RERUN and take samples. What is the minimal number of samples you need in order to get a good idea of the target-color distribution in the population? Anyway, how 'good' must a good idea be? Can you think of a way of describing this 'goodness'? What is a good way of spreading the samples on the population?

Try setting the ABNORMALITY slider to different values and press RERUN over and over for the same percentage green, for instance 50%. Can you think of situations in the world where a certain attribute is distributed in a population in a way that corresponds to a high value of ABNORMALITY? What do we mean when we speak of a 'uniform distribution' within a population? For instance, is a distribution of ABNORMALITY = 0 uniform? Or must there be strict order, for instance stripes of target-color, in order for you to feel that the distribution is uniform? Also, is there a difference between your sense of uniformity whether you're looking at the whole population or just at certain parts of it? If you threw a handful of pebbles onto a square area, would you say they fell 'uniformly'? What kinds of patterns are natural, and what kinds of patterns would you think of as coincidental?

Set RANDOM-RERUN? to false and press RERUN multiple times.  Each time you press RERUN, change the SHOW-POP-%? to true.  Do you notice that the number of green patches varies from trial to trial?  The way the population is established every trial is that each patch "flips a weighted coin" to see whether it should be green or not. Because there are so many patches, it turns out that the percentage of patches that "landed on" green is roughly the same as the percentage green you set with the slider. You can explore this intriguing idea further in the ProbLab model Stochastic Patchwork.


EXTENDING THE MODEL
-------------------
What other quantitative aspects of sampling might a teacher or student need so as to understand and do more in this activity? Perhaps the class would want to keep a record of how well they are doing over an entire lesson. How would you quantify such performance and how would you display it? Would a plot be useful for this or just a list of numbers?


RELATED MODELS
--------------
All models in ProbLab deal with probability and statistics in ways that may enrich student understanding of sample space, randomness, and distributions. 


CREDITS AND REFERENCES
----------------------
Thanks to Dor Abrahamson for designing this and other models in ProbLab.

This activity and associated models and materials was created as part of the projects: PARTICIPATORY SIMULATIONS: NETWORK-BASED DESIGN FOR SYSTEMS LEARNING IN CLASSROOMS and INTEGRATED SIMULATION AND MODELING ENVIRONMENT. These projects gratefully acknowledge the support of the National Science Foundation (REPP & ROLE programs) -- grant numbers REC #9814682 and REC-0126227.

Copyright 2003 by Uri Wilensky. Updated 2003. All rights reserved.

Permission to use, modify or redistribute this model is hereby granted, provided that both of the following requirements are followed:
a) this copyright notice is included.
b) this model will not be redistributed for profit without permission from the copyright holders.
Contact the copyright holders for appropriate licenses for redistribution for profit.

To refer to this model in academic publications, please use: Wilensky, U. (2003). NetLogo HubNet Sampler model. http://ccl.northwestern.edu/netlogo/models/HubNetSampler. Center for Connected Learning and Computer-Based Modeling, Northwestern University, Evanston, IL.

In other publications, please use: Copyright 2003 by Uri Wilensky.  All rights reserved.  See http://ccl.northwestern.edu/netlogo/models/HubNetSampler for terms of use.
@#$#@#$#@
default
true
0
Polygon -7566196 true true 150 5 40 250 150 205 260 250

ant
true
0
Polygon -7566196 true true 136 61 129 46 144 30 119 45 124 60 114 82 97 37 132 10 93 36 111 84 127 105 172 105 189 84 208 35 171 11 202 35 204 37 186 82 177 60 180 44 159 32 170 44 165 60
Polygon -7566196 true true 150 95 135 103 139 117 125 149 137 180 135 196 150 204 166 195 161 180 174 150 158 116 164 102
Polygon -7566196 true true 149 186 128 197 114 232 134 270 149 282 166 270 185 232 171 195 149 186 149 186
Polygon -7566196 true true 225 66 230 107 159 122 161 127 234 111 236 106
Polygon -7566196 true true 78 58 99 116 139 123 137 128 95 119
Polygon -7566196 true true 48 103 90 147 129 147 130 151 86 151
Polygon -7566196 true true 65 224 92 171 134 160 135 164 95 175
Polygon -7566196 true true 235 222 210 170 163 162 161 166 208 174
Polygon -7566196 true true 249 107 211 147 168 147 168 150 213 150

arrow
true
0
Polygon -7566196 true true 150 0 0 150 105 150 105 293 195 293 195 150 300 150

bee
true
0
Polygon -256 true false 152 149 77 163 67 195 67 211 74 234 85 252 100 264 116 276 134 286 151 300 167 285 182 278 206 260 220 242 226 218 226 195 222 166
Polygon -16777216 true false 150 149 128 151 114 151 98 145 80 122 80 103 81 83 95 67 117 58 141 54 151 53 177 55 195 66 207 82 211 94 211 116 204 139 189 149 171 152
Polygon -7566196 true true 151 54 119 59 96 60 81 50 78 39 87 25 103 18 115 23 121 13 150 1 180 14 189 23 197 17 210 19 222 30 222 44 212 57 192 58
Polygon -16777216 true false 70 185 74 171 223 172 224 186
Polygon -16777216 true false 67 211 71 226 224 226 225 211 67 211
Polygon -16777216 true false 91 257 106 269 195 269 211 255
Line -1 false 144 100 70 87
Line -1 false 70 87 45 87
Line -1 false 45 86 26 97
Line -1 false 26 96 22 115
Line -1 false 22 115 25 130
Line -1 false 26 131 37 141
Line -1 false 37 141 55 144
Line -1 false 55 143 143 101
Line -1 false 141 100 227 138
Line -1 false 227 138 241 137
Line -1 false 241 137 249 129
Line -1 false 249 129 254 110
Line -1 false 253 108 248 97
Line -1 false 249 95 235 82
Line -1 false 235 82 144 100

bird1
false
0
Polygon -7566196 true true 2 6 2 39 270 298 297 298 299 271 187 160 279 75 276 22 100 67 31 0

bird2
false
0
Polygon -7566196 true true 2 4 33 4 298 270 298 298 272 298 155 184 117 289 61 295 61 105 0 43

blues
true
0
Circle -16776961 true false 77 76 148

boat1
false
0
Polygon -1 true false 63 162 90 207 223 207 290 162
Rectangle -6524078 true false 150 32 157 162
Polygon -16776961 true false 150 34 131 49 145 47 147 48 149 49
Polygon -7566196 true true 158 33 230 157 182 150 169 151 157 156
Polygon -7566196 true true 149 55 88 143 103 139 111 136 117 139 126 145 130 147 139 147 146 146 149 55

boat2
false
0
Polygon -1 true false 63 162 90 207 223 207 290 162
Rectangle -6524078 true false 150 32 157 162
Polygon -16776961 true false 150 34 131 49 145 47 147 48 149 49
Polygon -7566196 true true 157 54 175 79 174 96 185 102 178 112 194 124 196 131 190 139 192 146 211 151 216 154 157 154
Polygon -7566196 true true 150 74 146 91 139 99 143 114 141 123 137 126 131 129 132 139 142 136 126 142 119 147 148 147

boat3
false
0
Polygon -1 true false 63 162 90 207 223 207 290 162
Rectangle -6524078 true false 150 32 157 162
Polygon -16776961 true false 150 34 131 49 145 47 147 48 149 49
Polygon -7566196 true true 158 37 172 45 188 59 202 79 217 109 220 130 218 147 204 156 158 156 161 142 170 123 170 102 169 88 165 62
Polygon -7566196 true true 149 66 142 78 139 96 141 111 146 139 148 147 110 147 113 131 118 106 126 71

box
true
0
Polygon -7566196 true true 45 255 255 255 255 45 45 45

butterfly1
true
0
Polygon -16777216 true false 151 76 138 91 138 284 150 296 162 286 162 91
Polygon -7566196 true true 164 106 184 79 205 61 236 48 259 53 279 86 287 119 289 158 278 177 256 182 164 181
Polygon -7566196 true true 136 110 119 82 110 71 85 61 59 48 36 56 17 88 6 115 2 147 15 178 134 178
Polygon -7566196 true true 46 181 28 227 50 255 77 273 112 283 135 274 135 180
Polygon -7566196 true true 165 185 254 184 272 224 255 251 236 267 191 283 164 276
Line -7566196 true 167 47 159 82
Line -7566196 true 136 47 145 81
Circle -7566196 true true 165 45 8
Circle -7566196 true true 134 45 6
Circle -7566196 true true 133 44 7
Circle -7566196 true true 133 43 8

circle
false
0
Circle -7566196 true true 35 35 230

frame
false
14
Rectangle -7566196 false false 0 1 296 296
Rectangle -7566196 false false 0 2 297 297
Rectangle -7566196 false false 0 0 298 298
Rectangle -7566196 false false 1 3 295 295
Rectangle -7566196 false false 1 1 299 299

person
false
0
Circle -7566196 true true 155 20 63
Rectangle -7566196 true true 158 79 217 164
Polygon -7566196 true true 158 81 110 129 131 143 158 109 165 110
Polygon -7566196 true true 216 83 267 123 248 143 215 107
Polygon -7566196 true true 167 163 145 234 183 234 183 163
Polygon -7566196 true true 195 163 195 233 227 233 206 159

reds
true
0
Circle -7566196 true true 76 77 148
Circle -65536 true false 77 78 148

spacecraft
true
0
Polygon -7566196 true true 150 0 180 135 255 255 225 240 150 180 75 240 45 255 120 135

thin-arrow
true
0
Polygon -7566196 true true 150 0 0 150 120 150 120 293 180 293 180 150 300 150

truck-down
false
0
Polygon -7566196 true true 225 30 225 270 120 270 105 210 60 180 45 30 105 60 105 30
Polygon -8716033 true false 195 75 195 120 240 120 240 75
Polygon -8716033 true false 195 225 195 180 240 180 240 225

truck-left
false
0
Polygon -7566196 true true 120 135 225 135 225 210 75 210 75 165 105 165
Polygon -8716033 true false 90 210 105 225 120 210
Polygon -8716033 true false 180 210 195 225 210 210

truck-right
false
0
Polygon -7566196 true true 180 135 75 135 75 210 225 210 225 165 195 165
Polygon -8716033 true false 210 210 195 225 180 210
Polygon -8716033 true false 120 210 105 225 90 210

wolf-left
false
3
Polygon -6524078 true true 117 97 91 74 66 74 60 85 36 85 38 92 44 97 62 97 81 117 84 134 92 147 109 152 136 144 174 144 174 103 143 103 134 97
Polygon -6524078 true true 87 80 79 55 76 79
Polygon -6524078 true true 81 75 70 58 73 82
Polygon -6524078 true true 99 131 76 152 76 163 96 182 104 182 109 173 102 167 99 173 87 159 104 140
Polygon -6524078 true true 107 138 107 186 98 190 99 196 112 196 115 190
Polygon -6524078 true true 116 140 114 189 105 137
Rectangle -6524078 true true 109 150 114 192
Rectangle -6524078 true true 111 143 116 191
Polygon -6524078 true true 168 106 184 98 205 98 218 115 218 137 186 164 196 176 195 194 178 195 178 183 188 183 169 164 173 144
Polygon -6524078 true true 207 140 200 163 206 175 207 192 193 189 192 177 198 176 185 150
Polygon -6524078 true true 214 134 203 168 192 148
Polygon -6524078 true true 204 151 203 176 193 148
Polygon -6524078 true true 207 103 221 98 236 101 243 115 243 128 256 142 239 143 233 133 225 115 214 114

wolf-right
false
3
Polygon -6524078 true true 170 127 200 93 231 93 237 103 262 103 261 113 253 119 231 119 215 143 213 160 208 173 189 187 169 190 154 190 126 180 106 171 72 171 73 126 122 126 144 123 159 123
Polygon -6524078 true true 201 99 214 69 215 99
Polygon -6524078 true true 207 98 223 71 220 101
Polygon -6524078 true true 184 172 189 234 203 238 203 246 187 247 180 239 171 180
Polygon -6524078 true true 197 174 204 220 218 224 219 234 201 232 195 225 179 179
Polygon -6524078 true true 78 167 95 187 95 208 79 220 92 234 98 235 100 249 81 246 76 241 61 212 65 195 52 170 45 150 44 128 55 121 69 121 81 135
Polygon -6524078 true true 48 143 58 141
Polygon -6524078 true true 46 136 68 137
Polygon -6524078 true true 45 129 35 142 37 159 53 192 47 210 62 238 80 237
Line -16777216 false 74 237 59 213
Line -16777216 false 59 213 59 212
Line -16777216 false 58 211 67 192
Polygon -6524078 true true 38 138 66 149
Polygon -6524078 true true 46 128 33 120 21 118 11 123 3 138 5 160 13 178 9 192 0 199 20 196 25 179 24 161 25 148 45 140
Polygon -6524078 true true 67 122 96 126 63 144

@#$#@#$#@
NetLogo 2.0beta5
@#$#@#$#@
@#$#@#$#@
@#$#@#$#@