Use Network

extensions [
  nw
]

breed [nodes node]
breed [messages message]

messages-own [
  location ;;holds a node in which a message is
]

nodes-own[
  ;; Use Net
  target ;;target as a message destination
  ;; this RECEIVDED is not used well in this implementation
  ;; But this is useful to see which node is "actually used as a "hub"
  received ;;if a node received, add 1
  ;; Choose Net
  distance-to-other-nodes   ;; list of distances of this node to other turtles
  ;; Local Search
  localset ;; holds a local agentset
  ;; Homophily
  gender ;; gender to either 0 "male" or 1 "female"
]

links-own [
  used ;;if a message went through a link, add 1
]

globals [
  ;; Use Net
  origin ;;holds a starting node
  current-location ;; holds a node where a message is currently
  next-location ;; owns a node where a message goes next
  target-node ;;holds a target node
  unreachable ;;holds true/false
  number-of-unreachable ;;counts unreachable cases
  steps ;;holds count of steps
  steps-record ;;holds a list of steps per session
  min-pl-record ;; holds a list of min path length per session
  min-pl ;; holds min distance between the origin and target
  number-of-sessions ;;owns the count of sessions
  incomplete ;;holds the number of imcomplete cases
  incomplete-case ;;holds true/false
  deadend ;;holds true/false
  number-of-deadend ;;counts deadend cases
  actual-average-pl ;; average path length of the network
  number-of-neighbors ;; holds [out-link-neighbors] of location
  ;; Choose Net
  average-path-length ;; average path length of the network
  pl-list ;; list of distances of this node to other turtles
  unconnected ;; holds the number of unconnected pairs
  connected ;; holds the number of connected pairs
]

;;;;;;;;;;;;;;;;;;;;;
;; Setup Procedure ;;
;;;;;;;;;;;;;;;;;;;;;

to setup
  clear-all
  set-default-shape nodes "circle"
  create-nodes number-of-nodes [set color blue]
  ask nodes [
    create-links-to n-of number-of-links other nodes
    set target one-of other nodes
    set received 0
    set gender random 2 ;; set gender to either 0 "male" or 1 "female"
  ]
  layout
  message-setup
  ask target-node [
    set color red
  ]
  ask nodes [
    set localset (min-n-of 4 other nodes [distance myself]) ;; holds a turtles-own variable
  ]
  local-search
  link-setup
  ask origin [
    ifelse nw:distance-to target = False [
    set min-pl 0 ][
    set min-pl nw:distance-to target]
  ]
  set number-of-sessions 0
  set unreachable false
  set incomplete 0
  unreachable-setup
  set steps-record []
  set min-pl-record []
  ;; Choose Net
  find-path-lengths
  find-connected-pairs
  path-length-list
  find-average
  reset-ticks
end 

;;circle layout

to layout
  layout-circle (sort nodes) max-pxcor - 1
end 

to go
  if any? messages with [location = target-node][
    set steps number-of-steps
    set steps-record lput number-of-steps steps-record
    set min-pl-record lput min-pl min-pl-record
    set number-of-sessions number-of-sessions + 1
    target-resetup
  ]
  unreachable-setup
  if unreachable = true [
    set unreachable false
    set number-of-unreachable number-of-unreachable + 1
    set steps 0
    set steps-record lput 0 steps-record ;; tentatively assign 0 but INF should be more appropriate...
    set min-pl-record lput 0 min-pl-record
    set number-of-sessions number-of-sessions + 1
    target-resetup
  ]
  wrong-choice
  if deadend = true [
    set deadend false
    set number-of-deadend number-of-deadend + 1
    set steps 0
    set steps-record lput 0 steps-record;; tentatively assign 0 but INF should be more appropriate...
    set min-pl-record lput 0 min-pl-record
    set number-of-sessions number-of-sessions + 1
    target-resetup
  ]
  ask links [
    set thickness 0
    ask links with [used >= 1]
      [set thickness 0.3]
  ]
  message-procedure
  tick
end 

