Spatial-Social Interactions

;;   Spatial-Social Interactions

breed       [ people person ]     ;; the agents that interact with the environment
breed       [ events event ]      ;; turtles used to highlight where the environment has an event
patches-own [ urban               ;; this patch is an urban spot
              rural               ;; this patch is rural
              eventspace          ;; this patch is eventspace (an event can occur here)
              event-number ]      ;; the event number which has happened
people-own  [ concern             ;; the concern level of the person
              sharing             ;; whether or not they are sharing an event (1 = sharing this tick, 2 = sharing next tick)
              sharing-event       ;; the event number they are sharing
              shared-events-list  ;; the list of recent events they have shared - prevents runaway feedback loops
              home-patch          ;; the original patch so the person can go home after a "layout"
              shares              ;; the number of times this person has shared a story
              events-seen ]       ;; the number of events this person has seen (regardless of concern level)
globals     [ decay               ;; how much concern levels decay per tick
              count-eventspace    ;; number of eventspace patches
              link-state          ;; whether or not the link button has been toggled
              event-counter ]     ;; a running count of how many events to create event-numbers
extensions  [ rnd ]               ;; use this extension for weighted selection

to startup
  ;; This is really for it to be pretty, since we have to reload it following the clear-all
  load-environment
  reset-ticks
end 

to setup
  clear-all
  ;; reset the event couunter
  set event-counter 1

  ;; load in the transportation network to preload patches
  load-environment

  ;; Sprout people in the urban spaces
  ask n-of ((urban-ratio) * num-people) patches with [urban and not eventspace]  [
    sprout-people 1 [ prepare-person set home-patch patch-here ]
  ]

  ;; Sprout people in the rural spaces
  ask n-of ((1 - urban-ratio) * num-people) patches with [rural and not eventspace]  [
    sprout-people 1 [ prepare-person set home-patch patch-here ]
  ]

  ;; now let's make the network
  if any? people [ make-network ]

  ;; hide the links
  ask links [ hide-link ]
  set link-state false

  reset-ticks
end 

to go
  ;; calculate an exponential factor from the attention-span in case the user changed it
  ;; 10 = no decay, otherwise do use an exponential decay amount to make this respond somewhat linearly
  ifelse attention-span = 10 [ set decay 1 ] [set decay 1 - 10 ^ (- (attention-span ^ 0.5))]

  ;; clear out the old event markers since they are old news
  ask events [ die ]

  ;; Let's go ahead and trigger events in some of the cells
  ask patches with [eventspace] [
    ;; reset the incidents from the last tick back to normal
    if pcolor = cyan [ set pcolor black ]
    ;; trigger patches randomly to have a news event... uniform probability per eventspace patch
    if random-float 1.0 < event-freq / count-eventspace [
      ;; set the event number for this patch and increment the counter
      set event-number event-counter
      set event-counter event-counter + 1
      ;; set the patch color to show an event occured here
      set pcolor cyan
    ]
  ]

  ;; Since the people are cycled through in an order we need to do two passes so people can
  ;; react to local shares, and then react to the other people.

  ;; First pass - Set sharing for people who finished the last tick with an event to share. Also react to
  ;; local events.
  ask people [
    ;; if they ended the last tick in active sharing state, they are now sharing that story in this tick,
    ;; even without a local event. set them sharing normally, and make their links grey
    ifelse sharing = 2 [ set sharing 1 ask my-out-links [set color grey ]]
      ;; otherwise just clear the sharing out in case they shared normally last tick
      [set sharing 0 set sharing-event 0 ]

    ;; create their newspaper from local events, and then update their status if there are any events
    let newspaper [event-number] of patches in-radius news-range with [pcolor = cyan]
    ;; we pass handle-news false so that it knows it's getting a local newspaper
    handle-news newspaper false
  ]

  ;; Second pass - People react to the remote events shared to them
  ask people [
    ;; if someone in their network has shared it with them, they see it and are concerned
    if sum [sharing] of in-link-neighbors > 0 [
      ;; let's check to make sure we haven't seen this news story before. Get the list of events being shared to us.
      let event-list [sharing-event] of in-link-neighbors with [sharing > 0]
      ;; we pass handle-news true so that it knows it's getting a shared event-list
      handle-news event-list true
    ]
    ;; Clean up - If there is any concern, decay it, threshold it, and update the status
    if concern > 0 [
      set concern concern * decay
      if concern < concern-threshold [ set color blue ]
      if concern > active-threshold  [ set color yellow ]
      if concern > concern-cap [ set concern concern-cap ]
    ]
  ]

  ;; Now create visual indicators for events that have happened so they can be found on the
  ;; display (since patches are just one pixel)
  ask patches with [ pcolor = cyan ] [
    sprout-events 1 [
      ;; make the display a circle the size of the news-range
      set shape "circle"
      set size news-range
      set color cyan
    ]
  ]

  tick

  ;; if we've hit the stopping criteria, stop.
  if any? people [ if mean [concern] of people > stop-at-mean-concern [ stop ] ]
