Complex Quality Improvement Network

extensions [nw] ;; This is the netlogo network extension called from the code
directed-link-breed [ directed-edges directed-edge ] ;; category of link. Only used for centrality measures
undirected-link-breed [ undirected-edges undirected-edge ] ;; category of link. Only used for centrality measures

Globals ;; global variables (these are the observer-level variables)

[
  Signal
  Iteration-count
 ]


turtles-own ;; Potential agent states
[
  susceptible?        ;; if true, the turtle will accept the new environmental signal and can be updated
  updated?            ;; if true, the turtle has been updated with the new environmental signal
  agreed?             ;; if true, the turtle has a shared problem-solving schema
  implemented?        ;; if true, the turtle has implemented the agreed problem-solving action
  reviewed?           ;; if true, the turtle has reviewed the problem solving action
  adjusted?           ;; if true, the turtle has adjusted the problem solving action
  resistant?          ;; if true, the turtle will resist/reject the new signal and can't be updated
  schema-check-timer  ;; number of ticks since this turtle's last schema-check
  ]

to setup
  clear-all
   if Network-source = "Generate" ;; This 'if' condition prevents accidently generating a network over the top of an imported network
  [create-network]
    set-current-plot "degree distribution"
   set signal (Signal-base + (0))
  set-default-shape turtles "person"
     reset-ticks
end 

to cycle
  ask turtles
 [ set color blue
  set adjusted? false ;;one of two end states from previous cycle
  set susceptible? true
  set resistant? false ;;one of two end states from previous cycle
  become-susceptible
  set schema-check-timer random schema-check-frequency
    ]
   set Iteration-count Iteration-count + 1 ;; tracking 1 iteration
  set-current-plot "Network Status"
    ask n-of Initial-detection-size turtles ;; this sets the initial update size
    [ become-updated ]
  ask links [ set color yellow ]
end 

;; Load network ;;Only used if importing a network - not used if generating the network

to load-network
  nw:set-context turtles links
  nw:load-graphml "CQINTest1.graphml" ;;target graphml file must be in C:\Users\bill\OneDrive\Documents\NetLogo ;; (i.e. must be the same folder as the model)
   [
  set size 3
       set shape "person"
    ;; set color blue
    set updated? false
    set susceptible? true
    set resistant? false
     become-susceptible
    set schema-check-timer random schema-check-frequency
  ]
  reset-ticks
end 

;;Generate networks rather than use imported network

to create-network ;; create the agent network - random or preferential attachment
  if network-type = "random"
 [setup-nodes
    setup-spatially-clustered-network ]
   if network-type = "preferential-attachment" [create-preferential-attachment ]
end 

to setup-nodes
  set-default-shape turtles "person"
    create-turtles number-of-nodes
 [
    ; for visual reasons, we don't put any nodes *too* close to the edges
    setxy (random-xcor * 0.9) (random-ycor * 0.9)
    set size 1.5
    become-susceptible
   set schema-check-timer random schema-check-frequency
 ]
end 

to create-preferential-attachment ;; this is the Barabasi-Albert method of creating a preferential attachment graph
    nw:generate-preferential-attachment turtles links (number-of-nodes) (node-degree) ;; N.B for this  preferential attachment code in Netlogo the node degree represents the MINIMUM degree
  [
    set size 2
    set shape "person"
    set color blue
    set updated? false
    set susceptible? true
    set resistant? false
    become-susceptible
    set schema-check-timer random schema-check-frequency
      ]
end 

to create-random-network ;; generate an Erdos-Renyi random graph
    nw:generate-random turtles links (number-of-nodes) (number-of-nodes * node-degree / 2  * 0.5) [
    set size 1.5
    set shape "person"
    set color blue
    set updated? false
    set susceptible? true
    set resistant? false
  ]
end 

to layout ;; visually set out network
 repeat 20 [
;; layout-spring turtles links 1 22 4
   layout-spring turtles links 0.7 20 3
;; layout-radial turtles links (turtle 0)
;; layout-circle turtles 18
;; update-plots
   display
     ]
end 

to setup-spatially-clustered-network
  let num-links (node-degree * number-of-nodes) / 2  ;; for random network node degree is average
  while [count links < num-links ]
  [
    ask one-of turtles
    [
      let choice (min-one-of (other turtles with [not link-neighbor? myself])
                   [distance myself])
      if choice != nobody [ create-link-with choice ]
    ]
  ]
  ; make the network look a little prettier
  repeat 10
  [
   layout-spring turtles links 0.3 (world-width / (sqrt number-of-nodes)) 1
  ]