;;;;;;;;;;;;;;;;;;;;;;;
;; Use Net procedure ;;
;;;;;;;;;;;;;;;;;;;;;;;

;;mesasge procedure

to message-procedure
  ask messages [
    if not any? [out-link-neighbors] of location [
      stop
    ]
    set current-location location
    ;set upper limits of passing messages through links
    ifelse route-limits? [
      ;; 1 as an arbitrary limit
      let out-link-node [my-out-links with [(used < 1) and (self != myself)]] of current-location
      ifelse  count out-link-node > 1 ;;count out-link-node = number-of-links
      [set number-of-neighbors turtle-set [end2] of out-link-node
        if search-strategy = "random-search"
        [set next-location one-of number-of-neighbors] ;[out-link-neighbors] of location]
        if search-strategy = "local-search"
        [ls-strategy]
        if search-strategy = "homophilious-search"
        [homophily]
        if search-strategy = "preferential-attachment"
        [preferential]
      ]
      ;; if running out of available links a node can use, end the session
      [ifelse count out-link-node = 0
        [set incomplete incomplete + 1
        set incomplete-case true
        stop]
        [set next-location one-of turtle-set [end2] of out-link-node]
      ]
    ][
    set number-of-neighbors [out-link-neighbors] of current-location
      if search-strategy = "random-search"
      [set next-location one-of number-of-neighbors] ;[out-link-neighbors] of location]
      if search-strategy = "local-search"
      [ls-strategy]
      if search-strategy = "homophilious-search"
      [homophily]
      if search-strategy = "preferential-attachment"
      [preferential]
    ]
    let new-location next-location
    ;; change the thickness of the link as a message moves
    ask [out-link-to new-location] of location [set thickness 0.3 set used used + 1]
    face new-location ;; not strictly necessary, but improves the visuals a bit
    move-to new-location
    set location new-location
    ask location [
      set received received + 1 ;; increase received
    ]
  ]
  if incomplete-case = true [
    set number-of-sessions number-of-sessions + 1
    set incomplete-case false
    target-resetup
  ]
end 


;;new round setup

to target-resetup
  ask nodes [
    set target one-of other nodes
    ;set received 0
    set color blue
  ]
  ask messages [die]
  message-setup
  ask target-node [
    set color red
  ]
  link-setup
  ;unreachable-setup
  ask origin [
    ifelse nw:distance-to target = False [
    set min-pl 0 ][
    set min-pl nw:distance-to target]
  ]
  reset-ticks
end 

;;procedure for target

to message-setup
  create-messages 1 [ ;; TO DO: replace 1 to a slider
    set color orange
    set location one-of nodes
    set origin location
    set target-node [target] of location
    move-to location
  ]
end 

;;link weight

to link-setup
  ask links [
    set used 0
    set thickness 0
    ;ask links with [used >= 1]
      ;[set thickness 0.3]
  ]
end 

;;detect an unreachable case

to unreachable-setup
  ;;an empty means no path b/w the origin and target exists
  if empty? [nw:path-to target-node] of origin [
    set unreachable true
  ]
end 

;;critical mistakes of route choices
;;where a path to the target becomes no longer avaiable

to wrong-choice
  ask messages [
    ask location [
      if empty? nw:path-to target-node [
        set deadend true
      ]
    ]
  ]
end 

;; average simulated path length

to-report calculate-average
  let avg-pl filter [? != 0] steps-record
  set actual-average-pl (sum avg-pl) / (length avg-pl)
  report actual-average-pl
end 

to-report unreachable-pairs
  report number-of-unreachable
end 

to-report number-of-steps
  report ticks
end 

to-report sessions
  report number-of-sessions
end 

to-report incompletes
  report incomplete
end 

;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Choose Net procedure ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;

to path-length-list
  set pl-list []
  foreach sort nodes [
    let x [distance-to-other-nodes] of ?
    set pl-list sentence pl-list x
  ]
end 

;; calculate the number of unconnected pairs and connected pairs