end 

;; this makes an existing person into a fresh new one, but preserves their network

to prepare-person
  set shape "person"
  set color blue
  set concern initial-concern
  set size 10
  set shared-events-list []
  set shares 0
  set events-seen 0
end 

;; this takes care of picking an event we haven't responded to before and setting up the sharing

to handle-news [ event-list secondary-mode ]
  ;; find one event that hasn't been shared with us.
  let this-event find-not-in-list event-list shared-events-list
  ;; if we got an event number back, that means we haven't seen that event before
  if this-event > 0 [
    ;; make us more concerned
    set concern concern + event-severity
    set events-seen events-seen + 1
    ;; add it to our list
    set shared-events-list lput this-event shared-events-list
    ;; keep our memory limited to the last 20 news stories. old news may reverberate around the network but
    ;; maybe that's realistic if there are long cycles in it.
    if length shared-events-list > 20 [
      set shared-events-list but-first shared-events-list
    ]
    ifelse not secondary-mode [
      ;; if this is an event in my area, we just set sharing
      if concern > concern-threshold or concern > active-threshold [
        set sharing 1
        set sharing-event this-event
        set shares shares + 1
      ]
    ] [
      ;; for events that weren't local but were shared to them...
      ;; if they are concerned, they will share the remote event with their network
      if concern > active-threshold [
        ;; set sharing to 2 so we know in the next round to handle this sharing. News can only move one
        ;; link length per tick.
        set sharing 2
        set sharing-event this-event
        ;; increment the sharing count for this person
        set shares shares + 1
        ;; make the active sharers show their links to make it obvious the span of the remote sharing
        ask my-out-links [show-link set color yellow ]
        ;; make it so the link display toggle button knows there are links showing
        set link-state true
      ]
    ]
  ]
end 


;; this is used to search for new news by finding is a newspaper has news (needle-list)
;; they haven't seen before (haystack)

to-report find-not-in-list [needle-list haystack]
  foreach needle-list [
    needle -> if not member? needle haystack [ report needle ]
  ]
  report 0
end 

;; if the user wants to keep the network but do another run of the model...

to reset-concern
  ;; have the people reset
  ask people [
    prepare-person
  ]
  ;; hide any links that were showing for active sharers
  ask links [ hide-link ]

  ;; clear all the plots and reset the ticks so it's like a new run
  clear-all-plots
  reset-ticks
end 

;; this toggles the display of the links for convenience

to link-toggle
  ifelse link-state [ set link-state false ask links [hide-link] ]
                    [ set link-state true  ask links [show-link] ]
end 

;; load up the environment into the patches and handle missing files

to load-environment
  let filename ""
  ;; if the files exist let's use them
  if geography-type = "freight-network"    [ set filename "transport dataset.png" ]
  if geography-type = "shark-attack-data"  [ set filename "shark dataset.png" ]
  ifelse file-exists? filename [
    import-pcolors filename
  ] [
    user-message "The graphics file for the map couldn't be found. Please check to make sure you extracted them from the ZIP file and placed them in the same directory."
  ]
  ;; set up some colors the PNG files use when imported
  let color-rural 56.8
  let color-urban 25
  let color-eventspace 1
  ;; Have the patches set some properties based on their colors for easy logic checks
  ask patches [
    set rural      pcolor = color-rural
    set urban      pcolor = color-urban
    set eventspace pcolor <= color-eventspace
  ]
  ;; give the eventspace patches a location property for analysis purposes
  ask patches with [ eventspace ] [
    ifelse count patches in-radius 4 with [ urban ] > count patches in-radius 4 with [ rural ] [ set urban true ] [ set rural true ]
  ]
  ;; Count how many eventspace patches we have to scale the event frequency to the size of the map
  set count-eventspace count patches with [eventspace]
end 

;; allows the user to flip the size of the people so the icons aren't as distracting

