Binary Spin Lattice

3 collaborators

Fred Browning (Author)

Jennifer Campos (Author)

Kaitlyn Moore (Author)

WHAT IS IT?

This is a model of a binary spin lattice thermodynamic system that measures properties such as temperature, entropy, total energy. The spins in the binary spin lattice system can either be up representing an excited state or can be down representing the ground state. These spins can be influenced and flipped by neighboring spins.

HOW IT WORKS

In this model, the patches represent nuclei that are in different energy states. These energy states can change when influenced by neighboring patches. If most of neighboring patches are spin up or greater than zero, then the patch being influenced will flip up to the excited state and if this is not the case, then the patch will flip down to the ground state.

The model stops when the temperatures of the two spin groups have reached thermal equilibrium.

The switches will affect the outcome of thermodynamic properties, the world division switch makes one spin group large and the other spin group smaller.

The sliders will also affect the outcome of the simulation. Any percent extied slider above fifty will produce a negative temperature and any below will produce a positive temperature.

HOW TO USE IT

SET UP: a button that resets the model and updates any changes made to the sliders and/or switches.

GO: a button that continually runs the simulation.

MONITORS: temp3 a, temp3 b, entropy3 a, entropy3 b, total entropy3, total energy3 a, total energy3 b, and total total energy3 are monitors in the interface that are updated while the simulation is running. The final measurements on the monitors reflect when both spin groups are at equilibrium with each other.

PERCENT EXCITED A: a slider that allows the percent of excited nuclei to vary for spin group a (blue group).

PERCENT EXCITED B: a slider that allows the percent of excited nuclei to vary for spin group b (pink group).

DENSE SETUP: a switch that splits the world in half creating spin group a and spin group b and allows the percent of excited nuclei of each spin group to be contained on either side of the world.

WORLD DIVISION: a switch that isolates spin group b in the bottom right corner which results in a larger spin group a.

PLOTS: these plots will continue to update throughout the simulation.

THINGS TO NOTICE

When the spin group temperatures are transitioning from a positive temperature to a negative temperature or vice versa, the temp3 a and temp3 b plot will fluctuate between the boundary of positive infinity to negative infinity. The plot is discontinuous between the positive and negative infinites during this time because the program reads these values as extremely positive or extremely negative contrary to the kelvin scale where they are near each other.

THINGS TO TRY

Analyze how the temperatures react when both switches are on and percent excited a is much greater then percent excited b as well as when percent excited a is much less than percent excited b. Compare and contrast the final data with different switch scenarios.

When both switches are on, try setting percent excited b two percents higher than percent excited a and determine why it only took less than five ticks to reach equilibrium. Also, vary delta e to determine if this slider increases or decreases the amount of ticks.

Next, try setting the percent excited's three values away from each other and manipulate delta e to compare the number of ticks it takes to reach equilibrium when both switches are on.

Observe the differences between having different switches on or off and how it affects the number of ticks to reach equilibrium.

EXTENDING THE MODEL

Creating a three-level system
Changing the world division to occupy a larger or smaller space within the world thus enabling one group to act as a heat reservoir
Modifying the world size of the spin groups
Including the entropy of mixing

RELATED MODELS

Ising Model (in the Chemistry & Physics - GasLab Section of Models Library)

CREDITS AND REFERENCES

This model was created by Jennifer Campos and Kaitlyn Moore as part of Palm Beach Atlantic University's Summer UnderGraduate Academic Research (SUGAR) Program.

Credit to: Dr. Fred Browning for advising this modeling project

Wilensky, U. (2003). NetLogo Ising model. http://ccl.northwestern.edu/netlogo/models/Ising. Center for Connected Learning and Computer-Based Modeling, Northwestern University, Evanston, IL.

Wilensky, U. (1999). NetLogo. http://ccl.northwestern.edu/netlogo/. Center for Connected Learning and Computer-Based Modeling, Northwestern University, Evanston, IL.

Additional resources that were used to complete this model:

Kelly, J. (1996-2002). Ensembles. http://www.physics.umd.edu/courses/Phys603/kelly/Notes/Ensembles.pdf. Statistical Physics using Mathmatica.