end 


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; set initial signal detection;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to trigger
;; Note that this can be repeated if desired
  set Iteration-count Iteration-count + 1 ;; tracking 1 iteration
  set-current-plot "Network Status"
     ask n-of Initial-detection-size turtles ;; this sets the initial update size
    [ become-updated ]
  ask links [ set color yellow ]
  reset-ticks
end 

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Underlying process sequence (The Improvement cycle phases);;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to go  ;; this is the first phase of the learning classifier cycle, detecting and assigning credit to a new environmental signal
  if count turtles with [resistant?] >= count turtles * max-non-co-operating
    [stop]
  if  all? turtles [updated? or resistant?]
    [stop]
      if Iteration-count = Planned-iterations + 1
  [stop]
     if Signal = Signal-target
  [stop ]
  ask turtles
  [
     set schema-check-timer schema-check-timer + 1
     if schema-check-timer >= schema-check-frequency
       [ set schema-check-timer 0 ]
  ]
  spread-signal
   do-schema-checks
    tick
;;  nw:save-graphml "example.graphml" ;; option saves generated network to graphml format for analysis outside netlogo
end 

to go-2  ;; this is the second phase of the learning classifier cycle, determining and agreeing available problem-solving elements and actions
  if count turtles with [resistant?] >= count turtles * max-non-co-operating
  [stop]
  if all? turtles [agreed? or resistant?]
   [ stop ]
 if Iteration-count = Planned-iterations + 1
   [ stop ]
  if Signal = Signal-target
  [stop ]
  ask turtles
   [
     set schema-check-timer schema-check-timer + 2
    if schema-check-timer >= schema-check-frequency
       [ set schema-check-timer 0 ]
  ]
problem-solve
    do-schema-checks-2
  tick
end 

to go-3  ;; this is the third phase of the learning classifier cycle, implementing problem-solving actions
  if count turtles with [resistant?] >= count turtles * max-non-co-operating
  [stop]
  if all? turtles [implemented? or resistant?]
   [ stop ]
  if Iteration-count = Planned-iterations + 1
  [stop]
   if Signal = Signal-target
  [stop ]
    ask turtles
   [
     set schema-check-timer schema-check-timer + 3
    if schema-check-timer >= schema-check-frequency
       [ set schema-check-timer 0 ]
  ]
 implement
  do-schema-checks-3
  tick
end 

to go-4  ;; fourth phase of the learning classifier cycle, check/assess effectiveness, progress, unintended consequences
   if count turtles with [resistant?] >= count turtles * max-non-co-operating
  [stop]
  if all? turtles [reviewed? or resistant?]
   [ stop ]
 if Iteration-count = Planned-iterations + 1
  [stop]
   if Signal = Signal-target
  [stop ]
  ask turtles
   [
     set schema-check-timer schema-check-timer + 4
    if schema-check-timer >= schema-check-frequency
       [ set schema-check-timer 0 ]
  ]
 review
  do-schema-checks-4
  tick
end 

to go-5  ;; fifth phase of the learning classifier cycle, adjusting (within intended parameters)
 if count turtles with [resistant?] >= count turtles * max-non-co-operating
  [stop]
  if all? turtles [adjusted? or resistant?]
   [ stop ]
  if Iteration-count = Planned-iterations + 1
  [stop]
   if Signal = Signal-target
  [stop ] if Signal = Signal-target
  [stop ]
    ask turtles
   [
     set schema-check-timer schema-check-timer + 5
    if schema-check-timer >= schema-check-frequency
       [ set schema-check-timer 0 ]
  ]
 adjust
  do-schema-checks-5
  tick
end 

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; turtle procedures (behaviour and actions);;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

to become-susceptible  ;; turtle procedure
  set susceptible? true
  set updated? false
  set agreed? false
  set implemented? false
  set reviewed? false
  set adjusted? false
  set resistant? false
  set color blue
end 

to become-updated  ;; turtle procedure
  set updated? true
  set susceptible? false
  set agreed? false
  set implemented? false
  set reviewed? false
  set adjusted? false
  set resistant? false
  set color red
end 

to become-agreed ;; turtle procedure
  set agreed? true
  set susceptible? false
  set updated? false
  set implemented? false
  set reviewed? false
  set adjusted? false
  set resistant? false
  set color green
end 