to tiny-toggle
  ifelse [size] of one-of people = 1
    [ask people [ set size 10 ]]
    [ask people [ set size 1 ]]
end 

;; create the social network

to make-network
  if num-followed > 0 [
    if network-mode = "random-network" [
      ask people [
        ;; create random links within the distance found
        create-links-from n-of num-followed find-nearby false
      ]
    ]
    if network-mode = "scale-free" [
      make-scale-free
    ]
    if network-mode = "small-world" [
      make-small-world
    ]
    if network-mode = "triangles" [
      make-friends-of-friends
    ]
    if network-mode = "dual-scale-free" [
      make-twitter
    ]
  ]
end 

to make-scale-free
  ;; preferrential attachment using Uri's netlogo lottery method. Depending on settings,
  ;; it will prefer local links.

  ;; use a boolean for speed in the loop

  ;; create one link to get the lottery started
  if num-followed > 0 and count links = 0 [ ask one-of people [ create-link-from one-of other people ] ]
  ;; begin the lottery!
  ask people [
    ;; create links to other people with probability of how many people they are linked to
    repeat num-followed [
      let candidate self
      ;; find a turtle that isn't me
      while [candidate = self] [
        ;; conduct the lottery
        set candidate find-scale-free
        ;; if the turtle who is possibly anywhere only has 1 link and is not local,
        ;; find a local link instead.
        if ([count my-out-links] of candidate <= 1 and distance candidate > link-distance ) [
          set candidate one-of find-nearby false
        ]
      ]
      create-link-from candidate
    ]
  ]
end 

;; this implements Uri's method of building a scale-free network in NetLogo

to-report find-scale-free
  report [one-of both-ends] of one-of links
end 

;; this is used during setup to find nearby people to connect to, making sure it's as least as big as the number to follow

to-report find-nearby [ one-link-only ]
  ;; have a variable ready to expand the scope of the search if we don't find enough links
  let focus 0
  ;; a place to store the agentset between runs so we can simply report it if the set is big enough
  let searchset no-turtles
  ;; until we find an agentset of at least count of required links, keep expanding the search radius
  loop [
    ifelse one-link-only
      [ set searchset other people with [ count my-in-links = 0 ] in-radius (link-distance + focus) ]
      [ set searchset other people in-radius (link-distance + focus) ]
    ifelse count searchset < num-followed [
      ;; we didn't find enough people, so we'll just expand the search area next time
      set focus focus + link-distance
    ][
      ;; we've got a big enough set, simply report it.
      report searchset
    ]
  ]
end 