to find-connected-pairs
  set connected 0
  set unconnected 0
  let i 0 ;;holds a target turtle number
  let node-count count nodes
  foreach sort nodes[
    ask ? [
      while [ i < node-count ]
      [ifelse ? = node i ;;if a turtle is the same as i, skip it
        [set i i + 1]
        [ifelse empty? nw:path-to node i ;;since if there is no path from a turtle to i, return an empty list
          [
            set i i + 1
            set unconnected unconnected + 1
          ]
          [set i i + 1
            set connected connected + 1]
        ]
      ]
    ]
   set i 0 ;;set the default again
  ]
end 

;; calculate distance from turtles to other turtles only if they are connected with each other

to find-path-lengths
  ask nodes
  [
    set distance-to-other-nodes filter [is-number? ?] [[nw:distance-to myself] of myself] of other nodes
  ]
end 

;; average path length

to find-average
  set average-path-length (sum [sum distance-to-other-nodes] of nodes) / (connected)
end 

to-report avg-path-length
  report average-path-length
end 

to-report unreachable-path
  report unconnected
end 

;; calculate global clustering coefficient

to-report clustering-coefficient
  let closed-triplets sum [ nw:clustering-coefficient * count my-links * (count my-links - 1) ] of nodes
  let triplets sum [ count my-links * (count my-links - 1) ] of nodes
  report closed-triplets / triplets
end 

;; local search implementation of small-world networks

to local-search
  if small-world? [
    ask links [die]
    ask nodes [
      ;; if NUMBER of links are below 4, use n-of for localset since localset includes 4 neighbors
      ifelse number-of-links <= 4 [
        create-links-to n-of number-of-links localset
        if (random-float 1) < rewiring-probability [
          let rewire one-of other nodes with [ (self != myself) and (localset != myself) ]
          ask one-of links [ die ]
          create-link-to rewire
        ]
      ]
      [create-links-to localset
        create-links-to n-of (number-of-links - 4) other nodes with [ (self != myself) and (localset != myself) ]
      ]
    ]
  ]
end 

;;;;;;;;;;;;;;;
;; Cognition ;;
;;;;;;;;;;;;;;;

;; local search strategy

to ls-strategy
  ;; this procedure gives local knowledge of who is the target to nodes
  ;; but nodes don't hold any knowledge of long nodes which are not in their local set
  ;; If nodes hold long nodes and they don't find the target in their localset, then they send a message to a long node
  ask nodes [
    let l1 sort-on [who] [localset] of current-location
    let l2 sort-on [who] number-of-neighbors
    let long-node filter [? != l1] l2
    ifelse member? [target] of origin number-of-neighbors [
    ifelse member? [target] of origin [localset] of current-location [
      set next-location [target] of origin][
        ;; since some nodes don't rewire, make sure whether nodes have links with long-distant nodes
        ifelse empty? long-node[
          set next-location one-of number-of-neighbors][
          set next-location item random length long-node long-node
      ]
    ]
    ][ifelse empty? long-node[
          set next-location one-of number-of-neighbors][
          set next-location item random length long-node long-node
          ]
    ]
  ]
end 

;; homophily search

to homophily
  ;; A node holding a message prefers to send the same gender neighbor as target's gender
  ;; if they don't have any neighbor's gender same as target's, then they randomly choose next destination in their link neighbors
  ask nodes [
    ifelse any? number-of-neighbors with [gender = [gender] of target-node] [
      ;; a 70 percent chance to choose a contact whose gender is the same as target
      ;; Otherwise, follow the random choice procedure
      ;; this random implementation is not parcilarly something I'm not proud of...
      ;; 70 is an abtraral number, but it works both with & without route limits
      ifelse random 99 < 70 [set next-location one-of number-of-neighbors with [gender = [gender] of target-node]][
        set next-location one-of number-of-neighbors]
    ][set next-location one-of number-of-neighbors
    ]
  ]
end 

;; preferential attachment search

to preferential
  ;; nodes look at maximum indegree neighbor as their next message destination
  ask nodes [
    set next-location max-one-of number-of-neighbors [count [in-link-neighbors] of self ]
  ]
end