to become-implemented  ;; turtle procedure
  set implemented? true
  set susceptible? false
  set updated? false
  set agreed? false
  set reviewed? false
  set adjusted? false
  set resistant? false
  set color brown
end 

to become-reviewed  ;; turtle procedure
  set reviewed? true
  set susceptible? false
  set updated? false
  set agreed? false
  set implemented? false
  set adjusted? false
  set resistant? false
  set color pink
end 

to become-adjusted  ;; turtle procedure
  set adjusted? true
  set susceptible? false
  set updated? false
  set agreed? false
  set implemented? false
  set reviewed? false
  set resistant? false
  set color orange
end 

to become-resistant  ;; turtle procedure
  set susceptible? false
  set updated? false
  set agreed? false
  set implemented? false
  set reviewed? false
  set adjusted? false
  set resistant? true
  set color gray
  ask my-links [ set color gray - 2 ]
end 

to spread-signal
  ask turtles with [updated?] ; n=initial detection size
    [ask link-neighbors with [susceptible? and not resistant?]
              [ if random-float 100  < (schema-share-effectiveness) * (Learning-gain ^ Iteration-count)
            [ become-updated ] ] ]
end 

to problem-solve
 ask turtles with [updated?]
  ;;ask turtles with [updated? or agreed?] ;;
     [ask link-neighbors with [updated? and not resistant?]
                 [ if random-float 100  < (schema-share-effectiveness) * (learning-gain ^ Iteration-count) * (problem-solving-effectiveness * (Learning-gain ^ Iteration-count)) / problem-space-complexity ;; Option 1: Rationale tbc
            [ become-agreed ] ] ]
end 

to implement
 ask turtles with [agreed?]
;;  ask turtles with [agreed? or implemented?]
      [ask link-neighbors with [agreed? and not resistant?]
                 [ if random-float 100  < (schema-share-effectiveness * (learning-gain ^ Iteration-count)) * ((problem-solving-effectiveness * (Learning-gain ^ Iteration-count)) / problem-space-complexity) * ((100 - coevolution-constraints) / 100) ;; Option 1: Rationale tbc
            [ become-implemented ] ] ]
end 

to review
 ask turtles with [implemented?]
 ;; ask turtles with [implemented? or reviewed?]
      [ask link-neighbors with [implemented? and not resistant?]
           [ if random-float 100  < (schema-share-effectiveness) * (Learning-gain ^ Iteration-count)
                         [ become-reviewed ] ] ]
end 

to adjust
   ask turtles with [reviewed?]
 ;; ask turtles with [reviewed? or adjusted?]
      [ask link-neighbors with [reviewed? and not resistant?]
        [ if random-float 100  < (schema-share-effectiveness) * (learning-gain ^ Iteration-count) * (problem-solving-effectiveness * (Learning-gain ^ Iteration-count)) / problem-space-complexity * (100 - coevolution-constraints) / 100  ;;
             [ become-adjusted ] ] ]
end 

to do-schema-checks
  ask turtles with [updated? and schema-check-timer = 0]
  [
    if random 100 < (rejection-threshold *(0.8 + (problem-space-complexity / 100 ))) ;; Rejection threshold hypothesised as lightly coupled to problem space complexity in this version
    [
    ifelse random 100 < (rejection-chance *(0.8 + (problem-space-complexity / 100 )))
        [become-resistant ]
        [become-updated]
     ]
  ]
end 

to do-schema-checks-2
ask turtles with [updated? and schema-check-timer = 0]
;;  ask turtles with [agreed? or updated? and schema-check-timer = 0]
;; ask turtles with [not resistant? and schema-check-timer = 0]
  [
    if random 100 < (rejection-threshold *(0.8 + (problem-space-complexity / 100 )))
    [
    ifelse random 100 < (rejection-chance *(0.8 + (problem-space-complexity / 100 )))
        [become-resistant]
        [become-agreed]
     ]
  ]
end 

to do-schema-checks-3
   ask turtles with [agreed? and schema-check-timer = 0]
;;  ask turtles with [implemented? or agreed? and schema-check-timer = 0]
 ;;  ask turtles with [not resistant? and schema-check-timer = 0]
  [
    if random 100 < (rejection-threshold *(0.8 + (problem-space-complexity / 100 )))
    [
    ifelse random 100 < (rejection-chance *(0.8 + (problem-space-complexity / 100 )))
        [become-resistant]
        [become-implemented]
     ]
  ]
end 

to do-schema-checks-4
 ask turtles with [implemented? and schema-check-timer = 0]