to make-twitter
  ;; inspired by http://www.mdpi.com/1099-4300/17/8/5848
  ;; has 4 different preferential attachment types that are formed probabilistically until
  ;; all of the people have a link

  ;; these are weights, not probabilities
  ;; first, the types proposed by the authors
  let pw 1.0   ;; new node created as followed
  let qw 2.0   ;; new node created as a follower   (they recommend q

  let rw 0.5   ;; add links between existing nodes (similar to rewires in smallworld)
  ;; this one I'm adding in because the network above has very low bidirectional links unless the weight
  ;; for r is enormous (they appear to have chosen equivalents of pw=1 and rw=30 roughly)
  let sw 1.0   ;; influential nodes follow other influential nodes that follow them

  ;; rebalance the weights into probabilities
  let tot pw + qw + sw + rw
  let p pw / tot
  let q qw / tot
  let r rw / tot
  let s sw / tot

  ;; make one link so the preferrential attachment doesn't fail
  if not any? links [ ask one-of people [ create-link-from one-of other people ] ]

  while [ count people with [ count my-links = 0 ] > 0 ] [
    let rand random-float 1.0
    if ( rand <= p ) [      ;; new node as followed
      let followed one-of people with [ count my-links = 0 ]
      ask one-of links [
        let follower one-of both-ends
        ask follower [ create-link-from followed ]
      ]
    ]
    if ( rand <= p + q and rand > p ) [    ;; new node as follower
      let follower one-of people with [ count my-links = 0 ]
      ask one-of links [
        let followed one-of both-ends
        ask follower [
          create-link-from followed
        ]
      ]
    ]
    if ( rand <= p + q + s and rand > p + q ) [     ;; make a link bidirectional
      let candidate nobody  ;; we need to find a link that isn't already bidirectional
      let attempts 0   ;; let's try 10 times to find one that isn't bidirectional before we give up
      while [candidate = nobody and attempts < 10 ] [
        ;; selected a link weighted against the count of links the end points have
        set candidate rnd:weighted-one-of links [ count [my-links] of end1 + count [my-links] of end2 ]
        if (link [who] of [end2] of candidate [who] of [end1] of candidate != nobody) [
          set candidate nobody
        ]
        set attempts attempts + 1
      ]
      ;; if we found someone
      if candidate != nobody [
        ask candidate  [
          ;; create a reversed link
          let far-end end2
          ask end1 [ create-link-from far-end ]
        ]
      ]
    ]
    if ( rand > p + q + s ) [     ;; existing node as follower of another existing node
      ask one-of links [
        let follower one-of both-ends
        let followed follower
        while [ follower = followed ] [
          ask one-of links [ set followed one-of both-ends ]
        ]
        ask follower [ create-link-from followed ]
      ]
    ]
  ]
end 

;; make a small-world network taking into account the distance settings

to make-small-world
  ;; This is a little complicated, but it makes a big lattice loop out of the people with link distances
  ;; based on the UI setting. With long distances it acts geographically random, and with short
  ;; distances it snakes around the country in a loop from neighbor to neighbor.
  let current-person one-of people
  let person-list []
  let everyone-set people
  ;; where there are still people to link
  while [ count everyone-set > 0 ] [
    ;; starting point for distance search
    let focus 0
    ;; make our candidate list empty
    let candidate-set no-turtles
    ;; while the candidate list is empty
    while [count candidate-set = 0 ] [
      ;; find candidates that are within the link range
      set candidate-set everyone-set with [ distance current-person < link-distance + focus ]
      ;; in case we didn't find any, increase the search distance
      set focus focus + link-distance
    ]
    ;; now pick a random one out of the candidate list
    let next-person one-of candidate-set
    ;; take that person out of the everyone list because they are taken care of
    set everyone-set everyone-set with [ self != next-person ]
    ;; put that onto the ordered person-list for order of linkage
    set person-list lput next-person person-list
    ;; make the next person the current person for the loop
    set current-person next-person
  ]
  ;; borrows heavily from Uri's implementation from here on
  let n 0
  while [n < length person-list ]
  [
    ;; create 2 legs to each has 2 in and 2 out connections.
    ;; with a small ratio of rewirings the loop is unlikely to
    ;; be severed or cut people out of the network.
    let lattice-legs 2
    ;; have a counter to step down list
    let lattice 1
    repeat lattice-legs [
      make-edge item n person-list
                item ((n + lattice) mod length person-list) person-list
      set lattice lattice + 1
    ]
    set n n + 1
  ]

  ;; now rewire to the user specification
  let potential-edges links
  if any? potential-edges [
    ask n-of (rewire-ratio * count potential-edges) potential-edges [
      ;; "a" remains the same
      let node1 end1
      ;; if "a" is not connected to everybody
      if [ count link-neighbors ] of end1 < (count people - 1)
      [
        ;; find a node distinct from node1 and not already a neighbor of node1
        let node2 one-of people with [ (self != node1) and (not link-neighbor? node1) ]
        ;; wire the new edge
        ask node1 [ create-link-from node2 ]
        ;; remove the old edge
        die
      ]
    ]
  ]
end 

;; this implements Uri's method of rewiring small world networks, modified for directed links

to make-edge [node1 node2]
  ask node1 [ create-link-from node2 ]
end 

;; this implements Allen Downey's Friends of Friends network as an example of a
;; "triangle" network to boost clustering. Unlike the other networks here,
;; this is non-directional like Facebook.

to make-friends-of-friends
  ;; http://allendowney.blogspot.com/2016/09/its-small-world-scale-free-network.html
  let m count people
  ;; make the core a subset of the total, scaled here to the population
  let n log m 10 * 10
  let p 0.10

  ;; make the fully connected core
  ;; randomly select people to make up the core
  let core n-of n people
  ask core [
    let node1 self
    ask other core [
      create-link-with node1
    ]
  ]

  ;; walk through each and make links to every other
  ;; the people that don't have links are the "others"
  let others people with [ count my-links = 0 ]
  ;; now make the triangles
  ask others [
    let link-target one-of core
    let link-from self
    let friends [link-neighbors] of link-target
    ask friends [
      if ( random-float 1.0 < p ) [
        let fof link-neighbors
        ask link-from [ create-link-with one-of fof with [ self != link-from ] ]
      ]
    ]
    create-link-with link-target
  ]
end