Axelrod_Cultural_Dissemination

;; Axelrod's Model for Cultural Evolution is an agent-based model described by 
;; Robert Axelrod in his paper:
;; Axelrod, R. 1997. “The dissemination of culture - A model with local convergence and global polarization.” 
;;        Journal of Conflict Resolution 41:203-226.
;;
;; 'Axelrod_Cultural_Dissemination.nlogo' implements this model with one extension: agents can move.
;; 
;; 2013 Arezky H. Rodríguez (arezky@gmail.com)
;; 

;; -------------------------------------------------- ;;
;;;;;;;;;;;;;;;;;
;;; VARIABLES ;;;
;;;;;;;;;;;;;;;;;

globals [
  number_of_agents                ;; number of all agents in the society
  Cult_max                        ;; number related with the maximun cultural value of an agent (q-1 q-1 q-1 ... q-1)
  number_of_cultures              ;; number of cultures in the society
  number_of_possible_interactions ;; number of possible interactions at each tick that could be according to cultural overlap between agents
  number_of_real_interactions     ;; number of real interactions at each tick that occurs according to cultural overlap between agents
  time                            ;; time
  component-size                  ;; number of turtles explored so far in the current component
  giant-component-size            ;; number of turtles in the giant component  
  number_of_cultural_regions      ;; number of cultural regions simply connected
  number_of_active_agents         ;; number of agents which have at leat one neighbor (other agent in-radius 'radius' with 
                                  ;;                  overlap between 0 and 1 (not including the extremes of the intervale)
]

turtles-own [
  culture                         ;; culture of an agent
  explored?                       ;; if the agent is already explored (or not) when determining number of cultural regions
]

patches-own [ ]

;; -------------------------------------------------- ;;
;;;;;;;;;;;;;;;;;;;;;;;;
;;; SETUP PROCEDURES ;;;
;;;;;;;;;;;;;;;;;;;;;;;;

;; 
;; General setup settings
;; 

to setup
  clear-all
  clear-all-plots
  
  resize-world 0 (world-size - 1) 0 (world-size - 1)   ;; defining the size of the society (number of patches
  set number_of_agents (world-size * world-size)       ;; one agent per patch
  set-patch-size 360 / world-size                      ;; setting patch size for good looking
  ask patches [set pcolor 34]                          ;; setting color of patches
  set giant-component-size 0                           ;; initializing the number of agent in the bigger cultural domain
  set number_of_cultural_regions 0                     ;; initializing the number of the cultural domains
  
  setup-turtles                                        ;; creating the agents, locating them and setting their cultural values randomly

  reset-ticks
  set time 0
end 

;; 
;; Turtles settings
;; 

to setup-turtles
  set-default-shape turtles "default"
  create-turtles number_of_agents [
    set size 0.8
    while [any? other turtles-here] [ move-to one-of patches ] ;; setting agent location. Only one agent at each patch
  ]

  setup-culture-max                                       ;; asigning a value to the culture with maximum traits value
  setup-agent-culture                                     ;; setting agents culture
  count-cultures                                          ;; counting the amount of different cultures at time = 0
  do-plots                                                ;; plotting for visualization
end 

;; 
;; setting agents culture
;; 

to setup-agent-culture
  ask turtles [
    set culture []
    repeat f [
      set culture lput random q culture                   ;; setting a random trait to each feature of the agent culture
    ]
    setup-agent-culture-color                             ;; setting a color for an agent according to its culture
  ]
end 

;; 
;; asigning a value to the culture with maximum traits values
;; it is done mapping the traits value to a number in base q
;; 

to setup-culture-max
  let i 1
  let suma 0
  repeat F [
    set suma suma + q ^ (F - i)
    set i i + 1
  ]
  set Cult_max ((q - 1) * suma)
end 

;; -------------------------------------------------- ;;
;;;;;;;;;;;;;;;;;;;;;;
;;; MAIN PROCEDURE ;;;
;;;;;;;;;;;;;;;;;;;;;;

to go
  clear-links
  let repeating? true
  while [repeating?] [
    set number_of_possible_interactions 0                            ;; setting initial values
    set number_of_real_interactions 0
    set number_of_active_agents 0
    ask turtles [                                                    ;; asking agents to move and interact localy 
      if random-float 1.0 < veloc [ random-move ]                    ;;   moving (in case veloc > 0)
      cultural-interaction                                           ;; all agents interact in asyncronous-random updating
    ]

    if number_of_active_agents = 0 [set repeating? false]            ;; stopping when there are no active agents
    set time time + 1                                                ;;   it happens when each agent has full or null overlap with
                                                                     ;;   each of its neighbors.
                                                                     ;;   neighbors are all agents in radius 'radius'
    count-cultures                                                   ;; counting the amount of different cultures
    do-plots                                                         ;;   and plotting for visualization
    tick
  ]

  count-turtles-on-bigger-region                                     ;; when running stops, count number of agents in the bigger domain
                                                                     ;;   and the amount of domains

  if saving? [                                                       ;; to save if saving? true
    let file_out_name  (word "F" F "L" world-size "r" radius ".dat") ;;   it is saved a file with values of
    file-open file_out_name                                          ;;   q, number of agents in the bigger cultural domain (normalized), number of cultural domains (normalized)
    file-print (word q " " (giant-component-size / number_of_agents) " " (number_of_cultural_regions / number_of_agents))
    file-close      
  ]
  stop
end 

;; 
;; calculating number cultures on the whole society
;; 

to count-cultures
  let list_of_cultures []
  ask turtles [
    ; setting agent culture in base q
    let i 1
    let suma 0
    repeat F [
      set suma suma + item (i - 1) culture * q ^ (F - i) ;10 ^ (F - i)
      set i i + 1
    ]
    set list_of_cultures fput suma list_of_cultures                    ;; including each culture (its corresponding number) in a list
  ]
  set list_of_cultures remove-duplicates list_of_cultures              ;; removing repeted cultures
  set number_of_cultures length list_of_cultures                       ;; the amount of different cultures is the length of the list
end  

;; 
;; counting the number of agent in the biggest culture
;; 

to count-turtles-on-bigger-region
  ; first it is linked all agents of the same culture (each agent looks for a neighbour which is in its neighborhood (agent inside in radius)
  ask turtles [
    creates-links-with-same-cultural-neighbours-in-neighborhood-of-radio-radius
  ]
  find-all-components                                                  ;; exploring each connected network finding and counting agents of the same culture
end 

;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Network Exploration ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;

;; 
;; to find all the connected components in the network, their sizes and starting turtles
;; 

to find-all-components
  ask turtles [ set explored? false]
  ;; keep exploring till all turtles get explored
  loop
  [
    ;; pick a node taht has not yet been explored
    let starting_turtle one-of turtles with [ not explored? ]
    if starting_turtle = nobody [ stop ]
    ;; reset the number of turtles found to 0. This variable is updated each time we explore an unexplored node
    set component-size 0
    ;; find all turtles reachable from this node
    ask starting_turtle [ 
      explore     
      ;; after each explore procedure finishes it is explored one cultural region, so increment the counter (  number_of_cultural_regions )
      set number_of_cultural_regions number_of_cultural_regions + 1
    ]
    ;; the explore procedure updates the component-size variable, so check, have we found a new giant component?
    if component-size > giant-component-size [
      set giant-component-size component-size
    ]
  ]
end 

;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; TURTLES' PROCEDURES ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;

;; 
;; Finds all turtle reachable from this node (it is a recursive procedure)
;; 

to explore ;; turtle procedure
  if explored? [ stop ]
  set explored? true
  set component-size component-size + 1
  ask link-neighbors [ explore ]
end 

;; 
;; agents look for a neighbor to interact
;; 

to cultural-interaction
  ;counting any turtle for interacting at distance less than radius and with overlap between 0 and F (not includying)
  let number_of_possible_neighbors count other turtles in-radius radius with [(0 < overlap_between self myself ) and (overlap_between self myself < F)]
  ;if there are neighbors for interacting, setting agent neighbor.
  if number_of_possible_neighbors > 0 [
    set number_of_active_agents number_of_active_agents + 1
    let neighbor_turtle one-of other turtles in-radius radius
    ;interacting the cultures
    let target_turtle self
    culturally_interacting target_turtle neighbor_turtle
  ]
end 

;; 
;; an agent creates a link with all it neighbors with the same culture
;; 

to creates-links-with-same-cultural-neighbours-in-neighborhood-of-radio-radius
  let neighborhood other turtles in-radius radius
  ask neighborhood [
    if overlap_between self myself = F [ create-link-with myself ]                ;; overlap_between is a reporter
  ]
end 

;; 
;; setting interaction between target agent and neighbor selected
;; 

to culturally_interacting [target_turtle neighbor_turtle]
  let overlap overlap_between target_turtle neighbor_turtle
  if (0 < overlap and overlap < F ) [
    set number_of_possible_interactions number_of_possible_interactions + 1       ;; if interaction is possible increment the counter
    let prob_interaction (overlap / F)                                            ;; setting the probability of interaction
    if random-float 1.0 < prob_interaction [
      set number_of_real_interactions number_of_real_interactions + 1
      ;choosing a feature position randomly where the two cultures are different
      let trait random F                                                          ;; generates a number between 0 and (F - 1)
      let trait_selected? false
      while [not trait_selected?] [
        ifelse (item trait [culture] of target_turtle = item trait [culture] of neighbor_turtle)
        [
          set trait ((trait + 1) mod F)                                           ;; looking for other feature
        ]
        [
          set trait_selected? true                                                ;; found a feature with different cultural traits
        ]
      ]
      let new_cultural_value (item trait [culture] of neighbor_turtle)
      set culture replace-item trait culture new_cultural_value                   ;; replacing/copying the neighbor trait
      setup-agent-culture-color                                                   ;; updating the agent color according to its new culture
    ]
  ]
end 

;; 
;; random move according to 'steplength' and 'angle' for rotating
;; 

to random-move
  let var (random angle + 1)                                           ;; selecting and angle to rotate
  set heading (heading +  var - ((angle + 1) / 2))                     ;; mapping for left and right
  ifelse can-move? steplength                                          ;; in case of no periodic boundary conditions, if agent at the border 
  [                                                                    ;;     rotate with any angle for new direction
    forward steplength
  ]
  [
    set heading random 360
    forward steplength
  ]
end 

;; 
;; setting the color according to the culture
;; 

to setup-agent-culture-color
  ;setting agent culture in base q
  let i 1
  let suma 0
  repeat F [
    set suma suma + item (i - 1) culture * q ^ (F - i) 
    set i i + 1
  ]
  let Cult_base_q suma

  ;setting the corresponding color to the turtle according to the culture_base_q value. a range of blue is selected
  set color (9.9 * Cult_base_q / Cult_max) + 100
end 

;;;;;;;;;;;;;;
;;; GRAPHS ;;;
;;;;;;;;;;;;;;

to do-plots
  ;setting the plot of Cultures
  set-current-plot "Graph"
  set-current-plot-pen "Cultures"
  plotxy time (number_of_cultures / q ^ F)
  set-current-plot-pen "Possible interactions"
  plotxy time (number_of_possible_interactions / number_of_agents)
  set-current-plot-pen "Real interactions"
  plotxy time (number_of_real_interactions / number_of_agents)  
  set-current-plot-pen "Active agents"
  plotxy time (number_of_active_agents / number_of_agents)
end 


;;;;;;;;;;;;;;;;;;;;;;;;;
;;; REPORT PROCEDURES ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;

;; reporting overlap between two agents

to-report overlap_between [target_turtle neighbor_turtle]
  let suma 0
  (foreach [culture] of target_turtle [culture] of neighbor_turtle
    [ if ?1 = ?2 [ set suma suma + 1]  ]
    )
  report suma
end 

;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; PATCHES' PROCEDURES ;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;

;; there are no patches procedures