;;  ask turtles with [reviewed? or implemented? and schema-check-timer = 0]
  ;;  ask turtles with [not resistant? and schema-check-timer = 0]
  [
    if random 100 < (rejection-threshold *(0.8 + (problem-space-complexity / 100 )))
    [
    ifelse random 100 < (rejection-chance *(0.8 + (problem-space-complexity / 100 )))
        [become-resistant]
        [become-reviewed]
     ]
  ]
end 

to do-schema-checks-5
 ask turtles with [reviewed? and schema-check-timer = 0]
;; ask turtles with [adjusted? or reviewed? and schema-check-timer = 0]
  ;;  ask turtles with [not resistant? and schema-check-timer = 0]
  [
    if random 100 < (rejection-threshold *(0.8 + (problem-space-complexity / 100 )))
    [
    ifelse random 100 < (rejection-chance *(0.8 + (problem-space-complexity / 100 )))
        [become-resistant]
        [become-adjusted]
     ]
  ]
  if count turtles with [resistant?] < count turtles * max-non-co-operating
    [set signal (Signal-base + (Signal-increment * Iteration-count))]
show-signal
end 

to show-signal
  output-show Signal
end 

;;;;;;;;;;;;;;;;;;;;;;;;
;; Centrality measures;;
;;;;;;;;;;;;;;;;;;;;;;;;

;; This section of code is from the Netlogo model library - 'Extensions NW General' Examples

to-report get-links-to-use ;; Reports the link set corresponding to the value of the links-to-use combo box
 report ifelse-value links-to-use = "directed"
   [ directed-edges ]
    [ undirected-edges ]
end 

to betweenness
  centrality [ -> nw:betweenness-centrality ]
end 

to eigenvector
  centrality [ -> nw:eigenvector-centrality ]
end 

to closeness
 centrality [ -> nw:closeness-centrality ]
end 

; Takes a centrality measure as a reporter task, runs it for all nodes
; and set labels, sizes and colors of turtles to illustrate result

to centrality [ measure ]
  nw:set-context turtles links
 ask turtles [
    let res (runresult measure) ; run the task for the turtle
    ifelse is-number? res [
      set label precision res 2
     set size res ; this will be normalized later
    ]
   [ ; if the result is not a number, it is because eigenvector returned false (in the case of disconnected graphs
      set label res
     set size 1
   ]
 ]
  normalize-sizes-and-colors
end 

; We want the size of the turtles to reflect their centrality, but different measures
; give different ranges of size, so we normalize the sizes according to the formula
; below. We then use the normalized sizes to pick an appropriate color.

to normalize-sizes-and-colors
  if count turtles > 0 [
    let sizes sort [ size ] of turtles ; initial sizes in increasing order
    let delta last sizes - first sizes ; difference between biggest and smallest
    ifelse delta = 0 [ ; if they are all the same size
      ask turtles [ set size 1 ]
    ]
    [ ; remap the size to a range between 0.5 and 2.5
      ask turtles [ set size ((size - first sizes) / delta) * 2 + 0.5 ]
    ]
    ask turtles [ set color scale-color red size 0 5 ] ; using a higher range max not to get too white...
  ]
end 

;;;;;;;;;;;;;
;; Clusters;;
;;;;;;;;;;;;;

;; This section of code from the Netlogo model library - Extensions NW General Examples

; Colorizes each node according to the community it is part of

to community-detection
  nw:set-context turtles get-links-to-use
  color-clusters nw:louvain-communities
end 

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Highlighting and coloring of clusters ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;; This section of code from the Netlogo model library - Extensions NW General Examples

to color-clusters [ clusters ]
  ; reset all colors
  ask turtles [ set color gray ]
  ask links [ set color gray - 2 ]
  let n length clusters
  ; Generate a unique hue for each cluster
  let hues n-values n [ i -> (360 * i / n) ]

  ; loop through the clusters and colors zipped together
  (foreach clusters hues [ [cluster hue] ->
    ask cluster [ ; for each node in the cluster
                  ; give the node the color of its cluster
      set color hsb hue 100 100
      ; Color links contained in the cluster slightly darker than the cluster color
      ask my-links with [ member? other-end cluster ] [ set color hsb hue 100 75 ]
    ]
  ])
end 

;; Bill Wilson Complex Quality Improvement Network (CQIN) Massey University Research Project 2020-2023

; Reference Model: 'Virus on a network'
; Copyright 2008 Uri Wilensky.
; See Info tab for full copyright and license.