Kittel C. & Kroemer H. (1980). Thermal Physics, Second Edition. University of California, San Francisco. W. H. Freeman and Company, NY.

Railsback, S. F., & Grimm, V. (2012). Agent-based and individual-based modeling: A practical introduction. Princeton, N.J: Princeton University Press.

Klein, M. (1956) Thermodynamics and Statistical Mechanics at Negative Absolute Temperatures. Physical Review, 103, 20-28.

Section 2: Introduction to Statistical Mechanics. (1997). http://personal.rhul.ac.uk/uhap/027/ph2610/ph2610_files/sect2.pdf.

Wikipedia Contributors. (3 June 2017). Population Inversion. https://en.wikipedia.org/wiki/Population_inversion. Wikipedia, The Free Encyclopedia.

Comments and Questions

Please start the discussion about this model! (You'll first need to log in.)

Click to Run Model

globals [          ; variables for spin groups a (blue) and spin group b (pink)
  spin_diff_a      ; difference between spin ups(e two's) and spin downs(e one's) in spin group a
  spin_diff_b      ; difference between spin ups and spin downs in spin group b
  n_two_a          ; excited state for spin group a (dark blue)
  n_two_b          ; excited state for spin group b (dark pink)
  n_one_a          ; ground state for spin group a (light blue)
  n_one_b          ; ground state for spin group b (light pink)
  total_energy_a   ; spin group a's total energy
  total_energy_b   ; spin group b's total energy
  e_one_a          ; spin downs for spin group a (blue) when negative
  e_one_b          ; spin downs for spin group b (pink) when negative
  e_two_a          ; spin ups for spin group a (blue) when positive
  e_two_b          ; spin ups for spin group b (pink) when positve
  n_total_a        ; total number of spins in group a
  n_total_b        ; total number of spins in group b
  entropy_a
  entropy_b
  temperature2_a
  temperature2_b
  free_energy_a
  free_energy_b
  delta_e_b
  spin_group_a     ; left side of the world in blue
  spin_group_b     ; right side of the world in pink
  temp_hold_a      ; compares previous step of spin group a and stops temperatures from crossing and flipping
  temp_hold_b      ; compares previous step of spin group b and stops temperatures from crossing and flipping
  spin_flip_a      ; keeps track on whether or not more than 50% of a spin group is exctied
  spin_flip_b
  spin_flip_hold_a ; compares previous step of spin group a and stops temperatures from crossing and flipping
  spin_flip_hold_b ; compares previous step of spin group b and stops temperatures from crossing and flipping
  ;
]

patches-own [spin        ; holds 1 or 2
             orientation ; -1 or 1 for spin 1 or 2 respectively
             spin_group  ; spin group a = 1 is blue and spin group b = 2 is pink
             ]

to setup
   ca                                                         ; resets all global variables to zero
  set e_one_a 100                                             ; ground state energy for spin group a (blue)
  set e_one_b 100                                             ; ground state energy for spin group b (pink)
  set delta_e_b delta_e_a                                     ; set the same enregy difference for both spin groups
  set e_two_a (e_one_a + delta_e_a)                           ; excited state energy for spin group a
  set e_two_b (e_one_b + delta_e_b)                           ; excited state energy for spin group b
  ask patches [set spin 1                                     ; sets all to ground state (spin down)
               set orientation -1]                            ; sets all to ground state (spin down)
  if dense-setup = true and world-division = true [setup1]
  if dense-setup = false and world-division = false [setup2]
  if dense-setup = true and world-division = false [setup3]
  if dense-setup = false and world-division = true [setup4]
    reset-ticks                                               ; resets ticks to zero and resets plots
end 

to setup1                                                                                    ; when both switches are on nuclei are contained and are distrubuted                                                                                               ; and world-division = true
  if world-division = true [                                                                 ; into rectangular blocks based on the amount of percent excited set
    set n_two_a ceiling ((percent_excited_a / 100) * (0.75 * world-width * world-height))    ; sets spin group a larger
    set n_two_b ceiling ((percent_excited_b / 100) * (0.25 * world-width * world-height))]   ; sets spin group b smaller
      set n_one_a floor ((world-width * world-height) - n_two_a)
      set n_one_b floor ((world-width * world-height) - n_two_b)
      set n_total_a floor (n_one_a + n_two_a)
      set n_total_b floor (n_one_b + n_two_b)
  ask patches [set spin_group 1
               set pcolor blue]
  ask patches [if pxcor >= world-width / 2 and pycor <= (world-height / 2) [set spin_group 2
                                                                            set pcolor pink]
    ]

 if dense-setup = true [
    set n_two_a ceiling ((percent_excited_a / 100) * (0.75 * world-width * world-height))
    set n_two_b ceiling ((percent_excited_b / 100) * (0.25 * world-width * world-height))

    let bw (world-width / 4)                                       ; sets block width where world is divided into 4 x 4 rectangles
    let bh (world-height / 4)                                      ; sets block height where world is divided into 4 x 4 rectangles
    let block_area floor ((world-width / 4) * (world-height / 4))  ; area of one rectanlge block
    let number_b_blocks ceiling (n_two_b / block_area)             ; determines number of blocks for spin group b
    let number_a_blocks ceiling (n_two_a / block_area)             ; determines number of blocks for spin group a

    ; sets rectangular sections for spin group a
    if number_a_blocks = 1 [ask n-of n_two_a patches with [pxcor < (bw) and pycor <= (bh)] [set spin 2 set orientation 1]]
    if number_a_blocks = 2 [ask n-of n_two_a patches with [(pxcor < (bw) and pycor <= (bh)) or (pxcor < (bw) and pycor <= ((bh * 2) ))]
      [set spin 2 set orientation 1]]
    if number_a_blocks = 3 [ask n-of n_two_a patches with [(pxcor < (bw) and pycor <= (bh)) or (pxcor < (bw) and pycor <= ((bh * 2))) or
        (pxcor < (bw) and pycor <= ((bh * 3)))] [set spin 2 set orientation 1]]
    if number_a_blocks = 4 [ask n-of n_two_a patches with [(pxcor < (bw) and pycor <= (bh)) or (pxcor < (bw) and pycor <= ((bh * 2))) or
        (pxcor < (bw) and pycor <= ((bh * 3))) or (pxcor < (bw) and pycor <= ((bh * 4)))] [set spin 2 set orientation 1]]
    if number_a_blocks = 5 [ask n-of n_two_a patches with [(pxcor < (bw) and pycor <= (bh * 4)) or (pxcor < (2 * bw) and pycor > (3 * bh))]
        [set spin 2 set orientation 1]]
    if number_a_blocks = 6 [ask n-of n_two_a patches with [(pxcor < (bw) and pycor <= (bh * 4)) or (pxcor < (3 * bw) and pycor >= (3 * bh))]
        [set spin 2 set orientation 1]]
    if number_a_blocks = 7 [ask n-of n_two_a patches with [(pxcor < (bw) and pycor <= (bh * 4)) or (pxcor < (4 * bw) and pycor >= (3 * bh))]
        [set spin 2 set orientation 1]]
    if number_a_blocks = 8 [ask n-of n_two_a patches with [(pxcor < (bw) and pycor <= (bh * 4)) or (pxcor < (4 * bw) and pycor >= (3 * bh)) or
        (pxcor < (bw * 2) and pycor <= (bh))] [set spin 2 set orientation 1]]
    if number_a_blocks = 9 [ask n-of n_two_a patches with [(pxcor < (bw) and pycor <= (bh * 4)) or (pxcor < (4 * bw) and pycor >= (3 * bh)) or
        (pxcor < (bw * 2) and pycor <= (2 * bh))] [set spin 2 set orientation 1]]
    if number_a_blocks = 10 [ask n-of n_two_a patches with [(pxcor < (bw) and pycor <= (bh * 4)) or (pxcor < (4 * bw) and pycor >= (3 * bh)) or
        (pxcor < (bw * 2) and pycor <= (3 * bh))] [set spin 2 set orientation 1]]
    if number_a_blocks = 11 [ask n-of n_two_a patches with [(pxcor < (bw) and pycor <= (bh * 4)) or (pxcor < (4 * bw) and pycor >= (3 * bh)) or
        (pxcor < (bw * 2) and pycor < (3 * bh)) or (pxcor < (3 * bw) and pycor >= (2 * bh))] [set spin 2 set orientation 1]]
    if number_a_blocks = 12 [ask n-of n_two_a patches with [(pxcor < (bw) and pycor <= (bh * 4)) or (pxcor < (4 * bw) and pycor >= (3 * bh)) or
        (pxcor < (bw * 2) and pycor <= (3 * bh)) or (pxcor < (4 * bw) and pycor > (2 * bh))] [set spin 2 set orientation 1]]

    ; sets rectangular sections for spin group b
    if number_b_blocks = 1 [ask n-of n_two_b patches with [pxcor > ((3 * bw) - 1) and pycor <= (bh - 1)] [set spin 2 set orientation 1]]
    if number_b_blocks = 2 [ask n-of n_two_b patches with [(pxcor > ((3 * bw) - 1) and pycor <= (bh - 1)) or
        (pxcor > ((2 * bw) - 1) and pycor <= (bh - 1))] [set spin 2 set orientation 1]]
    if number_b_blocks = 3 [ask n-of n_two_b patches with [(pxcor > ((3 * bw) - 1) and pycor <= (bh - 1)) or
        (pxcor > ((2 * bw) - 1) and pycor <= (bh - 1)) or (pxcor > ((3 * bw) - 1) and pycor <= (2 * bh))] [set spin 2 set orientation 1]]
    if number_b_blocks = 4 [ask n-of n_two_b patches with [(pxcor > ((3 * bw) - 1) and pycor <= (bh - 1)) or
        (pxcor > ((2 * bw) - 1) and pycor <= (bh - 1)) or (pxcor > ((3 * bw) - 1) and pycor <= (2 * bh)) or (pxcor >= ((2 * bw)) and pycor <= (2 * bh))]
        [set spin 2 set orientation 1]]

      set spin_diff_a count patches with [spin = 2 and spin_group = 1] - count patches with [spin = 1 and spin_group = 1]
      set spin_diff_b count patches with [spin = 2 and spin_group = 2] - count patches with [spin = 1 and spin_group = 2]
        set temperature2_a  temp2_a
        set temperature2_b  temp2_b
        set entropy_a       S_a
        set entropy_b       S_b
        set total_energy_a  U_a
        set total_energy_b  U_b
        set free_energy_a   F_a
        set free_energy_b   F_b
        set temp_hold_a     temp3_a
        set temp_hold_b     temp3_b

  ; if most of neighbor patches are spin up (greater than 0) then set spint_flip 1 and if not se spin_flip 0
  ifelse (spin_diff_a > 0) [set spin_flip_a 1] [ifelse (spin_diff_a < 0) [set spin_flip_a -1][set spin_flip_a 0]
        ]

  ifelse (spin_diff_b > 0) [set spin_flip_b 1] [ifelse (spin_diff_b < 0) [set spin_flip_b -1][set spin_flip_b 0]
        ]
      ask patches [recolor]
  ]
end 

to setup2                                                                                ; when both switches are fasle world is
  if world-division = false [                                                            ; cut in half and nuclei are spread out
    set n_two_a floor ((percent_excited_a / 100) * (0.5 * world-width * world-height))
    set n_two_b floor ((percent_excited_b / 100) * (0.5 * world-width * world-height))]
      set n_one_a floor ((world-width * world-height) - n_two_a)
      set n_one_b floor ((world-width * world-height) - n_two_b)
      set n_total_a floor (n_one_a + n_two_a)
      set n_total_b floor (n_one_b + n_two_b)
 ask patches [set spin_group 1
              set pcolor blue]
 ask patches [if pxcor > (world-width / 2 - 1) [set pcolor pink
                                                set spin_group 2]
  ]
  if dense-setup = false [
    ask n-of n_two_a patches with [spin_group = 1] [set spin 2                         ; excited states in spin group a (dark blue)
                                                    set orientation 1]
    ask n-of n_two_b patches with [spin_group = 2] [set spin 2                         ; excited states in spin group b (dark pink)
                                                    set orientation 1]
    ask patches [recolor]                                                              ; sets color of the spins that determine excited or ground states
      set spin_diff_a count patches with [spin = 2 and spin_group = 1] - count patches with [spin = 1 and spin_group = 1]
      set spin_diff_b count patches with [spin = 2 and spin_group = 2] - count patches with [spin = 1 and spin_group = 2]
        set temperature2_a  temp2_a
        set temperature2_b  temp2_b
        set entropy_a       S_a
        set entropy_b       S_b
        set total_energy_a  U_a
        set total_energy_b  U_b
        set free_energy_a   F_a
        set free_energy_b   F_b
        set temp_hold_a     temp3_a
        set temp_hold_b     temp3_b
  ifelse (spin_diff_a > 0) [set spin_flip_a 1] [ifelse (spin_diff_a < 0) [set spin_flip_a -1][set spin_flip_a 0]
        ]
  ifelse (spin_diff_b > 0) [set spin_flip_b 1] [ifelse (spin_diff_b < 0) [set spin_flip_b -1][set spin_flip_b 0]
    ]
  ]
end 

to setup3                                                                                 ; when world division switch is
  if world-division = false [                                                             ; false the world is cut in half
    set n_two_a floor ((percent_excited_a / 100) * (0.5 * world-width * world-height))
      set n_two_b floor ((percent_excited_b / 100) * (0.5 * world-width * world-height))]
      set n_one_a floor ((world-width * world-height) - n_two_a)
      set n_one_b floor ((world-width * world-height) - n_two_b)
      set n_total_a floor (n_one_a + n_two_a)
      set n_total_b floor (n_one_b + n_two_b)
 ask patches [set spin_group 1
              set pcolor blue]
 ask patches [if pxcor > (world-width / 2 - 1) [set pcolor pink
                                                set spin_group 2]
  ]
  if dense-setup = true [
    let x_excited_a floor ((percent_excited_a / 100) * (world-width / 2))
    let x_excited_b ceiling (world-width - (percent_excited_b / 100) * (world-width / 2))
  ask n-of n_two_a patches with [pxcor <= x_excited_a] [set spin 2
                                                        set orientation 1]
  ask n-of n_two_b patches with [ pxcor >= x_excited_b - 1 ][set spin 2
                                                             set orientation 1]
      set spin_diff_a count patches with [spin = 2 and spin_group = 1] - count patches with [spin = 1 and spin_group = 1]
      set spin_diff_b count patches with [spin = 2 and spin_group = 2] - count patches with [spin = 1 and spin_group = 2]
        set temperature2_a  temp2_a
        set temperature2_b  temp2_b
        set entropy_a       S_a
        set entropy_b       S_b
        set total_energy_a  U_a
        set total_energy_b  U_b
        set free_energy_a   F_a
        set free_energy_b   F_b
        set temp_hold_a     temp3_a
        set temp_hold_b     temp3_b
  ifelse (spin_diff_a > 0) [set spin_flip_a 1] [ifelse (spin_diff_a < 0) [set spin_flip_a -1][set spin_flip_a 0]
        ]
  ifelse (spin_diff_b > 0) [set spin_flip_b 1] [ifelse (spin_diff_b < 0) [set spin_flip_b -1][set spin_flip_b 0]
        ]
      ask patches [recolor]
  ]
end 

to setup4
  if world-division = true [
    set n_two_a floor ((percent_excited_a / 100) * (0.75 * world-width * world-height))
    set n_two_b floor ((percent_excited_b / 100) * (0.25 * world-width * world-height))]
      set n_one_a floor ((world-width * world-height) - n_two_a)
      set n_one_b floor ((world-width * world-height) - n_two_b)
      set n_total_a floor (n_one_a + n_two_a)
      set n_total_b floor (n_one_b + n_two_b)
  ask patches [set spin_group 1
               set pcolor blue]
  ask patches [if (pxcor >= world-width / 2) and (pycor <= world-height / 2) [set spin_group 2
                                                                              set pcolor pink]
  ]
  if dense-setup = false [
   ask n-of n_two_a patches with [spin_group = 1] [set spin 2
                                                   set orientation 1]
   ask n-of n_two_b patches with [spin_group = 2] [set spin 2
                                                   set orientation 1]
     ask patches [recolor]
       set spin_diff_a count patches with [spin = 2 and spin_group = 1] - count patches with [spin = 1 and spin_group = 1]
       set spin_diff_b count patches with [spin = 2 and spin_group = 2] - count patches with [spin = 1 and spin_group = 2]
         set temperature2_a  temp2_a
         set temperature2_b  temp2_b
         set entropy_a       S_a
         set entropy_b       S_b
         set total_energy_a  U_a
         set total_energy_b  U_b
         set free_energy_a   F_a
         set free_energy_b   F_b
         set temp_hold_a     temp3_a
         set temp_hold_b     temp3_b
    ifelse (spin_diff_a > 0) [set spin_flip_a 1] [ifelse (spin_diff_a < 0) [set spin_flip_a -1][set spin_flip_a 0]
        ]
    ifelse (spin_diff_b > 0) [set spin_flip_b 1] [ifelse (spin_diff_b < 0) [set spin_flip_b -1][set spin_flip_b 0]
    ]
  ]
end 

to recolor                ; colors patches according to spin
  ifelse spin_group = 1 [
  ifelse spin = 1
    [set pcolor blue + 2] ; excited state for spin group a
    [set pcolor blue - 2] ; ground state for spin group a
  ]
  [ifelse spin = 1
    [set pcolor pink + 2] ; excited state for spin group b
    [set pcolor pink - 2] ; ground state for spin group b
  ]
end 

to go
  repeat 1000 [                                 ; updates 1000 patches at a time
    ask one-of patches [update]
  ]
 set spin_diff_a count patches with [spin = 2 and spin_group = 1] - count patches with [spin = 1 and spin_group = 1]
 set spin_diff_b count patches with [spin = 2 and spin_group = 2] - count patches with [spin = 1 and spin_group = 2]
   tick                                         ; updating 1000 patches at a time only
 update-plots                                   ; must update plots separately
   if floor temp3_a = floor temp3_b [stop]      ; rounding values to
   if floor temp3_a = ceiling temp3_b [stop]    ; show that equilibrium
   if ceiling temp3_a = floor temp3_b [stop]    ; has been reached
   if ticks > 50000 [stop]                      ; if equilibrium has not been reached yet
 ifelse (spin_diff_a > 0) [set spin_flip_a 1 ] [ifelse (spin_diff_a < 0) [set spin_flip_a -1][set spin_flip_a 0]
        ]
 ifelse (spin_diff_b > 0) [set spin_flip_b 1] [ifelse (spin_diff_b < 0) [set spin_flip_b -1][set spin_flip_b 0]
        ]
  if (spin_flip_hold_a = spin_flip_a and spin_flip_hold_b = spin_flip_b) [ ; when temp3_a and temp3_b cross
  if (temp3_a < temp3_b and temp_hold_a > temp_hold_b) [stop]
  if (temp3_a > temp3_b and temp_hold_a < temp_hold_b) [stop]
  ]
   set temp_hold_a      temp3_a
   set temp_hold_b      temp3_b
   set spin_flip_hold_a spin_flip_a
   set spin_flip_hold_b spin_flip_b
end 

to update                                                           ; updating spins of one patch
  let Ediff (2 * orientation * sum [orientation] of neighbors)
  if (Ediff <= 0) [
    let hold_orientation orientation
      ask n-of 1 neighbors with [orientation != hold_orientation] [ ; if neighboring spins are different then changes to ground state
      set orientation (- orientation)
  ifelse orientation = -1 [set spin 1] [set spin 2]                 ; if true then ground state and if not assign to excited state
      recolor
      ]
      set orientation (- orientation)
      ifelse orientation = -1 [set spin 1] [set spin 2]
      recolor
      ]
end 

to-report S_a ; spin group a initial entropy
  report (1) * (n_total_a * ln (n_total_a) - n_two_a * ln (n_two_a) - n_one_a * ln (n_one_a))
end 

to-report S_b ; spin group b initial entropy
  report (1) * (n_total_b * ln (n_total_b) - n_two_b * ln (n_two_b) - n_one_b * ln (n_one_b))
end 

to-report entropy3_a ; updates monitor
  report (1) * (n_total_a * ln (n_total_a) - count patches with [spin = 2 and spin_group = 1] * ln (count patches with [spin = 2 and spin_group = 1]) -
    count patches with [spin = 1 and spin_group = 1] * ln (count patches with [spin = 1 and spin_group = 1]))
end 

to-report entropy3_b ; updates monitor
  report (1) * (n_total_b * ln (n_total_b) - count patches with [spin = 2 and spin_group = 2] * ln (count patches with [spin = 2 and spin_group = 2]) -
    count patches with [spin = 1 and spin_group = 2] * ln (count patches with [spin = 1 and spin_group = 2]))
end 

to-report total_entropy3 ; updates monitor
  report (1) * (n_total_a * ln (n_total_a) - count patches with [spin = 2 and spin_group = 1] * ln (count patches with [spin = 2 and spin_group = 1]) -
    count patches with [spin = 1 and spin_group = 1] * ln (count patches with [spin = 1 and spin_group = 1])) + (1) * (n_total_b * ln (n_total_b) -
    count patches with [spin = 2 and spin_group = 2] * ln (count patches with [spin = 2 and spin_group = 2]) - count patches with [spin = 1 and spin_group = 2] *
    ln (count patches with [spin = 1 and spin_group = 2]))
end 

to-report U_a ; initial total_energy
  report ((n_two_a * e_two_a) + (n_one_a * e_one_a))
end 

to-report U_b ; initial total_energy
  report ((n_two_b * e_two_b) + (n_one_b * e_one_b))
end 

to-report total_energy3_a ; updates monitor
  report ((count patches with [spin = 2 and spin_group = 1] * e_two_a) + (count patches with [spin = 2 and spin_group = 2] * e_one_a))
end 

to-report total_energy3_b ; updates monitor
  report ((count patches with [spin = 2 and spin_group = 2] * e_two_b) + (count patches with [spin = 1 and spin_group = 2] * e_one_b))
end 

to-report total_total_energy3 ; updates monitor
  report ((count patches with [spin = 2 and spin_group = 1] * e_two_a) + (count patches with [spin = 2 and spin_group = 2] * e_one_a)) +
  ((count patches with [spin = 2 and spin_group = 2] * e_two_b) + (count patches with [spin = 1 and spin_group = 2] * e_one_b))
end 

to-report temp2_a ; initial temperature
  ifelse (n_two_a / n_one_a) = 1 [report 0] [
    report ( -1 * (e_two_a - e_one_a) / (ln (n_two_a / n_one_a)))]
end 

to-report temp2_b ; initial temperature
   ifelse (n_two_b / n_one_b) = 1 [report 0] [
     report ( -1 * (e_two_b - e_one_b) / (ln (n_two_b / n_one_b)))]
end 

to-report temp3_a ; updates monitor
   ifelse (count patches with [spin = 2 and spin_group = 1] / count patches with [spin = 1 and spin_group = 1]) = 1 [report 0] [
     report ( -1 * (e_two_a - e_one_a) / (ln (count patches with [spin = 2 and spin_group = 1] / count patches with [spin = 1 and spin_group = 1])))]
end 

to-report temp3_b ; updates monitor
   ifelse (count patches with [spin = 2 and spin_group = 2] / count patches with [spin = 1 and spin_group = 2]) = 1 [report 0] [
     report ( -1 * (e_two_b - e_one_b) / (ln (count patches with [spin = 2 and spin_group = 2] / count patches with [spin = 1 and spin_group = 2])))]
end 

to-report F_a ; initial free_energy
  report (total_energy_a - (temperature2_a * entropy_a))
end 

to-report F_b ; initial free_energy
  report (total_energy_b - (temperature2_b * entropy_b))
end

There are 2 versions of this model.

		Uploaded by	When	Description	Download
		Fred Browning	almost 7 years ago	Binary Spin Lattice	Download this version
		Fred Browning	almost 7 years ago	Initial upload	Download this version

Attached files

File	Type	Description	Last updated
Binary Spin Lattice.png	preview	Preview for 'Binary Spin Lattice'	almost 7 years ago, by Fred Browning	Download

This model does not have any ancestors.

This model does not have any descendants.

NetLogo