ChemWiki - User contributions [en]

Rep:Y3CMPCG1417

2019-11-20T10:44:04Z

Cg1417: /* TASK: Modify your script from the previous section. You should still plot the whole temperature range, but fit the polynomial only to the peak of the heat capacity! You should find it easier to get a good fit when restricted to this region */

==Section 1 - Introduction to the Ising Model==

===TASK: Show that the lowest possible energy for the Ising model is <math>E = -DNJ</math>, where D is the number of dimensions and N is the total number of spins. What is the multiplicity of this state? Calculate its entropy.===

Consider a 1D row of lattice sites of N=3 with spin configuration [+1][+1][+1].

Mathematically the interaction energy is defined asː
<math> -\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} </math> where J is a constant and <math>s_{i}s_{j}</math> is the product between two spins in adjacent lattice sites.

The sum of the interaction energies <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j}</math> can be considered as the sum of the individual interaction energies between spinsː
<math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = \epsilon_{12} + \epsilon_{23} + \epsilon_{13} + \epsilon_{21} + \epsilon_{32} + \epsilon_{31} </math>.

Although lattice sites 1 and 3 are not adjacent they are said to still interact according to the periodic boundary conditions applied.

However, <math>\epsilon_{12} = \epsilon_{21} </math> and <math>\epsilon_{23} = \epsilon_{32}</math> and <math>\epsilon_{13} = \epsilon_{31}</math> which means that all of the interactions within the system are counted twice, hence the total energy needs to be halved, resulting in the following formula being obtainedː <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = 2\epsilon_{12} + 2\epsilon_{13} + 2\epsilon_{23} </math>.

It can be determined that <math>\epsilon_{12} = (+1)(+1) = 1</math> , <math>\epsilon_{13} = (+1)(+1) = 1</math> and <math>\epsilon_{23} = (+1)(+1) = 1</math>.

Thereforeː <math>-\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = -\frac{1}{2} \ J \ (2 + 2 + 2) = -\frac{1}{2} \ J \ 6 = - 3 J = -DNJ</math> for a 1D lattice with <math>D=1</math> and 3 lattice sites <math>N=3</math>

The multiplicity of the system,<math>\Omega = \frac{lattice sites!}{n. spin up!n. spin down!}</math>

Entropy, <math>S</math> is defined as <math>S = k_B ln(\Omega)</math> and so in this case <math>S = k_B ln(\frac{100!}{100!}) = 0</math>

===TASK: Imagine that the system is in the lowest energy configuration. To move to a different state, one of the spins must spontaneously change direction ("flip"). What is the change in energy if this happens <math>(D=3, N=1000)</math>? How much entropy does the system gain by doing soʔ===

In a 3D lattice system, each lattice site has three unique interactions with its neighbours to its left, top and front. In the lowest energy configuration, all spins are parallel and for a system the minimum energy is <math>E = -DNJ</math>, so for the system with <math>N=1000</math> and <math>D=3</math>, the minimum energy is <math>-3000J</math>.

If a single spin is flipped, the product of its spin with its neighbours spin reverses and becomes negative and this increases the total energy of the system. Since 3 unique spin-spin interactions are reversed in sign, the total energy increases by <math>+3J</math>, meaning the new total energy is <math>-2997J</math>

Initially the multiplicity of the system will be <math>\Omega = \frac{1000!}{1000!}</math> , and after the flip, the multiplicity becomes <math> \Omega = \frac{1000!}{999!1!}=1000</math>.

The associated change in entropy, <math>\Delta S = k_B ln(1000) - 0 = 6.91 k_B</math>, which is an expected increase in entropy as the number of possible configurations of the system increases.

===TASK: Calculate the magnetisation of the 1D and 2D lattices in Figure 1. What magnetisation would you expect to observe for an Ising lattice with <math>D = 3,\ N=1000</math> at absolute zero?===

[[File:ThirdYearCMPExpt-IsingSketch.png|thumb|left|Figure 1 - Shows 1D (N = 5), 2D (N = 5x5) and 3D (N = 5x5x5) lattices.]]

Magnetisation is defined as <math>M=\sum_{i} s_i</math>. So for the 1D lattice with <math>N = 5</math> in ''Figure 2'', <math>M = +1</math> and for the 2D lattice with <math>N = 25 , M = +1</math> too.

According to the 3rd Law of thermodynamics, entropy is 0 at absolute zero for a perfect crystalline solid, and consequently it is expected that the lattices will have follow suit and have zero entropy at 0K. To have zero entropy all spins must be parallel as such that magnetisation, <math>M = N</math>. For all the spins to be parallel, there is only one possible configuration. So, for a lattice with <math>N = 1000</math> and <math>D =3</math>, if <math>M = N</math>, then multiplicity, <math>\Omega = 1</math> and entropy, <math>S =k_B ln(1) = 0</math>.

 

==Section 2 - Calculating the Energy and Magnetisation==

===TASK: complete the functions energy() and magnetisation(), which should return the energy of the lattice and the total magnetisation, respectively. In the energy() function you may assume that <math>J=1.0</math> at all times (in fact, we are working in reduced units in which <math>J=k_B</math>, but there will be more information about this in later sections). Do not worry about the efficiency of the code at the moment — we will address the speed in a later part of the experiment.===

<pre>def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
lat=self.lattice #creates lattice and stores it
mag=[]
for i in range(0,len(lat)): #loops through all rows of lattice
for j in range(0,len(lat[i])): #loops through elements of each row
mag+=[lat[i][j]] #adds spin value to mag array
return sum(mag) #sums all spins from mag array
</pre>

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

lat=self.lattice #creates lattice and stores it
left=[]
top=[]

for i in range(0,len(lat)):
for j in range(0,len(lat[i])):
left+=[lat[i][j]*lat[i][j-1]] #multiplies spin by spin to left
top+=[lat[i][j]*lat[i-1][j]] #multiplies spin by spin above it
int_en=left+top #sums spin products from left and top
energy=-sum(int_en) #sums all spin products for each spin to give total

return energy
</pre>

===TASK: Run the ILcheck.py script from the IPython Qt console using the command===

''Figure 2'' shows the results when ILcheck.py was ran on my IsingLattice.py file. The ILcheck.py file was ran several times to ensure the code worked for various random lattices.

[[File:Cg1417ILcheck run.png|thumb|left|500px| Figure 2 - Result from running the ILcheck.py file]]

 

==Section 3 - Introduction to Monte Carlo Simulation==

===TASK: How many configurations are available to a system with 100 spins? To evaluate these expressions, we have to calculate the energy and magnetisation for each of these configurations, then perform the sum. Let's be very, very, generous, and say that we can analyse <math>1\times 10^9</math> configurations per second with our computer. How long will it take to evaluate a single value of <math>\left\langle M\right\rangle_T</math>?===

For a system with 100 lattice sites and two possible spins for each site, there are <math>2^{100}</math>possible configurations for the system. <math>2^{100}= 1.27\times 10^{30} </math>, so if the computer can analyse <math>1\times 10^9</math> configurations per second, then it will take <math>\frac{1.27\times 10^{30}}{10^9} = 1.27\times 10^{21} s</math> to analyse the whole system, which is longer than the age of the universe and therefore is not a practical approach.

===TASK: Implement a single cycle of the above algorithm in the montecarlocycle(T) function. This function should return the energy of your lattice and the magnetisation at the end of the cycle. You may assume that the energy returned by your energy() function is in units of <math>k_B</math>! Complete the statistics() function. This should return the following quantities whenever it is called: <math><E>, <E^2>, <M>, <M^2></math>, and the number of Monte Carlo steps that have elapsed.===
<pre>
E = []
E2 = []
M = []
M2 = []
n_cycles = 0

def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back if rejected else not changed

self.E+=[self.energy()] #records energy
self.E2+=[self.energy()**2] #records energy squared
self.M+=[self.magnetisation()] #records magnetisation
self.M2+=[self.magnetisation()**2] #records magnetisation squared
self.n_cycles=self.n_cycles+1 #adds 1 to run total

return (self.energy(),self.magnetisation())

def statistics(self):
# complete this function so that it calculates the correct values for the averages of E, E*E (E2), M, M*M (M2), and returns them

e=np.mean(self.E)
e2=np.mean(self.E2)
m=np.mean(self.M)
m2=np.mean(self.M2)

return e,e2,m,m2,self.n_cycles
</pre>

''Figure 3'' shows the results of a single run of the montecarlostep() function and the lattice the function operated upon.

[[File:cg1417MonteCarloStep_run.png|thumb|left|Figure 3 - Results from a single montecarlostep() function and the resulting lattice produced along with the correct return from the statistics() function]]

 

===TASK: If <math>T < T_C</math>, do you expect a spontaneous magnetisation (i.e. do you expect <math>\left\langle M\right\rangle \neq 0</math>)? When the state of the simulation appears to stop changing (when you have reached an equilibrium state), use the controls to export the output to PNG and attach this to your report. You should also include the output from your statistics() function.===

If the temperature of the system is less than the Curie Temperature, <math>T_C</math> then spontaneous magnetisation can occur and the system will tend to its lowest energy state where all of the spins are parallel - this is a property of ferromagnetic materials.

[[File:Cg1417ILanim_run.png|400px|thumb|left|Figure 4 - Results from running the ILanim.py file - shows the energy and magnetisation converging over time]]

''Figure 4'' shows that over time the the system spontaneously converges to the minimum energy state with all of the spins parallel to one another and shows, as I expected, that spontaneous magnetisation occurs and also shows that the temperature of this simulation is below the Curie Temperature, <math>T < T_C</math>.

 

==Section 4 - Accelerating the Code==

===TASK: Use the script ILtimetrial.py to record how long your current version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 5'' show the results of running the ILtimetrial.py file on my code three timesː

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1.png
| width1=500
| image2=cg1417ILtimetrial_run2.png
| width2=500
| image3=cg1417ILtimetrial_run3.png
| width3=500
| footer = Figure 5 - Results of running the ILtimetrial.py file on my code three separate times
}}
 

This gave me an avergage time of <math>24.3 s \pm 0.2s</math>

===TASK: Look at the documentation for the NumPy sum function. You should be able to modify your magnetisation() function so that it uses this to evaluate M. The energy is a little trickier. Familiarise yourself with the NumPy roll and multiply functions, and use these to replace your energy double loop (you will need to call roll and multiply twice!).===

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

left=multiply(roll(self.lattice,1,axis=1),self.lattice) #product of spin with spin left of it
top=multiply(roll(self.lattice,-1,axis=0),self.lattice) #product of spin with spin above it

int_en=sum(left+top) #sum of array containing sum of left and top spin products for each spin

energy = -sum(int_en) #calculates the total energy of system
return energy

def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
return sum(sum(self.lattice)) #adds up all spins in lattice
</pre>
The use of the bumpy modules reduces the amount of code required and removes the need for loops making the code significantly shorter, and is therefore expected to run ILtimetrial.py faster than the initial code developed.

===TASK: Use the script ILtimetrial.py to record how long your new version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 6'' shows the result of running the ILtimetrial.py on my new accelerated code.

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1fast.png
| width1=500
| image2=ILtimetrial_run2fast.png
| width2=500
| image3=ILtimetrial_run3fast.png
| width3=500
| footer = Figure 6 - Results of running the ILtimetrial.py file on my new updated and accelerated code.
}}
 

The accelerated code is much faster upon using the roll, multiply and sum modules with a new average time of <math>0.790 s \pm 0.005 </math>

==Section 5 - The effect of temperature==

===TASK: The script ILfinalframe.py runs for a given number of cycles at a given temperature, then plots a depiction of the final lattice state as well as graphs of the energy and magnetisation as a function of cycle number. This is much quicker than animating every frame! Experiment with different temperature and lattice sizes. How many cycles are typically needed for the system to go from its random starting position to the equilibrium state? Modify your statistics() and montecarlostep() functions so that the first N cycles of the simulation are ignored when calculating the averages. You should state in your report what period you chose to ignore, and include graphs from ILfinalframe.py to illustrate your motivation in choosing this figure.===

''Figure 7'' below shows the results from running the ILfinalframe.py for 2x2 lattice at T=1,2,3,5.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2T1.png
| image2 = cg14172x2T2.png
| image3 =cg14172x2T3.png
| image4 =cg14172x2T5.png
| footer_align = left
| footer = Figure 7 - Results of running the ILfinalframe.py file at T=1,2,3,5 for a 2x2 matrix.
}}

 

For a 2x2 matrix, a suitable cut-off point to exclude from the avergage energies and magnetisations is where the energy and magnetisations per spin are constant, which is 30 steps. For T=3 and T=5 the graphs do not converge because it is possible that these temperatures are higher than the Curie Temperature and as such spontaneous magnetisation will not occur and the system will not diverge to the lowest energy state. At the higher temperatures, there are larger thermal fluctations and the Boltzmann factor is more significant allowing the system to move away from the lowest energy state easier. As a result moving forwards, a suitable cut-off point will only be determined from T=1 and T=2 graphs for the larger matrices.

''Figure 8'' shows the results from running a 4x4 lattice at T=1,2 and 3.

{{multiple image
| width =350
| align = left
| image1 = cg14174x4T1.png
| image2 = cg14174x4T2.png
| image3 =cg14174x4T3.png
| footer_align = left
| footer = Figure 8 - Results of running the ILfinalframe.py file at T=1,2,3 for a 4x4 matrix.
}}

From ''Figure 8'', a suitable cut-off point for the energy and magnetisations is 200 as this is after where the energy and magnetisation has converged for T=1, and is after the initial large drop in energy for T=2, even though there are a few small fluctuations after 200 steps. The result from T=3 has been included to show the large fluctuations for the larger temperatures, and supporting my choice to determine the cut-off from T=1 and T=2 only.

''Figure 9'' shows the results for an 8x8 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg14178x8T1.png
| image2 = cg14178x8T2.png
| footer_align = left
| footer = Figure 9 - Results of running the ILfinalframe.py file at T=1,2 for an 8x8 matrix
}}

From ''Figure 9'' above, a suitable cut-off point is 1000 steps as this is where the energy and magnetisation has easily converged by and is also the point after which the initial large drop in energy has been overcome for T=2 too.

''Figure 10'' shows the result of running the ILfinalframe.py for a 16x16 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg141716x16T1.png
| image2 = cg141716x16T2.png
| footer_align = left
| footer = Figure 10 - Results of running the ILfinalframe.py file at T=1,2 for a 16x16 matrix
}}

From ''Figure 10'', a suitable cut-off point is 15000 steps as for T=1 the energy and magnetisations have converged significantly and will not change much, and likewise this is the same for the T=2 frame.

''Figure 11'' below shows the results from a 32x32 matrix at T=1 and T=2.

{{multiple image
| width =350
| align = left
| image1 = cg141732x32T1.png
| image2 = cg141732x32T2.png
| footer_align = left
| footer = Figure 11 - Results of running the ILfinalframe.py file at T=1,2 for a 32x32 matrix
}}

''Figure 11'' above shows the results of running the ILfinalframe.py file for a 32x32 matrix at T=1 and T=2. As a result a suitable cut-off of 50000 steps was chosen as the energy and magnetisation has significantly converged, but not as much as it could at 100000 steps. I chose a slightly lower value to ensure that the run times of my monte-carlo simulations in future tasks were not extremely time consuming.

The montecarlostep() function was changed by adding a condition that values only above the pre-determined cut-off were included when determining the average value of energy; energy squared; magnetisation and magnetisations squared from the statistics function. The statistics() function did not need to be modified.

The following code is from the 32x32 matrixː

<pre>def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back

if self.n_cycles > 50000: #only adds values to array of E,E2,M and M2 above the specific cut-off
self.E+=[self.energy()]
self.E2+=[self.energy()**2]
self.M+=[self.magnetisation()]
self.M2+=[self.magnetisation()**2]
self.n_cycles=self.n_cycles+1

return (self.energy(),self.magnetisation())
</pre>

===TASK: Use ILtemperaturerange.py to plot the average energy and magnetisation for each temperature, with error bars, for an <math>8\times 8</math> lattice. Use your intuition and results from the script ILfinalframe.py to estimate how many cycles each simulation should be. The temperature range 0.25 to 5.0 is sufficient. Use as many temperature points as you feel necessary to illustrate the trend, but do not use a temperature spacing larger than 0.5. The NumPy function savetxt() stores your array of output data on disk — you will need it later. Save the file as 8x8.dat so that you know which lattice size it came from.===

Using the modified code, the file ILtemperaturerange.py was ran on an 8x8 matrix between T=0.5 and T=5 with a step of T=0.02 for 10000 Montecarlo steps and the first 1000 steps of each temperature were excluded when calculating the averages. ''Figure 12'' shows the result of the simulation and also included error bars of standard deviation.

[[File:Cg14178x8error.png|1000px|thumb|left|Figure 12 - Graph showing average energy and average magnetisation for an 8x8 lattice with error bars between T=0.5 and T=5]]

 

Below is the source code for the script to produce the graph from CG1417IsingModelGraphs.ipynbː

<pre>data8x8=np.loadtxt('8x8.dat') #loads data
temps8x8=data8x8[:,0] #stores temperatures
energies8x8=data8x8[:,1] #stores average energy for each T
energysq8x8=data8x8[:,2] #stores average energy squared for each T
mag8x8=data8x8[:,3] #stores magnetisation for each T
magsq8x8=data8x8[:,4] #stores magnetisation squared for each T
stde8x8=data8x8[:,5] #edited ILtemperaturerange.py to record the standard deviation of the energy for each T
stdm8x8=data8x8[:,6] #edited ILtemperaturerange.py to record the standard deviation of the magnetisation for each T

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.errorbar(temps8x8, np.array(energies8x8)/64,yerr=np.divide(stde8x8,64),color='black',ecolor='teal',alpha=0.8) #plots energy per spin against T
magax.errorbar(temps8x8, np.array(mag8x8)/64,yerr=np.divide(stdm8x8,64),alpha=0.8,ecolor='salmon',color='black') #plots magnetisation per spin against T on separate graph
pl.savefig('8x8error.png',bbox_inches='tight') #saves figure
pl.show()

</pre>

==Section 6 - The effect of system size==

===TASK: Repeat the final task of the previous section for the following lattice sizes: 2x2, 4x4, 8x8, 16x16, 32x32. Make sure that you name each datafile that your produce after the corresponding lattice size! Write a Python script to make a plot showing the energy per spin versus temperature for each of your lattice sizes. Hint: the NumPy loadtxt function is the reverse of the savetxt function, and can be used to read your previously saved files into the script. Repeat this for the magnetisation. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. How big a lattice do you think is big enough to capture the long range fluctuations?===

The python script for this section is identical as for the 8x8 graph above in Figure 12 with the relevant files and variables changed accordingly.

Each matrix was simulated using the ILtemperaturerange.py file between T=0.5 and T=5 with a step of T=0.02.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2error.png
| caption1 = 2x2 matrix - 5000 steps, cut-off = 30 steps
| image2 = 4x4error.png
| caption2 = 4x4 matrix - 1000 steps, cut-off = 200 steps
| image3 =cg141716x16error.png
| caption3 = 16x16 matrix - 50000 steps, cut-off = 15000 steps
| image4 =cg141732x32error.png
| caption4 = 32x32 matrix - 200000 steps, cut-off = 50000 steps
| footer_align = left
| footer = Figure 13 - Results of running the ILtemperaturerange.py file for 2x2, 4x4, 16x16 and 32x32 matrices.
}}

 

Long-range interactions are present and more significant in the smaller lattices where there are fewer stronger, short range interactions. As a result, I expect long-range interactions to be important in square lattices up to a 4x4 size.

==Section 7 - Determining the Heat Capacity==

===TASK: By definition, <math>C = \frac{\partial \left\langle E\right\rangle}{\partial T}</math>. From this, show that <math>C = \frac{\mathrm{Var}[E]}{k_B T^2}</math> (Where <math>\mathrm{Var}[E]</math> is the variance in <math>E</math>.)===

Recall from statistical thermodynamics that the average energy of a system is the sum across all microstates of the probability of that microstate multiplied by the energy of that microstate, which is defined mathematically asː <math>\langle E \rangle = \sum_i p_{i}\epsilon_{i}</math>.

The partition function <math>q</math> is defined as <math>q = \sum_{i} exp(-\beta \epsilon_{i})</math> where <math>\beta =\frac{1}{k_BT}</math>and the probability, <math>p_{i}</math> can be defined in terms of the partition function as <math>p_{i} = \frac{exp(-\beta \epsilon_{i})}{\sum_{i} exp(-\beta \epsilon_{i})} = \frac{exp(-\beta \epsilon_{i})}{q}</math>.

As a result, <math>\langle E \rangle</math> can be re-written as <math>\langle E \rangle = \sum_{i} \frac{\epsilon_{i} exp(-\beta \epsilon_{i})}{q} = -\frac{1}{q} \frac{\partial}{\partial \beta}\sum_{i}exp(-\beta \epsilon_{i}) = -\frac{1}{q} \frac{\partial q}{\partial \beta}</math>

Likewise, <math>\langle E^2 \rangle = \sum_i p_{i}\epsilon_{i}^{2} = \sum_{i} \frac{\epsilon_{i}^{2}exp(-\beta \epsilon_{i})}{q} = \frac{1}{q} \frac{\partial^{2}}{\partial \beta^{2}}\sum_{i}exp(-\beta \epsilon_{i}) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}}</math>

From definitionː <math>Var[E] = \Delta E^2 = \langle E^2 \rangle - \langle E \rangle^2 </math>

When the definition of <math>\langle E \rangle</math> and <math>\langle E^2 \rangle</math> is written in terms of partition function <math>q</math>ː <math>Var[E] = \langle E^2 \rangle - \langle E \rangle^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \left(\frac{1}{q}\frac{\partial q}{\partial \beta}\right)^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2</math>.

According to the chain ruleː <math>\frac{\partial}{\partial \beta}\left(\frac{1}{q} \frac{\partial q}{\partial \beta}\right) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2 = -\frac{\partial}{\partial \beta}\langle E \rangle = Var[E]</math>

And using the chain rule againː <math>C = \frac{\partial \langle E \rangle}{\partial T}= \left(-\frac{\partial \langle E \rangle}{\partial \beta}\right) \left(-\frac{\partial \beta}{\partial T}\right) = \frac{Var[E]}{k_B T^2}</math>

===TASK: Write a Python script to make a plot showing the heat capacity versus temperature for each of your lattice sizes from the previous section. You may need to do some research to recall the connection between the variance of a variable, <math>\mathrm{Var}[X]</math>, the mean of its square <math>\left\langle X^2\right\rangle</math>, and its squared mean <math>\left\langle X\right\rangle^2</math>. You may find that the data around the peak is very noisy — this is normal, and is a result of being in the critical region. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. ===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb

{{multiple image
| width =300
| align = left
| image1 = cg14172x2heatcap.png
| caption1 = 2x2 Matrix
| image2 = cg14174x4heatcap.png
| caption2 = 4x4 Matrix
| image3 =cg14178x8heatcap.png
| caption3 = 8x8 Matrix
| image4 =cg141716x16heatcap.png
| caption4 = 16x16 Matrix
| image5=cg141732x32heatcap.png
| caption5= 32x32 Matrix
| footer = Figure 14 - Graphs showing Heat Capacity against Temperature for each matrix size
}}

Here is the source code to produce the figuresː
<pre> def heatCap(energies,energysq,T,latsize):
#defines the heat capacity for a given temperature
energiesq=np.multiply(energies,energies) #creates array of (average energies) squared
varE=np.subtract(energysq,energiesq) #defines variance of average energy
tempsq=np.multiply(T,T) #array of temperature squared
return np.array(np.divide(varE,tempsq))/(latsize**2)

heatCap2x2=heatCap(energies2x2,energysq2x2,temps2x2,2) #creates array of heat capacity for each T

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(temps2x2,heatCap2x2,color='orange') #plots heat capacity for each T
pl.savefig('cg14172x2heatcap.png',bbox_inches='tight') #saves figure
pl.show()
</pre>

A general trend from the above graphs is that the peak of the graph shifts towards lower temperatures as the size of the matrix used increases which means the Curie Temperature decreases as matrix size increases. Also, as lattice size increases the noise around the peak becomes larger which will affect the accuracy of determining the maximum heat capacity and Curie Temperature for the larger lattices.

==Section 8 - Locating the Curie Temperature==
===TASK: A C++ program has been used to run some much longer simulations than would be possible on the college computers in Python. You can view its source code here if you are interested. Each file contains six columns: <math>T, E, E^2, M, M^2, C</math> (the final five quantities are per spin), and you can read them with the NumPy loadtxt function as before. For each lattice size, plot the C++ data against your data. For one lattice size, save a PNG of this comparison and add it to your report — add a legend to the graph to label which is which. To do this, you will need to pass the label="..." keyword to the plot function, then call the legend() function of the axis object (documentation here).===

The python code used to read and plot the C++ data is found in the Jupyter notebook CG1417IsingModelGraphs.ipynb.

''Figure 15'' below shows the C++ plotted against my own data for a 16x16 Matrix.

[[File:Cg141716x16C++.png|400px|thumb|left|Figure 15 - Graph showing my own data against the C++ data for a 16x16 matrix.]]

 

The curves produced using the C++ data are much smoother and have less noise than the data gained from my python code. This is likely due to the C++ code having more montecarlosteps per temperature, reducing the effect of random fluctuations on the averages and also having a smaller step gap which will make the curve smoother as the points are closer together.

Here is the source code the produce the figuresː
<pre>#reads data from C++ file
temps2x2C=data2x2C[:,0]
energies2x2C=data2x2C[:,1]
energysq2x2C=data2x2C[:,2]
mag2x2C=data2x2C[:,3]
magsq2x2C=data2x2C[:,4]
heatcap2x2C=data2x2C[:,5]

#fitting C++ data

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.plot(temps2x2, np.array(energies2x2)/4,color='black',alpha=0.7,label='Python Data') #python energy against T
enerax.plot(temps2x2C, energies2x2C, color='red',label='C++ Data') #C energy against T
magax.plot(temps2x2, np.array(mag2x2)/4,color='black',alpha=0.7,label='Python Data') #python magnetisation against T
magax.plot(temps2x2C, mag2x2C,color='red',label='C++ Data') #C energy against T
enerax.legend() #shows legend on energy graph
magax.legend() #shows legend on energy graph
pl.show()
</pre>

The relevant variables and dat files were changed for each matrix.

===TASK: write a script to read the data from a particular file, and plot C vs T, as well as a fitted polynomial. Try changing the degree of the polynomial to improve the fit — in general, it might be difficult to get a good fit! Attach a PNG of an example fit to your report.===

The python script to read and plot the fitted polynomial is found in CG1417PolyfitScript.ipynb

Here is the source code for ''Figure 15''

<pre>data_test = np.loadtxt("16x16C.dat")
T_test = data_test[:,0] #gets temperatures
C_test = data_test[:,5] #gets heat capacity data

#first we fit the polynomial to the data
fit_test = np.polyfit(T_test, C_test, 35) # fit a polynomial of degree 35ǃ

#now we generate interpolated values of the fitted polynomial over the range of our function
T_min_test = 0.5 #np.min(T_test)
T_max_test = 5 #np.max(T_test)

T_range_test = np.linspace(T_min_test, T_max_test, 1000) #generate 1000 evenly spaced points between T_min and T_max
fitted_C_values_test = np.polyval(fit_test, T_range_test)# use the fit object to generate the corresponding values of C

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(T_test,C_test,color='orange',label='C++ Data') #plots C data of heat capacity against temp
heatcapax.plot(T_range_test,fitted_C_values_test,label='Fitted Polynomial') #plots fitted polynomial for whole range of temp
heatcapax.legend()
pl.savefig('FIT_TEST16x16_35.png', bbox_inches='tight') #saves figure
pl.show()
</pre>

Below in ''Figure 16'' is a plot of my Heat Capacity against Temperature data for a 16x16 matrix and features a polynomial of degree 35 plotted against it. Even with a polynomial of such a high degree, it poorly fits the curve and does not fit to the peak of the curve either.

[[File:cg1417FIT_TEST16x16_35.png|thumb|left|400px|Figure 16 - Plot of Heat Capacity against Temperature along with a poorly fitted polynomial of degree 35. ]]

 

===TASK: Modify your script from the previous section. You should still plot the whole temperature range, but fit the polynomial only to the peak of the heat capacity! You should find it easier to get a good fit when restricted to this region===

The script was modified as such that the polynomial was fitted in a set range around the peak of the graph, this is demonstrated in ''Figure 17'' which shows a newly fitted polynomial between a much smaller range of temperatures (T = 2.15-2.55) and a much smaller degree polynomial (3).

[[File:CG1417FIT_16x16C_3.png|thumb|left|400px|Figure 17 - Graph showing Heat Capacity against Temperature for a 16x16 matrix along with a fitted polynomial between a much more restricted range of temperatures and a significantly lower degree of polynomial]]

Upon comparison with ''Figure 16'', the new fitted polynomial is a significantly better fit even for a 3rd degree polynomial and is a much more accurate representation of my data around the peak of the graph and will make it easier to determine the maximum value of Heat Capacity. However, the polyfit curve still doesn't perfectly fit the peak due to the significant amount of noise present there.

 

Here is the source code for ''Figure 17'' from CG1417PolyfitScript.ipynbː
<pre>data16 = np.loadtxt("16x16C.dat") #loads data to variable

T16 = data16[:,0] #gets temps
C16 = data16[:,5] # gets heat capacities

Tmin16 = 2.15 #chosen min temp
Tmax16 = 2.55 #chosen max temp

selection16 = np.logical_and(T16 > Tmin16, T16 < Tmax16) #choose only those rows where both conditions are true
peak_T_values16 = T16[selection16] #choose temp values in range chosen above
peak_C_values16 = C16[selection16] #choose heat cap values in range of t above

fit16 = np.polyfit(peak_T_values16,peak_C_values16,3) #fit 3rd order polynomial
peak_T_range16 = np.linspace(Tmin16, Tmax16, 1000) #defines 1000 temps within data range
fitted_C_values16 = np.polyval(fit16, peak_T_range16) #use the fit object to get corresponding values of heat cap

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(T16,C16,color='orange',label='C++ Data') #plots C data of heat cap against temp
heatcapax.plot(peak_T_range16,fitted_C_values16,label='Fitted Polynomial') #plots fitted polynomial for small range
heatcapax.legend()
pl.savefig('FIT_16x16C_3.png', bbox_inches='tight') #saves figure
pl.show()

</pre>

===TASK: find the temperature at which the maximum in C occurs for each datafile that you were given. Make a text file containing two colums: the lattice side length (2,4,8, etc.), and the temperature at which C is a maximum. This is your estimate of <math>T_C</math> for that side length. Make a plot that uses the scaling relation given above to determine <math>T_{C,\infty}</math>. By doing a little research online, you should be able to find the theoretical exact Curie temperature for the infinite 2D Ising lattice. How does your value compare to this? Are you surprised by how good/bad the agreement is? Attach a PNG of this final graph to your report, and discuss briefly what you think the major sources of error are in your estimate.===

''Figure 18'' below shows a graph of <math>T_{C,L}</math> against <math>\frac{1}{Lattice Size}</math> to determine the Curie Temperature of an infinite 2D Ising Model Lattice <math>T_{C,\infty}</math>. The black dots represent the raw data obtained from obtaining the temperature at which the Heat Capacity was a maximum for the lattices and the red line in a linear curve fit plotted against the data to allow the y-intercept which is the Curie Temperature for the infinite 2D lattice to be determined.

[[File:cg1417CurieTemp.png|400px|thumb|left|Figure 18 - Plot of 1/Lattice Size against Curie Temperature for that lattice size.]]

The value for <math>T_{C,\inf}</math> obtained from the data is <math>T_{C,\infty} = 2.277 \frac{J}{k_B}</math> with a literature value being <math>T_{C,\infty} = 2.269 \frac{J}{k_B}</math> <ref>L. Onsager, Phys. Rev., 1944, 65, 117--149.</ref>for an infinite square 2D lattice. This means that my result slightly over-estimates the Curie Temperature for the infinite lattice and as a result for an infinite lattice the temperature at which spontaneous magnetisation stops would actually occur at a slightly lower temperature than expected. However, the difference between my value and the literature value is only 0.008 which is incredibly small and the amount of agreement between the two values is somewhat surprising, which means that the error in my estimates of the Curie Temperature for each lattice size is relatively small. The points which have the largest residuals and deviation from the line of best fit in ''Figure 17'' corresponds to the smaller lattice sizes of 2x2 and 4x4 where longer range interactions are more significant. The longer range interactions posed by the boundary conditions are significant for the smaller sizes and causes the energy of the smaller matrices to be less accurate and have a larger associated error with the energy and the Curie Temperature for that lattice size. This affects the accuracy of the line of best fit and to increase the accuracy of this line, larger lattice sizes of 128x128, 256x256 etc should be included in the calculation for the line of best fit and the smaller matrices ignored - this should allow a more accurate value of <math>T_{C,\infty}</math> to be determined.

 

Below is the source code used to generate ''Figure 18'' from CG1417PolyfitScript.py
<pre>
Cmax64x64 = np.max(fitted_C_values64) #finds Cmax for 64x64 matrix - done for others already
Tmax64x64 = peak_T_range64[fitted_C_values64 == Cmax64x64] #finds Tmax corresponding to Cmax

LatSize=[2,4,8,16,32,64] #stores lattice sizes
Tmax=[Tmax2x2,Tmax4x4,Tmax8x8,Tmax16x16,Tmax32x32,Tmax64x64] #stores corresponding Tmax data
np.savetxt('CmaxVSTmax.txt', (LatSize,Tmax)) #writes data to txt file

ScalData=np.loadtxt('CmaxVSTmax.txt') #loads data
LatticeSize=ScalData[0] #gets lattice sizes
TempMax=ScalData[1] #gets max temp or curie temp for each lattice

Lmin1min = np.min(np.divide(1,LatticeSize)) #minimum of 1/LatticeSize values
Lmin1max = np.max(np.divide(1,LatticeSize)) #maximum of 1/LatticeSize values

fitTcl = np.polyfit(np.divide(1,LatticeSize),TempMax, 1) #creates fit object

Lmin1values = np.linspace(Lmin1min, Lmin1max, 1000) #finds 1000 values between min and max x-axis value of 1/LatticeSize
fitted_Tcl_values = np.polyval(fitTcl, Lmin1values) #creates corresponding Curie Temp values for each value in Lmin1values

fig = pl.figure()
scalrelax = fig.add_subplot(1,1,1)
scalrelax.set_xlabel('1/Lattice Size')
scalrelax.set_ylabel('Curie Temperature/ J/k_B')
scalrelax.plot(np.divide(1,LatticeSize),TempMax,color='black',marker='.',linestyle='') #plots Curie Temp against 1/LatticeSize
scalrelax.plot(Lmin1values,fitted_Tcl_values,color='red',marker='',linestyle='-') #plots line of best fit for data above
pl.savefig('CurieTemp.png', bbox_inches='tight') #saves figure
pl.show()

</pre>

== References ==

Rep:Y3CMPCG1417

2019-11-20T10:43:17Z

Cg1417: /* TASK: Use ILtemperaturerange.py to plot the average energy and magnetisation for each temperature, with error bars, for an 8\times 8 lattice. Use your intuition and results from the script ILfinalframe.py to estimate how many cycles each simulation...

==Section 1 - Introduction to the Ising Model==

===TASK: Show that the lowest possible energy for the Ising model is <math>E = -DNJ</math>, where D is the number of dimensions and N is the total number of spins. What is the multiplicity of this state? Calculate its entropy.===

Consider a 1D row of lattice sites of N=3 with spin configuration [+1][+1][+1].

Mathematically the interaction energy is defined asː
<math> -\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} </math> where J is a constant and <math>s_{i}s_{j}</math> is the product between two spins in adjacent lattice sites.

The sum of the interaction energies <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j}</math> can be considered as the sum of the individual interaction energies between spinsː
<math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = \epsilon_{12} + \epsilon_{23} + \epsilon_{13} + \epsilon_{21} + \epsilon_{32} + \epsilon_{31} </math>.

Although lattice sites 1 and 3 are not adjacent they are said to still interact according to the periodic boundary conditions applied.

However, <math>\epsilon_{12} = \epsilon_{21} </math> and <math>\epsilon_{23} = \epsilon_{32}</math> and <math>\epsilon_{13} = \epsilon_{31}</math> which means that all of the interactions within the system are counted twice, hence the total energy needs to be halved, resulting in the following formula being obtainedː <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = 2\epsilon_{12} + 2\epsilon_{13} + 2\epsilon_{23} </math>.

It can be determined that <math>\epsilon_{12} = (+1)(+1) = 1</math> , <math>\epsilon_{13} = (+1)(+1) = 1</math> and <math>\epsilon_{23} = (+1)(+1) = 1</math>.

Thereforeː <math>-\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = -\frac{1}{2} \ J \ (2 + 2 + 2) = -\frac{1}{2} \ J \ 6 = - 3 J = -DNJ</math> for a 1D lattice with <math>D=1</math> and 3 lattice sites <math>N=3</math>

The multiplicity of the system,<math>\Omega = \frac{lattice sites!}{n. spin up!n. spin down!}</math>

Entropy, <math>S</math> is defined as <math>S = k_B ln(\Omega)</math> and so in this case <math>S = k_B ln(\frac{100!}{100!}) = 0</math>

===TASK: Imagine that the system is in the lowest energy configuration. To move to a different state, one of the spins must spontaneously change direction ("flip"). What is the change in energy if this happens <math>(D=3, N=1000)</math>? How much entropy does the system gain by doing soʔ===

In a 3D lattice system, each lattice site has three unique interactions with its neighbours to its left, top and front. In the lowest energy configuration, all spins are parallel and for a system the minimum energy is <math>E = -DNJ</math>, so for the system with <math>N=1000</math> and <math>D=3</math>, the minimum energy is <math>-3000J</math>.

If a single spin is flipped, the product of its spin with its neighbours spin reverses and becomes negative and this increases the total energy of the system. Since 3 unique spin-spin interactions are reversed in sign, the total energy increases by <math>+3J</math>, meaning the new total energy is <math>-2997J</math>

Initially the multiplicity of the system will be <math>\Omega = \frac{1000!}{1000!}</math> , and after the flip, the multiplicity becomes <math> \Omega = \frac{1000!}{999!1!}=1000</math>.

The associated change in entropy, <math>\Delta S = k_B ln(1000) - 0 = 6.91 k_B</math>, which is an expected increase in entropy as the number of possible configurations of the system increases.

===TASK: Calculate the magnetisation of the 1D and 2D lattices in Figure 1. What magnetisation would you expect to observe for an Ising lattice with <math>D = 3,\ N=1000</math> at absolute zero?===

[[File:ThirdYearCMPExpt-IsingSketch.png|thumb|left|Figure 1 - Shows 1D (N = 5), 2D (N = 5x5) and 3D (N = 5x5x5) lattices.]]

Magnetisation is defined as <math>M=\sum_{i} s_i</math>. So for the 1D lattice with <math>N = 5</math> in ''Figure 2'', <math>M = +1</math> and for the 2D lattice with <math>N = 25 , M = +1</math> too.

According to the 3rd Law of thermodynamics, entropy is 0 at absolute zero for a perfect crystalline solid, and consequently it is expected that the lattices will have follow suit and have zero entropy at 0K. To have zero entropy all spins must be parallel as such that magnetisation, <math>M = N</math>. For all the spins to be parallel, there is only one possible configuration. So, for a lattice with <math>N = 1000</math> and <math>D =3</math>, if <math>M = N</math>, then multiplicity, <math>\Omega = 1</math> and entropy, <math>S =k_B ln(1) = 0</math>.

 

==Section 2 - Calculating the Energy and Magnetisation==

===TASK: complete the functions energy() and magnetisation(), which should return the energy of the lattice and the total magnetisation, respectively. In the energy() function you may assume that <math>J=1.0</math> at all times (in fact, we are working in reduced units in which <math>J=k_B</math>, but there will be more information about this in later sections). Do not worry about the efficiency of the code at the moment — we will address the speed in a later part of the experiment.===

<pre>def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
lat=self.lattice #creates lattice and stores it
mag=[]
for i in range(0,len(lat)): #loops through all rows of lattice
for j in range(0,len(lat[i])): #loops through elements of each row
mag+=[lat[i][j]] #adds spin value to mag array
return sum(mag) #sums all spins from mag array
</pre>

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

lat=self.lattice #creates lattice and stores it
left=[]
top=[]

for i in range(0,len(lat)):
for j in range(0,len(lat[i])):
left+=[lat[i][j]*lat[i][j-1]] #multiplies spin by spin to left
top+=[lat[i][j]*lat[i-1][j]] #multiplies spin by spin above it
int_en=left+top #sums spin products from left and top
energy=-sum(int_en) #sums all spin products for each spin to give total

return energy
</pre>

===TASK: Run the ILcheck.py script from the IPython Qt console using the command===

''Figure 2'' shows the results when ILcheck.py was ran on my IsingLattice.py file. The ILcheck.py file was ran several times to ensure the code worked for various random lattices.

[[File:Cg1417ILcheck run.png|thumb|left|500px| Figure 2 - Result from running the ILcheck.py file]]

 

==Section 3 - Introduction to Monte Carlo Simulation==

===TASK: How many configurations are available to a system with 100 spins? To evaluate these expressions, we have to calculate the energy and magnetisation for each of these configurations, then perform the sum. Let's be very, very, generous, and say that we can analyse <math>1\times 10^9</math> configurations per second with our computer. How long will it take to evaluate a single value of <math>\left\langle M\right\rangle_T</math>?===

For a system with 100 lattice sites and two possible spins for each site, there are <math>2^{100}</math>possible configurations for the system. <math>2^{100}= 1.27\times 10^{30} </math>, so if the computer can analyse <math>1\times 10^9</math> configurations per second, then it will take <math>\frac{1.27\times 10^{30}}{10^9} = 1.27\times 10^{21} s</math> to analyse the whole system, which is longer than the age of the universe and therefore is not a practical approach.

===TASK: Implement a single cycle of the above algorithm in the montecarlocycle(T) function. This function should return the energy of your lattice and the magnetisation at the end of the cycle. You may assume that the energy returned by your energy() function is in units of <math>k_B</math>! Complete the statistics() function. This should return the following quantities whenever it is called: <math><E>, <E^2>, <M>, <M^2></math>, and the number of Monte Carlo steps that have elapsed.===
<pre>
E = []
E2 = []
M = []
M2 = []
n_cycles = 0

def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back if rejected else not changed

self.E+=[self.energy()] #records energy
self.E2+=[self.energy()**2] #records energy squared
self.M+=[self.magnetisation()] #records magnetisation
self.M2+=[self.magnetisation()**2] #records magnetisation squared
self.n_cycles=self.n_cycles+1 #adds 1 to run total

return (self.energy(),self.magnetisation())

def statistics(self):
# complete this function so that it calculates the correct values for the averages of E, E*E (E2), M, M*M (M2), and returns them

e=np.mean(self.E)
e2=np.mean(self.E2)
m=np.mean(self.M)
m2=np.mean(self.M2)

return e,e2,m,m2,self.n_cycles
</pre>

''Figure 3'' shows the results of a single run of the montecarlostep() function and the lattice the function operated upon.

[[File:cg1417MonteCarloStep_run.png|thumb|left|Figure 3 - Results from a single montecarlostep() function and the resulting lattice produced along with the correct return from the statistics() function]]

 

===TASK: If <math>T < T_C</math>, do you expect a spontaneous magnetisation (i.e. do you expect <math>\left\langle M\right\rangle \neq 0</math>)? When the state of the simulation appears to stop changing (when you have reached an equilibrium state), use the controls to export the output to PNG and attach this to your report. You should also include the output from your statistics() function.===

If the temperature of the system is less than the Curie Temperature, <math>T_C</math> then spontaneous magnetisation can occur and the system will tend to its lowest energy state where all of the spins are parallel - this is a property of ferromagnetic materials.

[[File:Cg1417ILanim_run.png|400px|thumb|left|Figure 4 - Results from running the ILanim.py file - shows the energy and magnetisation converging over time]]

''Figure 4'' shows that over time the the system spontaneously converges to the minimum energy state with all of the spins parallel to one another and shows, as I expected, that spontaneous magnetisation occurs and also shows that the temperature of this simulation is below the Curie Temperature, <math>T < T_C</math>.

 

==Section 4 - Accelerating the Code==

===TASK: Use the script ILtimetrial.py to record how long your current version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 5'' show the results of running the ILtimetrial.py file on my code three timesː

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1.png
| width1=500
| image2=cg1417ILtimetrial_run2.png
| width2=500
| image3=cg1417ILtimetrial_run3.png
| width3=500
| footer = Figure 5 - Results of running the ILtimetrial.py file on my code three separate times
}}
 

This gave me an avergage time of <math>24.3 s \pm 0.2s</math>

===TASK: Look at the documentation for the NumPy sum function. You should be able to modify your magnetisation() function so that it uses this to evaluate M. The energy is a little trickier. Familiarise yourself with the NumPy roll and multiply functions, and use these to replace your energy double loop (you will need to call roll and multiply twice!).===

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

left=multiply(roll(self.lattice,1,axis=1),self.lattice) #product of spin with spin left of it
top=multiply(roll(self.lattice,-1,axis=0),self.lattice) #product of spin with spin above it

int_en=sum(left+top) #sum of array containing sum of left and top spin products for each spin

energy = -sum(int_en) #calculates the total energy of system
return energy

def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
return sum(sum(self.lattice)) #adds up all spins in lattice
</pre>
The use of the bumpy modules reduces the amount of code required and removes the need for loops making the code significantly shorter, and is therefore expected to run ILtimetrial.py faster than the initial code developed.

===TASK: Use the script ILtimetrial.py to record how long your new version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 6'' shows the result of running the ILtimetrial.py on my new accelerated code.

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1fast.png
| width1=500
| image2=ILtimetrial_run2fast.png
| width2=500
| image3=ILtimetrial_run3fast.png
| width3=500
| footer = Figure 6 - Results of running the ILtimetrial.py file on my new updated and accelerated code.
}}
 

The accelerated code is much faster upon using the roll, multiply and sum modules with a new average time of <math>0.790 s \pm 0.005 </math>

==Section 5 - The effect of temperature==

===TASK: The script ILfinalframe.py runs for a given number of cycles at a given temperature, then plots a depiction of the final lattice state as well as graphs of the energy and magnetisation as a function of cycle number. This is much quicker than animating every frame! Experiment with different temperature and lattice sizes. How many cycles are typically needed for the system to go from its random starting position to the equilibrium state? Modify your statistics() and montecarlostep() functions so that the first N cycles of the simulation are ignored when calculating the averages. You should state in your report what period you chose to ignore, and include graphs from ILfinalframe.py to illustrate your motivation in choosing this figure.===

''Figure 7'' below shows the results from running the ILfinalframe.py for 2x2 lattice at T=1,2,3,5.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2T1.png
| image2 = cg14172x2T2.png
| image3 =cg14172x2T3.png
| image4 =cg14172x2T5.png
| footer_align = left
| footer = Figure 7 - Results of running the ILfinalframe.py file at T=1,2,3,5 for a 2x2 matrix.
}}

 

For a 2x2 matrix, a suitable cut-off point to exclude from the avergage energies and magnetisations is where the energy and magnetisations per spin are constant, which is 30 steps. For T=3 and T=5 the graphs do not converge because it is possible that these temperatures are higher than the Curie Temperature and as such spontaneous magnetisation will not occur and the system will not diverge to the lowest energy state. At the higher temperatures, there are larger thermal fluctations and the Boltzmann factor is more significant allowing the system to move away from the lowest energy state easier. As a result moving forwards, a suitable cut-off point will only be determined from T=1 and T=2 graphs for the larger matrices.

''Figure 8'' shows the results from running a 4x4 lattice at T=1,2 and 3.

{{multiple image
| width =350
| align = left
| image1 = cg14174x4T1.png
| image2 = cg14174x4T2.png
| image3 =cg14174x4T3.png
| footer_align = left
| footer = Figure 8 - Results of running the ILfinalframe.py file at T=1,2,3 for a 4x4 matrix.
}}

From ''Figure 8'', a suitable cut-off point for the energy and magnetisations is 200 as this is after where the energy and magnetisation has converged for T=1, and is after the initial large drop in energy for T=2, even though there are a few small fluctuations after 200 steps. The result from T=3 has been included to show the large fluctuations for the larger temperatures, and supporting my choice to determine the cut-off from T=1 and T=2 only.

''Figure 9'' shows the results for an 8x8 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg14178x8T1.png
| image2 = cg14178x8T2.png
| footer_align = left
| footer = Figure 9 - Results of running the ILfinalframe.py file at T=1,2 for an 8x8 matrix
}}

From ''Figure 9'' above, a suitable cut-off point is 1000 steps as this is where the energy and magnetisation has easily converged by and is also the point after which the initial large drop in energy has been overcome for T=2 too.

''Figure 10'' shows the result of running the ILfinalframe.py for a 16x16 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg141716x16T1.png
| image2 = cg141716x16T2.png
| footer_align = left
| footer = Figure 10 - Results of running the ILfinalframe.py file at T=1,2 for a 16x16 matrix
}}

From ''Figure 10'', a suitable cut-off point is 15000 steps as for T=1 the energy and magnetisations have converged significantly and will not change much, and likewise this is the same for the T=2 frame.

''Figure 11'' below shows the results from a 32x32 matrix at T=1 and T=2.

{{multiple image
| width =350
| align = left
| image1 = cg141732x32T1.png
| image2 = cg141732x32T2.png
| footer_align = left
| footer = Figure 11 - Results of running the ILfinalframe.py file at T=1,2 for a 32x32 matrix
}}

''Figure 11'' above shows the results of running the ILfinalframe.py file for a 32x32 matrix at T=1 and T=2. As a result a suitable cut-off of 50000 steps was chosen as the energy and magnetisation has significantly converged, but not as much as it could at 100000 steps. I chose a slightly lower value to ensure that the run times of my monte-carlo simulations in future tasks were not extremely time consuming.

The montecarlostep() function was changed by adding a condition that values only above the pre-determined cut-off were included when determining the average value of energy; energy squared; magnetisation and magnetisations squared from the statistics function. The statistics() function did not need to be modified.

The following code is from the 32x32 matrixː

<pre>def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back

if self.n_cycles > 50000: #only adds values to array of E,E2,M and M2 above the specific cut-off
self.E+=[self.energy()]
self.E2+=[self.energy()**2]
self.M+=[self.magnetisation()]
self.M2+=[self.magnetisation()**2]
self.n_cycles=self.n_cycles+1

return (self.energy(),self.magnetisation())
</pre>

===TASK: Use ILtemperaturerange.py to plot the average energy and magnetisation for each temperature, with error bars, for an <math>8\times 8</math> lattice. Use your intuition and results from the script ILfinalframe.py to estimate how many cycles each simulation should be. The temperature range 0.25 to 5.0 is sufficient. Use as many temperature points as you feel necessary to illustrate the trend, but do not use a temperature spacing larger than 0.5. The NumPy function savetxt() stores your array of output data on disk — you will need it later. Save the file as 8x8.dat so that you know which lattice size it came from.===

Using the modified code, the file ILtemperaturerange.py was ran on an 8x8 matrix between T=0.5 and T=5 with a step of T=0.02 for 10000 Montecarlo steps and the first 1000 steps of each temperature were excluded when calculating the averages. ''Figure 12'' shows the result of the simulation and also included error bars of standard deviation.

[[File:Cg14178x8error.png|1000px|thumb|left|Figure 12 - Graph showing average energy and average magnetisation for an 8x8 lattice with error bars between T=0.5 and T=5]]

 

Below is the source code for the script to produce the graph from CG1417IsingModelGraphs.ipynbː

<pre>data8x8=np.loadtxt('8x8.dat') #loads data
temps8x8=data8x8[:,0] #stores temperatures
energies8x8=data8x8[:,1] #stores average energy for each T
energysq8x8=data8x8[:,2] #stores average energy squared for each T
mag8x8=data8x8[:,3] #stores magnetisation for each T
magsq8x8=data8x8[:,4] #stores magnetisation squared for each T
stde8x8=data8x8[:,5] #edited ILtemperaturerange.py to record the standard deviation of the energy for each T
stdm8x8=data8x8[:,6] #edited ILtemperaturerange.py to record the standard deviation of the magnetisation for each T

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.errorbar(temps8x8, np.array(energies8x8)/64,yerr=np.divide(stde8x8,64),color='black',ecolor='teal',alpha=0.8) #plots energy per spin against T
magax.errorbar(temps8x8, np.array(mag8x8)/64,yerr=np.divide(stdm8x8,64),alpha=0.8,ecolor='salmon',color='black') #plots magnetisation per spin against T on separate graph
pl.savefig('8x8error.png',bbox_inches='tight') #saves figure
pl.show()

</pre>

==Section 6 - The effect of system size==

===TASK: Repeat the final task of the previous section for the following lattice sizes: 2x2, 4x4, 8x8, 16x16, 32x32. Make sure that you name each datafile that your produce after the corresponding lattice size! Write a Python script to make a plot showing the energy per spin versus temperature for each of your lattice sizes. Hint: the NumPy loadtxt function is the reverse of the savetxt function, and can be used to read your previously saved files into the script. Repeat this for the magnetisation. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. How big a lattice do you think is big enough to capture the long range fluctuations?===

The python script for this section is identical as for the 8x8 graph above in Figure 12 with the relevant files and variables changed accordingly.

Each matrix was simulated using the ILtemperaturerange.py file between T=0.5 and T=5 with a step of T=0.02.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2error.png
| caption1 = 2x2 matrix - 5000 steps, cut-off = 30 steps
| image2 = 4x4error.png
| caption2 = 4x4 matrix - 1000 steps, cut-off = 200 steps
| image3 =cg141716x16error.png
| caption3 = 16x16 matrix - 50000 steps, cut-off = 15000 steps
| image4 =cg141732x32error.png
| caption4 = 32x32 matrix - 200000 steps, cut-off = 50000 steps
| footer_align = left
| footer = Figure 13 - Results of running the ILtemperaturerange.py file for 2x2, 4x4, 16x16 and 32x32 matrices.
}}

 

Long-range interactions are present and more significant in the smaller lattices where there are fewer stronger, short range interactions. As a result, I expect long-range interactions to be important in square lattices up to a 4x4 size.

==Section 7 - Determining the Heat Capacity==

===TASK: By definition, <math>C = \frac{\partial \left\langle E\right\rangle}{\partial T}</math>. From this, show that <math>C = \frac{\mathrm{Var}[E]}{k_B T^2}</math> (Where <math>\mathrm{Var}[E]</math> is the variance in <math>E</math>.)===

Recall from statistical thermodynamics that the average energy of a system is the sum across all microstates of the probability of that microstate multiplied by the energy of that microstate, which is defined mathematically asː <math>\langle E \rangle = \sum_i p_{i}\epsilon_{i}</math>.

The partition function <math>q</math> is defined as <math>q = \sum_{i} exp(-\beta \epsilon_{i})</math> where <math>\beta =\frac{1}{k_BT}</math>and the probability, <math>p_{i}</math> can be defined in terms of the partition function as <math>p_{i} = \frac{exp(-\beta \epsilon_{i})}{\sum_{i} exp(-\beta \epsilon_{i})} = \frac{exp(-\beta \epsilon_{i})}{q}</math>.

As a result, <math>\langle E \rangle</math> can be re-written as <math>\langle E \rangle = \sum_{i} \frac{\epsilon_{i} exp(-\beta \epsilon_{i})}{q} = -\frac{1}{q} \frac{\partial}{\partial \beta}\sum_{i}exp(-\beta \epsilon_{i}) = -\frac{1}{q} \frac{\partial q}{\partial \beta}</math>

Likewise, <math>\langle E^2 \rangle = \sum_i p_{i}\epsilon_{i}^{2} = \sum_{i} \frac{\epsilon_{i}^{2}exp(-\beta \epsilon_{i})}{q} = \frac{1}{q} \frac{\partial^{2}}{\partial \beta^{2}}\sum_{i}exp(-\beta \epsilon_{i}) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}}</math>

From definitionː <math>Var[E] = \Delta E^2 = \langle E^2 \rangle - \langle E \rangle^2 </math>

When the definition of <math>\langle E \rangle</math> and <math>\langle E^2 \rangle</math> is written in terms of partition function <math>q</math>ː <math>Var[E] = \langle E^2 \rangle - \langle E \rangle^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \left(\frac{1}{q}\frac{\partial q}{\partial \beta}\right)^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2</math>.

According to the chain ruleː <math>\frac{\partial}{\partial \beta}\left(\frac{1}{q} \frac{\partial q}{\partial \beta}\right) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2 = -\frac{\partial}{\partial \beta}\langle E \rangle = Var[E]</math>

And using the chain rule againː <math>C = \frac{\partial \langle E \rangle}{\partial T}= \left(-\frac{\partial \langle E \rangle}{\partial \beta}\right) \left(-\frac{\partial \beta}{\partial T}\right) = \frac{Var[E]}{k_B T^2}</math>

===TASK: Write a Python script to make a plot showing the heat capacity versus temperature for each of your lattice sizes from the previous section. You may need to do some research to recall the connection between the variance of a variable, <math>\mathrm{Var}[X]</math>, the mean of its square <math>\left\langle X^2\right\rangle</math>, and its squared mean <math>\left\langle X\right\rangle^2</math>. You may find that the data around the peak is very noisy — this is normal, and is a result of being in the critical region. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. ===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb

{{multiple image
| width =300
| align = left
| image1 = cg14172x2heatcap.png
| caption1 = 2x2 Matrix
| image2 = cg14174x4heatcap.png
| caption2 = 4x4 Matrix
| image3 =cg14178x8heatcap.png
| caption3 = 8x8 Matrix
| image4 =cg141716x16heatcap.png
| caption4 = 16x16 Matrix
| image5=cg141732x32heatcap.png
| caption5= 32x32 Matrix
| footer = Figure 14 - Graphs showing Heat Capacity against Temperature for each matrix size
}}

Here is the source code to produce the figuresː
<pre> def heatCap(energies,energysq,T,latsize):
#defines the heat capacity for a given temperature
energiesq=np.multiply(energies,energies) #creates array of (average energies) squared
varE=np.subtract(energysq,energiesq) #defines variance of average energy
tempsq=np.multiply(T,T) #array of temperature squared
return np.array(np.divide(varE,tempsq))/(latsize**2)

heatCap2x2=heatCap(energies2x2,energysq2x2,temps2x2,2) #creates array of heat capacity for each T

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(temps2x2,heatCap2x2,color='orange') #plots heat capacity for each T
pl.savefig('cg14172x2heatcap.png',bbox_inches='tight') #saves figure
pl.show()
</pre>

A general trend from the above graphs is that the peak of the graph shifts towards lower temperatures as the size of the matrix used increases which means the Curie Temperature decreases as matrix size increases. Also, as lattice size increases the noise around the peak becomes larger which will affect the accuracy of determining the maximum heat capacity and Curie Temperature for the larger lattices.

==Section 8 - Locating the Curie Temperature==
===TASK: A C++ program has been used to run some much longer simulations than would be possible on the college computers in Python. You can view its source code here if you are interested. Each file contains six columns: <math>T, E, E^2, M, M^2, C</math> (the final five quantities are per spin), and you can read them with the NumPy loadtxt function as before. For each lattice size, plot the C++ data against your data. For one lattice size, save a PNG of this comparison and add it to your report — add a legend to the graph to label which is which. To do this, you will need to pass the label="..." keyword to the plot function, then call the legend() function of the axis object (documentation here).===

The python code used to read and plot the C++ data is found in the Jupyter notebook CG1417IsingModelGraphs.ipynb.

''Figure 15'' below shows the C++ plotted against my own data for a 16x16 Matrix.

[[File:Cg141716x16C++.png|400px|thumb|left|Figure 15 - Graph showing my own data against the C++ data for a 16x16 matrix.]]

 

The curves produced using the C++ data are much smoother and have less noise than the data gained from my python code. This is likely due to the C++ code having more montecarlosteps per temperature, reducing the effect of random fluctuations on the averages and also having a smaller step gap which will make the curve smoother as the points are closer together.

Here is the source code the produce the figuresː
<pre>#reads data from C++ file
temps2x2C=data2x2C[:,0]
energies2x2C=data2x2C[:,1]
energysq2x2C=data2x2C[:,2]
mag2x2C=data2x2C[:,3]
magsq2x2C=data2x2C[:,4]
heatcap2x2C=data2x2C[:,5]

#fitting C++ data

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.plot(temps2x2, np.array(energies2x2)/4,color='black',alpha=0.7,label='Python Data') #python energy against T
enerax.plot(temps2x2C, energies2x2C, color='red',label='C++ Data') #C energy against T
magax.plot(temps2x2, np.array(mag2x2)/4,color='black',alpha=0.7,label='Python Data') #python magnetisation against T
magax.plot(temps2x2C, mag2x2C,color='red',label='C++ Data') #C energy against T
enerax.legend() #shows legend on energy graph
magax.legend() #shows legend on energy graph
pl.show()
</pre>

The relevant variables and dat files were changed for each matrix.

===TASK: write a script to read the data from a particular file, and plot C vs T, as well as a fitted polynomial. Try changing the degree of the polynomial to improve the fit — in general, it might be difficult to get a good fit! Attach a PNG of an example fit to your report.===

The python script to read and plot the fitted polynomial is found in CG1417PolyfitScript.ipynb

Here is the source code for ''Figure 15''

<pre>data_test = np.loadtxt("16x16C.dat")
T_test = data_test[:,0] #gets temperatures
C_test = data_test[:,5] #gets heat capacity data

#first we fit the polynomial to the data
fit_test = np.polyfit(T_test, C_test, 35) # fit a polynomial of degree 35ǃ

#now we generate interpolated values of the fitted polynomial over the range of our function
T_min_test = 0.5 #np.min(T_test)
T_max_test = 5 #np.max(T_test)

T_range_test = np.linspace(T_min_test, T_max_test, 1000) #generate 1000 evenly spaced points between T_min and T_max
fitted_C_values_test = np.polyval(fit_test, T_range_test)# use the fit object to generate the corresponding values of C

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(T_test,C_test,color='orange',label='C++ Data') #plots C data of heat capacity against temp
heatcapax.plot(T_range_test,fitted_C_values_test,label='Fitted Polynomial') #plots fitted polynomial for whole range of temp
heatcapax.legend()
pl.savefig('FIT_TEST16x16_35.png', bbox_inches='tight') #saves figure
pl.show()
</pre>

Below in ''Figure 16'' is a plot of my Heat Capacity against Temperature data for a 16x16 matrix and features a polynomial of degree 35 plotted against it. Even with a polynomial of such a high degree, it poorly fits the curve and does not fit to the peak of the curve either.

[[File:cg1417FIT_TEST16x16_35.png|thumb|left|400px|Figure 16 - Plot of Heat Capacity against Temperature along with a poorly fitted polynomial of degree 35. ]]

 

===TASK: Modify your script from the previous section. You should still plot the whole temperature range, but fit the polynomial only to the peak of the heat capacity! You should find it easier to get a good fit when restricted to this region===

The script was modified as such that the polynomial was fitted in a set range around the peak of the graph, this is demonstrated in ''Figure 17'' which shows a newly fitted polynomial between a much smaller range of temperatures (T = 2.15-2.55) and a much smaller degree polynomial (3).

[[File:CG1417FIT_16x16C_3.png|thumb|left|400px|Figure 17 - Graph showing Heat Capacity against Temperature for a 16x16 matrix along with a fitted polynomial between a much more restricted range of temperatures and a significantly lower degree of polynomial]]

Upon comparison with ''Figure 16'', the new fitted polynomial is a significantly better fit even for a 3rd degree polynomial and is a much more accurate representation of my data around the peak of the graph and will make it easier to determine the maximum value of Heat Capacity. However, the polyfit curve still doesn't perfectly fit the peak due to the significant amount of noise present there.

 

Here is the source code for ''Figure 17''ː
<pre>data16 = np.loadtxt("16x16C.dat") #loads data to variable

T16 = data16[:,0] #gets temps
C16 = data16[:,5] # gets heat capacities

Tmin16 = 2.15 #chosen min temp
Tmax16 = 2.55 #chosen max temp

selection16 = np.logical_and(T16 > Tmin16, T16 < Tmax16) #choose only those rows where both conditions are true
peak_T_values16 = T16[selection16] #choose temp values in range chosen above
peak_C_values16 = C16[selection16] #choose heat cap values in range of t above

fit16 = np.polyfit(peak_T_values16,peak_C_values16,3) #fit 3rd order polynomial
peak_T_range16 = np.linspace(Tmin16, Tmax16, 1000) #defines 1000 temps within data range
fitted_C_values16 = np.polyval(fit16, peak_T_range16) #use the fit object to get corresponding values of heat cap

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(T16,C16,color='orange',label='C++ Data') #plots C data of heat cap against temp
heatcapax.plot(peak_T_range16,fitted_C_values16,label='Fitted Polynomial') #plots fitted polynomial for small range
heatcapax.legend()
pl.savefig('FIT_16x16C_3.png', bbox_inches='tight') #saves figure
pl.show()

</pre>

===TASK: find the temperature at which the maximum in C occurs for each datafile that you were given. Make a text file containing two colums: the lattice side length (2,4,8, etc.), and the temperature at which C is a maximum. This is your estimate of <math>T_C</math> for that side length. Make a plot that uses the scaling relation given above to determine <math>T_{C,\infty}</math>. By doing a little research online, you should be able to find the theoretical exact Curie temperature for the infinite 2D Ising lattice. How does your value compare to this? Are you surprised by how good/bad the agreement is? Attach a PNG of this final graph to your report, and discuss briefly what you think the major sources of error are in your estimate.===

''Figure 18'' below shows a graph of <math>T_{C,L}</math> against <math>\frac{1}{Lattice Size}</math> to determine the Curie Temperature of an infinite 2D Ising Model Lattice <math>T_{C,\infty}</math>. The black dots represent the raw data obtained from obtaining the temperature at which the Heat Capacity was a maximum for the lattices and the red line in a linear curve fit plotted against the data to allow the y-intercept which is the Curie Temperature for the infinite 2D lattice to be determined.

[[File:cg1417CurieTemp.png|400px|thumb|left|Figure 18 - Plot of 1/Lattice Size against Curie Temperature for that lattice size.]]

The value for <math>T_{C,\inf}</math> obtained from the data is <math>T_{C,\infty} = 2.277 \frac{J}{k_B}</math> with a literature value being <math>T_{C,\infty} = 2.269 \frac{J}{k_B}</math> <ref>L. Onsager, Phys. Rev., 1944, 65, 117--149.</ref>for an infinite square 2D lattice. This means that my result slightly over-estimates the Curie Temperature for the infinite lattice and as a result for an infinite lattice the temperature at which spontaneous magnetisation stops would actually occur at a slightly lower temperature than expected. However, the difference between my value and the literature value is only 0.008 which is incredibly small and the amount of agreement between the two values is somewhat surprising, which means that the error in my estimates of the Curie Temperature for each lattice size is relatively small. The points which have the largest residuals and deviation from the line of best fit in ''Figure 17'' corresponds to the smaller lattice sizes of 2x2 and 4x4 where longer range interactions are more significant. The longer range interactions posed by the boundary conditions are significant for the smaller sizes and causes the energy of the smaller matrices to be less accurate and have a larger associated error with the energy and the Curie Temperature for that lattice size. This affects the accuracy of the line of best fit and to increase the accuracy of this line, larger lattice sizes of 128x128, 256x256 etc should be included in the calculation for the line of best fit and the smaller matrices ignored - this should allow a more accurate value of <math>T_{C,\infty}</math> to be determined.

 

Below is the source code used to generate ''Figure 18'' from CG1417PolyfitScript.py
<pre>
Cmax64x64 = np.max(fitted_C_values64) #finds Cmax for 64x64 matrix - done for others already
Tmax64x64 = peak_T_range64[fitted_C_values64 == Cmax64x64] #finds Tmax corresponding to Cmax

LatSize=[2,4,8,16,32,64] #stores lattice sizes
Tmax=[Tmax2x2,Tmax4x4,Tmax8x8,Tmax16x16,Tmax32x32,Tmax64x64] #stores corresponding Tmax data
np.savetxt('CmaxVSTmax.txt', (LatSize,Tmax)) #writes data to txt file

ScalData=np.loadtxt('CmaxVSTmax.txt') #loads data
LatticeSize=ScalData[0] #gets lattice sizes
TempMax=ScalData[1] #gets max temp or curie temp for each lattice

Lmin1min = np.min(np.divide(1,LatticeSize)) #minimum of 1/LatticeSize values
Lmin1max = np.max(np.divide(1,LatticeSize)) #maximum of 1/LatticeSize values

fitTcl = np.polyfit(np.divide(1,LatticeSize),TempMax, 1) #creates fit object

Lmin1values = np.linspace(Lmin1min, Lmin1max, 1000) #finds 1000 values between min and max x-axis value of 1/LatticeSize
fitted_Tcl_values = np.polyval(fitTcl, Lmin1values) #creates corresponding Curie Temp values for each value in Lmin1values

fig = pl.figure()
scalrelax = fig.add_subplot(1,1,1)
scalrelax.set_xlabel('1/Lattice Size')
scalrelax.set_ylabel('Curie Temperature/ J/k_B')
scalrelax.plot(np.divide(1,LatticeSize),TempMax,color='black',marker='.',linestyle='') #plots Curie Temp against 1/LatticeSize
scalrelax.plot(Lmin1values,fitted_Tcl_values,color='red',marker='',linestyle='-') #plots line of best fit for data above
pl.savefig('CurieTemp.png', bbox_inches='tight') #saves figure
pl.show()

</pre>

== References ==

Rep:Y3CMPCG1417

2019-11-20T10:42:43Z

Cg1417: /* TASK: find the temperature at which the maximum in C occurs for each datafile that you were given. Make a text file containing two colums: the lattice side length (2,4,8, etc.), and the temperature at which C is a maximum. This is your estimate of T...

==Section 1 - Introduction to the Ising Model==

===TASK: Show that the lowest possible energy for the Ising model is <math>E = -DNJ</math>, where D is the number of dimensions and N is the total number of spins. What is the multiplicity of this state? Calculate its entropy.===

Consider a 1D row of lattice sites of N=3 with spin configuration [+1][+1][+1].

Mathematically the interaction energy is defined asː
<math> -\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} </math> where J is a constant and <math>s_{i}s_{j}</math> is the product between two spins in adjacent lattice sites.

The sum of the interaction energies <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j}</math> can be considered as the sum of the individual interaction energies between spinsː
<math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = \epsilon_{12} + \epsilon_{23} + \epsilon_{13} + \epsilon_{21} + \epsilon_{32} + \epsilon_{31} </math>.

Although lattice sites 1 and 3 are not adjacent they are said to still interact according to the periodic boundary conditions applied.

However, <math>\epsilon_{12} = \epsilon_{21} </math> and <math>\epsilon_{23} = \epsilon_{32}</math> and <math>\epsilon_{13} = \epsilon_{31}</math> which means that all of the interactions within the system are counted twice, hence the total energy needs to be halved, resulting in the following formula being obtainedː <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = 2\epsilon_{12} + 2\epsilon_{13} + 2\epsilon_{23} </math>.

It can be determined that <math>\epsilon_{12} = (+1)(+1) = 1</math> , <math>\epsilon_{13} = (+1)(+1) = 1</math> and <math>\epsilon_{23} = (+1)(+1) = 1</math>.

Thereforeː <math>-\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = -\frac{1}{2} \ J \ (2 + 2 + 2) = -\frac{1}{2} \ J \ 6 = - 3 J = -DNJ</math> for a 1D lattice with <math>D=1</math> and 3 lattice sites <math>N=3</math>

The multiplicity of the system,<math>\Omega = \frac{lattice sites!}{n. spin up!n. spin down!}</math>

Entropy, <math>S</math> is defined as <math>S = k_B ln(\Omega)</math> and so in this case <math>S = k_B ln(\frac{100!}{100!}) = 0</math>

===TASK: Imagine that the system is in the lowest energy configuration. To move to a different state, one of the spins must spontaneously change direction ("flip"). What is the change in energy if this happens <math>(D=3, N=1000)</math>? How much entropy does the system gain by doing soʔ===

In a 3D lattice system, each lattice site has three unique interactions with its neighbours to its left, top and front. In the lowest energy configuration, all spins are parallel and for a system the minimum energy is <math>E = -DNJ</math>, so for the system with <math>N=1000</math> and <math>D=3</math>, the minimum energy is <math>-3000J</math>.

If a single spin is flipped, the product of its spin with its neighbours spin reverses and becomes negative and this increases the total energy of the system. Since 3 unique spin-spin interactions are reversed in sign, the total energy increases by <math>+3J</math>, meaning the new total energy is <math>-2997J</math>

Initially the multiplicity of the system will be <math>\Omega = \frac{1000!}{1000!}</math> , and after the flip, the multiplicity becomes <math> \Omega = \frac{1000!}{999!1!}=1000</math>.

The associated change in entropy, <math>\Delta S = k_B ln(1000) - 0 = 6.91 k_B</math>, which is an expected increase in entropy as the number of possible configurations of the system increases.

===TASK: Calculate the magnetisation of the 1D and 2D lattices in Figure 1. What magnetisation would you expect to observe for an Ising lattice with <math>D = 3,\ N=1000</math> at absolute zero?===

[[File:ThirdYearCMPExpt-IsingSketch.png|thumb|left|Figure 1 - Shows 1D (N = 5), 2D (N = 5x5) and 3D (N = 5x5x5) lattices.]]

Magnetisation is defined as <math>M=\sum_{i} s_i</math>. So for the 1D lattice with <math>N = 5</math> in ''Figure 2'', <math>M = +1</math> and for the 2D lattice with <math>N = 25 , M = +1</math> too.

According to the 3rd Law of thermodynamics, entropy is 0 at absolute zero for a perfect crystalline solid, and consequently it is expected that the lattices will have follow suit and have zero entropy at 0K. To have zero entropy all spins must be parallel as such that magnetisation, <math>M = N</math>. For all the spins to be parallel, there is only one possible configuration. So, for a lattice with <math>N = 1000</math> and <math>D =3</math>, if <math>M = N</math>, then multiplicity, <math>\Omega = 1</math> and entropy, <math>S =k_B ln(1) = 0</math>.

 

==Section 2 - Calculating the Energy and Magnetisation==

===TASK: complete the functions energy() and magnetisation(), which should return the energy of the lattice and the total magnetisation, respectively. In the energy() function you may assume that <math>J=1.0</math> at all times (in fact, we are working in reduced units in which <math>J=k_B</math>, but there will be more information about this in later sections). Do not worry about the efficiency of the code at the moment — we will address the speed in a later part of the experiment.===

<pre>def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
lat=self.lattice #creates lattice and stores it
mag=[]
for i in range(0,len(lat)): #loops through all rows of lattice
for j in range(0,len(lat[i])): #loops through elements of each row
mag+=[lat[i][j]] #adds spin value to mag array
return sum(mag) #sums all spins from mag array
</pre>

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

lat=self.lattice #creates lattice and stores it
left=[]
top=[]

for i in range(0,len(lat)):
for j in range(0,len(lat[i])):
left+=[lat[i][j]*lat[i][j-1]] #multiplies spin by spin to left
top+=[lat[i][j]*lat[i-1][j]] #multiplies spin by spin above it
int_en=left+top #sums spin products from left and top
energy=-sum(int_en) #sums all spin products for each spin to give total

return energy
</pre>

===TASK: Run the ILcheck.py script from the IPython Qt console using the command===

''Figure 2'' shows the results when ILcheck.py was ran on my IsingLattice.py file. The ILcheck.py file was ran several times to ensure the code worked for various random lattices.

[[File:Cg1417ILcheck run.png|thumb|left|500px| Figure 2 - Result from running the ILcheck.py file]]

 

==Section 3 - Introduction to Monte Carlo Simulation==

===TASK: How many configurations are available to a system with 100 spins? To evaluate these expressions, we have to calculate the energy and magnetisation for each of these configurations, then perform the sum. Let's be very, very, generous, and say that we can analyse <math>1\times 10^9</math> configurations per second with our computer. How long will it take to evaluate a single value of <math>\left\langle M\right\rangle_T</math>?===

For a system with 100 lattice sites and two possible spins for each site, there are <math>2^{100}</math>possible configurations for the system. <math>2^{100}= 1.27\times 10^{30} </math>, so if the computer can analyse <math>1\times 10^9</math> configurations per second, then it will take <math>\frac{1.27\times 10^{30}}{10^9} = 1.27\times 10^{21} s</math> to analyse the whole system, which is longer than the age of the universe and therefore is not a practical approach.

===TASK: Implement a single cycle of the above algorithm in the montecarlocycle(T) function. This function should return the energy of your lattice and the magnetisation at the end of the cycle. You may assume that the energy returned by your energy() function is in units of <math>k_B</math>! Complete the statistics() function. This should return the following quantities whenever it is called: <math><E>, <E^2>, <M>, <M^2></math>, and the number of Monte Carlo steps that have elapsed.===
<pre>
E = []
E2 = []
M = []
M2 = []
n_cycles = 0

def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back if rejected else not changed

self.E+=[self.energy()] #records energy
self.E2+=[self.energy()**2] #records energy squared
self.M+=[self.magnetisation()] #records magnetisation
self.M2+=[self.magnetisation()**2] #records magnetisation squared
self.n_cycles=self.n_cycles+1 #adds 1 to run total

return (self.energy(),self.magnetisation())

def statistics(self):
# complete this function so that it calculates the correct values for the averages of E, E*E (E2), M, M*M (M2), and returns them

e=np.mean(self.E)
e2=np.mean(self.E2)
m=np.mean(self.M)
m2=np.mean(self.M2)

return e,e2,m,m2,self.n_cycles
</pre>

''Figure 3'' shows the results of a single run of the montecarlostep() function and the lattice the function operated upon.

[[File:cg1417MonteCarloStep_run.png|thumb|left|Figure 3 - Results from a single montecarlostep() function and the resulting lattice produced along with the correct return from the statistics() function]]

 

===TASK: If <math>T < T_C</math>, do you expect a spontaneous magnetisation (i.e. do you expect <math>\left\langle M\right\rangle \neq 0</math>)? When the state of the simulation appears to stop changing (when you have reached an equilibrium state), use the controls to export the output to PNG and attach this to your report. You should also include the output from your statistics() function.===

If the temperature of the system is less than the Curie Temperature, <math>T_C</math> then spontaneous magnetisation can occur and the system will tend to its lowest energy state where all of the spins are parallel - this is a property of ferromagnetic materials.

[[File:Cg1417ILanim_run.png|400px|thumb|left|Figure 4 - Results from running the ILanim.py file - shows the energy and magnetisation converging over time]]

''Figure 4'' shows that over time the the system spontaneously converges to the minimum energy state with all of the spins parallel to one another and shows, as I expected, that spontaneous magnetisation occurs and also shows that the temperature of this simulation is below the Curie Temperature, <math>T < T_C</math>.

 

==Section 4 - Accelerating the Code==

===TASK: Use the script ILtimetrial.py to record how long your current version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 5'' show the results of running the ILtimetrial.py file on my code three timesː

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1.png
| width1=500
| image2=cg1417ILtimetrial_run2.png
| width2=500
| image3=cg1417ILtimetrial_run3.png
| width3=500
| footer = Figure 5 - Results of running the ILtimetrial.py file on my code three separate times
}}
 

This gave me an avergage time of <math>24.3 s \pm 0.2s</math>

===TASK: Look at the documentation for the NumPy sum function. You should be able to modify your magnetisation() function so that it uses this to evaluate M. The energy is a little trickier. Familiarise yourself with the NumPy roll and multiply functions, and use these to replace your energy double loop (you will need to call roll and multiply twice!).===

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

left=multiply(roll(self.lattice,1,axis=1),self.lattice) #product of spin with spin left of it
top=multiply(roll(self.lattice,-1,axis=0),self.lattice) #product of spin with spin above it

int_en=sum(left+top) #sum of array containing sum of left and top spin products for each spin

energy = -sum(int_en) #calculates the total energy of system
return energy

def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
return sum(sum(self.lattice)) #adds up all spins in lattice
</pre>
The use of the bumpy modules reduces the amount of code required and removes the need for loops making the code significantly shorter, and is therefore expected to run ILtimetrial.py faster than the initial code developed.

===TASK: Use the script ILtimetrial.py to record how long your new version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 6'' shows the result of running the ILtimetrial.py on my new accelerated code.

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1fast.png
| width1=500
| image2=ILtimetrial_run2fast.png
| width2=500
| image3=ILtimetrial_run3fast.png
| width3=500
| footer = Figure 6 - Results of running the ILtimetrial.py file on my new updated and accelerated code.
}}
 

The accelerated code is much faster upon using the roll, multiply and sum modules with a new average time of <math>0.790 s \pm 0.005 </math>

==Section 5 - The effect of temperature==

===TASK: The script ILfinalframe.py runs for a given number of cycles at a given temperature, then plots a depiction of the final lattice state as well as graphs of the energy and magnetisation as a function of cycle number. This is much quicker than animating every frame! Experiment with different temperature and lattice sizes. How many cycles are typically needed for the system to go from its random starting position to the equilibrium state? Modify your statistics() and montecarlostep() functions so that the first N cycles of the simulation are ignored when calculating the averages. You should state in your report what period you chose to ignore, and include graphs from ILfinalframe.py to illustrate your motivation in choosing this figure.===

''Figure 7'' below shows the results from running the ILfinalframe.py for 2x2 lattice at T=1,2,3,5.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2T1.png
| image2 = cg14172x2T2.png
| image3 =cg14172x2T3.png
| image4 =cg14172x2T5.png
| footer_align = left
| footer = Figure 7 - Results of running the ILfinalframe.py file at T=1,2,3,5 for a 2x2 matrix.
}}

 

For a 2x2 matrix, a suitable cut-off point to exclude from the avergage energies and magnetisations is where the energy and magnetisations per spin are constant, which is 30 steps. For T=3 and T=5 the graphs do not converge because it is possible that these temperatures are higher than the Curie Temperature and as such spontaneous magnetisation will not occur and the system will not diverge to the lowest energy state. At the higher temperatures, there are larger thermal fluctations and the Boltzmann factor is more significant allowing the system to move away from the lowest energy state easier. As a result moving forwards, a suitable cut-off point will only be determined from T=1 and T=2 graphs for the larger matrices.

''Figure 8'' shows the results from running a 4x4 lattice at T=1,2 and 3.

{{multiple image
| width =350
| align = left
| image1 = cg14174x4T1.png
| image2 = cg14174x4T2.png
| image3 =cg14174x4T3.png
| footer_align = left
| footer = Figure 8 - Results of running the ILfinalframe.py file at T=1,2,3 for a 4x4 matrix.
}}

From ''Figure 8'', a suitable cut-off point for the energy and magnetisations is 200 as this is after where the energy and magnetisation has converged for T=1, and is after the initial large drop in energy for T=2, even though there are a few small fluctuations after 200 steps. The result from T=3 has been included to show the large fluctuations for the larger temperatures, and supporting my choice to determine the cut-off from T=1 and T=2 only.

''Figure 9'' shows the results for an 8x8 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg14178x8T1.png
| image2 = cg14178x8T2.png
| footer_align = left
| footer = Figure 9 - Results of running the ILfinalframe.py file at T=1,2 for an 8x8 matrix
}}

From ''Figure 9'' above, a suitable cut-off point is 1000 steps as this is where the energy and magnetisation has easily converged by and is also the point after which the initial large drop in energy has been overcome for T=2 too.

''Figure 10'' shows the result of running the ILfinalframe.py for a 16x16 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg141716x16T1.png
| image2 = cg141716x16T2.png
| footer_align = left
| footer = Figure 10 - Results of running the ILfinalframe.py file at T=1,2 for a 16x16 matrix
}}

From ''Figure 10'', a suitable cut-off point is 15000 steps as for T=1 the energy and magnetisations have converged significantly and will not change much, and likewise this is the same for the T=2 frame.

''Figure 11'' below shows the results from a 32x32 matrix at T=1 and T=2.

{{multiple image
| width =350
| align = left
| image1 = cg141732x32T1.png
| image2 = cg141732x32T2.png
| footer_align = left
| footer = Figure 11 - Results of running the ILfinalframe.py file at T=1,2 for a 32x32 matrix
}}

''Figure 11'' above shows the results of running the ILfinalframe.py file for a 32x32 matrix at T=1 and T=2. As a result a suitable cut-off of 50000 steps was chosen as the energy and magnetisation has significantly converged, but not as much as it could at 100000 steps. I chose a slightly lower value to ensure that the run times of my monte-carlo simulations in future tasks were not extremely time consuming.

The montecarlostep() function was changed by adding a condition that values only above the pre-determined cut-off were included when determining the average value of energy; energy squared; magnetisation and magnetisations squared from the statistics function. The statistics() function did not need to be modified.

The following code is from the 32x32 matrixː

<pre>def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back

if self.n_cycles > 50000: #only adds values to array of E,E2,M and M2 above the specific cut-off
self.E+=[self.energy()]
self.E2+=[self.energy()**2]
self.M+=[self.magnetisation()]
self.M2+=[self.magnetisation()**2]
self.n_cycles=self.n_cycles+1

return (self.energy(),self.magnetisation())
</pre>

===TASK: Use ILtemperaturerange.py to plot the average energy and magnetisation for each temperature, with error bars, for an <math>8\times 8</math> lattice. Use your intuition and results from the script ILfinalframe.py to estimate how many cycles each simulation should be. The temperature range 0.25 to 5.0 is sufficient. Use as many temperature points as you feel necessary to illustrate the trend, but do not use a temperature spacing larger than 0.5. The NumPy function savetxt() stores your array of output data on disk — you will need it later. Save the file as 8x8.dat so that you know which lattice size it came from.===

Using the modified code, the file ILtemperaturerange.py was ran on an 8x8 matrix between T=0.5 and T=5 with a step of T=0.02 for 10000 Montecarlo steps and the first 1000 steps of each temperature were excluded when calculating the averages. ''Figure 12'' shows the result of the simulation and also included error bars of standard deviation.

[[File:Cg14178x8error.png|1000px|thumb|left|Figure 12 - Graph showing average energy and average magnetisation for an 8x8 lattice with error bars between T=0.5 and T=5]]

 

Below is the source code for the script to produce the graphː

<pre>data8x8=np.loadtxt('8x8.dat') #loads data
temps8x8=data8x8[:,0] #stores temperatures
energies8x8=data8x8[:,1] #stores average energy for each T
energysq8x8=data8x8[:,2] #stores average energy squared for each T
mag8x8=data8x8[:,3] #stores magnetisation for each T
magsq8x8=data8x8[:,4] #stores magnetisation squared for each T
stde8x8=data8x8[:,5] #edited ILtemperaturerange.py to record the standard deviation of the energy for each T
stdm8x8=data8x8[:,6] #edited ILtemperaturerange.py to record the standard deviation of the magnetisation for each T

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.errorbar(temps8x8, np.array(energies8x8)/64,yerr=np.divide(stde8x8,64),color='black',ecolor='teal',alpha=0.8) #plots energy per spin against T
magax.errorbar(temps8x8, np.array(mag8x8)/64,yerr=np.divide(stdm8x8,64),alpha=0.8,ecolor='salmon',color='black') #plots magnetisation per spin against T on separate graph
pl.savefig('8x8error.png',bbox_inches='tight') #saves figure
pl.show()

</pre>

==Section 6 - The effect of system size==

===TASK: Repeat the final task of the previous section for the following lattice sizes: 2x2, 4x4, 8x8, 16x16, 32x32. Make sure that you name each datafile that your produce after the corresponding lattice size! Write a Python script to make a plot showing the energy per spin versus temperature for each of your lattice sizes. Hint: the NumPy loadtxt function is the reverse of the savetxt function, and can be used to read your previously saved files into the script. Repeat this for the magnetisation. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. How big a lattice do you think is big enough to capture the long range fluctuations?===

The python script for this section is identical as for the 8x8 graph above in Figure 12 with the relevant files and variables changed accordingly.

Each matrix was simulated using the ILtemperaturerange.py file between T=0.5 and T=5 with a step of T=0.02.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2error.png
| caption1 = 2x2 matrix - 5000 steps, cut-off = 30 steps
| image2 = 4x4error.png
| caption2 = 4x4 matrix - 1000 steps, cut-off = 200 steps
| image3 =cg141716x16error.png
| caption3 = 16x16 matrix - 50000 steps, cut-off = 15000 steps
| image4 =cg141732x32error.png
| caption4 = 32x32 matrix - 200000 steps, cut-off = 50000 steps
| footer_align = left
| footer = Figure 13 - Results of running the ILtemperaturerange.py file for 2x2, 4x4, 16x16 and 32x32 matrices.
}}

 

Long-range interactions are present and more significant in the smaller lattices where there are fewer stronger, short range interactions. As a result, I expect long-range interactions to be important in square lattices up to a 4x4 size.

==Section 7 - Determining the Heat Capacity==

===TASK: By definition, <math>C = \frac{\partial \left\langle E\right\rangle}{\partial T}</math>. From this, show that <math>C = \frac{\mathrm{Var}[E]}{k_B T^2}</math> (Where <math>\mathrm{Var}[E]</math> is the variance in <math>E</math>.)===

Recall from statistical thermodynamics that the average energy of a system is the sum across all microstates of the probability of that microstate multiplied by the energy of that microstate, which is defined mathematically asː <math>\langle E \rangle = \sum_i p_{i}\epsilon_{i}</math>.

The partition function <math>q</math> is defined as <math>q = \sum_{i} exp(-\beta \epsilon_{i})</math> where <math>\beta =\frac{1}{k_BT}</math>and the probability, <math>p_{i}</math> can be defined in terms of the partition function as <math>p_{i} = \frac{exp(-\beta \epsilon_{i})}{\sum_{i} exp(-\beta \epsilon_{i})} = \frac{exp(-\beta \epsilon_{i})}{q}</math>.

As a result, <math>\langle E \rangle</math> can be re-written as <math>\langle E \rangle = \sum_{i} \frac{\epsilon_{i} exp(-\beta \epsilon_{i})}{q} = -\frac{1}{q} \frac{\partial}{\partial \beta}\sum_{i}exp(-\beta \epsilon_{i}) = -\frac{1}{q} \frac{\partial q}{\partial \beta}</math>

Likewise, <math>\langle E^2 \rangle = \sum_i p_{i}\epsilon_{i}^{2} = \sum_{i} \frac{\epsilon_{i}^{2}exp(-\beta \epsilon_{i})}{q} = \frac{1}{q} \frac{\partial^{2}}{\partial \beta^{2}}\sum_{i}exp(-\beta \epsilon_{i}) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}}</math>

From definitionː <math>Var[E] = \Delta E^2 = \langle E^2 \rangle - \langle E \rangle^2 </math>

When the definition of <math>\langle E \rangle</math> and <math>\langle E^2 \rangle</math> is written in terms of partition function <math>q</math>ː <math>Var[E] = \langle E^2 \rangle - \langle E \rangle^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \left(\frac{1}{q}\frac{\partial q}{\partial \beta}\right)^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2</math>.

According to the chain ruleː <math>\frac{\partial}{\partial \beta}\left(\frac{1}{q} \frac{\partial q}{\partial \beta}\right) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2 = -\frac{\partial}{\partial \beta}\langle E \rangle = Var[E]</math>

And using the chain rule againː <math>C = \frac{\partial \langle E \rangle}{\partial T}= \left(-\frac{\partial \langle E \rangle}{\partial \beta}\right) \left(-\frac{\partial \beta}{\partial T}\right) = \frac{Var[E]}{k_B T^2}</math>

===TASK: Write a Python script to make a plot showing the heat capacity versus temperature for each of your lattice sizes from the previous section. You may need to do some research to recall the connection between the variance of a variable, <math>\mathrm{Var}[X]</math>, the mean of its square <math>\left\langle X^2\right\rangle</math>, and its squared mean <math>\left\langle X\right\rangle^2</math>. You may find that the data around the peak is very noisy — this is normal, and is a result of being in the critical region. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. ===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb

{{multiple image
| width =300
| align = left
| image1 = cg14172x2heatcap.png
| caption1 = 2x2 Matrix
| image2 = cg14174x4heatcap.png
| caption2 = 4x4 Matrix
| image3 =cg14178x8heatcap.png
| caption3 = 8x8 Matrix
| image4 =cg141716x16heatcap.png
| caption4 = 16x16 Matrix
| image5=cg141732x32heatcap.png
| caption5= 32x32 Matrix
| footer = Figure 14 - Graphs showing Heat Capacity against Temperature for each matrix size
}}

Here is the source code to produce the figuresː
<pre> def heatCap(energies,energysq,T,latsize):
#defines the heat capacity for a given temperature
energiesq=np.multiply(energies,energies) #creates array of (average energies) squared
varE=np.subtract(energysq,energiesq) #defines variance of average energy
tempsq=np.multiply(T,T) #array of temperature squared
return np.array(np.divide(varE,tempsq))/(latsize**2)

heatCap2x2=heatCap(energies2x2,energysq2x2,temps2x2,2) #creates array of heat capacity for each T

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(temps2x2,heatCap2x2,color='orange') #plots heat capacity for each T
pl.savefig('cg14172x2heatcap.png',bbox_inches='tight') #saves figure
pl.show()
</pre>

A general trend from the above graphs is that the peak of the graph shifts towards lower temperatures as the size of the matrix used increases which means the Curie Temperature decreases as matrix size increases. Also, as lattice size increases the noise around the peak becomes larger which will affect the accuracy of determining the maximum heat capacity and Curie Temperature for the larger lattices.

==Section 8 - Locating the Curie Temperature==
===TASK: A C++ program has been used to run some much longer simulations than would be possible on the college computers in Python. You can view its source code here if you are interested. Each file contains six columns: <math>T, E, E^2, M, M^2, C</math> (the final five quantities are per spin), and you can read them with the NumPy loadtxt function as before. For each lattice size, plot the C++ data against your data. For one lattice size, save a PNG of this comparison and add it to your report — add a legend to the graph to label which is which. To do this, you will need to pass the label="..." keyword to the plot function, then call the legend() function of the axis object (documentation here).===

The python code used to read and plot the C++ data is found in the Jupyter notebook CG1417IsingModelGraphs.ipynb.

''Figure 15'' below shows the C++ plotted against my own data for a 16x16 Matrix.

[[File:Cg141716x16C++.png|400px|thumb|left|Figure 15 - Graph showing my own data against the C++ data for a 16x16 matrix.]]

 

The curves produced using the C++ data are much smoother and have less noise than the data gained from my python code. This is likely due to the C++ code having more montecarlosteps per temperature, reducing the effect of random fluctuations on the averages and also having a smaller step gap which will make the curve smoother as the points are closer together.

Here is the source code the produce the figuresː
<pre>#reads data from C++ file
temps2x2C=data2x2C[:,0]
energies2x2C=data2x2C[:,1]
energysq2x2C=data2x2C[:,2]
mag2x2C=data2x2C[:,3]
magsq2x2C=data2x2C[:,4]
heatcap2x2C=data2x2C[:,5]

#fitting C++ data

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.plot(temps2x2, np.array(energies2x2)/4,color='black',alpha=0.7,label='Python Data') #python energy against T
enerax.plot(temps2x2C, energies2x2C, color='red',label='C++ Data') #C energy against T
magax.plot(temps2x2, np.array(mag2x2)/4,color='black',alpha=0.7,label='Python Data') #python magnetisation against T
magax.plot(temps2x2C, mag2x2C,color='red',label='C++ Data') #C energy against T
enerax.legend() #shows legend on energy graph
magax.legend() #shows legend on energy graph
pl.show()
</pre>

The relevant variables and dat files were changed for each matrix.

===TASK: write a script to read the data from a particular file, and plot C vs T, as well as a fitted polynomial. Try changing the degree of the polynomial to improve the fit — in general, it might be difficult to get a good fit! Attach a PNG of an example fit to your report.===

The python script to read and plot the fitted polynomial is found in CG1417PolyfitScript.ipynb

Here is the source code for ''Figure 15''

<pre>data_test = np.loadtxt("16x16C.dat")
T_test = data_test[:,0] #gets temperatures
C_test = data_test[:,5] #gets heat capacity data

#first we fit the polynomial to the data
fit_test = np.polyfit(T_test, C_test, 35) # fit a polynomial of degree 35ǃ

#now we generate interpolated values of the fitted polynomial over the range of our function
T_min_test = 0.5 #np.min(T_test)
T_max_test = 5 #np.max(T_test)

T_range_test = np.linspace(T_min_test, T_max_test, 1000) #generate 1000 evenly spaced points between T_min and T_max
fitted_C_values_test = np.polyval(fit_test, T_range_test)# use the fit object to generate the corresponding values of C

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(T_test,C_test,color='orange',label='C++ Data') #plots C data of heat capacity against temp
heatcapax.plot(T_range_test,fitted_C_values_test,label='Fitted Polynomial') #plots fitted polynomial for whole range of temp
heatcapax.legend()
pl.savefig('FIT_TEST16x16_35.png', bbox_inches='tight') #saves figure
pl.show()
</pre>

Below in ''Figure 16'' is a plot of my Heat Capacity against Temperature data for a 16x16 matrix and features a polynomial of degree 35 plotted against it. Even with a polynomial of such a high degree, it poorly fits the curve and does not fit to the peak of the curve either.

[[File:cg1417FIT_TEST16x16_35.png|thumb|left|400px|Figure 16 - Plot of Heat Capacity against Temperature along with a poorly fitted polynomial of degree 35. ]]

 

===TASK: Modify your script from the previous section. You should still plot the whole temperature range, but fit the polynomial only to the peak of the heat capacity! You should find it easier to get a good fit when restricted to this region===

The script was modified as such that the polynomial was fitted in a set range around the peak of the graph, this is demonstrated in ''Figure 17'' which shows a newly fitted polynomial between a much smaller range of temperatures (T = 2.15-2.55) and a much smaller degree polynomial (3).

[[File:CG1417FIT_16x16C_3.png|thumb|left|400px|Figure 17 - Graph showing Heat Capacity against Temperature for a 16x16 matrix along with a fitted polynomial between a much more restricted range of temperatures and a significantly lower degree of polynomial]]

Upon comparison with ''Figure 16'', the new fitted polynomial is a significantly better fit even for a 3rd degree polynomial and is a much more accurate representation of my data around the peak of the graph and will make it easier to determine the maximum value of Heat Capacity. However, the polyfit curve still doesn't perfectly fit the peak due to the significant amount of noise present there.

 

Here is the source code for ''Figure 17''ː
<pre>data16 = np.loadtxt("16x16C.dat") #loads data to variable

T16 = data16[:,0] #gets temps
C16 = data16[:,5] # gets heat capacities

Tmin16 = 2.15 #chosen min temp
Tmax16 = 2.55 #chosen max temp

selection16 = np.logical_and(T16 > Tmin16, T16 < Tmax16) #choose only those rows where both conditions are true
peak_T_values16 = T16[selection16] #choose temp values in range chosen above
peak_C_values16 = C16[selection16] #choose heat cap values in range of t above

fit16 = np.polyfit(peak_T_values16,peak_C_values16,3) #fit 3rd order polynomial
peak_T_range16 = np.linspace(Tmin16, Tmax16, 1000) #defines 1000 temps within data range
fitted_C_values16 = np.polyval(fit16, peak_T_range16) #use the fit object to get corresponding values of heat cap

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(T16,C16,color='orange',label='C++ Data') #plots C data of heat cap against temp
heatcapax.plot(peak_T_range16,fitted_C_values16,label='Fitted Polynomial') #plots fitted polynomial for small range
heatcapax.legend()
pl.savefig('FIT_16x16C_3.png', bbox_inches='tight') #saves figure
pl.show()

</pre>

===TASK: find the temperature at which the maximum in C occurs for each datafile that you were given. Make a text file containing two colums: the lattice side length (2,4,8, etc.), and the temperature at which C is a maximum. This is your estimate of <math>T_C</math> for that side length. Make a plot that uses the scaling relation given above to determine <math>T_{C,\infty}</math>. By doing a little research online, you should be able to find the theoretical exact Curie temperature for the infinite 2D Ising lattice. How does your value compare to this? Are you surprised by how good/bad the agreement is? Attach a PNG of this final graph to your report, and discuss briefly what you think the major sources of error are in your estimate.===

''Figure 18'' below shows a graph of <math>T_{C,L}</math> against <math>\frac{1}{Lattice Size}</math> to determine the Curie Temperature of an infinite 2D Ising Model Lattice <math>T_{C,\infty}</math>. The black dots represent the raw data obtained from obtaining the temperature at which the Heat Capacity was a maximum for the lattices and the red line in a linear curve fit plotted against the data to allow the y-intercept which is the Curie Temperature for the infinite 2D lattice to be determined.

[[File:cg1417CurieTemp.png|400px|thumb|left|Figure 18 - Plot of 1/Lattice Size against Curie Temperature for that lattice size.]]

The value for <math>T_{C,\inf}</math> obtained from the data is <math>T_{C,\infty} = 2.277 \frac{J}{k_B}</math> with a literature value being <math>T_{C,\infty} = 2.269 \frac{J}{k_B}</math> <ref>L. Onsager, Phys. Rev., 1944, 65, 117--149.</ref>for an infinite square 2D lattice. This means that my result slightly over-estimates the Curie Temperature for the infinite lattice and as a result for an infinite lattice the temperature at which spontaneous magnetisation stops would actually occur at a slightly lower temperature than expected. However, the difference between my value and the literature value is only 0.008 which is incredibly small and the amount of agreement between the two values is somewhat surprising, which means that the error in my estimates of the Curie Temperature for each lattice size is relatively small. The points which have the largest residuals and deviation from the line of best fit in ''Figure 17'' corresponds to the smaller lattice sizes of 2x2 and 4x4 where longer range interactions are more significant. The longer range interactions posed by the boundary conditions are significant for the smaller sizes and causes the energy of the smaller matrices to be less accurate and have a larger associated error with the energy and the Curie Temperature for that lattice size. This affects the accuracy of the line of best fit and to increase the accuracy of this line, larger lattice sizes of 128x128, 256x256 etc should be included in the calculation for the line of best fit and the smaller matrices ignored - this should allow a more accurate value of <math>T_{C,\infty}</math> to be determined.

 

Below is the source code used to generate ''Figure 18'' from CG1417PolyfitScript.py
<pre>
Cmax64x64 = np.max(fitted_C_values64) #finds Cmax for 64x64 matrix - done for others already
Tmax64x64 = peak_T_range64[fitted_C_values64 == Cmax64x64] #finds Tmax corresponding to Cmax

LatSize=[2,4,8,16,32,64] #stores lattice sizes
Tmax=[Tmax2x2,Tmax4x4,Tmax8x8,Tmax16x16,Tmax32x32,Tmax64x64] #stores corresponding Tmax data
np.savetxt('CmaxVSTmax.txt', (LatSize,Tmax)) #writes data to txt file

ScalData=np.loadtxt('CmaxVSTmax.txt') #loads data
LatticeSize=ScalData[0] #gets lattice sizes
TempMax=ScalData[1] #gets max temp or curie temp for each lattice

Lmin1min = np.min(np.divide(1,LatticeSize)) #minimum of 1/LatticeSize values
Lmin1max = np.max(np.divide(1,LatticeSize)) #maximum of 1/LatticeSize values

fitTcl = np.polyfit(np.divide(1,LatticeSize),TempMax, 1) #creates fit object

Lmin1values = np.linspace(Lmin1min, Lmin1max, 1000) #finds 1000 values between min and max x-axis value of 1/LatticeSize
fitted_Tcl_values = np.polyval(fitTcl, Lmin1values) #creates corresponding Curie Temp values for each value in Lmin1values

fig = pl.figure()
scalrelax = fig.add_subplot(1,1,1)
scalrelax.set_xlabel('1/Lattice Size')
scalrelax.set_ylabel('Curie Temperature/ J/k_B')
scalrelax.plot(np.divide(1,LatticeSize),TempMax,color='black',marker='.',linestyle='') #plots Curie Temp against 1/LatticeSize
scalrelax.plot(Lmin1values,fitted_Tcl_values,color='red',marker='',linestyle='-') #plots line of best fit for data above
pl.savefig('CurieTemp.png', bbox_inches='tight') #saves figure
pl.show()

</pre>

== References ==

Rep:Y3CMPCG1417

2019-11-20T10:41:53Z

==Section 1 - Introduction to the Ising Model==

===TASK: Show that the lowest possible energy for the Ising model is <math>E = -DNJ</math>, where D is the number of dimensions and N is the total number of spins. What is the multiplicity of this state? Calculate its entropy.===

Consider a 1D row of lattice sites of N=3 with spin configuration [+1][+1][+1].

Mathematically the interaction energy is defined asː
<math> -\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} </math> where J is a constant and <math>s_{i}s_{j}</math> is the product between two spins in adjacent lattice sites.

The sum of the interaction energies <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j}</math> can be considered as the sum of the individual interaction energies between spinsː
<math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = \epsilon_{12} + \epsilon_{23} + \epsilon_{13} + \epsilon_{21} + \epsilon_{32} + \epsilon_{31} </math>.

Although lattice sites 1 and 3 are not adjacent they are said to still interact according to the periodic boundary conditions applied.

However, <math>\epsilon_{12} = \epsilon_{21} </math> and <math>\epsilon_{23} = \epsilon_{32}</math> and <math>\epsilon_{13} = \epsilon_{31}</math> which means that all of the interactions within the system are counted twice, hence the total energy needs to be halved, resulting in the following formula being obtainedː <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = 2\epsilon_{12} + 2\epsilon_{13} + 2\epsilon_{23} </math>.

It can be determined that <math>\epsilon_{12} = (+1)(+1) = 1</math> , <math>\epsilon_{13} = (+1)(+1) = 1</math> and <math>\epsilon_{23} = (+1)(+1) = 1</math>.

Thereforeː <math>-\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = -\frac{1}{2} \ J \ (2 + 2 + 2) = -\frac{1}{2} \ J \ 6 = - 3 J = -DNJ</math> for a 1D lattice with <math>D=1</math> and 3 lattice sites <math>N=3</math>

The multiplicity of the system,<math>\Omega = \frac{lattice sites!}{n. spin up!n. spin down!}</math>

Entropy, <math>S</math> is defined as <math>S = k_B ln(\Omega)</math> and so in this case <math>S = k_B ln(\frac{100!}{100!}) = 0</math>

===TASK: Imagine that the system is in the lowest energy configuration. To move to a different state, one of the spins must spontaneously change direction ("flip"). What is the change in energy if this happens <math>(D=3, N=1000)</math>? How much entropy does the system gain by doing soʔ===

In a 3D lattice system, each lattice site has three unique interactions with its neighbours to its left, top and front. In the lowest energy configuration, all spins are parallel and for a system the minimum energy is <math>E = -DNJ</math>, so for the system with <math>N=1000</math> and <math>D=3</math>, the minimum energy is <math>-3000J</math>.

If a single spin is flipped, the product of its spin with its neighbours spin reverses and becomes negative and this increases the total energy of the system. Since 3 unique spin-spin interactions are reversed in sign, the total energy increases by <math>+3J</math>, meaning the new total energy is <math>-2997J</math>

Initially the multiplicity of the system will be <math>\Omega = \frac{1000!}{1000!}</math> , and after the flip, the multiplicity becomes <math> \Omega = \frac{1000!}{999!1!}=1000</math>.

The associated change in entropy, <math>\Delta S = k_B ln(1000) - 0 = 6.91 k_B</math>, which is an expected increase in entropy as the number of possible configurations of the system increases.

===TASK: Calculate the magnetisation of the 1D and 2D lattices in Figure 1. What magnetisation would you expect to observe for an Ising lattice with <math>D = 3,\ N=1000</math> at absolute zero?===

[[File:ThirdYearCMPExpt-IsingSketch.png|thumb|left|Figure 1 - Shows 1D (N = 5), 2D (N = 5x5) and 3D (N = 5x5x5) lattices.]]

Magnetisation is defined as <math>M=\sum_{i} s_i</math>. So for the 1D lattice with <math>N = 5</math> in ''Figure 2'', <math>M = +1</math> and for the 2D lattice with <math>N = 25 , M = +1</math> too.

According to the 3rd Law of thermodynamics, entropy is 0 at absolute zero for a perfect crystalline solid, and consequently it is expected that the lattices will have follow suit and have zero entropy at 0K. To have zero entropy all spins must be parallel as such that magnetisation, <math>M = N</math>. For all the spins to be parallel, there is only one possible configuration. So, for a lattice with <math>N = 1000</math> and <math>D =3</math>, if <math>M = N</math>, then multiplicity, <math>\Omega = 1</math> and entropy, <math>S =k_B ln(1) = 0</math>.

 

==Section 2 - Calculating the Energy and Magnetisation==

===TASK: complete the functions energy() and magnetisation(), which should return the energy of the lattice and the total magnetisation, respectively. In the energy() function you may assume that <math>J=1.0</math> at all times (in fact, we are working in reduced units in which <math>J=k_B</math>, but there will be more information about this in later sections). Do not worry about the efficiency of the code at the moment — we will address the speed in a later part of the experiment.===

<pre>def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
lat=self.lattice #creates lattice and stores it
mag=[]
for i in range(0,len(lat)): #loops through all rows of lattice
for j in range(0,len(lat[i])): #loops through elements of each row
mag+=[lat[i][j]] #adds spin value to mag array
return sum(mag) #sums all spins from mag array
</pre>

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

lat=self.lattice #creates lattice and stores it
left=[]
top=[]

for i in range(0,len(lat)):
for j in range(0,len(lat[i])):
left+=[lat[i][j]*lat[i][j-1]] #multiplies spin by spin to left
top+=[lat[i][j]*lat[i-1][j]] #multiplies spin by spin above it
int_en=left+top #sums spin products from left and top
energy=-sum(int_en) #sums all spin products for each spin to give total

return energy
</pre>

===TASK: Run the ILcheck.py script from the IPython Qt console using the command===

''Figure 2'' shows the results when ILcheck.py was ran on my IsingLattice.py file. The ILcheck.py file was ran several times to ensure the code worked for various random lattices.

[[File:Cg1417ILcheck run.png|thumb|left|500px| Figure 2 - Result from running the ILcheck.py file]]

 

==Section 3 - Introduction to Monte Carlo Simulation==

===TASK: How many configurations are available to a system with 100 spins? To evaluate these expressions, we have to calculate the energy and magnetisation for each of these configurations, then perform the sum. Let's be very, very, generous, and say that we can analyse <math>1\times 10^9</math> configurations per second with our computer. How long will it take to evaluate a single value of <math>\left\langle M\right\rangle_T</math>?===

For a system with 100 lattice sites and two possible spins for each site, there are <math>2^{100}</math>possible configurations for the system. <math>2^{100}= 1.27\times 10^{30} </math>, so if the computer can analyse <math>1\times 10^9</math> configurations per second, then it will take <math>\frac{1.27\times 10^{30}}{10^9} = 1.27\times 10^{21} s</math> to analyse the whole system, which is longer than the age of the universe and therefore is not a practical approach.

===TASK: Implement a single cycle of the above algorithm in the montecarlocycle(T) function. This function should return the energy of your lattice and the magnetisation at the end of the cycle. You may assume that the energy returned by your energy() function is in units of <math>k_B</math>! Complete the statistics() function. This should return the following quantities whenever it is called: <math><E>, <E^2>, <M>, <M^2></math>, and the number of Monte Carlo steps that have elapsed.===
<pre>
E = []
E2 = []
M = []
M2 = []
n_cycles = 0

def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back if rejected else not changed

self.E+=[self.energy()] #records energy
self.E2+=[self.energy()**2] #records energy squared
self.M+=[self.magnetisation()] #records magnetisation
self.M2+=[self.magnetisation()**2] #records magnetisation squared
self.n_cycles=self.n_cycles+1 #adds 1 to run total

return (self.energy(),self.magnetisation())

def statistics(self):
# complete this function so that it calculates the correct values for the averages of E, E*E (E2), M, M*M (M2), and returns them

e=np.mean(self.E)
e2=np.mean(self.E2)
m=np.mean(self.M)
m2=np.mean(self.M2)

return e,e2,m,m2,self.n_cycles
</pre>

''Figure 3'' shows the results of a single run of the montecarlostep() function and the lattice the function operated upon.

[[File:cg1417MonteCarloStep_run.png|thumb|left|Figure 3 - Results from a single montecarlostep() function and the resulting lattice produced along with the correct return from the statistics() function]]

 

===TASK: If <math>T < T_C</math>, do you expect a spontaneous magnetisation (i.e. do you expect <math>\left\langle M\right\rangle \neq 0</math>)? When the state of the simulation appears to stop changing (when you have reached an equilibrium state), use the controls to export the output to PNG and attach this to your report. You should also include the output from your statistics() function.===

If the temperature of the system is less than the Curie Temperature, <math>T_C</math> then spontaneous magnetisation can occur and the system will tend to its lowest energy state where all of the spins are parallel - this is a property of ferromagnetic materials.

[[File:Cg1417ILanim_run.png|400px|thumb|left|Figure 4 - Results from running the ILanim.py file - shows the energy and magnetisation converging over time]]

''Figure 4'' shows that over time the the system spontaneously converges to the minimum energy state with all of the spins parallel to one another and shows, as I expected, that spontaneous magnetisation occurs and also shows that the temperature of this simulation is below the Curie Temperature, <math>T < T_C</math>.

 

==Section 4 - Accelerating the Code==

===TASK: Use the script ILtimetrial.py to record how long your current version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 5'' show the results of running the ILtimetrial.py file on my code three timesː

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1.png
| width1=500
| image2=cg1417ILtimetrial_run2.png
| width2=500
| image3=cg1417ILtimetrial_run3.png
| width3=500
| footer = Figure 5 - Results of running the ILtimetrial.py file on my code three separate times
}}
 

This gave me an avergage time of <math>24.3 s \pm 0.2s</math>

===TASK: Look at the documentation for the NumPy sum function. You should be able to modify your magnetisation() function so that it uses this to evaluate M. The energy is a little trickier. Familiarise yourself with the NumPy roll and multiply functions, and use these to replace your energy double loop (you will need to call roll and multiply twice!).===

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

left=multiply(roll(self.lattice,1,axis=1),self.lattice) #product of spin with spin left of it
top=multiply(roll(self.lattice,-1,axis=0),self.lattice) #product of spin with spin above it

int_en=sum(left+top) #sum of array containing sum of left and top spin products for each spin

energy = -sum(int_en) #calculates the total energy of system
return energy

def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
return sum(sum(self.lattice)) #adds up all spins in lattice
</pre>
The use of the bumpy modules reduces the amount of code required and removes the need for loops making the code significantly shorter, and is therefore expected to run ILtimetrial.py faster than the initial code developed.

===TASK: Use the script ILtimetrial.py to record how long your new version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 6'' shows the result of running the ILtimetrial.py on my new accelerated code.

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1fast.png
| width1=500
| image2=ILtimetrial_run2fast.png
| width2=500
| image3=ILtimetrial_run3fast.png
| width3=500
| footer = Figure 6 - Results of running the ILtimetrial.py file on my new updated and accelerated code.
}}
 

The accelerated code is much faster upon using the roll, multiply and sum modules with a new average time of <math>0.790 s \pm 0.005 </math>

==Section 5 - The effect of temperature==

===TASK: The script ILfinalframe.py runs for a given number of cycles at a given temperature, then plots a depiction of the final lattice state as well as graphs of the energy and magnetisation as a function of cycle number. This is much quicker than animating every frame! Experiment with different temperature and lattice sizes. How many cycles are typically needed for the system to go from its random starting position to the equilibrium state? Modify your statistics() and montecarlostep() functions so that the first N cycles of the simulation are ignored when calculating the averages. You should state in your report what period you chose to ignore, and include graphs from ILfinalframe.py to illustrate your motivation in choosing this figure.===

''Figure 7'' below shows the results from running the ILfinalframe.py for 2x2 lattice at T=1,2,3,5.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2T1.png
| image2 = cg14172x2T2.png
| image3 =cg14172x2T3.png
| image4 =cg14172x2T5.png
| footer_align = left
| footer = Figure 7 - Results of running the ILfinalframe.py file at T=1,2,3,5 for a 2x2 matrix.
}}

 

For a 2x2 matrix, a suitable cut-off point to exclude from the avergage energies and magnetisations is where the energy and magnetisations per spin are constant, which is 30 steps. For T=3 and T=5 the graphs do not converge because it is possible that these temperatures are higher than the Curie Temperature and as such spontaneous magnetisation will not occur and the system will not diverge to the lowest energy state. At the higher temperatures, there are larger thermal fluctations and the Boltzmann factor is more significant allowing the system to move away from the lowest energy state easier. As a result moving forwards, a suitable cut-off point will only be determined from T=1 and T=2 graphs for the larger matrices.

''Figure 8'' shows the results from running a 4x4 lattice at T=1,2 and 3.

{{multiple image
| width =350
| align = left
| image1 = cg14174x4T1.png
| image2 = cg14174x4T2.png
| image3 =cg14174x4T3.png
| footer_align = left
| footer = Figure 8 - Results of running the ILfinalframe.py file at T=1,2,3 for a 4x4 matrix.
}}

From ''Figure 8'', a suitable cut-off point for the energy and magnetisations is 200 as this is after where the energy and magnetisation has converged for T=1, and is after the initial large drop in energy for T=2, even though there are a few small fluctuations after 200 steps. The result from T=3 has been included to show the large fluctuations for the larger temperatures, and supporting my choice to determine the cut-off from T=1 and T=2 only.

''Figure 9'' shows the results for an 8x8 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg14178x8T1.png
| image2 = cg14178x8T2.png
| footer_align = left
| footer = Figure 9 - Results of running the ILfinalframe.py file at T=1,2 for an 8x8 matrix
}}

From ''Figure 9'' above, a suitable cut-off point is 1000 steps as this is where the energy and magnetisation has easily converged by and is also the point after which the initial large drop in energy has been overcome for T=2 too.

''Figure 10'' shows the result of running the ILfinalframe.py for a 16x16 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg141716x16T1.png
| image2 = cg141716x16T2.png
| footer_align = left
| footer = Figure 10 - Results of running the ILfinalframe.py file at T=1,2 for a 16x16 matrix
}}

From ''Figure 10'', a suitable cut-off point is 15000 steps as for T=1 the energy and magnetisations have converged significantly and will not change much, and likewise this is the same for the T=2 frame.

''Figure 11'' below shows the results from a 32x32 matrix at T=1 and T=2.

{{multiple image
| width =350
| align = left
| image1 = cg141732x32T1.png
| image2 = cg141732x32T2.png
| footer_align = left
| footer = Figure 11 - Results of running the ILfinalframe.py file at T=1,2 for a 32x32 matrix
}}

''Figure 11'' above shows the results of running the ILfinalframe.py file for a 32x32 matrix at T=1 and T=2. As a result a suitable cut-off of 50000 steps was chosen as the energy and magnetisation has significantly converged, but not as much as it could at 100000 steps. I chose a slightly lower value to ensure that the run times of my monte-carlo simulations in future tasks were not extremely time consuming.

The montecarlostep() function was changed by adding a condition that values only above the pre-determined cut-off were included when determining the average value of energy; energy squared; magnetisation and magnetisations squared from the statistics function. The statistics() function did not need to be modified.

The following code is from the 32x32 matrixː

<pre>def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back

if self.n_cycles > 50000: #only adds values to array of E,E2,M and M2 above the specific cut-off
self.E+=[self.energy()]
self.E2+=[self.energy()**2]
self.M+=[self.magnetisation()]
self.M2+=[self.magnetisation()**2]
self.n_cycles=self.n_cycles+1

return (self.energy(),self.magnetisation())
</pre>

===TASK: Use ILtemperaturerange.py to plot the average energy and magnetisation for each temperature, with error bars, for an <math>8\times 8</math> lattice. Use your intuition and results from the script ILfinalframe.py to estimate how many cycles each simulation should be. The temperature range 0.25 to 5.0 is sufficient. Use as many temperature points as you feel necessary to illustrate the trend, but do not use a temperature spacing larger than 0.5. The NumPy function savetxt() stores your array of output data on disk — you will need it later. Save the file as 8x8.dat so that you know which lattice size it came from.===

Using the modified code, the file ILtemperaturerange.py was ran on an 8x8 matrix between T=0.5 and T=5 with a step of T=0.02 for 10000 Montecarlo steps and the first 1000 steps of each temperature were excluded when calculating the averages. ''Figure 12'' shows the result of the simulation and also included error bars of standard deviation.

[[File:Cg14178x8error.png|1000px|thumb|left|Figure 12 - Graph showing average energy and average magnetisation for an 8x8 lattice with error bars between T=0.5 and T=5]]

 

Below is the source code for the script to produce the graphː

<pre>data8x8=np.loadtxt('8x8.dat') #loads data
temps8x8=data8x8[:,0] #stores temperatures
energies8x8=data8x8[:,1] #stores average energy for each T
energysq8x8=data8x8[:,2] #stores average energy squared for each T
mag8x8=data8x8[:,3] #stores magnetisation for each T
magsq8x8=data8x8[:,4] #stores magnetisation squared for each T
stde8x8=data8x8[:,5] #edited ILtemperaturerange.py to record the standard deviation of the energy for each T
stdm8x8=data8x8[:,6] #edited ILtemperaturerange.py to record the standard deviation of the magnetisation for each T

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.errorbar(temps8x8, np.array(energies8x8)/64,yerr=np.divide(stde8x8,64),color='black',ecolor='teal',alpha=0.8) #plots energy per spin against T
magax.errorbar(temps8x8, np.array(mag8x8)/64,yerr=np.divide(stdm8x8,64),alpha=0.8,ecolor='salmon',color='black') #plots magnetisation per spin against T on separate graph
pl.savefig('8x8error.png',bbox_inches='tight') #saves figure
pl.show()

</pre>

==Section 6 - The effect of system size==

===TASK: Repeat the final task of the previous section for the following lattice sizes: 2x2, 4x4, 8x8, 16x16, 32x32. Make sure that you name each datafile that your produce after the corresponding lattice size! Write a Python script to make a plot showing the energy per spin versus temperature for each of your lattice sizes. Hint: the NumPy loadtxt function is the reverse of the savetxt function, and can be used to read your previously saved files into the script. Repeat this for the magnetisation. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. How big a lattice do you think is big enough to capture the long range fluctuations?===

The python script for this section is identical as for the 8x8 graph above in Figure 12 with the relevant files and variables changed accordingly.

Each matrix was simulated using the ILtemperaturerange.py file between T=0.5 and T=5 with a step of T=0.02.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2error.png
| caption1 = 2x2 matrix - 5000 steps, cut-off = 30 steps
| image2 = 4x4error.png
| caption2 = 4x4 matrix - 1000 steps, cut-off = 200 steps
| image3 =cg141716x16error.png
| caption3 = 16x16 matrix - 50000 steps, cut-off = 15000 steps
| image4 =cg141732x32error.png
| caption4 = 32x32 matrix - 200000 steps, cut-off = 50000 steps
| footer_align = left
| footer = Figure 13 - Results of running the ILtemperaturerange.py file for 2x2, 4x4, 16x16 and 32x32 matrices.
}}

 

Long-range interactions are present and more significant in the smaller lattices where there are fewer stronger, short range interactions. As a result, I expect long-range interactions to be important in square lattices up to a 4x4 size.

==Section 7 - Determining the Heat Capacity==

===TASK: By definition, <math>C = \frac{\partial \left\langle E\right\rangle}{\partial T}</math>. From this, show that <math>C = \frac{\mathrm{Var}[E]}{k_B T^2}</math> (Where <math>\mathrm{Var}[E]</math> is the variance in <math>E</math>.)===

Recall from statistical thermodynamics that the average energy of a system is the sum across all microstates of the probability of that microstate multiplied by the energy of that microstate, which is defined mathematically asː <math>\langle E \rangle = \sum_i p_{i}\epsilon_{i}</math>.

The partition function <math>q</math> is defined as <math>q = \sum_{i} exp(-\beta \epsilon_{i})</math> where <math>\beta =\frac{1}{k_BT}</math>and the probability, <math>p_{i}</math> can be defined in terms of the partition function as <math>p_{i} = \frac{exp(-\beta \epsilon_{i})}{\sum_{i} exp(-\beta \epsilon_{i})} = \frac{exp(-\beta \epsilon_{i})}{q}</math>.

As a result, <math>\langle E \rangle</math> can be re-written as <math>\langle E \rangle = \sum_{i} \frac{\epsilon_{i} exp(-\beta \epsilon_{i})}{q} = -\frac{1}{q} \frac{\partial}{\partial \beta}\sum_{i}exp(-\beta \epsilon_{i}) = -\frac{1}{q} \frac{\partial q}{\partial \beta}</math>

Likewise, <math>\langle E^2 \rangle = \sum_i p_{i}\epsilon_{i}^{2} = \sum_{i} \frac{\epsilon_{i}^{2}exp(-\beta \epsilon_{i})}{q} = \frac{1}{q} \frac{\partial^{2}}{\partial \beta^{2}}\sum_{i}exp(-\beta \epsilon_{i}) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}}</math>

From definitionː <math>Var[E] = \Delta E^2 = \langle E^2 \rangle - \langle E \rangle^2 </math>

When the definition of <math>\langle E \rangle</math> and <math>\langle E^2 \rangle</math> is written in terms of partition function <math>q</math>ː <math>Var[E] = \langle E^2 \rangle - \langle E \rangle^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \left(\frac{1}{q}\frac{\partial q}{\partial \beta}\right)^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2</math>.

According to the chain ruleː <math>\frac{\partial}{\partial \beta}\left(\frac{1}{q} \frac{\partial q}{\partial \beta}\right) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2 = -\frac{\partial}{\partial \beta}\langle E \rangle = Var[E]</math>

And using the chain rule againː <math>C = \frac{\partial \langle E \rangle}{\partial T}= \left(-\frac{\partial \langle E \rangle}{\partial \beta}\right) \left(-\frac{\partial \beta}{\partial T}\right) = \frac{Var[E]}{k_B T^2}</math>

===TASK: Write a Python script to make a plot showing the heat capacity versus temperature for each of your lattice sizes from the previous section. You may need to do some research to recall the connection between the variance of a variable, <math>\mathrm{Var}[X]</math>, the mean of its square <math>\left\langle X^2\right\rangle</math>, and its squared mean <math>\left\langle X\right\rangle^2</math>. You may find that the data around the peak is very noisy — this is normal, and is a result of being in the critical region. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. ===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb

{{multiple image
| width =300
| align = left
| image1 = cg14172x2heatcap.png
| caption1 = 2x2 Matrix
| image2 = cg14174x4heatcap.png
| caption2 = 4x4 Matrix
| image3 =cg14178x8heatcap.png
| caption3 = 8x8 Matrix
| image4 =cg141716x16heatcap.png
| caption4 = 16x16 Matrix
| image5=cg141732x32heatcap.png
| caption5= 32x32 Matrix
| footer = Figure 14 - Graphs showing Heat Capacity against Temperature for each matrix size
}}

Here is the source code to produce the figuresː
<pre> def heatCap(energies,energysq,T,latsize):
#defines the heat capacity for a given temperature
energiesq=np.multiply(energies,energies) #creates array of (average energies) squared
varE=np.subtract(energysq,energiesq) #defines variance of average energy
tempsq=np.multiply(T,T) #array of temperature squared
return np.array(np.divide(varE,tempsq))/(latsize**2)

heatCap2x2=heatCap(energies2x2,energysq2x2,temps2x2,2) #creates array of heat capacity for each T

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(temps2x2,heatCap2x2,color='orange') #plots heat capacity for each T
pl.savefig('cg14172x2heatcap.png',bbox_inches='tight') #saves figure
pl.show()
</pre>

A general trend from the above graphs is that the peak of the graph shifts towards lower temperatures as the size of the matrix used increases which means the Curie Temperature decreases as matrix size increases. Also, as lattice size increases the noise around the peak becomes larger which will affect the accuracy of determining the maximum heat capacity and Curie Temperature for the larger lattices.

==Section 8 - Locating the Curie Temperature==
===TASK: A C++ program has been used to run some much longer simulations than would be possible on the college computers in Python. You can view its source code here if you are interested. Each file contains six columns: <math>T, E, E^2, M, M^2, C</math> (the final five quantities are per spin), and you can read them with the NumPy loadtxt function as before. For each lattice size, plot the C++ data against your data. For one lattice size, save a PNG of this comparison and add it to your report — add a legend to the graph to label which is which. To do this, you will need to pass the label="..." keyword to the plot function, then call the legend() function of the axis object (documentation here).===

The python code used to read and plot the C++ data is found in the Jupyter notebook CG1417IsingModelGraphs.ipynb.

''Figure 15'' below shows the C++ plotted against my own data for a 16x16 Matrix.

[[File:Cg141716x16C++.png|400px|thumb|left|Figure 15 - Graph showing my own data against the C++ data for a 16x16 matrix.]]

 

The curves produced using the C++ data are much smoother and have less noise than the data gained from my python code. This is likely due to the C++ code having more montecarlosteps per temperature, reducing the effect of random fluctuations on the averages and also having a smaller step gap which will make the curve smoother as the points are closer together.

Here is the source code the produce the figuresː
<pre>#reads data from C++ file
temps2x2C=data2x2C[:,0]
energies2x2C=data2x2C[:,1]
energysq2x2C=data2x2C[:,2]
mag2x2C=data2x2C[:,3]
magsq2x2C=data2x2C[:,4]
heatcap2x2C=data2x2C[:,5]

#fitting C++ data

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.plot(temps2x2, np.array(energies2x2)/4,color='black',alpha=0.7,label='Python Data') #python energy against T
enerax.plot(temps2x2C, energies2x2C, color='red',label='C++ Data') #C energy against T
magax.plot(temps2x2, np.array(mag2x2)/4,color='black',alpha=0.7,label='Python Data') #python magnetisation against T
magax.plot(temps2x2C, mag2x2C,color='red',label='C++ Data') #C energy against T
enerax.legend() #shows legend on energy graph
magax.legend() #shows legend on energy graph
pl.show()
</pre>

The relevant variables and dat files were changed for each matrix.

===TASK: write a script to read the data from a particular file, and plot C vs T, as well as a fitted polynomial. Try changing the degree of the polynomial to improve the fit — in general, it might be difficult to get a good fit! Attach a PNG of an example fit to your report.===

The python script to read and plot the fitted polynomial is found in CG1417PolyfitScript.ipynb

Here is the source code for ''Figure 15''

<pre>data_test = np.loadtxt("16x16C.dat")
T_test = data_test[:,0] #gets temperatures
C_test = data_test[:,5] #gets heat capacity data

#first we fit the polynomial to the data
fit_test = np.polyfit(T_test, C_test, 35) # fit a polynomial of degree 35ǃ

#now we generate interpolated values of the fitted polynomial over the range of our function
T_min_test = 0.5 #np.min(T_test)
T_max_test = 5 #np.max(T_test)

T_range_test = np.linspace(T_min_test, T_max_test, 1000) #generate 1000 evenly spaced points between T_min and T_max
fitted_C_values_test = np.polyval(fit_test, T_range_test)# use the fit object to generate the corresponding values of C

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(T_test,C_test,color='orange',label='C++ Data') #plots C data of heat capacity against temp
heatcapax.plot(T_range_test,fitted_C_values_test,label='Fitted Polynomial') #plots fitted polynomial for whole range of temp
heatcapax.legend()
pl.savefig('FIT_TEST16x16_35.png', bbox_inches='tight') #saves figure
pl.show()
</pre>

Below in ''Figure 16'' is a plot of my Heat Capacity against Temperature data for a 16x16 matrix and features a polynomial of degree 35 plotted against it. Even with a polynomial of such a high degree, it poorly fits the curve and does not fit to the peak of the curve either.

[[File:cg1417FIT_TEST16x16_35.png|thumb|left|400px|Figure 16 - Plot of Heat Capacity against Temperature along with a poorly fitted polynomial of degree 35. ]]

 

===TASK: Modify your script from the previous section. You should still plot the whole temperature range, but fit the polynomial only to the peak of the heat capacity! You should find it easier to get a good fit when restricted to this region===

The script was modified as such that the polynomial was fitted in a set range around the peak of the graph, this is demonstrated in ''Figure 17'' which shows a newly fitted polynomial between a much smaller range of temperatures (T = 2.15-2.55) and a much smaller degree polynomial (3).

[[File:CG1417FIT_16x16C_3.png|thumb|left|400px|Figure 17 - Graph showing Heat Capacity against Temperature for a 16x16 matrix along with a fitted polynomial between a much more restricted range of temperatures and a significantly lower degree of polynomial]]

Upon comparison with ''Figure 16'', the new fitted polynomial is a significantly better fit even for a 3rd degree polynomial and is a much more accurate representation of my data around the peak of the graph and will make it easier to determine the maximum value of Heat Capacity. However, the polyfit curve still doesn't perfectly fit the peak due to the significant amount of noise present there.

 

Here is the source code for ''Figure 17''ː
<pre>data16 = np.loadtxt("16x16C.dat") #loads data to variable

T16 = data16[:,0] #gets temps
C16 = data16[:,5] # gets heat capacities

Tmin16 = 2.15 #chosen min temp
Tmax16 = 2.55 #chosen max temp

selection16 = np.logical_and(T16 > Tmin16, T16 < Tmax16) #choose only those rows where both conditions are true
peak_T_values16 = T16[selection16] #choose temp values in range chosen above
peak_C_values16 = C16[selection16] #choose heat cap values in range of t above

fit16 = np.polyfit(peak_T_values16,peak_C_values16,3) #fit 3rd order polynomial
peak_T_range16 = np.linspace(Tmin16, Tmax16, 1000) #defines 1000 temps within data range
fitted_C_values16 = np.polyval(fit16, peak_T_range16) #use the fit object to get corresponding values of heat cap

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(T16,C16,color='orange',label='C++ Data') #plots C data of heat cap against temp
heatcapax.plot(peak_T_range16,fitted_C_values16,label='Fitted Polynomial') #plots fitted polynomial for small range
heatcapax.legend()
pl.savefig('FIT_16x16C_3.png', bbox_inches='tight') #saves figure
pl.show()

</pre>

===TASK: find the temperature at which the maximum in C occurs for each datafile that you were given. Make a text file containing two colums: the lattice side length (2,4,8, etc.), and the temperature at which C is a maximum. This is your estimate of <math>T_C</math> for that side length. Make a plot that uses the scaling relation given above to determine <math>T_{C,\infty}</math>. By doing a little research online, you should be able to find the theoretical exact Curie temperature for the infinite 2D Ising lattice. How does your value compare to this? Are you surprised by how good/bad the agreement is? Attach a PNG of this final graph to your report, and discuss briefly what you think the major sources of error are in your estimate.===

''Figure 18'' below shows a graph of <math>T_{C,L}</math> against <math>\frac{1}{Lattice Size}</math> to determine the Curie Temperature of an infinite 2D Ising Model Lattice <math>T_{C,\infty}</math>. The black dots represent the raw data obtained from obtaining the temperature at which the Heat Capacity was a maximum for the lattices and the red line in a linear curve fit plotted against the data to allow the y-intercept which is the Curie Temperature for the infinite 2D lattice to be determined.

[[File:cg1417CurieTemp.png|400px|thumb|left|Figure 18 - Plot of 1/Lattice Size against Curie Temperature for that lattice size.]]

The value for <math>T_{C,\inf}</math> obtained from the data is <math>T_{C,\infty} = 2.277 \frac{J}{k_B}</math> with a literature value being <math>T_{C,\infty} = 2.269 \frac{J}{k_B}</math> <ref>L. Onsager, Phys. Rev., 1944, 65, 117--149.</ref>for an infinite square 2D lattice. This means that my result slightly over-estimates the Curie Temperature for the infinite lattice and as a result for an infinite lattice the temperature at which spontaneous magnetisation stops would actually occur at a slightly lower temperature than expected. However, the difference between my value and the literature value is only 0.008 which is incredibly small and the amount of agreement between the two values is somewhat surprising, which means that the error in my estimates of the Curie Temperature for each lattice size is relatively small. The points which have the largest residuals and deviation from the line of best fit in ''Figure 17'' corresponds to the smaller lattice sizes of 2x2 and 4x4 where longer range interactions are more significant. The longer range interactions posed by the boundary conditions are significant for the smaller sizes and causes the energy of the smaller matrices to be less accurate and have a larger associated error with the energy and the Curie Temperature for that lattice size. This affects the accuracy of the line of best fit and to increase the accuracy of this line, larger lattice sizes of 128x128, 256x256 etc should be included in the calculation for the line of best fit and the smaller matrices ignored - this should allow a more accurate value of <math>T_{C,\infty}</math> to be determined.

 

Below is the source code used to generate ''Figure 18''
<pre>
Cmax64x64 = np.max(fitted_C_values64) #finds Cmax for 64x64 matrix - done for others already
Tmax64x64 = peak_T_range64[fitted_C_values64 == Cmax64x64] #finds Tmax corresponding to Cmax

LatSize=[2,4,8,16,32,64] #stores lattice sizes
Tmax=[Tmax2x2,Tmax4x4,Tmax8x8,Tmax16x16,Tmax32x32,Tmax64x64] #stores corresponding Tmax data
np.savetxt('CmaxVSTmax.txt', (LatSize,Tmax)) #writes data to txt file

ScalData=np.loadtxt('CmaxVSTmax.txt') #loads data
LatticeSize=ScalData[0] #gets lattice sizes
TempMax=ScalData[1] #gets max temp or curie temp for each lattice

Lmin1min = np.min(np.divide(1,LatticeSize)) #minimum of 1/LatticeSize values
Lmin1max = np.max(np.divide(1,LatticeSize)) #maximum of 1/LatticeSize values

fitTcl = np.polyfit(np.divide(1,LatticeSize),TempMax, 1) #creates fit object

Lmin1values = np.linspace(Lmin1min, Lmin1max, 1000) #finds 1000 values between min and max x-axis value of 1/LatticeSize
fitted_Tcl_values = np.polyval(fitTcl, Lmin1values) #creates corresponding Curie Temp values for each value in Lmin1values

fig = pl.figure()
scalrelax = fig.add_subplot(1,1,1)
scalrelax.set_xlabel('1/Lattice Size')
scalrelax.set_ylabel('Curie Temperature/ J/k_B')
scalrelax.plot(np.divide(1,LatticeSize),TempMax,color='black',marker='.',linestyle='') #plots Curie Temp against 1/LatticeSize
scalrelax.plot(Lmin1values,fitted_Tcl_values,color='red',marker='',linestyle='-') #plots line of best fit for data above
pl.savefig('CurieTemp.png', bbox_inches='tight') #saves figure
pl.show()

</pre>

== References ==

Rep:Y3CMPCG1417

2019-11-20T10:39:19Z

==Section 1 - Introduction to the Ising Model==

===TASK: Show that the lowest possible energy for the Ising model is <math>E = -DNJ</math>, where D is the number of dimensions and N is the total number of spins. What is the multiplicity of this state? Calculate its entropy.===

Consider a 1D row of lattice sites of N=3 with spin configuration [+1][+1][+1].

Mathematically the interaction energy is defined asː
<math> -\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} </math> where J is a constant and <math>s_{i}s_{j}</math> is the product between two spins in adjacent lattice sites.

The sum of the interaction energies <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j}</math> can be considered as the sum of the individual interaction energies between spinsː
<math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = \epsilon_{12} + \epsilon_{23} + \epsilon_{13} + \epsilon_{21} + \epsilon_{32} + \epsilon_{31} </math>.

Although lattice sites 1 and 3 are not adjacent they are said to still interact according to the periodic boundary conditions applied.

However, <math>\epsilon_{12} = \epsilon_{21} </math> and <math>\epsilon_{23} = \epsilon_{32}</math> and <math>\epsilon_{13} = \epsilon_{31}</math> which means that all of the interactions within the system are counted twice, hence the total energy needs to be halved, resulting in the following formula being obtainedː <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = 2\epsilon_{12} + 2\epsilon_{13} + 2\epsilon_{23} </math>.

It can be determined that <math>\epsilon_{12} = (+1)(+1) = 1</math> , <math>\epsilon_{13} = (+1)(+1) = 1</math> and <math>\epsilon_{23} = (+1)(+1) = 1</math>.

Thereforeː <math>-\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = -\frac{1}{2} \ J \ (2 + 2 + 2) = -\frac{1}{2} \ J \ 6 = - 3 J = -DNJ</math> for a 1D lattice with <math>D=1</math> and 3 lattice sites <math>N=3</math>

The multiplicity of the system,<math>\Omega = \frac{lattice sites!}{n. spin up!n. spin down!}</math>

Entropy, <math>S</math> is defined as <math>S = k_B ln(\Omega)</math> and so in this case <math>S = k_B ln(\frac{100!}{100!}) = 0</math>

===TASK: Imagine that the system is in the lowest energy configuration. To move to a different state, one of the spins must spontaneously change direction ("flip"). What is the change in energy if this happens <math>(D=3, N=1000)</math>? How much entropy does the system gain by doing soʔ===

In a 3D lattice system, each lattice site has three unique interactions with its neighbours to its left, top and front. In the lowest energy configuration, all spins are parallel and for a system the minimum energy is <math>E = -DNJ</math>, so for the system with <math>N=1000</math> and <math>D=3</math>, the minimum energy is <math>-3000J</math>.

If a single spin is flipped, the product of its spin with its neighbours spin reverses and becomes negative and this increases the total energy of the system. Since 3 unique spin-spin interactions are reversed in sign, the total energy increases by <math>+3J</math>, meaning the new total energy is <math>-2997J</math>

Initially the multiplicity of the system will be <math>\Omega = \frac{1000!}{1000!}</math> , and after the flip, the multiplicity becomes <math> \Omega = \frac{1000!}{999!1!}=1000</math>.

The associated change in entropy, <math>\Delta S = k_B ln(1000) - 0 = 6.91 k_B</math>, which is an expected increase in entropy as the number of possible configurations of the system increases.

===TASK: Calculate the magnetisation of the 1D and 2D lattices in Figure 1. What magnetisation would you expect to observe for an Ising lattice with <math>D = 3,\ N=1000</math> at absolute zero?===

[[File:ThirdYearCMPExpt-IsingSketch.png|thumb|left|Figure 1 - Shows 1D (N = 5), 2D (N = 5x5) and 3D (N = 5x5x5) lattices.]]

Magnetisation is defined as <math>M=\sum_{i} s_i</math>. So for the 1D lattice with <math>N = 5</math> in ''Figure 2'', <math>M = +1</math> and for the 2D lattice with <math>N = 25 , M = +1</math> too.

According to the 3rd Law of thermodynamics, entropy is 0 at absolute zero for a perfect crystalline solid, and consequently it is expected that the lattices will have follow suit and have zero entropy at 0K. To have zero entropy all spins must be parallel as such that magnetisation, <math>M = N</math>. For all the spins to be parallel, there is only one possible configuration. So, for a lattice with <math>N = 1000</math> and <math>D =3</math>, if <math>M = N</math>, then multiplicity, <math>\Omega = 1</math> and entropy, <math>S =k_B ln(1) = 0</math>.

 

==Section 2 - Calculating the Energy and Magnetisation==

===TASK: complete the functions energy() and magnetisation(), which should return the energy of the lattice and the total magnetisation, respectively. In the energy() function you may assume that <math>J=1.0</math> at all times (in fact, we are working in reduced units in which <math>J=k_B</math>, but there will be more information about this in later sections). Do not worry about the efficiency of the code at the moment — we will address the speed in a later part of the experiment.===

<pre>def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
lat=self.lattice #creates lattice and stores it
mag=[]
for i in range(0,len(lat)): #loops through all rows of lattice
for j in range(0,len(lat[i])): #loops through elements of each row
mag+=[lat[i][j]] #adds spin value to mag array
return sum(mag) #sums all spins from mag array
</pre>

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

lat=self.lattice #creates lattice and stores it
left=[]
top=[]

for i in range(0,len(lat)):
for j in range(0,len(lat[i])):
left+=[lat[i][j]*lat[i][j-1]] #multiplies spin by spin to left
top+=[lat[i][j]*lat[i-1][j]] #multiplies spin by spin above it
int_en=left+top #sums spin products from left and top
energy=-sum(int_en) #sums all spin products for each spin to give total

return energy
</pre>

===TASK: Run the ILcheck.py script from the IPython Qt console using the command===

''Figure 2'' shows the results when ILcheck.py was ran on my IsingLattice.py file. The ILcheck.py file was ran several times to ensure the code worked for various random lattices.

[[File:Cg1417ILcheck run.png|thumb|left|500px| Figure 2 - Result from running the ILcheck.py file]]

 

==Section 3 - Introduction to Monte Carlo Simulation==

===TASK: How many configurations are available to a system with 100 spins? To evaluate these expressions, we have to calculate the energy and magnetisation for each of these configurations, then perform the sum. Let's be very, very, generous, and say that we can analyse <math>1\times 10^9</math> configurations per second with our computer. How long will it take to evaluate a single value of <math>\left\langle M\right\rangle_T</math>?===

For a system with 100 lattice sites and two possible spins for each site, there are <math>2^{100}</math>possible configurations for the system. <math>2^{100}= 1.27\times 10^{30} </math>, so if the computer can analyse <math>1\times 10^9</math> configurations per second, then it will take <math>\frac{1.27\times 10^{30}}{10^9} = 1.27\times 10^{21} s</math> to analyse the whole system, which is longer than the age of the universe and therefore is not a practical approach.

===TASK: Implement a single cycle of the above algorithm in the montecarlocycle(T) function. This function should return the energy of your lattice and the magnetisation at the end of the cycle. You may assume that the energy returned by your energy() function is in units of <math>k_B</math>! Complete the statistics() function. This should return the following quantities whenever it is called: <math><E>, <E^2>, <M>, <M^2></math>, and the number of Monte Carlo steps that have elapsed.===
<pre>
E = []
E2 = []
M = []
M2 = []
n_cycles = 0

def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back if rejected else not changed

self.E+=[self.energy()] #records energy
self.E2+=[self.energy()**2] #records energy squared
self.M+=[self.magnetisation()] #records magnetisation
self.M2+=[self.magnetisation()**2] #records magnetisation squared
self.n_cycles=self.n_cycles+1 #adds 1 to run total

return (self.energy(),self.magnetisation())

def statistics(self):
# complete this function so that it calculates the correct values for the averages of E, E*E (E2), M, M*M (M2), and returns them

e=np.mean(self.E)
e2=np.mean(self.E2)
m=np.mean(self.M)
m2=np.mean(self.M2)

return e,e2,m,m2,self.n_cycles
</pre>

''Figure 3'' shows the results of a single run of the montecarlostep() function and the lattice the function operated upon.

[[File:cg1417MonteCarloStep_run.png|thumb|left|Figure 3 - Results from a single montecarlostep() function and the resulting lattice produced along with the correct return from the statistics() function]]

 

===TASK: If <math>T < T_C</math>, do you expect a spontaneous magnetisation (i.e. do you expect <math>\left\langle M\right\rangle \neq 0</math>)? When the state of the simulation appears to stop changing (when you have reached an equilibrium state), use the controls to export the output to PNG and attach this to your report. You should also include the output from your statistics() function.===

If the temperature of the system is less than the Curie Temperature, <math>T_C</math> then spontaneous magnetisation can occur and the system will tend to its lowest energy state where all of the spins are parallel - this is a property of ferromagnetic materials.

[[File:Cg1417ILanim_run.png|400px|thumb|left|Figure 4 - Results from running the ILanim.py file - shows the energy and magnetisation converging over time]]

''Figure 4'' shows that over time the the system spontaneously converges to the minimum energy state with all of the spins parallel to one another and shows, as I expected, that spontaneous magnetisation occurs and also shows that the temperature of this simulation is below the Curie Temperature, <math>T < T_C</math>.

 

==Section 4 - Accelerating the Code==

===TASK: Use the script ILtimetrial.py to record how long your current version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 5'' show the results of running the ILtimetrial.py file on my code three timesː

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1.png
| width1=500
| image2=cg1417ILtimetrial_run2.png
| width2=500
| image3=cg1417ILtimetrial_run3.png
| width3=500
| footer = Figure 5 - Results of running the ILtimetrial.py file on my code three separate times
}}
 

This gave me an avergage time of <math>24.3 s \pm 0.2s</math>

===TASK: Look at the documentation for the NumPy sum function. You should be able to modify your magnetisation() function so that it uses this to evaluate M. The energy is a little trickier. Familiarise yourself with the NumPy roll and multiply functions, and use these to replace your energy double loop (you will need to call roll and multiply twice!).===

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

left=multiply(roll(self.lattice,1,axis=1),self.lattice) #product of spin with spin left of it
top=multiply(roll(self.lattice,-1,axis=0),self.lattice) #product of spin with spin above it

int_en=sum(left+top) #sum of array containing sum of left and top spin products for each spin

energy = -sum(int_en) #calculates the total energy of system
return energy

def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
return sum(sum(self.lattice)) #adds up all spins in lattice
</pre>
The use of the bumpy modules reduces the amount of code required and removes the need for loops making the code significantly shorter, and is therefore expected to run ILtimetrial.py faster than the initial code developed.

===TASK: Use the script ILtimetrial.py to record how long your new version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 6'' shows the result of running the ILtimetrial.py on my new accelerated code.

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1fast.png
| width1=500
| image2=ILtimetrial_run2fast.png
| width2=500
| image3=ILtimetrial_run3fast.png
| width3=500
| footer = Figure 6 - Results of running the ILtimetrial.py file on my new updated and accelerated code.
}}
 

The accelerated code is much faster upon using the roll, multiply and sum modules with a new average time of <math>0.790 s \pm 0.005 </math>

==Section 5 - The effect of temperature==

===TASK: The script ILfinalframe.py runs for a given number of cycles at a given temperature, then plots a depiction of the final lattice state as well as graphs of the energy and magnetisation as a function of cycle number. This is much quicker than animating every frame! Experiment with different temperature and lattice sizes. How many cycles are typically needed for the system to go from its random starting position to the equilibrium state? Modify your statistics() and montecarlostep() functions so that the first N cycles of the simulation are ignored when calculating the averages. You should state in your report what period you chose to ignore, and include graphs from ILfinalframe.py to illustrate your motivation in choosing this figure.===

''Figure 7'' below shows the results from running the ILfinalframe.py for 2x2 lattice at T=1,2,3,5.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2T1.png
| image2 = cg14172x2T2.png
| image3 =cg14172x2T3.png
| image4 =cg14172x2T5.png
| footer_align = left
| footer = Figure 7 - Results of running the ILfinalframe.py file at T=1,2,3,5 for a 2x2 matrix.
}}

 

For a 2x2 matrix, a suitable cut-off point to exclude from the avergage energies and magnetisations is where the energy and magnetisations per spin are constant, which is 30 steps. For T=3 and T=5 the graphs do not converge because it is possible that these temperatures are higher than the Curie Temperature and as such spontaneous magnetisation will not occur and the system will not diverge to the lowest energy state. At the higher temperatures, there are larger thermal fluctations and the Boltzmann factor is more significant allowing the system to move away from the lowest energy state easier. As a result moving forwards, a suitable cut-off point will only be determined from T=1 and T=2 graphs for the larger matrices.

''Figure 8'' shows the results from running a 4x4 lattice at T=1,2 and 3.

{{multiple image
| width =350
| align = left
| image1 = cg14174x4T1.png
| image2 = cg14174x4T2.png
| image3 =cg14174x4T3.png
| footer_align = left
| footer = Figure 8 - Results of running the ILfinalframe.py file at T=1,2,3 for a 4x4 matrix.
}}

From ''Figure 8'', a suitable cut-off point for the energy and magnetisations is 200 as this is after where the energy and magnetisation has converged for T=1, and is after the initial large drop in energy for T=2, even though there are a few small fluctuations after 200 steps. The result from T=3 has been included to show the large fluctuations for the larger temperatures, and supporting my choice to determine the cut-off from T=1 and T=2 only.

''Figure 9'' shows the results for an 8x8 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg14178x8T1.png
| image2 = cg14178x8T2.png
| footer_align = left
| footer = Figure 9 - Results of running the ILfinalframe.py file at T=1,2 for an 8x8 matrix
}}

From ''Figure 9'' above, a suitable cut-off point is 1000 steps as this is where the energy and magnetisation has easily converged by and is also the point after which the initial large drop in energy has been overcome for T=2 too.

''Figure 10'' shows the result of running the ILfinalframe.py for a 16x16 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg141716x16T1.png
| image2 = cg141716x16T2.png
| footer_align = left
| footer = Figure 10 - Results of running the ILfinalframe.py file at T=1,2 for a 16x16 matrix
}}

From ''Figure 10'', a suitable cut-off point is 15000 steps as for T=1 the energy and magnetisations have converged significantly and will not change much, and likewise this is the same for the T=2 frame.

''Figure 11'' below shows the results from a 32x32 matrix at T=1 and T=2.

{{multiple image
| width =350
| align = left
| image1 = cg141732x32T1.png
| image2 = cg141732x32T2.png
| footer_align = left
| footer = Figure 11 - Results of running the ILfinalframe.py file at T=1,2 for a 32x32 matrix
}}

''Figure 11'' above shows the results of running the ILfinalframe.py file for a 32x32 matrix at T=1 and T=2. As a result a suitable cut-off of 50000 steps was chosen as the energy and magnetisation has significantly converged, but not as much as it could at 100000 steps. I chose a slightly lower value to ensure that the run times of my monte-carlo simulations in future tasks were not extremely time consuming.

The montecarlostep() function was changed by adding a condition that values only above the pre-determined cut-off were included when determining the average value of energy; energy squared; magnetisation and magnetisations squared from the statistics function. The statistics() function did not need to be modified.

The following code is from the 32x32 matrixː

<pre>def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back

if self.n_cycles > 50000: #only adds values to array of E,E2,M and M2 above the specific cut-off
self.E+=[self.energy()]
self.E2+=[self.energy()**2]
self.M+=[self.magnetisation()]
self.M2+=[self.magnetisation()**2]
self.n_cycles=self.n_cycles+1

return (self.energy(),self.magnetisation())
</pre>

===TASK: Use ILtemperaturerange.py to plot the average energy and magnetisation for each temperature, with error bars, for an <math>8\times 8</math> lattice. Use your intuition and results from the script ILfinalframe.py to estimate how many cycles each simulation should be. The temperature range 0.25 to 5.0 is sufficient. Use as many temperature points as you feel necessary to illustrate the trend, but do not use a temperature spacing larger than 0.5. The NumPy function savetxt() stores your array of output data on disk — you will need it later. Save the file as 8x8.dat so that you know which lattice size it came from.===

Using the modified code, the file ILtemperaturerange.py was ran on an 8x8 matrix between T=0.5 and T=5 with a step of T=0.02 for 10000 Montecarlo steps and the first 1000 steps of each temperature were excluded when calculating the averages. ''Figure 12'' shows the result of the simulation and also included error bars of standard deviation.

[[File:Cg14178x8error.png|1000px|thumb|left|Figure 12 - Graph showing average energy and average magnetisation for an 8x8 lattice with error bars between T=0.5 and T=5]]

 

Below is the source code for the script to produce the graphː

<pre>data8x8=np.loadtxt('8x8.dat') #loads data
temps8x8=data8x8[:,0] #stores temperatures
energies8x8=data8x8[:,1] #stores average energy for each T
energysq8x8=data8x8[:,2] #stores average energy squared for each T
mag8x8=data8x8[:,3] #stores magnetisation for each T
magsq8x8=data8x8[:,4] #stores magnetisation squared for each T
stde8x8=data8x8[:,5] #edited ILtemperaturerange.py to record the standard deviation of the energy for each T
stdm8x8=data8x8[:,6] #edited ILtemperaturerange.py to record the standard deviation of the magnetisation for each T

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.errorbar(temps8x8, np.array(energies8x8)/64,yerr=np.divide(stde8x8,64),color='black',ecolor='teal',alpha=0.8) #plots energy per spin against T
magax.errorbar(temps8x8, np.array(mag8x8)/64,yerr=np.divide(stdm8x8,64),alpha=0.8,ecolor='salmon',color='black') #plots magnetisation per spin against T on separate graph
pl.savefig('8x8error.png',bbox_inches='tight') #saves figure
pl.show()

</pre>

==Section 6 - The effect of system size==

===TASK: Repeat the final task of the previous section for the following lattice sizes: 2x2, 4x4, 8x8, 16x16, 32x32. Make sure that you name each datafile that your produce after the corresponding lattice size! Write a Python script to make a plot showing the energy per spin versus temperature for each of your lattice sizes. Hint: the NumPy loadtxt function is the reverse of the savetxt function, and can be used to read your previously saved files into the script. Repeat this for the magnetisation. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. How big a lattice do you think is big enough to capture the long range fluctuations?===

The python script for this section is identical as for the 8x8 graph above in Figure 12 with the relevant files and variables changed accordingly.

Each matrix was simulated using the ILtemperaturerange.py file between T=0.5 and T=5 with a step of T=0.02.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2error.png
| caption1 = 2x2 matrix - 5000 steps, cut-off = 30 steps
| image2 = 4x4error.png
| caption2 = 4x4 matrix - 1000 steps, cut-off = 200 steps
| image3 =cg141716x16error.png
| caption3 = 16x16 matrix - 50000 steps, cut-off = 15000 steps
| image4 =cg141732x32error.png
| caption4 = 32x32 matrix - 200000 steps, cut-off = 50000 steps
| footer_align = left
| footer = Figure 13 - Results of running the ILtemperaturerange.py file for 2x2, 4x4, 16x16 and 32x32 matrices.
}}

 

Long-range interactions are present and more significant in the smaller lattices where there are fewer stronger, short range interactions. As a result, I expect long-range interactions to be important in square lattices up to a 4x4 size.

==Section 7 - Determining the Heat Capacity==

===TASK: By definition, <math>C = \frac{\partial \left\langle E\right\rangle}{\partial T}</math>. From this, show that <math>C = \frac{\mathrm{Var}[E]}{k_B T^2}</math> (Where <math>\mathrm{Var}[E]</math> is the variance in <math>E</math>.)===

Recall from statistical thermodynamics that the average energy of a system is the sum across all microstates of the probability of that microstate multiplied by the energy of that microstate, which is defined mathematically asː <math>\langle E \rangle = \sum_i p_{i}\epsilon_{i}</math>.

The partition function <math>q</math> is defined as <math>q = \sum_{i} exp(-\beta \epsilon_{i})</math> where <math>\beta =\frac{1}{k_BT}</math>and the probability, <math>p_{i}</math> can be defined in terms of the partition function as <math>p_{i} = \frac{exp(-\beta \epsilon_{i})}{\sum_{i} exp(-\beta \epsilon_{i})} = \frac{exp(-\beta \epsilon_{i})}{q}</math>.

As a result, <math>\langle E \rangle</math> can be re-written as <math>\langle E \rangle = \sum_{i} \frac{\epsilon_{i} exp(-\beta \epsilon_{i})}{q} = -\frac{1}{q} \frac{\partial}{\partial \beta}\sum_{i}exp(-\beta \epsilon_{i}) = -\frac{1}{q} \frac{\partial q}{\partial \beta}</math>

Likewise, <math>\langle E^2 \rangle = \sum_i p_{i}\epsilon_{i}^{2} = \sum_{i} \frac{\epsilon_{i}^{2}exp(-\beta \epsilon_{i})}{q} = \frac{1}{q} \frac{\partial^{2}}{\partial \beta^{2}}\sum_{i}exp(-\beta \epsilon_{i}) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}}</math>

From definitionː <math>Var[E] = \Delta E^2 = \langle E^2 \rangle - \langle E \rangle^2 </math>

When the definition of <math>\langle E \rangle</math> and <math>\langle E^2 \rangle</math> is written in terms of partition function <math>q</math>ː <math>Var[E] = \langle E^2 \rangle - \langle E \rangle^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \left(\frac{1}{q}\frac{\partial q}{\partial \beta}\right)^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2</math>.

According to the chain ruleː <math>\frac{\partial}{\partial \beta}\left(\frac{1}{q} \frac{\partial q}{\partial \beta}\right) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2 = -\frac{\partial}{\partial \beta}\langle E \rangle = Var[E]</math>

And using the chain rule againː <math>C = \frac{\partial \langle E \rangle}{\partial T}= \left(-\frac{\partial \langle E \rangle}{\partial \beta}\right) \left(-\frac{\partial \beta}{\partial T}\right) = \frac{Var[E]}{k_B T^2}</math>

===TASK: Write a Python script to make a plot showing the heat capacity versus temperature for each of your lattice sizes from the previous section. You may need to do some research to recall the connection between the variance of a variable, <math>\mathrm{Var}[X]</math>, the mean of its square <math>\left\langle X^2\right\rangle</math>, and its squared mean <math>\left\langle X\right\rangle^2</math>. You may find that the data around the peak is very noisy — this is normal, and is a result of being in the critical region. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. ===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb

{{multiple image
| width =300
| align = left
| image1 = cg14172x2heatcap.png
| caption1 = 2x2 Matrix
| image2 = cg14174x4heatcap.png
| caption2 = 4x4 Matrix
| image3 =cg14178x8heatcap.png
| caption3 = 8x8 Matrix
| image4 =cg141716x16heatcap.png
| caption4 = 16x16 Matrix
| image5=cg141732x32heatcap.png
| caption5= 32x32 Matrix
| footer = Figure 14 - Graphs showing Heat Capacity against Temperature for each matrix size
}}

Here is the source code to produce the figuresː
<pre> def heatCap(energies,energysq,T,latsize):
#defines the heat capacity for a given temperature
energiesq=np.multiply(energies,energies) #creates array of (average energies) squared
varE=np.subtract(energysq,energiesq) #defines variance of average energy
tempsq=np.multiply(T,T) #array of temperature squared
return np.array(np.divide(varE,tempsq))/(latsize**2)

heatCap2x2=heatCap(energies2x2,energysq2x2,temps2x2,2) #creates array of heat capacity for each T

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(temps2x2,heatCap2x2,color='orange') #plots heat capacity for each T
pl.savefig('cg14172x2heatcap.png',bbox_inches='tight') #saves figure
pl.show()
</pre>

A general trend from the above graphs is that the peak of the graph shifts towards lower temperatures as the size of the matrix used increases which means the Curie Temperature decreases as matrix size increases. Also, as lattice size increases the noise around the peak becomes larger which will affect the accuracy of determining the maximum heat capacity and Curie Temperature for the larger lattices.

==Section 8 - Locating the Curie Temperature==
===TASK: A C++ program has been used to run some much longer simulations than would be possible on the college computers in Python. You can view its source code here if you are interested. Each file contains six columns: <math>T, E, E^2, M, M^2, C</math> (the final five quantities are per spin), and you can read them with the NumPy loadtxt function as before. For each lattice size, plot the C++ data against your data. For one lattice size, save a PNG of this comparison and add it to your report — add a legend to the graph to label which is which. To do this, you will need to pass the label="..." keyword to the plot function, then call the legend() function of the axis object (documentation here).===

The python code used to read and plot the C++ data is found in the Jupyter notebook CG1417IsingModelGraphs.ipynb.

''Figure 15'' below shows the C++ plotted against my own data for a 16x16 Matrix.

[[File:Cg141716x16C++.png|400px|thumb|left|Figure 15 - Graph showing my own data against the C++ data for a 16x16 matrix.]]

 

The curves produced using the C++ data are much smoother and have less noise than the data gained from my python code. This is likely due to the C++ code having more montecarlosteps per temperature, reducing the effect of random fluctuations on the averages and also having a smaller step gap which will make the curve smoother as the points are closer together.

Here is the source code the produce the figuresː
<pre>#reads data from C++ file
temps2x2C=data2x2C[:,0]
energies2x2C=data2x2C[:,1]
energysq2x2C=data2x2C[:,2]
mag2x2C=data2x2C[:,3]
magsq2x2C=data2x2C[:,4]
heatcap2x2C=data2x2C[:,5]

#fitting C++ data

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.plot(temps2x2, np.array(energies2x2)/4,color='black',alpha=0.7,label='Python Data') #python energy against T
enerax.plot(temps2x2C, energies2x2C, color='red',label='C++ Data') #C energy against T
magax.plot(temps2x2, np.array(mag2x2)/4,color='black',alpha=0.7,label='Python Data') #python magnetisation against T
magax.plot(temps2x2C, mag2x2C,color='red',label='C++ Data') #C energy against T
enerax.legend() #shows legend on energy graph
magax.legend() #shows legend on energy graph
pl.show()
</pre>

The relevant variables and dat files were changed for each matrix.

===TASK: write a script to read the data from a particular file, and plot C vs T, as well as a fitted polynomial. Try changing the degree of the polynomial to improve the fit — in general, it might be difficult to get a good fit! Attach a PNG of an example fit to your report.===

The python script to read and plot the fitted polynomial is found in CG1417PolyfitScript.ipynb

Here is the source code for ''Figure 15''

<pre>data_test = np.loadtxt("16x16C.dat")
T_test = data_test[:,0] #gets temperatures
C_test = data_test[:,5] #gets heat capacity data

#first we fit the polynomial to the data
fit_test = np.polyfit(T_test, C_test, 35) # fit a polynomial of degree 35ǃ

#now we generate interpolated values of the fitted polynomial over the range of our function
T_min_test = 0.5 #np.min(T_test)
T_max_test = 5 #np.max(T_test)

T_range_test = np.linspace(T_min_test, T_max_test, 1000) #generate 1000 evenly spaced points between T_min and T_max
fitted_C_values_test = np.polyval(fit_test, T_range_test)# use the fit object to generate the corresponding values of C

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(T_test,C_test,color='orange',label='C++ Data') #plots C data of heat capacity against temp
heatcapax.plot(T_range_test,fitted_C_values_test,label='Fitted Polynomial') #plots fitted polynomial for whole range of temp
heatcapax.legend()
pl.savefig('FIT_TEST16x16_35.png', bbox_inches='tight') #saves figure
pl.show()
</pre>

Below in ''Figure 16'' is a plot of my Heat Capacity against Temperature data for a 16x16 matrix and features a polynomial of degree 35 plotted against it. Even with a polynomial of such a high degree, it poorly fits the curve and does not fit to the peak of the curve either.

[[File:cg1417FIT_TEST16x16_35.png|thumb|left|400px|Figure 16 - Plot of Heat Capacity against Temperature along with a poorly fitted polynomial of degree 35. ]]

 

===TASK: Modify your script from the previous section. You should still plot the whole temperature range, but fit the polynomial only to the peak of the heat capacity! You should find it easier to get a good fit when restricted to this region===

The script was modified as such that the polynomial was fitted in a set range around the peak of the graph, this is demonstrated in ''Figure 17'' which shows a newly fitted polynomial between a much smaller range of temperatures (T = 2.15-2.55) and a much smaller degree polynomial (3).

[[File:CG1417FIT_16x16C_3.png|thumb|left|400px|Figure 17 - Graph showing Heat Capacity against Temperature for a 16x16 matrix along with a fitted polynomial between a much more restricted range of temperatures and a significantly lower degree of polynomial]]

Upon comparison with ''Figure 16'', the new fitted polynomial is a significantly better fit even for a 3rd degree polynomial and is a much more accurate representation of my data around the peak of the graph and will make it easier to determine the maximum value of Heat Capacity. However, the polyfit curve still doesn't perfectly fit the peak due to the significant amount of noise present there.

 

Here is the source code for ''Figure 17''ː
<pre>data16 = np.loadtxt("16x16C.dat") #loads data to variable

T16 = data16[:,0] #gets temps
C16 = data16[:,5] # gets heat capacities

Tmin16 = 2.15 #chosen min temp
Tmax16 = 2.55 #chosen max temp

selection16 = np.logical_and(T16 > Tmin16, T16 < Tmax16) #choose only those rows where both conditions are true
peak_T_values16 = T16[selection16] #choose temp values in range chosen above
peak_C_values16 = C16[selection16] #choose heat cap values in range of t above

fit16 = np.polyfit(peak_T_values16,peak_C_values16,3) #fit 3rd order polynomial
peak_T_range16 = np.linspace(Tmin16, Tmax16, 1000) #defines 1000 temps within data range
fitted_C_values16 = np.polyval(fit16, peak_T_range16) #use the fit object to get corresponding values of heat cap

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(T16,C16,color='orange',label='C++ Data') #plots C data of heat cap against temp
heatcapax.plot(peak_T_range16,fitted_C_values16,label='Fitted Polynomial') #plots fitted polynomial for small range
heatcapax.legend()
pl.savefig('FIT_16x16C_3.png', bbox_inches='tight') #saves figure
pl.show()

</pre>

===TASK: find the temperature at which the maximum in C occurs for each datafile that you were given. Make a text file containing two colums: the lattice side length (2,4,8, etc.), and the temperature at which C is a maximum. This is your estimate of <math>T_C</math> for that side length. Make a plot that uses the scaling relation given above to determine <math>T_{C,\infty}</math>. By doing a little research online, you should be able to find the theoretical exact Curie temperature for the infinite 2D Ising lattice. How does your value compare to this? Are you surprised by how good/bad the agreement is? Attach a PNG of this final graph to your report, and discuss briefly what you think the major sources of error are in your estimate.===

''Figure 18'' below shows a graph of <math>T_{C,L}</math> against <math>\frac{1}{Lattice Size}</math> to determine the Curie Temperature of an infinite 2D Ising Model Lattice <math>T_{C,\infty}</math>. The black dots represent the raw data obtained from obtaining the temperature at which the Heat Capacity was a maximum for the lattices and the red line in a linear curve fit plotted against the data to allow the y-intercept which is the Curie Temperature for the infinite 2D lattice to be determined.

[[File:cg1417CurieTemp.png|400px|thumb|left|Figure 18 - Plot of 1/Lattice Size against Curie Temperature for that lattice size.]]

The value for <math>T_{C,\inf}</math> obtained from the data is <math>T_{C,\infty} = 2.277 \frac{J}{k_B}</math> with a literature value being <math>T_{C,\infty} = 2.269 \frac{J}{k_B}</math> <ref>L. Onsager, Phys. Rev., 1944, 65, 117--149.</ref>for an infinite square 2D lattice. This means that my result slightly over-estimates the Curie Temperature for the infinite lattice and as a result for an infinite lattice the temperature at which spontaneous magnetisation stops would actually occur at a slightly lower temperature than expected. However, the difference between my value and the literature value is only 0.008 which is incredibly small and the amount of agreement between the two values is somewhat surprising, which means that the error in my estimates of the Curie Temperature for each lattice size is relatively small. The points which have the largest residuals and deviation from the line of best fit in ''Figure 17'' corresponds to the smaller lattice sizes of 2x2 and 4x4 where longer range interactions are more significant. The longer range interactions posed by the boundary conditions are nowhere near as significant for the larger sizes and causes the energy of the smaller matrices to be less accurate and have a larger associated error with the energy and thus the Curie Temperature for that lattice size. This affects the accuracy of the line of best fit and to increase the accuracy of this line, larger lattice sizes of 128x128, 256x256 etc should be included in the calculation for the line of best fit and the smaller matrices ignored.

 

Below is the source code used to generate ''Figure 18''
<pre>
Cmax64x64 = np.max(fitted_C_values64) #finds Cmax for 64x64 matrix - done for others already
Tmax64x64 = peak_T_range64[fitted_C_values64 == Cmax64x64] #finds Tmax corresponding to Cmax

LatSize=[2,4,8,16,32,64] #stores lattice sizes
Tmax=[Tmax2x2,Tmax4x4,Tmax8x8,Tmax16x16,Tmax32x32,Tmax64x64] #stores corresponding Tmax data
np.savetxt('CmaxVSTmax.txt', (LatSize,Tmax)) #writes data to txt file

ScalData=np.loadtxt('CmaxVSTmax.txt') #loads data
LatticeSize=ScalData[0] #gets lattice sizes
TempMax=ScalData[1] #gets max temp or curie temp for each lattice

Lmin1min = np.min(np.divide(1,LatticeSize)) #minimum of 1/LatticeSize values
Lmin1max = np.max(np.divide(1,LatticeSize)) #maximum of 1/LatticeSize values

fitTcl = np.polyfit(np.divide(1,LatticeSize),TempMax, 1) #creates fit object

Lmin1values = np.linspace(Lmin1min, Lmin1max, 1000) #finds 1000 values between min and max x-axis value of 1/LatticeSize
fitted_Tcl_values = np.polyval(fitTcl, Lmin1values) #creates corresponding Curie Temp values for each value in Lmin1values

fig = pl.figure()
scalrelax = fig.add_subplot(1,1,1)
scalrelax.set_xlabel('1/Lattice Size')
scalrelax.set_ylabel('Curie Temperature/ J/k_B')
scalrelax.plot(np.divide(1,LatticeSize),TempMax,color='black',marker='.',linestyle='') #plots Curie Temp against 1/LatticeSize
scalrelax.plot(Lmin1values,fitted_Tcl_values,color='red',marker='',linestyle='-') #plots line of best fit for data above
pl.savefig('CurieTemp.png', bbox_inches='tight') #saves figure
pl.show()

</pre>

== References ==

Rep:Y3CMPCG1417

2019-11-20T10:38:19Z

Cg1417: /* TASK: write a script to read the data from a particular file, and plot C vs T, as well as a fitted polynomial. Try changing the degree of the polynomial to improve the fit — in general, it might be difficult to get a good fit! Attach a PNG of an e...

==Section 1 - Introduction to the Ising Model==

===TASK: Show that the lowest possible energy for the Ising model is <math>E = -DNJ</math>, where D is the number of dimensions and N is the total number of spins. What is the multiplicity of this state? Calculate its entropy.===

Consider a 1D row of lattice sites of N=3 with spin configuration [+1][+1][+1].

Mathematically the interaction energy is defined asː
<math> -\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} </math> where J is a constant and <math>s_{i}s_{j}</math> is the product between two spins in adjacent lattice sites.

The sum of the interaction energies <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j}</math> can be considered as the sum of the individual interaction energies between spinsː
<math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = \epsilon_{12} + \epsilon_{23} + \epsilon_{13} + \epsilon_{21} + \epsilon_{32} + \epsilon_{31} </math>.

Although lattice sites 1 and 3 are not adjacent they are said to still interact according to the periodic boundary conditions applied.

However, <math>\epsilon_{12} = \epsilon_{21} </math> and <math>\epsilon_{23} = \epsilon_{32}</math> and <math>\epsilon_{13} = \epsilon_{31}</math> which means that all of the interactions within the system are counted twice, hence the total energy needs to be halved, resulting in the following formula being obtainedː <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = 2\epsilon_{12} + 2\epsilon_{13} + 2\epsilon_{23} </math>.

It can be determined that <math>\epsilon_{12} = (+1)(+1) = 1</math> , <math>\epsilon_{13} = (+1)(+1) = 1</math> and <math>\epsilon_{23} = (+1)(+1) = 1</math>.

Thereforeː <math>-\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = -\frac{1}{2} \ J \ (2 + 2 + 2) = -\frac{1}{2} \ J \ 6 = - 3 J = -DNJ</math> for a 1D lattice with <math>D=1</math> and 3 lattice sites <math>N=3</math>

The multiplicity of the system,<math>\Omega = \frac{lattice sites!}{n. spin up!n. spin down!}</math>

Entropy, <math>S</math> is defined as <math>S = k_B ln(\Omega)</math> and so in this case <math>S = k_B ln(\frac{100!}{100!}) = 0</math>

===TASK: Imagine that the system is in the lowest energy configuration. To move to a different state, one of the spins must spontaneously change direction ("flip"). What is the change in energy if this happens <math>(D=3, N=1000)</math>? How much entropy does the system gain by doing soʔ===

In a 3D lattice system, each lattice site has three unique interactions with its neighbours to its left, top and front. In the lowest energy configuration, all spins are parallel and for a system the minimum energy is <math>E = -DNJ</math>, so for the system with <math>N=1000</math> and <math>D=3</math>, the minimum energy is <math>-3000J</math>.

If a single spin is flipped, the product of its spin with its neighbours spin reverses and becomes negative and this increases the total energy of the system. Since 3 unique spin-spin interactions are reversed in sign, the total energy increases by <math>+3J</math>, meaning the new total energy is <math>-2997J</math>

Initially the multiplicity of the system will be <math>\Omega = \frac{1000!}{1000!}</math> , and after the flip, the multiplicity becomes <math> \Omega = \frac{1000!}{999!1!}=1000</math>.

The associated change in entropy, <math>\Delta S = k_B ln(1000) - 0 = 6.91 k_B</math>, which is an expected increase in entropy as the number of possible configurations of the system increases.

===TASK: Calculate the magnetisation of the 1D and 2D lattices in Figure 1. What magnetisation would you expect to observe for an Ising lattice with <math>D = 3,\ N=1000</math> at absolute zero?===

[[File:ThirdYearCMPExpt-IsingSketch.png|thumb|left|Figure 1 - Shows 1D (N = 5), 2D (N = 5x5) and 3D (N = 5x5x5) lattices.]]

Magnetisation is defined as <math>M=\sum_{i} s_i</math>. So for the 1D lattice with <math>N = 5</math> in ''Figure 2'', <math>M = +1</math> and for the 2D lattice with <math>N = 25 , M = +1</math> too.

According to the 3rd Law of thermodynamics, entropy is 0 at absolute zero for a perfect crystalline solid, and consequently it is expected that the lattices will have follow suit and have zero entropy at 0K. To have zero entropy all spins must be parallel as such that magnetisation, <math>M = N</math>. For all the spins to be parallel, there is only one possible configuration. So, for a lattice with <math>N = 1000</math> and <math>D =3</math>, if <math>M = N</math>, then multiplicity, <math>\Omega = 1</math> and entropy, <math>S =k_B ln(1) = 0</math>.

 

==Section 2 - Calculating the Energy and Magnetisation==

===TASK: complete the functions energy() and magnetisation(), which should return the energy of the lattice and the total magnetisation, respectively. In the energy() function you may assume that <math>J=1.0</math> at all times (in fact, we are working in reduced units in which <math>J=k_B</math>, but there will be more information about this in later sections). Do not worry about the efficiency of the code at the moment — we will address the speed in a later part of the experiment.===

<pre>def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
lat=self.lattice #creates lattice and stores it
mag=[]
for i in range(0,len(lat)): #loops through all rows of lattice
for j in range(0,len(lat[i])): #loops through elements of each row
mag+=[lat[i][j]] #adds spin value to mag array
return sum(mag) #sums all spins from mag array
</pre>

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

lat=self.lattice #creates lattice and stores it
left=[]
top=[]

for i in range(0,len(lat)):
for j in range(0,len(lat[i])):
left+=[lat[i][j]*lat[i][j-1]] #multiplies spin by spin to left
top+=[lat[i][j]*lat[i-1][j]] #multiplies spin by spin above it
int_en=left+top #sums spin products from left and top
energy=-sum(int_en) #sums all spin products for each spin to give total

return energy
</pre>

===TASK: Run the ILcheck.py script from the IPython Qt console using the command===

''Figure 2'' shows the results when ILcheck.py was ran on my IsingLattice.py file. The ILcheck.py file was ran several times to ensure the code worked for various random lattices.

[[File:Cg1417ILcheck run.png|thumb|left|500px| Figure 2 - Result from running the ILcheck.py file]]

 

==Section 3 - Introduction to Monte Carlo Simulation==

===TASK: How many configurations are available to a system with 100 spins? To evaluate these expressions, we have to calculate the energy and magnetisation for each of these configurations, then perform the sum. Let's be very, very, generous, and say that we can analyse <math>1\times 10^9</math> configurations per second with our computer. How long will it take to evaluate a single value of <math>\left\langle M\right\rangle_T</math>?===

For a system with 100 lattice sites and two possible spins for each site, there are <math>2^{100}</math>possible configurations for the system. <math>2^{100}= 1.27\times 10^{30} </math>, so if the computer can analyse <math>1\times 10^9</math> configurations per second, then it will take <math>\frac{1.27\times 10^{30}}{10^9} = 1.27\times 10^{21} s</math> to analyse the whole system, which is longer than the age of the universe and therefore is not a practical approach.

===TASK: Implement a single cycle of the above algorithm in the montecarlocycle(T) function. This function should return the energy of your lattice and the magnetisation at the end of the cycle. You may assume that the energy returned by your energy() function is in units of <math>k_B</math>! Complete the statistics() function. This should return the following quantities whenever it is called: <math><E>, <E^2>, <M>, <M^2></math>, and the number of Monte Carlo steps that have elapsed.===
<pre>
E = []
E2 = []
M = []
M2 = []
n_cycles = 0

def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back if rejected else not changed

self.E+=[self.energy()] #records energy
self.E2+=[self.energy()**2] #records energy squared
self.M+=[self.magnetisation()] #records magnetisation
self.M2+=[self.magnetisation()**2] #records magnetisation squared
self.n_cycles=self.n_cycles+1 #adds 1 to run total

return (self.energy(),self.magnetisation())

def statistics(self):
# complete this function so that it calculates the correct values for the averages of E, E*E (E2), M, M*M (M2), and returns them

e=np.mean(self.E)
e2=np.mean(self.E2)
m=np.mean(self.M)
m2=np.mean(self.M2)

return e,e2,m,m2,self.n_cycles
</pre>

''Figure 3'' shows the results of a single run of the montecarlostep() function and the lattice the function operated upon.

[[File:cg1417MonteCarloStep_run.png|thumb|left|Figure 3 - Results from a single montecarlostep() function and the resulting lattice produced along with the correct return from the statistics() function]]

 

===TASK: If <math>T < T_C</math>, do you expect a spontaneous magnetisation (i.e. do you expect <math>\left\langle M\right\rangle \neq 0</math>)? When the state of the simulation appears to stop changing (when you have reached an equilibrium state), use the controls to export the output to PNG and attach this to your report. You should also include the output from your statistics() function.===

If the temperature of the system is less than the Curie Temperature, <math>T_C</math> then spontaneous magnetisation can occur and the system will tend to its lowest energy state where all of the spins are parallel - this is a property of ferromagnetic materials.

[[File:Cg1417ILanim_run.png|400px|thumb|left|Figure 4 - Results from running the ILanim.py file - shows the energy and magnetisation converging over time]]

''Figure 4'' shows that over time the the system spontaneously converges to the minimum energy state with all of the spins parallel to one another and shows, as I expected, that spontaneous magnetisation occurs and also shows that the temperature of this simulation is below the Curie Temperature, <math>T < T_C</math>.

 

==Section 4 - Accelerating the Code==

===TASK: Use the script ILtimetrial.py to record how long your current version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 5'' show the results of running the ILtimetrial.py file on my code three timesː

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1.png
| width1=500
| image2=cg1417ILtimetrial_run2.png
| width2=500
| image3=cg1417ILtimetrial_run3.png
| width3=500
| footer = Figure 5 - Results of running the ILtimetrial.py file on my code three separate times
}}
 

This gave me an avergage time of <math>24.3 s \pm 0.2s</math>

===TASK: Look at the documentation for the NumPy sum function. You should be able to modify your magnetisation() function so that it uses this to evaluate M. The energy is a little trickier. Familiarise yourself with the NumPy roll and multiply functions, and use these to replace your energy double loop (you will need to call roll and multiply twice!).===

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

left=multiply(roll(self.lattice,1,axis=1),self.lattice) #product of spin with spin left of it
top=multiply(roll(self.lattice,-1,axis=0),self.lattice) #product of spin with spin above it

int_en=sum(left+top) #sum of array containing sum of left and top spin products for each spin

energy = -sum(int_en) #calculates the total energy of system
return energy

def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
return sum(sum(self.lattice)) #adds up all spins in lattice
</pre>
The use of the bumpy modules reduces the amount of code required and removes the need for loops making the code significantly shorter, and is therefore expected to run ILtimetrial.py faster than the initial code developed.

===TASK: Use the script ILtimetrial.py to record how long your new version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 6'' shows the result of running the ILtimetrial.py on my new accelerated code.

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1fast.png
| width1=500
| image2=ILtimetrial_run2fast.png
| width2=500
| image3=ILtimetrial_run3fast.png
| width3=500
| footer = Figure 6 - Results of running the ILtimetrial.py file on my new updated and accelerated code.
}}
 

The accelerated code is much faster upon using the roll, multiply and sum modules with a new average time of <math>0.790 s \pm 0.005 </math>

==Section 5 - The effect of temperature==

===TASK: The script ILfinalframe.py runs for a given number of cycles at a given temperature, then plots a depiction of the final lattice state as well as graphs of the energy and magnetisation as a function of cycle number. This is much quicker than animating every frame! Experiment with different temperature and lattice sizes. How many cycles are typically needed for the system to go from its random starting position to the equilibrium state? Modify your statistics() and montecarlostep() functions so that the first N cycles of the simulation are ignored when calculating the averages. You should state in your report what period you chose to ignore, and include graphs from ILfinalframe.py to illustrate your motivation in choosing this figure.===

''Figure 7'' below shows the results from running the ILfinalframe.py for 2x2 lattice at T=1,2,3,5.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2T1.png
| image2 = cg14172x2T2.png
| image3 =cg14172x2T3.png
| image4 =cg14172x2T5.png
| footer_align = left
| footer = Figure 7 - Results of running the ILfinalframe.py file at T=1,2,3,5 for a 2x2 matrix.
}}

 

For a 2x2 matrix, a suitable cut-off point to exclude from the avergage energies and magnetisations is where the energy and magnetisations per spin are constant, which is 30 steps. For T=3 and T=5 the graphs do not converge because it is possible that these temperatures are higher than the Curie Temperature and as such spontaneous magnetisation will not occur and the system will not diverge to the lowest energy state. At the higher temperatures, there are larger thermal fluctations and the Boltzmann factor is more significant allowing the system to move away from the lowest energy state easier. As a result moving forwards, a suitable cut-off point will only be determined from T=1 and T=2 graphs for the larger matrices.

''Figure 8'' shows the results from running a 4x4 lattice at T=1,2 and 3.

{{multiple image
| width =350
| align = left
| image1 = cg14174x4T1.png
| image2 = cg14174x4T2.png
| image3 =cg14174x4T3.png
| footer_align = left
| footer = Figure 8 - Results of running the ILfinalframe.py file at T=1,2,3 for a 4x4 matrix.
}}

From ''Figure 8'', a suitable cut-off point for the energy and magnetisations is 200 as this is after where the energy and magnetisation has converged for T=1, and is after the initial large drop in energy for T=2, even though there are a few small fluctuations after 200 steps. The result from T=3 has been included to show the large fluctuations for the larger temperatures, and supporting my choice to determine the cut-off from T=1 and T=2 only.

''Figure 9'' shows the results for an 8x8 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg14178x8T1.png
| image2 = cg14178x8T2.png
| footer_align = left
| footer = Figure 9 - Results of running the ILfinalframe.py file at T=1,2 for an 8x8 matrix
}}

From ''Figure 9'' above, a suitable cut-off point is 1000 steps as this is where the energy and magnetisation has easily converged by and is also the point after which the initial large drop in energy has been overcome for T=2 too.

''Figure 10'' shows the result of running the ILfinalframe.py for a 16x16 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg141716x16T1.png
| image2 = cg141716x16T2.png
| footer_align = left
| footer = Figure 10 - Results of running the ILfinalframe.py file at T=1,2 for a 16x16 matrix
}}

From ''Figure 10'', a suitable cut-off point is 15000 steps as for T=1 the energy and magnetisations have converged significantly and will not change much, and likewise this is the same for the T=2 frame.

''Figure 11'' below shows the results from a 32x32 matrix at T=1 and T=2.

{{multiple image
| width =350
| align = left
| image1 = cg141732x32T1.png
| image2 = cg141732x32T2.png
| footer_align = left
| footer = Figure 11 - Results of running the ILfinalframe.py file at T=1,2 for a 32x32 matrix
}}

''Figure 11'' above shows the results of running the ILfinalframe.py file for a 32x32 matrix at T=1 and T=2. As a result a suitable cut-off of 50000 steps was chosen as the energy and magnetisation has significantly converged, but not as much as it could at 100000 steps. I chose a slightly lower value to ensure that the run times of my monte-carlo simulations in future tasks were not extremely time consuming.

The montecarlostep() function was changed by adding a condition that values only above the pre-determined cut-off were included when determining the average value of energy; energy squared; magnetisation and magnetisations squared from the statistics function. The statistics() function did not need to be modified.

The following code is from the 32x32 matrixː

<pre>def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back

if self.n_cycles > 50000: #only adds values to array of E,E2,M and M2 above the specific cut-off
self.E+=[self.energy()]
self.E2+=[self.energy()**2]
self.M+=[self.magnetisation()]
self.M2+=[self.magnetisation()**2]
self.n_cycles=self.n_cycles+1

return (self.energy(),self.magnetisation())
</pre>

===TASK: Use ILtemperaturerange.py to plot the average energy and magnetisation for each temperature, with error bars, for an <math>8\times 8</math> lattice. Use your intuition and results from the script ILfinalframe.py to estimate how many cycles each simulation should be. The temperature range 0.25 to 5.0 is sufficient. Use as many temperature points as you feel necessary to illustrate the trend, but do not use a temperature spacing larger than 0.5. The NumPy function savetxt() stores your array of output data on disk — you will need it later. Save the file as 8x8.dat so that you know which lattice size it came from.===

Using the modified code, the file ILtemperaturerange.py was ran on an 8x8 matrix between T=0.5 and T=5 with a step of T=0.02 for 10000 Montecarlo steps and the first 1000 steps of each temperature were excluded when calculating the averages. ''Figure 12'' shows the result of the simulation and also included error bars of standard deviation.

[[File:Cg14178x8error.png|1000px|thumb|left|Figure 12 - Graph showing average energy and average magnetisation for an 8x8 lattice with error bars between T=0.5 and T=5]]

 

Below is the source code for the script to produce the graphː

<pre>data8x8=np.loadtxt('8x8.dat') #loads data
temps8x8=data8x8[:,0] #stores temperatures
energies8x8=data8x8[:,1] #stores average energy for each T
energysq8x8=data8x8[:,2] #stores average energy squared for each T
mag8x8=data8x8[:,3] #stores magnetisation for each T
magsq8x8=data8x8[:,4] #stores magnetisation squared for each T
stde8x8=data8x8[:,5] #edited ILtemperaturerange.py to record the standard deviation of the energy for each T
stdm8x8=data8x8[:,6] #edited ILtemperaturerange.py to record the standard deviation of the magnetisation for each T

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.errorbar(temps8x8, np.array(energies8x8)/64,yerr=np.divide(stde8x8,64),color='black',ecolor='teal',alpha=0.8) #plots energy per spin against T
magax.errorbar(temps8x8, np.array(mag8x8)/64,yerr=np.divide(stdm8x8,64),alpha=0.8,ecolor='salmon',color='black') #plots magnetisation per spin against T on separate graph
pl.savefig('8x8error.png',bbox_inches='tight') #saves figure
pl.show()

</pre>

==Section 6 - The effect of system size==

===TASK: Repeat the final task of the previous section for the following lattice sizes: 2x2, 4x4, 8x8, 16x16, 32x32. Make sure that you name each datafile that your produce after the corresponding lattice size! Write a Python script to make a plot showing the energy per spin versus temperature for each of your lattice sizes. Hint: the NumPy loadtxt function is the reverse of the savetxt function, and can be used to read your previously saved files into the script. Repeat this for the magnetisation. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. How big a lattice do you think is big enough to capture the long range fluctuations?===

The python script for this section is identical as for the 8x8 graph above in Figure 12 with the relevant files and variables changed accordingly.

Each matrix was simulated using the ILtemperaturerange.py file between T=0.5 and T=5 with a step of T=0.02.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2error.png
| caption1 = 2x2 matrix - 5000 steps, cut-off = 30 steps
| image2 = 4x4error.png
| caption2 = 4x4 matrix - 1000 steps, cut-off = 200 steps
| image3 =cg141716x16error.png
| caption3 = 16x16 matrix - 50000 steps, cut-off = 15000 steps
| image4 =cg141732x32error.png
| caption4 = 32x32 matrix - 200000 steps, cut-off = 50000 steps
| footer_align = left
| footer = Figure 13 - Results of running the ILtemperaturerange.py file for 2x2, 4x4, 16x16 and 32x32 matrices.
}}

 

Long-range interactions are present and more significant in the smaller lattices where there are fewer stronger, short range interactions. As a result, I expect long-range interactions to be important in square lattices up to a 4x4 size.

==Section 7 - Determining the Heat Capacity==

===TASK: By definition, <math>C = \frac{\partial \left\langle E\right\rangle}{\partial T}</math>. From this, show that <math>C = \frac{\mathrm{Var}[E]}{k_B T^2}</math> (Where <math>\mathrm{Var}[E]</math> is the variance in <math>E</math>.)===

Recall from statistical thermodynamics that the average energy of a system is the sum across all microstates of the probability of that microstate multiplied by the energy of that microstate, which is defined mathematically asː <math>\langle E \rangle = \sum_i p_{i}\epsilon_{i}</math>.

The partition function <math>q</math> is defined as <math>q = \sum_{i} exp(-\beta \epsilon_{i})</math> where <math>\beta =\frac{1}{k_BT}</math>and the probability, <math>p_{i}</math> can be defined in terms of the partition function as <math>p_{i} = \frac{exp(-\beta \epsilon_{i})}{\sum_{i} exp(-\beta \epsilon_{i})} = \frac{exp(-\beta \epsilon_{i})}{q}</math>.

As a result, <math>\langle E \rangle</math> can be re-written as <math>\langle E \rangle = \sum_{i} \frac{\epsilon_{i} exp(-\beta \epsilon_{i})}{q} = -\frac{1}{q} \frac{\partial}{\partial \beta}\sum_{i}exp(-\beta \epsilon_{i}) = -\frac{1}{q} \frac{\partial q}{\partial \beta}</math>

Likewise, <math>\langle E^2 \rangle = \sum_i p_{i}\epsilon_{i}^{2} = \sum_{i} \frac{\epsilon_{i}^{2}exp(-\beta \epsilon_{i})}{q} = \frac{1}{q} \frac{\partial^{2}}{\partial \beta^{2}}\sum_{i}exp(-\beta \epsilon_{i}) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}}</math>

From definitionː <math>Var[E] = \Delta E^2 = \langle E^2 \rangle - \langle E \rangle^2 </math>

When the definition of <math>\langle E \rangle</math> and <math>\langle E^2 \rangle</math> is written in terms of partition function <math>q</math>ː <math>Var[E] = \langle E^2 \rangle - \langle E \rangle^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \left(\frac{1}{q}\frac{\partial q}{\partial \beta}\right)^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2</math>.

According to the chain ruleː <math>\frac{\partial}{\partial \beta}\left(\frac{1}{q} \frac{\partial q}{\partial \beta}\right) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2 = -\frac{\partial}{\partial \beta}\langle E \rangle = Var[E]</math>

And using the chain rule againː <math>C = \frac{\partial \langle E \rangle}{\partial T}= \left(-\frac{\partial \langle E \rangle}{\partial \beta}\right) \left(-\frac{\partial \beta}{\partial T}\right) = \frac{Var[E]}{k_B T^2}</math>

===TASK: Write a Python script to make a plot showing the heat capacity versus temperature for each of your lattice sizes from the previous section. You may need to do some research to recall the connection between the variance of a variable, <math>\mathrm{Var}[X]</math>, the mean of its square <math>\left\langle X^2\right\rangle</math>, and its squared mean <math>\left\langle X\right\rangle^2</math>. You may find that the data around the peak is very noisy — this is normal, and is a result of being in the critical region. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. ===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb

{{multiple image
| width =300
| align = left
| image1 = cg14172x2heatcap.png
| caption1 = 2x2 Matrix
| image2 = cg14174x4heatcap.png
| caption2 = 4x4 Matrix
| image3 =cg14178x8heatcap.png
| caption3 = 8x8 Matrix
| image4 =cg141716x16heatcap.png
| caption4 = 16x16 Matrix
| image5=cg141732x32heatcap.png
| caption5= 32x32 Matrix
| footer = Figure 14 - Graphs showing Heat Capacity against Temperature for each matrix size
}}

Here is the source code to produce the figuresː
<pre> def heatCap(energies,energysq,T,latsize):
#defines the heat capacity for a given temperature
energiesq=np.multiply(energies,energies) #creates array of (average energies) squared
varE=np.subtract(energysq,energiesq) #defines variance of average energy
tempsq=np.multiply(T,T) #array of temperature squared
return np.array(np.divide(varE,tempsq))/(latsize**2)

heatCap2x2=heatCap(energies2x2,energysq2x2,temps2x2,2) #creates array of heat capacity for each T

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(temps2x2,heatCap2x2,color='orange') #plots heat capacity for each T
pl.savefig('cg14172x2heatcap.png',bbox_inches='tight') #saves figure
pl.show()
</pre>

A general trend from the above graphs is that the peak of the graph shifts towards lower temperatures as the size of the matrix used increases which means the Curie Temperature decreases as matrix size increases. Also, as lattice size increases the noise around the peak becomes larger which will affect the accuracy of determining the maximum heat capacity and Curie Temperature for the larger lattices.

==Section 8 - Locating the Curie Temperature==
===TASK: A C++ program has been used to run some much longer simulations than would be possible on the college computers in Python. You can view its source code here if you are interested. Each file contains six columns: <math>T, E, E^2, M, M^2, C</math> (the final five quantities are per spin), and you can read them with the NumPy loadtxt function as before. For each lattice size, plot the C++ data against your data. For one lattice size, save a PNG of this comparison and add it to your report — add a legend to the graph to label which is which. To do this, you will need to pass the label="..." keyword to the plot function, then call the legend() function of the axis object (documentation here).===

The python code used to read and plot the C++ data is found in the Jupyter notebook CG1417IsingModelGraphs.ipynb.

''Figure 15'' below shows the C++ plotted against my own data for a 16x16 Matrix.

[[File:Cg141716x16C++.png|400px|thumb|left|Figure 15 - Graph showing my own data against the C++ data for a 16x16 matrix.]]

 

The curves produced using the C++ data are much smoother and have less noise than the data gained from my python code. This is likely due to the C++ code having more montecarlosteps per temperature, reducing the effect of random fluctuations on the averages and also having a smaller step gap which will make the curve smoother as the points are closer together.

Here is the source code the produce the figuresː
<pre>#reads data from C++ file
temps2x2C=data2x2C[:,0]
energies2x2C=data2x2C[:,1]
energysq2x2C=data2x2C[:,2]
mag2x2C=data2x2C[:,3]
magsq2x2C=data2x2C[:,4]
heatcap2x2C=data2x2C[:,5]

#fitting C++ data

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.plot(temps2x2, np.array(energies2x2)/4,color='black',alpha=0.7,label='Python Data') #python energy against T
enerax.plot(temps2x2C, energies2x2C, color='red',label='C++ Data') #C energy against T
magax.plot(temps2x2, np.array(mag2x2)/4,color='black',alpha=0.7,label='Python Data') #python magnetisation against T
magax.plot(temps2x2C, mag2x2C,color='red',label='C++ Data') #C energy against T
enerax.legend() #shows legend on energy graph
magax.legend() #shows legend on energy graph
pl.show()
</pre>

The relevant variables and dat files were changed for each matrix.

===TASK: write a script to read the data from a particular file, and plot C vs T, as well as a fitted polynomial. Try changing the degree of the polynomial to improve the fit — in general, it might be difficult to get a good fit! Attach a PNG of an example fit to your report.===

The python script to read and plot the fitted polynomial is found in CG1417PolyfitScript.ipynb

Here is the source code for ''Figure 15''

<pre>data_test = np.loadtxt("16x16C.dat")
T_test = data_test[:,0] #gets temperatures
C_test = data_test[:,5] #gets heat capacity data

#first we fit the polynomial to the data
fit_test = np.polyfit(T_test, C_test, 35) # fit a polynomial of degree 35ǃ

#now we generate interpolated values of the fitted polynomial over the range of our function
T_min_test = 0.5 #np.min(T_test)
T_max_test = 5 #np.max(T_test)

T_range_test = np.linspace(T_min_test, T_max_test, 1000) #generate 1000 evenly spaced points between T_min and T_max
fitted_C_values_test = np.polyval(fit_test, T_range_test)# use the fit object to generate the corresponding values of C

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(T_test,C_test,color='orange',label='C++ Data') #plots C data of heat capacity against temp
heatcapax.plot(T_range_test,fitted_C_values_test,label='Fitted Polynomial') #plots fitted polynomial for whole range of temp
heatcapax.legend()
pl.savefig('FIT_TEST16x16_35.png', bbox_inches='tight') #saves figure
pl.show()
</pre>

Below in ''Figure 16'' is a plot of my Heat Capacity against Temperature data for a 16x16 matrix and features a polynomial of degree 35 plotted against it. Even with a polynomial of such a high degree, it poorly fits the curve and does not fit to the peak of the curve either.

[[File:cg1417FIT_TEST16x16_35.png|thumb|left|400px|Figure 16 - Plot of Heat Capacity against Temperature along with a poorly fitted polynomial of degree 35. ]]

 

===TASK: Modify your script from the previous section. You should still plot the whole temperature range, but fit the polynomial only to the peak of the heat capacity! You should find it easier to get a good fit when restricted to this region===

The script was modified as such that the polynomial was fitted in a set range around the peak of the graph, this is demonstrated in ''Figure 17'' which shows a newly fitted polynomial between a much smaller range of temperatures (T = 2.15-2.55) and a much smaller degree polynomial (3).

[[File:CG1417FIT_16x16C_3.png|thumb|left|400px|Figure 17 - Graph showing Heat Capacity against Temperature for a 16x16 matrix along with a fitted polynomial between a much more restricted range of temperatures and a significantly lower degree of polynomial]]

Upon comparison with ''Figure 16'', the new fitted polynomial is a significantly better fit even for a 3rd degree polynomial and is a much more accurate representation of my data around the peak of the graph and will make it easier to determine the maximum value of Heat Capacity.

 

Here is the source code for ''Figure 17''ː
<pre>data16 = np.loadtxt("16x16C.dat") #loads data to variable

T16 = data16[:,0] #gets temps
C16 = data16[:,5] # gets heat capacities

Tmin16 = 2.15 #chosen min temp
Tmax16 = 2.55 #chosen max temp

selection16 = np.logical_and(T16 > Tmin16, T16 < Tmax16) #choose only those rows where both conditions are true
peak_T_values16 = T16[selection16] #choose temp values in range chosen above
peak_C_values16 = C16[selection16] #choose heat cap values in range of t above

fit16 = np.polyfit(peak_T_values16,peak_C_values16,3) #fit 3rd order polynomial
peak_T_range16 = np.linspace(Tmin16, Tmax16, 1000) #defines 1000 temps within data range
fitted_C_values16 = np.polyval(fit16, peak_T_range16) #use the fit object to get corresponding values of heat cap

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(T16,C16,color='orange',label='C++ Data') #plots C data of heat cap against temp
heatcapax.plot(peak_T_range16,fitted_C_values16,label='Fitted Polynomial') #plots fitted polynomial for small range
heatcapax.legend()
pl.savefig('FIT_16x16C_3.png', bbox_inches='tight') #saves figure
pl.show()

</pre>

===TASK: find the temperature at which the maximum in C occurs for each datafile that you were given. Make a text file containing two colums: the lattice side length (2,4,8, etc.), and the temperature at which C is a maximum. This is your estimate of <math>T_C</math> for that side length. Make a plot that uses the scaling relation given above to determine <math>T_{C,\infty}</math>. By doing a little research online, you should be able to find the theoretical exact Curie temperature for the infinite 2D Ising lattice. How does your value compare to this? Are you surprised by how good/bad the agreement is? Attach a PNG of this final graph to your report, and discuss briefly what you think the major sources of error are in your estimate.===

''Figure 18'' below shows a graph of <math>T_{C,L}</math> against <math>\frac{1}{Lattice Size}</math> to determine the Curie Temperature of an infinite 2D Ising Model Lattice <math>T_{C,\infty}</math>. The black dots represent the raw data obtained from obtaining the temperature at which the Heat Capacity was a maximum for the lattices and the red line in a linear curve fit plotted against the data to allow the y-intercept which is the Curie Temperature for the infinite 2D lattice to be determined.

[[File:cg1417CurieTemp.png|400px|thumb|left|Figure 18 - Plot of 1/Lattice Size against Curie Temperature for that lattice size.]]

The value for <math>T_{C,\inf}</math> obtained from the data is <math>T_{C,\infty} = 2.277 \frac{J}{k_B}</math> with a literature value being <math>T_{C,\infty} = 2.269 \frac{J}{k_B}</math> <ref>L. Onsager, Phys. Rev., 1944, 65, 117--149.</ref>for an infinite square 2D lattice. This means that my result slightly over-estimates the Curie Temperature for the infinite lattice and as a result for an infinite lattice the temperature at which spontaneous magnetisation stops would actually occur at a slightly lower temperature than expected. However, the difference between my value and the literature value is only 0.008 which is incredibly small and the amount of agreement between the two values is somewhat surprising, which means that the error in my estimates of the Curie Temperature for each lattice size is relatively small. The points which have the largest residuals and deviation from the line of best fit in ''Figure 17'' corresponds to the smaller lattice sizes of 2x2 and 4x4 where longer range interactions are more significant. The longer range interactions posed by the boundary conditions are nowhere near as significant for the larger sizes and causes the energy of the smaller matrices to be less accurate and have a larger associated error with the energy and thus the Curie Temperature for that lattice size. This affects the accuracy of the line of best fit and to increase the accuracy of this line, larger lattice sizes of 128x128, 256x256 etc should be included in the calculation for the line of best fit and the smaller matrices ignored.

 

Below is the source code used to generate ''Figure 18''
<pre>
Cmax64x64 = np.max(fitted_C_values64) #finds Cmax for 64x64 matrix - done for others already
Tmax64x64 = peak_T_range64[fitted_C_values64 == Cmax64x64] #finds Tmax corresponding to Cmax

LatSize=[2,4,8,16,32,64] #stores lattice sizes
Tmax=[Tmax2x2,Tmax4x4,Tmax8x8,Tmax16x16,Tmax32x32,Tmax64x64] #stores corresponding Tmax data
np.savetxt('CmaxVSTmax.txt', (LatSize,Tmax)) #writes data to txt file

ScalData=np.loadtxt('CmaxVSTmax.txt') #loads data
LatticeSize=ScalData[0] #gets lattice sizes
TempMax=ScalData[1] #gets max temp or curie temp for each lattice

Lmin1min = np.min(np.divide(1,LatticeSize)) #minimum of 1/LatticeSize values
Lmin1max = np.max(np.divide(1,LatticeSize)) #maximum of 1/LatticeSize values

fitTcl = np.polyfit(np.divide(1,LatticeSize),TempMax, 1) #creates fit object

Lmin1values = np.linspace(Lmin1min, Lmin1max, 1000) #finds 1000 values between min and max x-axis value of 1/LatticeSize
fitted_Tcl_values = np.polyval(fitTcl, Lmin1values) #creates corresponding Curie Temp values for each value in Lmin1values

fig = pl.figure()
scalrelax = fig.add_subplot(1,1,1)
scalrelax.set_xlabel('1/Lattice Size')
scalrelax.set_ylabel('Curie Temperature/ J/k_B')
scalrelax.plot(np.divide(1,LatticeSize),TempMax,color='black',marker='.',linestyle='') #plots Curie Temp against 1/LatticeSize
scalrelax.plot(Lmin1values,fitted_Tcl_values,color='red',marker='',linestyle='-') #plots line of best fit for data above
pl.savefig('CurieTemp.png', bbox_inches='tight') #saves figure
pl.show()

</pre>

== References ==

Rep:Y3CMPCG1417

2019-11-20T10:37:27Z

Cg1417: /* TASK: A C++ program has been used to run some much longer simulations than would be possible on the college computers in Python. You can view its source code here if you are interested. Each file contains six columns: T, E, E^2, M, M^2, C (the final fi

==Section 1 - Introduction to the Ising Model==

===TASK: Show that the lowest possible energy for the Ising model is <math>E = -DNJ</math>, where D is the number of dimensions and N is the total number of spins. What is the multiplicity of this state? Calculate its entropy.===

Consider a 1D row of lattice sites of N=3 with spin configuration [+1][+1][+1].

Mathematically the interaction energy is defined asː
<math> -\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} </math> where J is a constant and <math>s_{i}s_{j}</math> is the product between two spins in adjacent lattice sites.

The sum of the interaction energies <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j}</math> can be considered as the sum of the individual interaction energies between spinsː
<math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = \epsilon_{12} + \epsilon_{23} + \epsilon_{13} + \epsilon_{21} + \epsilon_{32} + \epsilon_{31} </math>.

Although lattice sites 1 and 3 are not adjacent they are said to still interact according to the periodic boundary conditions applied.

However, <math>\epsilon_{12} = \epsilon_{21} </math> and <math>\epsilon_{23} = \epsilon_{32}</math> and <math>\epsilon_{13} = \epsilon_{31}</math> which means that all of the interactions within the system are counted twice, hence the total energy needs to be halved, resulting in the following formula being obtainedː <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = 2\epsilon_{12} + 2\epsilon_{13} + 2\epsilon_{23} </math>.

It can be determined that <math>\epsilon_{12} = (+1)(+1) = 1</math> , <math>\epsilon_{13} = (+1)(+1) = 1</math> and <math>\epsilon_{23} = (+1)(+1) = 1</math>.

Thereforeː <math>-\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = -\frac{1}{2} \ J \ (2 + 2 + 2) = -\frac{1}{2} \ J \ 6 = - 3 J = -DNJ</math> for a 1D lattice with <math>D=1</math> and 3 lattice sites <math>N=3</math>

The multiplicity of the system,<math>\Omega = \frac{lattice sites!}{n. spin up!n. spin down!}</math>

Entropy, <math>S</math> is defined as <math>S = k_B ln(\Omega)</math> and so in this case <math>S = k_B ln(\frac{100!}{100!}) = 0</math>

===TASK: Imagine that the system is in the lowest energy configuration. To move to a different state, one of the spins must spontaneously change direction ("flip"). What is the change in energy if this happens <math>(D=3, N=1000)</math>? How much entropy does the system gain by doing soʔ===

In a 3D lattice system, each lattice site has three unique interactions with its neighbours to its left, top and front. In the lowest energy configuration, all spins are parallel and for a system the minimum energy is <math>E = -DNJ</math>, so for the system with <math>N=1000</math> and <math>D=3</math>, the minimum energy is <math>-3000J</math>.

If a single spin is flipped, the product of its spin with its neighbours spin reverses and becomes negative and this increases the total energy of the system. Since 3 unique spin-spin interactions are reversed in sign, the total energy increases by <math>+3J</math>, meaning the new total energy is <math>-2997J</math>

Initially the multiplicity of the system will be <math>\Omega = \frac{1000!}{1000!}</math> , and after the flip, the multiplicity becomes <math> \Omega = \frac{1000!}{999!1!}=1000</math>.

The associated change in entropy, <math>\Delta S = k_B ln(1000) - 0 = 6.91 k_B</math>, which is an expected increase in entropy as the number of possible configurations of the system increases.

===TASK: Calculate the magnetisation of the 1D and 2D lattices in Figure 1. What magnetisation would you expect to observe for an Ising lattice with <math>D = 3,\ N=1000</math> at absolute zero?===

[[File:ThirdYearCMPExpt-IsingSketch.png|thumb|left|Figure 1 - Shows 1D (N = 5), 2D (N = 5x5) and 3D (N = 5x5x5) lattices.]]

Magnetisation is defined as <math>M=\sum_{i} s_i</math>. So for the 1D lattice with <math>N = 5</math> in ''Figure 2'', <math>M = +1</math> and for the 2D lattice with <math>N = 25 , M = +1</math> too.

According to the 3rd Law of thermodynamics, entropy is 0 at absolute zero for a perfect crystalline solid, and consequently it is expected that the lattices will have follow suit and have zero entropy at 0K. To have zero entropy all spins must be parallel as such that magnetisation, <math>M = N</math>. For all the spins to be parallel, there is only one possible configuration. So, for a lattice with <math>N = 1000</math> and <math>D =3</math>, if <math>M = N</math>, then multiplicity, <math>\Omega = 1</math> and entropy, <math>S =k_B ln(1) = 0</math>.

 

==Section 2 - Calculating the Energy and Magnetisation==

===TASK: complete the functions energy() and magnetisation(), which should return the energy of the lattice and the total magnetisation, respectively. In the energy() function you may assume that <math>J=1.0</math> at all times (in fact, we are working in reduced units in which <math>J=k_B</math>, but there will be more information about this in later sections). Do not worry about the efficiency of the code at the moment — we will address the speed in a later part of the experiment.===

<pre>def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
lat=self.lattice #creates lattice and stores it
mag=[]
for i in range(0,len(lat)): #loops through all rows of lattice
for j in range(0,len(lat[i])): #loops through elements of each row
mag+=[lat[i][j]] #adds spin value to mag array
return sum(mag) #sums all spins from mag array
</pre>

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

lat=self.lattice #creates lattice and stores it
left=[]
top=[]

for i in range(0,len(lat)):
for j in range(0,len(lat[i])):
left+=[lat[i][j]*lat[i][j-1]] #multiplies spin by spin to left
top+=[lat[i][j]*lat[i-1][j]] #multiplies spin by spin above it
int_en=left+top #sums spin products from left and top
energy=-sum(int_en) #sums all spin products for each spin to give total

return energy
</pre>

===TASK: Run the ILcheck.py script from the IPython Qt console using the command===

''Figure 2'' shows the results when ILcheck.py was ran on my IsingLattice.py file. The ILcheck.py file was ran several times to ensure the code worked for various random lattices.

[[File:Cg1417ILcheck run.png|thumb|left|500px| Figure 2 - Result from running the ILcheck.py file]]

 

==Section 3 - Introduction to Monte Carlo Simulation==

===TASK: How many configurations are available to a system with 100 spins? To evaluate these expressions, we have to calculate the energy and magnetisation for each of these configurations, then perform the sum. Let's be very, very, generous, and say that we can analyse <math>1\times 10^9</math> configurations per second with our computer. How long will it take to evaluate a single value of <math>\left\langle M\right\rangle_T</math>?===

For a system with 100 lattice sites and two possible spins for each site, there are <math>2^{100}</math>possible configurations for the system. <math>2^{100}= 1.27\times 10^{30} </math>, so if the computer can analyse <math>1\times 10^9</math> configurations per second, then it will take <math>\frac{1.27\times 10^{30}}{10^9} = 1.27\times 10^{21} s</math> to analyse the whole system, which is longer than the age of the universe and therefore is not a practical approach.

===TASK: Implement a single cycle of the above algorithm in the montecarlocycle(T) function. This function should return the energy of your lattice and the magnetisation at the end of the cycle. You may assume that the energy returned by your energy() function is in units of <math>k_B</math>! Complete the statistics() function. This should return the following quantities whenever it is called: <math><E>, <E^2>, <M>, <M^2></math>, and the number of Monte Carlo steps that have elapsed.===
<pre>
E = []
E2 = []
M = []
M2 = []
n_cycles = 0

def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back if rejected else not changed

self.E+=[self.energy()] #records energy
self.E2+=[self.energy()**2] #records energy squared
self.M+=[self.magnetisation()] #records magnetisation
self.M2+=[self.magnetisation()**2] #records magnetisation squared
self.n_cycles=self.n_cycles+1 #adds 1 to run total

return (self.energy(),self.magnetisation())

def statistics(self):
# complete this function so that it calculates the correct values for the averages of E, E*E (E2), M, M*M (M2), and returns them

e=np.mean(self.E)
e2=np.mean(self.E2)
m=np.mean(self.M)
m2=np.mean(self.M2)

return e,e2,m,m2,self.n_cycles
</pre>

''Figure 3'' shows the results of a single run of the montecarlostep() function and the lattice the function operated upon.

[[File:cg1417MonteCarloStep_run.png|thumb|left|Figure 3 - Results from a single montecarlostep() function and the resulting lattice produced along with the correct return from the statistics() function]]

 

===TASK: If <math>T < T_C</math>, do you expect a spontaneous magnetisation (i.e. do you expect <math>\left\langle M\right\rangle \neq 0</math>)? When the state of the simulation appears to stop changing (when you have reached an equilibrium state), use the controls to export the output to PNG and attach this to your report. You should also include the output from your statistics() function.===

If the temperature of the system is less than the Curie Temperature, <math>T_C</math> then spontaneous magnetisation can occur and the system will tend to its lowest energy state where all of the spins are parallel - this is a property of ferromagnetic materials.

[[File:Cg1417ILanim_run.png|400px|thumb|left|Figure 4 - Results from running the ILanim.py file - shows the energy and magnetisation converging over time]]

''Figure 4'' shows that over time the the system spontaneously converges to the minimum energy state with all of the spins parallel to one another and shows, as I expected, that spontaneous magnetisation occurs and also shows that the temperature of this simulation is below the Curie Temperature, <math>T < T_C</math>.

 

==Section 4 - Accelerating the Code==

===TASK: Use the script ILtimetrial.py to record how long your current version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 5'' show the results of running the ILtimetrial.py file on my code three timesː

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1.png
| width1=500
| image2=cg1417ILtimetrial_run2.png
| width2=500
| image3=cg1417ILtimetrial_run3.png
| width3=500
| footer = Figure 5 - Results of running the ILtimetrial.py file on my code three separate times
}}
 

This gave me an avergage time of <math>24.3 s \pm 0.2s</math>

===TASK: Look at the documentation for the NumPy sum function. You should be able to modify your magnetisation() function so that it uses this to evaluate M. The energy is a little trickier. Familiarise yourself with the NumPy roll and multiply functions, and use these to replace your energy double loop (you will need to call roll and multiply twice!).===

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

left=multiply(roll(self.lattice,1,axis=1),self.lattice) #product of spin with spin left of it
top=multiply(roll(self.lattice,-1,axis=0),self.lattice) #product of spin with spin above it

int_en=sum(left+top) #sum of array containing sum of left and top spin products for each spin

energy = -sum(int_en) #calculates the total energy of system
return energy

def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
return sum(sum(self.lattice)) #adds up all spins in lattice
</pre>
The use of the bumpy modules reduces the amount of code required and removes the need for loops making the code significantly shorter, and is therefore expected to run ILtimetrial.py faster than the initial code developed.

===TASK: Use the script ILtimetrial.py to record how long your new version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 6'' shows the result of running the ILtimetrial.py on my new accelerated code.

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1fast.png
| width1=500
| image2=ILtimetrial_run2fast.png
| width2=500
| image3=ILtimetrial_run3fast.png
| width3=500
| footer = Figure 6 - Results of running the ILtimetrial.py file on my new updated and accelerated code.
}}
 

The accelerated code is much faster upon using the roll, multiply and sum modules with a new average time of <math>0.790 s \pm 0.005 </math>

==Section 5 - The effect of temperature==

===TASK: The script ILfinalframe.py runs for a given number of cycles at a given temperature, then plots a depiction of the final lattice state as well as graphs of the energy and magnetisation as a function of cycle number. This is much quicker than animating every frame! Experiment with different temperature and lattice sizes. How many cycles are typically needed for the system to go from its random starting position to the equilibrium state? Modify your statistics() and montecarlostep() functions so that the first N cycles of the simulation are ignored when calculating the averages. You should state in your report what period you chose to ignore, and include graphs from ILfinalframe.py to illustrate your motivation in choosing this figure.===

''Figure 7'' below shows the results from running the ILfinalframe.py for 2x2 lattice at T=1,2,3,5.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2T1.png
| image2 = cg14172x2T2.png
| image3 =cg14172x2T3.png
| image4 =cg14172x2T5.png
| footer_align = left
| footer = Figure 7 - Results of running the ILfinalframe.py file at T=1,2,3,5 for a 2x2 matrix.
}}

 

For a 2x2 matrix, a suitable cut-off point to exclude from the avergage energies and magnetisations is where the energy and magnetisations per spin are constant, which is 30 steps. For T=3 and T=5 the graphs do not converge because it is possible that these temperatures are higher than the Curie Temperature and as such spontaneous magnetisation will not occur and the system will not diverge to the lowest energy state. At the higher temperatures, there are larger thermal fluctations and the Boltzmann factor is more significant allowing the system to move away from the lowest energy state easier. As a result moving forwards, a suitable cut-off point will only be determined from T=1 and T=2 graphs for the larger matrices.

''Figure 8'' shows the results from running a 4x4 lattice at T=1,2 and 3.

{{multiple image
| width =350
| align = left
| image1 = cg14174x4T1.png
| image2 = cg14174x4T2.png
| image3 =cg14174x4T3.png
| footer_align = left
| footer = Figure 8 - Results of running the ILfinalframe.py file at T=1,2,3 for a 4x4 matrix.
}}

From ''Figure 8'', a suitable cut-off point for the energy and magnetisations is 200 as this is after where the energy and magnetisation has converged for T=1, and is after the initial large drop in energy for T=2, even though there are a few small fluctuations after 200 steps. The result from T=3 has been included to show the large fluctuations for the larger temperatures, and supporting my choice to determine the cut-off from T=1 and T=2 only.

''Figure 9'' shows the results for an 8x8 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg14178x8T1.png
| image2 = cg14178x8T2.png
| footer_align = left
| footer = Figure 9 - Results of running the ILfinalframe.py file at T=1,2 for an 8x8 matrix
}}

From ''Figure 9'' above, a suitable cut-off point is 1000 steps as this is where the energy and magnetisation has easily converged by and is also the point after which the initial large drop in energy has been overcome for T=2 too.

''Figure 10'' shows the result of running the ILfinalframe.py for a 16x16 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg141716x16T1.png
| image2 = cg141716x16T2.png
| footer_align = left
| footer = Figure 10 - Results of running the ILfinalframe.py file at T=1,2 for a 16x16 matrix
}}

From ''Figure 10'', a suitable cut-off point is 15000 steps as for T=1 the energy and magnetisations have converged significantly and will not change much, and likewise this is the same for the T=2 frame.

''Figure 11'' below shows the results from a 32x32 matrix at T=1 and T=2.

{{multiple image
| width =350
| align = left
| image1 = cg141732x32T1.png
| image2 = cg141732x32T2.png
| footer_align = left
| footer = Figure 11 - Results of running the ILfinalframe.py file at T=1,2 for a 32x32 matrix
}}

''Figure 11'' above shows the results of running the ILfinalframe.py file for a 32x32 matrix at T=1 and T=2. As a result a suitable cut-off of 50000 steps was chosen as the energy and magnetisation has significantly converged, but not as much as it could at 100000 steps. I chose a slightly lower value to ensure that the run times of my monte-carlo simulations in future tasks were not extremely time consuming.

The montecarlostep() function was changed by adding a condition that values only above the pre-determined cut-off were included when determining the average value of energy; energy squared; magnetisation and magnetisations squared from the statistics function. The statistics() function did not need to be modified.

The following code is from the 32x32 matrixː

<pre>def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back

if self.n_cycles > 50000: #only adds values to array of E,E2,M and M2 above the specific cut-off
self.E+=[self.energy()]
self.E2+=[self.energy()**2]
self.M+=[self.magnetisation()]
self.M2+=[self.magnetisation()**2]
self.n_cycles=self.n_cycles+1

return (self.energy(),self.magnetisation())
</pre>

===TASK: Use ILtemperaturerange.py to plot the average energy and magnetisation for each temperature, with error bars, for an <math>8\times 8</math> lattice. Use your intuition and results from the script ILfinalframe.py to estimate how many cycles each simulation should be. The temperature range 0.25 to 5.0 is sufficient. Use as many temperature points as you feel necessary to illustrate the trend, but do not use a temperature spacing larger than 0.5. The NumPy function savetxt() stores your array of output data on disk — you will need it later. Save the file as 8x8.dat so that you know which lattice size it came from.===

Using the modified code, the file ILtemperaturerange.py was ran on an 8x8 matrix between T=0.5 and T=5 with a step of T=0.02 for 10000 Montecarlo steps and the first 1000 steps of each temperature were excluded when calculating the averages. ''Figure 12'' shows the result of the simulation and also included error bars of standard deviation.

[[File:Cg14178x8error.png|1000px|thumb|left|Figure 12 - Graph showing average energy and average magnetisation for an 8x8 lattice with error bars between T=0.5 and T=5]]

 

Below is the source code for the script to produce the graphː

<pre>data8x8=np.loadtxt('8x8.dat') #loads data
temps8x8=data8x8[:,0] #stores temperatures
energies8x8=data8x8[:,1] #stores average energy for each T
energysq8x8=data8x8[:,2] #stores average energy squared for each T
mag8x8=data8x8[:,3] #stores magnetisation for each T
magsq8x8=data8x8[:,4] #stores magnetisation squared for each T
stde8x8=data8x8[:,5] #edited ILtemperaturerange.py to record the standard deviation of the energy for each T
stdm8x8=data8x8[:,6] #edited ILtemperaturerange.py to record the standard deviation of the magnetisation for each T

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.errorbar(temps8x8, np.array(energies8x8)/64,yerr=np.divide(stde8x8,64),color='black',ecolor='teal',alpha=0.8) #plots energy per spin against T
magax.errorbar(temps8x8, np.array(mag8x8)/64,yerr=np.divide(stdm8x8,64),alpha=0.8,ecolor='salmon',color='black') #plots magnetisation per spin against T on separate graph
pl.savefig('8x8error.png',bbox_inches='tight') #saves figure
pl.show()

</pre>

==Section 6 - The effect of system size==

===TASK: Repeat the final task of the previous section for the following lattice sizes: 2x2, 4x4, 8x8, 16x16, 32x32. Make sure that you name each datafile that your produce after the corresponding lattice size! Write a Python script to make a plot showing the energy per spin versus temperature for each of your lattice sizes. Hint: the NumPy loadtxt function is the reverse of the savetxt function, and can be used to read your previously saved files into the script. Repeat this for the magnetisation. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. How big a lattice do you think is big enough to capture the long range fluctuations?===

The python script for this section is identical as for the 8x8 graph above in Figure 12 with the relevant files and variables changed accordingly.

Each matrix was simulated using the ILtemperaturerange.py file between T=0.5 and T=5 with a step of T=0.02.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2error.png
| caption1 = 2x2 matrix - 5000 steps, cut-off = 30 steps
| image2 = 4x4error.png
| caption2 = 4x4 matrix - 1000 steps, cut-off = 200 steps
| image3 =cg141716x16error.png
| caption3 = 16x16 matrix - 50000 steps, cut-off = 15000 steps
| image4 =cg141732x32error.png
| caption4 = 32x32 matrix - 200000 steps, cut-off = 50000 steps
| footer_align = left
| footer = Figure 13 - Results of running the ILtemperaturerange.py file for 2x2, 4x4, 16x16 and 32x32 matrices.
}}

 

Long-range interactions are present and more significant in the smaller lattices where there are fewer stronger, short range interactions. As a result, I expect long-range interactions to be important in square lattices up to a 4x4 size.

==Section 7 - Determining the Heat Capacity==

===TASK: By definition, <math>C = \frac{\partial \left\langle E\right\rangle}{\partial T}</math>. From this, show that <math>C = \frac{\mathrm{Var}[E]}{k_B T^2}</math> (Where <math>\mathrm{Var}[E]</math> is the variance in <math>E</math>.)===

Recall from statistical thermodynamics that the average energy of a system is the sum across all microstates of the probability of that microstate multiplied by the energy of that microstate, which is defined mathematically asː <math>\langle E \rangle = \sum_i p_{i}\epsilon_{i}</math>.

The partition function <math>q</math> is defined as <math>q = \sum_{i} exp(-\beta \epsilon_{i})</math> where <math>\beta =\frac{1}{k_BT}</math>and the probability, <math>p_{i}</math> can be defined in terms of the partition function as <math>p_{i} = \frac{exp(-\beta \epsilon_{i})}{\sum_{i} exp(-\beta \epsilon_{i})} = \frac{exp(-\beta \epsilon_{i})}{q}</math>.

As a result, <math>\langle E \rangle</math> can be re-written as <math>\langle E \rangle = \sum_{i} \frac{\epsilon_{i} exp(-\beta \epsilon_{i})}{q} = -\frac{1}{q} \frac{\partial}{\partial \beta}\sum_{i}exp(-\beta \epsilon_{i}) = -\frac{1}{q} \frac{\partial q}{\partial \beta}</math>

Likewise, <math>\langle E^2 \rangle = \sum_i p_{i}\epsilon_{i}^{2} = \sum_{i} \frac{\epsilon_{i}^{2}exp(-\beta \epsilon_{i})}{q} = \frac{1}{q} \frac{\partial^{2}}{\partial \beta^{2}}\sum_{i}exp(-\beta \epsilon_{i}) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}}</math>

From definitionː <math>Var[E] = \Delta E^2 = \langle E^2 \rangle - \langle E \rangle^2 </math>

When the definition of <math>\langle E \rangle</math> and <math>\langle E^2 \rangle</math> is written in terms of partition function <math>q</math>ː <math>Var[E] = \langle E^2 \rangle - \langle E \rangle^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \left(\frac{1}{q}\frac{\partial q}{\partial \beta}\right)^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2</math>.

According to the chain ruleː <math>\frac{\partial}{\partial \beta}\left(\frac{1}{q} \frac{\partial q}{\partial \beta}\right) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2 = -\frac{\partial}{\partial \beta}\langle E \rangle = Var[E]</math>

And using the chain rule againː <math>C = \frac{\partial \langle E \rangle}{\partial T}= \left(-\frac{\partial \langle E \rangle}{\partial \beta}\right) \left(-\frac{\partial \beta}{\partial T}\right) = \frac{Var[E]}{k_B T^2}</math>

===TASK: Write a Python script to make a plot showing the heat capacity versus temperature for each of your lattice sizes from the previous section. You may need to do some research to recall the connection between the variance of a variable, <math>\mathrm{Var}[X]</math>, the mean of its square <math>\left\langle X^2\right\rangle</math>, and its squared mean <math>\left\langle X\right\rangle^2</math>. You may find that the data around the peak is very noisy — this is normal, and is a result of being in the critical region. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. ===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb

{{multiple image
| width =300
| align = left
| image1 = cg14172x2heatcap.png
| caption1 = 2x2 Matrix
| image2 = cg14174x4heatcap.png
| caption2 = 4x4 Matrix
| image3 =cg14178x8heatcap.png
| caption3 = 8x8 Matrix
| image4 =cg141716x16heatcap.png
| caption4 = 16x16 Matrix
| image5=cg141732x32heatcap.png
| caption5= 32x32 Matrix
| footer = Figure 14 - Graphs showing Heat Capacity against Temperature for each matrix size
}}

Here is the source code to produce the figuresː
<pre> def heatCap(energies,energysq,T,latsize):
#defines the heat capacity for a given temperature
energiesq=np.multiply(energies,energies) #creates array of (average energies) squared
varE=np.subtract(energysq,energiesq) #defines variance of average energy
tempsq=np.multiply(T,T) #array of temperature squared
return np.array(np.divide(varE,tempsq))/(latsize**2)

heatCap2x2=heatCap(energies2x2,energysq2x2,temps2x2,2) #creates array of heat capacity for each T

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(temps2x2,heatCap2x2,color='orange') #plots heat capacity for each T
pl.savefig('cg14172x2heatcap.png',bbox_inches='tight') #saves figure
pl.show()
</pre>

A general trend from the above graphs is that the peak of the graph shifts towards lower temperatures as the size of the matrix used increases which means the Curie Temperature decreases as matrix size increases. Also, as lattice size increases the noise around the peak becomes larger which will affect the accuracy of determining the maximum heat capacity and Curie Temperature for the larger lattices.

==Section 8 - Locating the Curie Temperature==
===TASK: A C++ program has been used to run some much longer simulations than would be possible on the college computers in Python. You can view its source code here if you are interested. Each file contains six columns: <math>T, E, E^2, M, M^2, C</math> (the final five quantities are per spin), and you can read them with the NumPy loadtxt function as before. For each lattice size, plot the C++ data against your data. For one lattice size, save a PNG of this comparison and add it to your report — add a legend to the graph to label which is which. To do this, you will need to pass the label="..." keyword to the plot function, then call the legend() function of the axis object (documentation here).===

The python code used to read and plot the C++ data is found in the Jupyter notebook CG1417IsingModelGraphs.ipynb.

''Figure 15'' below shows the C++ plotted against my own data for a 16x16 Matrix.

[[File:Cg141716x16C++.png|400px|thumb|left|Figure 15 - Graph showing my own data against the C++ data for a 16x16 matrix.]]

 

The curves produced using the C++ data are much smoother and have less noise than the data gained from my python code. This is likely due to the C++ code having more montecarlosteps per temperature, reducing the effect of random fluctuations on the averages and also having a smaller step gap which will make the curve smoother as the points are closer together.

Here is the source code the produce the figuresː
<pre>#reads data from C++ file
temps2x2C=data2x2C[:,0]
energies2x2C=data2x2C[:,1]
energysq2x2C=data2x2C[:,2]
mag2x2C=data2x2C[:,3]
magsq2x2C=data2x2C[:,4]
heatcap2x2C=data2x2C[:,5]

#fitting C++ data

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.plot(temps2x2, np.array(energies2x2)/4,color='black',alpha=0.7,label='Python Data') #python energy against T
enerax.plot(temps2x2C, energies2x2C, color='red',label='C++ Data') #C energy against T
magax.plot(temps2x2, np.array(mag2x2)/4,color='black',alpha=0.7,label='Python Data') #python magnetisation against T
magax.plot(temps2x2C, mag2x2C,color='red',label='C++ Data') #C energy against T
enerax.legend() #shows legend on energy graph
magax.legend() #shows legend on energy graph
pl.show()
</pre>

The relevant variables and dat files were changed for each matrix.

===TASK: write a script to read the data from a particular file, and plot C vs T, as well as a fitted polynomial. Try changing the degree of the polynomial to improve the fit — in general, it might be difficult to get a good fit! Attach a PNG of an example fit to your report.===

The python script to read and plot the fitted polynomial is found in CG1417PolyfitScript.ipynb

Here is the source code for ''Figure 15''

<pre>data_test = np.loadtxt("16x16C.dat")
T_test = data_test[:,0] #gets temperatures
C_test = data_test[:,5] #gets heat capacity data

#first we fit the polynomial to the data
fit_test = np.polyfit(T_test, C_test, 35) # fit a polynomial

#now we generate interpolated values of the fitted polynomial over the range of our function
T_min_test = 0.5 #np.min(T_test)
T_max_test = 5 #np.max(T_test)

T_range_test = np.linspace(T_min_test, T_max_test, 1000) #generate 1000 evenly spaced points between T_min and T_max
fitted_C_values_test = np.polyval(fit_test, T_range_test)# use the fit object to generate the corresponding values of C

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(T_test,C_test,color='orange',label='C++ Data') #plots C data of heat capacity against temp
heatcapax.plot(T_range_test,fitted_C_values_test,label='Fitted Polynomial') #plots fitted polynomial for whole range of temp
heatcapax.legend()
pl.savefig('FIT_TEST16x16_35.png', bbox_inches='tight') #saves figure
pl.show()
</pre>

Below in ''Figure 16'' is a plot of my Heat Capacity against Temperature data for a 16x16 matrix and features a polynomial of degree 35 plotted against it. Even with a polynomial of such a high degree, it poorly fits the curve and does not fit to the peak of the curve either.

[[File:cg1417FIT_TEST16x16_35.png|thumb|left|400px|Figure 16 - Plot of Heat Capacity against Temperature along with a poorly fitted polynomial of degree 35. ]]

 

===TASK: Modify your script from the previous section. You should still plot the whole temperature range, but fit the polynomial only to the peak of the heat capacity! You should find it easier to get a good fit when restricted to this region===

The script was modified as such that the polynomial was fitted in a set range around the peak of the graph, this is demonstrated in ''Figure 17'' which shows a newly fitted polynomial between a much smaller range of temperatures (T = 2.15-2.55) and a much smaller degree polynomial (3).

[[File:CG1417FIT_16x16C_3.png|thumb|left|400px|Figure 17 - Graph showing Heat Capacity against Temperature for a 16x16 matrix along with a fitted polynomial between a much more restricted range of temperatures and a significantly lower degree of polynomial]]

Upon comparison with ''Figure 16'', the new fitted polynomial is a significantly better fit even for a 3rd degree polynomial and is a much more accurate representation of my data around the peak of the graph and will make it easier to determine the maximum value of Heat Capacity.

 

Here is the source code for ''Figure 17''ː
<pre>data16 = np.loadtxt("16x16C.dat") #loads data to variable

T16 = data16[:,0] #gets temps
C16 = data16[:,5] # gets heat capacities

Tmin16 = 2.15 #chosen min temp
Tmax16 = 2.55 #chosen max temp

selection16 = np.logical_and(T16 > Tmin16, T16 < Tmax16) #choose only those rows where both conditions are true
peak_T_values16 = T16[selection16] #choose temp values in range chosen above
peak_C_values16 = C16[selection16] #choose heat cap values in range of t above

fit16 = np.polyfit(peak_T_values16,peak_C_values16,3) #fit 3rd order polynomial
peak_T_range16 = np.linspace(Tmin16, Tmax16, 1000) #defines 1000 temps within data range
fitted_C_values16 = np.polyval(fit16, peak_T_range16) #use the fit object to get corresponding values of heat cap

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(T16,C16,color='orange',label='C++ Data') #plots C data of heat cap against temp
heatcapax.plot(peak_T_range16,fitted_C_values16,label='Fitted Polynomial') #plots fitted polynomial for small range
heatcapax.legend()
pl.savefig('FIT_16x16C_3.png', bbox_inches='tight') #saves figure
pl.show()

</pre>

===TASK: find the temperature at which the maximum in C occurs for each datafile that you were given. Make a text file containing two colums: the lattice side length (2,4,8, etc.), and the temperature at which C is a maximum. This is your estimate of <math>T_C</math> for that side length. Make a plot that uses the scaling relation given above to determine <math>T_{C,\infty}</math>. By doing a little research online, you should be able to find the theoretical exact Curie temperature for the infinite 2D Ising lattice. How does your value compare to this? Are you surprised by how good/bad the agreement is? Attach a PNG of this final graph to your report, and discuss briefly what you think the major sources of error are in your estimate.===

''Figure 18'' below shows a graph of <math>T_{C,L}</math> against <math>\frac{1}{Lattice Size}</math> to determine the Curie Temperature of an infinite 2D Ising Model Lattice <math>T_{C,\infty}</math>. The black dots represent the raw data obtained from obtaining the temperature at which the Heat Capacity was a maximum for the lattices and the red line in a linear curve fit plotted against the data to allow the y-intercept which is the Curie Temperature for the infinite 2D lattice to be determined.

[[File:cg1417CurieTemp.png|400px|thumb|left|Figure 18 - Plot of 1/Lattice Size against Curie Temperature for that lattice size.]]

The value for <math>T_{C,\inf}</math> obtained from the data is <math>T_{C,\infty} = 2.277 \frac{J}{k_B}</math> with a literature value being <math>T_{C,\infty} = 2.269 \frac{J}{k_B}</math> <ref>L. Onsager, Phys. Rev., 1944, 65, 117--149.</ref>for an infinite square 2D lattice. This means that my result slightly over-estimates the Curie Temperature for the infinite lattice and as a result for an infinite lattice the temperature at which spontaneous magnetisation stops would actually occur at a slightly lower temperature than expected. However, the difference between my value and the literature value is only 0.008 which is incredibly small and the amount of agreement between the two values is somewhat surprising, which means that the error in my estimates of the Curie Temperature for each lattice size is relatively small. The points which have the largest residuals and deviation from the line of best fit in ''Figure 17'' corresponds to the smaller lattice sizes of 2x2 and 4x4 where longer range interactions are more significant. The longer range interactions posed by the boundary conditions are nowhere near as significant for the larger sizes and causes the energy of the smaller matrices to be less accurate and have a larger associated error with the energy and thus the Curie Temperature for that lattice size. This affects the accuracy of the line of best fit and to increase the accuracy of this line, larger lattice sizes of 128x128, 256x256 etc should be included in the calculation for the line of best fit and the smaller matrices ignored.

 

Below is the source code used to generate ''Figure 18''
<pre>
Cmax64x64 = np.max(fitted_C_values64) #finds Cmax for 64x64 matrix - done for others already
Tmax64x64 = peak_T_range64[fitted_C_values64 == Cmax64x64] #finds Tmax corresponding to Cmax

LatSize=[2,4,8,16,32,64] #stores lattice sizes
Tmax=[Tmax2x2,Tmax4x4,Tmax8x8,Tmax16x16,Tmax32x32,Tmax64x64] #stores corresponding Tmax data
np.savetxt('CmaxVSTmax.txt', (LatSize,Tmax)) #writes data to txt file

ScalData=np.loadtxt('CmaxVSTmax.txt') #loads data
LatticeSize=ScalData[0] #gets lattice sizes
TempMax=ScalData[1] #gets max temp or curie temp for each lattice

Lmin1min = np.min(np.divide(1,LatticeSize)) #minimum of 1/LatticeSize values
Lmin1max = np.max(np.divide(1,LatticeSize)) #maximum of 1/LatticeSize values

fitTcl = np.polyfit(np.divide(1,LatticeSize),TempMax, 1) #creates fit object

Lmin1values = np.linspace(Lmin1min, Lmin1max, 1000) #finds 1000 values between min and max x-axis value of 1/LatticeSize
fitted_Tcl_values = np.polyval(fitTcl, Lmin1values) #creates corresponding Curie Temp values for each value in Lmin1values

fig = pl.figure()
scalrelax = fig.add_subplot(1,1,1)
scalrelax.set_xlabel('1/Lattice Size')
scalrelax.set_ylabel('Curie Temperature/ J/k_B')
scalrelax.plot(np.divide(1,LatticeSize),TempMax,color='black',marker='.',linestyle='') #plots Curie Temp against 1/LatticeSize
scalrelax.plot(Lmin1values,fitted_Tcl_values,color='red',marker='',linestyle='-') #plots line of best fit for data above
pl.savefig('CurieTemp.png', bbox_inches='tight') #saves figure
pl.show()

</pre>

== References ==

Rep:Y3CMPCG1417

2019-11-20T10:34:16Z

==Section 1 - Introduction to the Ising Model==

===TASK: Show that the lowest possible energy for the Ising model is <math>E = -DNJ</math>, where D is the number of dimensions and N is the total number of spins. What is the multiplicity of this state? Calculate its entropy.===

Consider a 1D row of lattice sites of N=3 with spin configuration [+1][+1][+1].

Mathematically the interaction energy is defined asː
<math> -\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} </math> where J is a constant and <math>s_{i}s_{j}</math> is the product between two spins in adjacent lattice sites.

The sum of the interaction energies <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j}</math> can be considered as the sum of the individual interaction energies between spinsː
<math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = \epsilon_{12} + \epsilon_{23} + \epsilon_{13} + \epsilon_{21} + \epsilon_{32} + \epsilon_{31} </math>.

Although lattice sites 1 and 3 are not adjacent they are said to still interact according to the periodic boundary conditions applied.

However, <math>\epsilon_{12} = \epsilon_{21} </math> and <math>\epsilon_{23} = \epsilon_{32}</math> and <math>\epsilon_{13} = \epsilon_{31}</math> which means that all of the interactions within the system are counted twice, hence the total energy needs to be halved, resulting in the following formula being obtainedː <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = 2\epsilon_{12} + 2\epsilon_{13} + 2\epsilon_{23} </math>.

It can be determined that <math>\epsilon_{12} = (+1)(+1) = 1</math> , <math>\epsilon_{13} = (+1)(+1) = 1</math> and <math>\epsilon_{23} = (+1)(+1) = 1</math>.

Thereforeː <math>-\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = -\frac{1}{2} \ J \ (2 + 2 + 2) = -\frac{1}{2} \ J \ 6 = - 3 J = -DNJ</math> for a 1D lattice with <math>D=1</math> and 3 lattice sites <math>N=3</math>

The multiplicity of the system,<math>\Omega = \frac{lattice sites!}{n. spin up!n. spin down!}</math>

Entropy, <math>S</math> is defined as <math>S = k_B ln(\Omega)</math> and so in this case <math>S = k_B ln(\frac{100!}{100!}) = 0</math>

===TASK: Imagine that the system is in the lowest energy configuration. To move to a different state, one of the spins must spontaneously change direction ("flip"). What is the change in energy if this happens <math>(D=3, N=1000)</math>? How much entropy does the system gain by doing soʔ===

In a 3D lattice system, each lattice site has three unique interactions with its neighbours to its left, top and front. In the lowest energy configuration, all spins are parallel and for a system the minimum energy is <math>E = -DNJ</math>, so for the system with <math>N=1000</math> and <math>D=3</math>, the minimum energy is <math>-3000J</math>.

If a single spin is flipped, the product of its spin with its neighbours spin reverses and becomes negative and this increases the total energy of the system. Since 3 unique spin-spin interactions are reversed in sign, the total energy increases by <math>+3J</math>, meaning the new total energy is <math>-2997J</math>

Initially the multiplicity of the system will be <math>\Omega = \frac{1000!}{1000!}</math> , and after the flip, the multiplicity becomes <math> \Omega = \frac{1000!}{999!1!}=1000</math>.

The associated change in entropy, <math>\Delta S = k_B ln(1000) - 0 = 6.91 k_B</math>, which is an expected increase in entropy as the number of possible configurations of the system increases.

===TASK: Calculate the magnetisation of the 1D and 2D lattices in Figure 1. What magnetisation would you expect to observe for an Ising lattice with <math>D = 3,\ N=1000</math> at absolute zero?===

[[File:ThirdYearCMPExpt-IsingSketch.png|thumb|left|Figure 1 - Shows 1D (N = 5), 2D (N = 5x5) and 3D (N = 5x5x5) lattices.]]

Magnetisation is defined as <math>M=\sum_{i} s_i</math>. So for the 1D lattice with <math>N = 5</math> in ''Figure 2'', <math>M = +1</math> and for the 2D lattice with <math>N = 25 , M = +1</math> too.

According to the 3rd Law of thermodynamics, entropy is 0 at absolute zero for a perfect crystalline solid, and consequently it is expected that the lattices will have follow suit and have zero entropy at 0K. To have zero entropy all spins must be parallel as such that magnetisation, <math>M = N</math>. For all the spins to be parallel, there is only one possible configuration. So, for a lattice with <math>N = 1000</math> and <math>D =3</math>, if <math>M = N</math>, then multiplicity, <math>\Omega = 1</math> and entropy, <math>S =k_B ln(1) = 0</math>.

 

==Section 2 - Calculating the Energy and Magnetisation==

===TASK: complete the functions energy() and magnetisation(), which should return the energy of the lattice and the total magnetisation, respectively. In the energy() function you may assume that <math>J=1.0</math> at all times (in fact, we are working in reduced units in which <math>J=k_B</math>, but there will be more information about this in later sections). Do not worry about the efficiency of the code at the moment — we will address the speed in a later part of the experiment.===

<pre>def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
lat=self.lattice #creates lattice and stores it
mag=[]
for i in range(0,len(lat)): #loops through all rows of lattice
for j in range(0,len(lat[i])): #loops through elements of each row
mag+=[lat[i][j]] #adds spin value to mag array
return sum(mag) #sums all spins from mag array
</pre>

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

lat=self.lattice #creates lattice and stores it
left=[]
top=[]

for i in range(0,len(lat)):
for j in range(0,len(lat[i])):
left+=[lat[i][j]*lat[i][j-1]] #multiplies spin by spin to left
top+=[lat[i][j]*lat[i-1][j]] #multiplies spin by spin above it
int_en=left+top #sums spin products from left and top
energy=-sum(int_en) #sums all spin products for each spin to give total

return energy
</pre>

===TASK: Run the ILcheck.py script from the IPython Qt console using the command===

''Figure 2'' shows the results when ILcheck.py was ran on my IsingLattice.py file. The ILcheck.py file was ran several times to ensure the code worked for various random lattices.

[[File:Cg1417ILcheck run.png|thumb|left|500px| Figure 2 - Result from running the ILcheck.py file]]

 

==Section 3 - Introduction to Monte Carlo Simulation==

===TASK: How many configurations are available to a system with 100 spins? To evaluate these expressions, we have to calculate the energy and magnetisation for each of these configurations, then perform the sum. Let's be very, very, generous, and say that we can analyse <math>1\times 10^9</math> configurations per second with our computer. How long will it take to evaluate a single value of <math>\left\langle M\right\rangle_T</math>?===

For a system with 100 lattice sites and two possible spins for each site, there are <math>2^{100}</math>possible configurations for the system. <math>2^{100}= 1.27\times 10^{30} </math>, so if the computer can analyse <math>1\times 10^9</math> configurations per second, then it will take <math>\frac{1.27\times 10^{30}}{10^9} = 1.27\times 10^{21} s</math> to analyse the whole system, which is longer than the age of the universe and therefore is not a practical approach.

===TASK: Implement a single cycle of the above algorithm in the montecarlocycle(T) function. This function should return the energy of your lattice and the magnetisation at the end of the cycle. You may assume that the energy returned by your energy() function is in units of <math>k_B</math>! Complete the statistics() function. This should return the following quantities whenever it is called: <math><E>, <E^2>, <M>, <M^2></math>, and the number of Monte Carlo steps that have elapsed.===
<pre>
E = []
E2 = []
M = []
M2 = []
n_cycles = 0

def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back if rejected else not changed

self.E+=[self.energy()] #records energy
self.E2+=[self.energy()**2] #records energy squared
self.M+=[self.magnetisation()] #records magnetisation
self.M2+=[self.magnetisation()**2] #records magnetisation squared
self.n_cycles=self.n_cycles+1 #adds 1 to run total

return (self.energy(),self.magnetisation())

def statistics(self):
# complete this function so that it calculates the correct values for the averages of E, E*E (E2), M, M*M (M2), and returns them

e=np.mean(self.E)
e2=np.mean(self.E2)
m=np.mean(self.M)
m2=np.mean(self.M2)

return e,e2,m,m2,self.n_cycles
</pre>

''Figure 3'' shows the results of a single run of the montecarlostep() function and the lattice the function operated upon.

[[File:cg1417MonteCarloStep_run.png|thumb|left|Figure 3 - Results from a single montecarlostep() function and the resulting lattice produced along with the correct return from the statistics() function]]

 

===TASK: If <math>T < T_C</math>, do you expect a spontaneous magnetisation (i.e. do you expect <math>\left\langle M\right\rangle \neq 0</math>)? When the state of the simulation appears to stop changing (when you have reached an equilibrium state), use the controls to export the output to PNG and attach this to your report. You should also include the output from your statistics() function.===

If the temperature of the system is less than the Curie Temperature, <math>T_C</math> then spontaneous magnetisation can occur and the system will tend to its lowest energy state where all of the spins are parallel - this is a property of ferromagnetic materials.

[[File:Cg1417ILanim_run.png|400px|thumb|left|Figure 4 - Results from running the ILanim.py file - shows the energy and magnetisation converging over time]]

''Figure 4'' shows that over time the the system spontaneously converges to the minimum energy state with all of the spins parallel to one another and shows, as I expected, that spontaneous magnetisation occurs and also shows that the temperature of this simulation is below the Curie Temperature, <math>T < T_C</math>.

 

==Section 4 - Accelerating the Code==

===TASK: Use the script ILtimetrial.py to record how long your current version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 5'' show the results of running the ILtimetrial.py file on my code three timesː

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1.png
| width1=500
| image2=cg1417ILtimetrial_run2.png
| width2=500
| image3=cg1417ILtimetrial_run3.png
| width3=500
| footer = Figure 5 - Results of running the ILtimetrial.py file on my code three separate times
}}
 

This gave me an avergage time of <math>24.3 s \pm 0.2s</math>

===TASK: Look at the documentation for the NumPy sum function. You should be able to modify your magnetisation() function so that it uses this to evaluate M. The energy is a little trickier. Familiarise yourself with the NumPy roll and multiply functions, and use these to replace your energy double loop (you will need to call roll and multiply twice!).===

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

left=multiply(roll(self.lattice,1,axis=1),self.lattice) #product of spin with spin left of it
top=multiply(roll(self.lattice,-1,axis=0),self.lattice) #product of spin with spin above it

int_en=sum(left+top) #sum of array containing sum of left and top spin products for each spin

energy = -sum(int_en) #calculates the total energy of system
return energy

def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
return sum(sum(self.lattice)) #adds up all spins in lattice
</pre>
The use of the bumpy modules reduces the amount of code required and removes the need for loops making the code significantly shorter, and is therefore expected to run ILtimetrial.py faster than the initial code developed.

===TASK: Use the script ILtimetrial.py to record how long your new version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 6'' shows the result of running the ILtimetrial.py on my new accelerated code.

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1fast.png
| width1=500
| image2=ILtimetrial_run2fast.png
| width2=500
| image3=ILtimetrial_run3fast.png
| width3=500
| footer = Figure 6 - Results of running the ILtimetrial.py file on my new updated and accelerated code.
}}
 

The accelerated code is much faster upon using the roll, multiply and sum modules with a new average time of <math>0.790 s \pm 0.005 </math>

==Section 5 - The effect of temperature==

===TASK: The script ILfinalframe.py runs for a given number of cycles at a given temperature, then plots a depiction of the final lattice state as well as graphs of the energy and magnetisation as a function of cycle number. This is much quicker than animating every frame! Experiment with different temperature and lattice sizes. How many cycles are typically needed for the system to go from its random starting position to the equilibrium state? Modify your statistics() and montecarlostep() functions so that the first N cycles of the simulation are ignored when calculating the averages. You should state in your report what period you chose to ignore, and include graphs from ILfinalframe.py to illustrate your motivation in choosing this figure.===

''Figure 7'' below shows the results from running the ILfinalframe.py for 2x2 lattice at T=1,2,3,5.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2T1.png
| image2 = cg14172x2T2.png
| image3 =cg14172x2T3.png
| image4 =cg14172x2T5.png
| footer_align = left
| footer = Figure 7 - Results of running the ILfinalframe.py file at T=1,2,3,5 for a 2x2 matrix.
}}

 

For a 2x2 matrix, a suitable cut-off point to exclude from the avergage energies and magnetisations is where the energy and magnetisations per spin are constant, which is 30 steps. For T=3 and T=5 the graphs do not converge because it is possible that these temperatures are higher than the Curie Temperature and as such spontaneous magnetisation will not occur and the system will not diverge to the lowest energy state. At the higher temperatures, there are larger thermal fluctations and the Boltzmann factor is more significant allowing the system to move away from the lowest energy state easier. As a result moving forwards, a suitable cut-off point will only be determined from T=1 and T=2 graphs for the larger matrices.

''Figure 8'' shows the results from running a 4x4 lattice at T=1,2 and 3.

{{multiple image
| width =350
| align = left
| image1 = cg14174x4T1.png
| image2 = cg14174x4T2.png
| image3 =cg14174x4T3.png
| footer_align = left
| footer = Figure 8 - Results of running the ILfinalframe.py file at T=1,2,3 for a 4x4 matrix.
}}

From ''Figure 8'', a suitable cut-off point for the energy and magnetisations is 200 as this is after where the energy and magnetisation has converged for T=1, and is after the initial large drop in energy for T=2, even though there are a few small fluctuations after 200 steps. The result from T=3 has been included to show the large fluctuations for the larger temperatures, and supporting my choice to determine the cut-off from T=1 and T=2 only.

''Figure 9'' shows the results for an 8x8 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg14178x8T1.png
| image2 = cg14178x8T2.png
| footer_align = left
| footer = Figure 9 - Results of running the ILfinalframe.py file at T=1,2 for an 8x8 matrix
}}

From ''Figure 9'' above, a suitable cut-off point is 1000 steps as this is where the energy and magnetisation has easily converged by and is also the point after which the initial large drop in energy has been overcome for T=2 too.

''Figure 10'' shows the result of running the ILfinalframe.py for a 16x16 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg141716x16T1.png
| image2 = cg141716x16T2.png
| footer_align = left
| footer = Figure 10 - Results of running the ILfinalframe.py file at T=1,2 for a 16x16 matrix
}}

From ''Figure 10'', a suitable cut-off point is 15000 steps as for T=1 the energy and magnetisations have converged significantly and will not change much, and likewise this is the same for the T=2 frame.

''Figure 11'' below shows the results from a 32x32 matrix at T=1 and T=2.

{{multiple image
| width =350
| align = left
| image1 = cg141732x32T1.png
| image2 = cg141732x32T2.png
| footer_align = left
| footer = Figure 11 - Results of running the ILfinalframe.py file at T=1,2 for a 32x32 matrix
}}

''Figure 11'' above shows the results of running the ILfinalframe.py file for a 32x32 matrix at T=1 and T=2. As a result a suitable cut-off of 50000 steps was chosen as the energy and magnetisation has significantly converged, but not as much as it could at 100000 steps. I chose a slightly lower value to ensure that the run times of my monte-carlo simulations in future tasks were not extremely time consuming.

The montecarlostep() function was changed by adding a condition that values only above the pre-determined cut-off were included when determining the average value of energy; energy squared; magnetisation and magnetisations squared from the statistics function. The statistics() function did not need to be modified.

The following code is from the 32x32 matrixː

<pre>def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back

if self.n_cycles > 50000: #only adds values to array of E,E2,M and M2 above the specific cut-off
self.E+=[self.energy()]
self.E2+=[self.energy()**2]
self.M+=[self.magnetisation()]
self.M2+=[self.magnetisation()**2]
self.n_cycles=self.n_cycles+1

return (self.energy(),self.magnetisation())
</pre>

===TASK: Use ILtemperaturerange.py to plot the average energy and magnetisation for each temperature, with error bars, for an <math>8\times 8</math> lattice. Use your intuition and results from the script ILfinalframe.py to estimate how many cycles each simulation should be. The temperature range 0.25 to 5.0 is sufficient. Use as many temperature points as you feel necessary to illustrate the trend, but do not use a temperature spacing larger than 0.5. The NumPy function savetxt() stores your array of output data on disk — you will need it later. Save the file as 8x8.dat so that you know which lattice size it came from.===

Using the modified code, the file ILtemperaturerange.py was ran on an 8x8 matrix between T=0.5 and T=5 with a step of T=0.02 for 10000 Montecarlo steps and the first 1000 steps of each temperature were excluded when calculating the averages. ''Figure 12'' shows the result of the simulation and also included error bars of standard deviation.

[[File:Cg14178x8error.png|1000px|thumb|left|Figure 12 - Graph showing average energy and average magnetisation for an 8x8 lattice with error bars between T=0.5 and T=5]]

 

Below is the source code for the script to produce the graphː

<pre>data8x8=np.loadtxt('8x8.dat') #loads data
temps8x8=data8x8[:,0] #stores temperatures
energies8x8=data8x8[:,1] #stores average energy for each T
energysq8x8=data8x8[:,2] #stores average energy squared for each T
mag8x8=data8x8[:,3] #stores magnetisation for each T
magsq8x8=data8x8[:,4] #stores magnetisation squared for each T
stde8x8=data8x8[:,5] #edited ILtemperaturerange.py to record the standard deviation of the energy for each T
stdm8x8=data8x8[:,6] #edited ILtemperaturerange.py to record the standard deviation of the magnetisation for each T

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.errorbar(temps8x8, np.array(energies8x8)/64,yerr=np.divide(stde8x8,64),color='black',ecolor='teal',alpha=0.8) #plots energy per spin against T
magax.errorbar(temps8x8, np.array(mag8x8)/64,yerr=np.divide(stdm8x8,64),alpha=0.8,ecolor='salmon',color='black') #plots magnetisation per spin against T on separate graph
pl.savefig('8x8error.png',bbox_inches='tight') #saves figure
pl.show()

</pre>

==Section 6 - The effect of system size==

===TASK: Repeat the final task of the previous section for the following lattice sizes: 2x2, 4x4, 8x8, 16x16, 32x32. Make sure that you name each datafile that your produce after the corresponding lattice size! Write a Python script to make a plot showing the energy per spin versus temperature for each of your lattice sizes. Hint: the NumPy loadtxt function is the reverse of the savetxt function, and can be used to read your previously saved files into the script. Repeat this for the magnetisation. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. How big a lattice do you think is big enough to capture the long range fluctuations?===

The python script for this section is identical as for the 8x8 graph above in Figure 12 with the relevant files and variables changed accordingly.

Each matrix was simulated using the ILtemperaturerange.py file between T=0.5 and T=5 with a step of T=0.02.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2error.png
| caption1 = 2x2 matrix - 5000 steps, cut-off = 30 steps
| image2 = 4x4error.png
| caption2 = 4x4 matrix - 1000 steps, cut-off = 200 steps
| image3 =cg141716x16error.png
| caption3 = 16x16 matrix - 50000 steps, cut-off = 15000 steps
| image4 =cg141732x32error.png
| caption4 = 32x32 matrix - 200000 steps, cut-off = 50000 steps
| footer_align = left
| footer = Figure 13 - Results of running the ILtemperaturerange.py file for 2x2, 4x4, 16x16 and 32x32 matrices.
}}

 

Long-range interactions are present and more significant in the smaller lattices where there are fewer stronger, short range interactions. As a result, I expect long-range interactions to be important in square lattices up to a 4x4 size.

==Section 7 - Determining the Heat Capacity==

===TASK: By definition, <math>C = \frac{\partial \left\langle E\right\rangle}{\partial T}</math>. From this, show that <math>C = \frac{\mathrm{Var}[E]}{k_B T^2}</math> (Where <math>\mathrm{Var}[E]</math> is the variance in <math>E</math>.)===

Recall from statistical thermodynamics that the average energy of a system is the sum across all microstates of the probability of that microstate multiplied by the energy of that microstate, which is defined mathematically asː <math>\langle E \rangle = \sum_i p_{i}\epsilon_{i}</math>.

The partition function <math>q</math> is defined as <math>q = \sum_{i} exp(-\beta \epsilon_{i})</math> where <math>\beta =\frac{1}{k_BT}</math>and the probability, <math>p_{i}</math> can be defined in terms of the partition function as <math>p_{i} = \frac{exp(-\beta \epsilon_{i})}{\sum_{i} exp(-\beta \epsilon_{i})} = \frac{exp(-\beta \epsilon_{i})}{q}</math>.

As a result, <math>\langle E \rangle</math> can be re-written as <math>\langle E \rangle = \sum_{i} \frac{\epsilon_{i} exp(-\beta \epsilon_{i})}{q} = -\frac{1}{q} \frac{\partial}{\partial \beta}\sum_{i}exp(-\beta \epsilon_{i}) = -\frac{1}{q} \frac{\partial q}{\partial \beta}</math>

Likewise, <math>\langle E^2 \rangle = \sum_i p_{i}\epsilon_{i}^{2} = \sum_{i} \frac{\epsilon_{i}^{2}exp(-\beta \epsilon_{i})}{q} = \frac{1}{q} \frac{\partial^{2}}{\partial \beta^{2}}\sum_{i}exp(-\beta \epsilon_{i}) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}}</math>

From definitionː <math>Var[E] = \Delta E^2 = \langle E^2 \rangle - \langle E \rangle^2 </math>

When the definition of <math>\langle E \rangle</math> and <math>\langle E^2 \rangle</math> is written in terms of partition function <math>q</math>ː <math>Var[E] = \langle E^2 \rangle - \langle E \rangle^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \left(\frac{1}{q}\frac{\partial q}{\partial \beta}\right)^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2</math>.

According to the chain ruleː <math>\frac{\partial}{\partial \beta}\left(\frac{1}{q} \frac{\partial q}{\partial \beta}\right) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2 = -\frac{\partial}{\partial \beta}\langle E \rangle = Var[E]</math>

And using the chain rule againː <math>C = \frac{\partial \langle E \rangle}{\partial T}= \left(-\frac{\partial \langle E \rangle}{\partial \beta}\right) \left(-\frac{\partial \beta}{\partial T}\right) = \frac{Var[E]}{k_B T^2}</math>

===TASK: Write a Python script to make a plot showing the heat capacity versus temperature for each of your lattice sizes from the previous section. You may need to do some research to recall the connection between the variance of a variable, <math>\mathrm{Var}[X]</math>, the mean of its square <math>\left\langle X^2\right\rangle</math>, and its squared mean <math>\left\langle X\right\rangle^2</math>. You may find that the data around the peak is very noisy — this is normal, and is a result of being in the critical region. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. ===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb

{{multiple image
| width =300
| align = left
| image1 = cg14172x2heatcap.png
| caption1 = 2x2 Matrix
| image2 = cg14174x4heatcap.png
| caption2 = 4x4 Matrix
| image3 =cg14178x8heatcap.png
| caption3 = 8x8 Matrix
| image4 =cg141716x16heatcap.png
| caption4 = 16x16 Matrix
| image5=cg141732x32heatcap.png
| caption5= 32x32 Matrix
| footer = Figure 14 - Graphs showing Heat Capacity against Temperature for each matrix size
}}

Here is the source code to produce the figuresː
<pre> def heatCap(energies,energysq,T,latsize):
#defines the heat capacity for a given temperature
energiesq=np.multiply(energies,energies) #creates array of (average energies) squared
varE=np.subtract(energysq,energiesq) #defines variance of average energy
tempsq=np.multiply(T,T) #array of temperature squared
return np.array(np.divide(varE,tempsq))/(latsize**2)

heatCap2x2=heatCap(energies2x2,energysq2x2,temps2x2,2) #creates array of heat capacity for each T

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(temps2x2,heatCap2x2,color='orange') #plots heat capacity for each T
pl.savefig('cg14172x2heatcap.png',bbox_inches='tight') #saves figure
pl.show()
</pre>

A general trend from the above graphs is that the peak of the graph shifts towards lower temperatures as the size of the matrix used increases which means the Curie Temperature decreases as matrix size increases. Also, as lattice size increases the noise around the peak becomes larger which will affect the accuracy of determining the maximum heat capacity and Curie Temperature for the larger lattices.

==Section 8 - Locating the Curie Temperature==
===TASK: A C++ program has been used to run some much longer simulations than would be possible on the college computers in Python. You can view its source code here if you are interested. Each file contains six columns: <math>T, E, E^2, M, M^2, C</math> (the final five quantities are per spin), and you can read them with the NumPy loadtxt function as before. For each lattice size, plot the C++ data against your data. For one lattice size, save a PNG of this comparison and add it to your report — add a legend to the graph to label which is which. To do this, you will need to pass the label="..." keyword to the plot function, then call the legend() function of the axis object (documentation here).===

The python code used to read and plot the C++ data is found in the Jupyter notebook CG1417IsingModelGraphs.ipynb.

''Figure 15'' below shows the C++ plotted against my own data for a 16x16 Matrix.

[[File:Cg141716x16C++.png|400px|thumb|left|Figure 15 - Graph showing my own data against the C++ data for a 16x16 matrix.]]

 

Here is the source code the produce the figuresː
<pre>#reads data from C++ file
temps2x2C=data2x2C[:,0]
energies2x2C=data2x2C[:,1]
energysq2x2C=data2x2C[:,2]
mag2x2C=data2x2C[:,3]
magsq2x2C=data2x2C[:,4]
heatcap2x2C=data2x2C[:,5]

#fitting C++ data

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.plot(temps2x2, np.array(energies2x2)/4,color='black',alpha=0.7,label='Python Data') #python energy against T
enerax.plot(temps2x2C, energies2x2C, color='red',label='C++ Data') #C energy against T
magax.plot(temps2x2, np.array(mag2x2)/4,color='black',alpha=0.7,label='Python Data') #python magnetisation against T
magax.plot(temps2x2C, mag2x2C,color='red',label='C++ Data') #C energy against T
enerax.legend() #shows legend on energy graph
magax.legend() #shows legend on energy graph
pl.show()
</pre>

The relevant variables and dat files were changed for each matrix.

===TASK: write a script to read the data from a particular file, and plot C vs T, as well as a fitted polynomial. Try changing the degree of the polynomial to improve the fit — in general, it might be difficult to get a good fit! Attach a PNG of an example fit to your report.===

The python script to read and plot the fitted polynomial is found in CG1417PolyfitScript.ipynb

Here is the source code for ''Figure 15''

<pre>data_test = np.loadtxt("16x16C.dat")
T_test = data_test[:,0] #gets temperatures
C_test = data_test[:,5] #gets heat capacity data

#first we fit the polynomial to the data
fit_test = np.polyfit(T_test, C_test, 35) # fit a polynomial

#now we generate interpolated values of the fitted polynomial over the range of our function
T_min_test = 0.5 #np.min(T_test)
T_max_test = 5 #np.max(T_test)

T_range_test = np.linspace(T_min_test, T_max_test, 1000) #generate 1000 evenly spaced points between T_min and T_max
fitted_C_values_test = np.polyval(fit_test, T_range_test)# use the fit object to generate the corresponding values of C

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(T_test,C_test,color='orange',label='C++ Data') #plots C data of heat capacity against temp
heatcapax.plot(T_range_test,fitted_C_values_test,label='Fitted Polynomial') #plots fitted polynomial for whole range of temp
heatcapax.legend()
pl.savefig('FIT_TEST16x16_35.png', bbox_inches='tight') #saves figure
pl.show()
</pre>

Below in ''Figure 16'' is a plot of my Heat Capacity against Temperature data for a 16x16 matrix and features a polynomial of degree 35 plotted against it. Even with a polynomial of such a high degree, it poorly fits the curve and does not fit to the peak of the curve either.

[[File:cg1417FIT_TEST16x16_35.png|thumb|left|400px|Figure 16 - Plot of Heat Capacity against Temperature along with a poorly fitted polynomial of degree 35. ]]

 

===TASK: Modify your script from the previous section. You should still plot the whole temperature range, but fit the polynomial only to the peak of the heat capacity! You should find it easier to get a good fit when restricted to this region===

The script was modified as such that the polynomial was fitted in a set range around the peak of the graph, this is demonstrated in ''Figure 17'' which shows a newly fitted polynomial between a much smaller range of temperatures (T = 2.15-2.55) and a much smaller degree polynomial (3).

[[File:CG1417FIT_16x16C_3.png|thumb|left|400px|Figure 17 - Graph showing Heat Capacity against Temperature for a 16x16 matrix along with a fitted polynomial between a much more restricted range of temperatures and a significantly lower degree of polynomial]]

Upon comparison with ''Figure 16'', the new fitted polynomial is a significantly better fit even for a 3rd degree polynomial and is a much more accurate representation of my data around the peak of the graph and will make it easier to determine the maximum value of Heat Capacity.

 

Here is the source code for ''Figure 17''ː
<pre>data16 = np.loadtxt("16x16C.dat") #loads data to variable

T16 = data16[:,0] #gets temps
C16 = data16[:,5] # gets heat capacities

Tmin16 = 2.15 #chosen min temp
Tmax16 = 2.55 #chosen max temp

selection16 = np.logical_and(T16 > Tmin16, T16 < Tmax16) #choose only those rows where both conditions are true
peak_T_values16 = T16[selection16] #choose temp values in range chosen above
peak_C_values16 = C16[selection16] #choose heat cap values in range of t above

fit16 = np.polyfit(peak_T_values16,peak_C_values16,3) #fit 3rd order polynomial
peak_T_range16 = np.linspace(Tmin16, Tmax16, 1000) #defines 1000 temps within data range
fitted_C_values16 = np.polyval(fit16, peak_T_range16) #use the fit object to get corresponding values of heat cap

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(T16,C16,color='orange',label='C++ Data') #plots C data of heat cap against temp
heatcapax.plot(peak_T_range16,fitted_C_values16,label='Fitted Polynomial') #plots fitted polynomial for small range
heatcapax.legend()
pl.savefig('FIT_16x16C_3.png', bbox_inches='tight') #saves figure
pl.show()

</pre>

===TASK: find the temperature at which the maximum in C occurs for each datafile that you were given. Make a text file containing two colums: the lattice side length (2,4,8, etc.), and the temperature at which C is a maximum. This is your estimate of <math>T_C</math> for that side length. Make a plot that uses the scaling relation given above to determine <math>T_{C,\infty}</math>. By doing a little research online, you should be able to find the theoretical exact Curie temperature for the infinite 2D Ising lattice. How does your value compare to this? Are you surprised by how good/bad the agreement is? Attach a PNG of this final graph to your report, and discuss briefly what you think the major sources of error are in your estimate.===

''Figure 18'' below shows a graph of <math>T_{C,L}</math> against <math>\frac{1}{Lattice Size}</math> to determine the Curie Temperature of an infinite 2D Ising Model Lattice <math>T_{C,\infty}</math>. The black dots represent the raw data obtained from obtaining the temperature at which the Heat Capacity was a maximum for the lattices and the red line in a linear curve fit plotted against the data to allow the y-intercept which is the Curie Temperature for the infinite 2D lattice to be determined.

[[File:cg1417CurieTemp.png|400px|thumb|left|Figure 18 - Plot of 1/Lattice Size against Curie Temperature for that lattice size.]]

The value for <math>T_{C,\inf}</math> obtained from the data is <math>T_{C,\infty} = 2.277 \frac{J}{k_B}</math> with a literature value being <math>T_{C,\infty} = 2.269 \frac{J}{k_B}</math> <ref>L. Onsager, Phys. Rev., 1944, 65, 117--149.</ref>for an infinite square 2D lattice. This means that my result slightly over-estimates the Curie Temperature for the infinite lattice and as a result for an infinite lattice the temperature at which spontaneous magnetisation stops would actually occur at a slightly lower temperature than expected. However, the difference between my value and the literature value is only 0.008 which is incredibly small and the amount of agreement between the two values is somewhat surprising, which means that the error in my estimates of the Curie Temperature for each lattice size is relatively small. The points which have the largest residuals and deviation from the line of best fit in ''Figure 17'' corresponds to the smaller lattice sizes of 2x2 and 4x4 where longer range interactions are more significant. The longer range interactions posed by the boundary conditions are nowhere near as significant for the larger sizes and causes the energy of the smaller matrices to be less accurate and have a larger associated error with the energy and thus the Curie Temperature for that lattice size. This affects the accuracy of the line of best fit and to increase the accuracy of this line, larger lattice sizes of 128x128, 256x256 etc should be included in the calculation for the line of best fit and the smaller matrices ignored.

 

Below is the source code used to generate ''Figure 18''
<pre>
Cmax64x64 = np.max(fitted_C_values64) #finds Cmax for 64x64 matrix - done for others already
Tmax64x64 = peak_T_range64[fitted_C_values64 == Cmax64x64] #finds Tmax corresponding to Cmax

LatSize=[2,4,8,16,32,64] #stores lattice sizes
Tmax=[Tmax2x2,Tmax4x4,Tmax8x8,Tmax16x16,Tmax32x32,Tmax64x64] #stores corresponding Tmax data
np.savetxt('CmaxVSTmax.txt', (LatSize,Tmax)) #writes data to txt file

ScalData=np.loadtxt('CmaxVSTmax.txt') #loads data
LatticeSize=ScalData[0] #gets lattice sizes
TempMax=ScalData[1] #gets max temp or curie temp for each lattice

Lmin1min = np.min(np.divide(1,LatticeSize)) #minimum of 1/LatticeSize values
Lmin1max = np.max(np.divide(1,LatticeSize)) #maximum of 1/LatticeSize values

fitTcl = np.polyfit(np.divide(1,LatticeSize),TempMax, 1) #creates fit object

Lmin1values = np.linspace(Lmin1min, Lmin1max, 1000) #finds 1000 values between min and max x-axis value of 1/LatticeSize
fitted_Tcl_values = np.polyval(fitTcl, Lmin1values) #creates corresponding Curie Temp values for each value in Lmin1values

fig = pl.figure()
scalrelax = fig.add_subplot(1,1,1)
scalrelax.set_xlabel('1/Lattice Size')
scalrelax.set_ylabel('Curie Temperature/ J/k_B')
scalrelax.plot(np.divide(1,LatticeSize),TempMax,color='black',marker='.',linestyle='') #plots Curie Temp against 1/LatticeSize
scalrelax.plot(Lmin1values,fitted_Tcl_values,color='red',marker='',linestyle='-') #plots line of best fit for data above
pl.savefig('CurieTemp.png', bbox_inches='tight') #saves figure
pl.show()

</pre>

== References ==

Rep:Y3CMPCG1417

2019-11-20T10:32:51Z

Cg1417: /* TASK: Write a Python script to make a plot showing the heat capacity versus temperature for each of your lattice sizes from the previous section. You may need to do some research to recall the connection between the variance of a variable, \mathrm{V...

==Section 1 - Introduction to the Ising Model==

===TASK: Show that the lowest possible energy for the Ising model is <math>E = -DNJ</math>, where D is the number of dimensions and N is the total number of spins. What is the multiplicity of this state? Calculate its entropy.===

Consider a 1D row of lattice sites of N=3 with spin configuration [+1][+1][+1].

Mathematically the interaction energy is defined asː
<math> -\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} </math> where J is a constant and <math>s_{i}s_{j}</math> is the product between two spins in adjacent lattice sites.

The sum of the interaction energies <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j}</math> can be considered as the sum of the individual interaction energies between spinsː
<math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = \epsilon_{12} + \epsilon_{23} + \epsilon_{13} + \epsilon_{21} + \epsilon_{32} + \epsilon_{31} </math>.

Although lattice sites 1 and 3 are not adjacent they are said to still interact according to the periodic boundary conditions applied.

However, <math>\epsilon_{12} = \epsilon_{21} </math> and <math>\epsilon_{23} = \epsilon_{32}</math> and <math>\epsilon_{13} = \epsilon_{31}</math> which means that all of the interactions within the system are counted twice, hence the total energy needs to be halved, resulting in the following formula being obtainedː <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = 2\epsilon_{12} + 2\epsilon_{13} + 2\epsilon_{23} </math>.

It can be determined that <math>\epsilon_{12} = (+1)(+1) = 1</math> , <math>\epsilon_{13} = (+1)(+1) = 1</math> and <math>\epsilon_{23} = (+1)(+1) = 1</math>.

Thereforeː <math>-\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = -\frac{1}{2} \ J \ (2 + 2 + 2) = -\frac{1}{2} \ J \ 6 = - 3 J = -DNJ</math> for a 1D lattice with <math>D=1</math> and 3 lattice sites <math>N=3</math>

The multiplicity of the system,<math>\Omega = \frac{lattice sites!}{n. spin up!n. spin down!}</math>

Entropy, <math>S</math> is defined as <math>S = k_B ln(\Omega)</math> and so in this case <math>S = k_B ln(\frac{100!}{100!}) = 0</math>

===TASK: Imagine that the system is in the lowest energy configuration. To move to a different state, one of the spins must spontaneously change direction ("flip"). What is the change in energy if this happens <math>(D=3, N=1000)</math>? How much entropy does the system gain by doing soʔ===

In a 3D lattice system, each lattice site has three unique interactions with its neighbours to its left, top and front. In the lowest energy configuration, all spins are parallel and for a system the minimum energy is <math>E = -DNJ</math>, so for the system with <math>N=1000</math> and <math>D=3</math>, the minimum energy is <math>-3000J</math>.

If a single spin is flipped, the product of its spin with its neighbours spin reverses and becomes negative and this increases the total energy of the system. Since 3 unique spin-spin interactions are reversed in sign, the total energy increases by <math>+3J</math>, meaning the new total energy is <math>-2997J</math>

Initially the multiplicity of the system will be <math>\Omega = \frac{1000!}{1000!}</math> , and after the flip, the multiplicity becomes <math> \Omega = \frac{1000!}{999!1!}=1000</math>.

The associated change in entropy, <math>\Delta S = k_B ln(1000) - 0 = 6.91 k_B</math>, which is an expected increase in entropy as the number of possible configurations of the system increases.

===TASK: Calculate the magnetisation of the 1D and 2D lattices in Figure 1. What magnetisation would you expect to observe for an Ising lattice with <math>D = 3,\ N=1000</math> at absolute zero?===

[[File:ThirdYearCMPExpt-IsingSketch.png|thumb|left|Figure 1 - Shows 1D (N = 5), 2D (N = 5x5) and 3D (N = 5x5x5) lattices.]]

Magnetisation is defined as <math>M=\sum_{i} s_i</math>. So for the 1D lattice with <math>N = 5</math> in ''Figure 2'', <math>M = +1</math> and for the 2D lattice with <math>N = 25 , M = +1</math> too.

According to the 3rd Law of thermodynamics, entropy is 0 at absolute zero for a perfect crystalline solid, and consequently it is expected that the lattices will have follow suit and have zero entropy at 0K. To have zero entropy all spins must be parallel as such that magnetisation, <math>M = N</math>. For all the spins to be parallel, there is only one possible configuration. So, for a lattice with <math>N = 1000</math> and <math>D =3</math>, if <math>M = N</math>, then multiplicity, <math>\Omega = 1</math> and entropy, <math>S =k_B ln(1) = 0</math>.

 

==Section 2 - Calculating the Energy and Magnetisation==

===TASK: complete the functions energy() and magnetisation(), which should return the energy of the lattice and the total magnetisation, respectively. In the energy() function you may assume that <math>J=1.0</math> at all times (in fact, we are working in reduced units in which <math>J=k_B</math>, but there will be more information about this in later sections). Do not worry about the efficiency of the code at the moment — we will address the speed in a later part of the experiment.===

<pre>def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
lat=self.lattice #creates lattice and stores it
mag=[]
for i in range(0,len(lat)): #loops through all rows of lattice
for j in range(0,len(lat[i])): #loops through elements of each row
mag+=[lat[i][j]] #adds spin value to mag array
return sum(mag) #sums all spins from mag array
</pre>

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

lat=self.lattice #creates lattice and stores it
left=[]
top=[]

for i in range(0,len(lat)):
for j in range(0,len(lat[i])):
left+=[lat[i][j]*lat[i][j-1]] #multiplies spin by spin to left
top+=[lat[i][j]*lat[i-1][j]] #multiplies spin by spin above it
int_en=left+top #sums spin products from left and top
energy=-sum(int_en) #sums all spin products for each spin to give total

return energy
</pre>

===TASK: Run the ILcheck.py script from the IPython Qt console using the command===

''Figure 2'' shows the results when ILcheck.py was ran on my IsingLattice.py file. The ILcheck.py file was ran several times to ensure the code worked for various random lattices.

[[File:Cg1417ILcheck run.png|thumb|left|500px| Figure 2 - Result from running the ILcheck.py file]]

 

==Section 3 - Introduction to Monte Carlo Simulation==

===TASK: How many configurations are available to a system with 100 spins? To evaluate these expressions, we have to calculate the energy and magnetisation for each of these configurations, then perform the sum. Let's be very, very, generous, and say that we can analyse <math>1\times 10^9</math> configurations per second with our computer. How long will it take to evaluate a single value of <math>\left\langle M\right\rangle_T</math>?===

For a system with 100 lattice sites and two possible spins for each site, there are <math>2^{100}</math>possible configurations for the system. <math>2^{100}= 1.27\times 10^{30} </math>, so if the computer can analyse <math>1\times 10^9</math> configurations per second, then it will take <math>\frac{1.27\times 10^{30}}{10^9} = 1.27\times 10^{21} s</math> to analyse the whole system, which is longer than the age of the universe and therefore is not a practical approach.

===TASK: Implement a single cycle of the above algorithm in the montecarlocycle(T) function. This function should return the energy of your lattice and the magnetisation at the end of the cycle. You may assume that the energy returned by your energy() function is in units of <math>k_B</math>! Complete the statistics() function. This should return the following quantities whenever it is called: <math><E>, <E^2>, <M>, <M^2></math>, and the number of Monte Carlo steps that have elapsed.===
<pre>
E = []
E2 = []
M = []
M2 = []
n_cycles = 0

def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back if rejected else not changed

self.E+=[self.energy()] #records energy
self.E2+=[self.energy()**2] #records energy squared
self.M+=[self.magnetisation()] #records magnetisation
self.M2+=[self.magnetisation()**2] #records magnetisation squared
self.n_cycles=self.n_cycles+1 #adds 1 to run total

return (self.energy(),self.magnetisation())

def statistics(self):
# complete this function so that it calculates the correct values for the averages of E, E*E (E2), M, M*M (M2), and returns them

e=np.mean(self.E)
e2=np.mean(self.E2)
m=np.mean(self.M)
m2=np.mean(self.M2)

return e,e2,m,m2,self.n_cycles
</pre>

''Figure 3'' shows the results of a single run of the montecarlostep() function and the lattice the function operated upon.

[[File:cg1417MonteCarloStep_run.png|thumb|left|Figure 3 - Results from a single montecarlostep() function and the resulting lattice produced along with the correct return from the statistics() function]]

 

===TASK: If <math>T < T_C</math>, do you expect a spontaneous magnetisation (i.e. do you expect <math>\left\langle M\right\rangle \neq 0</math>)? When the state of the simulation appears to stop changing (when you have reached an equilibrium state), use the controls to export the output to PNG and attach this to your report. You should also include the output from your statistics() function.===

If the temperature of the system is less than the Curie Temperature, <math>T_C</math> then spontaneous magnetisation can occur and the system will tend to its lowest energy state where all of the spins are parallel - this is a property of ferromagnetic materials.

[[File:Cg1417ILanim_run.png|400px|thumb|left|Figure 4 - Results from running the ILanim.py file - shows the energy and magnetisation converging over time]]

''Figure 4'' shows that over time the the system spontaneously converges to the minimum energy state with all of the spins parallel to one another and shows, as I expected, that spontaneous magnetisation occurs and also shows that the temperature of this simulation is below the Curie Temperature, <math>T < T_C</math>.

 

==Section 4 - Accelerating the Code==

===TASK: Use the script ILtimetrial.py to record how long your current version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 5'' show the results of running the ILtimetrial.py file on my code three timesː

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1.png
| width1=500
| image2=cg1417ILtimetrial_run2.png
| width2=500
| image3=cg1417ILtimetrial_run3.png
| width3=500
| footer = Figure 5 - Results of running the ILtimetrial.py file on my code three separate times
}}
 

This gave me an avergage time of <math>24.3 s \pm 0.2s</math>

===TASK: Look at the documentation for the NumPy sum function. You should be able to modify your magnetisation() function so that it uses this to evaluate M. The energy is a little trickier. Familiarise yourself with the NumPy roll and multiply functions, and use these to replace your energy double loop (you will need to call roll and multiply twice!).===

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

left=multiply(roll(self.lattice,1,axis=1),self.lattice) #product of spin with spin left of it
top=multiply(roll(self.lattice,-1,axis=0),self.lattice) #product of spin with spin above it

int_en=sum(left+top) #sum of array containing sum of left and top spin products for each spin

energy = -sum(int_en) #calculates the total energy of system
return energy

def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
return sum(sum(self.lattice)) #adds up all spins in lattice
</pre>
The use of the bumpy modules reduces the amount of code required and removes the need for loops making the code significantly shorter, and is therefore expected to run ILtimetrial.py faster than the initial code developed.

===TASK: Use the script ILtimetrial.py to record how long your new version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 6'' shows the result of running the ILtimetrial.py on my new accelerated code.

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1fast.png
| width1=500
| image2=ILtimetrial_run2fast.png
| width2=500
| image3=ILtimetrial_run3fast.png
| width3=500
| footer = Figure 6 - Results of running the ILtimetrial.py file on my new updated and accelerated code.
}}
 

The accelerated code is much faster upon using the roll, multiply and sum modules with a new average time of <math>0.790 s \pm 0.005 </math>

==Section 5 - The effect of temperature==

===TASK: The script ILfinalframe.py runs for a given number of cycles at a given temperature, then plots a depiction of the final lattice state as well as graphs of the energy and magnetisation as a function of cycle number. This is much quicker than animating every frame! Experiment with different temperature and lattice sizes. How many cycles are typically needed for the system to go from its random starting position to the equilibrium state? Modify your statistics() and montecarlostep() functions so that the first N cycles of the simulation are ignored when calculating the averages. You should state in your report what period you chose to ignore, and include graphs from ILfinalframe.py to illustrate your motivation in choosing this figure.===

''Figure 7'' below shows the results from running the ILfinalframe.py for 2x2 lattice at T=1,2,3,5.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2T1.png
| image2 = cg14172x2T2.png
| image3 =cg14172x2T3.png
| image4 =cg14172x2T5.png
| footer_align = left
| footer = Figure 7 - Results of running the ILfinalframe.py file at T=1,2,3,5 for a 2x2 matrix.
}}

 

For a 2x2 matrix, a suitable cut-off point to exclude from the avergage energies and magnetisations is where the energy and magnetisations per spin are constant, which is 30 steps. For T=3 and T=5 the graphs do not converge because it is possible that these temperatures are higher than the Curie Temperature and as such spontaneous magnetisation will not occur and the system will not diverge to the lowest energy state. At the higher temperatures, there are larger thermal fluctations and the Boltzmann factor is more significant allowing the system to move away from the lowest energy state easier. As a result moving forwards, a suitable cut-off point will only be determined from T=1 and T=2 graphs for the larger matrices.

''Figure 8'' shows the results from running a 4x4 lattice at T=1,2 and 3.

{{multiple image
| width =350
| align = left
| image1 = cg14174x4T1.png
| image2 = cg14174x4T2.png
| image3 =cg14174x4T3.png
| footer_align = left
| footer = Figure 8 - Results of running the ILfinalframe.py file at T=1,2,3 for a 4x4 matrix.
}}

From ''Figure 8'', a suitable cut-off point for the energy and magnetisations is 200 as this is after where the energy and magnetisation has converged for T=1, and is after the initial large drop in energy for T=2, even though there are a few small fluctuations after 200 steps. The result from T=3 has been included to show the large fluctuations for the larger temperatures, and supporting my choice to determine the cut-off from T=1 and T=2 only.

''Figure 9'' shows the results for an 8x8 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg14178x8T1.png
| image2 = cg14178x8T2.png
| footer_align = left
| footer = Figure 9 - Results of running the ILfinalframe.py file at T=1,2 for an 8x8 matrix
}}

From ''Figure 9'' above, a suitable cut-off point is 1000 steps as this is where the energy and magnetisation has easily converged by and is also the point after which the initial large drop in energy has been overcome for T=2 too.

''Figure 10'' shows the result of running the ILfinalframe.py for a 16x16 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg141716x16T1.png
| image2 = cg141716x16T2.png
| footer_align = left
| footer = Figure 10 - Results of running the ILfinalframe.py file at T=1,2 for a 16x16 matrix
}}

From ''Figure 10'', a suitable cut-off point is 15000 steps as for T=1 the energy and magnetisations have converged significantly and will not change much, and likewise this is the same for the T=2 frame.

''Figure 11'' below shows the results from a 32x32 matrix at T=1 and T=2.

{{multiple image
| width =350
| align = left
| image1 = cg141732x32T1.png
| image2 = cg141732x32T2.png
| footer_align = left
| footer = Figure 11 - Results of running the ILfinalframe.py file at T=1,2 for a 32x32 matrix
}}

''Figure 11'' above shows the results of running the ILfinalframe.py file for a 32x32 matrix at T=1 and T=2. As a result a suitable cut-off of 50000 steps was chosen as the energy and magnetisation has significantly converged, but not as much as it could at 100000 steps. I chose a slightly lower value to ensure that the run times of my monte-carlo simulations in future tasks were not extremely time consuming.

The montecarlostep() function was changed by adding a condition that values only above the pre-determined cut-off were included when determining the average value of energy; energy squared; magnetisation and magnetisations squared from the statistics function. The statistics() function did not need to be modified.

The following code is from the 32x32 matrixː

<pre>def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back

if self.n_cycles > 50000: #only adds values to array of E,E2,M and M2 above the specific cut-off
self.E+=[self.energy()]
self.E2+=[self.energy()**2]
self.M+=[self.magnetisation()]
self.M2+=[self.magnetisation()**2]
self.n_cycles=self.n_cycles+1

return (self.energy(),self.magnetisation())
</pre>

===TASK: Use ILtemperaturerange.py to plot the average energy and magnetisation for each temperature, with error bars, for an <math>8\times 8</math> lattice. Use your intuition and results from the script ILfinalframe.py to estimate how many cycles each simulation should be. The temperature range 0.25 to 5.0 is sufficient. Use as many temperature points as you feel necessary to illustrate the trend, but do not use a temperature spacing larger than 0.5. The NumPy function savetxt() stores your array of output data on disk — you will need it later. Save the file as 8x8.dat so that you know which lattice size it came from.===

Using the modified code, the file ILtemperaturerange.py was ran on an 8x8 matrix between T=0.5 and T=5 with a step of T=0.02 for 10000 Montecarlo steps and the first 1000 steps of each temperature were excluded when calculating the averages. ''Figure 12'' shows the result of the simulation and also included error bars of standard deviation.

[[File:Cg14178x8error.png|1000px|thumb|left|Figure 12 - Graph showing average energy and average magnetisation for an 8x8 lattice with error bars between T=0.5 and T=5]]

 

Below is the source code for the script to produce the graphː

<pre>data8x8=np.loadtxt('8x8.dat') #loads data
temps8x8=data8x8[:,0] #stores temperatures
energies8x8=data8x8[:,1] #stores average energy for each T
energysq8x8=data8x8[:,2] #stores average energy squared for each T
mag8x8=data8x8[:,3] #stores magnetisation for each T
magsq8x8=data8x8[:,4] #stores magnetisation squared for each T
stde8x8=data8x8[:,5] #edited ILtemperaturerange.py to record the standard deviation of the energy for each T
stdm8x8=data8x8[:,6] #edited ILtemperaturerange.py to record the standard deviation of the magnetisation for each T

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.errorbar(temps8x8, np.array(energies8x8)/64,yerr=np.divide(stde8x8,64),color='black',ecolor='teal',alpha=0.8) #plots energy per spin against T
magax.errorbar(temps8x8, np.array(mag8x8)/64,yerr=np.divide(stdm8x8,64),alpha=0.8,ecolor='salmon',color='black') #plots magnetisation per spin against T on separate graph
pl.savefig('8x8error.png',bbox_inches='tight') #saves figure
pl.show()

</pre>

==Section 6 - The effect of system size==

===TASK: Repeat the final task of the previous section for the following lattice sizes: 2x2, 4x4, 8x8, 16x16, 32x32. Make sure that you name each datafile that your produce after the corresponding lattice size! Write a Python script to make a plot showing the energy per spin versus temperature for each of your lattice sizes. Hint: the NumPy loadtxt function is the reverse of the savetxt function, and can be used to read your previously saved files into the script. Repeat this for the magnetisation. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. How big a lattice do you think is big enough to capture the long range fluctuations?===

The python script for this section is identical as for the 8x8 graph above in Figure 12 with the relevant files and variables changed accordingly.

Each matrix was simulated using the ILtemperaturerange.py file between T=0.5 and T=5 with a step of T=0.02.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2error.png
| caption1 = 2x2 matrix - 5000 steps, cut-off = 30 steps
| image2 = 4x4error.png
| caption2 = 4x4 matrix - 1000 steps, cut-off = 200 steps
| image3 =cg141716x16error.png
| caption3 = 16x16 matrix - 50000 steps, cut-off = 15000 steps
| image4 =cg141732x32error.png
| caption4 = 32x32 matrix - 200000 steps, cut-off = 50000 steps
| footer_align = left
| footer = Figure 13 - Results of running the ILtemperaturerange.py file for 2x2, 4x4, 16x16 and 32x32 matrices.
}}

 

Long-range interactions are present and more significant in the smaller lattices where there are fewer stronger, short range interactions. As a result, I expect long-range interactions to be important in square lattices up to a 4x4 size.

==Section 7 - Determining the Heat Capacity==

===TASK: By definition, <math>C = \frac{\partial \left\langle E\right\rangle}{\partial T}</math>. From this, show that <math>C = \frac{\mathrm{Var}[E]}{k_B T^2}</math> (Where <math>\mathrm{Var}[E]</math> is the variance in <math>E</math>.)===

Recall from statistical thermodynamics that the average energy of a system is the sum across all microstates of the probability of that microstate multiplied by the energy of that microstate, which is defined mathematically asː <math>\langle E \rangle = \sum_i p_{i}\epsilon_{i}</math>.

The partition function <math>q</math> is defined as <math>q = \sum_{i} exp(-\beta \epsilon_{i})</math> where <math>\beta =\frac{1}{k_BT}</math>and the probability, <math>p_{i}</math> can be defined in terms of the partition function as <math>p_{i} = \frac{exp(-\beta \epsilon_{i})}{\sum_{i} exp(-\beta \epsilon_{i})} = \frac{exp(-\beta \epsilon_{i})}{q}</math>.

As a result, <math>\langle E \rangle</math> can be re-written as <math>\langle E \rangle = \sum_{i} \frac{\epsilon_{i} exp(-\beta \epsilon_{i})}{q} = -\frac{1}{q} \frac{\partial}{\partial \beta}\sum_{i}exp(-\beta \epsilon_{i}) = -\frac{1}{q} \frac{\partial q}{\partial \beta}</math>

Likewise, <math>\langle E^2 \rangle = \sum_i p_{i}\epsilon_{i}^{2} = \sum_{i} \frac{\epsilon_{i}^{2}exp(-\beta \epsilon_{i})}{q} = \frac{1}{q} \frac{\partial^{2}}{\partial \beta^{2}}\sum_{i}exp(-\beta \epsilon_{i}) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}}</math>

From definitionː <math>Var[E] = \Delta E^2 = \langle E^2 \rangle - \langle E \rangle^2 </math>

When the definition of <math>\langle E \rangle</math> and <math>\langle E^2 \rangle</math> is written in terms of partition function <math>q</math>ː <math>Var[E] = \langle E^2 \rangle - \langle E \rangle^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \left(\frac{1}{q}\frac{\partial q}{\partial \beta}\right)^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2</math>.

According to the chain ruleː <math>\frac{\partial}{\partial \beta}\left(\frac{1}{q} \frac{\partial q}{\partial \beta}\right) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2 = -\frac{\partial}{\partial \beta}\langle E \rangle = Var[E]</math>

And using the chain rule againː <math>C = \frac{\partial \langle E \rangle}{\partial T}= \left(-\frac{\partial \langle E \rangle}{\partial \beta}\right) \left(-\frac{\partial \beta}{\partial T}\right) = \frac{Var[E]}{k_B T^2}</math>

===TASK: Write a Python script to make a plot showing the heat capacity versus temperature for each of your lattice sizes from the previous section. You may need to do some research to recall the connection between the variance of a variable, <math>\mathrm{Var}[X]</math>, the mean of its square <math>\left\langle X^2\right\rangle</math>, and its squared mean <math>\left\langle X\right\rangle^2</math>. You may find that the data around the peak is very noisy — this is normal, and is a result of being in the critical region. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. ===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb

{{multiple image
| width =300
| align = left
| image1 = cg14172x2heatcap.png
| caption1 = 2x2 Matrix
| image2 = cg14174x4heatcap.png
| caption2 = 4x4 Matrix
| image3 =cg14178x8heatcap.png
| caption3 = 8x8 Matrix
| image4 =cg141716x16heatcap.png
| caption4 = 16x16 Matrix
| image5=cg141732x32heatcap.png
| caption5= 32x32 Matrix
| footer = Figure 14 - Graphs showing Heat Capacity against Temperature for each matrix size
}}

Here is the source code to produce the figuresː
<pre> def heatCap(energies,energysq,T,latsize):
#defines the heat capacity for a given temperature
energiesq=np.multiply(energies,energies) #creates array of (average energies) squared
varE=np.subtract(energysq,energiesq) #defines variance of average energy
tempsq=np.multiply(T,T) #array of temperature squared
return np.array(np.divide(varE,tempsq))/(latsize**2)

heatCap2x2=heatCap(energies2x2,energysq2x2,temps2x2,2) #creates array of heat capacity for each T

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(temps2x2,heatCap2x2,color='orange') #plots heat capacity for each T
pl.savefig('cg14172x2heatcap.png',bbox_inches='tight') #saves figure
pl.show()
</pre>

A general trend from the above graphs is that the peak of the graph shifts towards lower temperatures as the size of the matrix used increases which means the Curie Temperature decreases as matrix size increases. Also, as lattice size increases the noise around the peak becomes larger which will affect the accuracy of determining the maximum heat capacity and Curie Temperature for the larger lattices.

==Section 8 - Locating the Curie Temperature==
===TASK: A C++ program has been used to run some much longer simulations than would be possible on the college computers in Python. You can view its source code here if you are interested. Each file contains six columns: <math>T, E, E^2, M, M^2, C</math> (the final five quantities are per spin), and you can read them with the NumPy loadtxt function as before. For each lattice size, plot the C++ data against your data. For one lattice size, save a PNG of this comparison and add it to your report — add a legend to the graph to label which is which. To do this, you will need to pass the label="..." keyword to the plot function, then call the legend() function of the axis object (documentation here).===

The python code used to read and plot the C++ data is found in the Jupyter notebook CG1417IsingModelGraphs.ipynb.

''Figure 15'' below shows the C++ plotted against my own data for a 16x16 Matrix.

[[File:Cg141716x16C++.png|400px|thumb|left|Figure 15 - Graph showing my own data against the C++ data for a 16x16 matrix.]]

 

Here is the source code the produce the figuresː
<pre>#fitting C++ data

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.plot(temps2x2, np.array(energies2x2)/4,color='black',alpha=0.7,label='Python Data') #python energy against T
enerax.plot(temps2x2C, energies2x2C, color='red',label='C++ Data') #C energy against T
magax.plot(temps2x2, np.array(mag2x2)/4,color='black',alpha=0.7,label='Python Data') #python magnetisation against T
magax.plot(temps2x2C, mag2x2C,color='red',label='C++ Data') #C energy against T
enerax.legend() #shows legend on energy graph
magax.legend() #shows legend on energy graph
pl.show()
</pre>

The relevant variables and dat files were changed for each matrix.

===TASK: write a script to read the data from a particular file, and plot C vs T, as well as a fitted polynomial. Try changing the degree of the polynomial to improve the fit — in general, it might be difficult to get a good fit! Attach a PNG of an example fit to your report.===

The python script to read and plot the fitted polynomial is found in CG1417PolyfitScript.ipynb

Here is the source code for ''Figure 15''

<pre>data_test = np.loadtxt("16x16C.dat")
T_test = data_test[:,0] #gets temperatures
C_test = data_test[:,5] #gets heat capacity data

#first we fit the polynomial to the data
fit_test = np.polyfit(T_test, C_test, 35) # fit a polynomial

#now we generate interpolated values of the fitted polynomial over the range of our function
T_min_test = 0.5 #np.min(T_test)
T_max_test = 5 #np.max(T_test)

T_range_test = np.linspace(T_min_test, T_max_test, 1000) #generate 1000 evenly spaced points between T_min and T_max
fitted_C_values_test = np.polyval(fit_test, T_range_test)# use the fit object to generate the corresponding values of C

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(T_test,C_test,color='orange',label='C++ Data') #plots C data of heat capacity against temp
heatcapax.plot(T_range_test,fitted_C_values_test,label='Fitted Polynomial') #plots fitted polynomial for whole range of temp
heatcapax.legend()
pl.savefig('FIT_TEST16x16_35.png', bbox_inches='tight') #saves figure
pl.show()
</pre>

Below in ''Figure 16'' is a plot of my Heat Capacity against Temperature data for a 16x16 matrix and features a polynomial of degree 35 plotted against it. Even with a polynomial of such a high degree, it poorly fits the curve and does not fit to the peak of the curve either.

[[File:cg1417FIT_TEST16x16_35.png|thumb|left|400px|Figure 16 - Plot of Heat Capacity against Temperature along with a poorly fitted polynomial of degree 35. ]]

 

===TASK: Modify your script from the previous section. You should still plot the whole temperature range, but fit the polynomial only to the peak of the heat capacity! You should find it easier to get a good fit when restricted to this region===

The script was modified as such that the polynomial was fitted in a set range around the peak of the graph, this is demonstrated in ''Figure 17'' which shows a newly fitted polynomial between a much smaller range of temperatures (T = 2.15-2.55) and a much smaller degree polynomial (3).

[[File:CG1417FIT_16x16C_3.png|thumb|left|400px|Figure 17 - Graph showing Heat Capacity against Temperature for a 16x16 matrix along with a fitted polynomial between a much more restricted range of temperatures and a significantly lower degree of polynomial]]

Upon comparison with ''Figure 16'', the new fitted polynomial is a significantly better fit even for a 3rd degree polynomial and is a much more accurate representation of my data around the peak of the graph and will make it easier to determine the maximum value of Heat Capacity.

 

Here is the source code for ''Figure 17''ː
<pre>data16 = np.loadtxt("16x16C.dat") #loads data to variable

T16 = data16[:,0] #gets temps
C16 = data16[:,5] # gets heat capacities

Tmin16 = 2.15 #chosen min temp
Tmax16 = 2.55 #chosen max temp

selection16 = np.logical_and(T16 > Tmin16, T16 < Tmax16) #choose only those rows where both conditions are true
peak_T_values16 = T16[selection16] #choose temp values in range chosen above
peak_C_values16 = C16[selection16] #choose heat cap values in range of t above

fit16 = np.polyfit(peak_T_values16,peak_C_values16,3) #fit 3rd order polynomial
peak_T_range16 = np.linspace(Tmin16, Tmax16, 1000) #defines 1000 temps within data range
fitted_C_values16 = np.polyval(fit16, peak_T_range16) #use the fit object to get corresponding values of heat cap

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(T16,C16,color='orange',label='C++ Data') #plots C data of heat cap against temp
heatcapax.plot(peak_T_range16,fitted_C_values16,label='Fitted Polynomial') #plots fitted polynomial for small range
heatcapax.legend()
pl.savefig('FIT_16x16C_3.png', bbox_inches='tight') #saves figure
pl.show()

</pre>

===TASK: find the temperature at which the maximum in C occurs for each datafile that you were given. Make a text file containing two colums: the lattice side length (2,4,8, etc.), and the temperature at which C is a maximum. This is your estimate of <math>T_C</math> for that side length. Make a plot that uses the scaling relation given above to determine <math>T_{C,\infty}</math>. By doing a little research online, you should be able to find the theoretical exact Curie temperature for the infinite 2D Ising lattice. How does your value compare to this? Are you surprised by how good/bad the agreement is? Attach a PNG of this final graph to your report, and discuss briefly what you think the major sources of error are in your estimate.===

''Figure 18'' below shows a graph of <math>T_{C,L}</math> against <math>\frac{1}{Lattice Size}</math> to determine the Curie Temperature of an infinite 2D Ising Model Lattice <math>T_{C,\infty}</math>. The black dots represent the raw data obtained from obtaining the temperature at which the Heat Capacity was a maximum for the lattices and the red line in a linear curve fit plotted against the data to allow the y-intercept which is the Curie Temperature for the infinite 2D lattice to be determined.

[[File:cg1417CurieTemp.png|400px|thumb|left|Figure 18 - Plot of 1/Lattice Size against Curie Temperature for that lattice size.]]

The value for <math>T_{C,\inf}</math> obtained from the data is <math>T_{C,\infty} = 2.277 \frac{J}{k_B}</math> with a literature value being <math>T_{C,\infty} = 2.269 \frac{J}{k_B}</math> <ref>L. Onsager, Phys. Rev., 1944, 65, 117--149.</ref>for an infinite square 2D lattice. This means that my result slightly over-estimates the Curie Temperature for the infinite lattice and as a result for an infinite lattice the temperature at which spontaneous magnetisation stops would actually occur at a slightly lower temperature than expected. However, the difference between my value and the literature value is only 0.008 which is incredibly small and the amount of agreement between the two values is somewhat surprising, which means that the error in my estimates of the Curie Temperature for each lattice size is relatively small. The points which have the largest residuals and deviation from the line of best fit in ''Figure 17'' corresponds to the smaller lattice sizes of 2x2 and 4x4 where longer range interactions are more significant. The longer range interactions posed by the boundary conditions are nowhere near as significant for the larger sizes and causes the energy of the smaller matrices to be less accurate and have a larger associated error with the energy and thus the Curie Temperature for that lattice size. This affects the accuracy of the line of best fit and to increase the accuracy of this line, larger lattice sizes of 128x128, 256x256 etc should be included in the calculation for the line of best fit and the smaller matrices ignored.

 

Below is the source code used to generate ''Figure 18''
<pre>
Cmax64x64 = np.max(fitted_C_values64) #finds Cmax for 64x64 matrix - done for others already
Tmax64x64 = peak_T_range64[fitted_C_values64 == Cmax64x64] #finds Tmax corresponding to Cmax

LatSize=[2,4,8,16,32,64] #stores lattice sizes
Tmax=[Tmax2x2,Tmax4x4,Tmax8x8,Tmax16x16,Tmax32x32,Tmax64x64] #stores corresponding Tmax data
np.savetxt('CmaxVSTmax.txt', (LatSize,Tmax)) #writes data to txt file

ScalData=np.loadtxt('CmaxVSTmax.txt') #loads data
LatticeSize=ScalData[0] #gets lattice sizes
TempMax=ScalData[1] #gets max temp or curie temp for each lattice

Lmin1min = np.min(np.divide(1,LatticeSize)) #minimum of 1/LatticeSize values
Lmin1max = np.max(np.divide(1,LatticeSize)) #maximum of 1/LatticeSize values

fitTcl = np.polyfit(np.divide(1,LatticeSize),TempMax, 1) #creates fit object

Lmin1values = np.linspace(Lmin1min, Lmin1max, 1000) #finds 1000 values between min and max x-axis value of 1/LatticeSize
fitted_Tcl_values = np.polyval(fitTcl, Lmin1values) #creates corresponding Curie Temp values for each value in Lmin1values

fig = pl.figure()
scalrelax = fig.add_subplot(1,1,1)
scalrelax.set_xlabel('1/Lattice Size')
scalrelax.set_ylabel('Curie Temperature/ J/k_B')
scalrelax.plot(np.divide(1,LatticeSize),TempMax,color='black',marker='.',linestyle='') #plots Curie Temp against 1/LatticeSize
scalrelax.plot(Lmin1values,fitted_Tcl_values,color='red',marker='',linestyle='-') #plots line of best fit for data above
pl.savefig('CurieTemp.png', bbox_inches='tight') #saves figure
pl.show()

</pre>

== References ==

Rep:Y3CMPCG1417

2019-11-20T10:30:18Z

Cg1417: /* Section 6 - The effect of system size */

==Section 1 - Introduction to the Ising Model==

===TASK: Show that the lowest possible energy for the Ising model is <math>E = -DNJ</math>, where D is the number of dimensions and N is the total number of spins. What is the multiplicity of this state? Calculate its entropy.===

Consider a 1D row of lattice sites of N=3 with spin configuration [+1][+1][+1].

Mathematically the interaction energy is defined asː
<math> -\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} </math> where J is a constant and <math>s_{i}s_{j}</math> is the product between two spins in adjacent lattice sites.

The sum of the interaction energies <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j}</math> can be considered as the sum of the individual interaction energies between spinsː
<math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = \epsilon_{12} + \epsilon_{23} + \epsilon_{13} + \epsilon_{21} + \epsilon_{32} + \epsilon_{31} </math>.

Although lattice sites 1 and 3 are not adjacent they are said to still interact according to the periodic boundary conditions applied.

However, <math>\epsilon_{12} = \epsilon_{21} </math> and <math>\epsilon_{23} = \epsilon_{32}</math> and <math>\epsilon_{13} = \epsilon_{31}</math> which means that all of the interactions within the system are counted twice, hence the total energy needs to be halved, resulting in the following formula being obtainedː <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = 2\epsilon_{12} + 2\epsilon_{13} + 2\epsilon_{23} </math>.

It can be determined that <math>\epsilon_{12} = (+1)(+1) = 1</math> , <math>\epsilon_{13} = (+1)(+1) = 1</math> and <math>\epsilon_{23} = (+1)(+1) = 1</math>.

Thereforeː <math>-\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = -\frac{1}{2} \ J \ (2 + 2 + 2) = -\frac{1}{2} \ J \ 6 = - 3 J = -DNJ</math> for a 1D lattice with <math>D=1</math> and 3 lattice sites <math>N=3</math>

The multiplicity of the system,<math>\Omega = \frac{lattice sites!}{n. spin up!n. spin down!}</math>

Entropy, <math>S</math> is defined as <math>S = k_B ln(\Omega)</math> and so in this case <math>S = k_B ln(\frac{100!}{100!}) = 0</math>

===TASK: Imagine that the system is in the lowest energy configuration. To move to a different state, one of the spins must spontaneously change direction ("flip"). What is the change in energy if this happens <math>(D=3, N=1000)</math>? How much entropy does the system gain by doing soʔ===

In a 3D lattice system, each lattice site has three unique interactions with its neighbours to its left, top and front. In the lowest energy configuration, all spins are parallel and for a system the minimum energy is <math>E = -DNJ</math>, so for the system with <math>N=1000</math> and <math>D=3</math>, the minimum energy is <math>-3000J</math>.

If a single spin is flipped, the product of its spin with its neighbours spin reverses and becomes negative and this increases the total energy of the system. Since 3 unique spin-spin interactions are reversed in sign, the total energy increases by <math>+3J</math>, meaning the new total energy is <math>-2997J</math>

Initially the multiplicity of the system will be <math>\Omega = \frac{1000!}{1000!}</math> , and after the flip, the multiplicity becomes <math> \Omega = \frac{1000!}{999!1!}=1000</math>.

The associated change in entropy, <math>\Delta S = k_B ln(1000) - 0 = 6.91 k_B</math>, which is an expected increase in entropy as the number of possible configurations of the system increases.

===TASK: Calculate the magnetisation of the 1D and 2D lattices in Figure 1. What magnetisation would you expect to observe for an Ising lattice with <math>D = 3,\ N=1000</math> at absolute zero?===

[[File:ThirdYearCMPExpt-IsingSketch.png|thumb|left|Figure 1 - Shows 1D (N = 5), 2D (N = 5x5) and 3D (N = 5x5x5) lattices.]]

Magnetisation is defined as <math>M=\sum_{i} s_i</math>. So for the 1D lattice with <math>N = 5</math> in ''Figure 2'', <math>M = +1</math> and for the 2D lattice with <math>N = 25 , M = +1</math> too.

According to the 3rd Law of thermodynamics, entropy is 0 at absolute zero for a perfect crystalline solid, and consequently it is expected that the lattices will have follow suit and have zero entropy at 0K. To have zero entropy all spins must be parallel as such that magnetisation, <math>M = N</math>. For all the spins to be parallel, there is only one possible configuration. So, for a lattice with <math>N = 1000</math> and <math>D =3</math>, if <math>M = N</math>, then multiplicity, <math>\Omega = 1</math> and entropy, <math>S =k_B ln(1) = 0</math>.

 

==Section 2 - Calculating the Energy and Magnetisation==

===TASK: complete the functions energy() and magnetisation(), which should return the energy of the lattice and the total magnetisation, respectively. In the energy() function you may assume that <math>J=1.0</math> at all times (in fact, we are working in reduced units in which <math>J=k_B</math>, but there will be more information about this in later sections). Do not worry about the efficiency of the code at the moment — we will address the speed in a later part of the experiment.===

<pre>def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
lat=self.lattice #creates lattice and stores it
mag=[]
for i in range(0,len(lat)): #loops through all rows of lattice
for j in range(0,len(lat[i])): #loops through elements of each row
mag+=[lat[i][j]] #adds spin value to mag array
return sum(mag) #sums all spins from mag array
</pre>

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

lat=self.lattice #creates lattice and stores it
left=[]
top=[]

for i in range(0,len(lat)):
for j in range(0,len(lat[i])):
left+=[lat[i][j]*lat[i][j-1]] #multiplies spin by spin to left
top+=[lat[i][j]*lat[i-1][j]] #multiplies spin by spin above it
int_en=left+top #sums spin products from left and top
energy=-sum(int_en) #sums all spin products for each spin to give total

return energy
</pre>

===TASK: Run the ILcheck.py script from the IPython Qt console using the command===

''Figure 2'' shows the results when ILcheck.py was ran on my IsingLattice.py file. The ILcheck.py file was ran several times to ensure the code worked for various random lattices.

[[File:Cg1417ILcheck run.png|thumb|left|500px| Figure 2 - Result from running the ILcheck.py file]]

 

==Section 3 - Introduction to Monte Carlo Simulation==

===TASK: How many configurations are available to a system with 100 spins? To evaluate these expressions, we have to calculate the energy and magnetisation for each of these configurations, then perform the sum. Let's be very, very, generous, and say that we can analyse <math>1\times 10^9</math> configurations per second with our computer. How long will it take to evaluate a single value of <math>\left\langle M\right\rangle_T</math>?===

For a system with 100 lattice sites and two possible spins for each site, there are <math>2^{100}</math>possible configurations for the system. <math>2^{100}= 1.27\times 10^{30} </math>, so if the computer can analyse <math>1\times 10^9</math> configurations per second, then it will take <math>\frac{1.27\times 10^{30}}{10^9} = 1.27\times 10^{21} s</math> to analyse the whole system, which is longer than the age of the universe and therefore is not a practical approach.

===TASK: Implement a single cycle of the above algorithm in the montecarlocycle(T) function. This function should return the energy of your lattice and the magnetisation at the end of the cycle. You may assume that the energy returned by your energy() function is in units of <math>k_B</math>! Complete the statistics() function. This should return the following quantities whenever it is called: <math><E>, <E^2>, <M>, <M^2></math>, and the number of Monte Carlo steps that have elapsed.===
<pre>
E = []
E2 = []
M = []
M2 = []
n_cycles = 0

def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back if rejected else not changed

self.E+=[self.energy()] #records energy
self.E2+=[self.energy()**2] #records energy squared
self.M+=[self.magnetisation()] #records magnetisation
self.M2+=[self.magnetisation()**2] #records magnetisation squared
self.n_cycles=self.n_cycles+1 #adds 1 to run total

return (self.energy(),self.magnetisation())

def statistics(self):
# complete this function so that it calculates the correct values for the averages of E, E*E (E2), M, M*M (M2), and returns them

e=np.mean(self.E)
e2=np.mean(self.E2)
m=np.mean(self.M)
m2=np.mean(self.M2)

return e,e2,m,m2,self.n_cycles
</pre>

''Figure 3'' shows the results of a single run of the montecarlostep() function and the lattice the function operated upon.

[[File:cg1417MonteCarloStep_run.png|thumb|left|Figure 3 - Results from a single montecarlostep() function and the resulting lattice produced along with the correct return from the statistics() function]]

 

===TASK: If <math>T < T_C</math>, do you expect a spontaneous magnetisation (i.e. do you expect <math>\left\langle M\right\rangle \neq 0</math>)? When the state of the simulation appears to stop changing (when you have reached an equilibrium state), use the controls to export the output to PNG and attach this to your report. You should also include the output from your statistics() function.===

If the temperature of the system is less than the Curie Temperature, <math>T_C</math> then spontaneous magnetisation can occur and the system will tend to its lowest energy state where all of the spins are parallel - this is a property of ferromagnetic materials.

[[File:Cg1417ILanim_run.png|400px|thumb|left|Figure 4 - Results from running the ILanim.py file - shows the energy and magnetisation converging over time]]

''Figure 4'' shows that over time the the system spontaneously converges to the minimum energy state with all of the spins parallel to one another and shows, as I expected, that spontaneous magnetisation occurs and also shows that the temperature of this simulation is below the Curie Temperature, <math>T < T_C</math>.

 

==Section 4 - Accelerating the Code==

===TASK: Use the script ILtimetrial.py to record how long your current version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 5'' show the results of running the ILtimetrial.py file on my code three timesː

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1.png
| width1=500
| image2=cg1417ILtimetrial_run2.png
| width2=500
| image3=cg1417ILtimetrial_run3.png
| width3=500
| footer = Figure 5 - Results of running the ILtimetrial.py file on my code three separate times
}}
 

This gave me an avergage time of <math>24.3 s \pm 0.2s</math>

===TASK: Look at the documentation for the NumPy sum function. You should be able to modify your magnetisation() function so that it uses this to evaluate M. The energy is a little trickier. Familiarise yourself with the NumPy roll and multiply functions, and use these to replace your energy double loop (you will need to call roll and multiply twice!).===

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

left=multiply(roll(self.lattice,1,axis=1),self.lattice) #product of spin with spin left of it
top=multiply(roll(self.lattice,-1,axis=0),self.lattice) #product of spin with spin above it

int_en=sum(left+top) #sum of array containing sum of left and top spin products for each spin

energy = -sum(int_en) #calculates the total energy of system
return energy

def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
return sum(sum(self.lattice)) #adds up all spins in lattice
</pre>
The use of the bumpy modules reduces the amount of code required and removes the need for loops making the code significantly shorter, and is therefore expected to run ILtimetrial.py faster than the initial code developed.

===TASK: Use the script ILtimetrial.py to record how long your new version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 6'' shows the result of running the ILtimetrial.py on my new accelerated code.

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1fast.png
| width1=500
| image2=ILtimetrial_run2fast.png
| width2=500
| image3=ILtimetrial_run3fast.png
| width3=500
| footer = Figure 6 - Results of running the ILtimetrial.py file on my new updated and accelerated code.
}}
 

The accelerated code is much faster upon using the roll, multiply and sum modules with a new average time of <math>0.790 s \pm 0.005 </math>

==Section 5 - The effect of temperature==

===TASK: The script ILfinalframe.py runs for a given number of cycles at a given temperature, then plots a depiction of the final lattice state as well as graphs of the energy and magnetisation as a function of cycle number. This is much quicker than animating every frame! Experiment with different temperature and lattice sizes. How many cycles are typically needed for the system to go from its random starting position to the equilibrium state? Modify your statistics() and montecarlostep() functions so that the first N cycles of the simulation are ignored when calculating the averages. You should state in your report what period you chose to ignore, and include graphs from ILfinalframe.py to illustrate your motivation in choosing this figure.===

''Figure 7'' below shows the results from running the ILfinalframe.py for 2x2 lattice at T=1,2,3,5.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2T1.png
| image2 = cg14172x2T2.png
| image3 =cg14172x2T3.png
| image4 =cg14172x2T5.png
| footer_align = left
| footer = Figure 7 - Results of running the ILfinalframe.py file at T=1,2,3,5 for a 2x2 matrix.
}}

 

For a 2x2 matrix, a suitable cut-off point to exclude from the avergage energies and magnetisations is where the energy and magnetisations per spin are constant, which is 30 steps. For T=3 and T=5 the graphs do not converge because it is possible that these temperatures are higher than the Curie Temperature and as such spontaneous magnetisation will not occur and the system will not diverge to the lowest energy state. At the higher temperatures, there are larger thermal fluctations and the Boltzmann factor is more significant allowing the system to move away from the lowest energy state easier. As a result moving forwards, a suitable cut-off point will only be determined from T=1 and T=2 graphs for the larger matrices.

''Figure 8'' shows the results from running a 4x4 lattice at T=1,2 and 3.

{{multiple image
| width =350
| align = left
| image1 = cg14174x4T1.png
| image2 = cg14174x4T2.png
| image3 =cg14174x4T3.png
| footer_align = left
| footer = Figure 8 - Results of running the ILfinalframe.py file at T=1,2,3 for a 4x4 matrix.
}}

From ''Figure 8'', a suitable cut-off point for the energy and magnetisations is 200 as this is after where the energy and magnetisation has converged for T=1, and is after the initial large drop in energy for T=2, even though there are a few small fluctuations after 200 steps. The result from T=3 has been included to show the large fluctuations for the larger temperatures, and supporting my choice to determine the cut-off from T=1 and T=2 only.

''Figure 9'' shows the results for an 8x8 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg14178x8T1.png
| image2 = cg14178x8T2.png
| footer_align = left
| footer = Figure 9 - Results of running the ILfinalframe.py file at T=1,2 for an 8x8 matrix
}}

From ''Figure 9'' above, a suitable cut-off point is 1000 steps as this is where the energy and magnetisation has easily converged by and is also the point after which the initial large drop in energy has been overcome for T=2 too.

''Figure 10'' shows the result of running the ILfinalframe.py for a 16x16 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg141716x16T1.png
| image2 = cg141716x16T2.png
| footer_align = left
| footer = Figure 10 - Results of running the ILfinalframe.py file at T=1,2 for a 16x16 matrix
}}

From ''Figure 10'', a suitable cut-off point is 15000 steps as for T=1 the energy and magnetisations have converged significantly and will not change much, and likewise this is the same for the T=2 frame.

''Figure 11'' below shows the results from a 32x32 matrix at T=1 and T=2.

{{multiple image
| width =350
| align = left
| image1 = cg141732x32T1.png
| image2 = cg141732x32T2.png
| footer_align = left
| footer = Figure 11 - Results of running the ILfinalframe.py file at T=1,2 for a 32x32 matrix
}}

''Figure 11'' above shows the results of running the ILfinalframe.py file for a 32x32 matrix at T=1 and T=2. As a result a suitable cut-off of 50000 steps was chosen as the energy and magnetisation has significantly converged, but not as much as it could at 100000 steps. I chose a slightly lower value to ensure that the run times of my monte-carlo simulations in future tasks were not extremely time consuming.

The montecarlostep() function was changed by adding a condition that values only above the pre-determined cut-off were included when determining the average value of energy; energy squared; magnetisation and magnetisations squared from the statistics function. The statistics() function did not need to be modified.

The following code is from the 32x32 matrixː

<pre>def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back

if self.n_cycles > 50000: #only adds values to array of E,E2,M and M2 above the specific cut-off
self.E+=[self.energy()]
self.E2+=[self.energy()**2]
self.M+=[self.magnetisation()]
self.M2+=[self.magnetisation()**2]
self.n_cycles=self.n_cycles+1

return (self.energy(),self.magnetisation())
</pre>

===TASK: Use ILtemperaturerange.py to plot the average energy and magnetisation for each temperature, with error bars, for an <math>8\times 8</math> lattice. Use your intuition and results from the script ILfinalframe.py to estimate how many cycles each simulation should be. The temperature range 0.25 to 5.0 is sufficient. Use as many temperature points as you feel necessary to illustrate the trend, but do not use a temperature spacing larger than 0.5. The NumPy function savetxt() stores your array of output data on disk — you will need it later. Save the file as 8x8.dat so that you know which lattice size it came from.===

Using the modified code, the file ILtemperaturerange.py was ran on an 8x8 matrix between T=0.5 and T=5 with a step of T=0.02 for 10000 Montecarlo steps and the first 1000 steps of each temperature were excluded when calculating the averages. ''Figure 12'' shows the result of the simulation and also included error bars of standard deviation.

[[File:Cg14178x8error.png|1000px|thumb|left|Figure 12 - Graph showing average energy and average magnetisation for an 8x8 lattice with error bars between T=0.5 and T=5]]

 

Below is the source code for the script to produce the graphː

<pre>data8x8=np.loadtxt('8x8.dat') #loads data
temps8x8=data8x8[:,0] #stores temperatures
energies8x8=data8x8[:,1] #stores average energy for each T
energysq8x8=data8x8[:,2] #stores average energy squared for each T
mag8x8=data8x8[:,3] #stores magnetisation for each T
magsq8x8=data8x8[:,4] #stores magnetisation squared for each T
stde8x8=data8x8[:,5] #edited ILtemperaturerange.py to record the standard deviation of the energy for each T
stdm8x8=data8x8[:,6] #edited ILtemperaturerange.py to record the standard deviation of the magnetisation for each T

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.errorbar(temps8x8, np.array(energies8x8)/64,yerr=np.divide(stde8x8,64),color='black',ecolor='teal',alpha=0.8) #plots energy per spin against T
magax.errorbar(temps8x8, np.array(mag8x8)/64,yerr=np.divide(stdm8x8,64),alpha=0.8,ecolor='salmon',color='black') #plots magnetisation per spin against T on separate graph
pl.savefig('8x8error.png',bbox_inches='tight') #saves figure
pl.show()

</pre>

==Section 6 - The effect of system size==

===TASK: Repeat the final task of the previous section for the following lattice sizes: 2x2, 4x4, 8x8, 16x16, 32x32. Make sure that you name each datafile that your produce after the corresponding lattice size! Write a Python script to make a plot showing the energy per spin versus temperature for each of your lattice sizes. Hint: the NumPy loadtxt function is the reverse of the savetxt function, and can be used to read your previously saved files into the script. Repeat this for the magnetisation. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. How big a lattice do you think is big enough to capture the long range fluctuations?===

The python script for this section is identical as for the 8x8 graph above in Figure 12 with the relevant files and variables changed accordingly.

Each matrix was simulated using the ILtemperaturerange.py file between T=0.5 and T=5 with a step of T=0.02.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2error.png
| caption1 = 2x2 matrix - 5000 steps, cut-off = 30 steps
| image2 = 4x4error.png
| caption2 = 4x4 matrix - 1000 steps, cut-off = 200 steps
| image3 =cg141716x16error.png
| caption3 = 16x16 matrix - 50000 steps, cut-off = 15000 steps
| image4 =cg141732x32error.png
| caption4 = 32x32 matrix - 200000 steps, cut-off = 50000 steps
| footer_align = left
| footer = Figure 13 - Results of running the ILtemperaturerange.py file for 2x2, 4x4, 16x16 and 32x32 matrices.
}}

 

Long-range interactions are present and more significant in the smaller lattices where there are fewer stronger, short range interactions. As a result, I expect long-range interactions to be important in square lattices up to a 4x4 size.

==Section 7 - Determining the Heat Capacity==

===TASK: By definition, <math>C = \frac{\partial \left\langle E\right\rangle}{\partial T}</math>. From this, show that <math>C = \frac{\mathrm{Var}[E]}{k_B T^2}</math> (Where <math>\mathrm{Var}[E]</math> is the variance in <math>E</math>.)===

Recall from statistical thermodynamics that the average energy of a system is the sum across all microstates of the probability of that microstate multiplied by the energy of that microstate, which is defined mathematically asː <math>\langle E \rangle = \sum_i p_{i}\epsilon_{i}</math>.

The partition function <math>q</math> is defined as <math>q = \sum_{i} exp(-\beta \epsilon_{i})</math> where <math>\beta =\frac{1}{k_BT}</math>and the probability, <math>p_{i}</math> can be defined in terms of the partition function as <math>p_{i} = \frac{exp(-\beta \epsilon_{i})}{\sum_{i} exp(-\beta \epsilon_{i})} = \frac{exp(-\beta \epsilon_{i})}{q}</math>.

As a result, <math>\langle E \rangle</math> can be re-written as <math>\langle E \rangle = \sum_{i} \frac{\epsilon_{i} exp(-\beta \epsilon_{i})}{q} = -\frac{1}{q} \frac{\partial}{\partial \beta}\sum_{i}exp(-\beta \epsilon_{i}) = -\frac{1}{q} \frac{\partial q}{\partial \beta}</math>

Likewise, <math>\langle E^2 \rangle = \sum_i p_{i}\epsilon_{i}^{2} = \sum_{i} \frac{\epsilon_{i}^{2}exp(-\beta \epsilon_{i})}{q} = \frac{1}{q} \frac{\partial^{2}}{\partial \beta^{2}}\sum_{i}exp(-\beta \epsilon_{i}) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}}</math>

From definitionː <math>Var[E] = \Delta E^2 = \langle E^2 \rangle - \langle E \rangle^2 </math>

When the definition of <math>\langle E \rangle</math> and <math>\langle E^2 \rangle</math> is written in terms of partition function <math>q</math>ː <math>Var[E] = \langle E^2 \rangle - \langle E \rangle^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \left(\frac{1}{q}\frac{\partial q}{\partial \beta}\right)^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2</math>.

According to the chain ruleː <math>\frac{\partial}{\partial \beta}\left(\frac{1}{q} \frac{\partial q}{\partial \beta}\right) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2 = -\frac{\partial}{\partial \beta}\langle E \rangle = Var[E]</math>

And using the chain rule againː <math>C = \frac{\partial \langle E \rangle}{\partial T}= \left(-\frac{\partial \langle E \rangle}{\partial \beta}\right) \left(-\frac{\partial \beta}{\partial T}\right) = \frac{Var[E]}{k_B T^2}</math>

===TASK: Write a Python script to make a plot showing the heat capacity versus temperature for each of your lattice sizes from the previous section. You may need to do some research to recall the connection between the variance of a variable, <math>\mathrm{Var}[X]</math>, the mean of its square <math>\left\langle X^2\right\rangle</math>, and its squared mean <math>\left\langle X\right\rangle^2</math>. You may find that the data around the peak is very noisy — this is normal, and is a result of being in the critical region. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. ===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb

{{multiple image
| width =300
| align = left
| image1 = cg14172x2heatcap.png
| caption1 = 2x2 Matrix
| image2 = cg14174x4heatcap.png
| caption2 = 4x4 Matrix
| image3 =cg14178x8heatcap.png
| caption3 = 8x8 Matrix
| image4 =cg141716x16heatcap.png
| caption4 = 16x16 Matrix
| image5=cg141732x32heatcap.png
| caption5= 32x32 Matrix
| footer = Figure 14 - Graphs showing Heat Capacity against Temperature for each matrix size
}}

Here is the source code to produce the figuresː
<pre> def heatCap(energies,energysq,T,latsize):
#defines the heat capacity for a given temperature
energiesq=np.multiply(energies,energies) #creates array of (average energies) squared
varE=np.subtract(energysq,energiesq) #defines variance of average energy
tempsq=np.multiply(T,T) #array of temperature squared
return np.array(np.divide(varE,tempsq))/(latsize**2)

heatCap2x2=heatCap(energies2x2,energysq2x2,temps2x2,2) #creates array of heat capacity for each T

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(temps2x2,heatCap2x2,color='orange') #plots heat capacity for each T
pl.savefig('cg14172x2heatcap.png',bbox_inches='tight') #saves figure
pl.show()
</pre>

A general trend from the above graphs is that the peak of the graph shifts towards lower temperatures as the size of the matrix used increases which means the Curie Temperature decreases as matrix size increases.

==Section 8 - Locating the Curie Temperature==
===TASK: A C++ program has been used to run some much longer simulations than would be possible on the college computers in Python. You can view its source code here if you are interested. Each file contains six columns: <math>T, E, E^2, M, M^2, C</math> (the final five quantities are per spin), and you can read them with the NumPy loadtxt function as before. For each lattice size, plot the C++ data against your data. For one lattice size, save a PNG of this comparison and add it to your report — add a legend to the graph to label which is which. To do this, you will need to pass the label="..." keyword to the plot function, then call the legend() function of the axis object (documentation here).===

The python code used to read and plot the C++ data is found in the Jupyter notebook CG1417IsingModelGraphs.ipynb.

''Figure 15'' below shows the C++ plotted against my own data for a 16x16 Matrix.

[[File:Cg141716x16C++.png|400px|thumb|left|Figure 15 - Graph showing my own data against the C++ data for a 16x16 matrix.]]

 

Here is the source code the produce the figuresː
<pre>#fitting C++ data

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.plot(temps2x2, np.array(energies2x2)/4,color='black',alpha=0.7,label='Python Data') #python energy against T
enerax.plot(temps2x2C, energies2x2C, color='red',label='C++ Data') #C energy against T
magax.plot(temps2x2, np.array(mag2x2)/4,color='black',alpha=0.7,label='Python Data') #python magnetisation against T
magax.plot(temps2x2C, mag2x2C,color='red',label='C++ Data') #C energy against T
enerax.legend() #shows legend on energy graph
magax.legend() #shows legend on energy graph
pl.show()
</pre>

The relevant variables and dat files were changed for each matrix.

===TASK: write a script to read the data from a particular file, and plot C vs T, as well as a fitted polynomial. Try changing the degree of the polynomial to improve the fit — in general, it might be difficult to get a good fit! Attach a PNG of an example fit to your report.===

The python script to read and plot the fitted polynomial is found in CG1417PolyfitScript.ipynb

Here is the source code for ''Figure 15''

<pre>data_test = np.loadtxt("16x16C.dat")
T_test = data_test[:,0] #gets temperatures
C_test = data_test[:,5] #gets heat capacity data

#first we fit the polynomial to the data
fit_test = np.polyfit(T_test, C_test, 35) # fit a polynomial

#now we generate interpolated values of the fitted polynomial over the range of our function
T_min_test = 0.5 #np.min(T_test)
T_max_test = 5 #np.max(T_test)

T_range_test = np.linspace(T_min_test, T_max_test, 1000) #generate 1000 evenly spaced points between T_min and T_max
fitted_C_values_test = np.polyval(fit_test, T_range_test)# use the fit object to generate the corresponding values of C

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(T_test,C_test,color='orange',label='C++ Data') #plots C data of heat capacity against temp
heatcapax.plot(T_range_test,fitted_C_values_test,label='Fitted Polynomial') #plots fitted polynomial for whole range of temp
heatcapax.legend()
pl.savefig('FIT_TEST16x16_35.png', bbox_inches='tight') #saves figure
pl.show()
</pre>

Below in ''Figure 16'' is a plot of my Heat Capacity against Temperature data for a 16x16 matrix and features a polynomial of degree 35 plotted against it. Even with a polynomial of such a high degree, it poorly fits the curve and does not fit to the peak of the curve either.

[[File:cg1417FIT_TEST16x16_35.png|thumb|left|400px|Figure 16 - Plot of Heat Capacity against Temperature along with a poorly fitted polynomial of degree 35. ]]

 

===TASK: Modify your script from the previous section. You should still plot the whole temperature range, but fit the polynomial only to the peak of the heat capacity! You should find it easier to get a good fit when restricted to this region===

The script was modified as such that the polynomial was fitted in a set range around the peak of the graph, this is demonstrated in ''Figure 17'' which shows a newly fitted polynomial between a much smaller range of temperatures (T = 2.15-2.55) and a much smaller degree polynomial (3).

[[File:CG1417FIT_16x16C_3.png|thumb|left|400px|Figure 17 - Graph showing Heat Capacity against Temperature for a 16x16 matrix along with a fitted polynomial between a much more restricted range of temperatures and a significantly lower degree of polynomial]]

Upon comparison with ''Figure 16'', the new fitted polynomial is a significantly better fit even for a 3rd degree polynomial and is a much more accurate representation of my data around the peak of the graph and will make it easier to determine the maximum value of Heat Capacity.

 

Here is the source code for ''Figure 17''ː
<pre>data16 = np.loadtxt("16x16C.dat") #loads data to variable

T16 = data16[:,0] #gets temps
C16 = data16[:,5] # gets heat capacities

Tmin16 = 2.15 #chosen min temp
Tmax16 = 2.55 #chosen max temp

selection16 = np.logical_and(T16 > Tmin16, T16 < Tmax16) #choose only those rows where both conditions are true
peak_T_values16 = T16[selection16] #choose temp values in range chosen above
peak_C_values16 = C16[selection16] #choose heat cap values in range of t above

fit16 = np.polyfit(peak_T_values16,peak_C_values16,3) #fit 3rd order polynomial
peak_T_range16 = np.linspace(Tmin16, Tmax16, 1000) #defines 1000 temps within data range
fitted_C_values16 = np.polyval(fit16, peak_T_range16) #use the fit object to get corresponding values of heat cap

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(T16,C16,color='orange',label='C++ Data') #plots C data of heat cap against temp
heatcapax.plot(peak_T_range16,fitted_C_values16,label='Fitted Polynomial') #plots fitted polynomial for small range
heatcapax.legend()
pl.savefig('FIT_16x16C_3.png', bbox_inches='tight') #saves figure
pl.show()

</pre>

===TASK: find the temperature at which the maximum in C occurs for each datafile that you were given. Make a text file containing two colums: the lattice side length (2,4,8, etc.), and the temperature at which C is a maximum. This is your estimate of <math>T_C</math> for that side length. Make a plot that uses the scaling relation given above to determine <math>T_{C,\infty}</math>. By doing a little research online, you should be able to find the theoretical exact Curie temperature for the infinite 2D Ising lattice. How does your value compare to this? Are you surprised by how good/bad the agreement is? Attach a PNG of this final graph to your report, and discuss briefly what you think the major sources of error are in your estimate.===

''Figure 18'' below shows a graph of <math>T_{C,L}</math> against <math>\frac{1}{Lattice Size}</math> to determine the Curie Temperature of an infinite 2D Ising Model Lattice <math>T_{C,\infty}</math>. The black dots represent the raw data obtained from obtaining the temperature at which the Heat Capacity was a maximum for the lattices and the red line in a linear curve fit plotted against the data to allow the y-intercept which is the Curie Temperature for the infinite 2D lattice to be determined.

[[File:cg1417CurieTemp.png|400px|thumb|left|Figure 18 - Plot of 1/Lattice Size against Curie Temperature for that lattice size.]]

The value for <math>T_{C,\inf}</math> obtained from the data is <math>T_{C,\infty} = 2.277 \frac{J}{k_B}</math> with a literature value being <math>T_{C,\infty} = 2.269 \frac{J}{k_B}</math> <ref>L. Onsager, Phys. Rev., 1944, 65, 117--149.</ref>for an infinite square 2D lattice. This means that my result slightly over-estimates the Curie Temperature for the infinite lattice and as a result for an infinite lattice the temperature at which spontaneous magnetisation stops would actually occur at a slightly lower temperature than expected. However, the difference between my value and the literature value is only 0.008 which is incredibly small and the amount of agreement between the two values is somewhat surprising, which means that the error in my estimates of the Curie Temperature for each lattice size is relatively small. The points which have the largest residuals and deviation from the line of best fit in ''Figure 17'' corresponds to the smaller lattice sizes of 2x2 and 4x4 where longer range interactions are more significant. The longer range interactions posed by the boundary conditions are nowhere near as significant for the larger sizes and causes the energy of the smaller matrices to be less accurate and have a larger associated error with the energy and thus the Curie Temperature for that lattice size. This affects the accuracy of the line of best fit and to increase the accuracy of this line, larger lattice sizes of 128x128, 256x256 etc should be included in the calculation for the line of best fit and the smaller matrices ignored.

 

Below is the source code used to generate ''Figure 18''
<pre>
Cmax64x64 = np.max(fitted_C_values64) #finds Cmax for 64x64 matrix - done for others already
Tmax64x64 = peak_T_range64[fitted_C_values64 == Cmax64x64] #finds Tmax corresponding to Cmax

LatSize=[2,4,8,16,32,64] #stores lattice sizes
Tmax=[Tmax2x2,Tmax4x4,Tmax8x8,Tmax16x16,Tmax32x32,Tmax64x64] #stores corresponding Tmax data
np.savetxt('CmaxVSTmax.txt', (LatSize,Tmax)) #writes data to txt file

ScalData=np.loadtxt('CmaxVSTmax.txt') #loads data
LatticeSize=ScalData[0] #gets lattice sizes
TempMax=ScalData[1] #gets max temp or curie temp for each lattice

Lmin1min = np.min(np.divide(1,LatticeSize)) #minimum of 1/LatticeSize values
Lmin1max = np.max(np.divide(1,LatticeSize)) #maximum of 1/LatticeSize values

fitTcl = np.polyfit(np.divide(1,LatticeSize),TempMax, 1) #creates fit object

Lmin1values = np.linspace(Lmin1min, Lmin1max, 1000) #finds 1000 values between min and max x-axis value of 1/LatticeSize
fitted_Tcl_values = np.polyval(fitTcl, Lmin1values) #creates corresponding Curie Temp values for each value in Lmin1values

fig = pl.figure()
scalrelax = fig.add_subplot(1,1,1)
scalrelax.set_xlabel('1/Lattice Size')
scalrelax.set_ylabel('Curie Temperature/ J/k_B')
scalrelax.plot(np.divide(1,LatticeSize),TempMax,color='black',marker='.',linestyle='') #plots Curie Temp against 1/LatticeSize
scalrelax.plot(Lmin1values,fitted_Tcl_values,color='red',marker='',linestyle='-') #plots line of best fit for data above
pl.savefig('CurieTemp.png', bbox_inches='tight') #saves figure
pl.show()

</pre>

== References ==

Rep:Y3CMPCG1417

2019-11-20T10:23:23Z

Cg1417: /* TASK: The script ILfinalframe.py runs for a given number of cycles at a given temperature, then plots a depiction of the final lattice state as well as graphs of the energy and magnetisation as a function of cycle number. This is much quicker than a...

==Section 1 - Introduction to the Ising Model==

===TASK: Show that the lowest possible energy for the Ising model is <math>E = -DNJ</math>, where D is the number of dimensions and N is the total number of spins. What is the multiplicity of this state? Calculate its entropy.===

Consider a 1D row of lattice sites of N=3 with spin configuration [+1][+1][+1].

Mathematically the interaction energy is defined asː
<math> -\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} </math> where J is a constant and <math>s_{i}s_{j}</math> is the product between two spins in adjacent lattice sites.

The sum of the interaction energies <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j}</math> can be considered as the sum of the individual interaction energies between spinsː
<math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = \epsilon_{12} + \epsilon_{23} + \epsilon_{13} + \epsilon_{21} + \epsilon_{32} + \epsilon_{31} </math>.

Although lattice sites 1 and 3 are not adjacent they are said to still interact according to the periodic boundary conditions applied.

However, <math>\epsilon_{12} = \epsilon_{21} </math> and <math>\epsilon_{23} = \epsilon_{32}</math> and <math>\epsilon_{13} = \epsilon_{31}</math> which means that all of the interactions within the system are counted twice, hence the total energy needs to be halved, resulting in the following formula being obtainedː <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = 2\epsilon_{12} + 2\epsilon_{13} + 2\epsilon_{23} </math>.

It can be determined that <math>\epsilon_{12} = (+1)(+1) = 1</math> , <math>\epsilon_{13} = (+1)(+1) = 1</math> and <math>\epsilon_{23} = (+1)(+1) = 1</math>.

Thereforeː <math>-\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = -\frac{1}{2} \ J \ (2 + 2 + 2) = -\frac{1}{2} \ J \ 6 = - 3 J = -DNJ</math> for a 1D lattice with <math>D=1</math> and 3 lattice sites <math>N=3</math>

The multiplicity of the system,<math>\Omega = \frac{lattice sites!}{n. spin up!n. spin down!}</math>

Entropy, <math>S</math> is defined as <math>S = k_B ln(\Omega)</math> and so in this case <math>S = k_B ln(\frac{100!}{100!}) = 0</math>

===TASK: Imagine that the system is in the lowest energy configuration. To move to a different state, one of the spins must spontaneously change direction ("flip"). What is the change in energy if this happens <math>(D=3, N=1000)</math>? How much entropy does the system gain by doing soʔ===

In a 3D lattice system, each lattice site has three unique interactions with its neighbours to its left, top and front. In the lowest energy configuration, all spins are parallel and for a system the minimum energy is <math>E = -DNJ</math>, so for the system with <math>N=1000</math> and <math>D=3</math>, the minimum energy is <math>-3000J</math>.

If a single spin is flipped, the product of its spin with its neighbours spin reverses and becomes negative and this increases the total energy of the system. Since 3 unique spin-spin interactions are reversed in sign, the total energy increases by <math>+3J</math>, meaning the new total energy is <math>-2997J</math>

Initially the multiplicity of the system will be <math>\Omega = \frac{1000!}{1000!}</math> , and after the flip, the multiplicity becomes <math> \Omega = \frac{1000!}{999!1!}=1000</math>.

The associated change in entropy, <math>\Delta S = k_B ln(1000) - 0 = 6.91 k_B</math>, which is an expected increase in entropy as the number of possible configurations of the system increases.

===TASK: Calculate the magnetisation of the 1D and 2D lattices in Figure 1. What magnetisation would you expect to observe for an Ising lattice with <math>D = 3,\ N=1000</math> at absolute zero?===

[[File:ThirdYearCMPExpt-IsingSketch.png|thumb|left|Figure 1 - Shows 1D (N = 5), 2D (N = 5x5) and 3D (N = 5x5x5) lattices.]]

Magnetisation is defined as <math>M=\sum_{i} s_i</math>. So for the 1D lattice with <math>N = 5</math> in ''Figure 2'', <math>M = +1</math> and for the 2D lattice with <math>N = 25 , M = +1</math> too.

According to the 3rd Law of thermodynamics, entropy is 0 at absolute zero for a perfect crystalline solid, and consequently it is expected that the lattices will have follow suit and have zero entropy at 0K. To have zero entropy all spins must be parallel as such that magnetisation, <math>M = N</math>. For all the spins to be parallel, there is only one possible configuration. So, for a lattice with <math>N = 1000</math> and <math>D =3</math>, if <math>M = N</math>, then multiplicity, <math>\Omega = 1</math> and entropy, <math>S =k_B ln(1) = 0</math>.

 

==Section 2 - Calculating the Energy and Magnetisation==

===TASK: complete the functions energy() and magnetisation(), which should return the energy of the lattice and the total magnetisation, respectively. In the energy() function you may assume that <math>J=1.0</math> at all times (in fact, we are working in reduced units in which <math>J=k_B</math>, but there will be more information about this in later sections). Do not worry about the efficiency of the code at the moment — we will address the speed in a later part of the experiment.===

<pre>def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
lat=self.lattice #creates lattice and stores it
mag=[]
for i in range(0,len(lat)): #loops through all rows of lattice
for j in range(0,len(lat[i])): #loops through elements of each row
mag+=[lat[i][j]] #adds spin value to mag array
return sum(mag) #sums all spins from mag array
</pre>

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

lat=self.lattice #creates lattice and stores it
left=[]
top=[]

for i in range(0,len(lat)):
for j in range(0,len(lat[i])):
left+=[lat[i][j]*lat[i][j-1]] #multiplies spin by spin to left
top+=[lat[i][j]*lat[i-1][j]] #multiplies spin by spin above it
int_en=left+top #sums spin products from left and top
energy=-sum(int_en) #sums all spin products for each spin to give total

return energy
</pre>

===TASK: Run the ILcheck.py script from the IPython Qt console using the command===

''Figure 2'' shows the results when ILcheck.py was ran on my IsingLattice.py file. The ILcheck.py file was ran several times to ensure the code worked for various random lattices.

[[File:Cg1417ILcheck run.png|thumb|left|500px| Figure 2 - Result from running the ILcheck.py file]]

 

==Section 3 - Introduction to Monte Carlo Simulation==

===TASK: How many configurations are available to a system with 100 spins? To evaluate these expressions, we have to calculate the energy and magnetisation for each of these configurations, then perform the sum. Let's be very, very, generous, and say that we can analyse <math>1\times 10^9</math> configurations per second with our computer. How long will it take to evaluate a single value of <math>\left\langle M\right\rangle_T</math>?===

For a system with 100 lattice sites and two possible spins for each site, there are <math>2^{100}</math>possible configurations for the system. <math>2^{100}= 1.27\times 10^{30} </math>, so if the computer can analyse <math>1\times 10^9</math> configurations per second, then it will take <math>\frac{1.27\times 10^{30}}{10^9} = 1.27\times 10^{21} s</math> to analyse the whole system, which is longer than the age of the universe and therefore is not a practical approach.

===TASK: Implement a single cycle of the above algorithm in the montecarlocycle(T) function. This function should return the energy of your lattice and the magnetisation at the end of the cycle. You may assume that the energy returned by your energy() function is in units of <math>k_B</math>! Complete the statistics() function. This should return the following quantities whenever it is called: <math><E>, <E^2>, <M>, <M^2></math>, and the number of Monte Carlo steps that have elapsed.===
<pre>
E = []
E2 = []
M = []
M2 = []
n_cycles = 0

def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back if rejected else not changed

self.E+=[self.energy()] #records energy
self.E2+=[self.energy()**2] #records energy squared
self.M+=[self.magnetisation()] #records magnetisation
self.M2+=[self.magnetisation()**2] #records magnetisation squared
self.n_cycles=self.n_cycles+1 #adds 1 to run total

return (self.energy(),self.magnetisation())

def statistics(self):
# complete this function so that it calculates the correct values for the averages of E, E*E (E2), M, M*M (M2), and returns them

e=np.mean(self.E)
e2=np.mean(self.E2)
m=np.mean(self.M)
m2=np.mean(self.M2)

return e,e2,m,m2,self.n_cycles
</pre>

''Figure 3'' shows the results of a single run of the montecarlostep() function and the lattice the function operated upon.

[[File:cg1417MonteCarloStep_run.png|thumb|left|Figure 3 - Results from a single montecarlostep() function and the resulting lattice produced along with the correct return from the statistics() function]]

 

===TASK: If <math>T < T_C</math>, do you expect a spontaneous magnetisation (i.e. do you expect <math>\left\langle M\right\rangle \neq 0</math>)? When the state of the simulation appears to stop changing (when you have reached an equilibrium state), use the controls to export the output to PNG and attach this to your report. You should also include the output from your statistics() function.===

If the temperature of the system is less than the Curie Temperature, <math>T_C</math> then spontaneous magnetisation can occur and the system will tend to its lowest energy state where all of the spins are parallel - this is a property of ferromagnetic materials.

[[File:Cg1417ILanim_run.png|400px|thumb|left|Figure 4 - Results from running the ILanim.py file - shows the energy and magnetisation converging over time]]

''Figure 4'' shows that over time the the system spontaneously converges to the minimum energy state with all of the spins parallel to one another and shows, as I expected, that spontaneous magnetisation occurs and also shows that the temperature of this simulation is below the Curie Temperature, <math>T < T_C</math>.

 

==Section 4 - Accelerating the Code==

===TASK: Use the script ILtimetrial.py to record how long your current version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 5'' show the results of running the ILtimetrial.py file on my code three timesː

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1.png
| width1=500
| image2=cg1417ILtimetrial_run2.png
| width2=500
| image3=cg1417ILtimetrial_run3.png
| width3=500
| footer = Figure 5 - Results of running the ILtimetrial.py file on my code three separate times
}}
 

This gave me an avergage time of <math>24.3 s \pm 0.2s</math>

===TASK: Look at the documentation for the NumPy sum function. You should be able to modify your magnetisation() function so that it uses this to evaluate M. The energy is a little trickier. Familiarise yourself with the NumPy roll and multiply functions, and use these to replace your energy double loop (you will need to call roll and multiply twice!).===

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

left=multiply(roll(self.lattice,1,axis=1),self.lattice) #product of spin with spin left of it
top=multiply(roll(self.lattice,-1,axis=0),self.lattice) #product of spin with spin above it

int_en=sum(left+top) #sum of array containing sum of left and top spin products for each spin

energy = -sum(int_en) #calculates the total energy of system
return energy

def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
return sum(sum(self.lattice)) #adds up all spins in lattice
</pre>
The use of the bumpy modules reduces the amount of code required and removes the need for loops making the code significantly shorter, and is therefore expected to run ILtimetrial.py faster than the initial code developed.

===TASK: Use the script ILtimetrial.py to record how long your new version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 6'' shows the result of running the ILtimetrial.py on my new accelerated code.

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1fast.png
| width1=500
| image2=ILtimetrial_run2fast.png
| width2=500
| image3=ILtimetrial_run3fast.png
| width3=500
| footer = Figure 6 - Results of running the ILtimetrial.py file on my new updated and accelerated code.
}}
 

The accelerated code is much faster upon using the roll, multiply and sum modules with a new average time of <math>0.790 s \pm 0.005 </math>

==Section 5 - The effect of temperature==

===TASK: The script ILfinalframe.py runs for a given number of cycles at a given temperature, then plots a depiction of the final lattice state as well as graphs of the energy and magnetisation as a function of cycle number. This is much quicker than animating every frame! Experiment with different temperature and lattice sizes. How many cycles are typically needed for the system to go from its random starting position to the equilibrium state? Modify your statistics() and montecarlostep() functions so that the first N cycles of the simulation are ignored when calculating the averages. You should state in your report what period you chose to ignore, and include graphs from ILfinalframe.py to illustrate your motivation in choosing this figure.===

''Figure 7'' below shows the results from running the ILfinalframe.py for 2x2 lattice at T=1,2,3,5.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2T1.png
| image2 = cg14172x2T2.png
| image3 =cg14172x2T3.png
| image4 =cg14172x2T5.png
| footer_align = left
| footer = Figure 7 - Results of running the ILfinalframe.py file at T=1,2,3,5 for a 2x2 matrix.
}}

 

For a 2x2 matrix, a suitable cut-off point to exclude from the avergage energies and magnetisations is where the energy and magnetisations per spin are constant, which is 30 steps. For T=3 and T=5 the graphs do not converge because it is possible that these temperatures are higher than the Curie Temperature and as such spontaneous magnetisation will not occur and the system will not diverge to the lowest energy state. At the higher temperatures, there are larger thermal fluctations and the Boltzmann factor is more significant allowing the system to move away from the lowest energy state easier. As a result moving forwards, a suitable cut-off point will only be determined from T=1 and T=2 graphs for the larger matrices.

''Figure 8'' shows the results from running a 4x4 lattice at T=1,2 and 3.

{{multiple image
| width =350
| align = left
| image1 = cg14174x4T1.png
| image2 = cg14174x4T2.png
| image3 =cg14174x4T3.png
| footer_align = left
| footer = Figure 8 - Results of running the ILfinalframe.py file at T=1,2,3 for a 4x4 matrix.
}}

From ''Figure 8'', a suitable cut-off point for the energy and magnetisations is 200 as this is after where the energy and magnetisation has converged for T=1, and is after the initial large drop in energy for T=2, even though there are a few small fluctuations after 200 steps. The result from T=3 has been included to show the large fluctuations for the larger temperatures, and supporting my choice to determine the cut-off from T=1 and T=2 only.

''Figure 9'' shows the results for an 8x8 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg14178x8T1.png
| image2 = cg14178x8T2.png
| footer_align = left
| footer = Figure 9 - Results of running the ILfinalframe.py file at T=1,2 for an 8x8 matrix
}}

From ''Figure 9'' above, a suitable cut-off point is 1000 steps as this is where the energy and magnetisation has easily converged by and is also the point after which the initial large drop in energy has been overcome for T=2 too.

''Figure 10'' shows the result of running the ILfinalframe.py for a 16x16 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg141716x16T1.png
| image2 = cg141716x16T2.png
| footer_align = left
| footer = Figure 10 - Results of running the ILfinalframe.py file at T=1,2 for a 16x16 matrix
}}

From ''Figure 10'', a suitable cut-off point is 15000 steps as for T=1 the energy and magnetisations have converged significantly and will not change much, and likewise this is the same for the T=2 frame.

''Figure 11'' below shows the results from a 32x32 matrix at T=1 and T=2.

{{multiple image
| width =350
| align = left
| image1 = cg141732x32T1.png
| image2 = cg141732x32T2.png
| footer_align = left
| footer = Figure 11 - Results of running the ILfinalframe.py file at T=1,2 for a 32x32 matrix
}}

''Figure 11'' above shows the results of running the ILfinalframe.py file for a 32x32 matrix at T=1 and T=2. As a result a suitable cut-off of 50000 steps was chosen as the energy and magnetisation has significantly converged, but not as much as it could at 100000 steps. I chose a slightly lower value to ensure that the run times of my monte-carlo simulations in future tasks were not extremely time consuming.

The montecarlostep() function was changed by adding a condition that values only above the pre-determined cut-off were included when determining the average value of energy; energy squared; magnetisation and magnetisations squared from the statistics function. The statistics() function did not need to be modified.

The following code is from the 32x32 matrixː

<pre>def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back

if self.n_cycles > 50000: #only adds values to array of E,E2,M and M2 above the specific cut-off
self.E+=[self.energy()]
self.E2+=[self.energy()**2]
self.M+=[self.magnetisation()]
self.M2+=[self.magnetisation()**2]
self.n_cycles=self.n_cycles+1

return (self.energy(),self.magnetisation())
</pre>

===TASK: Use ILtemperaturerange.py to plot the average energy and magnetisation for each temperature, with error bars, for an <math>8\times 8</math> lattice. Use your intuition and results from the script ILfinalframe.py to estimate how many cycles each simulation should be. The temperature range 0.25 to 5.0 is sufficient. Use as many temperature points as you feel necessary to illustrate the trend, but do not use a temperature spacing larger than 0.5. The NumPy function savetxt() stores your array of output data on disk — you will need it later. Save the file as 8x8.dat so that you know which lattice size it came from.===

Using the modified code, the file ILtemperaturerange.py was ran on an 8x8 matrix between T=0.5 and T=5 with a step of T=0.02 for 10000 Montecarlo steps and the first 1000 steps of each temperature were excluded when calculating the averages. ''Figure 12'' shows the result of the simulation and also included error bars of standard deviation.

[[File:Cg14178x8error.png|1000px|thumb|left|Figure 12 - Graph showing average energy and average magnetisation for an 8x8 lattice with error bars between T=0.5 and T=5]]

 

Below is the source code for the script to produce the graphː

<pre>data8x8=np.loadtxt('8x8.dat') #loads data
temps8x8=data8x8[:,0] #stores temperatures
energies8x8=data8x8[:,1] #stores average energy for each T
energysq8x8=data8x8[:,2] #stores average energy squared for each T
mag8x8=data8x8[:,3] #stores magnetisation for each T
magsq8x8=data8x8[:,4] #stores magnetisation squared for each T
stde8x8=data8x8[:,5] #edited ILtemperaturerange.py to record the standard deviation of the energy for each T
stdm8x8=data8x8[:,6] #edited ILtemperaturerange.py to record the standard deviation of the magnetisation for each T

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.errorbar(temps8x8, np.array(energies8x8)/64,yerr=np.divide(stde8x8,64),color='black',ecolor='teal',alpha=0.8) #plots energy per spin against T
magax.errorbar(temps8x8, np.array(mag8x8)/64,yerr=np.divide(stdm8x8,64),alpha=0.8,ecolor='salmon',color='black') #plots magnetisation per spin against T on separate graph
pl.savefig('8x8error.png',bbox_inches='tight') #saves figure
pl.show()

</pre>

==Section 6 - The effect of system size==

===TASK: Repeat the final task of the previous section for the following lattice sizes: 2x2, 4x4, 8x8, 16x16, 32x32. Make sure that you name each datafile that your produce after the corresponding lattice size! Write a Python script to make a plot showing the energy per spin versus temperature for each of your lattice sizes. Hint: the NumPy loadtxt function is the reverse of the savetxt function, and can be used to read your previously saved files into the script. Repeat this for the magnetisation. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. How big a lattice do you think is big enough to capture the long range fluctuations?===

The python script for this section is identical as for the 8x8 graph above in Figure 12 with the relevant files and variables changed accordingly.

Each matrix was simulated using the ILtemperaturerange.py file between T=0.5 and T=5 with a step of T=0.02.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2error.png
| caption1 = 2x2 matrix - 5000 steps, cut-off = 30 steps
| image2 = 4x4error.png
| caption2 = 4x4 matrix - 1000 steps, cut-off = 200 steps
| image3 =cg141716x16error.png
| caption3 = 16x16 matrix - 50000 steps, cut-off = 15000 steps
| image4 =cg141732x32error.png
| caption4 = 32x32 matrix - 200000 steps, cut-off = 50000 steps
| footer_align = left
| footer = Figure 13 - Results of running the ILtemperaturerange.py file for 2x2, 4x4, 16x16 and 32x32 matrices.
}}

 

==Section 7 - Determining the Heat Capacity==

===TASK: By definition, <math>C = \frac{\partial \left\langle E\right\rangle}{\partial T}</math>. From this, show that <math>C = \frac{\mathrm{Var}[E]}{k_B T^2}</math> (Where <math>\mathrm{Var}[E]</math> is the variance in <math>E</math>.)===

Recall from statistical thermodynamics that the average energy of a system is the sum across all microstates of the probability of that microstate multiplied by the energy of that microstate, which is defined mathematically asː <math>\langle E \rangle = \sum_i p_{i}\epsilon_{i}</math>.

The partition function <math>q</math> is defined as <math>q = \sum_{i} exp(-\beta \epsilon_{i})</math> where <math>\beta =\frac{1}{k_BT}</math>and the probability, <math>p_{i}</math> can be defined in terms of the partition function as <math>p_{i} = \frac{exp(-\beta \epsilon_{i})}{\sum_{i} exp(-\beta \epsilon_{i})} = \frac{exp(-\beta \epsilon_{i})}{q}</math>.

As a result, <math>\langle E \rangle</math> can be re-written as <math>\langle E \rangle = \sum_{i} \frac{\epsilon_{i} exp(-\beta \epsilon_{i})}{q} = -\frac{1}{q} \frac{\partial}{\partial \beta}\sum_{i}exp(-\beta \epsilon_{i}) = -\frac{1}{q} \frac{\partial q}{\partial \beta}</math>

Likewise, <math>\langle E^2 \rangle = \sum_i p_{i}\epsilon_{i}^{2} = \sum_{i} \frac{\epsilon_{i}^{2}exp(-\beta \epsilon_{i})}{q} = \frac{1}{q} \frac{\partial^{2}}{\partial \beta^{2}}\sum_{i}exp(-\beta \epsilon_{i}) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}}</math>

From definitionː <math>Var[E] = \Delta E^2 = \langle E^2 \rangle - \langle E \rangle^2 </math>

When the definition of <math>\langle E \rangle</math> and <math>\langle E^2 \rangle</math> is written in terms of partition function <math>q</math>ː <math>Var[E] = \langle E^2 \rangle - \langle E \rangle^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \left(\frac{1}{q}\frac{\partial q}{\partial \beta}\right)^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2</math>.

According to the chain ruleː <math>\frac{\partial}{\partial \beta}\left(\frac{1}{q} \frac{\partial q}{\partial \beta}\right) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2 = -\frac{\partial}{\partial \beta}\langle E \rangle = Var[E]</math>

And using the chain rule againː <math>C = \frac{\partial \langle E \rangle}{\partial T}= \left(-\frac{\partial \langle E \rangle}{\partial \beta}\right) \left(-\frac{\partial \beta}{\partial T}\right) = \frac{Var[E]}{k_B T^2}</math>

===TASK: Write a Python script to make a plot showing the heat capacity versus temperature for each of your lattice sizes from the previous section. You may need to do some research to recall the connection between the variance of a variable, <math>\mathrm{Var}[X]</math>, the mean of its square <math>\left\langle X^2\right\rangle</math>, and its squared mean <math>\left\langle X\right\rangle^2</math>. You may find that the data around the peak is very noisy — this is normal, and is a result of being in the critical region. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. ===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb

{{multiple image
| width =300
| align = left
| image1 = cg14172x2heatcap.png
| caption1 = 2x2 Matrix
| image2 = cg14174x4heatcap.png
| caption2 = 4x4 Matrix
| image3 =cg14178x8heatcap.png
| caption3 = 8x8 Matrix
| image4 =cg141716x16heatcap.png
| caption4 = 16x16 Matrix
| image5=cg141732x32heatcap.png
| caption5= 32x32 Matrix
| footer = Figure 14 - Graphs showing Heat Capacity against Temperature for each matrix size
}}

Here is the source code to produce the figuresː
<pre> def heatCap(energies,energysq,T,latsize):
#defines the heat capacity for a given temperature
energiesq=np.multiply(energies,energies) #creates array of (average energies) squared
varE=np.subtract(energysq,energiesq) #defines variance of average energy
tempsq=np.multiply(T,T) #array of temperature squared
return np.array(np.divide(varE,tempsq))/(latsize**2)

heatCap2x2=heatCap(energies2x2,energysq2x2,temps2x2,2) #creates array of heat capacity for each T

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(temps2x2,heatCap2x2,color='orange') #plots heat capacity for each T
pl.savefig('cg14172x2heatcap.png',bbox_inches='tight') #saves figure
pl.show()
</pre>

A general trend from the above graphs is that the peak of the graph shifts towards lower temperatures as the size of the matrix used increases which means the Curie Temperature decreases as matrix size increases.

==Section 8 - Locating the Curie Temperature==
===TASK: A C++ program has been used to run some much longer simulations than would be possible on the college computers in Python. You can view its source code here if you are interested. Each file contains six columns: <math>T, E, E^2, M, M^2, C</math> (the final five quantities are per spin), and you can read them with the NumPy loadtxt function as before. For each lattice size, plot the C++ data against your data. For one lattice size, save a PNG of this comparison and add it to your report — add a legend to the graph to label which is which. To do this, you will need to pass the label="..." keyword to the plot function, then call the legend() function of the axis object (documentation here).===

The python code used to read and plot the C++ data is found in the Jupyter notebook CG1417IsingModelGraphs.ipynb.

''Figure 15'' below shows the C++ plotted against my own data for a 16x16 Matrix.

[[File:Cg141716x16C++.png|400px|thumb|left|Figure 15 - Graph showing my own data against the C++ data for a 16x16 matrix.]]

 

Here is the source code the produce the figuresː
<pre>#fitting C++ data

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.plot(temps2x2, np.array(energies2x2)/4,color='black',alpha=0.7,label='Python Data') #python energy against T
enerax.plot(temps2x2C, energies2x2C, color='red',label='C++ Data') #C energy against T
magax.plot(temps2x2, np.array(mag2x2)/4,color='black',alpha=0.7,label='Python Data') #python magnetisation against T
magax.plot(temps2x2C, mag2x2C,color='red',label='C++ Data') #C energy against T
enerax.legend() #shows legend on energy graph
magax.legend() #shows legend on energy graph
pl.show()
</pre>

The relevant variables and dat files were changed for each matrix.

===TASK: write a script to read the data from a particular file, and plot C vs T, as well as a fitted polynomial. Try changing the degree of the polynomial to improve the fit — in general, it might be difficult to get a good fit! Attach a PNG of an example fit to your report.===

The python script to read and plot the fitted polynomial is found in CG1417PolyfitScript.ipynb

Here is the source code for ''Figure 15''

<pre>data_test = np.loadtxt("16x16C.dat")
T_test = data_test[:,0] #gets temperatures
C_test = data_test[:,5] #gets heat capacity data

#first we fit the polynomial to the data
fit_test = np.polyfit(T_test, C_test, 35) # fit a polynomial

#now we generate interpolated values of the fitted polynomial over the range of our function
T_min_test = 0.5 #np.min(T_test)
T_max_test = 5 #np.max(T_test)

T_range_test = np.linspace(T_min_test, T_max_test, 1000) #generate 1000 evenly spaced points between T_min and T_max
fitted_C_values_test = np.polyval(fit_test, T_range_test)# use the fit object to generate the corresponding values of C

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(T_test,C_test,color='orange',label='C++ Data') #plots C data of heat capacity against temp
heatcapax.plot(T_range_test,fitted_C_values_test,label='Fitted Polynomial') #plots fitted polynomial for whole range of temp
heatcapax.legend()
pl.savefig('FIT_TEST16x16_35.png', bbox_inches='tight') #saves figure
pl.show()
</pre>

Below in ''Figure 16'' is a plot of my Heat Capacity against Temperature data for a 16x16 matrix and features a polynomial of degree 35 plotted against it. Even with a polynomial of such a high degree, it poorly fits the curve and does not fit to the peak of the curve either.

[[File:cg1417FIT_TEST16x16_35.png|thumb|left|400px|Figure 16 - Plot of Heat Capacity against Temperature along with a poorly fitted polynomial of degree 35. ]]

 

===TASK: Modify your script from the previous section. You should still plot the whole temperature range, but fit the polynomial only to the peak of the heat capacity! You should find it easier to get a good fit when restricted to this region===

The script was modified as such that the polynomial was fitted in a set range around the peak of the graph, this is demonstrated in ''Figure 17'' which shows a newly fitted polynomial between a much smaller range of temperatures (T = 2.15-2.55) and a much smaller degree polynomial (3).

[[File:CG1417FIT_16x16C_3.png|thumb|left|400px|Figure 17 - Graph showing Heat Capacity against Temperature for a 16x16 matrix along with a fitted polynomial between a much more restricted range of temperatures and a significantly lower degree of polynomial]]

Upon comparison with ''Figure 16'', the new fitted polynomial is a significantly better fit even for a 3rd degree polynomial and is a much more accurate representation of my data around the peak of the graph and will make it easier to determine the maximum value of Heat Capacity.

 

Here is the source code for ''Figure 17''ː
<pre>data16 = np.loadtxt("16x16C.dat") #loads data to variable

T16 = data16[:,0] #gets temps
C16 = data16[:,5] # gets heat capacities

Tmin16 = 2.15 #chosen min temp
Tmax16 = 2.55 #chosen max temp

selection16 = np.logical_and(T16 > Tmin16, T16 < Tmax16) #choose only those rows where both conditions are true
peak_T_values16 = T16[selection16] #choose temp values in range chosen above
peak_C_values16 = C16[selection16] #choose heat cap values in range of t above

fit16 = np.polyfit(peak_T_values16,peak_C_values16,3) #fit 3rd order polynomial
peak_T_range16 = np.linspace(Tmin16, Tmax16, 1000) #defines 1000 temps within data range
fitted_C_values16 = np.polyval(fit16, peak_T_range16) #use the fit object to get corresponding values of heat cap

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(T16,C16,color='orange',label='C++ Data') #plots C data of heat cap against temp
heatcapax.plot(peak_T_range16,fitted_C_values16,label='Fitted Polynomial') #plots fitted polynomial for small range
heatcapax.legend()
pl.savefig('FIT_16x16C_3.png', bbox_inches='tight') #saves figure
pl.show()

</pre>

===TASK: find the temperature at which the maximum in C occurs for each datafile that you were given. Make a text file containing two colums: the lattice side length (2,4,8, etc.), and the temperature at which C is a maximum. This is your estimate of <math>T_C</math> for that side length. Make a plot that uses the scaling relation given above to determine <math>T_{C,\infty}</math>. By doing a little research online, you should be able to find the theoretical exact Curie temperature for the infinite 2D Ising lattice. How does your value compare to this? Are you surprised by how good/bad the agreement is? Attach a PNG of this final graph to your report, and discuss briefly what you think the major sources of error are in your estimate.===

''Figure 18'' below shows a graph of <math>T_{C,L}</math> against <math>\frac{1}{Lattice Size}</math> to determine the Curie Temperature of an infinite 2D Ising Model Lattice <math>T_{C,\infty}</math>. The black dots represent the raw data obtained from obtaining the temperature at which the Heat Capacity was a maximum for the lattices and the red line in a linear curve fit plotted against the data to allow the y-intercept which is the Curie Temperature for the infinite 2D lattice to be determined.

[[File:cg1417CurieTemp.png|400px|thumb|left|Figure 18 - Plot of 1/Lattice Size against Curie Temperature for that lattice size.]]

The value for <math>T_{C,\inf}</math> obtained from the data is <math>T_{C,\infty} = 2.277 \frac{J}{k_B}</math> with a literature value being <math>T_{C,\infty} = 2.269 \frac{J}{k_B}</math> <ref>L. Onsager, Phys. Rev., 1944, 65, 117--149.</ref>for an infinite square 2D lattice. This means that my result slightly over-estimates the Curie Temperature for the infinite lattice and as a result for an infinite lattice the temperature at which spontaneous magnetisation stops would actually occur at a slightly lower temperature than expected. However, the difference between my value and the literature value is only 0.008 which is incredibly small and the amount of agreement between the two values is somewhat surprising, which means that the error in my estimates of the Curie Temperature for each lattice size is relatively small. The points which have the largest residuals and deviation from the line of best fit in ''Figure 17'' corresponds to the smaller lattice sizes of 2x2 and 4x4 where longer range interactions are more significant. The longer range interactions posed by the boundary conditions are nowhere near as significant for the larger sizes and causes the energy of the smaller matrices to be less accurate and have a larger associated error with the energy and thus the Curie Temperature for that lattice size. This affects the accuracy of the line of best fit and to increase the accuracy of this line, larger lattice sizes of 128x128, 256x256 etc should be included in the calculation for the line of best fit and the smaller matrices ignored.

 

Below is the source code used to generate ''Figure 18''
<pre>
Cmax64x64 = np.max(fitted_C_values64) #finds Cmax for 64x64 matrix - done for others already
Tmax64x64 = peak_T_range64[fitted_C_values64 == Cmax64x64] #finds Tmax corresponding to Cmax

LatSize=[2,4,8,16,32,64] #stores lattice sizes
Tmax=[Tmax2x2,Tmax4x4,Tmax8x8,Tmax16x16,Tmax32x32,Tmax64x64] #stores corresponding Tmax data
np.savetxt('CmaxVSTmax.txt', (LatSize,Tmax)) #writes data to txt file

ScalData=np.loadtxt('CmaxVSTmax.txt') #loads data
LatticeSize=ScalData[0] #gets lattice sizes
TempMax=ScalData[1] #gets max temp or curie temp for each lattice

Lmin1min = np.min(np.divide(1,LatticeSize)) #minimum of 1/LatticeSize values
Lmin1max = np.max(np.divide(1,LatticeSize)) #maximum of 1/LatticeSize values

fitTcl = np.polyfit(np.divide(1,LatticeSize),TempMax, 1) #creates fit object

Lmin1values = np.linspace(Lmin1min, Lmin1max, 1000) #finds 1000 values between min and max x-axis value of 1/LatticeSize
fitted_Tcl_values = np.polyval(fitTcl, Lmin1values) #creates corresponding Curie Temp values for each value in Lmin1values

fig = pl.figure()
scalrelax = fig.add_subplot(1,1,1)
scalrelax.set_xlabel('1/Lattice Size')
scalrelax.set_ylabel('Curie Temperature/ J/k_B')
scalrelax.plot(np.divide(1,LatticeSize),TempMax,color='black',marker='.',linestyle='') #plots Curie Temp against 1/LatticeSize
scalrelax.plot(Lmin1values,fitted_Tcl_values,color='red',marker='',linestyle='-') #plots line of best fit for data above
pl.savefig('CurieTemp.png', bbox_inches='tight') #saves figure
pl.show()

</pre>

== References ==

Rep:Y3CMPCG1417

2019-11-20T10:19:36Z

Cg1417: /* TASK: Look at the documentation for the NumPy sum function. You should be able to modify your magnetisation() function so that it uses this to evaluate M. The energy is a little trickier. Familiarise yourself with the NumPy roll and multiply functio...

==Section 1 - Introduction to the Ising Model==

===TASK: Show that the lowest possible energy for the Ising model is <math>E = -DNJ</math>, where D is the number of dimensions and N is the total number of spins. What is the multiplicity of this state? Calculate its entropy.===

Consider a 1D row of lattice sites of N=3 with spin configuration [+1][+1][+1].

Mathematically the interaction energy is defined asː
<math> -\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} </math> where J is a constant and <math>s_{i}s_{j}</math> is the product between two spins in adjacent lattice sites.

The sum of the interaction energies <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j}</math> can be considered as the sum of the individual interaction energies between spinsː
<math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = \epsilon_{12} + \epsilon_{23} + \epsilon_{13} + \epsilon_{21} + \epsilon_{32} + \epsilon_{31} </math>.

Although lattice sites 1 and 3 are not adjacent they are said to still interact according to the periodic boundary conditions applied.

However, <math>\epsilon_{12} = \epsilon_{21} </math> and <math>\epsilon_{23} = \epsilon_{32}</math> and <math>\epsilon_{13} = \epsilon_{31}</math> which means that all of the interactions within the system are counted twice, hence the total energy needs to be halved, resulting in the following formula being obtainedː <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = 2\epsilon_{12} + 2\epsilon_{13} + 2\epsilon_{23} </math>.

It can be determined that <math>\epsilon_{12} = (+1)(+1) = 1</math> , <math>\epsilon_{13} = (+1)(+1) = 1</math> and <math>\epsilon_{23} = (+1)(+1) = 1</math>.

Thereforeː <math>-\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = -\frac{1}{2} \ J \ (2 + 2 + 2) = -\frac{1}{2} \ J \ 6 = - 3 J = -DNJ</math> for a 1D lattice with <math>D=1</math> and 3 lattice sites <math>N=3</math>

The multiplicity of the system,<math>\Omega = \frac{lattice sites!}{n. spin up!n. spin down!}</math>

Entropy, <math>S</math> is defined as <math>S = k_B ln(\Omega)</math> and so in this case <math>S = k_B ln(\frac{100!}{100!}) = 0</math>

===TASK: Imagine that the system is in the lowest energy configuration. To move to a different state, one of the spins must spontaneously change direction ("flip"). What is the change in energy if this happens <math>(D=3, N=1000)</math>? How much entropy does the system gain by doing soʔ===

In a 3D lattice system, each lattice site has three unique interactions with its neighbours to its left, top and front. In the lowest energy configuration, all spins are parallel and for a system the minimum energy is <math>E = -DNJ</math>, so for the system with <math>N=1000</math> and <math>D=3</math>, the minimum energy is <math>-3000J</math>.

If a single spin is flipped, the product of its spin with its neighbours spin reverses and becomes negative and this increases the total energy of the system. Since 3 unique spin-spin interactions are reversed in sign, the total energy increases by <math>+3J</math>, meaning the new total energy is <math>-2997J</math>

Initially the multiplicity of the system will be <math>\Omega = \frac{1000!}{1000!}</math> , and after the flip, the multiplicity becomes <math> \Omega = \frac{1000!}{999!1!}=1000</math>.

The associated change in entropy, <math>\Delta S = k_B ln(1000) - 0 = 6.91 k_B</math>, which is an expected increase in entropy as the number of possible configurations of the system increases.

===TASK: Calculate the magnetisation of the 1D and 2D lattices in Figure 1. What magnetisation would you expect to observe for an Ising lattice with <math>D = 3,\ N=1000</math> at absolute zero?===

[[File:ThirdYearCMPExpt-IsingSketch.png|thumb|left|Figure 1 - Shows 1D (N = 5), 2D (N = 5x5) and 3D (N = 5x5x5) lattices.]]

Magnetisation is defined as <math>M=\sum_{i} s_i</math>. So for the 1D lattice with <math>N = 5</math> in ''Figure 2'', <math>M = +1</math> and for the 2D lattice with <math>N = 25 , M = +1</math> too.

According to the 3rd Law of thermodynamics, entropy is 0 at absolute zero for a perfect crystalline solid, and consequently it is expected that the lattices will have follow suit and have zero entropy at 0K. To have zero entropy all spins must be parallel as such that magnetisation, <math>M = N</math>. For all the spins to be parallel, there is only one possible configuration. So, for a lattice with <math>N = 1000</math> and <math>D =3</math>, if <math>M = N</math>, then multiplicity, <math>\Omega = 1</math> and entropy, <math>S =k_B ln(1) = 0</math>.

 

==Section 2 - Calculating the Energy and Magnetisation==

===TASK: complete the functions energy() and magnetisation(), which should return the energy of the lattice and the total magnetisation, respectively. In the energy() function you may assume that <math>J=1.0</math> at all times (in fact, we are working in reduced units in which <math>J=k_B</math>, but there will be more information about this in later sections). Do not worry about the efficiency of the code at the moment — we will address the speed in a later part of the experiment.===

<pre>def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
lat=self.lattice #creates lattice and stores it
mag=[]
for i in range(0,len(lat)): #loops through all rows of lattice
for j in range(0,len(lat[i])): #loops through elements of each row
mag+=[lat[i][j]] #adds spin value to mag array
return sum(mag) #sums all spins from mag array
</pre>

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

lat=self.lattice #creates lattice and stores it
left=[]
top=[]

for i in range(0,len(lat)):
for j in range(0,len(lat[i])):
left+=[lat[i][j]*lat[i][j-1]] #multiplies spin by spin to left
top+=[lat[i][j]*lat[i-1][j]] #multiplies spin by spin above it
int_en=left+top #sums spin products from left and top
energy=-sum(int_en) #sums all spin products for each spin to give total

return energy
</pre>

===TASK: Run the ILcheck.py script from the IPython Qt console using the command===

''Figure 2'' shows the results when ILcheck.py was ran on my IsingLattice.py file. The ILcheck.py file was ran several times to ensure the code worked for various random lattices.

[[File:Cg1417ILcheck run.png|thumb|left|500px| Figure 2 - Result from running the ILcheck.py file]]

 

==Section 3 - Introduction to Monte Carlo Simulation==

===TASK: How many configurations are available to a system with 100 spins? To evaluate these expressions, we have to calculate the energy and magnetisation for each of these configurations, then perform the sum. Let's be very, very, generous, and say that we can analyse <math>1\times 10^9</math> configurations per second with our computer. How long will it take to evaluate a single value of <math>\left\langle M\right\rangle_T</math>?===

For a system with 100 lattice sites and two possible spins for each site, there are <math>2^{100}</math>possible configurations for the system. <math>2^{100}= 1.27\times 10^{30} </math>, so if the computer can analyse <math>1\times 10^9</math> configurations per second, then it will take <math>\frac{1.27\times 10^{30}}{10^9} = 1.27\times 10^{21} s</math> to analyse the whole system, which is longer than the age of the universe and therefore is not a practical approach.

===TASK: Implement a single cycle of the above algorithm in the montecarlocycle(T) function. This function should return the energy of your lattice and the magnetisation at the end of the cycle. You may assume that the energy returned by your energy() function is in units of <math>k_B</math>! Complete the statistics() function. This should return the following quantities whenever it is called: <math><E>, <E^2>, <M>, <M^2></math>, and the number of Monte Carlo steps that have elapsed.===
<pre>
E = []
E2 = []
M = []
M2 = []
n_cycles = 0

def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back if rejected else not changed

self.E+=[self.energy()] #records energy
self.E2+=[self.energy()**2] #records energy squared
self.M+=[self.magnetisation()] #records magnetisation
self.M2+=[self.magnetisation()**2] #records magnetisation squared
self.n_cycles=self.n_cycles+1 #adds 1 to run total

return (self.energy(),self.magnetisation())

def statistics(self):
# complete this function so that it calculates the correct values for the averages of E, E*E (E2), M, M*M (M2), and returns them

e=np.mean(self.E)
e2=np.mean(self.E2)
m=np.mean(self.M)
m2=np.mean(self.M2)

return e,e2,m,m2,self.n_cycles
</pre>

''Figure 3'' shows the results of a single run of the montecarlostep() function and the lattice the function operated upon.

[[File:cg1417MonteCarloStep_run.png|thumb|left|Figure 3 - Results from a single montecarlostep() function and the resulting lattice produced along with the correct return from the statistics() function]]

 

===TASK: If <math>T < T_C</math>, do you expect a spontaneous magnetisation (i.e. do you expect <math>\left\langle M\right\rangle \neq 0</math>)? When the state of the simulation appears to stop changing (when you have reached an equilibrium state), use the controls to export the output to PNG and attach this to your report. You should also include the output from your statistics() function.===

If the temperature of the system is less than the Curie Temperature, <math>T_C</math> then spontaneous magnetisation can occur and the system will tend to its lowest energy state where all of the spins are parallel - this is a property of ferromagnetic materials.

[[File:Cg1417ILanim_run.png|400px|thumb|left|Figure 4 - Results from running the ILanim.py file - shows the energy and magnetisation converging over time]]

''Figure 4'' shows that over time the the system spontaneously converges to the minimum energy state with all of the spins parallel to one another and shows, as I expected, that spontaneous magnetisation occurs and also shows that the temperature of this simulation is below the Curie Temperature, <math>T < T_C</math>.

 

==Section 4 - Accelerating the Code==

===TASK: Use the script ILtimetrial.py to record how long your current version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 5'' show the results of running the ILtimetrial.py file on my code three timesː

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1.png
| width1=500
| image2=cg1417ILtimetrial_run2.png
| width2=500
| image3=cg1417ILtimetrial_run3.png
| width3=500
| footer = Figure 5 - Results of running the ILtimetrial.py file on my code three separate times
}}
 

This gave me an avergage time of <math>24.3 s \pm 0.2s</math>

===TASK: Look at the documentation for the NumPy sum function. You should be able to modify your magnetisation() function so that it uses this to evaluate M. The energy is a little trickier. Familiarise yourself with the NumPy roll and multiply functions, and use these to replace your energy double loop (you will need to call roll and multiply twice!).===

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

left=multiply(roll(self.lattice,1,axis=1),self.lattice) #product of spin with spin left of it
top=multiply(roll(self.lattice,-1,axis=0),self.lattice) #product of spin with spin above it

int_en=sum(left+top) #sum of array containing sum of left and top spin products for each spin

energy = -sum(int_en) #calculates the total energy of system
return energy

def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
return sum(sum(self.lattice)) #adds up all spins in lattice
</pre>
The use of the bumpy modules reduces the amount of code required and removes the need for loops making the code significantly shorter, and is therefore expected to run ILtimetrial.py faster than the initial code developed.

===TASK: Use the script ILtimetrial.py to record how long your new version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 6'' shows the result of running the ILtimetrial.py on my new accelerated code.

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1fast.png
| width1=500
| image2=ILtimetrial_run2fast.png
| width2=500
| image3=ILtimetrial_run3fast.png
| width3=500
| footer = Figure 6 - Results of running the ILtimetrial.py file on my new updated and accelerated code.
}}
 

The accelerated code is much faster upon using the roll, multiply and sum modules with a new average time of <math>0.790 s \pm 0.005 </math>

==Section 5 - The effect of temperature==

===TASK: The script ILfinalframe.py runs for a given number of cycles at a given temperature, then plots a depiction of the final lattice state as well as graphs of the energy and magnetisation as a function of cycle number. This is much quicker than animating every frame! Experiment with different temperature and lattice sizes. How many cycles are typically needed for the system to go from its random starting position to the equilibrium state? Modify your statistics() and montecarlostep() functions so that the first N cycles of the simulation are ignored when calculating the averages. You should state in your report what period you chose to ignore, and include graphs from ILfinalframe.py to illustrate your motivation in choosing this figure.===

''Figure 7'' below shows the results from running the ILfinalframe.py for 2x2 lattice at T=1,2,3,5.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2T1.png
| image2 = cg14172x2T2.png
| image3 =cg14172x2T3.png
| image4 =cg14172x2T5.png
| footer_align = left
| footer = Figure 7 - Results of running the ILfinalframe.py file at T=1,2,3,5 for a 2x2 matrix.
}}

 

For a 2x2 matrix, a suitable cut-off point to exclude from the avergage energies and magnetisations is where the energy and magnetisations per spin are constant, which is 30 steps. For T=3 and T=5 the graphs do not converge because it is possible that these temperatures are higher than the Curie Temperature and as such spontaneous magnetisation will not occur and the system will not diverge to the lowest energy state. At the higher temperatures, there are larger thermal fluctations and the Boltzmann factor is more significant allowing the system to move away from the lowest energy state easier. As a result moving forwards, a suitable cut-off point will only be determined from T=1 and T=2 graphs for the larger matrices.

''Figure 8'' shows the results from running a 4x4 lattice at T=1,2 and 3.

{{multiple image
| width =350
| align = left
| image1 = cg14174x4T1.png
| image2 = cg14174x4T2.png
| image3 =cg14174x4T3.png
| footer_align = left
| footer = Figure 8 - Results of running the ILfinalframe.py file at T=1,2,3 for a 4x4 matrix.
}}

From ''Figure 8'', a suitable cut-off point for the energy and magnetisations is 200 as this is after where the energy and magnetisation has converged for T=1, and is after the initial large drop in energy for T=2, even though there are a few small fluctuations after 200 steps. The result from T=3 has been included to show the large fluctuations for the larger temperatures, and supporting my choice to determine the cut-off from T=1 and T=2 only.

''Figure 9'' shows the results for an 8x8 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg14178x8T1.png
| image2 = cg14178x8T2.png
| footer_align = left
| footer = Figure 9 - Results of running the ILfinalframe.py file at T=1,2 for an 8x8 matrix
}}

From ''Figure 9'' above, a suitable cut-off point is 1000 steps as this is where the energy and magnetisation has easily converged by and is also the point after which the initial large drop in energy has been overcome for T=2 too.

''Figure 10'' shows the result of running the ILfinalframe.py for a 16x16 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg141716x16T1.png
| image2 = cg141716x16T2.png
| footer_align = left
| footer = Figure 10 - Results of running the ILfinalframe.py file at T=1,2 for a 16x16 matrix
}}

From ''Figure 10'', a suitable cut-off point is 15000 steps as for T=1 the energy and magnetisations have converged significantly and will not change much, and likewise this is the same for the T=2 frame.

''Figure 11'' below shows the results from a 32x32 matrix at T=1 and T=2.

{{multiple image
| width =350
| align = left
| image1 = cg141732x32T1.png
| image2 = cg141732x32T2.png
| footer_align = left
| footer = Figure 11 - Results of running the ILfinalframe.py file at T=1,2 for a 32x32 matrix
}}

''Figure 11'' above shows the results of running the ILfinalframe.py file for a 32x32 matrix at T=1 and T=2. As a result a suitable cut-off of 50000 steps was chosen as the energy and magnetisation has significantly converged, but not as much as it could at 100000 steps. I chose a slightly lower value to ensure that the run times of my monte-carlo simulations in future tasks were not extremely time consuming.

The montecarlostep() function was changed by adding a condition that values only above the pre-determined cut-off were included when determining the average value of energy; energy squared; magnetisation and magnetisations squared from the statistics function. The statistics() function did not need to be modified.

The following code is from the 32x32 matrixː

<pre>def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back

if self.n_cycles > 50000: #only adds values to array of E,E2,M and M2 is above specific cut-off
self.E+=[self.energy()]
self.E2+=[self.energy()**2]
self.M+=[self.magnetisation()]
self.M2+=[self.magnetisation()**2]
self.n_cycles=self.n_cycles+1

return (self.energy(),self.magnetisation())
</pre>

===TASK: Use ILtemperaturerange.py to plot the average energy and magnetisation for each temperature, with error bars, for an <math>8\times 8</math> lattice. Use your intuition and results from the script ILfinalframe.py to estimate how many cycles each simulation should be. The temperature range 0.25 to 5.0 is sufficient. Use as many temperature points as you feel necessary to illustrate the trend, but do not use a temperature spacing larger than 0.5. The NumPy function savetxt() stores your array of output data on disk — you will need it later. Save the file as 8x8.dat so that you know which lattice size it came from.===

Using the modified code, the file ILtemperaturerange.py was ran on an 8x8 matrix between T=0.5 and T=5 with a step of T=0.02 for 10000 Montecarlo steps and the first 1000 steps of each temperature were excluded when calculating the averages. ''Figure 12'' shows the result of the simulation and also included error bars of standard deviation.

[[File:Cg14178x8error.png|1000px|thumb|left|Figure 12 - Graph showing average energy and average magnetisation for an 8x8 lattice with error bars between T=0.5 and T=5]]

 

Below is the source code for the script to produce the graphː

<pre>data8x8=np.loadtxt('8x8.dat') #loads data
temps8x8=data8x8[:,0] #stores temperatures
energies8x8=data8x8[:,1] #stores average energy for each T
energysq8x8=data8x8[:,2] #stores average energy squared for each T
mag8x8=data8x8[:,3] #stores magnetisation for each T
magsq8x8=data8x8[:,4] #stores magnetisation squared for each T
stde8x8=data8x8[:,5] #edited ILtemperaturerange.py to record the standard deviation of the energy for each T
stdm8x8=data8x8[:,6] #edited ILtemperaturerange.py to record the standard deviation of the magnetisation for each T

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.errorbar(temps8x8, np.array(energies8x8)/64,yerr=np.divide(stde8x8,64),color='black',ecolor='teal',alpha=0.8) #plots energy per spin against T
magax.errorbar(temps8x8, np.array(mag8x8)/64,yerr=np.divide(stdm8x8,64),alpha=0.8,ecolor='salmon',color='black') #plots magnetisation per spin against T on separate graph
pl.savefig('8x8error.png',bbox_inches='tight') #saves figure
pl.show()

</pre>

==Section 6 - The effect of system size==

===TASK: Repeat the final task of the previous section for the following lattice sizes: 2x2, 4x4, 8x8, 16x16, 32x32. Make sure that you name each datafile that your produce after the corresponding lattice size! Write a Python script to make a plot showing the energy per spin versus temperature for each of your lattice sizes. Hint: the NumPy loadtxt function is the reverse of the savetxt function, and can be used to read your previously saved files into the script. Repeat this for the magnetisation. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. How big a lattice do you think is big enough to capture the long range fluctuations?===

The python script for this section is identical as for the 8x8 graph above in Figure 12 with the relevant files and variables changed accordingly.

Each matrix was simulated using the ILtemperaturerange.py file between T=0.5 and T=5 with a step of T=0.02.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2error.png
| caption1 = 2x2 matrix - 5000 steps, cut-off = 30 steps
| image2 = 4x4error.png
| caption2 = 4x4 matrix - 1000 steps, cut-off = 200 steps
| image3 =cg141716x16error.png
| caption3 = 16x16 matrix - 50000 steps, cut-off = 15000 steps
| image4 =cg141732x32error.png
| caption4 = 32x32 matrix - 200000 steps, cut-off = 50000 steps
| footer_align = left
| footer = Figure 13 - Results of running the ILtemperaturerange.py file for 2x2, 4x4, 16x16 and 32x32 matrices.
}}

 

==Section 7 - Determining the Heat Capacity==

===TASK: By definition, <math>C = \frac{\partial \left\langle E\right\rangle}{\partial T}</math>. From this, show that <math>C = \frac{\mathrm{Var}[E]}{k_B T^2}</math> (Where <math>\mathrm{Var}[E]</math> is the variance in <math>E</math>.)===

Recall from statistical thermodynamics that the average energy of a system is the sum across all microstates of the probability of that microstate multiplied by the energy of that microstate, which is defined mathematically asː <math>\langle E \rangle = \sum_i p_{i}\epsilon_{i}</math>.

The partition function <math>q</math> is defined as <math>q = \sum_{i} exp(-\beta \epsilon_{i})</math> where <math>\beta =\frac{1}{k_BT}</math>and the probability, <math>p_{i}</math> can be defined in terms of the partition function as <math>p_{i} = \frac{exp(-\beta \epsilon_{i})}{\sum_{i} exp(-\beta \epsilon_{i})} = \frac{exp(-\beta \epsilon_{i})}{q}</math>.

As a result, <math>\langle E \rangle</math> can be re-written as <math>\langle E \rangle = \sum_{i} \frac{\epsilon_{i} exp(-\beta \epsilon_{i})}{q} = -\frac{1}{q} \frac{\partial}{\partial \beta}\sum_{i}exp(-\beta \epsilon_{i}) = -\frac{1}{q} \frac{\partial q}{\partial \beta}</math>

Likewise, <math>\langle E^2 \rangle = \sum_i p_{i}\epsilon_{i}^{2} = \sum_{i} \frac{\epsilon_{i}^{2}exp(-\beta \epsilon_{i})}{q} = \frac{1}{q} \frac{\partial^{2}}{\partial \beta^{2}}\sum_{i}exp(-\beta \epsilon_{i}) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}}</math>

From definitionː <math>Var[E] = \Delta E^2 = \langle E^2 \rangle - \langle E \rangle^2 </math>

When the definition of <math>\langle E \rangle</math> and <math>\langle E^2 \rangle</math> is written in terms of partition function <math>q</math>ː <math>Var[E] = \langle E^2 \rangle - \langle E \rangle^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \left(\frac{1}{q}\frac{\partial q}{\partial \beta}\right)^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2</math>.

According to the chain ruleː <math>\frac{\partial}{\partial \beta}\left(\frac{1}{q} \frac{\partial q}{\partial \beta}\right) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2 = -\frac{\partial}{\partial \beta}\langle E \rangle = Var[E]</math>

And using the chain rule againː <math>C = \frac{\partial \langle E \rangle}{\partial T}= \left(-\frac{\partial \langle E \rangle}{\partial \beta}\right) \left(-\frac{\partial \beta}{\partial T}\right) = \frac{Var[E]}{k_B T^2}</math>

===TASK: Write a Python script to make a plot showing the heat capacity versus temperature for each of your lattice sizes from the previous section. You may need to do some research to recall the connection between the variance of a variable, <math>\mathrm{Var}[X]</math>, the mean of its square <math>\left\langle X^2\right\rangle</math>, and its squared mean <math>\left\langle X\right\rangle^2</math>. You may find that the data around the peak is very noisy — this is normal, and is a result of being in the critical region. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. ===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb

{{multiple image
| width =300
| align = left
| image1 = cg14172x2heatcap.png
| caption1 = 2x2 Matrix
| image2 = cg14174x4heatcap.png
| caption2 = 4x4 Matrix
| image3 =cg14178x8heatcap.png
| caption3 = 8x8 Matrix
| image4 =cg141716x16heatcap.png
| caption4 = 16x16 Matrix
| image5=cg141732x32heatcap.png
| caption5= 32x32 Matrix
| footer = Figure 14 - Graphs showing Heat Capacity against Temperature for each matrix size
}}

Here is the source code to produce the figuresː
<pre> def heatCap(energies,energysq,T,latsize):
#defines the heat capacity for a given temperature
energiesq=np.multiply(energies,energies) #creates array of (average energies) squared
varE=np.subtract(energysq,energiesq) #defines variance of average energy
tempsq=np.multiply(T,T) #array of temperature squared
return np.array(np.divide(varE,tempsq))/(latsize**2)

heatCap2x2=heatCap(energies2x2,energysq2x2,temps2x2,2) #creates array of heat capacity for each T

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(temps2x2,heatCap2x2,color='orange') #plots heat capacity for each T
pl.savefig('cg14172x2heatcap.png',bbox_inches='tight') #saves figure
pl.show()
</pre>

A general trend from the above graphs is that the peak of the graph shifts towards lower temperatures as the size of the matrix used increases which means the Curie Temperature decreases as matrix size increases.

==Section 8 - Locating the Curie Temperature==
===TASK: A C++ program has been used to run some much longer simulations than would be possible on the college computers in Python. You can view its source code here if you are interested. Each file contains six columns: <math>T, E, E^2, M, M^2, C</math> (the final five quantities are per spin), and you can read them with the NumPy loadtxt function as before. For each lattice size, plot the C++ data against your data. For one lattice size, save a PNG of this comparison and add it to your report — add a legend to the graph to label which is which. To do this, you will need to pass the label="..." keyword to the plot function, then call the legend() function of the axis object (documentation here).===

The python code used to read and plot the C++ data is found in the Jupyter notebook CG1417IsingModelGraphs.ipynb.

''Figure 15'' below shows the C++ plotted against my own data for a 16x16 Matrix.

[[File:Cg141716x16C++.png|400px|thumb|left|Figure 15 - Graph showing my own data against the C++ data for a 16x16 matrix.]]

 

Here is the source code the produce the figuresː
<pre>#fitting C++ data

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.plot(temps2x2, np.array(energies2x2)/4,color='black',alpha=0.7,label='Python Data') #python energy against T
enerax.plot(temps2x2C, energies2x2C, color='red',label='C++ Data') #C energy against T
magax.plot(temps2x2, np.array(mag2x2)/4,color='black',alpha=0.7,label='Python Data') #python magnetisation against T
magax.plot(temps2x2C, mag2x2C,color='red',label='C++ Data') #C energy against T
enerax.legend() #shows legend on energy graph
magax.legend() #shows legend on energy graph
pl.show()
</pre>

The relevant variables and dat files were changed for each matrix.

===TASK: write a script to read the data from a particular file, and plot C vs T, as well as a fitted polynomial. Try changing the degree of the polynomial to improve the fit — in general, it might be difficult to get a good fit! Attach a PNG of an example fit to your report.===

The python script to read and plot the fitted polynomial is found in CG1417PolyfitScript.ipynb

Here is the source code for ''Figure 15''

<pre>data_test = np.loadtxt("16x16C.dat")
T_test = data_test[:,0] #gets temperatures
C_test = data_test[:,5] #gets heat capacity data

#first we fit the polynomial to the data
fit_test = np.polyfit(T_test, C_test, 35) # fit a polynomial

#now we generate interpolated values of the fitted polynomial over the range of our function
T_min_test = 0.5 #np.min(T_test)
T_max_test = 5 #np.max(T_test)

T_range_test = np.linspace(T_min_test, T_max_test, 1000) #generate 1000 evenly spaced points between T_min and T_max
fitted_C_values_test = np.polyval(fit_test, T_range_test)# use the fit object to generate the corresponding values of C

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(T_test,C_test,color='orange',label='C++ Data') #plots C data of heat capacity against temp
heatcapax.plot(T_range_test,fitted_C_values_test,label='Fitted Polynomial') #plots fitted polynomial for whole range of temp
heatcapax.legend()
pl.savefig('FIT_TEST16x16_35.png', bbox_inches='tight') #saves figure
pl.show()
</pre>

Below in ''Figure 16'' is a plot of my Heat Capacity against Temperature data for a 16x16 matrix and features a polynomial of degree 35 plotted against it. Even with a polynomial of such a high degree, it poorly fits the curve and does not fit to the peak of the curve either.

[[File:cg1417FIT_TEST16x16_35.png|thumb|left|400px|Figure 16 - Plot of Heat Capacity against Temperature along with a poorly fitted polynomial of degree 35. ]]

 

===TASK: Modify your script from the previous section. You should still plot the whole temperature range, but fit the polynomial only to the peak of the heat capacity! You should find it easier to get a good fit when restricted to this region===

The script was modified as such that the polynomial was fitted in a set range around the peak of the graph, this is demonstrated in ''Figure 17'' which shows a newly fitted polynomial between a much smaller range of temperatures (T = 2.15-2.55) and a much smaller degree polynomial (3).

[[File:CG1417FIT_16x16C_3.png|thumb|left|400px|Figure 17 - Graph showing Heat Capacity against Temperature for a 16x16 matrix along with a fitted polynomial between a much more restricted range of temperatures and a significantly lower degree of polynomial]]

Upon comparison with ''Figure 16'', the new fitted polynomial is a significantly better fit even for a 3rd degree polynomial and is a much more accurate representation of my data around the peak of the graph and will make it easier to determine the maximum value of Heat Capacity.

 

Here is the source code for ''Figure 17''ː
<pre>data16 = np.loadtxt("16x16C.dat") #loads data to variable

T16 = data16[:,0] #gets temps
C16 = data16[:,5] # gets heat capacities

Tmin16 = 2.15 #chosen min temp
Tmax16 = 2.55 #chosen max temp

selection16 = np.logical_and(T16 > Tmin16, T16 < Tmax16) #choose only those rows where both conditions are true
peak_T_values16 = T16[selection16] #choose temp values in range chosen above
peak_C_values16 = C16[selection16] #choose heat cap values in range of t above

fit16 = np.polyfit(peak_T_values16,peak_C_values16,3) #fit 3rd order polynomial
peak_T_range16 = np.linspace(Tmin16, Tmax16, 1000) #defines 1000 temps within data range
fitted_C_values16 = np.polyval(fit16, peak_T_range16) #use the fit object to get corresponding values of heat cap

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(T16,C16,color='orange',label='C++ Data') #plots C data of heat cap against temp
heatcapax.plot(peak_T_range16,fitted_C_values16,label='Fitted Polynomial') #plots fitted polynomial for small range
heatcapax.legend()
pl.savefig('FIT_16x16C_3.png', bbox_inches='tight') #saves figure
pl.show()

</pre>

===TASK: find the temperature at which the maximum in C occurs for each datafile that you were given. Make a text file containing two colums: the lattice side length (2,4,8, etc.), and the temperature at which C is a maximum. This is your estimate of <math>T_C</math> for that side length. Make a plot that uses the scaling relation given above to determine <math>T_{C,\infty}</math>. By doing a little research online, you should be able to find the theoretical exact Curie temperature for the infinite 2D Ising lattice. How does your value compare to this? Are you surprised by how good/bad the agreement is? Attach a PNG of this final graph to your report, and discuss briefly what you think the major sources of error are in your estimate.===

''Figure 18'' below shows a graph of <math>T_{C,L}</math> against <math>\frac{1}{Lattice Size}</math> to determine the Curie Temperature of an infinite 2D Ising Model Lattice <math>T_{C,\infty}</math>. The black dots represent the raw data obtained from obtaining the temperature at which the Heat Capacity was a maximum for the lattices and the red line in a linear curve fit plotted against the data to allow the y-intercept which is the Curie Temperature for the infinite 2D lattice to be determined.

[[File:cg1417CurieTemp.png|400px|thumb|left|Figure 18 - Plot of 1/Lattice Size against Curie Temperature for that lattice size.]]

The value for <math>T_{C,\inf}</math> obtained from the data is <math>T_{C,\infty} = 2.277 \frac{J}{k_B}</math> with a literature value being <math>T_{C,\infty} = 2.269 \frac{J}{k_B}</math> <ref>L. Onsager, Phys. Rev., 1944, 65, 117--149.</ref>for an infinite square 2D lattice. This means that my result slightly over-estimates the Curie Temperature for the infinite lattice and as a result for an infinite lattice the temperature at which spontaneous magnetisation stops would actually occur at a slightly lower temperature than expected. However, the difference between my value and the literature value is only 0.008 which is incredibly small and the amount of agreement between the two values is somewhat surprising, which means that the error in my estimates of the Curie Temperature for each lattice size is relatively small. The points which have the largest residuals and deviation from the line of best fit in ''Figure 17'' corresponds to the smaller lattice sizes of 2x2 and 4x4 where longer range interactions are more significant. The longer range interactions posed by the boundary conditions are nowhere near as significant for the larger sizes and causes the energy of the smaller matrices to be less accurate and have a larger associated error with the energy and thus the Curie Temperature for that lattice size. This affects the accuracy of the line of best fit and to increase the accuracy of this line, larger lattice sizes of 128x128, 256x256 etc should be included in the calculation for the line of best fit and the smaller matrices ignored.

 

Below is the source code used to generate ''Figure 18''
<pre>
Cmax64x64 = np.max(fitted_C_values64) #finds Cmax for 64x64 matrix - done for others already
Tmax64x64 = peak_T_range64[fitted_C_values64 == Cmax64x64] #finds Tmax corresponding to Cmax

LatSize=[2,4,8,16,32,64] #stores lattice sizes
Tmax=[Tmax2x2,Tmax4x4,Tmax8x8,Tmax16x16,Tmax32x32,Tmax64x64] #stores corresponding Tmax data
np.savetxt('CmaxVSTmax.txt', (LatSize,Tmax)) #writes data to txt file

ScalData=np.loadtxt('CmaxVSTmax.txt') #loads data
LatticeSize=ScalData[0] #gets lattice sizes
TempMax=ScalData[1] #gets max temp or curie temp for each lattice

Lmin1min = np.min(np.divide(1,LatticeSize)) #minimum of 1/LatticeSize values
Lmin1max = np.max(np.divide(1,LatticeSize)) #maximum of 1/LatticeSize values

fitTcl = np.polyfit(np.divide(1,LatticeSize),TempMax, 1) #creates fit object

Lmin1values = np.linspace(Lmin1min, Lmin1max, 1000) #finds 1000 values between min and max x-axis value of 1/LatticeSize
fitted_Tcl_values = np.polyval(fitTcl, Lmin1values) #creates corresponding Curie Temp values for each value in Lmin1values

fig = pl.figure()
scalrelax = fig.add_subplot(1,1,1)
scalrelax.set_xlabel('1/Lattice Size')
scalrelax.set_ylabel('Curie Temperature/ J/k_B')
scalrelax.plot(np.divide(1,LatticeSize),TempMax,color='black',marker='.',linestyle='') #plots Curie Temp against 1/LatticeSize
scalrelax.plot(Lmin1values,fitted_Tcl_values,color='red',marker='',linestyle='-') #plots line of best fit for data above
pl.savefig('CurieTemp.png', bbox_inches='tight') #saves figure
pl.show()

</pre>

== References ==

Rep:Y3CMPCG1417

2019-11-20T10:16:19Z

==Section 1 - Introduction to the Ising Model==

===TASK: Show that the lowest possible energy for the Ising model is <math>E = -DNJ</math>, where D is the number of dimensions and N is the total number of spins. What is the multiplicity of this state? Calculate its entropy.===

Consider a 1D row of lattice sites of N=3 with spin configuration [+1][+1][+1].

Mathematically the interaction energy is defined asː
<math> -\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} </math> where J is a constant and <math>s_{i}s_{j}</math> is the product between two spins in adjacent lattice sites.

The sum of the interaction energies <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j}</math> can be considered as the sum of the individual interaction energies between spinsː
<math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = \epsilon_{12} + \epsilon_{23} + \epsilon_{13} + \epsilon_{21} + \epsilon_{32} + \epsilon_{31} </math>.

Although lattice sites 1 and 3 are not adjacent they are said to still interact according to the periodic boundary conditions applied.

However, <math>\epsilon_{12} = \epsilon_{21} </math> and <math>\epsilon_{23} = \epsilon_{32}</math> and <math>\epsilon_{13} = \epsilon_{31}</math> which means that all of the interactions within the system are counted twice, hence the total energy needs to be halved, resulting in the following formula being obtainedː <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = 2\epsilon_{12} + 2\epsilon_{13} + 2\epsilon_{23} </math>.

It can be determined that <math>\epsilon_{12} = (+1)(+1) = 1</math> , <math>\epsilon_{13} = (+1)(+1) = 1</math> and <math>\epsilon_{23} = (+1)(+1) = 1</math>.

Thereforeː <math>-\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = -\frac{1}{2} \ J \ (2 + 2 + 2) = -\frac{1}{2} \ J \ 6 = - 3 J = -DNJ</math> for a 1D lattice with <math>D=1</math> and 3 lattice sites <math>N=3</math>

The multiplicity of the system,<math>\Omega = \frac{lattice sites!}{n. spin up!n. spin down!}</math>

Entropy, <math>S</math> is defined as <math>S = k_B ln(\Omega)</math> and so in this case <math>S = k_B ln(\frac{100!}{100!}) = 0</math>

===TASK: Imagine that the system is in the lowest energy configuration. To move to a different state, one of the spins must spontaneously change direction ("flip"). What is the change in energy if this happens <math>(D=3, N=1000)</math>? How much entropy does the system gain by doing soʔ===

In a 3D lattice system, each lattice site has three unique interactions with its neighbours to its left, top and front. In the lowest energy configuration, all spins are parallel and for a system the minimum energy is <math>E = -DNJ</math>, so for the system with <math>N=1000</math> and <math>D=3</math>, the minimum energy is <math>-3000J</math>.

If a single spin is flipped, the product of its spin with its neighbours spin reverses and becomes negative and this increases the total energy of the system. Since 3 unique spin-spin interactions are reversed in sign, the total energy increases by <math>+3J</math>, meaning the new total energy is <math>-2997J</math>

Initially the multiplicity of the system will be <math>\Omega = \frac{1000!}{1000!}</math> , and after the flip, the multiplicity becomes <math> \Omega = \frac{1000!}{999!1!}=1000</math>.

The associated change in entropy, <math>\Delta S = k_B ln(1000) - 0 = 6.91 k_B</math>, which is an expected increase in entropy as the number of possible configurations of the system increases.

===TASK: Calculate the magnetisation of the 1D and 2D lattices in Figure 1. What magnetisation would you expect to observe for an Ising lattice with <math>D = 3,\ N=1000</math> at absolute zero?===

[[File:ThirdYearCMPExpt-IsingSketch.png|thumb|left|Figure 1 - Shows 1D (N = 5), 2D (N = 5x5) and 3D (N = 5x5x5) lattices.]]

Magnetisation is defined as <math>M=\sum_{i} s_i</math>. So for the 1D lattice with <math>N = 5</math> in ''Figure 2'', <math>M = +1</math> and for the 2D lattice with <math>N = 25 , M = +1</math> too.

According to the 3rd Law of thermodynamics, entropy is 0 at absolute zero for a perfect crystalline solid, and consequently it is expected that the lattices will have follow suit and have zero entropy at 0K. To have zero entropy all spins must be parallel as such that magnetisation, <math>M = N</math>. For all the spins to be parallel, there is only one possible configuration. So, for a lattice with <math>N = 1000</math> and <math>D =3</math>, if <math>M = N</math>, then multiplicity, <math>\Omega = 1</math> and entropy, <math>S =k_B ln(1) = 0</math>.

 

==Section 2 - Calculating the Energy and Magnetisation==

===TASK: complete the functions energy() and magnetisation(), which should return the energy of the lattice and the total magnetisation, respectively. In the energy() function you may assume that <math>J=1.0</math> at all times (in fact, we are working in reduced units in which <math>J=k_B</math>, but there will be more information about this in later sections). Do not worry about the efficiency of the code at the moment — we will address the speed in a later part of the experiment.===

<pre>def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
lat=self.lattice #creates lattice and stores it
mag=[]
for i in range(0,len(lat)): #loops through all rows of lattice
for j in range(0,len(lat[i])): #loops through elements of each row
mag+=[lat[i][j]] #adds spin value to mag array
return sum(mag) #sums all spins from mag array
</pre>

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

lat=self.lattice #creates lattice and stores it
left=[]
top=[]

for i in range(0,len(lat)):
for j in range(0,len(lat[i])):
left+=[lat[i][j]*lat[i][j-1]] #multiplies spin by spin to left
top+=[lat[i][j]*lat[i-1][j]] #multiplies spin by spin above it
int_en=left+top #sums spin products from left and top
energy=-sum(int_en) #sums all spin products for each spin to give total

return energy
</pre>

===TASK: Run the ILcheck.py script from the IPython Qt console using the command===

''Figure 2'' shows the results when ILcheck.py was ran on my IsingLattice.py file. The ILcheck.py file was ran several times to ensure the code worked for various random lattices.

[[File:Cg1417ILcheck run.png|thumb|left|500px| Figure 2 - Result from running the ILcheck.py file]]

 

==Section 3 - Introduction to Monte Carlo Simulation==

===TASK: How many configurations are available to a system with 100 spins? To evaluate these expressions, we have to calculate the energy and magnetisation for each of these configurations, then perform the sum. Let's be very, very, generous, and say that we can analyse <math>1\times 10^9</math> configurations per second with our computer. How long will it take to evaluate a single value of <math>\left\langle M\right\rangle_T</math>?===

For a system with 100 lattice sites and two possible spins for each site, there are <math>2^{100}</math>possible configurations for the system. <math>2^{100}= 1.27\times 10^{30} </math>, so if the computer can analyse <math>1\times 10^9</math> configurations per second, then it will take <math>\frac{1.27\times 10^{30}}{10^9} = 1.27\times 10^{21} s</math> to analyse the whole system, which is longer than the age of the universe and therefore is not a practical approach.

===TASK: Implement a single cycle of the above algorithm in the montecarlocycle(T) function. This function should return the energy of your lattice and the magnetisation at the end of the cycle. You may assume that the energy returned by your energy() function is in units of <math>k_B</math>! Complete the statistics() function. This should return the following quantities whenever it is called: <math><E>, <E^2>, <M>, <M^2></math>, and the number of Monte Carlo steps that have elapsed.===
<pre>
E = []
E2 = []
M = []
M2 = []
n_cycles = 0

def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back if rejected else not changed

self.E+=[self.energy()] #records energy
self.E2+=[self.energy()**2] #records energy squared
self.M+=[self.magnetisation()] #records magnetisation
self.M2+=[self.magnetisation()**2] #records magnetisation squared
self.n_cycles=self.n_cycles+1 #adds 1 to run total

return (self.energy(),self.magnetisation())

def statistics(self):
# complete this function so that it calculates the correct values for the averages of E, E*E (E2), M, M*M (M2), and returns them

e=np.mean(self.E)
e2=np.mean(self.E2)
m=np.mean(self.M)
m2=np.mean(self.M2)

return e,e2,m,m2,self.n_cycles
</pre>

''Figure 3'' shows the results of a single run of the montecarlostep() function and the lattice the function operated upon.

[[File:cg1417MonteCarloStep_run.png|thumb|left|Figure 3 - Results from a single montecarlostep() function and the resulting lattice produced along with the correct return from the statistics() function]]

 

===TASK: If <math>T < T_C</math>, do you expect a spontaneous magnetisation (i.e. do you expect <math>\left\langle M\right\rangle \neq 0</math>)? When the state of the simulation appears to stop changing (when you have reached an equilibrium state), use the controls to export the output to PNG and attach this to your report. You should also include the output from your statistics() function.===

If the temperature of the system is less than the Curie Temperature, <math>T_C</math> then spontaneous magnetisation can occur and the system will tend to its lowest energy state where all of the spins are parallel - this is a property of ferromagnetic materials.

[[File:Cg1417ILanim_run.png|400px|thumb|left|Figure 4 - Results from running the ILanim.py file - shows the energy and magnetisation converging over time]]

''Figure 4'' shows that over time the the system spontaneously converges to the minimum energy state with all of the spins parallel to one another and shows, as I expected, that spontaneous magnetisation occurs and also shows that the temperature of this simulation is below the Curie Temperature, <math>T < T_C</math>.

 

==Section 4 - Accelerating the Code==

===TASK: Use the script ILtimetrial.py to record how long your current version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 5'' show the results of running the ILtimetrial.py file on my code three timesː

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1.png
| width1=500
| image2=cg1417ILtimetrial_run2.png
| width2=500
| image3=cg1417ILtimetrial_run3.png
| width3=500
| footer = Figure 5 - Results of running the ILtimetrial.py file on my code three separate times
}}
 

This gave me an avergage time of <math>24.3 s \pm 0.2s</math>

===TASK: Look at the documentation for the NumPy sum function. You should be able to modify your magnetisation() function so that it uses this to evaluate M. The energy is a little trickier. Familiarise yourself with the NumPy roll and multiply functions, and use these to replace your energy double loop (you will need to call roll and multiply twice!).===

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

left=multiply(roll(self.lattice,1,axis=1),self.lattice) #product of spin with spin left of it
top=multiply(roll(self.lattice,-1,axis=0),self.lattice) #product of spin with spin above it

int_en=sum(left+top) #sum of array containing sum of left and top spin products for each spin

energy = -sum(int_en) #calculates the total energy of system
return energy

def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
return sum(sum(self.lattice)) #adds up all spins in lattice
</pre>

===TASK: Use the script ILtimetrial.py to record how long your new version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 6'' shows the result of running the ILtimetrial.py on my new accelerated code.

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1fast.png
| width1=500
| image2=ILtimetrial_run2fast.png
| width2=500
| image3=ILtimetrial_run3fast.png
| width3=500
| footer = Figure 6 - Results of running the ILtimetrial.py file on my new updated and accelerated code.
}}
 

The accelerated code is much faster upon using the roll, multiply and sum modules with a new average time of <math>0.790 s \pm 0.005 </math>

==Section 5 - The effect of temperature==

===TASK: The script ILfinalframe.py runs for a given number of cycles at a given temperature, then plots a depiction of the final lattice state as well as graphs of the energy and magnetisation as a function of cycle number. This is much quicker than animating every frame! Experiment with different temperature and lattice sizes. How many cycles are typically needed for the system to go from its random starting position to the equilibrium state? Modify your statistics() and montecarlostep() functions so that the first N cycles of the simulation are ignored when calculating the averages. You should state in your report what period you chose to ignore, and include graphs from ILfinalframe.py to illustrate your motivation in choosing this figure.===

''Figure 7'' below shows the results from running the ILfinalframe.py for 2x2 lattice at T=1,2,3,5.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2T1.png
| image2 = cg14172x2T2.png
| image3 =cg14172x2T3.png
| image4 =cg14172x2T5.png
| footer_align = left
| footer = Figure 7 - Results of running the ILfinalframe.py file at T=1,2,3,5 for a 2x2 matrix.
}}

 

For a 2x2 matrix, a suitable cut-off point to exclude from the avergage energies and magnetisations is where the energy and magnetisations per spin are constant, which is 30 steps. For T=3 and T=5 the graphs do not converge because it is possible that these temperatures are higher than the Curie Temperature and as such spontaneous magnetisation will not occur and the system will not diverge to the lowest energy state. At the higher temperatures, there are larger thermal fluctations and the Boltzmann factor is more significant allowing the system to move away from the lowest energy state easier. As a result moving forwards, a suitable cut-off point will only be determined from T=1 and T=2 graphs for the larger matrices.

''Figure 8'' shows the results from running a 4x4 lattice at T=1,2 and 3.

{{multiple image
| width =350
| align = left
| image1 = cg14174x4T1.png
| image2 = cg14174x4T2.png
| image3 =cg14174x4T3.png
| footer_align = left
| footer = Figure 8 - Results of running the ILfinalframe.py file at T=1,2,3 for a 4x4 matrix.
}}

From ''Figure 8'', a suitable cut-off point for the energy and magnetisations is 200 as this is after where the energy and magnetisation has converged for T=1, and is after the initial large drop in energy for T=2, even though there are a few small fluctuations after 200 steps. The result from T=3 has been included to show the large fluctuations for the larger temperatures, and supporting my choice to determine the cut-off from T=1 and T=2 only.

''Figure 9'' shows the results for an 8x8 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg14178x8T1.png
| image2 = cg14178x8T2.png
| footer_align = left
| footer = Figure 9 - Results of running the ILfinalframe.py file at T=1,2 for an 8x8 matrix
}}

From ''Figure 9'' above, a suitable cut-off point is 1000 steps as this is where the energy and magnetisation has easily converged by and is also the point after which the initial large drop in energy has been overcome for T=2 too.

''Figure 10'' shows the result of running the ILfinalframe.py for a 16x16 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg141716x16T1.png
| image2 = cg141716x16T2.png
| footer_align = left
| footer = Figure 10 - Results of running the ILfinalframe.py file at T=1,2 for a 16x16 matrix
}}

From ''Figure 10'', a suitable cut-off point is 15000 steps as for T=1 the energy and magnetisations have converged significantly and will not change much, and likewise this is the same for the T=2 frame.

''Figure 11'' below shows the results from a 32x32 matrix at T=1 and T=2.

{{multiple image
| width =350
| align = left
| image1 = cg141732x32T1.png
| image2 = cg141732x32T2.png
| footer_align = left
| footer = Figure 11 - Results of running the ILfinalframe.py file at T=1,2 for a 32x32 matrix
}}

''Figure 11'' above shows the results of running the ILfinalframe.py file for a 32x32 matrix at T=1 and T=2. As a result a suitable cut-off of 50000 steps was chosen as the energy and magnetisation has significantly converged, but not as much as it could at 100000 steps. I chose a slightly lower value to ensure that the run times of my monte-carlo simulations in future tasks were not extremely time consuming.

The montecarlostep() function was changed by adding a condition that values only above the pre-determined cut-off were included when determining the average value of energy; energy squared; magnetisation and magnetisations squared from the statistics function. The statistics() function did not need to be modified.

The following code is from the 32x32 matrixː

<pre>def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back

if self.n_cycles > 50000: #only adds values to array of E,E2,M and M2 is above specific cut-off
self.E+=[self.energy()]
self.E2+=[self.energy()**2]
self.M+=[self.magnetisation()]
self.M2+=[self.magnetisation()**2]
self.n_cycles=self.n_cycles+1

return (self.energy(),self.magnetisation())
</pre>

===TASK: Use ILtemperaturerange.py to plot the average energy and magnetisation for each temperature, with error bars, for an <math>8\times 8</math> lattice. Use your intuition and results from the script ILfinalframe.py to estimate how many cycles each simulation should be. The temperature range 0.25 to 5.0 is sufficient. Use as many temperature points as you feel necessary to illustrate the trend, but do not use a temperature spacing larger than 0.5. The NumPy function savetxt() stores your array of output data on disk — you will need it later. Save the file as 8x8.dat so that you know which lattice size it came from.===

Using the modified code, the file ILtemperaturerange.py was ran on an 8x8 matrix between T=0.5 and T=5 with a step of T=0.02 for 10000 Montecarlo steps and the first 1000 steps of each temperature were excluded when calculating the averages. ''Figure 12'' shows the result of the simulation and also included error bars of standard deviation.

[[File:Cg14178x8error.png|1000px|thumb|left|Figure 12 - Graph showing average energy and average magnetisation for an 8x8 lattice with error bars between T=0.5 and T=5]]

 

Below is the source code for the script to produce the graphː

<pre>data8x8=np.loadtxt('8x8.dat') #loads data
temps8x8=data8x8[:,0] #stores temperatures
energies8x8=data8x8[:,1] #stores average energy for each T
energysq8x8=data8x8[:,2] #stores average energy squared for each T
mag8x8=data8x8[:,3] #stores magnetisation for each T
magsq8x8=data8x8[:,4] #stores magnetisation squared for each T
stde8x8=data8x8[:,5] #edited ILtemperaturerange.py to record the standard deviation of the energy for each T
stdm8x8=data8x8[:,6] #edited ILtemperaturerange.py to record the standard deviation of the magnetisation for each T

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.errorbar(temps8x8, np.array(energies8x8)/64,yerr=np.divide(stde8x8,64),color='black',ecolor='teal',alpha=0.8) #plots energy per spin against T
magax.errorbar(temps8x8, np.array(mag8x8)/64,yerr=np.divide(stdm8x8,64),alpha=0.8,ecolor='salmon',color='black') #plots magnetisation per spin against T on separate graph
pl.savefig('8x8error.png',bbox_inches='tight') #saves figure
pl.show()

</pre>

==Section 6 - The effect of system size==

===TASK: Repeat the final task of the previous section for the following lattice sizes: 2x2, 4x4, 8x8, 16x16, 32x32. Make sure that you name each datafile that your produce after the corresponding lattice size! Write a Python script to make a plot showing the energy per spin versus temperature for each of your lattice sizes. Hint: the NumPy loadtxt function is the reverse of the savetxt function, and can be used to read your previously saved files into the script. Repeat this for the magnetisation. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. How big a lattice do you think is big enough to capture the long range fluctuations?===

The python script for this section is identical as for the 8x8 graph above in Figure 12 with the relevant files and variables changed accordingly.

Each matrix was simulated using the ILtemperaturerange.py file between T=0.5 and T=5 with a step of T=0.02.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2error.png
| caption1 = 2x2 matrix - 5000 steps, cut-off = 30 steps
| image2 = 4x4error.png
| caption2 = 4x4 matrix - 1000 steps, cut-off = 200 steps
| image3 =cg141716x16error.png
| caption3 = 16x16 matrix - 50000 steps, cut-off = 15000 steps
| image4 =cg141732x32error.png
| caption4 = 32x32 matrix - 200000 steps, cut-off = 50000 steps
| footer_align = left
| footer = Figure 13 - Results of running the ILtemperaturerange.py file for 2x2, 4x4, 16x16 and 32x32 matrices.
}}

 

==Section 7 - Determining the Heat Capacity==

===TASK: By definition, <math>C = \frac{\partial \left\langle E\right\rangle}{\partial T}</math>. From this, show that <math>C = \frac{\mathrm{Var}[E]}{k_B T^2}</math> (Where <math>\mathrm{Var}[E]</math> is the variance in <math>E</math>.)===

Recall from statistical thermodynamics that the average energy of a system is the sum across all microstates of the probability of that microstate multiplied by the energy of that microstate, which is defined mathematically asː <math>\langle E \rangle = \sum_i p_{i}\epsilon_{i}</math>.

The partition function <math>q</math> is defined as <math>q = \sum_{i} exp(-\beta \epsilon_{i})</math> where <math>\beta =\frac{1}{k_BT}</math>and the probability, <math>p_{i}</math> can be defined in terms of the partition function as <math>p_{i} = \frac{exp(-\beta \epsilon_{i})}{\sum_{i} exp(-\beta \epsilon_{i})} = \frac{exp(-\beta \epsilon_{i})}{q}</math>.

As a result, <math>\langle E \rangle</math> can be re-written as <math>\langle E \rangle = \sum_{i} \frac{\epsilon_{i} exp(-\beta \epsilon_{i})}{q} = -\frac{1}{q} \frac{\partial}{\partial \beta}\sum_{i}exp(-\beta \epsilon_{i}) = -\frac{1}{q} \frac{\partial q}{\partial \beta}</math>

Likewise, <math>\langle E^2 \rangle = \sum_i p_{i}\epsilon_{i}^{2} = \sum_{i} \frac{\epsilon_{i}^{2}exp(-\beta \epsilon_{i})}{q} = \frac{1}{q} \frac{\partial^{2}}{\partial \beta^{2}}\sum_{i}exp(-\beta \epsilon_{i}) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}}</math>

From definitionː <math>Var[E] = \Delta E^2 = \langle E^2 \rangle - \langle E \rangle^2 </math>

When the definition of <math>\langle E \rangle</math> and <math>\langle E^2 \rangle</math> is written in terms of partition function <math>q</math>ː <math>Var[E] = \langle E^2 \rangle - \langle E \rangle^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \left(\frac{1}{q}\frac{\partial q}{\partial \beta}\right)^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2</math>.

According to the chain ruleː <math>\frac{\partial}{\partial \beta}\left(\frac{1}{q} \frac{\partial q}{\partial \beta}\right) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2 = -\frac{\partial}{\partial \beta}\langle E \rangle = Var[E]</math>

And using the chain rule againː <math>C = \frac{\partial \langle E \rangle}{\partial T}= \left(-\frac{\partial \langle E \rangle}{\partial \beta}\right) \left(-\frac{\partial \beta}{\partial T}\right) = \frac{Var[E]}{k_B T^2}</math>

===TASK: Write a Python script to make a plot showing the heat capacity versus temperature for each of your lattice sizes from the previous section. You may need to do some research to recall the connection between the variance of a variable, <math>\mathrm{Var}[X]</math>, the mean of its square <math>\left\langle X^2\right\rangle</math>, and its squared mean <math>\left\langle X\right\rangle^2</math>. You may find that the data around the peak is very noisy — this is normal, and is a result of being in the critical region. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. ===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb

{{multiple image
| width =300
| align = left
| image1 = cg14172x2heatcap.png
| caption1 = 2x2 Matrix
| image2 = cg14174x4heatcap.png
| caption2 = 4x4 Matrix
| image3 =cg14178x8heatcap.png
| caption3 = 8x8 Matrix
| image4 =cg141716x16heatcap.png
| caption4 = 16x16 Matrix
| image5=cg141732x32heatcap.png
| caption5= 32x32 Matrix
| footer = Figure 14 - Graphs showing Heat Capacity against Temperature for each matrix size
}}

Here is the source code to produce the figuresː
<pre> def heatCap(energies,energysq,T,latsize):
#defines the heat capacity for a given temperature
energiesq=np.multiply(energies,energies) #creates array of (average energies) squared
varE=np.subtract(energysq,energiesq) #defines variance of average energy
tempsq=np.multiply(T,T) #array of temperature squared
return np.array(np.divide(varE,tempsq))/(latsize**2)

heatCap2x2=heatCap(energies2x2,energysq2x2,temps2x2,2) #creates array of heat capacity for each T

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(temps2x2,heatCap2x2,color='orange') #plots heat capacity for each T
pl.savefig('cg14172x2heatcap.png',bbox_inches='tight') #saves figure
pl.show()
</pre>

A general trend from the above graphs is that the peak of the graph shifts towards lower temperatures as the size of the matrix used increases which means the Curie Temperature decreases as matrix size increases.

==Section 8 - Locating the Curie Temperature==
===TASK: A C++ program has been used to run some much longer simulations than would be possible on the college computers in Python. You can view its source code here if you are interested. Each file contains six columns: <math>T, E, E^2, M, M^2, C</math> (the final five quantities are per spin), and you can read them with the NumPy loadtxt function as before. For each lattice size, plot the C++ data against your data. For one lattice size, save a PNG of this comparison and add it to your report — add a legend to the graph to label which is which. To do this, you will need to pass the label="..." keyword to the plot function, then call the legend() function of the axis object (documentation here).===

The python code used to read and plot the C++ data is found in the Jupyter notebook CG1417IsingModelGraphs.ipynb.

''Figure 15'' below shows the C++ plotted against my own data for a 16x16 Matrix.

[[File:Cg141716x16C++.png|400px|thumb|left|Figure 15 - Graph showing my own data against the C++ data for a 16x16 matrix.]]

 

Here is the source code the produce the figuresː
<pre>#fitting C++ data

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.plot(temps2x2, np.array(energies2x2)/4,color='black',alpha=0.7,label='Python Data') #python energy against T
enerax.plot(temps2x2C, energies2x2C, color='red',label='C++ Data') #C energy against T
magax.plot(temps2x2, np.array(mag2x2)/4,color='black',alpha=0.7,label='Python Data') #python magnetisation against T
magax.plot(temps2x2C, mag2x2C,color='red',label='C++ Data') #C energy against T
enerax.legend() #shows legend on energy graph
magax.legend() #shows legend on energy graph
pl.show()
</pre>

The relevant variables and dat files were changed for each matrix.

===TASK: write a script to read the data from a particular file, and plot C vs T, as well as a fitted polynomial. Try changing the degree of the polynomial to improve the fit — in general, it might be difficult to get a good fit! Attach a PNG of an example fit to your report.===

The python script to read and plot the fitted polynomial is found in CG1417PolyfitScript.ipynb

Here is the source code for ''Figure 15''

<pre>data_test = np.loadtxt("16x16C.dat")
T_test = data_test[:,0] #gets temperatures
C_test = data_test[:,5] #gets heat capacity data

#first we fit the polynomial to the data
fit_test = np.polyfit(T_test, C_test, 35) # fit a polynomial

#now we generate interpolated values of the fitted polynomial over the range of our function
T_min_test = 0.5 #np.min(T_test)
T_max_test = 5 #np.max(T_test)

T_range_test = np.linspace(T_min_test, T_max_test, 1000) #generate 1000 evenly spaced points between T_min and T_max
fitted_C_values_test = np.polyval(fit_test, T_range_test)# use the fit object to generate the corresponding values of C

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(T_test,C_test,color='orange',label='C++ Data') #plots C data of heat capacity against temp
heatcapax.plot(T_range_test,fitted_C_values_test,label='Fitted Polynomial') #plots fitted polynomial for whole range of temp
heatcapax.legend()
pl.savefig('FIT_TEST16x16_35.png', bbox_inches='tight') #saves figure
pl.show()
</pre>

Below in ''Figure 16'' is a plot of my Heat Capacity against Temperature data for a 16x16 matrix and features a polynomial of degree 35 plotted against it. Even with a polynomial of such a high degree, it poorly fits the curve and does not fit to the peak of the curve either.

[[File:cg1417FIT_TEST16x16_35.png|thumb|left|400px|Figure 16 - Plot of Heat Capacity against Temperature along with a poorly fitted polynomial of degree 35. ]]

 

===TASK: Modify your script from the previous section. You should still plot the whole temperature range, but fit the polynomial only to the peak of the heat capacity! You should find it easier to get a good fit when restricted to this region===

The script was modified as such that the polynomial was fitted in a set range around the peak of the graph, this is demonstrated in ''Figure 17'' which shows a newly fitted polynomial between a much smaller range of temperatures (T = 2.15-2.55) and a much smaller degree polynomial (3).

[[File:CG1417FIT_16x16C_3.png|thumb|left|400px|Figure 17 - Graph showing Heat Capacity against Temperature for a 16x16 matrix along with a fitted polynomial between a much more restricted range of temperatures and a significantly lower degree of polynomial]]

Upon comparison with ''Figure 16'', the new fitted polynomial is a significantly better fit even for a 3rd degree polynomial and is a much more accurate representation of my data around the peak of the graph and will make it easier to determine the maximum value of Heat Capacity.

 

Here is the source code for ''Figure 17''ː
<pre>data16 = np.loadtxt("16x16C.dat") #loads data to variable

T16 = data16[:,0] #gets temps
C16 = data16[:,5] # gets heat capacities

Tmin16 = 2.15 #chosen min temp
Tmax16 = 2.55 #chosen max temp

selection16 = np.logical_and(T16 > Tmin16, T16 < Tmax16) #choose only those rows where both conditions are true
peak_T_values16 = T16[selection16] #choose temp values in range chosen above
peak_C_values16 = C16[selection16] #choose heat cap values in range of t above

fit16 = np.polyfit(peak_T_values16,peak_C_values16,3) #fit 3rd order polynomial
peak_T_range16 = np.linspace(Tmin16, Tmax16, 1000) #defines 1000 temps within data range
fitted_C_values16 = np.polyval(fit16, peak_T_range16) #use the fit object to get corresponding values of heat cap

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(T16,C16,color='orange',label='C++ Data') #plots C data of heat cap against temp
heatcapax.plot(peak_T_range16,fitted_C_values16,label='Fitted Polynomial') #plots fitted polynomial for small range
heatcapax.legend()
pl.savefig('FIT_16x16C_3.png', bbox_inches='tight') #saves figure
pl.show()

</pre>

===TASK: find the temperature at which the maximum in C occurs for each datafile that you were given. Make a text file containing two colums: the lattice side length (2,4,8, etc.), and the temperature at which C is a maximum. This is your estimate of <math>T_C</math> for that side length. Make a plot that uses the scaling relation given above to determine <math>T_{C,\infty}</math>. By doing a little research online, you should be able to find the theoretical exact Curie temperature for the infinite 2D Ising lattice. How does your value compare to this? Are you surprised by how good/bad the agreement is? Attach a PNG of this final graph to your report, and discuss briefly what you think the major sources of error are in your estimate.===

''Figure 18'' below shows a graph of <math>T_{C,L}</math> against <math>\frac{1}{Lattice Size}</math> to determine the Curie Temperature of an infinite 2D Ising Model Lattice <math>T_{C,\infty}</math>. The black dots represent the raw data obtained from obtaining the temperature at which the Heat Capacity was a maximum for the lattices and the red line in a linear curve fit plotted against the data to allow the y-intercept which is the Curie Temperature for the infinite 2D lattice to be determined.

[[File:cg1417CurieTemp.png|400px|thumb|left|Figure 18 - Plot of 1/Lattice Size against Curie Temperature for that lattice size.]]

The value for <math>T_{C,\inf}</math> obtained from the data is <math>T_{C,\infty} = 2.277 \frac{J}{k_B}</math> with a literature value being <math>T_{C,\infty} = 2.269 \frac{J}{k_B}</math> <ref>L. Onsager, Phys. Rev., 1944, 65, 117--149.</ref>for an infinite square 2D lattice. This means that my result slightly over-estimates the Curie Temperature for the infinite lattice and as a result for an infinite lattice the temperature at which spontaneous magnetisation stops would actually occur at a slightly lower temperature than expected. However, the difference between my value and the literature value is only 0.008 which is incredibly small and the amount of agreement between the two values is somewhat surprising, which means that the error in my estimates of the Curie Temperature for each lattice size is relatively small. The points which have the largest residuals and deviation from the line of best fit in ''Figure 17'' corresponds to the smaller lattice sizes of 2x2 and 4x4 where longer range interactions are more significant. The longer range interactions posed by the boundary conditions are nowhere near as significant for the larger sizes and causes the energy of the smaller matrices to be less accurate and have a larger associated error with the energy and thus the Curie Temperature for that lattice size. This affects the accuracy of the line of best fit and to increase the accuracy of this line, larger lattice sizes of 128x128, 256x256 etc should be included in the calculation for the line of best fit and the smaller matrices ignored.

 

Below is the source code used to generate ''Figure 18''
<pre>
Cmax64x64 = np.max(fitted_C_values64) #finds Cmax for 64x64 matrix - done for others already
Tmax64x64 = peak_T_range64[fitted_C_values64 == Cmax64x64] #finds Tmax corresponding to Cmax

LatSize=[2,4,8,16,32,64] #stores lattice sizes
Tmax=[Tmax2x2,Tmax4x4,Tmax8x8,Tmax16x16,Tmax32x32,Tmax64x64] #stores corresponding Tmax data
np.savetxt('CmaxVSTmax.txt', (LatSize,Tmax)) #writes data to txt file

ScalData=np.loadtxt('CmaxVSTmax.txt') #loads data
LatticeSize=ScalData[0] #gets lattice sizes
TempMax=ScalData[1] #gets max temp or curie temp for each lattice

Lmin1min = np.min(np.divide(1,LatticeSize)) #minimum of 1/LatticeSize values
Lmin1max = np.max(np.divide(1,LatticeSize)) #maximum of 1/LatticeSize values

fitTcl = np.polyfit(np.divide(1,LatticeSize),TempMax, 1) #creates fit object

Lmin1values = np.linspace(Lmin1min, Lmin1max, 1000) #finds 1000 values between min and max x-axis value of 1/LatticeSize
fitted_Tcl_values = np.polyval(fitTcl, Lmin1values) #creates corresponding Curie Temp values for each value in Lmin1values

fig = pl.figure()
scalrelax = fig.add_subplot(1,1,1)
scalrelax.set_xlabel('1/Lattice Size')
scalrelax.set_ylabel('Curie Temperature/ J/k_B')
scalrelax.plot(np.divide(1,LatticeSize),TempMax,color='black',marker='.',linestyle='') #plots Curie Temp against 1/LatticeSize
scalrelax.plot(Lmin1values,fitted_Tcl_values,color='red',marker='',linestyle='-') #plots line of best fit for data above
pl.savefig('CurieTemp.png', bbox_inches='tight') #saves figure
pl.show()

</pre>

== References ==

Rep:Y3CMPCG1417

2019-11-20T10:15:42Z

==Section 1 - Introduction to the Ising Model==

===TASK: Show that the lowest possible energy for the Ising model is <math>E = -DNJ</math>, where D is the number of dimensions and N is the total number of spins. What is the multiplicity of this state? Calculate its entropy.===

Consider a 1D row of lattice sites of N=3 with spin configuration [+1][+1][+1].

Mathematically the interaction energy is defined asː
<math> -\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} </math> where J is a constant and <math>s_{i}s_{j}</math> is the product between two spins in adjacent lattice sites.

The sum of the interaction energies <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j}</math> can be considered as the sum of the individual interaction energies between spinsː
<math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = \epsilon_{12} + \epsilon_{23} + \epsilon_{13} + \epsilon_{21} + \epsilon_{32} + \epsilon_{31} </math>.

Although lattice sites 1 and 3 are not adjacent they are said to still interact according to the periodic boundary conditions applied.

However, <math>\epsilon_{12} = \epsilon_{21} </math> and <math>\epsilon_{23} = \epsilon_{32}</math> and <math>\epsilon_{13} = \epsilon_{31}</math> which means that all of the interactions within the system are counted twice, hence the total energy needs to be halved, resulting in the following formula being obtainedː <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = 2\epsilon_{12} + 2\epsilon_{13} + 2\epsilon_{23} </math>.

It can be determined that <math>\epsilon_{12} = (+1)(+1) = 1</math> , <math>\epsilon_{13} = (+1)(+1) = 1</math> and <math>\epsilon_{23} = (+1)(+1) = 1</math>.

Thereforeː <math>-\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = -\frac{1}{2} \ J \ (2 + 2 + 2) = -\frac{1}{2} \ J \ 6 = - 3 J = -DNJ</math> for a 1D lattice with <math>D=1</math> and 3 lattice sites <math>N=3</math>

The multiplicity of the system,<math>\Omega = \frac{lattice sites!}{n. spin up!n. spin down!}</math>

Entropy, <math>S</math> is defined as <math>S = k_B ln(\Omega)</math> and so in this case <math>S = k_B ln(\frac{100!}{100!}) = 0</math>

===TASK: Imagine that the system is in the lowest energy configuration. To move to a different state, one of the spins must spontaneously change direction ("flip"). What is the change in energy if this happens <math>(D=3, N=1000)</math>? How much entropy does the system gain by doing soʔ===

In a 3D lattice system, each lattice site has three unique interactions with its neighbours to its left, top and front. In the lowest energy configuration, all spins are parallel and for a system the minimum energy is <math>E = -DNJ</math>, so for the system with <math>N=1000</math> and <math>D=3</math>, the minimum energy is <math>-3000J</math>.

If a single spin is flipped, the product of its spin with its neighbours spin reverses and becomes negative and this increases the total energy of the system. Since 3 unique spin-spin interactions are reversed in sign, the total energy increases by <math>+3J</math>, meaning the new total energy is <math>-2997J</math>

Initially the multiplicity of the system will be <math>\Omega = \frac{1000!}{1000!}</math> , and after the flip, the multiplicity becomes <math> \Omega = \frac{1000!}{999!1!}=1000</math>.

The associated change in entropy, <math>\Delta S = k_B ln(1000) - 0 = 6.91 k_B</math>, which is an expected increase in entropy as the number of possible configurations of the system increases.

===TASK: Calculate the magnetisation of the 1D and 2D lattices in Figure 1. What magnetisation would you expect to observe for an Ising lattice with <math>D = 3,\ N=1000</math> at absolute zero?===

[[File:ThirdYearCMPExpt-IsingSketch.png|thumb|left|Figure 1 - Shows 1D (N = 5), 2D (N = 5x5) and 3D (N = 5x5x5) lattices.]]

Magnetisation is defined as <math>M=\sum_{i} s_i</math>. So for the 1D lattice with <math>N = 5</math> in ''Figure 2'', <math>M = +1</math> and for the 2D lattice with <math>N = 25 , M = +1</math> too.

According to the 3rd Law of thermodynamics, entropy is 0 at absolute zero for a perfect crystalline solid, and consequently it is expected that the lattices will have follow suit and have zero entropy at 0K. To have zero entropy all spins must be parallel as such that magnetisation, <math>M = N</math>. For all the spins to be parallel, there is only one possible configuration. So, for a lattice with <math>N = 1000</math> and <math>D =3</math>, if <math>M = N</math>, then multiplicity, <math>\Omega = 1</math> and entropy, <math>S =k_B ln(1) = 0</math>.

 

==Section 2 - Calculating the Energy and Magnetisation==

===TASK: complete the functions energy() and magnetisation(), which should return the energy of the lattice and the total magnetisation, respectively. In the energy() function you may assume that <math>J=1.0</math> at all times (in fact, we are working in reduced units in which <math>J=k_B</math>, but there will be more information about this in later sections). Do not worry about the efficiency of the code at the moment — we will address the speed in a later part of the experiment.===

<pre>def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
lat=self.lattice #creates lattice and stores it
mag=[]
for i in range(0,len(lat)): #loops through all rows of lattice
for j in range(0,len(lat[i])): #loops through elements of each row
mag+=[lat[i][j]] #adds spin value to mag array
return sum(mag) #sums all spins from mag array
</pre>

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

lat=self.lattice #creates lattice and stores it
left=[]
top=[]

for i in range(0,len(lat)):
for j in range(0,len(lat[i])):
left+=[lat[i][j]*lat[i][j-1]] #multiplies spin by spin to left
top+=[lat[i][j]*lat[i-1][j]] #multiplies spin by spin above it
int_en=left+top #sums spin products from left and top
energy=-sum(int_en) #sums all spin products for each spin to give total

return energy
</pre>

===TASK: Run the ILcheck.py script from the IPython Qt console using the command===

''Figure 2'' shows the results when ILcheck.py was ran on my IsingLattice.py file. The ILcheck.py file was ran several times to ensure the code worked for various random lattices.

[[File:Cg1417ILcheck run.png|thumb|left|500px| Figure 2 - Result from running the ILcheck.py file]]

 

==Section 3 - Introduction to Monte Carlo Simulation==

===TASK: How many configurations are available to a system with 100 spins? To evaluate these expressions, we have to calculate the energy and magnetisation for each of these configurations, then perform the sum. Let's be very, very, generous, and say that we can analyse <math>1\times 10^9</math> configurations per second with our computer. How long will it take to evaluate a single value of <math>\left\langle M\right\rangle_T</math>?===

For a system with 100 lattice sites and two possible spins for each site, there are <math>2^{100}</math>possible configurations for the system. <math>2^{100}= 1.27\times 10^{30} </math>, so if the computer can analyse <math>1\times 10^9</math> configurations per second, then it will take <math>\frac{1.27\times 10^{30}}{10^9} = 1.27\times 10^{21} s</math> to analyse the whole system, which is longer than the age of the universe and therefore is not a practical approach.

===TASK: Implement a single cycle of the above algorithm in the montecarlocycle(T) function. This function should return the energy of your lattice and the magnetisation at the end of the cycle. You may assume that the energy returned by your energy() function is in units of <math>k_B</math>! Complete the statistics() function. This should return the following quantities whenever it is called: <math><E>, <E^2>, <M>, <M^2></math>, and the number of Monte Carlo steps that have elapsed.===
<pre>
E = []
E2 = []
M = []
M2 = []
n_cycles = 0

def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back if rejected else not changed

self.E+=[self.energy()] #records energy
self.E2+=[self.energy()**2] #records energy squared
self.M+=[self.magnetisation()] #records magnetisation
self.M2+=[self.magnetisation()**2] #records magnetisation squared
self.n_cycles=self.n_cycles+1 #adds 1 to run total

return (self.energy(),self.magnetisation())

def statistics(self):
# complete this function so that it calculates the correct values for the averages of E, E*E (E2), M, M*M (M2), and returns them

e=np.mean(self.E)
e2=np.mean(self.E2)
m=np.mean(self.M)
m2=np.mean(self.M2)

return e,e2,m,m2,self.n_cycles
</pre>

''Figure 3'' shows the results of a single run of the montecarlostep() function and the lattice the function operated upon.

[[File:cg1417MonteCarloStep_run.png|thumb|left|Figure 3 - Results from a single montecarlostep() function and the resulting lattice produced along with the correct return from the statistics() function]]

 

===TASK: If <math>T < T_C</math>, do you expect a spontaneous magnetisation (i.e. do you expect <math>\left\langle M\right\rangle \neq 0</math>)? When the state of the simulation appears to stop changing (when you have reached an equilibrium state), use the controls to export the output to PNG and attach this to your report. You should also include the output from your statistics() function.===

If the temperature of the system is less than the Curie Temperature, <math>T_C</math> then spontaneous magnetisation can occur and the system will tend to its lowest energy state where all of the spins are parallel - this is a property of ferromagnetic materials.

[[File:Cg1417ILanim_run.png|400px|thumb|left|Figure 4 - Results from running the ILanim.py file - shows the energy and magnetisation converging over time]]

''Figure 4'' shows that over time the the system spontaneously converges to the minimum energy state with all of the spins parallel to one another and shows, as I expected, that spontaneous magnetisation occurs and also shows that the temperature of this simulation is below the Curie Temperature, <math>T < T_C</math>.

 

==Section 4 - Accelerating the Code==

===TASK: Use the script ILtimetrial.py to record how long your current version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 5'' show the results of running the ILtimetrial.py file on my code three timesː

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1.png
| width1=500
| image2=cg1417ILtimetrial_run2.png
| width2=500
| image3=cg1417ILtimetrial_run3.png
| width3=500
| footer = Figure 5 - Results of running the ILtimetrial.py file on my code three separate times
}}
 

This gave me an avergage time of <math>24.3 s \pm 0.2s</math>

===TASK: Look at the documentation for the NumPy sum function. You should be able to modify your magnetisation() function so that it uses this to evaluate M. The energy is a little trickier. Familiarise yourself with the NumPy roll and multiply functions, and use these to replace your energy double loop (you will need to call roll and multiply twice!).===

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

left=multiply(roll(self.lattice,1,axis=1),self.lattice) #product of spin with spin left of it
top=multiply(roll(self.lattice,-1,axis=0),self.lattice) #product of spin with spin above it

int_en=sum(left+top) #sum of array containing sum of left and top spin products for each spin

energy = -sum(int_en) #calculates the total energy of system
return energy

def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
return sum(sum(self.lattice)) #adds up all spins in lattice
</pre>

===TASK: Use the script ILtimetrial.py to record how long your new version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 6'' shows the result of running the ILtimetrial.py on my new accelerated code.

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1fast.png
| width1=500
| image2=ILtimetrial_run2fast.png
| width2=500
| image3=ILtimetrial_run3fast.png
| width3=500
| footer = Figure 6 - Results of running the ILtimetrial.py file on my new updated and accelerated code.
}}
 

The accelerated code is much faster upon using the roll, multiply and sum modules with a new average time of <math>0.790 s \pm 0.005 </math>

==Section 5 - The effect of temperature==

===TASK: The script ILfinalframe.py runs for a given number of cycles at a given temperature, then plots a depiction of the final lattice state as well as graphs of the energy and magnetisation as a function of cycle number. This is much quicker than animating every frame! Experiment with different temperature and lattice sizes. How many cycles are typically needed for the system to go from its random starting position to the equilibrium state? Modify your statistics() and montecarlostep() functions so that the first N cycles of the simulation are ignored when calculating the averages. You should state in your report what period you chose to ignore, and include graphs from ILfinalframe.py to illustrate your motivation in choosing this figure.===

''Figure 7'' below shows the results from running the ILfinalframe.py for 2x2 lattice at T=1,2,3,5.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2T1.png
| image2 = cg14172x2T2.png
| image3 =cg14172x2T3.png
| image4 =cg14172x2T5.png
| footer_align = left
| footer = Figure 7 - Results of running the ILfinalframe.py file at T=1,2,3,5 for a 2x2 matrix.
}}

 

For a 2x2 matrix, a suitable cut-off point to exclude from the avergage energies and magnetisations is where the energy and magnetisations per spin are constant, which is 30 steps. For T=3 and T=5 the graphs do not converge because it is possible that these temperatures are higher than the Curie Temperature and as such spontaneous magnetisation will not occur and the system will not diverge to the lowest energy state. At the higher temperatures, there are larger thermal fluctations and the Boltzmann factor is more significant allowing the system to move away from the lowest energy state easier. As a result moving forwards, a suitable cut-off point will only be determined from T=1 and T=2 graphs for the larger matrices.

''Figure 8'' shows the results from running a 4x4 lattice at T=1,2 and 3.

{{multiple image
| width =350
| align = left
| image1 = cg14174x4T1.png
| image2 = cg14174x4T2.png
| image3 =cg14174x4T3.png
| footer_align = left
| footer = Figure 8 - Results of running the ILfinalframe.py file at T=1,2,3 for a 4x4 matrix.
}}

From ''Figure 8'', a suitable cut-off point for the energy and magnetisations is 200 as this is after where the energy and magnetisation has converged for T=1, and is after the initial large drop in energy for T=2, even though there are a few small fluctuations after 200 steps. The result from T=3 has been included to show the large fluctuations for the larger temperatures, and supporting my choice to determine the cut-off from T=1 and T=2 only.

''Figure 9'' shows the results for an 8x8 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg14178x8T1.png
| image2 = cg14178x8T2.png
| footer_align = left
| footer = Figure 9 - Results of running the ILfinalframe.py file at T=1,2 for an 8x8 matrix
}}

From ''Figure 9'' above, a suitable cut-off point is 1000 steps as this is where the energy and magnetisation has easily converged by and is also the point after which the initial large drop in energy has been overcome for T=2 too.

''Figure 10'' shows the result of running the ILfinalframe.py for a 16x16 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg141716x16T1.png
| image2 = cg141716x16T2.png
| footer_align = left
| footer = Figure 10 - Results of running the ILfinalframe.py file at T=1,2 for a 16x16 matrix
}}

From ''Figure 10'', a suitable cut-off point is 15000 steps as for T=1 the energy and magnetisations have converged significantly and will not change much, and likewise this is the same for the T=2 frame.

''Figure 11'' below shows the results from a 32x32 matrix at T=1 and T=2.

{{multiple image
| width =350
| align = left
| image1 = cg141732x32T1.png
| image2 = cg141732x32T2.png
| footer_align = left
| footer = Figure 11 - Results of running the ILfinalframe.py file at T=1,2 for a 32x32 matrix
}}

''Figure 11'' above shows the results of running the ILfinalframe.py file for a 32x32 matrix at T=1 and T=2. As a result a suitable cut-off of 50000 steps was chosen as the energy and magnetisation has significantly converged, but not as much as it could at 100000 steps. I chose a slightly lower value to ensure that the run times of my monte-carlo simulations in future tasks were not extremely time consuming.

The montecarlostep() function was changed by adding a condition that values only above the pre-determined cut-off were included when determining the average value of energy; energy squared; magnetisation and magnetisations squared from the statistics function. The statistics() function did not need to be modified.

The following code is from the 32x32 matrixː

<pre>def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back

if self.n_cycles > 50000: #only adds values to array of E,E2,M and M2 is above specific cut-off
self.E+=[self.energy()]
self.E2+=[self.energy()**2]
self.M+=[self.magnetisation()]
self.M2+=[self.magnetisation()**2]
self.n_cycles=self.n_cycles+1

return (self.energy(),self.magnetisation())
</pre>

===TASK: Use ILtemperaturerange.py to plot the average energy and magnetisation for each temperature, with error bars, for an <math>8\times 8</math> lattice. Use your intuition and results from the script ILfinalframe.py to estimate how many cycles each simulation should be. The temperature range 0.25 to 5.0 is sufficient. Use as many temperature points as you feel necessary to illustrate the trend, but do not use a temperature spacing larger than 0.5. The NumPy function savetxt() stores your array of output data on disk — you will need it later. Save the file as 8x8.dat so that you know which lattice size it came from.===

Using the modified code, the file ILtemperaturerange.py was ran on an 8x8 matrix between T=0.5 and T=5 with a step of T=0.02 for 10000 Montecarlo steps and the first 1000 steps of each temperature were excluded when calculating the averages. ''Figure 12'' shows the result of the simulation and also included error bars of standard deviation.

[[File:Cg14178x8error.png|1000px|thumb|left|Figure 12 - Graph showing average energy and average magnetisation for an 8x8 lattice with error bars between T=0.5 and T=5]]

 

Below is the source code for the script to produce the graphː

<pre>data8x8=np.loadtxt('8x8.dat') #loads data
temps8x8=data8x8[:,0] #stores temperatures
energies8x8=data8x8[:,1] #stores average energy for each T
energysq8x8=data8x8[:,2] #stores average energy squared for each T
mag8x8=data8x8[:,3] #stores magnetisation for each T
magsq8x8=data8x8[:,4] #stores magnetisation squared for each T
stde8x8=data8x8[:,5] #edited ILtemperaturerange.py to record the standard deviation of the energy for each T
stdm8x8=data8x8[:,6] #edited ILtemperaturerange.py to record the standard deviation of the magnetisation for each T

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.errorbar(temps8x8, np.array(energies8x8)/64,yerr=np.divide(stde8x8,64),color='black',ecolor='teal',alpha=0.8) #plots energy per spin against T
magax.errorbar(temps8x8, np.array(mag8x8)/64,yerr=np.divide(stdm8x8,64),alpha=0.8,ecolor='salmon',color='black') #plots magnetisation per spin against T on separate graph
pl.savefig('8x8error.png',bbox_inches='tight') #saves figure
pl.show()

</pre>

==Section 6 - The effect of system size==

===TASK: Repeat the final task of the previous section for the following lattice sizes: 2x2, 4x4, 8x8, 16x16, 32x32. Make sure that you name each datafile that your produce after the corresponding lattice size! Write a Python script to make a plot showing the energy per spin versus temperature for each of your lattice sizes. Hint: the NumPy loadtxt function is the reverse of the savetxt function, and can be used to read your previously saved files into the script. Repeat this for the magnetisation. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. How big a lattice do you think is big enough to capture the long range fluctuations?===

The python script for this section is identical as for the 8x8 graph above in Figure 12 with the relevant files and variables changed accordingly.

Each matrix was simulated using the ILtemperaturerange.py file between T=0.5 and T=5 with a step of T=0.02.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2error.png
| caption1 = 2x2 matrix - 5000 steps, cut-off = 30 steps
| image2 = 4x4error.png
| caption2 = 4x4 matrix - 1000 steps, cut-off = 200 steps
| image3 =cg141716x16error.png
| caption3 = 16x16 matrix - 50000 steps, cut-off = 15000 steps
| image4 =cg141732x32error.png
| caption4 = 32x32 matrix - 200000 steps, cut-off = 50000 steps
| footer_align = left
| footer = Figure 13 - Results of running the ILtemperaturerange.py file for 2x2, 4x4, 16x16 and 32x32 matrices.
}}

 

==Section 7 - Determining the Heat Capacity==

===TASK: By definition, <math>C = \frac{\partial \left\langle E\right\rangle}{\partial T}</math>. From this, show that <math>C = \frac{\mathrm{Var}[E]}{k_B T^2}</math> (Where <math>\mathrm{Var}[E]</math> is the variance in <math>E</math>.)===

Recall from statistical thermodynamics that the average energy of a system is the sum across all microstates of the probability of that microstate multiplied by the energy of that microstate, which is defined mathematically asː <math>\langle E \rangle = \sum_i p_{i}\epsilon_{i}</math>.

The partition function <math>q</math> is defined as <math>q = \sum_{i} exp(-\beta \epsilon_{i})</math> where <math>\beta =\frac{1}{k_BT}</math>and the probability, <math>p_{i}</math> can be defined in terms of the partition function as <math>p_{i} = \frac{exp(-\beta \epsilon_{i})}{\sum_{i} exp(-\beta \epsilon_{i})} = \frac{exp(-\beta \epsilon_{i})}{q}</math>.

As a result, <math>\langle E \rangle</math> can be re-written as <math>\langle E \rangle = \sum_{i} \frac{\epsilon_{i} exp(-\beta \epsilon_{i})}{q} = -\frac{1}{q} \frac{\partial}{\partial \beta}\sum_{i}exp(-\beta \epsilon_{i}) = -\frac{1}{q} \frac{\partial q}{\partial \beta}</math>

Likewise, <math>\langle E^2 \rangle = \sum_i p_{i}\epsilon_{i}^{2} = \sum_{i} \frac{\epsilon_{i}^{2}exp(-\beta \epsilon_{i})}{q} = \frac{1}{q} \frac{\partial^{2}}{\partial \beta^{2}}\sum_{i}exp(-\beta \epsilon_{i}) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}}</math>

From definitionː <math>Var[E] = \Delta E^2 = \langle E^2 \rangle - \langle E \rangle^2 </math>

When the definition of <math>\langle E \rangle</math> and <math>\langle E^2 \rangle</math> is written in terms of partition function <math>q</math>ː <math>Var[E] = \langle E^2 \rangle - \langle E \rangle^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \left(\frac{1}{q}\frac{\partial q}{\partial \beta}\right)^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2</math>.

According to the chain ruleː <math>\frac{\partial}{\partial \beta}\left(\frac{1}{q} \frac{\partial q}{\partial \beta}\right) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2 = -\frac{\partial}{\partial \beta}\langle E \rangle = Var[E]</math>

And using the chain rule againː <math>C = \frac{\partial \langle E \rangle}{\partial T}= \left(-\frac{\partial \langle E \rangle}{\partial \beta}\right) \left(-\frac{\partial \beta}{\partial T}\right) = \frac{Var[E]}{k_B T^2}</math>

===TASK: Write a Python script to make a plot showing the heat capacity versus temperature for each of your lattice sizes from the previous section. You may need to do some research to recall the connection between the variance of a variable, <math>\mathrm{Var}[X]</math>, the mean of its square <math>\left\langle X^2\right\rangle</math>, and its squared mean <math>\left\langle X\right\rangle^2</math>. You may find that the data around the peak is very noisy — this is normal, and is a result of being in the critical region. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. ===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb

{{multiple image
| width =300
| align = left
| image1 = cg14172x2heatcap.png
| caption1 = 2x2 Matrix
| image2 = cg14174x4heatcap.png
| caption2 = 4x4 Matrix
| image3 =cg14178x8heatcap.png
| caption3 = 8x8 Matrix
| image4 =cg141716x16heatcap.png
| caption4 = 16x16 Matrix
| image5=cg141732x32heatcap.png
| caption5= 32x32 Matrix
| footer = Figure 14 - Graphs showing Heat Capacity against Temperature for each matrix size
}}

Here is the source code to produce the figuresː
<pre> def heatCap(energies,energysq,T,latsize):
#defines the heat capacity for a given temperature
energiesq=np.multiply(energies,energies) #creates array of (average energies) squared
varE=np.subtract(energysq,energiesq) #defines variance of average energy
tempsq=np.multiply(T,T) #array of temperature squared
return np.array(np.divide(varE,tempsq))/(latsize**2)

heatCap2x2=heatCap(energies2x2,energysq2x2,temps2x2,2) #creates array of heat capacity for each T

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(temps2x2,heatCap2x2,color='orange') #plots heat capacity for each T
pl.savefig('cg14172x2heatcap.png',bbox_inches='tight') #saves figure
pl.show()
</pre>

A general trend from the above graphs is that the peak of the graph shifts towards lower temperatures as the size of the matrix used increases which means the Curie Temperature decreases as matrix size increases.

==Section 8 - Locating the Curie Temperature==
===TASK: A C++ program has been used to run some much longer simulations than would be possible on the college computers in Python. You can view its source code here if you are interested. Each file contains six columns: <math>T, E, E^2, M, M^2, C</math> (the final five quantities are per spin), and you can read them with the NumPy loadtxt function as before. For each lattice size, plot the C++ data against your data. For one lattice size, save a PNG of this comparison and add it to your report — add a legend to the graph to label which is which. To do this, you will need to pass the label="..." keyword to the plot function, then call the legend() function of the axis object (documentation here).===

The python code used to read and plot the C++ data is found in the Jupyter notebook CG1417IsingModelGraphs.ipynb.

''Figure 15'' below shows the C++ plotted against my own data for a 16x16 Matrix.

[[File:Cg141716x16C++.png|400px|thumb|left|Figure 15 - Graph showing my own data against the C++ data for a 16x16 matrix.]]

 

Here is the source code the produce the figuresː
<pre>#fitting C++ data

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.plot(temps2x2, np.array(energies2x2)/4,color='black',alpha=0.7,label='Python Data') #python energy against T
enerax.plot(temps2x2C, energies2x2C, color='red',label='C++ Data') #C energy against T
magax.plot(temps2x2, np.array(mag2x2)/4,color='black',alpha=0.7,label='Python Data') #python magnetisation against T
magax.plot(temps2x2C, mag2x2C,color='red',label='C++ Data') #C energy against T
enerax.legend() #shows legend on energy graph
magax.legend() #shows legend on energy graph
pl.show()
</pre>

The relevant variables and dat files were changed for each matrix.

===TASK: write a script to read the data from a particular file, and plot C vs T, as well as a fitted polynomial. Try changing the degree of the polynomial to improve the fit — in general, it might be difficult to get a good fit! Attach a PNG of an example fit to your report.===

The python script to read and plot the fitted polynomial is found in CG1417PolyfitScript.ipynb

Here is the source code for ''Figure 15''

<pre>data_test = np.loadtxt("16x16C.dat")
T_test = data_test[:,0] #gets temperatures
C_test = data_test[:,5] #gets heat capacity data

#first we fit the polynomial to the data
fit_test = np.polyfit(T_test, C_test, 35) # fit a polynomial

#now we generate interpolated values of the fitted polynomial over the range of our function
T_min_test = 0.5 #np.min(T_test)
T_max_test = 5 #np.max(T_test)

T_range_test = np.linspace(T_min_test, T_max_test, 1000) #generate 1000 evenly spaced points between T_min and T_max
fitted_C_values_test = np.polyval(fit_test, T_range_test)# use the fit object to generate the corresponding values of C

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(T_test,C_test,color='orange',label='C++ Data') #plots C data of heat capacity against temp
heatcapax.plot(T_range_test,fitted_C_values_test,label='Fitted Polynomial') #plots fitted polynomial for whole range of temp
heatcapax.legend()
pl.savefig('FIT_TEST16x16_35.png', bbox_inches='tight') #saves figure
pl.show()
</pre>

Below in ''Figure 16'' is a plot of my Heat Capacity against Temperature data for a 16x16 matrix and features a polynomial of degree 35 plotted against it. Even with a polynomial of such a high degree, it poorly fits the curve and does not fit to the peak of the curve either.

[[File:cg1417FIT_TEST16x16_35.png|thumb|left|400px|Figure 16 - Plot of Heat Capacity against Temperature along with a poorly fitted polynomial of degree 35. ]]

 

===TASK: Modify your script from the previous section. You should still plot the whole temperature range, but fit the polynomial only to the peak of the heat capacity! You should find it easier to get a good fit when restricted to this region===

The script was modified as such that the polynomial was fitted in a set range around the peak of the graph, this is demonstrated in ''Figure 17'' which shows a newly fitted polynomial between a much smaller range of temperatures (T = 2.15-2.55) and a much smaller degree polynomial (3).

[[File:CG1417FIT_16x16C_3.png|thumb|left|400px|Figure 17 - Graph showing Heat Capacity against Temperature for a 16x16 matrix along with a fitted polynomial between a much more restricted range of temperatures and a significantly lower degree of polynomial]]

Upon comparison with ''Figure 16'', the new fitted polynomial is a significantly better fit even for a 3rd degree polynomial and is a much more accurate representation of my data around the peak of the graph and will make it easier to determine the maximum value of Heat Capacity.

 

Here is the source code for ''Figure 17''ː
<pre>data16 = np.loadtxt("16x16C.dat") #loads data to variable

T16 = data16[:,0] #gets temps
C16 = data16[:,5] # gets heat capacities

Tmin16 = 2.15 #chosen min temp
Tmax16 = 2.55 #chosen max temp

selection16 = np.logical_and(T16 > Tmin16, T16 < Tmax16) #choose only those rows where both conditions are true
peak_T_values16 = T16[selection16] #choose temp values in range chosen above
peak_C_values16 = C16[selection16] #choose heat cap values in range of t above

fit16 = np.polyfit(peak_T_values16,peak_C_values16,3) #fit 3rd order polynomial
peak_T_range16 = np.linspace(Tmin16, Tmax16, 1000) #defines 1000 temps within data range
fitted_C_values16 = np.polyval(fit16, peak_T_range16) #use the fit object to get corresponding values of heat cap

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(T16,C16,color='orange',label='C++ Data') #plots C data of heat cap against temp
heatcapax.plot(peak_T_range16,fitted_C_values16,label='Fitted Polynomial') #plots fitted polynomial for small range
heatcapax.legend()
pl.savefig('FIT_16x16C_3.png', bbox_inches='tight') #saves figure
pl.show()

</pre>

===TASK: find the temperature at which the maximum in C occurs for each datafile that you were given. Make a text file containing two colums: the lattice side length (2,4,8, etc.), and the temperature at which C is a maximum. This is your estimate of <math>T_C</math> for that side length. Make a plot that uses the scaling relation given above to determine <math>T_{C,\infty}</math>. By doing a little research online, you should be able to find the theoretical exact Curie temperature for the infinite 2D Ising lattice. How does your value compare to this? Are you surprised by how good/bad the agreement is? Attach a PNG of this final graph to your report, and discuss briefly what you think the major sources of error are in your estimate.===

''Figure 17'' below shows a graph of <math>T_{C,L}</math> against <math>\frac{1}{Lattice Size}</math> to determine the Curie Temperature of an infinite 2D Ising Model Lattice <math>T_{C,\infty}</math>. The black dots represent the raw data obtained from obtaining the temperature at which the Heat Capacity was a maximum for the lattices and the red line in a linear curve fit plotted against the data to allow the y-intercept which is the Curie Temperature for the infinite 2D lattice to be determined.

[[File:cg1417CurieTemp.png|400px|thumb|left|Figure 17 - Plot of 1/Lattice Size against Curie Temperature for that lattice size.]]

The value for <math>T_{C,\inf}</math> obtained from the data is <math>T_{C,\infty} = 2.277 \frac{J}{k_B}</math> with a literature value being <math>T_{C,\infty} = 2.269 \frac{J}{k_B}</math> <ref>L. Onsager, Phys. Rev., 1944, 65, 117--149.</ref>for an infinite square 2D lattice. This means that my result slightly over-estimates the Curie Temperature for the infinite lattice and as a result for an infinite lattice the temperature at which spontaneous magnetisation stops would actually occur at a slightly lower temperature than expected. However, the difference between my value and the literature value is only 0.008 which is incredibly small and the amount of agreement between the two values is somewhat surprising, which means that the error in my estimates of the Curie Temperature for each lattice size is relatively small. The points which have the largest residuals and deviation from the line of best fit in ''Figure 17'' corresponds to the smaller lattice sizes of 2x2 and 4x4 where longer range interactions are more significant. The longer range interactions posed by the boundary conditions are nowhere near as significant for the larger sizes and causes the energy of the smaller matrices to be less accurate and have a larger associated error with the energy and thus the Curie Temperature for that lattice size. This affects the accuracy of the line of best fit and to increase the accuracy of this line, larger lattice sizes of 128x128, 256x256 etc should be included in the calculation for the line of best fit and the smaller matrices ignored.

 

Below is the source code used to generate ''Figure 17''
<pre>
Cmax64x64 = np.max(fitted_C_values64) #finds Cmax for 64x64 matrix - done for others already
Tmax64x64 = peak_T_range64[fitted_C_values64 == Cmax64x64] #finds Tmax corresponding to Cmax

LatSize=[2,4,8,16,32,64] #stores lattice sizes
Tmax=[Tmax2x2,Tmax4x4,Tmax8x8,Tmax16x16,Tmax32x32,Tmax64x64] #stores corresponding Tmax data
np.savetxt('CmaxVSTmax.txt', (LatSize,Tmax)) #writes data to txt file

ScalData=np.loadtxt('CmaxVSTmax.txt') #loads data
LatticeSize=ScalData[0] #gets lattice sizes
TempMax=ScalData[1] #gets max temp or curie temp for each lattice

Lmin1min = np.min(np.divide(1,LatticeSize)) #minimum of 1/LatticeSize values
Lmin1max = np.max(np.divide(1,LatticeSize)) #maximum of 1/LatticeSize values

fitTcl = np.polyfit(np.divide(1,LatticeSize),TempMax, 1) #creates fit object

Lmin1values = np.linspace(Lmin1min, Lmin1max, 1000) #finds 1000 values between min and max x-axis value of 1/LatticeSize
fitted_Tcl_values = np.polyval(fitTcl, Lmin1values) #creates corresponding Curie Temp values for each value in Lmin1values

fig = pl.figure()
scalrelax = fig.add_subplot(1,1,1)
scalrelax.set_xlabel('1/Lattice Size')
scalrelax.set_ylabel('Curie Temperature/ J/k_B')
scalrelax.plot(np.divide(1,LatticeSize),TempMax,color='black',marker='.',linestyle='') #plots Curie Temp against 1/LatticeSize
scalrelax.plot(Lmin1values,fitted_Tcl_values,color='red',marker='',linestyle='-') #plots line of best fit for data above
pl.savefig('CurieTemp.png', bbox_inches='tight') #saves figure
pl.show()

</pre>

== References ==

Rep:Y3CMPCG1417

2019-11-20T10:15:17Z

==Section 1 - Introduction to the Ising Model==

===TASK: Show that the lowest possible energy for the Ising model is <math>E = -DNJ</math>, where D is the number of dimensions and N is the total number of spins. What is the multiplicity of this state? Calculate its entropy.===

Consider a 1D row of lattice sites of N=3 with spin configuration [+1][+1][+1].

Mathematically the interaction energy is defined asː
<math> -\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} </math> where J is a constant and <math>s_{i}s_{j}</math> is the product between two spins in adjacent lattice sites.

The sum of the interaction energies <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j}</math> can be considered as the sum of the individual interaction energies between spinsː
<math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = \epsilon_{12} + \epsilon_{23} + \epsilon_{13} + \epsilon_{21} + \epsilon_{32} + \epsilon_{31} </math>.

Although lattice sites 1 and 3 are not adjacent they are said to still interact according to the periodic boundary conditions applied.

However, <math>\epsilon_{12} = \epsilon_{21} </math> and <math>\epsilon_{23} = \epsilon_{32}</math> and <math>\epsilon_{13} = \epsilon_{31}</math> which means that all of the interactions within the system are counted twice, hence the total energy needs to be halved, resulting in the following formula being obtainedː <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = 2\epsilon_{12} + 2\epsilon_{13} + 2\epsilon_{23} </math>.

It can be determined that <math>\epsilon_{12} = (+1)(+1) = 1</math> , <math>\epsilon_{13} = (+1)(+1) = 1</math> and <math>\epsilon_{23} = (+1)(+1) = 1</math>.

Thereforeː <math>-\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = -\frac{1}{2} \ J \ (2 + 2 + 2) = -\frac{1}{2} \ J \ 6 = - 3 J = -DNJ</math> for a 1D lattice with <math>D=1</math> and 3 lattice sites <math>N=3</math>

The multiplicity of the system,<math>\Omega = \frac{lattice sites!}{n. spin up!n. spin down!}</math>

Entropy, <math>S</math> is defined as <math>S = k_B ln(\Omega)</math> and so in this case <math>S = k_B ln(\frac{100!}{100!}) = 0</math>

===TASK: Imagine that the system is in the lowest energy configuration. To move to a different state, one of the spins must spontaneously change direction ("flip"). What is the change in energy if this happens <math>(D=3, N=1000)</math>? How much entropy does the system gain by doing soʔ===

In a 3D lattice system, each lattice site has three unique interactions with its neighbours to its left, top and front. In the lowest energy configuration, all spins are parallel and for a system the minimum energy is <math>E = -DNJ</math>, so for the system with <math>N=1000</math> and <math>D=3</math>, the minimum energy is <math>-3000J</math>.

If a single spin is flipped, the product of its spin with its neighbours spin reverses and becomes negative and this increases the total energy of the system. Since 3 unique spin-spin interactions are reversed in sign, the total energy increases by <math>+3J</math>, meaning the new total energy is <math>-2997J</math>

Initially the multiplicity of the system will be <math>\Omega = \frac{1000!}{1000!}</math> , and after the flip, the multiplicity becomes <math> \Omega = \frac{1000!}{999!1!}=1000</math>.

The associated change in entropy, <math>\Delta S = k_B ln(1000) - 0 = 6.91 k_B</math>, which is an expected increase in entropy as the number of possible configurations of the system increases.

===TASK: Calculate the magnetisation of the 1D and 2D lattices in Figure 1. What magnetisation would you expect to observe for an Ising lattice with <math>D = 3,\ N=1000</math> at absolute zero?===

[[File:ThirdYearCMPExpt-IsingSketch.png|thumb|left|Figure 1 - Shows 1D (N = 5), 2D (N = 5x5) and 3D (N = 5x5x5) lattices.]]

Magnetisation is defined as <math>M=\sum_{i} s_i</math>. So for the 1D lattice with <math>N = 5</math> in ''Figure 2'', <math>M = +1</math> and for the 2D lattice with <math>N = 25 , M = +1</math> too.

According to the 3rd Law of thermodynamics, entropy is 0 at absolute zero for a perfect crystalline solid, and consequently it is expected that the lattices will have follow suit and have zero entropy at 0K. To have zero entropy all spins must be parallel as such that magnetisation, <math>M = N</math>. For all the spins to be parallel, there is only one possible configuration. So, for a lattice with <math>N = 1000</math> and <math>D =3</math>, if <math>M = N</math>, then multiplicity, <math>\Omega = 1</math> and entropy, <math>S =k_B ln(1) = 0</math>.

 

==Section 2 - Calculating the Energy and Magnetisation==

===TASK: complete the functions energy() and magnetisation(), which should return the energy of the lattice and the total magnetisation, respectively. In the energy() function you may assume that <math>J=1.0</math> at all times (in fact, we are working in reduced units in which <math>J=k_B</math>, but there will be more information about this in later sections). Do not worry about the efficiency of the code at the moment — we will address the speed in a later part of the experiment.===

<pre>def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
lat=self.lattice #creates lattice and stores it
mag=[]
for i in range(0,len(lat)): #loops through all rows of lattice
for j in range(0,len(lat[i])): #loops through elements of each row
mag+=[lat[i][j]] #adds spin value to mag array
return sum(mag) #sums all spins from mag array
</pre>

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

lat=self.lattice #creates lattice and stores it
left=[]
top=[]

for i in range(0,len(lat)):
for j in range(0,len(lat[i])):
left+=[lat[i][j]*lat[i][j-1]] #multiplies spin by spin to left
top+=[lat[i][j]*lat[i-1][j]] #multiplies spin by spin above it
int_en=left+top #sums spin products from left and top
energy=-sum(int_en) #sums all spin products for each spin to give total

return energy
</pre>

===TASK: Run the ILcheck.py script from the IPython Qt console using the command===

''Figure 2'' shows the results when ILcheck.py was ran on my IsingLattice.py file. The ILcheck.py file was ran several times to ensure the code worked for various random lattices.

[[File:Cg1417ILcheck run.png|thumb|left|500px| Figure 2 - Result from running the ILcheck.py file]]

 

==Section 3 - Introduction to Monte Carlo Simulation==

===TASK: How many configurations are available to a system with 100 spins? To evaluate these expressions, we have to calculate the energy and magnetisation for each of these configurations, then perform the sum. Let's be very, very, generous, and say that we can analyse <math>1\times 10^9</math> configurations per second with our computer. How long will it take to evaluate a single value of <math>\left\langle M\right\rangle_T</math>?===

For a system with 100 lattice sites and two possible spins for each site, there are <math>2^{100}</math>possible configurations for the system. <math>2^{100}= 1.27\times 10^{30} </math>, so if the computer can analyse <math>1\times 10^9</math> configurations per second, then it will take <math>\frac{1.27\times 10^{30}}{10^9} = 1.27\times 10^{21} s</math> to analyse the whole system, which is longer than the age of the universe and therefore is not a practical approach.

===TASK: Implement a single cycle of the above algorithm in the montecarlocycle(T) function. This function should return the energy of your lattice and the magnetisation at the end of the cycle. You may assume that the energy returned by your energy() function is in units of <math>k_B</math>! Complete the statistics() function. This should return the following quantities whenever it is called: <math><E>, <E^2>, <M>, <M^2></math>, and the number of Monte Carlo steps that have elapsed.===
<pre>
E = []
E2 = []
M = []
M2 = []
n_cycles = 0

def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back if rejected else not changed

self.E+=[self.energy()] #records energy
self.E2+=[self.energy()**2] #records energy squared
self.M+=[self.magnetisation()] #records magnetisation
self.M2+=[self.magnetisation()**2] #records magnetisation squared
self.n_cycles=self.n_cycles+1 #adds 1 to run total

return (self.energy(),self.magnetisation())

def statistics(self):
# complete this function so that it calculates the correct values for the averages of E, E*E (E2), M, M*M (M2), and returns them

e=np.mean(self.E)
e2=np.mean(self.E2)
m=np.mean(self.M)
m2=np.mean(self.M2)

return e,e2,m,m2,self.n_cycles
</pre>

''Figure 3'' shows the results of a single run of the montecarlostep() function and the lattice the function operated upon.

[[File:cg1417MonteCarloStep_run.png|thumb|left|Figure 3 - Results from a single montecarlostep() function and the resulting lattice produced along with the correct return from the statistics() function]]

 

===TASK: If <math>T < T_C</math>, do you expect a spontaneous magnetisation (i.e. do you expect <math>\left\langle M\right\rangle \neq 0</math>)? When the state of the simulation appears to stop changing (when you have reached an equilibrium state), use the controls to export the output to PNG and attach this to your report. You should also include the output from your statistics() function.===

If the temperature of the system is less than the Curie Temperature, <math>T_C</math> then spontaneous magnetisation can occur and the system will tend to its lowest energy state where all of the spins are parallel - this is a property of ferromagnetic materials.

[[File:Cg1417ILanim_run.png|400px|thumb|left|Figure 4 - Results from running the ILanim.py file - shows the energy and magnetisation converging over time]]

''Figure 4'' shows that over time the the system spontaneously converges to the minimum energy state with all of the spins parallel to one another and shows, as I expected, that spontaneous magnetisation occurs and also shows that the temperature of this simulation is below the Curie Temperature, <math>T < T_C</math>.

 

==Section 4 - Accelerating the Code==

===TASK: Use the script ILtimetrial.py to record how long your current version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 5'' show the results of running the ILtimetrial.py file on my code three timesː

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1.png
| width1=500
| image2=cg1417ILtimetrial_run2.png
| width2=500
| image3=cg1417ILtimetrial_run3.png
| width3=500
| footer = Figure 5 - Results of running the ILtimetrial.py file on my code three separate times
}}
 

This gave me an avergage time of <math>24.3 s \pm 0.2s</math>

===TASK: Look at the documentation for the NumPy sum function. You should be able to modify your magnetisation() function so that it uses this to evaluate M. The energy is a little trickier. Familiarise yourself with the NumPy roll and multiply functions, and use these to replace your energy double loop (you will need to call roll and multiply twice!).===

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

left=multiply(roll(self.lattice,1,axis=1),self.lattice) #product of spin with spin left of it
top=multiply(roll(self.lattice,-1,axis=0),self.lattice) #product of spin with spin above it

int_en=sum(left+top) #sum of array containing sum of left and top spin products for each spin

energy = -sum(int_en) #calculates the total energy of system
return energy

def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
return sum(sum(self.lattice)) #adds up all spins in lattice
</pre>

===TASK: Use the script ILtimetrial.py to record how long your new version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 6'' shows the result of running the ILtimetrial.py on my new accelerated code.

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1fast.png
| width1=500
| image2=ILtimetrial_run2fast.png
| width2=500
| image3=ILtimetrial_run3fast.png
| width3=500
| footer = Figure 6 - Results of running the ILtimetrial.py file on my new updated and accelerated code.
}}
 

The accelerated code is much faster upon using the roll, multiply and sum modules with a new average time of <math>0.790 s \pm 0.005 </math>

==Section 5 - The effect of temperature==

===TASK: The script ILfinalframe.py runs for a given number of cycles at a given temperature, then plots a depiction of the final lattice state as well as graphs of the energy and magnetisation as a function of cycle number. This is much quicker than animating every frame! Experiment with different temperature and lattice sizes. How many cycles are typically needed for the system to go from its random starting position to the equilibrium state? Modify your statistics() and montecarlostep() functions so that the first N cycles of the simulation are ignored when calculating the averages. You should state in your report what period you chose to ignore, and include graphs from ILfinalframe.py to illustrate your motivation in choosing this figure.===

''Figure 7'' below shows the results from running the ILfinalframe.py for 2x2 lattice at T=1,2,3,5.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2T1.png
| image2 = cg14172x2T2.png
| image3 =cg14172x2T3.png
| image4 =cg14172x2T5.png
| footer_align = left
| footer = Figure 7 - Results of running the ILfinalframe.py file at T=1,2,3,5 for a 2x2 matrix.
}}

 

For a 2x2 matrix, a suitable cut-off point to exclude from the avergage energies and magnetisations is where the energy and magnetisations per spin are constant, which is 30 steps. For T=3 and T=5 the graphs do not converge because it is possible that these temperatures are higher than the Curie Temperature and as such spontaneous magnetisation will not occur and the system will not diverge to the lowest energy state. At the higher temperatures, there are larger thermal fluctations and the Boltzmann factor is more significant allowing the system to move away from the lowest energy state easier. As a result moving forwards, a suitable cut-off point will only be determined from T=1 and T=2 graphs for the larger matrices.

''Figure 8'' shows the results from running a 4x4 lattice at T=1,2 and 3.

{{multiple image
| width =350
| align = left
| image1 = cg14174x4T1.png
| image2 = cg14174x4T2.png
| image3 =cg14174x4T3.png
| footer_align = left
| footer = Figure 8 - Results of running the ILfinalframe.py file at T=1,2,3 for a 4x4 matrix.
}}

From ''Figure 8'', a suitable cut-off point for the energy and magnetisations is 200 as this is after where the energy and magnetisation has converged for T=1, and is after the initial large drop in energy for T=2, even though there are a few small fluctuations after 200 steps. The result from T=3 has been included to show the large fluctuations for the larger temperatures, and supporting my choice to determine the cut-off from T=1 and T=2 only.

''Figure 9'' shows the results for an 8x8 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg14178x8T1.png
| image2 = cg14178x8T2.png
| footer_align = left
| footer = Figure 9 - Results of running the ILfinalframe.py file at T=1,2 for an 8x8 matrix
}}

From ''Figure 9'' above, a suitable cut-off point is 1000 steps as this is where the energy and magnetisation has easily converged by and is also the point after which the initial large drop in energy has been overcome for T=2 too.

''Figure 10'' shows the result of running the ILfinalframe.py for a 16x16 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg141716x16T1.png
| image2 = cg141716x16T2.png
| footer_align = left
| footer = Figure 10 - Results of running the ILfinalframe.py file at T=1,2 for a 16x16 matrix
}}

From ''Figure 10'', a suitable cut-off point is 15000 steps as for T=1 the energy and magnetisations have converged significantly and will not change much, and likewise this is the same for the T=2 frame.

''Figure 11'' below shows the results from a 32x32 matrix at T=1 and T=2.

{{multiple image
| width =350
| align = left
| image1 = cg141732x32T1.png
| image2 = cg141732x32T2.png
| footer_align = left
| footer = Figure 11 - Results of running the ILfinalframe.py file at T=1,2 for a 32x32 matrix
}}

''Figure 11'' above shows the results of running the ILfinalframe.py file for a 32x32 matrix at T=1 and T=2. As a result a suitable cut-off of 50000 steps was chosen as the energy and magnetisation has significantly converged, but not as much as it could at 100000 steps. I chose a slightly lower value to ensure that the run times of my monte-carlo simulations in future tasks were not extremely time consuming.

The montecarlostep() function was changed by adding a condition that values only above the pre-determined cut-off were included when determining the average value of energy; energy squared; magnetisation and magnetisations squared from the statistics function. The statistics() function did not need to be modified.

The following code is from the 32x32 matrixː

<pre>def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back

if self.n_cycles > 50000: #only adds values to array of E,E2,M and M2 is above specific cut-off
self.E+=[self.energy()]
self.E2+=[self.energy()**2]
self.M+=[self.magnetisation()]
self.M2+=[self.magnetisation()**2]
self.n_cycles=self.n_cycles+1

return (self.energy(),self.magnetisation())
</pre>

===TASK: Use ILtemperaturerange.py to plot the average energy and magnetisation for each temperature, with error bars, for an <math>8\times 8</math> lattice. Use your intuition and results from the script ILfinalframe.py to estimate how many cycles each simulation should be. The temperature range 0.25 to 5.0 is sufficient. Use as many temperature points as you feel necessary to illustrate the trend, but do not use a temperature spacing larger than 0.5. The NumPy function savetxt() stores your array of output data on disk — you will need it later. Save the file as 8x8.dat so that you know which lattice size it came from.===

Using the modified code, the file ILtemperaturerange.py was ran on an 8x8 matrix between T=0.5 and T=5 with a step of T=0.02 for 10000 Montecarlo steps and the first 1000 steps of each temperature were excluded when calculating the averages. ''Figure 12'' shows the result of the simulation and also included error bars of standard deviation.

[[File:Cg14178x8error.png|1000px|thumb|left|Figure 12 - Graph showing average energy and average magnetisation for an 8x8 lattice with error bars between T=0.5 and T=5]]

 

Below is the source code for the script to produce the graphː

<pre>data8x8=np.loadtxt('8x8.dat') #loads data
temps8x8=data8x8[:,0] #stores temperatures
energies8x8=data8x8[:,1] #stores average energy for each T
energysq8x8=data8x8[:,2] #stores average energy squared for each T
mag8x8=data8x8[:,3] #stores magnetisation for each T
magsq8x8=data8x8[:,4] #stores magnetisation squared for each T
stde8x8=data8x8[:,5] #edited ILtemperaturerange.py to record the standard deviation of the energy for each T
stdm8x8=data8x8[:,6] #edited ILtemperaturerange.py to record the standard deviation of the magnetisation for each T

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.errorbar(temps8x8, np.array(energies8x8)/64,yerr=np.divide(stde8x8,64),color='black',ecolor='teal',alpha=0.8) #plots energy per spin against T
magax.errorbar(temps8x8, np.array(mag8x8)/64,yerr=np.divide(stdm8x8,64),alpha=0.8,ecolor='salmon',color='black') #plots magnetisation per spin against T on separate graph
pl.savefig('8x8error.png',bbox_inches='tight') #saves figure
pl.show()

</pre>

==Section 6 - The effect of system size==

===TASK: Repeat the final task of the previous section for the following lattice sizes: 2x2, 4x4, 8x8, 16x16, 32x32. Make sure that you name each datafile that your produce after the corresponding lattice size! Write a Python script to make a plot showing the energy per spin versus temperature for each of your lattice sizes. Hint: the NumPy loadtxt function is the reverse of the savetxt function, and can be used to read your previously saved files into the script. Repeat this for the magnetisation. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. How big a lattice do you think is big enough to capture the long range fluctuations?===

The python script for this section is identical as for the 8x8 graph above in Figure 12 with the relevant files and variables changed accordingly.

Each matrix was simulated using the ILtemperaturerange.py file between T=0.5 and T=5 with a step of T=0.02.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2error.png
| caption1 = 2x2 matrix - 5000 steps, cut-off = 30 steps
| image2 = 4x4error.png
| caption2 = 4x4 matrix - 1000 steps, cut-off = 200 steps
| image3 =cg141716x16error.png
| caption3 = 16x16 matrix - 50000 steps, cut-off = 15000 steps
| image4 =cg141732x32error.png
| caption4 = 32x32 matrix - 200000 steps, cut-off = 50000 steps
| footer_align = left
| footer = Figure 13 - Results of running the ILtemperaturerange.py file for 2x2, 4x4, 16x16 and 32x32 matrices.
}}

 

==Section 7 - Determining the Heat Capacity==

===TASK: By definition, <math>C = \frac{\partial \left\langle E\right\rangle}{\partial T}</math>. From this, show that <math>C = \frac{\mathrm{Var}[E]}{k_B T^2}</math> (Where <math>\mathrm{Var}[E]</math> is the variance in <math>E</math>.)===

Recall from statistical thermodynamics that the average energy of a system is the sum across all microstates of the probability of that microstate multiplied by the energy of that microstate, which is defined mathematically asː <math>\langle E \rangle = \sum_i p_{i}\epsilon_{i}</math>.

The partition function <math>q</math> is defined as <math>q = \sum_{i} exp(-\beta \epsilon_{i})</math> where <math>\beta =\frac{1}{k_BT}</math>and the probability, <math>p_{i}</math> can be defined in terms of the partition function as <math>p_{i} = \frac{exp(-\beta \epsilon_{i})}{\sum_{i} exp(-\beta \epsilon_{i})} = \frac{exp(-\beta \epsilon_{i})}{q}</math>.

As a result, <math>\langle E \rangle</math> can be re-written as <math>\langle E \rangle = \sum_{i} \frac{\epsilon_{i} exp(-\beta \epsilon_{i})}{q} = -\frac{1}{q} \frac{\partial}{\partial \beta}\sum_{i}exp(-\beta \epsilon_{i}) = -\frac{1}{q} \frac{\partial q}{\partial \beta}</math>

Likewise, <math>\langle E^2 \rangle = \sum_i p_{i}\epsilon_{i}^{2} = \sum_{i} \frac{\epsilon_{i}^{2}exp(-\beta \epsilon_{i})}{q} = \frac{1}{q} \frac{\partial^{2}}{\partial \beta^{2}}\sum_{i}exp(-\beta \epsilon_{i}) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}}</math>

From definitionː <math>Var[E] = \Delta E^2 = \langle E^2 \rangle - \langle E \rangle^2 </math>

When the definition of <math>\langle E \rangle</math> and <math>\langle E^2 \rangle</math> is written in terms of partition function <math>q</math>ː <math>Var[E] = \langle E^2 \rangle - \langle E \rangle^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \left(\frac{1}{q}\frac{\partial q}{\partial \beta}\right)^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2</math>.

According to the chain ruleː <math>\frac{\partial}{\partial \beta}\left(\frac{1}{q} \frac{\partial q}{\partial \beta}\right) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2 = -\frac{\partial}{\partial \beta}\langle E \rangle = Var[E]</math>

And using the chain rule againː <math>C = \frac{\partial \langle E \rangle}{\partial T}= \left(-\frac{\partial \langle E \rangle}{\partial \beta}\right) \left(-\frac{\partial \beta}{\partial T}\right) = \frac{Var[E]}{k_B T^2}</math>

===TASK: Write a Python script to make a plot showing the heat capacity versus temperature for each of your lattice sizes from the previous section. You may need to do some research to recall the connection between the variance of a variable, <math>\mathrm{Var}[X]</math>, the mean of its square <math>\left\langle X^2\right\rangle</math>, and its squared mean <math>\left\langle X\right\rangle^2</math>. You may find that the data around the peak is very noisy — this is normal, and is a result of being in the critical region. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. ===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb

{{multiple image
| width =300
| align = left
| image1 = cg14172x2heatcap.png
| caption1 = 2x2 Matrix
| image2 = cg14174x4heatcap.png
| caption2 = 4x4 Matrix
| image3 =cg14178x8heatcap.png
| caption3 = 8x8 Matrix
| image4 =cg141716x16heatcap.png
| caption4 = 16x16 Matrix
| image5=cg141732x32heatcap.png
| caption5= 32x32 Matrix
| footer = Figure 14 - Graphs showing Heat Capacity against Temperature for each matrix size
}}

Here is the source code to produce the figuresː
<pre> def heatCap(energies,energysq,T,latsize):
#defines the heat capacity for a given temperature
energiesq=np.multiply(energies,energies) #creates array of (average energies) squared
varE=np.subtract(energysq,energiesq) #defines variance of average energy
tempsq=np.multiply(T,T) #array of temperature squared
return np.array(np.divide(varE,tempsq))/(latsize**2)

heatCap2x2=heatCap(energies2x2,energysq2x2,temps2x2,2) #creates array of heat capacity for each T

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(temps2x2,heatCap2x2,color='orange') #plots heat capacity for each T
pl.savefig('cg14172x2heatcap.png',bbox_inches='tight') #saves figure
pl.show()
</pre>

A general trend from the above graphs is that the peak of the graph shifts towards lower temperatures as the size of the matrix used increases which means the Curie Temperature decreases as matrix size increases.

==Section 8 - Locating the Curie Temperature==
===TASK: A C++ program has been used to run some much longer simulations than would be possible on the college computers in Python. You can view its source code here if you are interested. Each file contains six columns: <math>T, E, E^2, M, M^2, C</math> (the final five quantities are per spin), and you can read them with the NumPy loadtxt function as before. For each lattice size, plot the C++ data against your data. For one lattice size, save a PNG of this comparison and add it to your report — add a legend to the graph to label which is which. To do this, you will need to pass the label="..." keyword to the plot function, then call the legend() function of the axis object (documentation here).===

The python code used to read and plot the C++ data is found in the Jupyter notebook CG1417IsingModelGraphs.ipynb.

''Figure 15'' below shows the C++ plotted against my own data for a 16x16 Matrix.

[[File:Cg141716x16C++.png|400px|thumb|left|Figure 15 - Graph showing my own data against the C++ data for a 16x16 matrix.]]

 

Here is the source code the produce the figuresː
<pre>#fitting C++ data

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.plot(temps2x2, np.array(energies2x2)/4,color='black',alpha=0.7,label='Python Data') #python energy against T
enerax.plot(temps2x2C, energies2x2C, color='red',label='C++ Data') #C energy against T
magax.plot(temps2x2, np.array(mag2x2)/4,color='black',alpha=0.7,label='Python Data') #python magnetisation against T
magax.plot(temps2x2C, mag2x2C,color='red',label='C++ Data') #C energy against T
enerax.legend() #shows legend on energy graph
magax.legend() #shows legend on energy graph
pl.show()
</pre>

The relevant variables and dat files were changed for each matrix.

===TASK: write a script to read the data from a particular file, and plot C vs T, as well as a fitted polynomial. Try changing the degree of the polynomial to improve the fit — in general, it might be difficult to get a good fit! Attach a PNG of an example fit to your report.===

The python script to read and plot the fitted polynomial is found in CG1417PolyfitScript.ipynb

Here is the source code for ''Figure 15''

<pre>data_test = np.loadtxt("16x16C.dat")
T_test = data_test[:,0] #gets temperatures
C_test = data_test[:,5] #gets heat capacity data

#first we fit the polynomial to the data
fit_test = np.polyfit(T_test, C_test, 35) # fit a polynomial

#now we generate interpolated values of the fitted polynomial over the range of our function
T_min_test = 0.5 #np.min(T_test)
T_max_test = 5 #np.max(T_test)

T_range_test = np.linspace(T_min_test, T_max_test, 1000) #generate 1000 evenly spaced points between T_min and T_max
fitted_C_values_test = np.polyval(fit_test, T_range_test)# use the fit object to generate the corresponding values of C

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(T_test,C_test,color='orange',label='C++ Data') #plots C data of heat capacity against temp
heatcapax.plot(T_range_test,fitted_C_values_test,label='Fitted Polynomial') #plots fitted polynomial for whole range of temp
heatcapax.legend()
pl.savefig('FIT_TEST16x16_35.png', bbox_inches='tight') #saves figure
pl.show()
</pre>

Below in ''Figure 16'' is a plot of my Heat Capacity against Temperature data for a 16x16 matrix and features a polynomial of degree 35 plotted against it. Even with a polynomial of such a high degree, it poorly fits the curve and does not fit to the peak of the curve either.

[[File:cg1417FIT_TEST16x16_35.png|thumb|left|400px|Figure 16 - Plot of Heat Capacity against Temperature along with a poorly fitted polynomial of degree 35. ]]

 

===TASK: Modify your script from the previous section. You should still plot the whole temperature range, but fit the polynomial only to the peak of the heat capacity! You should find it easier to get a good fit when restricted to this region===

The script was modified as such that the polynomial was fitted in a set range around the peak of the graph, this is demonstrated in ''Figure 17'' which shows a newly fitted polynomial between a much smaller range of temperatures (T = 2.15-2.55) and a much smaller degree polynomial (3).

[[File:CG1417FIT_16x16C_3.png|thumb|left|400px|Figure 16 - Graph showing Heat Capacity against Temperature for a 16x16 matrix along with a fitted polynomial between a much more restricted range of temperatures and a significantly lower degree of polynomial]]

Upon comparison with ''Figure 15'', the new fitted polynomial is a significantly better fit even for a 3rd degree polynomial and is a much more accurate representation of my data around the peak of the graph and will make it easier to determine the maximum value of Heat Capacity.

 

Here is the source code for ''Figure 16''ː
<pre>data16 = np.loadtxt("16x16C.dat") #loads data to variable

T16 = data16[:,0] #gets temps
C16 = data16[:,5] # gets heat capacities

Tmin16 = 2.15 #chosen min temp
Tmax16 = 2.55 #chosen max temp

selection16 = np.logical_and(T16 > Tmin16, T16 < Tmax16) #choose only those rows where both conditions are true
peak_T_values16 = T16[selection16] #choose temp values in range chosen above
peak_C_values16 = C16[selection16] #choose heat cap values in range of t above

fit16 = np.polyfit(peak_T_values16,peak_C_values16,3) #fit 3rd order polynomial
peak_T_range16 = np.linspace(Tmin16, Tmax16, 1000) #defines 1000 temps within data range
fitted_C_values16 = np.polyval(fit16, peak_T_range16) #use the fit object to get corresponding values of heat cap

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(T16,C16,color='orange',label='C++ Data') #plots C data of heat cap against temp
heatcapax.plot(peak_T_range16,fitted_C_values16,label='Fitted Polynomial') #plots fitted polynomial for small range
heatcapax.legend()
pl.savefig('FIT_16x16C_3.png', bbox_inches='tight') #saves figure
pl.show()

</pre>

===TASK: find the temperature at which the maximum in C occurs for each datafile that you were given. Make a text file containing two colums: the lattice side length (2,4,8, etc.), and the temperature at which C is a maximum. This is your estimate of <math>T_C</math> for that side length. Make a plot that uses the scaling relation given above to determine <math>T_{C,\infty}</math>. By doing a little research online, you should be able to find the theoretical exact Curie temperature for the infinite 2D Ising lattice. How does your value compare to this? Are you surprised by how good/bad the agreement is? Attach a PNG of this final graph to your report, and discuss briefly what you think the major sources of error are in your estimate.===

''Figure 17'' below shows a graph of <math>T_{C,L}</math> against <math>\frac{1}{Lattice Size}</math> to determine the Curie Temperature of an infinite 2D Ising Model Lattice <math>T_{C,\infty}</math>. The black dots represent the raw data obtained from obtaining the temperature at which the Heat Capacity was a maximum for the lattices and the red line in a linear curve fit plotted against the data to allow the y-intercept which is the Curie Temperature for the infinite 2D lattice to be determined.

[[File:cg1417CurieTemp.png|400px|thumb|left|Figure 17 - Plot of 1/Lattice Size against Curie Temperature for that lattice size.]]

The value for <math>T_{C,\inf}</math> obtained from the data is <math>T_{C,\infty} = 2.277 \frac{J}{k_B}</math> with a literature value being <math>T_{C,\infty} = 2.269 \frac{J}{k_B}</math> <ref>L. Onsager, Phys. Rev., 1944, 65, 117--149.</ref>for an infinite square 2D lattice. This means that my result slightly over-estimates the Curie Temperature for the infinite lattice and as a result for an infinite lattice the temperature at which spontaneous magnetisation stops would actually occur at a slightly lower temperature than expected. However, the difference between my value and the literature value is only 0.008 which is incredibly small and the amount of agreement between the two values is somewhat surprising, which means that the error in my estimates of the Curie Temperature for each lattice size is relatively small. The points which have the largest residuals and deviation from the line of best fit in ''Figure 17'' corresponds to the smaller lattice sizes of 2x2 and 4x4 where longer range interactions are more significant. The longer range interactions posed by the boundary conditions are nowhere near as significant for the larger sizes and causes the energy of the smaller matrices to be less accurate and have a larger associated error with the energy and thus the Curie Temperature for that lattice size. This affects the accuracy of the line of best fit and to increase the accuracy of this line, larger lattice sizes of 128x128, 256x256 etc should be included in the calculation for the line of best fit and the smaller matrices ignored.

 

Below is the source code used to generate ''Figure 17''
<pre>
Cmax64x64 = np.max(fitted_C_values64) #finds Cmax for 64x64 matrix - done for others already
Tmax64x64 = peak_T_range64[fitted_C_values64 == Cmax64x64] #finds Tmax corresponding to Cmax

LatSize=[2,4,8,16,32,64] #stores lattice sizes
Tmax=[Tmax2x2,Tmax4x4,Tmax8x8,Tmax16x16,Tmax32x32,Tmax64x64] #stores corresponding Tmax data
np.savetxt('CmaxVSTmax.txt', (LatSize,Tmax)) #writes data to txt file

ScalData=np.loadtxt('CmaxVSTmax.txt') #loads data
LatticeSize=ScalData[0] #gets lattice sizes
TempMax=ScalData[1] #gets max temp or curie temp for each lattice

Lmin1min = np.min(np.divide(1,LatticeSize)) #minimum of 1/LatticeSize values
Lmin1max = np.max(np.divide(1,LatticeSize)) #maximum of 1/LatticeSize values

fitTcl = np.polyfit(np.divide(1,LatticeSize),TempMax, 1) #creates fit object

Lmin1values = np.linspace(Lmin1min, Lmin1max, 1000) #finds 1000 values between min and max x-axis value of 1/LatticeSize
fitted_Tcl_values = np.polyval(fitTcl, Lmin1values) #creates corresponding Curie Temp values for each value in Lmin1values

fig = pl.figure()
scalrelax = fig.add_subplot(1,1,1)
scalrelax.set_xlabel('1/Lattice Size')
scalrelax.set_ylabel('Curie Temperature/ J/k_B')
scalrelax.plot(np.divide(1,LatticeSize),TempMax,color='black',marker='.',linestyle='') #plots Curie Temp against 1/LatticeSize
scalrelax.plot(Lmin1values,fitted_Tcl_values,color='red',marker='',linestyle='-') #plots line of best fit for data above
pl.savefig('CurieTemp.png', bbox_inches='tight') #saves figure
pl.show()

</pre>

== References ==

Rep:Y3CMPCG1417

2019-11-20T10:15:00Z

==Section 1 - Introduction to the Ising Model==

===TASK: Show that the lowest possible energy for the Ising model is <math>E = -DNJ</math>, where D is the number of dimensions and N is the total number of spins. What is the multiplicity of this state? Calculate its entropy.===

Consider a 1D row of lattice sites of N=3 with spin configuration [+1][+1][+1].

Mathematically the interaction energy is defined asː
<math> -\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} </math> where J is a constant and <math>s_{i}s_{j}</math> is the product between two spins in adjacent lattice sites.

The sum of the interaction energies <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j}</math> can be considered as the sum of the individual interaction energies between spinsː
<math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = \epsilon_{12} + \epsilon_{23} + \epsilon_{13} + \epsilon_{21} + \epsilon_{32} + \epsilon_{31} </math>.

Although lattice sites 1 and 3 are not adjacent they are said to still interact according to the periodic boundary conditions applied.

However, <math>\epsilon_{12} = \epsilon_{21} </math> and <math>\epsilon_{23} = \epsilon_{32}</math> and <math>\epsilon_{13} = \epsilon_{31}</math> which means that all of the interactions within the system are counted twice, hence the total energy needs to be halved, resulting in the following formula being obtainedː <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = 2\epsilon_{12} + 2\epsilon_{13} + 2\epsilon_{23} </math>.

It can be determined that <math>\epsilon_{12} = (+1)(+1) = 1</math> , <math>\epsilon_{13} = (+1)(+1) = 1</math> and <math>\epsilon_{23} = (+1)(+1) = 1</math>.

Thereforeː <math>-\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = -\frac{1}{2} \ J \ (2 + 2 + 2) = -\frac{1}{2} \ J \ 6 = - 3 J = -DNJ</math> for a 1D lattice with <math>D=1</math> and 3 lattice sites <math>N=3</math>

The multiplicity of the system,<math>\Omega = \frac{lattice sites!}{n. spin up!n. spin down!}</math>

Entropy, <math>S</math> is defined as <math>S = k_B ln(\Omega)</math> and so in this case <math>S = k_B ln(\frac{100!}{100!}) = 0</math>

===TASK: Imagine that the system is in the lowest energy configuration. To move to a different state, one of the spins must spontaneously change direction ("flip"). What is the change in energy if this happens <math>(D=3, N=1000)</math>? How much entropy does the system gain by doing soʔ===

In a 3D lattice system, each lattice site has three unique interactions with its neighbours to its left, top and front. In the lowest energy configuration, all spins are parallel and for a system the minimum energy is <math>E = -DNJ</math>, so for the system with <math>N=1000</math> and <math>D=3</math>, the minimum energy is <math>-3000J</math>.

If a single spin is flipped, the product of its spin with its neighbours spin reverses and becomes negative and this increases the total energy of the system. Since 3 unique spin-spin interactions are reversed in sign, the total energy increases by <math>+3J</math>, meaning the new total energy is <math>-2997J</math>

Initially the multiplicity of the system will be <math>\Omega = \frac{1000!}{1000!}</math> , and after the flip, the multiplicity becomes <math> \Omega = \frac{1000!}{999!1!}=1000</math>.

The associated change in entropy, <math>\Delta S = k_B ln(1000) - 0 = 6.91 k_B</math>, which is an expected increase in entropy as the number of possible configurations of the system increases.

===TASK: Calculate the magnetisation of the 1D and 2D lattices in Figure 1. What magnetisation would you expect to observe for an Ising lattice with <math>D = 3,\ N=1000</math> at absolute zero?===

[[File:ThirdYearCMPExpt-IsingSketch.png|thumb|left|Figure 1 - Shows 1D (N = 5), 2D (N = 5x5) and 3D (N = 5x5x5) lattices.]]

Magnetisation is defined as <math>M=\sum_{i} s_i</math>. So for the 1D lattice with <math>N = 5</math> in ''Figure 2'', <math>M = +1</math> and for the 2D lattice with <math>N = 25 , M = +1</math> too.

According to the 3rd Law of thermodynamics, entropy is 0 at absolute zero for a perfect crystalline solid, and consequently it is expected that the lattices will have follow suit and have zero entropy at 0K. To have zero entropy all spins must be parallel as such that magnetisation, <math>M = N</math>. For all the spins to be parallel, there is only one possible configuration. So, for a lattice with <math>N = 1000</math> and <math>D =3</math>, if <math>M = N</math>, then multiplicity, <math>\Omega = 1</math> and entropy, <math>S =k_B ln(1) = 0</math>.

 

==Section 2 - Calculating the Energy and Magnetisation==

===TASK: complete the functions energy() and magnetisation(), which should return the energy of the lattice and the total magnetisation, respectively. In the energy() function you may assume that <math>J=1.0</math> at all times (in fact, we are working in reduced units in which <math>J=k_B</math>, but there will be more information about this in later sections). Do not worry about the efficiency of the code at the moment — we will address the speed in a later part of the experiment.===

<pre>def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
lat=self.lattice #creates lattice and stores it
mag=[]
for i in range(0,len(lat)): #loops through all rows of lattice
for j in range(0,len(lat[i])): #loops through elements of each row
mag+=[lat[i][j]] #adds spin value to mag array
return sum(mag) #sums all spins from mag array
</pre>

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

lat=self.lattice #creates lattice and stores it
left=[]
top=[]

for i in range(0,len(lat)):
for j in range(0,len(lat[i])):
left+=[lat[i][j]*lat[i][j-1]] #multiplies spin by spin to left
top+=[lat[i][j]*lat[i-1][j]] #multiplies spin by spin above it
int_en=left+top #sums spin products from left and top
energy=-sum(int_en) #sums all spin products for each spin to give total

return energy
</pre>

===TASK: Run the ILcheck.py script from the IPython Qt console using the command===

''Figure 2'' shows the results when ILcheck.py was ran on my IsingLattice.py file. The ILcheck.py file was ran several times to ensure the code worked for various random lattices.

[[File:Cg1417ILcheck run.png|thumb|left|500px| Figure 2 - Result from running the ILcheck.py file]]

 

==Section 3 - Introduction to Monte Carlo Simulation==

===TASK: How many configurations are available to a system with 100 spins? To evaluate these expressions, we have to calculate the energy and magnetisation for each of these configurations, then perform the sum. Let's be very, very, generous, and say that we can analyse <math>1\times 10^9</math> configurations per second with our computer. How long will it take to evaluate a single value of <math>\left\langle M\right\rangle_T</math>?===

For a system with 100 lattice sites and two possible spins for each site, there are <math>2^{100}</math>possible configurations for the system. <math>2^{100}= 1.27\times 10^{30} </math>, so if the computer can analyse <math>1\times 10^9</math> configurations per second, then it will take <math>\frac{1.27\times 10^{30}}{10^9} = 1.27\times 10^{21} s</math> to analyse the whole system, which is longer than the age of the universe and therefore is not a practical approach.

===TASK: Implement a single cycle of the above algorithm in the montecarlocycle(T) function. This function should return the energy of your lattice and the magnetisation at the end of the cycle. You may assume that the energy returned by your energy() function is in units of <math>k_B</math>! Complete the statistics() function. This should return the following quantities whenever it is called: <math><E>, <E^2>, <M>, <M^2></math>, and the number of Monte Carlo steps that have elapsed.===
<pre>
E = []
E2 = []
M = []
M2 = []
n_cycles = 0

def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back if rejected else not changed

self.E+=[self.energy()] #records energy
self.E2+=[self.energy()**2] #records energy squared
self.M+=[self.magnetisation()] #records magnetisation
self.M2+=[self.magnetisation()**2] #records magnetisation squared
self.n_cycles=self.n_cycles+1 #adds 1 to run total

return (self.energy(),self.magnetisation())

def statistics(self):
# complete this function so that it calculates the correct values for the averages of E, E*E (E2), M, M*M (M2), and returns them

e=np.mean(self.E)
e2=np.mean(self.E2)
m=np.mean(self.M)
m2=np.mean(self.M2)

return e,e2,m,m2,self.n_cycles
</pre>

''Figure 3'' shows the results of a single run of the montecarlostep() function and the lattice the function operated upon.

[[File:cg1417MonteCarloStep_run.png|thumb|left|Figure 3 - Results from a single montecarlostep() function and the resulting lattice produced along with the correct return from the statistics() function]]

 

===TASK: If <math>T < T_C</math>, do you expect a spontaneous magnetisation (i.e. do you expect <math>\left\langle M\right\rangle \neq 0</math>)? When the state of the simulation appears to stop changing (when you have reached an equilibrium state), use the controls to export the output to PNG and attach this to your report. You should also include the output from your statistics() function.===

If the temperature of the system is less than the Curie Temperature, <math>T_C</math> then spontaneous magnetisation can occur and the system will tend to its lowest energy state where all of the spins are parallel - this is a property of ferromagnetic materials.

[[File:Cg1417ILanim_run.png|400px|thumb|left|Figure 4 - Results from running the ILanim.py file - shows the energy and magnetisation converging over time]]

''Figure 4'' shows that over time the the system spontaneously converges to the minimum energy state with all of the spins parallel to one another and shows, as I expected, that spontaneous magnetisation occurs and also shows that the temperature of this simulation is below the Curie Temperature, <math>T < T_C</math>.

 

==Section 4 - Accelerating the Code==

===TASK: Use the script ILtimetrial.py to record how long your current version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 5'' show the results of running the ILtimetrial.py file on my code three timesː

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1.png
| width1=500
| image2=cg1417ILtimetrial_run2.png
| width2=500
| image3=cg1417ILtimetrial_run3.png
| width3=500
| footer = Figure 5 - Results of running the ILtimetrial.py file on my code three separate times
}}
 

This gave me an avergage time of <math>24.3 s \pm 0.2s</math>

===TASK: Look at the documentation for the NumPy sum function. You should be able to modify your magnetisation() function so that it uses this to evaluate M. The energy is a little trickier. Familiarise yourself with the NumPy roll and multiply functions, and use these to replace your energy double loop (you will need to call roll and multiply twice!).===

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

left=multiply(roll(self.lattice,1,axis=1),self.lattice) #product of spin with spin left of it
top=multiply(roll(self.lattice,-1,axis=0),self.lattice) #product of spin with spin above it

int_en=sum(left+top) #sum of array containing sum of left and top spin products for each spin

energy = -sum(int_en) #calculates the total energy of system
return energy

def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
return sum(sum(self.lattice)) #adds up all spins in lattice
</pre>

===TASK: Use the script ILtimetrial.py to record how long your new version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 6'' shows the result of running the ILtimetrial.py on my new accelerated code.

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1fast.png
| width1=500
| image2=ILtimetrial_run2fast.png
| width2=500
| image3=ILtimetrial_run3fast.png
| width3=500
| footer = Figure 6 - Results of running the ILtimetrial.py file on my new updated and accelerated code.
}}
 

The accelerated code is much faster upon using the roll, multiply and sum modules with a new average time of <math>0.790 s \pm 0.005 </math>

==Section 5 - The effect of temperature==

===TASK: The script ILfinalframe.py runs for a given number of cycles at a given temperature, then plots a depiction of the final lattice state as well as graphs of the energy and magnetisation as a function of cycle number. This is much quicker than animating every frame! Experiment with different temperature and lattice sizes. How many cycles are typically needed for the system to go from its random starting position to the equilibrium state? Modify your statistics() and montecarlostep() functions so that the first N cycles of the simulation are ignored when calculating the averages. You should state in your report what period you chose to ignore, and include graphs from ILfinalframe.py to illustrate your motivation in choosing this figure.===

''Figure 7'' below shows the results from running the ILfinalframe.py for 2x2 lattice at T=1,2,3,5.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2T1.png
| image2 = cg14172x2T2.png
| image3 =cg14172x2T3.png
| image4 =cg14172x2T5.png
| footer_align = left
| footer = Figure 7 - Results of running the ILfinalframe.py file at T=1,2,3,5 for a 2x2 matrix.
}}

 

For a 2x2 matrix, a suitable cut-off point to exclude from the avergage energies and magnetisations is where the energy and magnetisations per spin are constant, which is 30 steps. For T=3 and T=5 the graphs do not converge because it is possible that these temperatures are higher than the Curie Temperature and as such spontaneous magnetisation will not occur and the system will not diverge to the lowest energy state. At the higher temperatures, there are larger thermal fluctations and the Boltzmann factor is more significant allowing the system to move away from the lowest energy state easier. As a result moving forwards, a suitable cut-off point will only be determined from T=1 and T=2 graphs for the larger matrices.

''Figure 8'' shows the results from running a 4x4 lattice at T=1,2 and 3.

{{multiple image
| width =350
| align = left
| image1 = cg14174x4T1.png
| image2 = cg14174x4T2.png
| image3 =cg14174x4T3.png
| footer_align = left
| footer = Figure 8 - Results of running the ILfinalframe.py file at T=1,2,3 for a 4x4 matrix.
}}

From ''Figure 8'', a suitable cut-off point for the energy and magnetisations is 200 as this is after where the energy and magnetisation has converged for T=1, and is after the initial large drop in energy for T=2, even though there are a few small fluctuations after 200 steps. The result from T=3 has been included to show the large fluctuations for the larger temperatures, and supporting my choice to determine the cut-off from T=1 and T=2 only.

''Figure 9'' shows the results for an 8x8 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg14178x8T1.png
| image2 = cg14178x8T2.png
| footer_align = left
| footer = Figure 9 - Results of running the ILfinalframe.py file at T=1,2 for an 8x8 matrix
}}

From ''Figure 9'' above, a suitable cut-off point is 1000 steps as this is where the energy and magnetisation has easily converged by and is also the point after which the initial large drop in energy has been overcome for T=2 too.

''Figure 10'' shows the result of running the ILfinalframe.py for a 16x16 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg141716x16T1.png
| image2 = cg141716x16T2.png
| footer_align = left
| footer = Figure 10 - Results of running the ILfinalframe.py file at T=1,2 for a 16x16 matrix
}}

From ''Figure 10'', a suitable cut-off point is 15000 steps as for T=1 the energy and magnetisations have converged significantly and will not change much, and likewise this is the same for the T=2 frame.

''Figure 11'' below shows the results from a 32x32 matrix at T=1 and T=2.

{{multiple image
| width =350
| align = left
| image1 = cg141732x32T1.png
| image2 = cg141732x32T2.png
| footer_align = left
| footer = Figure 11 - Results of running the ILfinalframe.py file at T=1,2 for a 32x32 matrix
}}

''Figure 11'' above shows the results of running the ILfinalframe.py file for a 32x32 matrix at T=1 and T=2. As a result a suitable cut-off of 50000 steps was chosen as the energy and magnetisation has significantly converged, but not as much as it could at 100000 steps. I chose a slightly lower value to ensure that the run times of my monte-carlo simulations in future tasks were not extremely time consuming.

The montecarlostep() function was changed by adding a condition that values only above the pre-determined cut-off were included when determining the average value of energy; energy squared; magnetisation and magnetisations squared from the statistics function. The statistics() function did not need to be modified.

The following code is from the 32x32 matrixː

<pre>def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back

if self.n_cycles > 50000: #only adds values to array of E,E2,M and M2 is above specific cut-off
self.E+=[self.energy()]
self.E2+=[self.energy()**2]
self.M+=[self.magnetisation()]
self.M2+=[self.magnetisation()**2]
self.n_cycles=self.n_cycles+1

return (self.energy(),self.magnetisation())
</pre>

===TASK: Use ILtemperaturerange.py to plot the average energy and magnetisation for each temperature, with error bars, for an <math>8\times 8</math> lattice. Use your intuition and results from the script ILfinalframe.py to estimate how many cycles each simulation should be. The temperature range 0.25 to 5.0 is sufficient. Use as many temperature points as you feel necessary to illustrate the trend, but do not use a temperature spacing larger than 0.5. The NumPy function savetxt() stores your array of output data on disk — you will need it later. Save the file as 8x8.dat so that you know which lattice size it came from.===

Using the modified code, the file ILtemperaturerange.py was ran on an 8x8 matrix between T=0.5 and T=5 with a step of T=0.02 for 10000 Montecarlo steps and the first 1000 steps of each temperature were excluded when calculating the averages. ''Figure 12'' shows the result of the simulation and also included error bars of standard deviation.

[[File:Cg14178x8error.png|1000px|thumb|left|Figure 12 - Graph showing average energy and average magnetisation for an 8x8 lattice with error bars between T=0.5 and T=5]]

 

Below is the source code for the script to produce the graphː

<pre>data8x8=np.loadtxt('8x8.dat') #loads data
temps8x8=data8x8[:,0] #stores temperatures
energies8x8=data8x8[:,1] #stores average energy for each T
energysq8x8=data8x8[:,2] #stores average energy squared for each T
mag8x8=data8x8[:,3] #stores magnetisation for each T
magsq8x8=data8x8[:,4] #stores magnetisation squared for each T
stde8x8=data8x8[:,5] #edited ILtemperaturerange.py to record the standard deviation of the energy for each T
stdm8x8=data8x8[:,6] #edited ILtemperaturerange.py to record the standard deviation of the magnetisation for each T

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.errorbar(temps8x8, np.array(energies8x8)/64,yerr=np.divide(stde8x8,64),color='black',ecolor='teal',alpha=0.8) #plots energy per spin against T
magax.errorbar(temps8x8, np.array(mag8x8)/64,yerr=np.divide(stdm8x8,64),alpha=0.8,ecolor='salmon',color='black') #plots magnetisation per spin against T on separate graph
pl.savefig('8x8error.png',bbox_inches='tight') #saves figure
pl.show()

</pre>

==Section 6 - The effect of system size==

===TASK: Repeat the final task of the previous section for the following lattice sizes: 2x2, 4x4, 8x8, 16x16, 32x32. Make sure that you name each datafile that your produce after the corresponding lattice size! Write a Python script to make a plot showing the energy per spin versus temperature for each of your lattice sizes. Hint: the NumPy loadtxt function is the reverse of the savetxt function, and can be used to read your previously saved files into the script. Repeat this for the magnetisation. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. How big a lattice do you think is big enough to capture the long range fluctuations?===

The python script for this section is identical as for the 8x8 graph above in Figure 12 with the relevant files and variables changed accordingly.

Each matrix was simulated using the ILtemperaturerange.py file between T=0.5 and T=5 with a step of T=0.02.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2error.png
| caption1 = 2x2 matrix - 5000 steps, cut-off = 30 steps
| image2 = 4x4error.png
| caption2 = 4x4 matrix - 1000 steps, cut-off = 200 steps
| image3 =cg141716x16error.png
| caption3 = 16x16 matrix - 50000 steps, cut-off = 15000 steps
| image4 =cg141732x32error.png
| caption4 = 32x32 matrix - 200000 steps, cut-off = 50000 steps
| footer_align = left
| footer = Figure 13 - Results of running the ILtemperaturerange.py file for 2x2, 4x4, 16x16 and 32x32 matrices.
}}

 

==Section 7 - Determining the Heat Capacity==

===TASK: By definition, <math>C = \frac{\partial \left\langle E\right\rangle}{\partial T}</math>. From this, show that <math>C = \frac{\mathrm{Var}[E]}{k_B T^2}</math> (Where <math>\mathrm{Var}[E]</math> is the variance in <math>E</math>.)===

Recall from statistical thermodynamics that the average energy of a system is the sum across all microstates of the probability of that microstate multiplied by the energy of that microstate, which is defined mathematically asː <math>\langle E \rangle = \sum_i p_{i}\epsilon_{i}</math>.

The partition function <math>q</math> is defined as <math>q = \sum_{i} exp(-\beta \epsilon_{i})</math> where <math>\beta =\frac{1}{k_BT}</math>and the probability, <math>p_{i}</math> can be defined in terms of the partition function as <math>p_{i} = \frac{exp(-\beta \epsilon_{i})}{\sum_{i} exp(-\beta \epsilon_{i})} = \frac{exp(-\beta \epsilon_{i})}{q}</math>.

As a result, <math>\langle E \rangle</math> can be re-written as <math>\langle E \rangle = \sum_{i} \frac{\epsilon_{i} exp(-\beta \epsilon_{i})}{q} = -\frac{1}{q} \frac{\partial}{\partial \beta}\sum_{i}exp(-\beta \epsilon_{i}) = -\frac{1}{q} \frac{\partial q}{\partial \beta}</math>

Likewise, <math>\langle E^2 \rangle = \sum_i p_{i}\epsilon_{i}^{2} = \sum_{i} \frac{\epsilon_{i}^{2}exp(-\beta \epsilon_{i})}{q} = \frac{1}{q} \frac{\partial^{2}}{\partial \beta^{2}}\sum_{i}exp(-\beta \epsilon_{i}) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}}</math>

From definitionː <math>Var[E] = \Delta E^2 = \langle E^2 \rangle - \langle E \rangle^2 </math>

When the definition of <math>\langle E \rangle</math> and <math>\langle E^2 \rangle</math> is written in terms of partition function <math>q</math>ː <math>Var[E] = \langle E^2 \rangle - \langle E \rangle^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \left(\frac{1}{q}\frac{\partial q}{\partial \beta}\right)^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2</math>.

According to the chain ruleː <math>\frac{\partial}{\partial \beta}\left(\frac{1}{q} \frac{\partial q}{\partial \beta}\right) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2 = -\frac{\partial}{\partial \beta}\langle E \rangle = Var[E]</math>

And using the chain rule againː <math>C = \frac{\partial \langle E \rangle}{\partial T}= \left(-\frac{\partial \langle E \rangle}{\partial \beta}\right) \left(-\frac{\partial \beta}{\partial T}\right) = \frac{Var[E]}{k_B T^2}</math>

===TASK: Write a Python script to make a plot showing the heat capacity versus temperature for each of your lattice sizes from the previous section. You may need to do some research to recall the connection between the variance of a variable, <math>\mathrm{Var}[X]</math>, the mean of its square <math>\left\langle X^2\right\rangle</math>, and its squared mean <math>\left\langle X\right\rangle^2</math>. You may find that the data around the peak is very noisy — this is normal, and is a result of being in the critical region. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. ===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb

{{multiple image
| width =300
| align = left
| image1 = cg14172x2heatcap.png
| caption1 = 2x2 Matrix
| image2 = cg14174x4heatcap.png
| caption2 = 4x4 Matrix
| image3 =cg14178x8heatcap.png
| caption3 = 8x8 Matrix
| image4 =cg141716x16heatcap.png
| caption4 = 16x16 Matrix
| image5=cg141732x32heatcap.png
| caption5= 32x32 Matrix
| footer = Figure 14 - Graphs showing Heat Capacity against Temperature for each matrix size
}}

Here is the source code to produce the figuresː
<pre> def heatCap(energies,energysq,T,latsize):
#defines the heat capacity for a given temperature
energiesq=np.multiply(energies,energies) #creates array of (average energies) squared
varE=np.subtract(energysq,energiesq) #defines variance of average energy
tempsq=np.multiply(T,T) #array of temperature squared
return np.array(np.divide(varE,tempsq))/(latsize**2)

heatCap2x2=heatCap(energies2x2,energysq2x2,temps2x2,2) #creates array of heat capacity for each T

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(temps2x2,heatCap2x2,color='orange') #plots heat capacity for each T
pl.savefig('cg14172x2heatcap.png',bbox_inches='tight') #saves figure
pl.show()
</pre>

A general trend from the above graphs is that the peak of the graph shifts towards lower temperatures as the size of the matrix used increases which means the Curie Temperature decreases as matrix size increases.

==Section 8 - Locating the Curie Temperature==
===TASK: A C++ program has been used to run some much longer simulations than would be possible on the college computers in Python. You can view its source code here if you are interested. Each file contains six columns: <math>T, E, E^2, M, M^2, C</math> (the final five quantities are per spin), and you can read them with the NumPy loadtxt function as before. For each lattice size, plot the C++ data against your data. For one lattice size, save a PNG of this comparison and add it to your report — add a legend to the graph to label which is which. To do this, you will need to pass the label="..." keyword to the plot function, then call the legend() function of the axis object (documentation here).===

The python code used to read and plot the C++ data is found in the Jupyter notebook CG1417IsingModelGraphs.ipynb.

''Figure 15'' below shows the C++ plotted against my own data for a 16x16 Matrix.

[[File:Cg141716x16C++.png|400px|thumb|left|Figure 15 - Graph showing my own data against the C++ data for a 16x16 matrix.]]

 

Here is the source code the produce the figuresː
<pre>#fitting C++ data

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.plot(temps2x2, np.array(energies2x2)/4,color='black',alpha=0.7,label='Python Data') #python energy against T
enerax.plot(temps2x2C, energies2x2C, color='red',label='C++ Data') #C energy against T
magax.plot(temps2x2, np.array(mag2x2)/4,color='black',alpha=0.7,label='Python Data') #python magnetisation against T
magax.plot(temps2x2C, mag2x2C,color='red',label='C++ Data') #C energy against T
enerax.legend() #shows legend on energy graph
magax.legend() #shows legend on energy graph
pl.show()
</pre>

The relevant variables and dat files were changed for each matrix.

===TASK: write a script to read the data from a particular file, and plot C vs T, as well as a fitted polynomial. Try changing the degree of the polynomial to improve the fit — in general, it might be difficult to get a good fit! Attach a PNG of an example fit to your report.===

The python script to read and plot the fitted polynomial is found in CG1417PolyfitScript.ipynb

Here is the source code for ''Figure 15''

<pre>data_test = np.loadtxt("16x16C.dat")
T_test = data_test[:,0] #gets temperatures
C_test = data_test[:,5] #gets heat capacity data

#first we fit the polynomial to the data
fit_test = np.polyfit(T_test, C_test, 35) # fit a polynomial

#now we generate interpolated values of the fitted polynomial over the range of our function
T_min_test = 0.5 #np.min(T_test)
T_max_test = 5 #np.max(T_test)

T_range_test = np.linspace(T_min_test, T_max_test, 1000) #generate 1000 evenly spaced points between T_min and T_max
fitted_C_values_test = np.polyval(fit_test, T_range_test)# use the fit object to generate the corresponding values of C

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(T_test,C_test,color='orange',label='C++ Data') #plots C data of heat capacity against temp
heatcapax.plot(T_range_test,fitted_C_values_test,label='Fitted Polynomial') #plots fitted polynomial for whole range of temp
heatcapax.legend()
pl.savefig('FIT_TEST16x16_35.png', bbox_inches='tight') #saves figure
pl.show()
</pre>

Below in ''Figure 15'' is a plot of my Heat Capacity against Temperature data for a 16x16 matrix and features a polynomial of degree 35 plotted against it. Even with a polynomial of such a high degree, it poorly fits the curve and does not fit to the peak of the curve either.

[[File:cg1417FIT_TEST16x16_35.png|thumb|left|400px|Figure 15 - Plot of Heat Capacity against Temperature along with a poorly fitted polynomial of degree 35. ]]

 

===TASK: Modify your script from the previous section. You should still plot the whole temperature range, but fit the polynomial only to the peak of the heat capacity! You should find it easier to get a good fit when restricted to this region===

The script was modified as such that the polynomial was fitted in a set range around the peak of the graph, this is demonstrated in ''Figure 17'' which shows a newly fitted polynomial between a much smaller range of temperatures (T = 2.15-2.55) and a much smaller degree polynomial (3).

[[File:CG1417FIT_16x16C_3.png|thumb|left|400px|Figure 16 - Graph showing Heat Capacity against Temperature for a 16x16 matrix along with a fitted polynomial between a much more restricted range of temperatures and a significantly lower degree of polynomial]]

Upon comparison with ''Figure 15'', the new fitted polynomial is a significantly better fit even for a 3rd degree polynomial and is a much more accurate representation of my data around the peak of the graph and will make it easier to determine the maximum value of Heat Capacity.

 

Here is the source code for ''Figure 16''ː
<pre>data16 = np.loadtxt("16x16C.dat") #loads data to variable

T16 = data16[:,0] #gets temps
C16 = data16[:,5] # gets heat capacities

Tmin16 = 2.15 #chosen min temp
Tmax16 = 2.55 #chosen max temp

selection16 = np.logical_and(T16 > Tmin16, T16 < Tmax16) #choose only those rows where both conditions are true
peak_T_values16 = T16[selection16] #choose temp values in range chosen above
peak_C_values16 = C16[selection16] #choose heat cap values in range of t above

fit16 = np.polyfit(peak_T_values16,peak_C_values16,3) #fit 3rd order polynomial
peak_T_range16 = np.linspace(Tmin16, Tmax16, 1000) #defines 1000 temps within data range
fitted_C_values16 = np.polyval(fit16, peak_T_range16) #use the fit object to get corresponding values of heat cap

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(T16,C16,color='orange',label='C++ Data') #plots C data of heat cap against temp
heatcapax.plot(peak_T_range16,fitted_C_values16,label='Fitted Polynomial') #plots fitted polynomial for small range
heatcapax.legend()
pl.savefig('FIT_16x16C_3.png', bbox_inches='tight') #saves figure
pl.show()

</pre>

===TASK: find the temperature at which the maximum in C occurs for each datafile that you were given. Make a text file containing two colums: the lattice side length (2,4,8, etc.), and the temperature at which C is a maximum. This is your estimate of <math>T_C</math> for that side length. Make a plot that uses the scaling relation given above to determine <math>T_{C,\infty}</math>. By doing a little research online, you should be able to find the theoretical exact Curie temperature for the infinite 2D Ising lattice. How does your value compare to this? Are you surprised by how good/bad the agreement is? Attach a PNG of this final graph to your report, and discuss briefly what you think the major sources of error are in your estimate.===

''Figure 17'' below shows a graph of <math>T_{C,L}</math> against <math>\frac{1}{Lattice Size}</math> to determine the Curie Temperature of an infinite 2D Ising Model Lattice <math>T_{C,\infty}</math>. The black dots represent the raw data obtained from obtaining the temperature at which the Heat Capacity was a maximum for the lattices and the red line in a linear curve fit plotted against the data to allow the y-intercept which is the Curie Temperature for the infinite 2D lattice to be determined.

[[File:cg1417CurieTemp.png|400px|thumb|left|Figure 17 - Plot of 1/Lattice Size against Curie Temperature for that lattice size.]]

The value for <math>T_{C,\inf}</math> obtained from the data is <math>T_{C,\infty} = 2.277 \frac{J}{k_B}</math> with a literature value being <math>T_{C,\infty} = 2.269 \frac{J}{k_B}</math> <ref>L. Onsager, Phys. Rev., 1944, 65, 117--149.</ref>for an infinite square 2D lattice. This means that my result slightly over-estimates the Curie Temperature for the infinite lattice and as a result for an infinite lattice the temperature at which spontaneous magnetisation stops would actually occur at a slightly lower temperature than expected. However, the difference between my value and the literature value is only 0.008 which is incredibly small and the amount of agreement between the two values is somewhat surprising, which means that the error in my estimates of the Curie Temperature for each lattice size is relatively small. The points which have the largest residuals and deviation from the line of best fit in ''Figure 17'' corresponds to the smaller lattice sizes of 2x2 and 4x4 where longer range interactions are more significant. The longer range interactions posed by the boundary conditions are nowhere near as significant for the larger sizes and causes the energy of the smaller matrices to be less accurate and have a larger associated error with the energy and thus the Curie Temperature for that lattice size. This affects the accuracy of the line of best fit and to increase the accuracy of this line, larger lattice sizes of 128x128, 256x256 etc should be included in the calculation for the line of best fit and the smaller matrices ignored.

 

Below is the source code used to generate ''Figure 17''
<pre>
Cmax64x64 = np.max(fitted_C_values64) #finds Cmax for 64x64 matrix - done for others already
Tmax64x64 = peak_T_range64[fitted_C_values64 == Cmax64x64] #finds Tmax corresponding to Cmax

LatSize=[2,4,8,16,32,64] #stores lattice sizes
Tmax=[Tmax2x2,Tmax4x4,Tmax8x8,Tmax16x16,Tmax32x32,Tmax64x64] #stores corresponding Tmax data
np.savetxt('CmaxVSTmax.txt', (LatSize,Tmax)) #writes data to txt file

ScalData=np.loadtxt('CmaxVSTmax.txt') #loads data
LatticeSize=ScalData[0] #gets lattice sizes
TempMax=ScalData[1] #gets max temp or curie temp for each lattice

Lmin1min = np.min(np.divide(1,LatticeSize)) #minimum of 1/LatticeSize values
Lmin1max = np.max(np.divide(1,LatticeSize)) #maximum of 1/LatticeSize values

fitTcl = np.polyfit(np.divide(1,LatticeSize),TempMax, 1) #creates fit object

Lmin1values = np.linspace(Lmin1min, Lmin1max, 1000) #finds 1000 values between min and max x-axis value of 1/LatticeSize
fitted_Tcl_values = np.polyval(fitTcl, Lmin1values) #creates corresponding Curie Temp values for each value in Lmin1values

fig = pl.figure()
scalrelax = fig.add_subplot(1,1,1)
scalrelax.set_xlabel('1/Lattice Size')
scalrelax.set_ylabel('Curie Temperature/ J/k_B')
scalrelax.plot(np.divide(1,LatticeSize),TempMax,color='black',marker='.',linestyle='') #plots Curie Temp against 1/LatticeSize
scalrelax.plot(Lmin1values,fitted_Tcl_values,color='red',marker='',linestyle='-') #plots line of best fit for data above
pl.savefig('CurieTemp.png', bbox_inches='tight') #saves figure
pl.show()

</pre>

== References ==

Rep:Y3CMPCG1417

2019-11-20T10:14:29Z

==Section 1 - Introduction to the Ising Model==

===TASK: Show that the lowest possible energy for the Ising model is <math>E = -DNJ</math>, where D is the number of dimensions and N is the total number of spins. What is the multiplicity of this state? Calculate its entropy.===

Consider a 1D row of lattice sites of N=3 with spin configuration [+1][+1][+1].

Mathematically the interaction energy is defined asː
<math> -\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} </math> where J is a constant and <math>s_{i}s_{j}</math> is the product between two spins in adjacent lattice sites.

The sum of the interaction energies <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j}</math> can be considered as the sum of the individual interaction energies between spinsː
<math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = \epsilon_{12} + \epsilon_{23} + \epsilon_{13} + \epsilon_{21} + \epsilon_{32} + \epsilon_{31} </math>.

Although lattice sites 1 and 3 are not adjacent they are said to still interact according to the periodic boundary conditions applied.

However, <math>\epsilon_{12} = \epsilon_{21} </math> and <math>\epsilon_{23} = \epsilon_{32}</math> and <math>\epsilon_{13} = \epsilon_{31}</math> which means that all of the interactions within the system are counted twice, hence the total energy needs to be halved, resulting in the following formula being obtainedː <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = 2\epsilon_{12} + 2\epsilon_{13} + 2\epsilon_{23} </math>.

It can be determined that <math>\epsilon_{12} = (+1)(+1) = 1</math> , <math>\epsilon_{13} = (+1)(+1) = 1</math> and <math>\epsilon_{23} = (+1)(+1) = 1</math>.

Thereforeː <math>-\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = -\frac{1}{2} \ J \ (2 + 2 + 2) = -\frac{1}{2} \ J \ 6 = - 3 J = -DNJ</math> for a 1D lattice with <math>D=1</math> and 3 lattice sites <math>N=3</math>

The multiplicity of the system,<math>\Omega = \frac{lattice sites!}{n. spin up!n. spin down!}</math>

Entropy, <math>S</math> is defined as <math>S = k_B ln(\Omega)</math> and so in this case <math>S = k_B ln(\frac{100!}{100!}) = 0</math>

===TASK: Imagine that the system is in the lowest energy configuration. To move to a different state, one of the spins must spontaneously change direction ("flip"). What is the change in energy if this happens <math>(D=3, N=1000)</math>? How much entropy does the system gain by doing soʔ===

In a 3D lattice system, each lattice site has three unique interactions with its neighbours to its left, top and front. In the lowest energy configuration, all spins are parallel and for a system the minimum energy is <math>E = -DNJ</math>, so for the system with <math>N=1000</math> and <math>D=3</math>, the minimum energy is <math>-3000J</math>.

If a single spin is flipped, the product of its spin with its neighbours spin reverses and becomes negative and this increases the total energy of the system. Since 3 unique spin-spin interactions are reversed in sign, the total energy increases by <math>+3J</math>, meaning the new total energy is <math>-2997J</math>

Initially the multiplicity of the system will be <math>\Omega = \frac{1000!}{1000!}</math> , and after the flip, the multiplicity becomes <math> \Omega = \frac{1000!}{999!1!}=1000</math>.

The associated change in entropy, <math>\Delta S = k_B ln(1000) - 0 = 6.91 k_B</math>, which is an expected increase in entropy as the number of possible configurations of the system increases.

===TASK: Calculate the magnetisation of the 1D and 2D lattices in Figure 1. What magnetisation would you expect to observe for an Ising lattice with <math>D = 3,\ N=1000</math> at absolute zero?===

[[File:ThirdYearCMPExpt-IsingSketch.png|thumb|left|Figure 1 - Shows 1D (N = 5), 2D (N = 5x5) and 3D (N = 5x5x5) lattices.]]

Magnetisation is defined as <math>M=\sum_{i} s_i</math>. So for the 1D lattice with <math>N = 5</math> in ''Figure 2'', <math>M = +1</math> and for the 2D lattice with <math>N = 25 , M = +1</math> too.

According to the 3rd Law of thermodynamics, entropy is 0 at absolute zero for a perfect crystalline solid, and consequently it is expected that the lattices will have follow suit and have zero entropy at 0K. To have zero entropy all spins must be parallel as such that magnetisation, <math>M = N</math>. For all the spins to be parallel, there is only one possible configuration. So, for a lattice with <math>N = 1000</math> and <math>D =3</math>, if <math>M = N</math>, then multiplicity, <math>\Omega = 1</math> and entropy, <math>S =k_B ln(1) = 0</math>.

 

==Section 2 - Calculating the Energy and Magnetisation==

===TASK: complete the functions energy() and magnetisation(), which should return the energy of the lattice and the total magnetisation, respectively. In the energy() function you may assume that <math>J=1.0</math> at all times (in fact, we are working in reduced units in which <math>J=k_B</math>, but there will be more information about this in later sections). Do not worry about the efficiency of the code at the moment — we will address the speed in a later part of the experiment.===

<pre>def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
lat=self.lattice #creates lattice and stores it
mag=[]
for i in range(0,len(lat)): #loops through all rows of lattice
for j in range(0,len(lat[i])): #loops through elements of each row
mag+=[lat[i][j]] #adds spin value to mag array
return sum(mag) #sums all spins from mag array
</pre>

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

lat=self.lattice #creates lattice and stores it
left=[]
top=[]

for i in range(0,len(lat)):
for j in range(0,len(lat[i])):
left+=[lat[i][j]*lat[i][j-1]] #multiplies spin by spin to left
top+=[lat[i][j]*lat[i-1][j]] #multiplies spin by spin above it
int_en=left+top #sums spin products from left and top
energy=-sum(int_en) #sums all spin products for each spin to give total

return energy
</pre>

===TASK: Run the ILcheck.py script from the IPython Qt console using the command===

''Figure 2'' shows the results when ILcheck.py was ran on my IsingLattice.py file. The ILcheck.py file was ran several times to ensure the code worked for various random lattices.

[[File:Cg1417ILcheck run.png|thumb|left|500px| Figure 2 - Result from running the ILcheck.py file]]

 

==Section 3 - Introduction to Monte Carlo Simulation==

===TASK: How many configurations are available to a system with 100 spins? To evaluate these expressions, we have to calculate the energy and magnetisation for each of these configurations, then perform the sum. Let's be very, very, generous, and say that we can analyse <math>1\times 10^9</math> configurations per second with our computer. How long will it take to evaluate a single value of <math>\left\langle M\right\rangle_T</math>?===

For a system with 100 lattice sites and two possible spins for each site, there are <math>2^{100}</math>possible configurations for the system. <math>2^{100}= 1.27\times 10^{30} </math>, so if the computer can analyse <math>1\times 10^9</math> configurations per second, then it will take <math>\frac{1.27\times 10^{30}}{10^9} = 1.27\times 10^{21} s</math> to analyse the whole system, which is longer than the age of the universe and therefore is not a practical approach.

===TASK: Implement a single cycle of the above algorithm in the montecarlocycle(T) function. This function should return the energy of your lattice and the magnetisation at the end of the cycle. You may assume that the energy returned by your energy() function is in units of <math>k_B</math>! Complete the statistics() function. This should return the following quantities whenever it is called: <math><E>, <E^2>, <M>, <M^2></math>, and the number of Monte Carlo steps that have elapsed.===
<pre>
E = []
E2 = []
M = []
M2 = []
n_cycles = 0

def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back if rejected else not changed

self.E+=[self.energy()] #records energy
self.E2+=[self.energy()**2] #records energy squared
self.M+=[self.magnetisation()] #records magnetisation
self.M2+=[self.magnetisation()**2] #records magnetisation squared
self.n_cycles=self.n_cycles+1 #adds 1 to run total

return (self.energy(),self.magnetisation())

def statistics(self):
# complete this function so that it calculates the correct values for the averages of E, E*E (E2), M, M*M (M2), and returns them

e=np.mean(self.E)
e2=np.mean(self.E2)
m=np.mean(self.M)
m2=np.mean(self.M2)

return e,e2,m,m2,self.n_cycles
</pre>

''Figure 3'' shows the results of a single run of the montecarlostep() function and the lattice the function operated upon.

[[File:cg1417MonteCarloStep_run.png|thumb|left|Figure 3 - Results from a single montecarlostep() function and the resulting lattice produced along with the correct return from the statistics() function]]

 

===TASK: If <math>T < T_C</math>, do you expect a spontaneous magnetisation (i.e. do you expect <math>\left\langle M\right\rangle \neq 0</math>)? When the state of the simulation appears to stop changing (when you have reached an equilibrium state), use the controls to export the output to PNG and attach this to your report. You should also include the output from your statistics() function.===

If the temperature of the system is less than the Curie Temperature, <math>T_C</math> then spontaneous magnetisation can occur and the system will tend to its lowest energy state where all of the spins are parallel - this is a property of ferromagnetic materials.

[[File:Cg1417ILanim_run.png|400px|thumb|left|Figure 4 - Results from running the ILanim.py file - shows the energy and magnetisation converging over time]]

''Figure 4'' shows that over time the the system spontaneously converges to the minimum energy state with all of the spins parallel to one another and shows, as I expected, that spontaneous magnetisation occurs and also shows that the temperature of this simulation is below the Curie Temperature, <math>T < T_C</math>.

 

==Section 4 - Accelerating the Code==

===TASK: Use the script ILtimetrial.py to record how long your current version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 5'' show the results of running the ILtimetrial.py file on my code three timesː

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1.png
| width1=500
| image2=cg1417ILtimetrial_run2.png
| width2=500
| image3=cg1417ILtimetrial_run3.png
| width3=500
| footer = Figure 5 - Results of running the ILtimetrial.py file on my code three separate times
}}
 

This gave me an avergage time of <math>24.3 s \pm 0.2s</math>

===TASK: Look at the documentation for the NumPy sum function. You should be able to modify your magnetisation() function so that it uses this to evaluate M. The energy is a little trickier. Familiarise yourself with the NumPy roll and multiply functions, and use these to replace your energy double loop (you will need to call roll and multiply twice!).===

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

left=multiply(roll(self.lattice,1,axis=1),self.lattice) #product of spin with spin left of it
top=multiply(roll(self.lattice,-1,axis=0),self.lattice) #product of spin with spin above it

int_en=sum(left+top) #sum of array containing sum of left and top spin products for each spin

energy = -sum(int_en) #calculates the total energy of system
return energy

def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
return sum(sum(self.lattice)) #adds up all spins in lattice
</pre>

===TASK: Use the script ILtimetrial.py to record how long your new version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 6'' shows the result of running the ILtimetrial.py on my new accelerated code.

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1fast.png
| width1=500
| image2=ILtimetrial_run2fast.png
| width2=500
| image3=ILtimetrial_run3fast.png
| width3=500
| footer = Figure 6 - Results of running the ILtimetrial.py file on my new updated and accelerated code.
}}
 

The accelerated code is much faster upon using the roll, multiply and sum modules with a new average time of <math>0.790 s \pm 0.005 </math>

==Section 5 - The effect of temperature==

===TASK: The script ILfinalframe.py runs for a given number of cycles at a given temperature, then plots a depiction of the final lattice state as well as graphs of the energy and magnetisation as a function of cycle number. This is much quicker than animating every frame! Experiment with different temperature and lattice sizes. How many cycles are typically needed for the system to go from its random starting position to the equilibrium state? Modify your statistics() and montecarlostep() functions so that the first N cycles of the simulation are ignored when calculating the averages. You should state in your report what period you chose to ignore, and include graphs from ILfinalframe.py to illustrate your motivation in choosing this figure.===

''Figure 7'' below shows the results from running the ILfinalframe.py for 2x2 lattice at T=1,2,3,5.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2T1.png
| image2 = cg14172x2T2.png
| image3 =cg14172x2T3.png
| image4 =cg14172x2T5.png
| footer_align = left
| footer = Figure 7 - Results of running the ILfinalframe.py file at T=1,2,3,5 for a 2x2 matrix.
}}

 

For a 2x2 matrix, a suitable cut-off point to exclude from the avergage energies and magnetisations is where the energy and magnetisations per spin are constant, which is 30 steps. For T=3 and T=5 the graphs do not converge because it is possible that these temperatures are higher than the Curie Temperature and as such spontaneous magnetisation will not occur and the system will not diverge to the lowest energy state. At the higher temperatures, there are larger thermal fluctations and the Boltzmann factor is more significant allowing the system to move away from the lowest energy state easier. As a result moving forwards, a suitable cut-off point will only be determined from T=1 and T=2 graphs for the larger matrices.

''Figure 8'' shows the results from running a 4x4 lattice at T=1,2 and 3.

{{multiple image
| width =350
| align = left
| image1 = cg14174x4T1.png
| image2 = cg14174x4T2.png
| image3 =cg14174x4T3.png
| footer_align = left
| footer = Figure 8 - Results of running the ILfinalframe.py file at T=1,2,3 for a 4x4 matrix.
}}

From ''Figure 8'', a suitable cut-off point for the energy and magnetisations is 200 as this is after where the energy and magnetisation has converged for T=1, and is after the initial large drop in energy for T=2, even though there are a few small fluctuations after 200 steps. The result from T=3 has been included to show the large fluctuations for the larger temperatures, and supporting my choice to determine the cut-off from T=1 and T=2 only.

''Figure 9'' shows the results for an 8x8 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg14178x8T1.png
| image2 = cg14178x8T2.png
| footer_align = left
| footer = Figure 9 - Results of running the ILfinalframe.py file at T=1,2 for an 8x8 matrix
}}

From ''Figure 9'' above, a suitable cut-off point is 1000 steps as this is where the energy and magnetisation has easily converged by and is also the point after which the initial large drop in energy has been overcome for T=2 too.

''Figure 10'' shows the result of running the ILfinalframe.py for a 16x16 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg141716x16T1.png
| image2 = cg141716x16T2.png
| footer_align = left
| footer = Figure 10 - Results of running the ILfinalframe.py file at T=1,2 for a 16x16 matrix
}}

From ''Figure 10'', a suitable cut-off point is 15000 steps as for T=1 the energy and magnetisations have converged significantly and will not change much, and likewise this is the same for the T=2 frame.

''Figure 11'' below shows the results from a 32x32 matrix at T=1 and T=2.

{{multiple image
| width =350
| align = left
| image1 = cg141732x32T1.png
| image2 = cg141732x32T2.png
| footer_align = left
| footer = Figure 11 - Results of running the ILfinalframe.py file at T=1,2 for a 32x32 matrix
}}

''Figure 11'' above shows the results of running the ILfinalframe.py file for a 32x32 matrix at T=1 and T=2. As a result a suitable cut-off of 50000 steps was chosen as the energy and magnetisation has significantly converged, but not as much as it could at 100000 steps. I chose a slightly lower value to ensure that the run times of my monte-carlo simulations in future tasks were not extremely time consuming.

The montecarlostep() function was changed by adding a condition that values only above the pre-determined cut-off were included when determining the average value of energy; energy squared; magnetisation and magnetisations squared from the statistics function. The statistics() function did not need to be modified.

The following code is from the 32x32 matrixː

<pre>def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back

if self.n_cycles > 50000: #only adds values to array of E,E2,M and M2 is above specific cut-off
self.E+=[self.energy()]
self.E2+=[self.energy()**2]
self.M+=[self.magnetisation()]
self.M2+=[self.magnetisation()**2]
self.n_cycles=self.n_cycles+1

return (self.energy(),self.magnetisation())
</pre>

===TASK: Use ILtemperaturerange.py to plot the average energy and magnetisation for each temperature, with error bars, for an <math>8\times 8</math> lattice. Use your intuition and results from the script ILfinalframe.py to estimate how many cycles each simulation should be. The temperature range 0.25 to 5.0 is sufficient. Use as many temperature points as you feel necessary to illustrate the trend, but do not use a temperature spacing larger than 0.5. The NumPy function savetxt() stores your array of output data on disk — you will need it later. Save the file as 8x8.dat so that you know which lattice size it came from.===

Using the modified code, the file ILtemperaturerange.py was ran on an 8x8 matrix between T=0.5 and T=5 with a step of T=0.02 for 10000 Montecarlo steps and the first 1000 steps of each temperature were excluded when calculating the averages. ''Figure 12'' shows the result of the simulation and also included error bars of standard deviation.

[[File:Cg14178x8error.png|1000px|thumb|left|Figure 12 - Graph showing average energy and average magnetisation for an 8x8 lattice with error bars between T=0.5 and T=5]]

 

Below is the source code for the script to produce the graphː

<pre>data8x8=np.loadtxt('8x8.dat') #loads data
temps8x8=data8x8[:,0] #stores temperatures
energies8x8=data8x8[:,1] #stores average energy for each T
energysq8x8=data8x8[:,2] #stores average energy squared for each T
mag8x8=data8x8[:,3] #stores magnetisation for each T
magsq8x8=data8x8[:,4] #stores magnetisation squared for each T
stde8x8=data8x8[:,5] #edited ILtemperaturerange.py to record the standard deviation of the energy for each T
stdm8x8=data8x8[:,6] #edited ILtemperaturerange.py to record the standard deviation of the magnetisation for each T

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.errorbar(temps8x8, np.array(energies8x8)/64,yerr=np.divide(stde8x8,64),color='black',ecolor='teal',alpha=0.8) #plots energy per spin against T
magax.errorbar(temps8x8, np.array(mag8x8)/64,yerr=np.divide(stdm8x8,64),alpha=0.8,ecolor='salmon',color='black') #plots magnetisation per spin against T on separate graph
pl.savefig('8x8error.png',bbox_inches='tight') #saves figure
pl.show()

</pre>

==Section 6 - The effect of system size==

===TASK: Repeat the final task of the previous section for the following lattice sizes: 2x2, 4x4, 8x8, 16x16, 32x32. Make sure that you name each datafile that your produce after the corresponding lattice size! Write a Python script to make a plot showing the energy per spin versus temperature for each of your lattice sizes. Hint: the NumPy loadtxt function is the reverse of the savetxt function, and can be used to read your previously saved files into the script. Repeat this for the magnetisation. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. How big a lattice do you think is big enough to capture the long range fluctuations?===

The python script for this section is identical as for the 8x8 graph above in Figure 12 with the relevant files and variables changed accordingly.

Each matrix was simulated using the ILtemperaturerange.py file between T=0.5 and T=5 with a step of T=0.02.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2error.png
| caption1 = 2x2 matrix - 5000 steps, cut-off = 30 steps
| image2 = 4x4error.png
| caption2 = 4x4 matrix - 1000 steps, cut-off = 200 steps
| image3 =cg141716x16error.png
| caption3 = 16x16 matrix - 50000 steps, cut-off = 15000 steps
| image4 =cg141732x32error.png
| caption4 = 32x32 matrix - 200000 steps, cut-off = 50000 steps
| footer_align = left
| footer = Figure 13 - Results of running the ILtemperaturerange.py file for 2x2, 4x4, 16x16 and 32x32 matrices.
}}

 

==Section 7 - Determining the Heat Capacity==

===TASK: By definition, <math>C = \frac{\partial \left\langle E\right\rangle}{\partial T}</math>. From this, show that <math>C = \frac{\mathrm{Var}[E]}{k_B T^2}</math> (Where <math>\mathrm{Var}[E]</math> is the variance in <math>E</math>.)===

Recall from statistical thermodynamics that the average energy of a system is the sum across all microstates of the probability of that microstate multiplied by the energy of that microstate, which is defined mathematically asː <math>\langle E \rangle = \sum_i p_{i}\epsilon_{i}</math>.

The partition function <math>q</math> is defined as <math>q = \sum_{i} exp(-\beta \epsilon_{i})</math> where <math>\beta =\frac{1}{k_BT}</math>and the probability, <math>p_{i}</math> can be defined in terms of the partition function as <math>p_{i} = \frac{exp(-\beta \epsilon_{i})}{\sum_{i} exp(-\beta \epsilon_{i})} = \frac{exp(-\beta \epsilon_{i})}{q}</math>.

As a result, <math>\langle E \rangle</math> can be re-written as <math>\langle E \rangle = \sum_{i} \frac{\epsilon_{i} exp(-\beta \epsilon_{i})}{q} = -\frac{1}{q} \frac{\partial}{\partial \beta}\sum_{i}exp(-\beta \epsilon_{i}) = -\frac{1}{q} \frac{\partial q}{\partial \beta}</math>

Likewise, <math>\langle E^2 \rangle = \sum_i p_{i}\epsilon_{i}^{2} = \sum_{i} \frac{\epsilon_{i}^{2}exp(-\beta \epsilon_{i})}{q} = \frac{1}{q} \frac{\partial^{2}}{\partial \beta^{2}}\sum_{i}exp(-\beta \epsilon_{i}) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}}</math>

From definitionː <math>Var[E] = \Delta E^2 = \langle E^2 \rangle - \langle E \rangle^2 </math>

When the definition of <math>\langle E \rangle</math> and <math>\langle E^2 \rangle</math> is written in terms of partition function <math>q</math>ː <math>Var[E] = \langle E^2 \rangle - \langle E \rangle^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \left(\frac{1}{q}\frac{\partial q}{\partial \beta}\right)^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2</math>.

According to the chain ruleː <math>\frac{\partial}{\partial \beta}\left(\frac{1}{q} \frac{\partial q}{\partial \beta}\right) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2 = -\frac{\partial}{\partial \beta}\langle E \rangle = Var[E]</math>

And using the chain rule againː <math>C = \frac{\partial \langle E \rangle}{\partial T}= \left(-\frac{\partial \langle E \rangle}{\partial \beta}\right) \left(-\frac{\partial \beta}{\partial T}\right) = \frac{Var[E]}{k_B T^2}</math>

===TASK: Write a Python script to make a plot showing the heat capacity versus temperature for each of your lattice sizes from the previous section. You may need to do some research to recall the connection between the variance of a variable, <math>\mathrm{Var}[X]</math>, the mean of its square <math>\left\langle X^2\right\rangle</math>, and its squared mean <math>\left\langle X\right\rangle^2</math>. You may find that the data around the peak is very noisy — this is normal, and is a result of being in the critical region. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. ===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb

{{multiple image
| width =300
| align = left
| image1 = cg14172x2heatcap.png
| caption1 = 2x2 Matrix
| image2 = cg14174x4heatcap.png
| caption2 = 4x4 Matrix
| image3 =cg14178x8heatcap.png
| caption3 = 8x8 Matrix
| image4 =cg141716x16heatcap.png
| caption4 = 16x16 Matrix
| image5=cg141732x32heatcap.png
| caption5= 32x32 Matrix
| footer = Figure 14 - Graphs showing Heat Capacity against Temperature for each matrix size
}}

Here is the source code to produce the figuresː
<pre> def heatCap(energies,energysq,T,latsize):
#defines the heat capacity for a given temperature
energiesq=np.multiply(energies,energies) #creates array of (average energies) squared
varE=np.subtract(energysq,energiesq) #defines variance of average energy
tempsq=np.multiply(T,T) #array of temperature squared
return np.array(np.divide(varE,tempsq))/(latsize**2)

heatCap2x2=heatCap(energies2x2,energysq2x2,temps2x2,2) #creates array of heat capacity for each T

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(temps2x2,heatCap2x2,color='orange') #plots heat capacity for each T
pl.savefig('cg14172x2heatcap.png',bbox_inches='tight') #saves figure
pl.show()
</pre>

A general trend from the above graphs is that the peak of the graph shifts towards lower temperatures as the size of the matrix used increases which means the Curie Temperature decreases as matrix size increases.

==Section 8 - Locating the Curie Temperature==
===TASK: A C++ program has been used to run some much longer simulations than would be possible on the college computers in Python. You can view its source code here if you are interested. Each file contains six columns: <math>T, E, E^2, M, M^2, C</math> (the final five quantities are per spin), and you can read them with the NumPy loadtxt function as before. For each lattice size, plot the C++ data against your data. For one lattice size, save a PNG of this comparison and add it to your report — add a legend to the graph to label which is which. To do this, you will need to pass the label="..." keyword to the plot function, then call the legend() function of the axis object (documentation here).===

The python code used to read and plot the C++ data is found in the Jupyter notebook CG1417IsingModelGraphs.ipynb.

''Figure 14'' below shows the C++ plotted against my own data for a 16x16 Matrix.

[[File:Cg141716x16C++.png|400px|thumb|left|Figure 14 - Graph showing my own data against the C++ data for a 16x16 matrix.]]

 

Here is the source code the produce the figuresː
<pre>#fitting C++ data

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.plot(temps2x2, np.array(energies2x2)/4,color='black',alpha=0.7,label='Python Data') #python energy against T
enerax.plot(temps2x2C, energies2x2C, color='red',label='C++ Data') #C energy against T
magax.plot(temps2x2, np.array(mag2x2)/4,color='black',alpha=0.7,label='Python Data') #python magnetisation against T
magax.plot(temps2x2C, mag2x2C,color='red',label='C++ Data') #C energy against T
enerax.legend() #shows legend on energy graph
magax.legend() #shows legend on energy graph
pl.show()
</pre>

The relevant variables and dat files were changed for each matrix.

===TASK: write a script to read the data from a particular file, and plot C vs T, as well as a fitted polynomial. Try changing the degree of the polynomial to improve the fit — in general, it might be difficult to get a good fit! Attach a PNG of an example fit to your report.===

The python script to read and plot the fitted polynomial is found in CG1417PolyfitScript.ipynb

Here is the source code for ''Figure 15''

<pre>data_test = np.loadtxt("16x16C.dat")
T_test = data_test[:,0] #gets temperatures
C_test = data_test[:,5] #gets heat capacity data

#first we fit the polynomial to the data
fit_test = np.polyfit(T_test, C_test, 35) # fit a polynomial

#now we generate interpolated values of the fitted polynomial over the range of our function
T_min_test = 0.5 #np.min(T_test)
T_max_test = 5 #np.max(T_test)

T_range_test = np.linspace(T_min_test, T_max_test, 1000) #generate 1000 evenly spaced points between T_min and T_max
fitted_C_values_test = np.polyval(fit_test, T_range_test)# use the fit object to generate the corresponding values of C

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(T_test,C_test,color='orange',label='C++ Data') #plots C data of heat capacity against temp
heatcapax.plot(T_range_test,fitted_C_values_test,label='Fitted Polynomial') #plots fitted polynomial for whole range of temp
heatcapax.legend()
pl.savefig('FIT_TEST16x16_35.png', bbox_inches='tight') #saves figure
pl.show()
</pre>

Below in ''Figure 15'' is a plot of my Heat Capacity against Temperature data for a 16x16 matrix and features a polynomial of degree 35 plotted against it. Even with a polynomial of such a high degree, it poorly fits the curve and does not fit to the peak of the curve either.

[[File:cg1417FIT_TEST16x16_35.png|thumb|left|400px|Figure 15 - Plot of Heat Capacity against Temperature along with a poorly fitted polynomial of degree 35. ]]

 

===TASK: Modify your script from the previous section. You should still plot the whole temperature range, but fit the polynomial only to the peak of the heat capacity! You should find it easier to get a good fit when restricted to this region===

The script was modified as such that the polynomial was fitted in a set range around the peak of the graph, this is demonstrated in ''Figure 17'' which shows a newly fitted polynomial between a much smaller range of temperatures (T = 2.15-2.55) and a much smaller degree polynomial (3).

[[File:CG1417FIT_16x16C_3.png|thumb|left|400px|Figure 16 - Graph showing Heat Capacity against Temperature for a 16x16 matrix along with a fitted polynomial between a much more restricted range of temperatures and a significantly lower degree of polynomial]]

Upon comparison with ''Figure 15'', the new fitted polynomial is a significantly better fit even for a 3rd degree polynomial and is a much more accurate representation of my data around the peak of the graph and will make it easier to determine the maximum value of Heat Capacity.

 

Here is the source code for ''Figure 16''ː
<pre>data16 = np.loadtxt("16x16C.dat") #loads data to variable

T16 = data16[:,0] #gets temps
C16 = data16[:,5] # gets heat capacities

Tmin16 = 2.15 #chosen min temp
Tmax16 = 2.55 #chosen max temp

selection16 = np.logical_and(T16 > Tmin16, T16 < Tmax16) #choose only those rows where both conditions are true
peak_T_values16 = T16[selection16] #choose temp values in range chosen above
peak_C_values16 = C16[selection16] #choose heat cap values in range of t above

fit16 = np.polyfit(peak_T_values16,peak_C_values16,3) #fit 3rd order polynomial
peak_T_range16 = np.linspace(Tmin16, Tmax16, 1000) #defines 1000 temps within data range
fitted_C_values16 = np.polyval(fit16, peak_T_range16) #use the fit object to get corresponding values of heat cap

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(T16,C16,color='orange',label='C++ Data') #plots C data of heat cap against temp
heatcapax.plot(peak_T_range16,fitted_C_values16,label='Fitted Polynomial') #plots fitted polynomial for small range
heatcapax.legend()
pl.savefig('FIT_16x16C_3.png', bbox_inches='tight') #saves figure
pl.show()

</pre>

===TASK: find the temperature at which the maximum in C occurs for each datafile that you were given. Make a text file containing two colums: the lattice side length (2,4,8, etc.), and the temperature at which C is a maximum. This is your estimate of <math>T_C</math> for that side length. Make a plot that uses the scaling relation given above to determine <math>T_{C,\infty}</math>. By doing a little research online, you should be able to find the theoretical exact Curie temperature for the infinite 2D Ising lattice. How does your value compare to this? Are you surprised by how good/bad the agreement is? Attach a PNG of this final graph to your report, and discuss briefly what you think the major sources of error are in your estimate.===

''Figure 17'' below shows a graph of <math>T_{C,L}</math> against <math>\frac{1}{Lattice Size}</math> to determine the Curie Temperature of an infinite 2D Ising Model Lattice <math>T_{C,\infty}</math>. The black dots represent the raw data obtained from obtaining the temperature at which the Heat Capacity was a maximum for the lattices and the red line in a linear curve fit plotted against the data to allow the y-intercept which is the Curie Temperature for the infinite 2D lattice to be determined.

[[File:cg1417CurieTemp.png|400px|thumb|left|Figure 17 - Plot of 1/Lattice Size against Curie Temperature for that lattice size.]]

The value for <math>T_{C,\inf}</math> obtained from the data is <math>T_{C,\infty} = 2.277 \frac{J}{k_B}</math> with a literature value being <math>T_{C,\infty} = 2.269 \frac{J}{k_B}</math> <ref>L. Onsager, Phys. Rev., 1944, 65, 117--149.</ref>for an infinite square 2D lattice. This means that my result slightly over-estimates the Curie Temperature for the infinite lattice and as a result for an infinite lattice the temperature at which spontaneous magnetisation stops would actually occur at a slightly lower temperature than expected. However, the difference between my value and the literature value is only 0.008 which is incredibly small and the amount of agreement between the two values is somewhat surprising, which means that the error in my estimates of the Curie Temperature for each lattice size is relatively small. The points which have the largest residuals and deviation from the line of best fit in ''Figure 17'' corresponds to the smaller lattice sizes of 2x2 and 4x4 where longer range interactions are more significant. The longer range interactions posed by the boundary conditions are nowhere near as significant for the larger sizes and causes the energy of the smaller matrices to be less accurate and have a larger associated error with the energy and thus the Curie Temperature for that lattice size. This affects the accuracy of the line of best fit and to increase the accuracy of this line, larger lattice sizes of 128x128, 256x256 etc should be included in the calculation for the line of best fit and the smaller matrices ignored.

 

Below is the source code used to generate ''Figure 17''
<pre>
Cmax64x64 = np.max(fitted_C_values64) #finds Cmax for 64x64 matrix - done for others already
Tmax64x64 = peak_T_range64[fitted_C_values64 == Cmax64x64] #finds Tmax corresponding to Cmax

LatSize=[2,4,8,16,32,64] #stores lattice sizes
Tmax=[Tmax2x2,Tmax4x4,Tmax8x8,Tmax16x16,Tmax32x32,Tmax64x64] #stores corresponding Tmax data
np.savetxt('CmaxVSTmax.txt', (LatSize,Tmax)) #writes data to txt file

ScalData=np.loadtxt('CmaxVSTmax.txt') #loads data
LatticeSize=ScalData[0] #gets lattice sizes
TempMax=ScalData[1] #gets max temp or curie temp for each lattice

Lmin1min = np.min(np.divide(1,LatticeSize)) #minimum of 1/LatticeSize values
Lmin1max = np.max(np.divide(1,LatticeSize)) #maximum of 1/LatticeSize values

fitTcl = np.polyfit(np.divide(1,LatticeSize),TempMax, 1) #creates fit object

Lmin1values = np.linspace(Lmin1min, Lmin1max, 1000) #finds 1000 values between min and max x-axis value of 1/LatticeSize
fitted_Tcl_values = np.polyval(fitTcl, Lmin1values) #creates corresponding Curie Temp values for each value in Lmin1values

fig = pl.figure()
scalrelax = fig.add_subplot(1,1,1)
scalrelax.set_xlabel('1/Lattice Size')
scalrelax.set_ylabel('Curie Temperature/ J/k_B')
scalrelax.plot(np.divide(1,LatticeSize),TempMax,color='black',marker='.',linestyle='') #plots Curie Temp against 1/LatticeSize
scalrelax.plot(Lmin1values,fitted_Tcl_values,color='red',marker='',linestyle='-') #plots line of best fit for data above
pl.savefig('CurieTemp.png', bbox_inches='tight') #saves figure
pl.show()

</pre>

== References ==

Rep:Y3CMPCG1417

2019-11-20T10:13:39Z

Cg1417: /* Section 6 - The effect of system size */

==Section 1 - Introduction to the Ising Model==

===TASK: Show that the lowest possible energy for the Ising model is <math>E = -DNJ</math>, where D is the number of dimensions and N is the total number of spins. What is the multiplicity of this state? Calculate its entropy.===

Consider a 1D row of lattice sites of N=3 with spin configuration [+1][+1][+1].

Mathematically the interaction energy is defined asː
<math> -\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} </math> where J is a constant and <math>s_{i}s_{j}</math> is the product between two spins in adjacent lattice sites.

The sum of the interaction energies <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j}</math> can be considered as the sum of the individual interaction energies between spinsː
<math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = \epsilon_{12} + \epsilon_{23} + \epsilon_{13} + \epsilon_{21} + \epsilon_{32} + \epsilon_{31} </math>.

Although lattice sites 1 and 3 are not adjacent they are said to still interact according to the periodic boundary conditions applied.

However, <math>\epsilon_{12} = \epsilon_{21} </math> and <math>\epsilon_{23} = \epsilon_{32}</math> and <math>\epsilon_{13} = \epsilon_{31}</math> which means that all of the interactions within the system are counted twice, hence the total energy needs to be halved, resulting in the following formula being obtainedː <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = 2\epsilon_{12} + 2\epsilon_{13} + 2\epsilon_{23} </math>.

It can be determined that <math>\epsilon_{12} = (+1)(+1) = 1</math> , <math>\epsilon_{13} = (+1)(+1) = 1</math> and <math>\epsilon_{23} = (+1)(+1) = 1</math>.

Thereforeː <math>-\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = -\frac{1}{2} \ J \ (2 + 2 + 2) = -\frac{1}{2} \ J \ 6 = - 3 J = -DNJ</math> for a 1D lattice with <math>D=1</math> and 3 lattice sites <math>N=3</math>

The multiplicity of the system,<math>\Omega = \frac{lattice sites!}{n. spin up!n. spin down!}</math>

Entropy, <math>S</math> is defined as <math>S = k_B ln(\Omega)</math> and so in this case <math>S = k_B ln(\frac{100!}{100!}) = 0</math>

===TASK: Imagine that the system is in the lowest energy configuration. To move to a different state, one of the spins must spontaneously change direction ("flip"). What is the change in energy if this happens <math>(D=3, N=1000)</math>? How much entropy does the system gain by doing soʔ===

In a 3D lattice system, each lattice site has three unique interactions with its neighbours to its left, top and front. In the lowest energy configuration, all spins are parallel and for a system the minimum energy is <math>E = -DNJ</math>, so for the system with <math>N=1000</math> and <math>D=3</math>, the minimum energy is <math>-3000J</math>.

If a single spin is flipped, the product of its spin with its neighbours spin reverses and becomes negative and this increases the total energy of the system. Since 3 unique spin-spin interactions are reversed in sign, the total energy increases by <math>+3J</math>, meaning the new total energy is <math>-2997J</math>

Initially the multiplicity of the system will be <math>\Omega = \frac{1000!}{1000!}</math> , and after the flip, the multiplicity becomes <math> \Omega = \frac{1000!}{999!1!}=1000</math>.

The associated change in entropy, <math>\Delta S = k_B ln(1000) - 0 = 6.91 k_B</math>, which is an expected increase in entropy as the number of possible configurations of the system increases.

===TASK: Calculate the magnetisation of the 1D and 2D lattices in Figure 1. What magnetisation would you expect to observe for an Ising lattice with <math>D = 3,\ N=1000</math> at absolute zero?===

[[File:ThirdYearCMPExpt-IsingSketch.png|thumb|left|Figure 1 - Shows 1D (N = 5), 2D (N = 5x5) and 3D (N = 5x5x5) lattices.]]

Magnetisation is defined as <math>M=\sum_{i} s_i</math>. So for the 1D lattice with <math>N = 5</math> in ''Figure 2'', <math>M = +1</math> and for the 2D lattice with <math>N = 25 , M = +1</math> too.

According to the 3rd Law of thermodynamics, entropy is 0 at absolute zero for a perfect crystalline solid, and consequently it is expected that the lattices will have follow suit and have zero entropy at 0K. To have zero entropy all spins must be parallel as such that magnetisation, <math>M = N</math>. For all the spins to be parallel, there is only one possible configuration. So, for a lattice with <math>N = 1000</math> and <math>D =3</math>, if <math>M = N</math>, then multiplicity, <math>\Omega = 1</math> and entropy, <math>S =k_B ln(1) = 0</math>.

 

==Section 2 - Calculating the Energy and Magnetisation==

===TASK: complete the functions energy() and magnetisation(), which should return the energy of the lattice and the total magnetisation, respectively. In the energy() function you may assume that <math>J=1.0</math> at all times (in fact, we are working in reduced units in which <math>J=k_B</math>, but there will be more information about this in later sections). Do not worry about the efficiency of the code at the moment — we will address the speed in a later part of the experiment.===

<pre>def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
lat=self.lattice #creates lattice and stores it
mag=[]
for i in range(0,len(lat)): #loops through all rows of lattice
for j in range(0,len(lat[i])): #loops through elements of each row
mag+=[lat[i][j]] #adds spin value to mag array
return sum(mag) #sums all spins from mag array
</pre>

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

lat=self.lattice #creates lattice and stores it
left=[]
top=[]

for i in range(0,len(lat)):
for j in range(0,len(lat[i])):
left+=[lat[i][j]*lat[i][j-1]] #multiplies spin by spin to left
top+=[lat[i][j]*lat[i-1][j]] #multiplies spin by spin above it
int_en=left+top #sums spin products from left and top
energy=-sum(int_en) #sums all spin products for each spin to give total

return energy
</pre>

===TASK: Run the ILcheck.py script from the IPython Qt console using the command===

''Figure 2'' shows the results when ILcheck.py was ran on my IsingLattice.py file. The ILcheck.py file was ran several times to ensure the code worked for various random lattices.

[[File:Cg1417ILcheck run.png|thumb|left|500px| Figure 2 - Result from running the ILcheck.py file]]

 

==Section 3 - Introduction to Monte Carlo Simulation==

===TASK: How many configurations are available to a system with 100 spins? To evaluate these expressions, we have to calculate the energy and magnetisation for each of these configurations, then perform the sum. Let's be very, very, generous, and say that we can analyse <math>1\times 10^9</math> configurations per second with our computer. How long will it take to evaluate a single value of <math>\left\langle M\right\rangle_T</math>?===

For a system with 100 lattice sites and two possible spins for each site, there are <math>2^{100}</math>possible configurations for the system. <math>2^{100}= 1.27\times 10^{30} </math>, so if the computer can analyse <math>1\times 10^9</math> configurations per second, then it will take <math>\frac{1.27\times 10^{30}}{10^9} = 1.27\times 10^{21} s</math> to analyse the whole system, which is longer than the age of the universe and therefore is not a practical approach.

===TASK: Implement a single cycle of the above algorithm in the montecarlocycle(T) function. This function should return the energy of your lattice and the magnetisation at the end of the cycle. You may assume that the energy returned by your energy() function is in units of <math>k_B</math>! Complete the statistics() function. This should return the following quantities whenever it is called: <math><E>, <E^2>, <M>, <M^2></math>, and the number of Monte Carlo steps that have elapsed.===
<pre>
E = []
E2 = []
M = []
M2 = []
n_cycles = 0

def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back if rejected else not changed

self.E+=[self.energy()] #records energy
self.E2+=[self.energy()**2] #records energy squared
self.M+=[self.magnetisation()] #records magnetisation
self.M2+=[self.magnetisation()**2] #records magnetisation squared
self.n_cycles=self.n_cycles+1 #adds 1 to run total

return (self.energy(),self.magnetisation())

def statistics(self):
# complete this function so that it calculates the correct values for the averages of E, E*E (E2), M, M*M (M2), and returns them

e=np.mean(self.E)
e2=np.mean(self.E2)
m=np.mean(self.M)
m2=np.mean(self.M2)

return e,e2,m,m2,self.n_cycles
</pre>

''Figure 3'' shows the results of a single run of the montecarlostep() function and the lattice the function operated upon.

[[File:cg1417MonteCarloStep_run.png|thumb|left|Figure 3 - Results from a single montecarlostep() function and the resulting lattice produced along with the correct return from the statistics() function]]

 

===TASK: If <math>T < T_C</math>, do you expect a spontaneous magnetisation (i.e. do you expect <math>\left\langle M\right\rangle \neq 0</math>)? When the state of the simulation appears to stop changing (when you have reached an equilibrium state), use the controls to export the output to PNG and attach this to your report. You should also include the output from your statistics() function.===

If the temperature of the system is less than the Curie Temperature, <math>T_C</math> then spontaneous magnetisation can occur and the system will tend to its lowest energy state where all of the spins are parallel - this is a property of ferromagnetic materials.

[[File:Cg1417ILanim_run.png|400px|thumb|left|Figure 4 - Results from running the ILanim.py file - shows the energy and magnetisation converging over time]]

''Figure 4'' shows that over time the the system spontaneously converges to the minimum energy state with all of the spins parallel to one another and shows, as I expected, that spontaneous magnetisation occurs and also shows that the temperature of this simulation is below the Curie Temperature, <math>T < T_C</math>.

 

==Section 4 - Accelerating the Code==

===TASK: Use the script ILtimetrial.py to record how long your current version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 5'' show the results of running the ILtimetrial.py file on my code three timesː

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1.png
| width1=500
| image2=cg1417ILtimetrial_run2.png
| width2=500
| image3=cg1417ILtimetrial_run3.png
| width3=500
| footer = Figure 5 - Results of running the ILtimetrial.py file on my code three separate times
}}
 

This gave me an avergage time of <math>24.3 s \pm 0.2s</math>

===TASK: Look at the documentation for the NumPy sum function. You should be able to modify your magnetisation() function so that it uses this to evaluate M. The energy is a little trickier. Familiarise yourself with the NumPy roll and multiply functions, and use these to replace your energy double loop (you will need to call roll and multiply twice!).===

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

left=multiply(roll(self.lattice,1,axis=1),self.lattice) #product of spin with spin left of it
top=multiply(roll(self.lattice,-1,axis=0),self.lattice) #product of spin with spin above it

int_en=sum(left+top) #sum of array containing sum of left and top spin products for each spin

energy = -sum(int_en) #calculates the total energy of system
return energy

def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
return sum(sum(self.lattice)) #adds up all spins in lattice
</pre>

===TASK: Use the script ILtimetrial.py to record how long your new version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 6'' shows the result of running the ILtimetrial.py on my new accelerated code.

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1fast.png
| width1=500
| image2=ILtimetrial_run2fast.png
| width2=500
| image3=ILtimetrial_run3fast.png
| width3=500
| footer = Figure 6 - Results of running the ILtimetrial.py file on my new updated and accelerated code.
}}
 

The accelerated code is much faster upon using the roll, multiply and sum modules with a new average time of <math>0.790 s \pm 0.005 </math>

==Section 5 - The effect of temperature==

===TASK: The script ILfinalframe.py runs for a given number of cycles at a given temperature, then plots a depiction of the final lattice state as well as graphs of the energy and magnetisation as a function of cycle number. This is much quicker than animating every frame! Experiment with different temperature and lattice sizes. How many cycles are typically needed for the system to go from its random starting position to the equilibrium state? Modify your statistics() and montecarlostep() functions so that the first N cycles of the simulation are ignored when calculating the averages. You should state in your report what period you chose to ignore, and include graphs from ILfinalframe.py to illustrate your motivation in choosing this figure.===

''Figure 7'' below shows the results from running the ILfinalframe.py for 2x2 lattice at T=1,2,3,5.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2T1.png
| image2 = cg14172x2T2.png
| image3 =cg14172x2T3.png
| image4 =cg14172x2T5.png
| footer_align = left
| footer = Figure 7 - Results of running the ILfinalframe.py file at T=1,2,3,5 for a 2x2 matrix.
}}

 

For a 2x2 matrix, a suitable cut-off point to exclude from the avergage energies and magnetisations is where the energy and magnetisations per spin are constant, which is 30 steps. For T=3 and T=5 the graphs do not converge because it is possible that these temperatures are higher than the Curie Temperature and as such spontaneous magnetisation will not occur and the system will not diverge to the lowest energy state. At the higher temperatures, there are larger thermal fluctations and the Boltzmann factor is more significant allowing the system to move away from the lowest energy state easier. As a result moving forwards, a suitable cut-off point will only be determined from T=1 and T=2 graphs for the larger matrices.

''Figure 8'' shows the results from running a 4x4 lattice at T=1,2 and 3.

{{multiple image
| width =350
| align = left
| image1 = cg14174x4T1.png
| image2 = cg14174x4T2.png
| image3 =cg14174x4T3.png
| footer_align = left
| footer = Figure 8 - Results of running the ILfinalframe.py file at T=1,2,3 for a 4x4 matrix.
}}

From ''Figure 8'', a suitable cut-off point for the energy and magnetisations is 200 as this is after where the energy and magnetisation has converged for T=1, and is after the initial large drop in energy for T=2, even though there are a few small fluctuations after 200 steps. The result from T=3 has been included to show the large fluctuations for the larger temperatures, and supporting my choice to determine the cut-off from T=1 and T=2 only.

''Figure 9'' shows the results for an 8x8 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg14178x8T1.png
| image2 = cg14178x8T2.png
| footer_align = left
| footer = Figure 9 - Results of running the ILfinalframe.py file at T=1,2 for an 8x8 matrix
}}

From ''Figure 9'' above, a suitable cut-off point is 1000 steps as this is where the energy and magnetisation has easily converged by and is also the point after which the initial large drop in energy has been overcome for T=2 too.

''Figure 10'' shows the result of running the ILfinalframe.py for a 16x16 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg141716x16T1.png
| image2 = cg141716x16T2.png
| footer_align = left
| footer = Figure 10 - Results of running the ILfinalframe.py file at T=1,2 for a 16x16 matrix
}}

From ''Figure 10'', a suitable cut-off point is 15000 steps as for T=1 the energy and magnetisations have converged significantly and will not change much, and likewise this is the same for the T=2 frame.

''Figure 11'' below shows the results from a 32x32 matrix at T=1 and T=2.

{{multiple image
| width =350
| align = left
| image1 = cg141732x32T1.png
| image2 = cg141732x32T2.png
| footer_align = left
| footer = Figure 11 - Results of running the ILfinalframe.py file at T=1,2 for a 32x32 matrix
}}

''Figure 11'' above shows the results of running the ILfinalframe.py file for a 32x32 matrix at T=1 and T=2. As a result a suitable cut-off of 50000 steps was chosen as the energy and magnetisation has significantly converged, but not as much as it could at 100000 steps. I chose a slightly lower value to ensure that the run times of my monte-carlo simulations in future tasks were not extremely time consuming.

The montecarlostep() function was changed by adding a condition that values only above the pre-determined cut-off were included when determining the average value of energy; energy squared; magnetisation and magnetisations squared from the statistics function. The statistics() function did not need to be modified.

The following code is from the 32x32 matrixː

<pre>def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back

if self.n_cycles > 50000: #only adds values to array of E,E2,M and M2 is above specific cut-off
self.E+=[self.energy()]
self.E2+=[self.energy()**2]
self.M+=[self.magnetisation()]
self.M2+=[self.magnetisation()**2]
self.n_cycles=self.n_cycles+1

return (self.energy(),self.magnetisation())
</pre>

===TASK: Use ILtemperaturerange.py to plot the average energy and magnetisation for each temperature, with error bars, for an <math>8\times 8</math> lattice. Use your intuition and results from the script ILfinalframe.py to estimate how many cycles each simulation should be. The temperature range 0.25 to 5.0 is sufficient. Use as many temperature points as you feel necessary to illustrate the trend, but do not use a temperature spacing larger than 0.5. The NumPy function savetxt() stores your array of output data on disk — you will need it later. Save the file as 8x8.dat so that you know which lattice size it came from.===

Using the modified code, the file ILtemperaturerange.py was ran on an 8x8 matrix between T=0.5 and T=5 with a step of T=0.02 for 10000 Montecarlo steps and the first 1000 steps of each temperature were excluded when calculating the averages. ''Figure 12'' shows the result of the simulation and also included error bars of standard deviation.

[[File:Cg14178x8error.png|1000px|thumb|left|Figure 12 - Graph showing average energy and average magnetisation for an 8x8 lattice with error bars between T=0.5 and T=5]]

 

Below is the source code for the script to produce the graphː

<pre>data8x8=np.loadtxt('8x8.dat') #loads data
temps8x8=data8x8[:,0] #stores temperatures
energies8x8=data8x8[:,1] #stores average energy for each T
energysq8x8=data8x8[:,2] #stores average energy squared for each T
mag8x8=data8x8[:,3] #stores magnetisation for each T
magsq8x8=data8x8[:,4] #stores magnetisation squared for each T
stde8x8=data8x8[:,5] #edited ILtemperaturerange.py to record the standard deviation of the energy for each T
stdm8x8=data8x8[:,6] #edited ILtemperaturerange.py to record the standard deviation of the magnetisation for each T

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.errorbar(temps8x8, np.array(energies8x8)/64,yerr=np.divide(stde8x8,64),color='black',ecolor='teal',alpha=0.8) #plots energy per spin against T
magax.errorbar(temps8x8, np.array(mag8x8)/64,yerr=np.divide(stdm8x8,64),alpha=0.8,ecolor='salmon',color='black') #plots magnetisation per spin against T on separate graph
pl.savefig('8x8error.png',bbox_inches='tight') #saves figure
pl.show()

</pre>

==Section 6 - The effect of system size==

===TASK: Repeat the final task of the previous section for the following lattice sizes: 2x2, 4x4, 8x8, 16x16, 32x32. Make sure that you name each datafile that your produce after the corresponding lattice size! Write a Python script to make a plot showing the energy per spin versus temperature for each of your lattice sizes. Hint: the NumPy loadtxt function is the reverse of the savetxt function, and can be used to read your previously saved files into the script. Repeat this for the magnetisation. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. How big a lattice do you think is big enough to capture the long range fluctuations?===

The python script for this section is identical as for the 8x8 graph above in Figure 12 with the relevant files and variables changed accordingly.

Each matrix was simulated using the ILtemperaturerange.py file between T=0.5 and T=5 with a step of T=0.02.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2error.png
| caption1 = 2x2 matrix - 5000 steps, cut-off = 30 steps
| image2 = 4x4error.png
| caption2 = 4x4 matrix - 1000 steps, cut-off = 200 steps
| image3 =cg141716x16error.png
| caption3 = 16x16 matrix - 50000 steps, cut-off = 15000 steps
| image4 =cg141732x32error.png
| caption4 = 32x32 matrix - 200000 steps, cut-off = 50000 steps
| footer_align = left
| footer = Figure 13 - Results of running the ILtemperaturerange.py file for 2x2, 4x4, 16x16 and 32x32 matrices.
}}

 

==Section 7 - Determining the Heat Capacity==

===TASK: By definition, <math>C = \frac{\partial \left\langle E\right\rangle}{\partial T}</math>. From this, show that <math>C = \frac{\mathrm{Var}[E]}{k_B T^2}</math> (Where <math>\mathrm{Var}[E]</math> is the variance in <math>E</math>.)===

Recall from statistical thermodynamics that the average energy of a system is the sum across all microstates of the probability of that microstate multiplied by the energy of that microstate, which is defined mathematically asː <math>\langle E \rangle = \sum_i p_{i}\epsilon_{i}</math>.

The partition function <math>q</math> is defined as <math>q = \sum_{i} exp(-\beta \epsilon_{i})</math> where <math>\beta =\frac{1}{k_BT}</math>and the probability, <math>p_{i}</math> can be defined in terms of the partition function as <math>p_{i} = \frac{exp(-\beta \epsilon_{i})}{\sum_{i} exp(-\beta \epsilon_{i})} = \frac{exp(-\beta \epsilon_{i})}{q}</math>.

As a result, <math>\langle E \rangle</math> can be re-written as <math>\langle E \rangle = \sum_{i} \frac{\epsilon_{i} exp(-\beta \epsilon_{i})}{q} = -\frac{1}{q} \frac{\partial}{\partial \beta}\sum_{i}exp(-\beta \epsilon_{i}) = -\frac{1}{q} \frac{\partial q}{\partial \beta}</math>

Likewise, <math>\langle E^2 \rangle = \sum_i p_{i}\epsilon_{i}^{2} = \sum_{i} \frac{\epsilon_{i}^{2}exp(-\beta \epsilon_{i})}{q} = \frac{1}{q} \frac{\partial^{2}}{\partial \beta^{2}}\sum_{i}exp(-\beta \epsilon_{i}) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}}</math>

From definitionː <math>Var[E] = \Delta E^2 = \langle E^2 \rangle - \langle E \rangle^2 </math>

When the definition of <math>\langle E \rangle</math> and <math>\langle E^2 \rangle</math> is written in terms of partition function <math>q</math>ː <math>Var[E] = \langle E^2 \rangle - \langle E \rangle^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \left(\frac{1}{q}\frac{\partial q}{\partial \beta}\right)^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2</math>.

According to the chain ruleː <math>\frac{\partial}{\partial \beta}\left(\frac{1}{q} \frac{\partial q}{\partial \beta}\right) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2 = -\frac{\partial}{\partial \beta}\langle E \rangle = Var[E]</math>

And using the chain rule againː <math>C = \frac{\partial \langle E \rangle}{\partial T}= \left(-\frac{\partial \langle E \rangle}{\partial \beta}\right) \left(-\frac{\partial \beta}{\partial T}\right) = \frac{Var[E]}{k_B T^2}</math>

===TASK: Write a Python script to make a plot showing the heat capacity versus temperature for each of your lattice sizes from the previous section. You may need to do some research to recall the connection between the variance of a variable, <math>\mathrm{Var}[X]</math>, the mean of its square <math>\left\langle X^2\right\rangle</math>, and its squared mean <math>\left\langle X\right\rangle^2</math>. You may find that the data around the peak is very noisy — this is normal, and is a result of being in the critical region. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. ===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb

{{multiple image
| width =300
| align = left
| image1 = cg14172x2heatcap.png
| caption1 = 2x2 Matrix
| image2 = cg14174x4heatcap.png
| caption2 = 4x4 Matrix
| image3 =cg14178x8heatcap.png
| caption3 = 8x8 Matrix
| image4 =cg141716x16heatcap.png
| caption4 = 16x16 Matrix
| image5=cg141732x32heatcap.png
| caption5= 32x32 Matrix
| footer = Figure 13 - Graphs showing Heat Capacity against Temperature for each matrix size
}}

Here is the source code to produce the figuresː
<pre> def heatCap(energies,energysq,T,latsize):
#defines the heat capacity for a given temperature
energiesq=np.multiply(energies,energies) #creates array of (average energies) squared
varE=np.subtract(energysq,energiesq) #defines variance of average energy
tempsq=np.multiply(T,T) #array of temperature squared
return np.array(np.divide(varE,tempsq))/(latsize**2)

heatCap2x2=heatCap(energies2x2,energysq2x2,temps2x2,2) #creates array of heat capacity for each T

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(temps2x2,heatCap2x2,color='orange') #plots heat capacity for each T
pl.savefig('cg14172x2heatcap.png',bbox_inches='tight') #saves figure
pl.show()
</pre>

A general trend from the above graphs is that the peak of the graph shifts towards lower temperatures as the size of the matrix used increases.

==Section 8 - Locating the Curie Temperature==
===TASK: A C++ program has been used to run some much longer simulations than would be possible on the college computers in Python. You can view its source code here if you are interested. Each file contains six columns: <math>T, E, E^2, M, M^2, C</math> (the final five quantities are per spin), and you can read them with the NumPy loadtxt function as before. For each lattice size, plot the C++ data against your data. For one lattice size, save a PNG of this comparison and add it to your report — add a legend to the graph to label which is which. To do this, you will need to pass the label="..." keyword to the plot function, then call the legend() function of the axis object (documentation here).===

The python code used to read and plot the C++ data is found in the Jupyter notebook CG1417IsingModelGraphs.ipynb.

''Figure 14'' below shows the C++ plotted against my own data for a 16x16 Matrix.

[[File:Cg141716x16C++.png|400px|thumb|left|Figure 14 - Graph showing my own data against the C++ data for a 16x16 matrix.]]

 

Here is the source code the produce the figuresː
<pre>#fitting C++ data

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.plot(temps2x2, np.array(energies2x2)/4,color='black',alpha=0.7,label='Python Data') #python energy against T
enerax.plot(temps2x2C, energies2x2C, color='red',label='C++ Data') #C energy against T
magax.plot(temps2x2, np.array(mag2x2)/4,color='black',alpha=0.7,label='Python Data') #python magnetisation against T
magax.plot(temps2x2C, mag2x2C,color='red',label='C++ Data') #C energy against T
enerax.legend() #shows legend on energy graph
magax.legend() #shows legend on energy graph
pl.show()
</pre>

The relevant variables and dat files were changed for each matrix.

===TASK: write a script to read the data from a particular file, and plot C vs T, as well as a fitted polynomial. Try changing the degree of the polynomial to improve the fit — in general, it might be difficult to get a good fit! Attach a PNG of an example fit to your report.===

The python script to read and plot the fitted polynomial is found in CG1417PolyfitScript.ipynb

Here is the source code for ''Figure 15''

<pre>data_test = np.loadtxt("16x16C.dat")
T_test = data_test[:,0] #gets temperatures
C_test = data_test[:,5] #gets heat capacity data

#first we fit the polynomial to the data
fit_test = np.polyfit(T_test, C_test, 35) # fit a polynomial

#now we generate interpolated values of the fitted polynomial over the range of our function
T_min_test = 0.5 #np.min(T_test)
T_max_test = 5 #np.max(T_test)

T_range_test = np.linspace(T_min_test, T_max_test, 1000) #generate 1000 evenly spaced points between T_min and T_max
fitted_C_values_test = np.polyval(fit_test, T_range_test)# use the fit object to generate the corresponding values of C

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(T_test,C_test,color='orange',label='C++ Data') #plots C data of heat capacity against temp
heatcapax.plot(T_range_test,fitted_C_values_test,label='Fitted Polynomial') #plots fitted polynomial for whole range of temp
heatcapax.legend()
pl.savefig('FIT_TEST16x16_35.png', bbox_inches='tight') #saves figure
pl.show()
</pre>

Below in ''Figure 15'' is a plot of my Heat Capacity against Temperature data for a 16x16 matrix and features a polynomial of degree 35 plotted against it. Even with a polynomial of such a high degree, it poorly fits the curve and does not fit to the peak of the curve either.

[[File:cg1417FIT_TEST16x16_35.png|thumb|left|400px|Figure 15 - Plot of Heat Capacity against Temperature along with a poorly fitted polynomial of degree 35. ]]

 

===TASK: Modify your script from the previous section. You should still plot the whole temperature range, but fit the polynomial only to the peak of the heat capacity! You should find it easier to get a good fit when restricted to this region===

The script was modified as such that the polynomial was fitted in a set range around the peak of the graph, this is demonstrated in ''Figure 17'' which shows a newly fitted polynomial between a much smaller range of temperatures (T = 2.15-2.55) and a much smaller degree polynomial (3).

[[File:CG1417FIT_16x16C_3.png|thumb|left|400px|Figure 16 - Graph showing Heat Capacity against Temperature for a 16x16 matrix along with a fitted polynomial between a much more restricted range of temperatures and a significantly lower degree of polynomial]]

Upon comparison with ''Figure 15'', the new fitted polynomial is a significantly better fit even for a 3rd degree polynomial and is a much more accurate representation of my data around the peak of the graph and will make it easier to determine the maximum value of Heat Capacity.

 

Here is the source code for ''Figure 16''ː
<pre>data16 = np.loadtxt("16x16C.dat") #loads data to variable

T16 = data16[:,0] #gets temps
C16 = data16[:,5] # gets heat capacities

Tmin16 = 2.15 #chosen min temp
Tmax16 = 2.55 #chosen max temp

selection16 = np.logical_and(T16 > Tmin16, T16 < Tmax16) #choose only those rows where both conditions are true
peak_T_values16 = T16[selection16] #choose temp values in range chosen above
peak_C_values16 = C16[selection16] #choose heat cap values in range of t above

fit16 = np.polyfit(peak_T_values16,peak_C_values16,3) #fit 3rd order polynomial
peak_T_range16 = np.linspace(Tmin16, Tmax16, 1000) #defines 1000 temps within data range
fitted_C_values16 = np.polyval(fit16, peak_T_range16) #use the fit object to get corresponding values of heat cap

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(T16,C16,color='orange',label='C++ Data') #plots C data of heat cap against temp
heatcapax.plot(peak_T_range16,fitted_C_values16,label='Fitted Polynomial') #plots fitted polynomial for small range
heatcapax.legend()
pl.savefig('FIT_16x16C_3.png', bbox_inches='tight') #saves figure
pl.show()

</pre>

===TASK: find the temperature at which the maximum in C occurs for each datafile that you were given. Make a text file containing two colums: the lattice side length (2,4,8, etc.), and the temperature at which C is a maximum. This is your estimate of <math>T_C</math> for that side length. Make a plot that uses the scaling relation given above to determine <math>T_{C,\infty}</math>. By doing a little research online, you should be able to find the theoretical exact Curie temperature for the infinite 2D Ising lattice. How does your value compare to this? Are you surprised by how good/bad the agreement is? Attach a PNG of this final graph to your report, and discuss briefly what you think the major sources of error are in your estimate.===

''Figure 17'' below shows a graph of <math>T_{C,L}</math> against <math>\frac{1}{Lattice Size}</math> to determine the Curie Temperature of an infinite 2D Ising Model Lattice <math>T_{C,\infty}</math>. The black dots represent the raw data obtained from obtaining the temperature at which the Heat Capacity was a maximum for the lattices and the red line in a linear curve fit plotted against the data to allow the y-intercept which is the Curie Temperature for the infinite 2D lattice to be determined.

[[File:cg1417CurieTemp.png|400px|thumb|left|Figure 17 - Plot of 1/Lattice Size against Curie Temperature for that lattice size.]]

The value for <math>T_{C,\inf}</math> obtained from the data is <math>T_{C,\infty} = 2.277 \frac{J}{k_B}</math> with a literature value being <math>T_{C,\infty} = 2.269 \frac{J}{k_B}</math> <ref>L. Onsager, Phys. Rev., 1944, 65, 117--149.</ref>for an infinite square 2D lattice. This means that my result slightly over-estimates the Curie Temperature for the infinite lattice and as a result for an infinite lattice the temperature at which spontaneous magnetisation stops would actually occur at a slightly lower temperature than expected. However, the difference between my value and the literature value is only 0.008 which is incredibly small and the amount of agreement between the two values is somewhat surprising, which means that the error in my estimates of the Curie Temperature for each lattice size is relatively small. The points which have the largest residuals and deviation from the line of best fit in ''Figure 17'' corresponds to the smaller lattice sizes of 2x2 and 4x4 where longer range interactions are more significant. The longer range interactions posed by the boundary conditions are nowhere near as significant for the larger sizes and causes the energy of the smaller matrices to be less accurate and have a larger associated error with the energy and thus the Curie Temperature for that lattice size. This affects the accuracy of the line of best fit and to increase the accuracy of this line, larger lattice sizes of 128x128, 256x256 etc should be included in the calculation for the line of best fit and the smaller matrices ignored.

 

Below is the source code used to generate ''Figure 17''
<pre>
Cmax64x64 = np.max(fitted_C_values64) #finds Cmax for 64x64 matrix - done for others already
Tmax64x64 = peak_T_range64[fitted_C_values64 == Cmax64x64] #finds Tmax corresponding to Cmax

LatSize=[2,4,8,16,32,64] #stores lattice sizes
Tmax=[Tmax2x2,Tmax4x4,Tmax8x8,Tmax16x16,Tmax32x32,Tmax64x64] #stores corresponding Tmax data
np.savetxt('CmaxVSTmax.txt', (LatSize,Tmax)) #writes data to txt file

ScalData=np.loadtxt('CmaxVSTmax.txt') #loads data
LatticeSize=ScalData[0] #gets lattice sizes
TempMax=ScalData[1] #gets max temp or curie temp for each lattice

Lmin1min = np.min(np.divide(1,LatticeSize)) #minimum of 1/LatticeSize values
Lmin1max = np.max(np.divide(1,LatticeSize)) #maximum of 1/LatticeSize values

fitTcl = np.polyfit(np.divide(1,LatticeSize),TempMax, 1) #creates fit object

Lmin1values = np.linspace(Lmin1min, Lmin1max, 1000) #finds 1000 values between min and max x-axis value of 1/LatticeSize
fitted_Tcl_values = np.polyval(fitTcl, Lmin1values) #creates corresponding Curie Temp values for each value in Lmin1values

fig = pl.figure()
scalrelax = fig.add_subplot(1,1,1)
scalrelax.set_xlabel('1/Lattice Size')
scalrelax.set_ylabel('Curie Temperature/ J/k_B')
scalrelax.plot(np.divide(1,LatticeSize),TempMax,color='black',marker='.',linestyle='') #plots Curie Temp against 1/LatticeSize
scalrelax.plot(Lmin1values,fitted_Tcl_values,color='red',marker='',linestyle='-') #plots line of best fit for data above
pl.savefig('CurieTemp.png', bbox_inches='tight') #saves figure
pl.show()

</pre>

== References ==

Rep:Y3CMPCG1417

2019-11-20T10:13:12Z

Cg1417: /* Section 5 - The effect of temperature */

==Section 1 - Introduction to the Ising Model==

===TASK: Show that the lowest possible energy for the Ising model is <math>E = -DNJ</math>, where D is the number of dimensions and N is the total number of spins. What is the multiplicity of this state? Calculate its entropy.===

Consider a 1D row of lattice sites of N=3 with spin configuration [+1][+1][+1].

Mathematically the interaction energy is defined asː
<math> -\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} </math> where J is a constant and <math>s_{i}s_{j}</math> is the product between two spins in adjacent lattice sites.

The sum of the interaction energies <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j}</math> can be considered as the sum of the individual interaction energies between spinsː
<math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = \epsilon_{12} + \epsilon_{23} + \epsilon_{13} + \epsilon_{21} + \epsilon_{32} + \epsilon_{31} </math>.

Although lattice sites 1 and 3 are not adjacent they are said to still interact according to the periodic boundary conditions applied.

However, <math>\epsilon_{12} = \epsilon_{21} </math> and <math>\epsilon_{23} = \epsilon_{32}</math> and <math>\epsilon_{13} = \epsilon_{31}</math> which means that all of the interactions within the system are counted twice, hence the total energy needs to be halved, resulting in the following formula being obtainedː <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = 2\epsilon_{12} + 2\epsilon_{13} + 2\epsilon_{23} </math>.

It can be determined that <math>\epsilon_{12} = (+1)(+1) = 1</math> , <math>\epsilon_{13} = (+1)(+1) = 1</math> and <math>\epsilon_{23} = (+1)(+1) = 1</math>.

Thereforeː <math>-\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = -\frac{1}{2} \ J \ (2 + 2 + 2) = -\frac{1}{2} \ J \ 6 = - 3 J = -DNJ</math> for a 1D lattice with <math>D=1</math> and 3 lattice sites <math>N=3</math>

The multiplicity of the system,<math>\Omega = \frac{lattice sites!}{n. spin up!n. spin down!}</math>

Entropy, <math>S</math> is defined as <math>S = k_B ln(\Omega)</math> and so in this case <math>S = k_B ln(\frac{100!}{100!}) = 0</math>

===TASK: Imagine that the system is in the lowest energy configuration. To move to a different state, one of the spins must spontaneously change direction ("flip"). What is the change in energy if this happens <math>(D=3, N=1000)</math>? How much entropy does the system gain by doing soʔ===

In a 3D lattice system, each lattice site has three unique interactions with its neighbours to its left, top and front. In the lowest energy configuration, all spins are parallel and for a system the minimum energy is <math>E = -DNJ</math>, so for the system with <math>N=1000</math> and <math>D=3</math>, the minimum energy is <math>-3000J</math>.

If a single spin is flipped, the product of its spin with its neighbours spin reverses and becomes negative and this increases the total energy of the system. Since 3 unique spin-spin interactions are reversed in sign, the total energy increases by <math>+3J</math>, meaning the new total energy is <math>-2997J</math>

Initially the multiplicity of the system will be <math>\Omega = \frac{1000!}{1000!}</math> , and after the flip, the multiplicity becomes <math> \Omega = \frac{1000!}{999!1!}=1000</math>.

The associated change in entropy, <math>\Delta S = k_B ln(1000) - 0 = 6.91 k_B</math>, which is an expected increase in entropy as the number of possible configurations of the system increases.

===TASK: Calculate the magnetisation of the 1D and 2D lattices in Figure 1. What magnetisation would you expect to observe for an Ising lattice with <math>D = 3,\ N=1000</math> at absolute zero?===

[[File:ThirdYearCMPExpt-IsingSketch.png|thumb|left|Figure 1 - Shows 1D (N = 5), 2D (N = 5x5) and 3D (N = 5x5x5) lattices.]]

Magnetisation is defined as <math>M=\sum_{i} s_i</math>. So for the 1D lattice with <math>N = 5</math> in ''Figure 2'', <math>M = +1</math> and for the 2D lattice with <math>N = 25 , M = +1</math> too.

According to the 3rd Law of thermodynamics, entropy is 0 at absolute zero for a perfect crystalline solid, and consequently it is expected that the lattices will have follow suit and have zero entropy at 0K. To have zero entropy all spins must be parallel as such that magnetisation, <math>M = N</math>. For all the spins to be parallel, there is only one possible configuration. So, for a lattice with <math>N = 1000</math> and <math>D =3</math>, if <math>M = N</math>, then multiplicity, <math>\Omega = 1</math> and entropy, <math>S =k_B ln(1) = 0</math>.

 

==Section 2 - Calculating the Energy and Magnetisation==

===TASK: complete the functions energy() and magnetisation(), which should return the energy of the lattice and the total magnetisation, respectively. In the energy() function you may assume that <math>J=1.0</math> at all times (in fact, we are working in reduced units in which <math>J=k_B</math>, but there will be more information about this in later sections). Do not worry about the efficiency of the code at the moment — we will address the speed in a later part of the experiment.===

<pre>def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
lat=self.lattice #creates lattice and stores it
mag=[]
for i in range(0,len(lat)): #loops through all rows of lattice
for j in range(0,len(lat[i])): #loops through elements of each row
mag+=[lat[i][j]] #adds spin value to mag array
return sum(mag) #sums all spins from mag array
</pre>

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

lat=self.lattice #creates lattice and stores it
left=[]
top=[]

for i in range(0,len(lat)):
for j in range(0,len(lat[i])):
left+=[lat[i][j]*lat[i][j-1]] #multiplies spin by spin to left
top+=[lat[i][j]*lat[i-1][j]] #multiplies spin by spin above it
int_en=left+top #sums spin products from left and top
energy=-sum(int_en) #sums all spin products for each spin to give total

return energy
</pre>

===TASK: Run the ILcheck.py script from the IPython Qt console using the command===

''Figure 2'' shows the results when ILcheck.py was ran on my IsingLattice.py file. The ILcheck.py file was ran several times to ensure the code worked for various random lattices.

[[File:Cg1417ILcheck run.png|thumb|left|500px| Figure 2 - Result from running the ILcheck.py file]]

 

==Section 3 - Introduction to Monte Carlo Simulation==

===TASK: How many configurations are available to a system with 100 spins? To evaluate these expressions, we have to calculate the energy and magnetisation for each of these configurations, then perform the sum. Let's be very, very, generous, and say that we can analyse <math>1\times 10^9</math> configurations per second with our computer. How long will it take to evaluate a single value of <math>\left\langle M\right\rangle_T</math>?===

For a system with 100 lattice sites and two possible spins for each site, there are <math>2^{100}</math>possible configurations for the system. <math>2^{100}= 1.27\times 10^{30} </math>, so if the computer can analyse <math>1\times 10^9</math> configurations per second, then it will take <math>\frac{1.27\times 10^{30}}{10^9} = 1.27\times 10^{21} s</math> to analyse the whole system, which is longer than the age of the universe and therefore is not a practical approach.

===TASK: Implement a single cycle of the above algorithm in the montecarlocycle(T) function. This function should return the energy of your lattice and the magnetisation at the end of the cycle. You may assume that the energy returned by your energy() function is in units of <math>k_B</math>! Complete the statistics() function. This should return the following quantities whenever it is called: <math><E>, <E^2>, <M>, <M^2></math>, and the number of Monte Carlo steps that have elapsed.===
<pre>
E = []
E2 = []
M = []
M2 = []
n_cycles = 0

def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back if rejected else not changed

self.E+=[self.energy()] #records energy
self.E2+=[self.energy()**2] #records energy squared
self.M+=[self.magnetisation()] #records magnetisation
self.M2+=[self.magnetisation()**2] #records magnetisation squared
self.n_cycles=self.n_cycles+1 #adds 1 to run total

return (self.energy(),self.magnetisation())

def statistics(self):
# complete this function so that it calculates the correct values for the averages of E, E*E (E2), M, M*M (M2), and returns them

e=np.mean(self.E)
e2=np.mean(self.E2)
m=np.mean(self.M)
m2=np.mean(self.M2)

return e,e2,m,m2,self.n_cycles
</pre>

''Figure 3'' shows the results of a single run of the montecarlostep() function and the lattice the function operated upon.

[[File:cg1417MonteCarloStep_run.png|thumb|left|Figure 3 - Results from a single montecarlostep() function and the resulting lattice produced along with the correct return from the statistics() function]]

 

===TASK: If <math>T < T_C</math>, do you expect a spontaneous magnetisation (i.e. do you expect <math>\left\langle M\right\rangle \neq 0</math>)? When the state of the simulation appears to stop changing (when you have reached an equilibrium state), use the controls to export the output to PNG and attach this to your report. You should also include the output from your statistics() function.===

If the temperature of the system is less than the Curie Temperature, <math>T_C</math> then spontaneous magnetisation can occur and the system will tend to its lowest energy state where all of the spins are parallel - this is a property of ferromagnetic materials.

[[File:Cg1417ILanim_run.png|400px|thumb|left|Figure 4 - Results from running the ILanim.py file - shows the energy and magnetisation converging over time]]

''Figure 4'' shows that over time the the system spontaneously converges to the minimum energy state with all of the spins parallel to one another and shows, as I expected, that spontaneous magnetisation occurs and also shows that the temperature of this simulation is below the Curie Temperature, <math>T < T_C</math>.

 

==Section 4 - Accelerating the Code==

===TASK: Use the script ILtimetrial.py to record how long your current version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 5'' show the results of running the ILtimetrial.py file on my code three timesː

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1.png
| width1=500
| image2=cg1417ILtimetrial_run2.png
| width2=500
| image3=cg1417ILtimetrial_run3.png
| width3=500
| footer = Figure 5 - Results of running the ILtimetrial.py file on my code three separate times
}}
 

This gave me an avergage time of <math>24.3 s \pm 0.2s</math>

===TASK: Look at the documentation for the NumPy sum function. You should be able to modify your magnetisation() function so that it uses this to evaluate M. The energy is a little trickier. Familiarise yourself with the NumPy roll and multiply functions, and use these to replace your energy double loop (you will need to call roll and multiply twice!).===

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

left=multiply(roll(self.lattice,1,axis=1),self.lattice) #product of spin with spin left of it
top=multiply(roll(self.lattice,-1,axis=0),self.lattice) #product of spin with spin above it

int_en=sum(left+top) #sum of array containing sum of left and top spin products for each spin

energy = -sum(int_en) #calculates the total energy of system
return energy

def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
return sum(sum(self.lattice)) #adds up all spins in lattice
</pre>

===TASK: Use the script ILtimetrial.py to record how long your new version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 6'' shows the result of running the ILtimetrial.py on my new accelerated code.

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1fast.png
| width1=500
| image2=ILtimetrial_run2fast.png
| width2=500
| image3=ILtimetrial_run3fast.png
| width3=500
| footer = Figure 6 - Results of running the ILtimetrial.py file on my new updated and accelerated code.
}}
 

The accelerated code is much faster upon using the roll, multiply and sum modules with a new average time of <math>0.790 s \pm 0.005 </math>

==Section 5 - The effect of temperature==

===TASK: The script ILfinalframe.py runs for a given number of cycles at a given temperature, then plots a depiction of the final lattice state as well as graphs of the energy and magnetisation as a function of cycle number. This is much quicker than animating every frame! Experiment with different temperature and lattice sizes. How many cycles are typically needed for the system to go from its random starting position to the equilibrium state? Modify your statistics() and montecarlostep() functions so that the first N cycles of the simulation are ignored when calculating the averages. You should state in your report what period you chose to ignore, and include graphs from ILfinalframe.py to illustrate your motivation in choosing this figure.===

''Figure 7'' below shows the results from running the ILfinalframe.py for 2x2 lattice at T=1,2,3,5.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2T1.png
| image2 = cg14172x2T2.png
| image3 =cg14172x2T3.png
| image4 =cg14172x2T5.png
| footer_align = left
| footer = Figure 7 - Results of running the ILfinalframe.py file at T=1,2,3,5 for a 2x2 matrix.
}}

 

For a 2x2 matrix, a suitable cut-off point to exclude from the avergage energies and magnetisations is where the energy and magnetisations per spin are constant, which is 30 steps. For T=3 and T=5 the graphs do not converge because it is possible that these temperatures are higher than the Curie Temperature and as such spontaneous magnetisation will not occur and the system will not diverge to the lowest energy state. At the higher temperatures, there are larger thermal fluctations and the Boltzmann factor is more significant allowing the system to move away from the lowest energy state easier. As a result moving forwards, a suitable cut-off point will only be determined from T=1 and T=2 graphs for the larger matrices.

''Figure 8'' shows the results from running a 4x4 lattice at T=1,2 and 3.

{{multiple image
| width =350
| align = left
| image1 = cg14174x4T1.png
| image2 = cg14174x4T2.png
| image3 =cg14174x4T3.png
| footer_align = left
| footer = Figure 8 - Results of running the ILfinalframe.py file at T=1,2,3 for a 4x4 matrix.
}}

From ''Figure 8'', a suitable cut-off point for the energy and magnetisations is 200 as this is after where the energy and magnetisation has converged for T=1, and is after the initial large drop in energy for T=2, even though there are a few small fluctuations after 200 steps. The result from T=3 has been included to show the large fluctuations for the larger temperatures, and supporting my choice to determine the cut-off from T=1 and T=2 only.

''Figure 9'' shows the results for an 8x8 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg14178x8T1.png
| image2 = cg14178x8T2.png
| footer_align = left
| footer = Figure 9 - Results of running the ILfinalframe.py file at T=1,2 for an 8x8 matrix
}}

From ''Figure 9'' above, a suitable cut-off point is 1000 steps as this is where the energy and magnetisation has easily converged by and is also the point after which the initial large drop in energy has been overcome for T=2 too.

''Figure 10'' shows the result of running the ILfinalframe.py for a 16x16 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg141716x16T1.png
| image2 = cg141716x16T2.png
| footer_align = left
| footer = Figure 10 - Results of running the ILfinalframe.py file at T=1,2 for a 16x16 matrix
}}

From ''Figure 10'', a suitable cut-off point is 15000 steps as for T=1 the energy and magnetisations have converged significantly and will not change much, and likewise this is the same for the T=2 frame.

''Figure 11'' below shows the results from a 32x32 matrix at T=1 and T=2.

{{multiple image
| width =350
| align = left
| image1 = cg141732x32T1.png
| image2 = cg141732x32T2.png
| footer_align = left
| footer = Figure 11 - Results of running the ILfinalframe.py file at T=1,2 for a 32x32 matrix
}}

''Figure 11'' above shows the results of running the ILfinalframe.py file for a 32x32 matrix at T=1 and T=2. As a result a suitable cut-off of 50000 steps was chosen as the energy and magnetisation has significantly converged, but not as much as it could at 100000 steps. I chose a slightly lower value to ensure that the run times of my monte-carlo simulations in future tasks were not extremely time consuming.

The montecarlostep() function was changed by adding a condition that values only above the pre-determined cut-off were included when determining the average value of energy; energy squared; magnetisation and magnetisations squared from the statistics function. The statistics() function did not need to be modified.

The following code is from the 32x32 matrixː

<pre>def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back

if self.n_cycles > 50000: #only adds values to array of E,E2,M and M2 is above specific cut-off
self.E+=[self.energy()]
self.E2+=[self.energy()**2]
self.M+=[self.magnetisation()]
self.M2+=[self.magnetisation()**2]
self.n_cycles=self.n_cycles+1

return (self.energy(),self.magnetisation())
</pre>

===TASK: Use ILtemperaturerange.py to plot the average energy and magnetisation for each temperature, with error bars, for an <math>8\times 8</math> lattice. Use your intuition and results from the script ILfinalframe.py to estimate how many cycles each simulation should be. The temperature range 0.25 to 5.0 is sufficient. Use as many temperature points as you feel necessary to illustrate the trend, but do not use a temperature spacing larger than 0.5. The NumPy function savetxt() stores your array of output data on disk — you will need it later. Save the file as 8x8.dat so that you know which lattice size it came from.===

Using the modified code, the file ILtemperaturerange.py was ran on an 8x8 matrix between T=0.5 and T=5 with a step of T=0.02 for 10000 Montecarlo steps and the first 1000 steps of each temperature were excluded when calculating the averages. ''Figure 12'' shows the result of the simulation and also included error bars of standard deviation.

[[File:Cg14178x8error.png|1000px|thumb|left|Figure 12 - Graph showing average energy and average magnetisation for an 8x8 lattice with error bars between T=0.5 and T=5]]

 

Below is the source code for the script to produce the graphː

<pre>data8x8=np.loadtxt('8x8.dat') #loads data
temps8x8=data8x8[:,0] #stores temperatures
energies8x8=data8x8[:,1] #stores average energy for each T
energysq8x8=data8x8[:,2] #stores average energy squared for each T
mag8x8=data8x8[:,3] #stores magnetisation for each T
magsq8x8=data8x8[:,4] #stores magnetisation squared for each T
stde8x8=data8x8[:,5] #edited ILtemperaturerange.py to record the standard deviation of the energy for each T
stdm8x8=data8x8[:,6] #edited ILtemperaturerange.py to record the standard deviation of the magnetisation for each T

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.errorbar(temps8x8, np.array(energies8x8)/64,yerr=np.divide(stde8x8,64),color='black',ecolor='teal',alpha=0.8) #plots energy per spin against T
magax.errorbar(temps8x8, np.array(mag8x8)/64,yerr=np.divide(stdm8x8,64),alpha=0.8,ecolor='salmon',color='black') #plots magnetisation per spin against T on separate graph
pl.savefig('8x8error.png',bbox_inches='tight') #saves figure
pl.show()

</pre>

==Section 6 - The effect of system size==

===TASK: Repeat the final task of the previous section for the following lattice sizes: 2x2, 4x4, 8x8, 16x16, 32x32. Make sure that you name each datafile that your produce after the corresponding lattice size! Write a Python script to make a plot showing the energy per spin versus temperature for each of your lattice sizes. Hint: the NumPy loadtxt function is the reverse of the savetxt function, and can be used to read your previously saved files into the script. Repeat this for the magnetisation. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. How big a lattice do you think is big enough to capture the long range fluctuations?===

The python script for this section is identical as for the 8x8 graph above in Figure 11 with the relevant files and variables changed accordingly.

Each matrix was simulated using the ILtemperaturerange.py file between T=0.5 and T=5 with a step of T=0.02.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2error.png
| caption1 = 2x2 matrix - 5000 steps, cut-off = 30 steps
| image2 = 4x4error.png
| caption2 = 4x4 matrix - 1000 steps, cut-off = 200 steps
| image3 =cg141716x16error.png
| caption3 = 16x16 matrix - 50000 steps, cut-off = 15000 steps
| image4 =cg141732x32error.png
| caption4 = 32x32 matrix - 200000 steps, cut-off = 50000 steps
| footer_align = left
| footer = Figure 12 - Results of running the ILtemperaturerange.py file for 2x2, 4x4, 16x16 and 32x32 matrices.
}}

 

==Section 7 - Determining the Heat Capacity==

===TASK: By definition, <math>C = \frac{\partial \left\langle E\right\rangle}{\partial T}</math>. From this, show that <math>C = \frac{\mathrm{Var}[E]}{k_B T^2}</math> (Where <math>\mathrm{Var}[E]</math> is the variance in <math>E</math>.)===

Recall from statistical thermodynamics that the average energy of a system is the sum across all microstates of the probability of that microstate multiplied by the energy of that microstate, which is defined mathematically asː <math>\langle E \rangle = \sum_i p_{i}\epsilon_{i}</math>.

The partition function <math>q</math> is defined as <math>q = \sum_{i} exp(-\beta \epsilon_{i})</math> where <math>\beta =\frac{1}{k_BT}</math>and the probability, <math>p_{i}</math> can be defined in terms of the partition function as <math>p_{i} = \frac{exp(-\beta \epsilon_{i})}{\sum_{i} exp(-\beta \epsilon_{i})} = \frac{exp(-\beta \epsilon_{i})}{q}</math>.

As a result, <math>\langle E \rangle</math> can be re-written as <math>\langle E \rangle = \sum_{i} \frac{\epsilon_{i} exp(-\beta \epsilon_{i})}{q} = -\frac{1}{q} \frac{\partial}{\partial \beta}\sum_{i}exp(-\beta \epsilon_{i}) = -\frac{1}{q} \frac{\partial q}{\partial \beta}</math>

Likewise, <math>\langle E^2 \rangle = \sum_i p_{i}\epsilon_{i}^{2} = \sum_{i} \frac{\epsilon_{i}^{2}exp(-\beta \epsilon_{i})}{q} = \frac{1}{q} \frac{\partial^{2}}{\partial \beta^{2}}\sum_{i}exp(-\beta \epsilon_{i}) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}}</math>

From definitionː <math>Var[E] = \Delta E^2 = \langle E^2 \rangle - \langle E \rangle^2 </math>

When the definition of <math>\langle E \rangle</math> and <math>\langle E^2 \rangle</math> is written in terms of partition function <math>q</math>ː <math>Var[E] = \langle E^2 \rangle - \langle E \rangle^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \left(\frac{1}{q}\frac{\partial q}{\partial \beta}\right)^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2</math>.

According to the chain ruleː <math>\frac{\partial}{\partial \beta}\left(\frac{1}{q} \frac{\partial q}{\partial \beta}\right) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2 = -\frac{\partial}{\partial \beta}\langle E \rangle = Var[E]</math>

And using the chain rule againː <math>C = \frac{\partial \langle E \rangle}{\partial T}= \left(-\frac{\partial \langle E \rangle}{\partial \beta}\right) \left(-\frac{\partial \beta}{\partial T}\right) = \frac{Var[E]}{k_B T^2}</math>

===TASK: Write a Python script to make a plot showing the heat capacity versus temperature for each of your lattice sizes from the previous section. You may need to do some research to recall the connection between the variance of a variable, <math>\mathrm{Var}[X]</math>, the mean of its square <math>\left\langle X^2\right\rangle</math>, and its squared mean <math>\left\langle X\right\rangle^2</math>. You may find that the data around the peak is very noisy — this is normal, and is a result of being in the critical region. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. ===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb

{{multiple image
| width =300
| align = left
| image1 = cg14172x2heatcap.png
| caption1 = 2x2 Matrix
| image2 = cg14174x4heatcap.png
| caption2 = 4x4 Matrix
| image3 =cg14178x8heatcap.png
| caption3 = 8x8 Matrix
| image4 =cg141716x16heatcap.png
| caption4 = 16x16 Matrix
| image5=cg141732x32heatcap.png
| caption5= 32x32 Matrix
| footer = Figure 13 - Graphs showing Heat Capacity against Temperature for each matrix size
}}

Here is the source code to produce the figuresː
<pre> def heatCap(energies,energysq,T,latsize):
#defines the heat capacity for a given temperature
energiesq=np.multiply(energies,energies) #creates array of (average energies) squared
varE=np.subtract(energysq,energiesq) #defines variance of average energy
tempsq=np.multiply(T,T) #array of temperature squared
return np.array(np.divide(varE,tempsq))/(latsize**2)

heatCap2x2=heatCap(energies2x2,energysq2x2,temps2x2,2) #creates array of heat capacity for each T

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(temps2x2,heatCap2x2,color='orange') #plots heat capacity for each T
pl.savefig('cg14172x2heatcap.png',bbox_inches='tight') #saves figure
pl.show()
</pre>

A general trend from the above graphs is that the peak of the graph shifts towards lower temperatures as the size of the matrix used increases.

==Section 8 - Locating the Curie Temperature==
===TASK: A C++ program has been used to run some much longer simulations than would be possible on the college computers in Python. You can view its source code here if you are interested. Each file contains six columns: <math>T, E, E^2, M, M^2, C</math> (the final five quantities are per spin), and you can read them with the NumPy loadtxt function as before. For each lattice size, plot the C++ data against your data. For one lattice size, save a PNG of this comparison and add it to your report — add a legend to the graph to label which is which. To do this, you will need to pass the label="..." keyword to the plot function, then call the legend() function of the axis object (documentation here).===

The python code used to read and plot the C++ data is found in the Jupyter notebook CG1417IsingModelGraphs.ipynb.

''Figure 14'' below shows the C++ plotted against my own data for a 16x16 Matrix.

[[File:Cg141716x16C++.png|400px|thumb|left|Figure 14 - Graph showing my own data against the C++ data for a 16x16 matrix.]]

 

Here is the source code the produce the figuresː
<pre>#fitting C++ data

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.plot(temps2x2, np.array(energies2x2)/4,color='black',alpha=0.7,label='Python Data') #python energy against T
enerax.plot(temps2x2C, energies2x2C, color='red',label='C++ Data') #C energy against T
magax.plot(temps2x2, np.array(mag2x2)/4,color='black',alpha=0.7,label='Python Data') #python magnetisation against T
magax.plot(temps2x2C, mag2x2C,color='red',label='C++ Data') #C energy against T
enerax.legend() #shows legend on energy graph
magax.legend() #shows legend on energy graph
pl.show()
</pre>

The relevant variables and dat files were changed for each matrix.

===TASK: write a script to read the data from a particular file, and plot C vs T, as well as a fitted polynomial. Try changing the degree of the polynomial to improve the fit — in general, it might be difficult to get a good fit! Attach a PNG of an example fit to your report.===

The python script to read and plot the fitted polynomial is found in CG1417PolyfitScript.ipynb

Here is the source code for ''Figure 15''

<pre>data_test = np.loadtxt("16x16C.dat")
T_test = data_test[:,0] #gets temperatures
C_test = data_test[:,5] #gets heat capacity data

#first we fit the polynomial to the data
fit_test = np.polyfit(T_test, C_test, 35) # fit a polynomial

#now we generate interpolated values of the fitted polynomial over the range of our function
T_min_test = 0.5 #np.min(T_test)
T_max_test = 5 #np.max(T_test)

T_range_test = np.linspace(T_min_test, T_max_test, 1000) #generate 1000 evenly spaced points between T_min and T_max
fitted_C_values_test = np.polyval(fit_test, T_range_test)# use the fit object to generate the corresponding values of C

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(T_test,C_test,color='orange',label='C++ Data') #plots C data of heat capacity against temp
heatcapax.plot(T_range_test,fitted_C_values_test,label='Fitted Polynomial') #plots fitted polynomial for whole range of temp
heatcapax.legend()
pl.savefig('FIT_TEST16x16_35.png', bbox_inches='tight') #saves figure
pl.show()
</pre>

Below in ''Figure 15'' is a plot of my Heat Capacity against Temperature data for a 16x16 matrix and features a polynomial of degree 35 plotted against it. Even with a polynomial of such a high degree, it poorly fits the curve and does not fit to the peak of the curve either.

[[File:cg1417FIT_TEST16x16_35.png|thumb|left|400px|Figure 15 - Plot of Heat Capacity against Temperature along with a poorly fitted polynomial of degree 35. ]]

 

===TASK: Modify your script from the previous section. You should still plot the whole temperature range, but fit the polynomial only to the peak of the heat capacity! You should find it easier to get a good fit when restricted to this region===

The script was modified as such that the polynomial was fitted in a set range around the peak of the graph, this is demonstrated in ''Figure 17'' which shows a newly fitted polynomial between a much smaller range of temperatures (T = 2.15-2.55) and a much smaller degree polynomial (3).

[[File:CG1417FIT_16x16C_3.png|thumb|left|400px|Figure 16 - Graph showing Heat Capacity against Temperature for a 16x16 matrix along with a fitted polynomial between a much more restricted range of temperatures and a significantly lower degree of polynomial]]

Upon comparison with ''Figure 15'', the new fitted polynomial is a significantly better fit even for a 3rd degree polynomial and is a much more accurate representation of my data around the peak of the graph and will make it easier to determine the maximum value of Heat Capacity.

 

Here is the source code for ''Figure 16''ː
<pre>data16 = np.loadtxt("16x16C.dat") #loads data to variable

T16 = data16[:,0] #gets temps
C16 = data16[:,5] # gets heat capacities

Tmin16 = 2.15 #chosen min temp
Tmax16 = 2.55 #chosen max temp

selection16 = np.logical_and(T16 > Tmin16, T16 < Tmax16) #choose only those rows where both conditions are true
peak_T_values16 = T16[selection16] #choose temp values in range chosen above
peak_C_values16 = C16[selection16] #choose heat cap values in range of t above

fit16 = np.polyfit(peak_T_values16,peak_C_values16,3) #fit 3rd order polynomial
peak_T_range16 = np.linspace(Tmin16, Tmax16, 1000) #defines 1000 temps within data range
fitted_C_values16 = np.polyval(fit16, peak_T_range16) #use the fit object to get corresponding values of heat cap

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(T16,C16,color='orange',label='C++ Data') #plots C data of heat cap against temp
heatcapax.plot(peak_T_range16,fitted_C_values16,label='Fitted Polynomial') #plots fitted polynomial for small range
heatcapax.legend()
pl.savefig('FIT_16x16C_3.png', bbox_inches='tight') #saves figure
pl.show()

</pre>

===TASK: find the temperature at which the maximum in C occurs for each datafile that you were given. Make a text file containing two colums: the lattice side length (2,4,8, etc.), and the temperature at which C is a maximum. This is your estimate of <math>T_C</math> for that side length. Make a plot that uses the scaling relation given above to determine <math>T_{C,\infty}</math>. By doing a little research online, you should be able to find the theoretical exact Curie temperature for the infinite 2D Ising lattice. How does your value compare to this? Are you surprised by how good/bad the agreement is? Attach a PNG of this final graph to your report, and discuss briefly what you think the major sources of error are in your estimate.===

''Figure 17'' below shows a graph of <math>T_{C,L}</math> against <math>\frac{1}{Lattice Size}</math> to determine the Curie Temperature of an infinite 2D Ising Model Lattice <math>T_{C,\infty}</math>. The black dots represent the raw data obtained from obtaining the temperature at which the Heat Capacity was a maximum for the lattices and the red line in a linear curve fit plotted against the data to allow the y-intercept which is the Curie Temperature for the infinite 2D lattice to be determined.

[[File:cg1417CurieTemp.png|400px|thumb|left|Figure 17 - Plot of 1/Lattice Size against Curie Temperature for that lattice size.]]

The value for <math>T_{C,\inf}</math> obtained from the data is <math>T_{C,\infty} = 2.277 \frac{J}{k_B}</math> with a literature value being <math>T_{C,\infty} = 2.269 \frac{J}{k_B}</math> <ref>L. Onsager, Phys. Rev., 1944, 65, 117--149.</ref>for an infinite square 2D lattice. This means that my result slightly over-estimates the Curie Temperature for the infinite lattice and as a result for an infinite lattice the temperature at which spontaneous magnetisation stops would actually occur at a slightly lower temperature than expected. However, the difference between my value and the literature value is only 0.008 which is incredibly small and the amount of agreement between the two values is somewhat surprising, which means that the error in my estimates of the Curie Temperature for each lattice size is relatively small. The points which have the largest residuals and deviation from the line of best fit in ''Figure 17'' corresponds to the smaller lattice sizes of 2x2 and 4x4 where longer range interactions are more significant. The longer range interactions posed by the boundary conditions are nowhere near as significant for the larger sizes and causes the energy of the smaller matrices to be less accurate and have a larger associated error with the energy and thus the Curie Temperature for that lattice size. This affects the accuracy of the line of best fit and to increase the accuracy of this line, larger lattice sizes of 128x128, 256x256 etc should be included in the calculation for the line of best fit and the smaller matrices ignored.

 

Below is the source code used to generate ''Figure 17''
<pre>
Cmax64x64 = np.max(fitted_C_values64) #finds Cmax for 64x64 matrix - done for others already
Tmax64x64 = peak_T_range64[fitted_C_values64 == Cmax64x64] #finds Tmax corresponding to Cmax

LatSize=[2,4,8,16,32,64] #stores lattice sizes
Tmax=[Tmax2x2,Tmax4x4,Tmax8x8,Tmax16x16,Tmax32x32,Tmax64x64] #stores corresponding Tmax data
np.savetxt('CmaxVSTmax.txt', (LatSize,Tmax)) #writes data to txt file

ScalData=np.loadtxt('CmaxVSTmax.txt') #loads data
LatticeSize=ScalData[0] #gets lattice sizes
TempMax=ScalData[1] #gets max temp or curie temp for each lattice

Lmin1min = np.min(np.divide(1,LatticeSize)) #minimum of 1/LatticeSize values
Lmin1max = np.max(np.divide(1,LatticeSize)) #maximum of 1/LatticeSize values

fitTcl = np.polyfit(np.divide(1,LatticeSize),TempMax, 1) #creates fit object

Lmin1values = np.linspace(Lmin1min, Lmin1max, 1000) #finds 1000 values between min and max x-axis value of 1/LatticeSize
fitted_Tcl_values = np.polyval(fitTcl, Lmin1values) #creates corresponding Curie Temp values for each value in Lmin1values

fig = pl.figure()
scalrelax = fig.add_subplot(1,1,1)
scalrelax.set_xlabel('1/Lattice Size')
scalrelax.set_ylabel('Curie Temperature/ J/k_B')
scalrelax.plot(np.divide(1,LatticeSize),TempMax,color='black',marker='.',linestyle='') #plots Curie Temp against 1/LatticeSize
scalrelax.plot(Lmin1values,fitted_Tcl_values,color='red',marker='',linestyle='-') #plots line of best fit for data above
pl.savefig('CurieTemp.png', bbox_inches='tight') #saves figure
pl.show()

</pre>

== References ==

Rep:Y3CMPCG1417

2019-11-20T10:11:46Z

Cg1417: /* TASK: Use the script ILtimetrial.py to record how long your new version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in y...

==Section 1 - Introduction to the Ising Model==

===TASK: Show that the lowest possible energy for the Ising model is <math>E = -DNJ</math>, where D is the number of dimensions and N is the total number of spins. What is the multiplicity of this state? Calculate its entropy.===

Consider a 1D row of lattice sites of N=3 with spin configuration [+1][+1][+1].

Mathematically the interaction energy is defined asː
<math> -\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} </math> where J is a constant and <math>s_{i}s_{j}</math> is the product between two spins in adjacent lattice sites.

The sum of the interaction energies <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j}</math> can be considered as the sum of the individual interaction energies between spinsː
<math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = \epsilon_{12} + \epsilon_{23} + \epsilon_{13} + \epsilon_{21} + \epsilon_{32} + \epsilon_{31} </math>.

Although lattice sites 1 and 3 are not adjacent they are said to still interact according to the periodic boundary conditions applied.

However, <math>\epsilon_{12} = \epsilon_{21} </math> and <math>\epsilon_{23} = \epsilon_{32}</math> and <math>\epsilon_{13} = \epsilon_{31}</math> which means that all of the interactions within the system are counted twice, hence the total energy needs to be halved, resulting in the following formula being obtainedː <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = 2\epsilon_{12} + 2\epsilon_{13} + 2\epsilon_{23} </math>.

It can be determined that <math>\epsilon_{12} = (+1)(+1) = 1</math> , <math>\epsilon_{13} = (+1)(+1) = 1</math> and <math>\epsilon_{23} = (+1)(+1) = 1</math>.

Thereforeː <math>-\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = -\frac{1}{2} \ J \ (2 + 2 + 2) = -\frac{1}{2} \ J \ 6 = - 3 J = -DNJ</math> for a 1D lattice with <math>D=1</math> and 3 lattice sites <math>N=3</math>

The multiplicity of the system,<math>\Omega = \frac{lattice sites!}{n. spin up!n. spin down!}</math>

Entropy, <math>S</math> is defined as <math>S = k_B ln(\Omega)</math> and so in this case <math>S = k_B ln(\frac{100!}{100!}) = 0</math>

===TASK: Imagine that the system is in the lowest energy configuration. To move to a different state, one of the spins must spontaneously change direction ("flip"). What is the change in energy if this happens <math>(D=3, N=1000)</math>? How much entropy does the system gain by doing soʔ===

In a 3D lattice system, each lattice site has three unique interactions with its neighbours to its left, top and front. In the lowest energy configuration, all spins are parallel and for a system the minimum energy is <math>E = -DNJ</math>, so for the system with <math>N=1000</math> and <math>D=3</math>, the minimum energy is <math>-3000J</math>.

If a single spin is flipped, the product of its spin with its neighbours spin reverses and becomes negative and this increases the total energy of the system. Since 3 unique spin-spin interactions are reversed in sign, the total energy increases by <math>+3J</math>, meaning the new total energy is <math>-2997J</math>

Initially the multiplicity of the system will be <math>\Omega = \frac{1000!}{1000!}</math> , and after the flip, the multiplicity becomes <math> \Omega = \frac{1000!}{999!1!}=1000</math>.

The associated change in entropy, <math>\Delta S = k_B ln(1000) - 0 = 6.91 k_B</math>, which is an expected increase in entropy as the number of possible configurations of the system increases.

===TASK: Calculate the magnetisation of the 1D and 2D lattices in Figure 1. What magnetisation would you expect to observe for an Ising lattice with <math>D = 3,\ N=1000</math> at absolute zero?===

[[File:ThirdYearCMPExpt-IsingSketch.png|thumb|left|Figure 1 - Shows 1D (N = 5), 2D (N = 5x5) and 3D (N = 5x5x5) lattices.]]

Magnetisation is defined as <math>M=\sum_{i} s_i</math>. So for the 1D lattice with <math>N = 5</math> in ''Figure 2'', <math>M = +1</math> and for the 2D lattice with <math>N = 25 , M = +1</math> too.

According to the 3rd Law of thermodynamics, entropy is 0 at absolute zero for a perfect crystalline solid, and consequently it is expected that the lattices will have follow suit and have zero entropy at 0K. To have zero entropy all spins must be parallel as such that magnetisation, <math>M = N</math>. For all the spins to be parallel, there is only one possible configuration. So, for a lattice with <math>N = 1000</math> and <math>D =3</math>, if <math>M = N</math>, then multiplicity, <math>\Omega = 1</math> and entropy, <math>S =k_B ln(1) = 0</math>.

 

==Section 2 - Calculating the Energy and Magnetisation==

===TASK: complete the functions energy() and magnetisation(), which should return the energy of the lattice and the total magnetisation, respectively. In the energy() function you may assume that <math>J=1.0</math> at all times (in fact, we are working in reduced units in which <math>J=k_B</math>, but there will be more information about this in later sections). Do not worry about the efficiency of the code at the moment — we will address the speed in a later part of the experiment.===

<pre>def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
lat=self.lattice #creates lattice and stores it
mag=[]
for i in range(0,len(lat)): #loops through all rows of lattice
for j in range(0,len(lat[i])): #loops through elements of each row
mag+=[lat[i][j]] #adds spin value to mag array
return sum(mag) #sums all spins from mag array
</pre>

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

lat=self.lattice #creates lattice and stores it
left=[]
top=[]

for i in range(0,len(lat)):
for j in range(0,len(lat[i])):
left+=[lat[i][j]*lat[i][j-1]] #multiplies spin by spin to left
top+=[lat[i][j]*lat[i-1][j]] #multiplies spin by spin above it
int_en=left+top #sums spin products from left and top
energy=-sum(int_en) #sums all spin products for each spin to give total

return energy
</pre>

===TASK: Run the ILcheck.py script from the IPython Qt console using the command===

''Figure 2'' shows the results when ILcheck.py was ran on my IsingLattice.py file. The ILcheck.py file was ran several times to ensure the code worked for various random lattices.

[[File:Cg1417ILcheck run.png|thumb|left|500px| Figure 2 - Result from running the ILcheck.py file]]

 

==Section 3 - Introduction to Monte Carlo Simulation==

===TASK: How many configurations are available to a system with 100 spins? To evaluate these expressions, we have to calculate the energy and magnetisation for each of these configurations, then perform the sum. Let's be very, very, generous, and say that we can analyse <math>1\times 10^9</math> configurations per second with our computer. How long will it take to evaluate a single value of <math>\left\langle M\right\rangle_T</math>?===

For a system with 100 lattice sites and two possible spins for each site, there are <math>2^{100}</math>possible configurations for the system. <math>2^{100}= 1.27\times 10^{30} </math>, so if the computer can analyse <math>1\times 10^9</math> configurations per second, then it will take <math>\frac{1.27\times 10^{30}}{10^9} = 1.27\times 10^{21} s</math> to analyse the whole system, which is longer than the age of the universe and therefore is not a practical approach.

===TASK: Implement a single cycle of the above algorithm in the montecarlocycle(T) function. This function should return the energy of your lattice and the magnetisation at the end of the cycle. You may assume that the energy returned by your energy() function is in units of <math>k_B</math>! Complete the statistics() function. This should return the following quantities whenever it is called: <math><E>, <E^2>, <M>, <M^2></math>, and the number of Monte Carlo steps that have elapsed.===
<pre>
E = []
E2 = []
M = []
M2 = []
n_cycles = 0

def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back if rejected else not changed

self.E+=[self.energy()] #records energy
self.E2+=[self.energy()**2] #records energy squared
self.M+=[self.magnetisation()] #records magnetisation
self.M2+=[self.magnetisation()**2] #records magnetisation squared
self.n_cycles=self.n_cycles+1 #adds 1 to run total

return (self.energy(),self.magnetisation())

def statistics(self):
# complete this function so that it calculates the correct values for the averages of E, E*E (E2), M, M*M (M2), and returns them

e=np.mean(self.E)
e2=np.mean(self.E2)
m=np.mean(self.M)
m2=np.mean(self.M2)

return e,e2,m,m2,self.n_cycles
</pre>

''Figure 3'' shows the results of a single run of the montecarlostep() function and the lattice the function operated upon.

[[File:cg1417MonteCarloStep_run.png|thumb|left|Figure 3 - Results from a single montecarlostep() function and the resulting lattice produced along with the correct return from the statistics() function]]

 

===TASK: If <math>T < T_C</math>, do you expect a spontaneous magnetisation (i.e. do you expect <math>\left\langle M\right\rangle \neq 0</math>)? When the state of the simulation appears to stop changing (when you have reached an equilibrium state), use the controls to export the output to PNG and attach this to your report. You should also include the output from your statistics() function.===

If the temperature of the system is less than the Curie Temperature, <math>T_C</math> then spontaneous magnetisation can occur and the system will tend to its lowest energy state where all of the spins are parallel - this is a property of ferromagnetic materials.

[[File:Cg1417ILanim_run.png|400px|thumb|left|Figure 4 - Results from running the ILanim.py file - shows the energy and magnetisation converging over time]]

''Figure 4'' shows that over time the the system spontaneously converges to the minimum energy state with all of the spins parallel to one another and shows, as I expected, that spontaneous magnetisation occurs and also shows that the temperature of this simulation is below the Curie Temperature, <math>T < T_C</math>.

 

==Section 4 - Accelerating the Code==

===TASK: Use the script ILtimetrial.py to record how long your current version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 5'' show the results of running the ILtimetrial.py file on my code three timesː

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1.png
| width1=500
| image2=cg1417ILtimetrial_run2.png
| width2=500
| image3=cg1417ILtimetrial_run3.png
| width3=500
| footer = Figure 5 - Results of running the ILtimetrial.py file on my code three separate times
}}
 

This gave me an avergage time of <math>24.3 s \pm 0.2s</math>

===TASK: Look at the documentation for the NumPy sum function. You should be able to modify your magnetisation() function so that it uses this to evaluate M. The energy is a little trickier. Familiarise yourself with the NumPy roll and multiply functions, and use these to replace your energy double loop (you will need to call roll and multiply twice!).===

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

left=multiply(roll(self.lattice,1,axis=1),self.lattice) #product of spin with spin left of it
top=multiply(roll(self.lattice,-1,axis=0),self.lattice) #product of spin with spin above it

int_en=sum(left+top) #sum of array containing sum of left and top spin products for each spin

energy = -sum(int_en) #calculates the total energy of system
return energy

def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
return sum(sum(self.lattice)) #adds up all spins in lattice
</pre>

===TASK: Use the script ILtimetrial.py to record how long your new version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 6'' shows the result of running the ILtimetrial.py on my new accelerated code.

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1fast.png
| width1=500
| image2=ILtimetrial_run2fast.png
| width2=500
| image3=ILtimetrial_run3fast.png
| width3=500
| footer = Figure 6 - Results of running the ILtimetrial.py file on my new updated and accelerated code.
}}
 

The accelerated code is much faster upon using the roll, multiply and sum modules with a new average time of <math>0.790 s \pm 0.005 </math>

==Section 5 - The effect of temperature==

===TASK: The script ILfinalframe.py runs for a given number of cycles at a given temperature, then plots a depiction of the final lattice state as well as graphs of the energy and magnetisation as a function of cycle number. This is much quicker than animating every frame! Experiment with different temperature and lattice sizes. How many cycles are typically needed for the system to go from its random starting position to the equilibrium state? Modify your statistics() and montecarlostep() functions so that the first N cycles of the simulation are ignored when calculating the averages. You should state in your report what period you chose to ignore, and include graphs from ILfinalframe.py to illustrate your motivation in choosing this figure.===

''Figure 6'' below shows the results from running the ILfinalframe.py for 2x2 lattice at T=1,2,3,5.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2T1.png
| image2 = cg14172x2T2.png
| image3 =cg14172x2T3.png
| image4 =cg14172x2T5.png
| footer_align = left
| footer = Figure 6 - Results of running the ILfinalframe.py file at T=1,2,3,5 for a 2x2 matrix.
}}

 

For a 2x2 matrix, a suitable cut-off point to exclude from the avergage energies and magnetisations is where the energy and magnetisations per spin are constant, which is 30 steps. For T=3 and T=5 the graphs do not converge because it is possible that these temperatures are higher than the Curie Temperature and as such spontaneous magnetisation will not occur and the system will not diverge to the lowest energy state. At the higher temperatures, there are larger thermal fluctations and the Boltzmann factor is more significant allowing the system to move away from the lowest energy state easier. As a result moving forwards, a suitable cut-off point will only be determined from T=1 and T=2 graphs for the larger matrices.

''Figure 7'' shows the results from running a 4x4 lattice at T=1,2 and 3.

{{multiple image
| width =350
| align = left
| image1 = cg14174x4T1.png
| image2 = cg14174x4T2.png
| image3 =cg14174x4T3.png
| footer_align = left
| footer = Figure 7 - Results of running the ILfinalframe.py file at T=1,2,3 for a 4x4 matrix.
}}

From ''Figure 7'', a suitable cut-off point for the energy and magnetisations is 200 as this is after where the energy and magnetisation has converged for T=1, and is after the initial large drop in energy for T=2, even though there are a few small fluctuations after 200 steps. The result from T=3 has been included to show the large fluctuations for the larger temperatures, and supporting my choice to determine the cut-off from T=1 and T=2 only.

''Figure 8'' shows the results for an 8x8 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg14178x8T1.png
| image2 = cg14178x8T2.png
| footer_align = left
| footer = Figure 8 - Results of running the ILfinalframe.py file at T=1,2 for an 8x8 matrix
}}

From ''Figure 8'' above, a suitable cut-off point is 1000 steps as this is where the energy and magnetisation has easily converged by and is also the point after which the initial large drop in energy has been overcome for T=2 too.

''Figure 9'' shows the result of running the ILfinalframe.py for a 16x16 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg141716x16T1.png
| image2 = cg141716x16T2.png
| footer_align = left
| footer = Figure 9 - Results of running the ILfinalframe.py file at T=1,2 for a 16x16 matrix
}}

From ''Figure 9'', a suitable cut-off point is 15000 steps as for T=1 the energy and magnetisations have converged significantly and will not change much, and likewise this is the same for the T=2 frame.

''Figure 10'' below shows the results from a 32x32 matrix at T=1 and T=2.

{{multiple image
| width =350
| align = left
| image1 = cg141732x32T1.png
| image2 = cg141732x32T2.png
| footer_align = left
| footer = Figure 10 - Results of running the ILfinalframe.py file at T=1,2 for a 32x32 matrix
}}

''Figure 10'' above shows the results of running the ILfinalframe.py file for a 32x32 matrix at T=1 and T=2. As a result a suitable cut-off of 50000 steps was chosen as the energy and magnetisation has significantly converged, but not as much as it could at 100000 steps. I chose a slightly lower value to ensure that the run times of my monte-carlo simulations in future tasks were not extremely time consuming.

The montecarlostep() function was changed by adding a condition that values only above the pre-determined cut-off were included when determining the average value of energy; energy squared; magnetisation and magnetisations squared from the statistics function. The statistics() function did not need to be modified.

The following code is from the 32x32 matrixː

<pre>def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back

if self.n_cycles > 50000: #only adds values to array of E,E2,M and M2 is above specific cut-off
self.E+=[self.energy()]
self.E2+=[self.energy()**2]
self.M+=[self.magnetisation()]
self.M2+=[self.magnetisation()**2]
self.n_cycles=self.n_cycles+1

return (self.energy(),self.magnetisation())
</pre>

===TASK: Use ILtemperaturerange.py to plot the average energy and magnetisation for each temperature, with error bars, for an <math>8\times 8</math> lattice. Use your intuition and results from the script ILfinalframe.py to estimate how many cycles each simulation should be. The temperature range 0.25 to 5.0 is sufficient. Use as many temperature points as you feel necessary to illustrate the trend, but do not use a temperature spacing larger than 0.5. The NumPy function savetxt() stores your array of output data on disk — you will need it later. Save the file as 8x8.dat so that you know which lattice size it came from.===

Using the modified code, the file ILtemperaturerange.py was ran on an 8x8 matrix between T=0.5 and T=5 with a step of T=0.02 for 10000 Montecarlo steps and the first 1000 steps of each temperature were excluded when calculating the averages. ''Figure 11'' shows the result of the simulation and also included error bars of standard deviation.

[[File:Cg14178x8error.png|1000px|thumb|left|Figure 11 - Graph showing average energy and average magnetisation for an 8x8 lattice with error bars between T=0.5 and T=5]]

 

Below is the source code for the script to produce the graphː

<pre>data8x8=np.loadtxt('8x8.dat') #loads data
temps8x8=data8x8[:,0] #stores temperatures
energies8x8=data8x8[:,1] #stores average energy for each T
energysq8x8=data8x8[:,2] #stores average energy squared for each T
mag8x8=data8x8[:,3] #stores magnetisation for each T
magsq8x8=data8x8[:,4] #stores magnetisation squared for each T
stde8x8=data8x8[:,5] #edited ILtemperaturerange.py to record the standard deviation of the energy for each T
stdm8x8=data8x8[:,6] #edited ILtemperaturerange.py to record the standard deviation of the magnetisation for each T

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.errorbar(temps8x8, np.array(energies8x8)/64,yerr=np.divide(stde8x8,64),color='black',ecolor='teal',alpha=0.8) #plots energy per spin against T
magax.errorbar(temps8x8, np.array(mag8x8)/64,yerr=np.divide(stdm8x8,64),alpha=0.8,ecolor='salmon',color='black') #plots magnetisation per spin against T on separate graph
pl.savefig('8x8error.png',bbox_inches='tight') #saves figure
pl.show()

</pre>

==Section 6 - The effect of system size==

===TASK: Repeat the final task of the previous section for the following lattice sizes: 2x2, 4x4, 8x8, 16x16, 32x32. Make sure that you name each datafile that your produce after the corresponding lattice size! Write a Python script to make a plot showing the energy per spin versus temperature for each of your lattice sizes. Hint: the NumPy loadtxt function is the reverse of the savetxt function, and can be used to read your previously saved files into the script. Repeat this for the magnetisation. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. How big a lattice do you think is big enough to capture the long range fluctuations?===

The python script for this section is identical as for the 8x8 graph above in Figure 11 with the relevant files and variables changed accordingly.

Each matrix was simulated using the ILtemperaturerange.py file between T=0.5 and T=5 with a step of T=0.02.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2error.png
| caption1 = 2x2 matrix - 5000 steps, cut-off = 30 steps
| image2 = 4x4error.png
| caption2 = 4x4 matrix - 1000 steps, cut-off = 200 steps
| image3 =cg141716x16error.png
| caption3 = 16x16 matrix - 50000 steps, cut-off = 15000 steps
| image4 =cg141732x32error.png
| caption4 = 32x32 matrix - 200000 steps, cut-off = 50000 steps
| footer_align = left
| footer = Figure 12 - Results of running the ILtemperaturerange.py file for 2x2, 4x4, 16x16 and 32x32 matrices.
}}

 

==Section 7 - Determining the Heat Capacity==

===TASK: By definition, <math>C = \frac{\partial \left\langle E\right\rangle}{\partial T}</math>. From this, show that <math>C = \frac{\mathrm{Var}[E]}{k_B T^2}</math> (Where <math>\mathrm{Var}[E]</math> is the variance in <math>E</math>.)===

Recall from statistical thermodynamics that the average energy of a system is the sum across all microstates of the probability of that microstate multiplied by the energy of that microstate, which is defined mathematically asː <math>\langle E \rangle = \sum_i p_{i}\epsilon_{i}</math>.

The partition function <math>q</math> is defined as <math>q = \sum_{i} exp(-\beta \epsilon_{i})</math> where <math>\beta =\frac{1}{k_BT}</math>and the probability, <math>p_{i}</math> can be defined in terms of the partition function as <math>p_{i} = \frac{exp(-\beta \epsilon_{i})}{\sum_{i} exp(-\beta \epsilon_{i})} = \frac{exp(-\beta \epsilon_{i})}{q}</math>.

As a result, <math>\langle E \rangle</math> can be re-written as <math>\langle E \rangle = \sum_{i} \frac{\epsilon_{i} exp(-\beta \epsilon_{i})}{q} = -\frac{1}{q} \frac{\partial}{\partial \beta}\sum_{i}exp(-\beta \epsilon_{i}) = -\frac{1}{q} \frac{\partial q}{\partial \beta}</math>

Likewise, <math>\langle E^2 \rangle = \sum_i p_{i}\epsilon_{i}^{2} = \sum_{i} \frac{\epsilon_{i}^{2}exp(-\beta \epsilon_{i})}{q} = \frac{1}{q} \frac{\partial^{2}}{\partial \beta^{2}}\sum_{i}exp(-\beta \epsilon_{i}) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}}</math>

From definitionː <math>Var[E] = \Delta E^2 = \langle E^2 \rangle - \langle E \rangle^2 </math>

When the definition of <math>\langle E \rangle</math> and <math>\langle E^2 \rangle</math> is written in terms of partition function <math>q</math>ː <math>Var[E] = \langle E^2 \rangle - \langle E \rangle^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \left(\frac{1}{q}\frac{\partial q}{\partial \beta}\right)^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2</math>.

According to the chain ruleː <math>\frac{\partial}{\partial \beta}\left(\frac{1}{q} \frac{\partial q}{\partial \beta}\right) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2 = -\frac{\partial}{\partial \beta}\langle E \rangle = Var[E]</math>

And using the chain rule againː <math>C = \frac{\partial \langle E \rangle}{\partial T}= \left(-\frac{\partial \langle E \rangle}{\partial \beta}\right) \left(-\frac{\partial \beta}{\partial T}\right) = \frac{Var[E]}{k_B T^2}</math>

===TASK: Write a Python script to make a plot showing the heat capacity versus temperature for each of your lattice sizes from the previous section. You may need to do some research to recall the connection between the variance of a variable, <math>\mathrm{Var}[X]</math>, the mean of its square <math>\left\langle X^2\right\rangle</math>, and its squared mean <math>\left\langle X\right\rangle^2</math>. You may find that the data around the peak is very noisy — this is normal, and is a result of being in the critical region. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. ===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb

{{multiple image
| width =300
| align = left
| image1 = cg14172x2heatcap.png
| caption1 = 2x2 Matrix
| image2 = cg14174x4heatcap.png
| caption2 = 4x4 Matrix
| image3 =cg14178x8heatcap.png
| caption3 = 8x8 Matrix
| image4 =cg141716x16heatcap.png
| caption4 = 16x16 Matrix
| image5=cg141732x32heatcap.png
| caption5= 32x32 Matrix
| footer = Figure 13 - Graphs showing Heat Capacity against Temperature for each matrix size
}}

Here is the source code to produce the figuresː
<pre> def heatCap(energies,energysq,T,latsize):
#defines the heat capacity for a given temperature
energiesq=np.multiply(energies,energies) #creates array of (average energies) squared
varE=np.subtract(energysq,energiesq) #defines variance of average energy
tempsq=np.multiply(T,T) #array of temperature squared
return np.array(np.divide(varE,tempsq))/(latsize**2)

heatCap2x2=heatCap(energies2x2,energysq2x2,temps2x2,2) #creates array of heat capacity for each T

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(temps2x2,heatCap2x2,color='orange') #plots heat capacity for each T
pl.savefig('cg14172x2heatcap.png',bbox_inches='tight') #saves figure
pl.show()
</pre>

A general trend from the above graphs is that the peak of the graph shifts towards lower temperatures as the size of the matrix used increases.

==Section 8 - Locating the Curie Temperature==
===TASK: A C++ program has been used to run some much longer simulations than would be possible on the college computers in Python. You can view its source code here if you are interested. Each file contains six columns: <math>T, E, E^2, M, M^2, C</math> (the final five quantities are per spin), and you can read them with the NumPy loadtxt function as before. For each lattice size, plot the C++ data against your data. For one lattice size, save a PNG of this comparison and add it to your report — add a legend to the graph to label which is which. To do this, you will need to pass the label="..." keyword to the plot function, then call the legend() function of the axis object (documentation here).===

The python code used to read and plot the C++ data is found in the Jupyter notebook CG1417IsingModelGraphs.ipynb.

''Figure 14'' below shows the C++ plotted against my own data for a 16x16 Matrix.

[[File:Cg141716x16C++.png|400px|thumb|left|Figure 14 - Graph showing my own data against the C++ data for a 16x16 matrix.]]

 

Here is the source code the produce the figuresː
<pre>#fitting C++ data

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.plot(temps2x2, np.array(energies2x2)/4,color='black',alpha=0.7,label='Python Data') #python energy against T
enerax.plot(temps2x2C, energies2x2C, color='red',label='C++ Data') #C energy against T
magax.plot(temps2x2, np.array(mag2x2)/4,color='black',alpha=0.7,label='Python Data') #python magnetisation against T
magax.plot(temps2x2C, mag2x2C,color='red',label='C++ Data') #C energy against T
enerax.legend() #shows legend on energy graph
magax.legend() #shows legend on energy graph
pl.show()
</pre>

The relevant variables and dat files were changed for each matrix.

===TASK: write a script to read the data from a particular file, and plot C vs T, as well as a fitted polynomial. Try changing the degree of the polynomial to improve the fit — in general, it might be difficult to get a good fit! Attach a PNG of an example fit to your report.===

The python script to read and plot the fitted polynomial is found in CG1417PolyfitScript.ipynb

Here is the source code for ''Figure 15''

<pre>data_test = np.loadtxt("16x16C.dat")
T_test = data_test[:,0] #gets temperatures
C_test = data_test[:,5] #gets heat capacity data

#first we fit the polynomial to the data
fit_test = np.polyfit(T_test, C_test, 35) # fit a polynomial

#now we generate interpolated values of the fitted polynomial over the range of our function
T_min_test = 0.5 #np.min(T_test)
T_max_test = 5 #np.max(T_test)

T_range_test = np.linspace(T_min_test, T_max_test, 1000) #generate 1000 evenly spaced points between T_min and T_max
fitted_C_values_test = np.polyval(fit_test, T_range_test)# use the fit object to generate the corresponding values of C

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(T_test,C_test,color='orange',label='C++ Data') #plots C data of heat capacity against temp
heatcapax.plot(T_range_test,fitted_C_values_test,label='Fitted Polynomial') #plots fitted polynomial for whole range of temp
heatcapax.legend()
pl.savefig('FIT_TEST16x16_35.png', bbox_inches='tight') #saves figure
pl.show()
</pre>

Below in ''Figure 15'' is a plot of my Heat Capacity against Temperature data for a 16x16 matrix and features a polynomial of degree 35 plotted against it. Even with a polynomial of such a high degree, it poorly fits the curve and does not fit to the peak of the curve either.

[[File:cg1417FIT_TEST16x16_35.png|thumb|left|400px|Figure 15 - Plot of Heat Capacity against Temperature along with a poorly fitted polynomial of degree 35. ]]

 

===TASK: Modify your script from the previous section. You should still plot the whole temperature range, but fit the polynomial only to the peak of the heat capacity! You should find it easier to get a good fit when restricted to this region===

The script was modified as such that the polynomial was fitted in a set range around the peak of the graph, this is demonstrated in ''Figure 17'' which shows a newly fitted polynomial between a much smaller range of temperatures (T = 2.15-2.55) and a much smaller degree polynomial (3).

[[File:CG1417FIT_16x16C_3.png|thumb|left|400px|Figure 16 - Graph showing Heat Capacity against Temperature for a 16x16 matrix along with a fitted polynomial between a much more restricted range of temperatures and a significantly lower degree of polynomial]]

Upon comparison with ''Figure 15'', the new fitted polynomial is a significantly better fit even for a 3rd degree polynomial and is a much more accurate representation of my data around the peak of the graph and will make it easier to determine the maximum value of Heat Capacity.

 

Here is the source code for ''Figure 16''ː
<pre>data16 = np.loadtxt("16x16C.dat") #loads data to variable

T16 = data16[:,0] #gets temps
C16 = data16[:,5] # gets heat capacities

Tmin16 = 2.15 #chosen min temp
Tmax16 = 2.55 #chosen max temp

selection16 = np.logical_and(T16 > Tmin16, T16 < Tmax16) #choose only those rows where both conditions are true
peak_T_values16 = T16[selection16] #choose temp values in range chosen above
peak_C_values16 = C16[selection16] #choose heat cap values in range of t above

fit16 = np.polyfit(peak_T_values16,peak_C_values16,3) #fit 3rd order polynomial
peak_T_range16 = np.linspace(Tmin16, Tmax16, 1000) #defines 1000 temps within data range
fitted_C_values16 = np.polyval(fit16, peak_T_range16) #use the fit object to get corresponding values of heat cap

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(T16,C16,color='orange',label='C++ Data') #plots C data of heat cap against temp
heatcapax.plot(peak_T_range16,fitted_C_values16,label='Fitted Polynomial') #plots fitted polynomial for small range
heatcapax.legend()
pl.savefig('FIT_16x16C_3.png', bbox_inches='tight') #saves figure
pl.show()

</pre>

===TASK: find the temperature at which the maximum in C occurs for each datafile that you were given. Make a text file containing two colums: the lattice side length (2,4,8, etc.), and the temperature at which C is a maximum. This is your estimate of <math>T_C</math> for that side length. Make a plot that uses the scaling relation given above to determine <math>T_{C,\infty}</math>. By doing a little research online, you should be able to find the theoretical exact Curie temperature for the infinite 2D Ising lattice. How does your value compare to this? Are you surprised by how good/bad the agreement is? Attach a PNG of this final graph to your report, and discuss briefly what you think the major sources of error are in your estimate.===

''Figure 17'' below shows a graph of <math>T_{C,L}</math> against <math>\frac{1}{Lattice Size}</math> to determine the Curie Temperature of an infinite 2D Ising Model Lattice <math>T_{C,\infty}</math>. The black dots represent the raw data obtained from obtaining the temperature at which the Heat Capacity was a maximum for the lattices and the red line in a linear curve fit plotted against the data to allow the y-intercept which is the Curie Temperature for the infinite 2D lattice to be determined.

[[File:cg1417CurieTemp.png|400px|thumb|left|Figure 17 - Plot of 1/Lattice Size against Curie Temperature for that lattice size.]]

The value for <math>T_{C,\inf}</math> obtained from the data is <math>T_{C,\infty} = 2.277 \frac{J}{k_B}</math> with a literature value being <math>T_{C,\infty} = 2.269 \frac{J}{k_B}</math> <ref>L. Onsager, Phys. Rev., 1944, 65, 117--149.</ref>for an infinite square 2D lattice. This means that my result slightly over-estimates the Curie Temperature for the infinite lattice and as a result for an infinite lattice the temperature at which spontaneous magnetisation stops would actually occur at a slightly lower temperature than expected. However, the difference between my value and the literature value is only 0.008 which is incredibly small and the amount of agreement between the two values is somewhat surprising, which means that the error in my estimates of the Curie Temperature for each lattice size is relatively small. The points which have the largest residuals and deviation from the line of best fit in ''Figure 17'' corresponds to the smaller lattice sizes of 2x2 and 4x4 where longer range interactions are more significant. The longer range interactions posed by the boundary conditions are nowhere near as significant for the larger sizes and causes the energy of the smaller matrices to be less accurate and have a larger associated error with the energy and thus the Curie Temperature for that lattice size. This affects the accuracy of the line of best fit and to increase the accuracy of this line, larger lattice sizes of 128x128, 256x256 etc should be included in the calculation for the line of best fit and the smaller matrices ignored.

 

Below is the source code used to generate ''Figure 17''
<pre>
Cmax64x64 = np.max(fitted_C_values64) #finds Cmax for 64x64 matrix - done for others already
Tmax64x64 = peak_T_range64[fitted_C_values64 == Cmax64x64] #finds Tmax corresponding to Cmax

LatSize=[2,4,8,16,32,64] #stores lattice sizes
Tmax=[Tmax2x2,Tmax4x4,Tmax8x8,Tmax16x16,Tmax32x32,Tmax64x64] #stores corresponding Tmax data
np.savetxt('CmaxVSTmax.txt', (LatSize,Tmax)) #writes data to txt file

ScalData=np.loadtxt('CmaxVSTmax.txt') #loads data
LatticeSize=ScalData[0] #gets lattice sizes
TempMax=ScalData[1] #gets max temp or curie temp for each lattice

Lmin1min = np.min(np.divide(1,LatticeSize)) #minimum of 1/LatticeSize values
Lmin1max = np.max(np.divide(1,LatticeSize)) #maximum of 1/LatticeSize values

fitTcl = np.polyfit(np.divide(1,LatticeSize),TempMax, 1) #creates fit object

Lmin1values = np.linspace(Lmin1min, Lmin1max, 1000) #finds 1000 values between min and max x-axis value of 1/LatticeSize
fitted_Tcl_values = np.polyval(fitTcl, Lmin1values) #creates corresponding Curie Temp values for each value in Lmin1values

fig = pl.figure()
scalrelax = fig.add_subplot(1,1,1)
scalrelax.set_xlabel('1/Lattice Size')
scalrelax.set_ylabel('Curie Temperature/ J/k_B')
scalrelax.plot(np.divide(1,LatticeSize),TempMax,color='black',marker='.',linestyle='') #plots Curie Temp against 1/LatticeSize
scalrelax.plot(Lmin1values,fitted_Tcl_values,color='red',marker='',linestyle='-') #plots line of best fit for data above
pl.savefig('CurieTemp.png', bbox_inches='tight') #saves figure
pl.show()

</pre>

== References ==

Rep:Y3CMPCG1417

2019-11-20T10:11:20Z

Cg1417: /* TASK: Use the script ILtimetrial.py to record how long your current version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error...

==Section 1 - Introduction to the Ising Model==

===TASK: Show that the lowest possible energy for the Ising model is <math>E = -DNJ</math>, where D is the number of dimensions and N is the total number of spins. What is the multiplicity of this state? Calculate its entropy.===

Consider a 1D row of lattice sites of N=3 with spin configuration [+1][+1][+1].

Mathematically the interaction energy is defined asː
<math> -\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} </math> where J is a constant and <math>s_{i}s_{j}</math> is the product between two spins in adjacent lattice sites.

The sum of the interaction energies <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j}</math> can be considered as the sum of the individual interaction energies between spinsː
<math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = \epsilon_{12} + \epsilon_{23} + \epsilon_{13} + \epsilon_{21} + \epsilon_{32} + \epsilon_{31} </math>.

Although lattice sites 1 and 3 are not adjacent they are said to still interact according to the periodic boundary conditions applied.

However, <math>\epsilon_{12} = \epsilon_{21} </math> and <math>\epsilon_{23} = \epsilon_{32}</math> and <math>\epsilon_{13} = \epsilon_{31}</math> which means that all of the interactions within the system are counted twice, hence the total energy needs to be halved, resulting in the following formula being obtainedː <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = 2\epsilon_{12} + 2\epsilon_{13} + 2\epsilon_{23} </math>.

It can be determined that <math>\epsilon_{12} = (+1)(+1) = 1</math> , <math>\epsilon_{13} = (+1)(+1) = 1</math> and <math>\epsilon_{23} = (+1)(+1) = 1</math>.

Thereforeː <math>-\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = -\frac{1}{2} \ J \ (2 + 2 + 2) = -\frac{1}{2} \ J \ 6 = - 3 J = -DNJ</math> for a 1D lattice with <math>D=1</math> and 3 lattice sites <math>N=3</math>

The multiplicity of the system,<math>\Omega = \frac{lattice sites!}{n. spin up!n. spin down!}</math>

Entropy, <math>S</math> is defined as <math>S = k_B ln(\Omega)</math> and so in this case <math>S = k_B ln(\frac{100!}{100!}) = 0</math>

===TASK: Imagine that the system is in the lowest energy configuration. To move to a different state, one of the spins must spontaneously change direction ("flip"). What is the change in energy if this happens <math>(D=3, N=1000)</math>? How much entropy does the system gain by doing soʔ===

In a 3D lattice system, each lattice site has three unique interactions with its neighbours to its left, top and front. In the lowest energy configuration, all spins are parallel and for a system the minimum energy is <math>E = -DNJ</math>, so for the system with <math>N=1000</math> and <math>D=3</math>, the minimum energy is <math>-3000J</math>.

If a single spin is flipped, the product of its spin with its neighbours spin reverses and becomes negative and this increases the total energy of the system. Since 3 unique spin-spin interactions are reversed in sign, the total energy increases by <math>+3J</math>, meaning the new total energy is <math>-2997J</math>

Initially the multiplicity of the system will be <math>\Omega = \frac{1000!}{1000!}</math> , and after the flip, the multiplicity becomes <math> \Omega = \frac{1000!}{999!1!}=1000</math>.

The associated change in entropy, <math>\Delta S = k_B ln(1000) - 0 = 6.91 k_B</math>, which is an expected increase in entropy as the number of possible configurations of the system increases.

===TASK: Calculate the magnetisation of the 1D and 2D lattices in Figure 1. What magnetisation would you expect to observe for an Ising lattice with <math>D = 3,\ N=1000</math> at absolute zero?===

[[File:ThirdYearCMPExpt-IsingSketch.png|thumb|left|Figure 1 - Shows 1D (N = 5), 2D (N = 5x5) and 3D (N = 5x5x5) lattices.]]

Magnetisation is defined as <math>M=\sum_{i} s_i</math>. So for the 1D lattice with <math>N = 5</math> in ''Figure 2'', <math>M = +1</math> and for the 2D lattice with <math>N = 25 , M = +1</math> too.

According to the 3rd Law of thermodynamics, entropy is 0 at absolute zero for a perfect crystalline solid, and consequently it is expected that the lattices will have follow suit and have zero entropy at 0K. To have zero entropy all spins must be parallel as such that magnetisation, <math>M = N</math>. For all the spins to be parallel, there is only one possible configuration. So, for a lattice with <math>N = 1000</math> and <math>D =3</math>, if <math>M = N</math>, then multiplicity, <math>\Omega = 1</math> and entropy, <math>S =k_B ln(1) = 0</math>.

 

==Section 2 - Calculating the Energy and Magnetisation==

===TASK: complete the functions energy() and magnetisation(), which should return the energy of the lattice and the total magnetisation, respectively. In the energy() function you may assume that <math>J=1.0</math> at all times (in fact, we are working in reduced units in which <math>J=k_B</math>, but there will be more information about this in later sections). Do not worry about the efficiency of the code at the moment — we will address the speed in a later part of the experiment.===

<pre>def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
lat=self.lattice #creates lattice and stores it
mag=[]
for i in range(0,len(lat)): #loops through all rows of lattice
for j in range(0,len(lat[i])): #loops through elements of each row
mag+=[lat[i][j]] #adds spin value to mag array
return sum(mag) #sums all spins from mag array
</pre>

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

lat=self.lattice #creates lattice and stores it
left=[]
top=[]

for i in range(0,len(lat)):
for j in range(0,len(lat[i])):
left+=[lat[i][j]*lat[i][j-1]] #multiplies spin by spin to left
top+=[lat[i][j]*lat[i-1][j]] #multiplies spin by spin above it
int_en=left+top #sums spin products from left and top
energy=-sum(int_en) #sums all spin products for each spin to give total

return energy
</pre>

===TASK: Run the ILcheck.py script from the IPython Qt console using the command===

''Figure 2'' shows the results when ILcheck.py was ran on my IsingLattice.py file. The ILcheck.py file was ran several times to ensure the code worked for various random lattices.

[[File:Cg1417ILcheck run.png|thumb|left|500px| Figure 2 - Result from running the ILcheck.py file]]

 

==Section 3 - Introduction to Monte Carlo Simulation==

===TASK: How many configurations are available to a system with 100 spins? To evaluate these expressions, we have to calculate the energy and magnetisation for each of these configurations, then perform the sum. Let's be very, very, generous, and say that we can analyse <math>1\times 10^9</math> configurations per second with our computer. How long will it take to evaluate a single value of <math>\left\langle M\right\rangle_T</math>?===

For a system with 100 lattice sites and two possible spins for each site, there are <math>2^{100}</math>possible configurations for the system. <math>2^{100}= 1.27\times 10^{30} </math>, so if the computer can analyse <math>1\times 10^9</math> configurations per second, then it will take <math>\frac{1.27\times 10^{30}}{10^9} = 1.27\times 10^{21} s</math> to analyse the whole system, which is longer than the age of the universe and therefore is not a practical approach.

===TASK: Implement a single cycle of the above algorithm in the montecarlocycle(T) function. This function should return the energy of your lattice and the magnetisation at the end of the cycle. You may assume that the energy returned by your energy() function is in units of <math>k_B</math>! Complete the statistics() function. This should return the following quantities whenever it is called: <math><E>, <E^2>, <M>, <M^2></math>, and the number of Monte Carlo steps that have elapsed.===
<pre>
E = []
E2 = []
M = []
M2 = []
n_cycles = 0

def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back if rejected else not changed

self.E+=[self.energy()] #records energy
self.E2+=[self.energy()**2] #records energy squared
self.M+=[self.magnetisation()] #records magnetisation
self.M2+=[self.magnetisation()**2] #records magnetisation squared
self.n_cycles=self.n_cycles+1 #adds 1 to run total

return (self.energy(),self.magnetisation())

def statistics(self):
# complete this function so that it calculates the correct values for the averages of E, E*E (E2), M, M*M (M2), and returns them

e=np.mean(self.E)
e2=np.mean(self.E2)
m=np.mean(self.M)
m2=np.mean(self.M2)

return e,e2,m,m2,self.n_cycles
</pre>

''Figure 3'' shows the results of a single run of the montecarlostep() function and the lattice the function operated upon.

[[File:cg1417MonteCarloStep_run.png|thumb|left|Figure 3 - Results from a single montecarlostep() function and the resulting lattice produced along with the correct return from the statistics() function]]

 

===TASK: If <math>T < T_C</math>, do you expect a spontaneous magnetisation (i.e. do you expect <math>\left\langle M\right\rangle \neq 0</math>)? When the state of the simulation appears to stop changing (when you have reached an equilibrium state), use the controls to export the output to PNG and attach this to your report. You should also include the output from your statistics() function.===

If the temperature of the system is less than the Curie Temperature, <math>T_C</math> then spontaneous magnetisation can occur and the system will tend to its lowest energy state where all of the spins are parallel - this is a property of ferromagnetic materials.

[[File:Cg1417ILanim_run.png|400px|thumb|left|Figure 4 - Results from running the ILanim.py file - shows the energy and magnetisation converging over time]]

''Figure 4'' shows that over time the the system spontaneously converges to the minimum energy state with all of the spins parallel to one another and shows, as I expected, that spontaneous magnetisation occurs and also shows that the temperature of this simulation is below the Curie Temperature, <math>T < T_C</math>.

 

==Section 4 - Accelerating the Code==

===TASK: Use the script ILtimetrial.py to record how long your current version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 5'' show the results of running the ILtimetrial.py file on my code three timesː

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1.png
| width1=500
| image2=cg1417ILtimetrial_run2.png
| width2=500
| image3=cg1417ILtimetrial_run3.png
| width3=500
| footer = Figure 5 - Results of running the ILtimetrial.py file on my code three separate times
}}
 

This gave me an avergage time of <math>24.3 s \pm 0.2s</math>

===TASK: Look at the documentation for the NumPy sum function. You should be able to modify your magnetisation() function so that it uses this to evaluate M. The energy is a little trickier. Familiarise yourself with the NumPy roll and multiply functions, and use these to replace your energy double loop (you will need to call roll and multiply twice!).===

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

left=multiply(roll(self.lattice,1,axis=1),self.lattice) #product of spin with spin left of it
top=multiply(roll(self.lattice,-1,axis=0),self.lattice) #product of spin with spin above it

int_en=sum(left+top) #sum of array containing sum of left and top spin products for each spin

energy = -sum(int_en) #calculates the total energy of system
return energy

def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
return sum(sum(self.lattice)) #adds up all spins in lattice
</pre>

===TASK: Use the script ILtimetrial.py to record how long your new version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 5'' shows the result of running the ILtimetrial.py on my new accelerated code.

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1fast.png
| width1=500
| image2=ILtimetrial_run2fast.png
| width2=500
| image3=ILtimetrial_run3fast.png
| width3=500
| footer = Figure 5 - Results of running the ILtimetrial.py file on my new updated and accelerated code.
}}
 

The accelerated code is much faster upon using the roll, multiply and sum modules with a new average time of <math>0.790 s \pm 0.005 </math>

==Section 5 - The effect of temperature==

===TASK: The script ILfinalframe.py runs for a given number of cycles at a given temperature, then plots a depiction of the final lattice state as well as graphs of the energy and magnetisation as a function of cycle number. This is much quicker than animating every frame! Experiment with different temperature and lattice sizes. How many cycles are typically needed for the system to go from its random starting position to the equilibrium state? Modify your statistics() and montecarlostep() functions so that the first N cycles of the simulation are ignored when calculating the averages. You should state in your report what period you chose to ignore, and include graphs from ILfinalframe.py to illustrate your motivation in choosing this figure.===

''Figure 6'' below shows the results from running the ILfinalframe.py for 2x2 lattice at T=1,2,3,5.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2T1.png
| image2 = cg14172x2T2.png
| image3 =cg14172x2T3.png
| image4 =cg14172x2T5.png
| footer_align = left
| footer = Figure 6 - Results of running the ILfinalframe.py file at T=1,2,3,5 for a 2x2 matrix.
}}

 

For a 2x2 matrix, a suitable cut-off point to exclude from the avergage energies and magnetisations is where the energy and magnetisations per spin are constant, which is 30 steps. For T=3 and T=5 the graphs do not converge because it is possible that these temperatures are higher than the Curie Temperature and as such spontaneous magnetisation will not occur and the system will not diverge to the lowest energy state. At the higher temperatures, there are larger thermal fluctations and the Boltzmann factor is more significant allowing the system to move away from the lowest energy state easier. As a result moving forwards, a suitable cut-off point will only be determined from T=1 and T=2 graphs for the larger matrices.

''Figure 7'' shows the results from running a 4x4 lattice at T=1,2 and 3.

{{multiple image
| width =350
| align = left
| image1 = cg14174x4T1.png
| image2 = cg14174x4T2.png
| image3 =cg14174x4T3.png
| footer_align = left
| footer = Figure 7 - Results of running the ILfinalframe.py file at T=1,2,3 for a 4x4 matrix.
}}

From ''Figure 7'', a suitable cut-off point for the energy and magnetisations is 200 as this is after where the energy and magnetisation has converged for T=1, and is after the initial large drop in energy for T=2, even though there are a few small fluctuations after 200 steps. The result from T=3 has been included to show the large fluctuations for the larger temperatures, and supporting my choice to determine the cut-off from T=1 and T=2 only.

''Figure 8'' shows the results for an 8x8 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg14178x8T1.png
| image2 = cg14178x8T2.png
| footer_align = left
| footer = Figure 8 - Results of running the ILfinalframe.py file at T=1,2 for an 8x8 matrix
}}

From ''Figure 8'' above, a suitable cut-off point is 1000 steps as this is where the energy and magnetisation has easily converged by and is also the point after which the initial large drop in energy has been overcome for T=2 too.

''Figure 9'' shows the result of running the ILfinalframe.py for a 16x16 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg141716x16T1.png
| image2 = cg141716x16T2.png
| footer_align = left
| footer = Figure 9 - Results of running the ILfinalframe.py file at T=1,2 for a 16x16 matrix
}}

From ''Figure 9'', a suitable cut-off point is 15000 steps as for T=1 the energy and magnetisations have converged significantly and will not change much, and likewise this is the same for the T=2 frame.

''Figure 10'' below shows the results from a 32x32 matrix at T=1 and T=2.

{{multiple image
| width =350
| align = left
| image1 = cg141732x32T1.png
| image2 = cg141732x32T2.png
| footer_align = left
| footer = Figure 10 - Results of running the ILfinalframe.py file at T=1,2 for a 32x32 matrix
}}

''Figure 10'' above shows the results of running the ILfinalframe.py file for a 32x32 matrix at T=1 and T=2. As a result a suitable cut-off of 50000 steps was chosen as the energy and magnetisation has significantly converged, but not as much as it could at 100000 steps. I chose a slightly lower value to ensure that the run times of my monte-carlo simulations in future tasks were not extremely time consuming.

The montecarlostep() function was changed by adding a condition that values only above the pre-determined cut-off were included when determining the average value of energy; energy squared; magnetisation and magnetisations squared from the statistics function. The statistics() function did not need to be modified.

The following code is from the 32x32 matrixː

<pre>def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back

if self.n_cycles > 50000: #only adds values to array of E,E2,M and M2 is above specific cut-off
self.E+=[self.energy()]
self.E2+=[self.energy()**2]
self.M+=[self.magnetisation()]
self.M2+=[self.magnetisation()**2]
self.n_cycles=self.n_cycles+1

return (self.energy(),self.magnetisation())
</pre>

===TASK: Use ILtemperaturerange.py to plot the average energy and magnetisation for each temperature, with error bars, for an <math>8\times 8</math> lattice. Use your intuition and results from the script ILfinalframe.py to estimate how many cycles each simulation should be. The temperature range 0.25 to 5.0 is sufficient. Use as many temperature points as you feel necessary to illustrate the trend, but do not use a temperature spacing larger than 0.5. The NumPy function savetxt() stores your array of output data on disk — you will need it later. Save the file as 8x8.dat so that you know which lattice size it came from.===

Using the modified code, the file ILtemperaturerange.py was ran on an 8x8 matrix between T=0.5 and T=5 with a step of T=0.02 for 10000 Montecarlo steps and the first 1000 steps of each temperature were excluded when calculating the averages. ''Figure 11'' shows the result of the simulation and also included error bars of standard deviation.

[[File:Cg14178x8error.png|1000px|thumb|left|Figure 11 - Graph showing average energy and average magnetisation for an 8x8 lattice with error bars between T=0.5 and T=5]]

 

Below is the source code for the script to produce the graphː

<pre>data8x8=np.loadtxt('8x8.dat') #loads data
temps8x8=data8x8[:,0] #stores temperatures
energies8x8=data8x8[:,1] #stores average energy for each T
energysq8x8=data8x8[:,2] #stores average energy squared for each T
mag8x8=data8x8[:,3] #stores magnetisation for each T
magsq8x8=data8x8[:,4] #stores magnetisation squared for each T
stde8x8=data8x8[:,5] #edited ILtemperaturerange.py to record the standard deviation of the energy for each T
stdm8x8=data8x8[:,6] #edited ILtemperaturerange.py to record the standard deviation of the magnetisation for each T

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.errorbar(temps8x8, np.array(energies8x8)/64,yerr=np.divide(stde8x8,64),color='black',ecolor='teal',alpha=0.8) #plots energy per spin against T
magax.errorbar(temps8x8, np.array(mag8x8)/64,yerr=np.divide(stdm8x8,64),alpha=0.8,ecolor='salmon',color='black') #plots magnetisation per spin against T on separate graph
pl.savefig('8x8error.png',bbox_inches='tight') #saves figure
pl.show()

</pre>

==Section 6 - The effect of system size==

===TASK: Repeat the final task of the previous section for the following lattice sizes: 2x2, 4x4, 8x8, 16x16, 32x32. Make sure that you name each datafile that your produce after the corresponding lattice size! Write a Python script to make a plot showing the energy per spin versus temperature for each of your lattice sizes. Hint: the NumPy loadtxt function is the reverse of the savetxt function, and can be used to read your previously saved files into the script. Repeat this for the magnetisation. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. How big a lattice do you think is big enough to capture the long range fluctuations?===

The python script for this section is identical as for the 8x8 graph above in Figure 11 with the relevant files and variables changed accordingly.

Each matrix was simulated using the ILtemperaturerange.py file between T=0.5 and T=5 with a step of T=0.02.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2error.png
| caption1 = 2x2 matrix - 5000 steps, cut-off = 30 steps
| image2 = 4x4error.png
| caption2 = 4x4 matrix - 1000 steps, cut-off = 200 steps
| image3 =cg141716x16error.png
| caption3 = 16x16 matrix - 50000 steps, cut-off = 15000 steps
| image4 =cg141732x32error.png
| caption4 = 32x32 matrix - 200000 steps, cut-off = 50000 steps
| footer_align = left
| footer = Figure 12 - Results of running the ILtemperaturerange.py file for 2x2, 4x4, 16x16 and 32x32 matrices.
}}

 

==Section 7 - Determining the Heat Capacity==

===TASK: By definition, <math>C = \frac{\partial \left\langle E\right\rangle}{\partial T}</math>. From this, show that <math>C = \frac{\mathrm{Var}[E]}{k_B T^2}</math> (Where <math>\mathrm{Var}[E]</math> is the variance in <math>E</math>.)===

Recall from statistical thermodynamics that the average energy of a system is the sum across all microstates of the probability of that microstate multiplied by the energy of that microstate, which is defined mathematically asː <math>\langle E \rangle = \sum_i p_{i}\epsilon_{i}</math>.

The partition function <math>q</math> is defined as <math>q = \sum_{i} exp(-\beta \epsilon_{i})</math> where <math>\beta =\frac{1}{k_BT}</math>and the probability, <math>p_{i}</math> can be defined in terms of the partition function as <math>p_{i} = \frac{exp(-\beta \epsilon_{i})}{\sum_{i} exp(-\beta \epsilon_{i})} = \frac{exp(-\beta \epsilon_{i})}{q}</math>.

As a result, <math>\langle E \rangle</math> can be re-written as <math>\langle E \rangle = \sum_{i} \frac{\epsilon_{i} exp(-\beta \epsilon_{i})}{q} = -\frac{1}{q} \frac{\partial}{\partial \beta}\sum_{i}exp(-\beta \epsilon_{i}) = -\frac{1}{q} \frac{\partial q}{\partial \beta}</math>

Likewise, <math>\langle E^2 \rangle = \sum_i p_{i}\epsilon_{i}^{2} = \sum_{i} \frac{\epsilon_{i}^{2}exp(-\beta \epsilon_{i})}{q} = \frac{1}{q} \frac{\partial^{2}}{\partial \beta^{2}}\sum_{i}exp(-\beta \epsilon_{i}) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}}</math>

From definitionː <math>Var[E] = \Delta E^2 = \langle E^2 \rangle - \langle E \rangle^2 </math>

When the definition of <math>\langle E \rangle</math> and <math>\langle E^2 \rangle</math> is written in terms of partition function <math>q</math>ː <math>Var[E] = \langle E^2 \rangle - \langle E \rangle^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \left(\frac{1}{q}\frac{\partial q}{\partial \beta}\right)^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2</math>.

According to the chain ruleː <math>\frac{\partial}{\partial \beta}\left(\frac{1}{q} \frac{\partial q}{\partial \beta}\right) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2 = -\frac{\partial}{\partial \beta}\langle E \rangle = Var[E]</math>

And using the chain rule againː <math>C = \frac{\partial \langle E \rangle}{\partial T}= \left(-\frac{\partial \langle E \rangle}{\partial \beta}\right) \left(-\frac{\partial \beta}{\partial T}\right) = \frac{Var[E]}{k_B T^2}</math>

===TASK: Write a Python script to make a plot showing the heat capacity versus temperature for each of your lattice sizes from the previous section. You may need to do some research to recall the connection between the variance of a variable, <math>\mathrm{Var}[X]</math>, the mean of its square <math>\left\langle X^2\right\rangle</math>, and its squared mean <math>\left\langle X\right\rangle^2</math>. You may find that the data around the peak is very noisy — this is normal, and is a result of being in the critical region. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. ===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb

{{multiple image
| width =300
| align = left
| image1 = cg14172x2heatcap.png
| caption1 = 2x2 Matrix
| image2 = cg14174x4heatcap.png
| caption2 = 4x4 Matrix
| image3 =cg14178x8heatcap.png
| caption3 = 8x8 Matrix
| image4 =cg141716x16heatcap.png
| caption4 = 16x16 Matrix
| image5=cg141732x32heatcap.png
| caption5= 32x32 Matrix
| footer = Figure 13 - Graphs showing Heat Capacity against Temperature for each matrix size
}}

Here is the source code to produce the figuresː
<pre> def heatCap(energies,energysq,T,latsize):
#defines the heat capacity for a given temperature
energiesq=np.multiply(energies,energies) #creates array of (average energies) squared
varE=np.subtract(energysq,energiesq) #defines variance of average energy
tempsq=np.multiply(T,T) #array of temperature squared
return np.array(np.divide(varE,tempsq))/(latsize**2)

heatCap2x2=heatCap(energies2x2,energysq2x2,temps2x2,2) #creates array of heat capacity for each T

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(temps2x2,heatCap2x2,color='orange') #plots heat capacity for each T
pl.savefig('cg14172x2heatcap.png',bbox_inches='tight') #saves figure
pl.show()
</pre>

A general trend from the above graphs is that the peak of the graph shifts towards lower temperatures as the size of the matrix used increases.

==Section 8 - Locating the Curie Temperature==
===TASK: A C++ program has been used to run some much longer simulations than would be possible on the college computers in Python. You can view its source code here if you are interested. Each file contains six columns: <math>T, E, E^2, M, M^2, C</math> (the final five quantities are per spin), and you can read them with the NumPy loadtxt function as before. For each lattice size, plot the C++ data against your data. For one lattice size, save a PNG of this comparison and add it to your report — add a legend to the graph to label which is which. To do this, you will need to pass the label="..." keyword to the plot function, then call the legend() function of the axis object (documentation here).===

The python code used to read and plot the C++ data is found in the Jupyter notebook CG1417IsingModelGraphs.ipynb.

''Figure 14'' below shows the C++ plotted against my own data for a 16x16 Matrix.

[[File:Cg141716x16C++.png|400px|thumb|left|Figure 14 - Graph showing my own data against the C++ data for a 16x16 matrix.]]

 

Here is the source code the produce the figuresː
<pre>#fitting C++ data

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.plot(temps2x2, np.array(energies2x2)/4,color='black',alpha=0.7,label='Python Data') #python energy against T
enerax.plot(temps2x2C, energies2x2C, color='red',label='C++ Data') #C energy against T
magax.plot(temps2x2, np.array(mag2x2)/4,color='black',alpha=0.7,label='Python Data') #python magnetisation against T
magax.plot(temps2x2C, mag2x2C,color='red',label='C++ Data') #C energy against T
enerax.legend() #shows legend on energy graph
magax.legend() #shows legend on energy graph
pl.show()
</pre>

The relevant variables and dat files were changed for each matrix.

===TASK: write a script to read the data from a particular file, and plot C vs T, as well as a fitted polynomial. Try changing the degree of the polynomial to improve the fit — in general, it might be difficult to get a good fit! Attach a PNG of an example fit to your report.===

The python script to read and plot the fitted polynomial is found in CG1417PolyfitScript.ipynb

Here is the source code for ''Figure 15''

<pre>data_test = np.loadtxt("16x16C.dat")
T_test = data_test[:,0] #gets temperatures
C_test = data_test[:,5] #gets heat capacity data

#first we fit the polynomial to the data
fit_test = np.polyfit(T_test, C_test, 35) # fit a polynomial

#now we generate interpolated values of the fitted polynomial over the range of our function
T_min_test = 0.5 #np.min(T_test)
T_max_test = 5 #np.max(T_test)

T_range_test = np.linspace(T_min_test, T_max_test, 1000) #generate 1000 evenly spaced points between T_min and T_max
fitted_C_values_test = np.polyval(fit_test, T_range_test)# use the fit object to generate the corresponding values of C

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(T_test,C_test,color='orange',label='C++ Data') #plots C data of heat capacity against temp
heatcapax.plot(T_range_test,fitted_C_values_test,label='Fitted Polynomial') #plots fitted polynomial for whole range of temp
heatcapax.legend()
pl.savefig('FIT_TEST16x16_35.png', bbox_inches='tight') #saves figure
pl.show()
</pre>

Below in ''Figure 15'' is a plot of my Heat Capacity against Temperature data for a 16x16 matrix and features a polynomial of degree 35 plotted against it. Even with a polynomial of such a high degree, it poorly fits the curve and does not fit to the peak of the curve either.

[[File:cg1417FIT_TEST16x16_35.png|thumb|left|400px|Figure 15 - Plot of Heat Capacity against Temperature along with a poorly fitted polynomial of degree 35. ]]

 

===TASK: Modify your script from the previous section. You should still plot the whole temperature range, but fit the polynomial only to the peak of the heat capacity! You should find it easier to get a good fit when restricted to this region===

The script was modified as such that the polynomial was fitted in a set range around the peak of the graph, this is demonstrated in ''Figure 17'' which shows a newly fitted polynomial between a much smaller range of temperatures (T = 2.15-2.55) and a much smaller degree polynomial (3).

[[File:CG1417FIT_16x16C_3.png|thumb|left|400px|Figure 16 - Graph showing Heat Capacity against Temperature for a 16x16 matrix along with a fitted polynomial between a much more restricted range of temperatures and a significantly lower degree of polynomial]]

Upon comparison with ''Figure 15'', the new fitted polynomial is a significantly better fit even for a 3rd degree polynomial and is a much more accurate representation of my data around the peak of the graph and will make it easier to determine the maximum value of Heat Capacity.

 

Here is the source code for ''Figure 16''ː
<pre>data16 = np.loadtxt("16x16C.dat") #loads data to variable

T16 = data16[:,0] #gets temps
C16 = data16[:,5] # gets heat capacities

Tmin16 = 2.15 #chosen min temp
Tmax16 = 2.55 #chosen max temp

selection16 = np.logical_and(T16 > Tmin16, T16 < Tmax16) #choose only those rows where both conditions are true
peak_T_values16 = T16[selection16] #choose temp values in range chosen above
peak_C_values16 = C16[selection16] #choose heat cap values in range of t above

fit16 = np.polyfit(peak_T_values16,peak_C_values16,3) #fit 3rd order polynomial
peak_T_range16 = np.linspace(Tmin16, Tmax16, 1000) #defines 1000 temps within data range
fitted_C_values16 = np.polyval(fit16, peak_T_range16) #use the fit object to get corresponding values of heat cap

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(T16,C16,color='orange',label='C++ Data') #plots C data of heat cap against temp
heatcapax.plot(peak_T_range16,fitted_C_values16,label='Fitted Polynomial') #plots fitted polynomial for small range
heatcapax.legend()
pl.savefig('FIT_16x16C_3.png', bbox_inches='tight') #saves figure
pl.show()

</pre>

===TASK: find the temperature at which the maximum in C occurs for each datafile that you were given. Make a text file containing two colums: the lattice side length (2,4,8, etc.), and the temperature at which C is a maximum. This is your estimate of <math>T_C</math> for that side length. Make a plot that uses the scaling relation given above to determine <math>T_{C,\infty}</math>. By doing a little research online, you should be able to find the theoretical exact Curie temperature for the infinite 2D Ising lattice. How does your value compare to this? Are you surprised by how good/bad the agreement is? Attach a PNG of this final graph to your report, and discuss briefly what you think the major sources of error are in your estimate.===

''Figure 17'' below shows a graph of <math>T_{C,L}</math> against <math>\frac{1}{Lattice Size}</math> to determine the Curie Temperature of an infinite 2D Ising Model Lattice <math>T_{C,\infty}</math>. The black dots represent the raw data obtained from obtaining the temperature at which the Heat Capacity was a maximum for the lattices and the red line in a linear curve fit plotted against the data to allow the y-intercept which is the Curie Temperature for the infinite 2D lattice to be determined.

[[File:cg1417CurieTemp.png|400px|thumb|left|Figure 17 - Plot of 1/Lattice Size against Curie Temperature for that lattice size.]]

The value for <math>T_{C,\inf}</math> obtained from the data is <math>T_{C,\infty} = 2.277 \frac{J}{k_B}</math> with a literature value being <math>T_{C,\infty} = 2.269 \frac{J}{k_B}</math> <ref>L. Onsager, Phys. Rev., 1944, 65, 117--149.</ref>for an infinite square 2D lattice. This means that my result slightly over-estimates the Curie Temperature for the infinite lattice and as a result for an infinite lattice the temperature at which spontaneous magnetisation stops would actually occur at a slightly lower temperature than expected. However, the difference between my value and the literature value is only 0.008 which is incredibly small and the amount of agreement between the two values is somewhat surprising, which means that the error in my estimates of the Curie Temperature for each lattice size is relatively small. The points which have the largest residuals and deviation from the line of best fit in ''Figure 17'' corresponds to the smaller lattice sizes of 2x2 and 4x4 where longer range interactions are more significant. The longer range interactions posed by the boundary conditions are nowhere near as significant for the larger sizes and causes the energy of the smaller matrices to be less accurate and have a larger associated error with the energy and thus the Curie Temperature for that lattice size. This affects the accuracy of the line of best fit and to increase the accuracy of this line, larger lattice sizes of 128x128, 256x256 etc should be included in the calculation for the line of best fit and the smaller matrices ignored.

 

Below is the source code used to generate ''Figure 17''
<pre>
Cmax64x64 = np.max(fitted_C_values64) #finds Cmax for 64x64 matrix - done for others already
Tmax64x64 = peak_T_range64[fitted_C_values64 == Cmax64x64] #finds Tmax corresponding to Cmax

LatSize=[2,4,8,16,32,64] #stores lattice sizes
Tmax=[Tmax2x2,Tmax4x4,Tmax8x8,Tmax16x16,Tmax32x32,Tmax64x64] #stores corresponding Tmax data
np.savetxt('CmaxVSTmax.txt', (LatSize,Tmax)) #writes data to txt file

ScalData=np.loadtxt('CmaxVSTmax.txt') #loads data
LatticeSize=ScalData[0] #gets lattice sizes
TempMax=ScalData[1] #gets max temp or curie temp for each lattice

Lmin1min = np.min(np.divide(1,LatticeSize)) #minimum of 1/LatticeSize values
Lmin1max = np.max(np.divide(1,LatticeSize)) #maximum of 1/LatticeSize values

fitTcl = np.polyfit(np.divide(1,LatticeSize),TempMax, 1) #creates fit object

Lmin1values = np.linspace(Lmin1min, Lmin1max, 1000) #finds 1000 values between min and max x-axis value of 1/LatticeSize
fitted_Tcl_values = np.polyval(fitTcl, Lmin1values) #creates corresponding Curie Temp values for each value in Lmin1values

fig = pl.figure()
scalrelax = fig.add_subplot(1,1,1)
scalrelax.set_xlabel('1/Lattice Size')
scalrelax.set_ylabel('Curie Temperature/ J/k_B')
scalrelax.plot(np.divide(1,LatticeSize),TempMax,color='black',marker='.',linestyle='') #plots Curie Temp against 1/LatticeSize
scalrelax.plot(Lmin1values,fitted_Tcl_values,color='red',marker='',linestyle='-') #plots line of best fit for data above
pl.savefig('CurieTemp.png', bbox_inches='tight') #saves figure
pl.show()

</pre>

== References ==

Rep:Y3CMPCG1417

2019-11-20T10:10:45Z

Cg1417: /* TASK: If T , do you expect a spontaneous magnetisation (i.e. do you expect \left\langle M\right\rangle \neq 0)? When the state of the simulation appears to stop changing (when you have reached an equilibrium state), use the controls to export the ou...

==Section 1 - Introduction to the Ising Model==

===TASK: Show that the lowest possible energy for the Ising model is <math>E = -DNJ</math>, where D is the number of dimensions and N is the total number of spins. What is the multiplicity of this state? Calculate its entropy.===

Consider a 1D row of lattice sites of N=3 with spin configuration [+1][+1][+1].

Mathematically the interaction energy is defined asː
<math> -\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} </math> where J is a constant and <math>s_{i}s_{j}</math> is the product between two spins in adjacent lattice sites.

The sum of the interaction energies <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j}</math> can be considered as the sum of the individual interaction energies between spinsː
<math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = \epsilon_{12} + \epsilon_{23} + \epsilon_{13} + \epsilon_{21} + \epsilon_{32} + \epsilon_{31} </math>.

Although lattice sites 1 and 3 are not adjacent they are said to still interact according to the periodic boundary conditions applied.

However, <math>\epsilon_{12} = \epsilon_{21} </math> and <math>\epsilon_{23} = \epsilon_{32}</math> and <math>\epsilon_{13} = \epsilon_{31}</math> which means that all of the interactions within the system are counted twice, hence the total energy needs to be halved, resulting in the following formula being obtainedː <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = 2\epsilon_{12} + 2\epsilon_{13} + 2\epsilon_{23} </math>.

It can be determined that <math>\epsilon_{12} = (+1)(+1) = 1</math> , <math>\epsilon_{13} = (+1)(+1) = 1</math> and <math>\epsilon_{23} = (+1)(+1) = 1</math>.

Thereforeː <math>-\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = -\frac{1}{2} \ J \ (2 + 2 + 2) = -\frac{1}{2} \ J \ 6 = - 3 J = -DNJ</math> for a 1D lattice with <math>D=1</math> and 3 lattice sites <math>N=3</math>

The multiplicity of the system,<math>\Omega = \frac{lattice sites!}{n. spin up!n. spin down!}</math>

Entropy, <math>S</math> is defined as <math>S = k_B ln(\Omega)</math> and so in this case <math>S = k_B ln(\frac{100!}{100!}) = 0</math>

===TASK: Imagine that the system is in the lowest energy configuration. To move to a different state, one of the spins must spontaneously change direction ("flip"). What is the change in energy if this happens <math>(D=3, N=1000)</math>? How much entropy does the system gain by doing soʔ===

In a 3D lattice system, each lattice site has three unique interactions with its neighbours to its left, top and front. In the lowest energy configuration, all spins are parallel and for a system the minimum energy is <math>E = -DNJ</math>, so for the system with <math>N=1000</math> and <math>D=3</math>, the minimum energy is <math>-3000J</math>.

If a single spin is flipped, the product of its spin with its neighbours spin reverses and becomes negative and this increases the total energy of the system. Since 3 unique spin-spin interactions are reversed in sign, the total energy increases by <math>+3J</math>, meaning the new total energy is <math>-2997J</math>

Initially the multiplicity of the system will be <math>\Omega = \frac{1000!}{1000!}</math> , and after the flip, the multiplicity becomes <math> \Omega = \frac{1000!}{999!1!}=1000</math>.

The associated change in entropy, <math>\Delta S = k_B ln(1000) - 0 = 6.91 k_B</math>, which is an expected increase in entropy as the number of possible configurations of the system increases.

===TASK: Calculate the magnetisation of the 1D and 2D lattices in Figure 1. What magnetisation would you expect to observe for an Ising lattice with <math>D = 3,\ N=1000</math> at absolute zero?===

[[File:ThirdYearCMPExpt-IsingSketch.png|thumb|left|Figure 1 - Shows 1D (N = 5), 2D (N = 5x5) and 3D (N = 5x5x5) lattices.]]

Magnetisation is defined as <math>M=\sum_{i} s_i</math>. So for the 1D lattice with <math>N = 5</math> in ''Figure 2'', <math>M = +1</math> and for the 2D lattice with <math>N = 25 , M = +1</math> too.

According to the 3rd Law of thermodynamics, entropy is 0 at absolute zero for a perfect crystalline solid, and consequently it is expected that the lattices will have follow suit and have zero entropy at 0K. To have zero entropy all spins must be parallel as such that magnetisation, <math>M = N</math>. For all the spins to be parallel, there is only one possible configuration. So, for a lattice with <math>N = 1000</math> and <math>D =3</math>, if <math>M = N</math>, then multiplicity, <math>\Omega = 1</math> and entropy, <math>S =k_B ln(1) = 0</math>.

 

==Section 2 - Calculating the Energy and Magnetisation==

===TASK: complete the functions energy() and magnetisation(), which should return the energy of the lattice and the total magnetisation, respectively. In the energy() function you may assume that <math>J=1.0</math> at all times (in fact, we are working in reduced units in which <math>J=k_B</math>, but there will be more information about this in later sections). Do not worry about the efficiency of the code at the moment — we will address the speed in a later part of the experiment.===

<pre>def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
lat=self.lattice #creates lattice and stores it
mag=[]
for i in range(0,len(lat)): #loops through all rows of lattice
for j in range(0,len(lat[i])): #loops through elements of each row
mag+=[lat[i][j]] #adds spin value to mag array
return sum(mag) #sums all spins from mag array
</pre>

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

lat=self.lattice #creates lattice and stores it
left=[]
top=[]

for i in range(0,len(lat)):
for j in range(0,len(lat[i])):
left+=[lat[i][j]*lat[i][j-1]] #multiplies spin by spin to left
top+=[lat[i][j]*lat[i-1][j]] #multiplies spin by spin above it
int_en=left+top #sums spin products from left and top
energy=-sum(int_en) #sums all spin products for each spin to give total

return energy
</pre>

===TASK: Run the ILcheck.py script from the IPython Qt console using the command===

''Figure 2'' shows the results when ILcheck.py was ran on my IsingLattice.py file. The ILcheck.py file was ran several times to ensure the code worked for various random lattices.

[[File:Cg1417ILcheck run.png|thumb|left|500px| Figure 2 - Result from running the ILcheck.py file]]

 

==Section 3 - Introduction to Monte Carlo Simulation==

===TASK: How many configurations are available to a system with 100 spins? To evaluate these expressions, we have to calculate the energy and magnetisation for each of these configurations, then perform the sum. Let's be very, very, generous, and say that we can analyse <math>1\times 10^9</math> configurations per second with our computer. How long will it take to evaluate a single value of <math>\left\langle M\right\rangle_T</math>?===

For a system with 100 lattice sites and two possible spins for each site, there are <math>2^{100}</math>possible configurations for the system. <math>2^{100}= 1.27\times 10^{30} </math>, so if the computer can analyse <math>1\times 10^9</math> configurations per second, then it will take <math>\frac{1.27\times 10^{30}}{10^9} = 1.27\times 10^{21} s</math> to analyse the whole system, which is longer than the age of the universe and therefore is not a practical approach.

===TASK: Implement a single cycle of the above algorithm in the montecarlocycle(T) function. This function should return the energy of your lattice and the magnetisation at the end of the cycle. You may assume that the energy returned by your energy() function is in units of <math>k_B</math>! Complete the statistics() function. This should return the following quantities whenever it is called: <math><E>, <E^2>, <M>, <M^2></math>, and the number of Monte Carlo steps that have elapsed.===
<pre>
E = []
E2 = []
M = []
M2 = []
n_cycles = 0

def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back if rejected else not changed

self.E+=[self.energy()] #records energy
self.E2+=[self.energy()**2] #records energy squared
self.M+=[self.magnetisation()] #records magnetisation
self.M2+=[self.magnetisation()**2] #records magnetisation squared
self.n_cycles=self.n_cycles+1 #adds 1 to run total

return (self.energy(),self.magnetisation())

def statistics(self):
# complete this function so that it calculates the correct values for the averages of E, E*E (E2), M, M*M (M2), and returns them

e=np.mean(self.E)
e2=np.mean(self.E2)
m=np.mean(self.M)
m2=np.mean(self.M2)

return e,e2,m,m2,self.n_cycles
</pre>

''Figure 3'' shows the results of a single run of the montecarlostep() function and the lattice the function operated upon.

[[File:cg1417MonteCarloStep_run.png|thumb|left|Figure 3 - Results from a single montecarlostep() function and the resulting lattice produced along with the correct return from the statistics() function]]

 

===TASK: If <math>T < T_C</math>, do you expect a spontaneous magnetisation (i.e. do you expect <math>\left\langle M\right\rangle \neq 0</math>)? When the state of the simulation appears to stop changing (when you have reached an equilibrium state), use the controls to export the output to PNG and attach this to your report. You should also include the output from your statistics() function.===

If the temperature of the system is less than the Curie Temperature, <math>T_C</math> then spontaneous magnetisation can occur and the system will tend to its lowest energy state where all of the spins are parallel - this is a property of ferromagnetic materials.

[[File:Cg1417ILanim_run.png|400px|thumb|left|Figure 4 - Results from running the ILanim.py file - shows the energy and magnetisation converging over time]]

''Figure 4'' shows that over time the the system spontaneously converges to the minimum energy state with all of the spins parallel to one another and shows, as I expected, that spontaneous magnetisation occurs and also shows that the temperature of this simulation is below the Curie Temperature, <math>T < T_C</math>.

 

==Section 4 - Accelerating the Code==

===TASK: Use the script ILtimetrial.py to record how long your current version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 4'' show the results of running the ILtimetrial.py file on my code three timesː

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1.png
| width1=500
| image2=cg1417ILtimetrial_run2.png
| width2=500
| image3=cg1417ILtimetrial_run3.png
| width3=500
| footer = Figure 4 - Results of running the ILtimetrial.py file on my code three separate times
}}
 

This gave me an avergage time of <math>24.3 s \pm 0.2s</math>

===TASK: Look at the documentation for the NumPy sum function. You should be able to modify your magnetisation() function so that it uses this to evaluate M. The energy is a little trickier. Familiarise yourself with the NumPy roll and multiply functions, and use these to replace your energy double loop (you will need to call roll and multiply twice!).===

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

left=multiply(roll(self.lattice,1,axis=1),self.lattice) #product of spin with spin left of it
top=multiply(roll(self.lattice,-1,axis=0),self.lattice) #product of spin with spin above it

int_en=sum(left+top) #sum of array containing sum of left and top spin products for each spin

energy = -sum(int_en) #calculates the total energy of system
return energy

def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
return sum(sum(self.lattice)) #adds up all spins in lattice
</pre>

===TASK: Use the script ILtimetrial.py to record how long your new version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 5'' shows the result of running the ILtimetrial.py on my new accelerated code.

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1fast.png
| width1=500
| image2=ILtimetrial_run2fast.png
| width2=500
| image3=ILtimetrial_run3fast.png
| width3=500
| footer = Figure 5 - Results of running the ILtimetrial.py file on my new updated and accelerated code.
}}
 

The accelerated code is much faster upon using the roll, multiply and sum modules with a new average time of <math>0.790 s \pm 0.005 </math>

==Section 5 - The effect of temperature==

===TASK: The script ILfinalframe.py runs for a given number of cycles at a given temperature, then plots a depiction of the final lattice state as well as graphs of the energy and magnetisation as a function of cycle number. This is much quicker than animating every frame! Experiment with different temperature and lattice sizes. How many cycles are typically needed for the system to go from its random starting position to the equilibrium state? Modify your statistics() and montecarlostep() functions so that the first N cycles of the simulation are ignored when calculating the averages. You should state in your report what period you chose to ignore, and include graphs from ILfinalframe.py to illustrate your motivation in choosing this figure.===

''Figure 6'' below shows the results from running the ILfinalframe.py for 2x2 lattice at T=1,2,3,5.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2T1.png
| image2 = cg14172x2T2.png
| image3 =cg14172x2T3.png
| image4 =cg14172x2T5.png
| footer_align = left
| footer = Figure 6 - Results of running the ILfinalframe.py file at T=1,2,3,5 for a 2x2 matrix.
}}

 

For a 2x2 matrix, a suitable cut-off point to exclude from the avergage energies and magnetisations is where the energy and magnetisations per spin are constant, which is 30 steps. For T=3 and T=5 the graphs do not converge because it is possible that these temperatures are higher than the Curie Temperature and as such spontaneous magnetisation will not occur and the system will not diverge to the lowest energy state. At the higher temperatures, there are larger thermal fluctations and the Boltzmann factor is more significant allowing the system to move away from the lowest energy state easier. As a result moving forwards, a suitable cut-off point will only be determined from T=1 and T=2 graphs for the larger matrices.

''Figure 7'' shows the results from running a 4x4 lattice at T=1,2 and 3.

{{multiple image
| width =350
| align = left
| image1 = cg14174x4T1.png
| image2 = cg14174x4T2.png
| image3 =cg14174x4T3.png
| footer_align = left
| footer = Figure 7 - Results of running the ILfinalframe.py file at T=1,2,3 for a 4x4 matrix.
}}

From ''Figure 7'', a suitable cut-off point for the energy and magnetisations is 200 as this is after where the energy and magnetisation has converged for T=1, and is after the initial large drop in energy for T=2, even though there are a few small fluctuations after 200 steps. The result from T=3 has been included to show the large fluctuations for the larger temperatures, and supporting my choice to determine the cut-off from T=1 and T=2 only.

''Figure 8'' shows the results for an 8x8 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg14178x8T1.png
| image2 = cg14178x8T2.png
| footer_align = left
| footer = Figure 8 - Results of running the ILfinalframe.py file at T=1,2 for an 8x8 matrix
}}

From ''Figure 8'' above, a suitable cut-off point is 1000 steps as this is where the energy and magnetisation has easily converged by and is also the point after which the initial large drop in energy has been overcome for T=2 too.

''Figure 9'' shows the result of running the ILfinalframe.py for a 16x16 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg141716x16T1.png
| image2 = cg141716x16T2.png
| footer_align = left
| footer = Figure 9 - Results of running the ILfinalframe.py file at T=1,2 for a 16x16 matrix
}}

From ''Figure 9'', a suitable cut-off point is 15000 steps as for T=1 the energy and magnetisations have converged significantly and will not change much, and likewise this is the same for the T=2 frame.

''Figure 10'' below shows the results from a 32x32 matrix at T=1 and T=2.

{{multiple image
| width =350
| align = left
| image1 = cg141732x32T1.png
| image2 = cg141732x32T2.png
| footer_align = left
| footer = Figure 10 - Results of running the ILfinalframe.py file at T=1,2 for a 32x32 matrix
}}

''Figure 10'' above shows the results of running the ILfinalframe.py file for a 32x32 matrix at T=1 and T=2. As a result a suitable cut-off of 50000 steps was chosen as the energy and magnetisation has significantly converged, but not as much as it could at 100000 steps. I chose a slightly lower value to ensure that the run times of my monte-carlo simulations in future tasks were not extremely time consuming.

The montecarlostep() function was changed by adding a condition that values only above the pre-determined cut-off were included when determining the average value of energy; energy squared; magnetisation and magnetisations squared from the statistics function. The statistics() function did not need to be modified.

The following code is from the 32x32 matrixː

<pre>def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back

if self.n_cycles > 50000: #only adds values to array of E,E2,M and M2 is above specific cut-off
self.E+=[self.energy()]
self.E2+=[self.energy()**2]
self.M+=[self.magnetisation()]
self.M2+=[self.magnetisation()**2]
self.n_cycles=self.n_cycles+1

return (self.energy(),self.magnetisation())
</pre>

===TASK: Use ILtemperaturerange.py to plot the average energy and magnetisation for each temperature, with error bars, for an <math>8\times 8</math> lattice. Use your intuition and results from the script ILfinalframe.py to estimate how many cycles each simulation should be. The temperature range 0.25 to 5.0 is sufficient. Use as many temperature points as you feel necessary to illustrate the trend, but do not use a temperature spacing larger than 0.5. The NumPy function savetxt() stores your array of output data on disk — you will need it later. Save the file as 8x8.dat so that you know which lattice size it came from.===

Using the modified code, the file ILtemperaturerange.py was ran on an 8x8 matrix between T=0.5 and T=5 with a step of T=0.02 for 10000 Montecarlo steps and the first 1000 steps of each temperature were excluded when calculating the averages. ''Figure 11'' shows the result of the simulation and also included error bars of standard deviation.

[[File:Cg14178x8error.png|1000px|thumb|left|Figure 11 - Graph showing average energy and average magnetisation for an 8x8 lattice with error bars between T=0.5 and T=5]]

 

Below is the source code for the script to produce the graphː

<pre>data8x8=np.loadtxt('8x8.dat') #loads data
temps8x8=data8x8[:,0] #stores temperatures
energies8x8=data8x8[:,1] #stores average energy for each T
energysq8x8=data8x8[:,2] #stores average energy squared for each T
mag8x8=data8x8[:,3] #stores magnetisation for each T
magsq8x8=data8x8[:,4] #stores magnetisation squared for each T
stde8x8=data8x8[:,5] #edited ILtemperaturerange.py to record the standard deviation of the energy for each T
stdm8x8=data8x8[:,6] #edited ILtemperaturerange.py to record the standard deviation of the magnetisation for each T

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.errorbar(temps8x8, np.array(energies8x8)/64,yerr=np.divide(stde8x8,64),color='black',ecolor='teal',alpha=0.8) #plots energy per spin against T
magax.errorbar(temps8x8, np.array(mag8x8)/64,yerr=np.divide(stdm8x8,64),alpha=0.8,ecolor='salmon',color='black') #plots magnetisation per spin against T on separate graph
pl.savefig('8x8error.png',bbox_inches='tight') #saves figure
pl.show()

</pre>

==Section 6 - The effect of system size==

===TASK: Repeat the final task of the previous section for the following lattice sizes: 2x2, 4x4, 8x8, 16x16, 32x32. Make sure that you name each datafile that your produce after the corresponding lattice size! Write a Python script to make a plot showing the energy per spin versus temperature for each of your lattice sizes. Hint: the NumPy loadtxt function is the reverse of the savetxt function, and can be used to read your previously saved files into the script. Repeat this for the magnetisation. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. How big a lattice do you think is big enough to capture the long range fluctuations?===

The python script for this section is identical as for the 8x8 graph above in Figure 11 with the relevant files and variables changed accordingly.

Each matrix was simulated using the ILtemperaturerange.py file between T=0.5 and T=5 with a step of T=0.02.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2error.png
| caption1 = 2x2 matrix - 5000 steps, cut-off = 30 steps
| image2 = 4x4error.png
| caption2 = 4x4 matrix - 1000 steps, cut-off = 200 steps
| image3 =cg141716x16error.png
| caption3 = 16x16 matrix - 50000 steps, cut-off = 15000 steps
| image4 =cg141732x32error.png
| caption4 = 32x32 matrix - 200000 steps, cut-off = 50000 steps
| footer_align = left
| footer = Figure 12 - Results of running the ILtemperaturerange.py file for 2x2, 4x4, 16x16 and 32x32 matrices.
}}

 

==Section 7 - Determining the Heat Capacity==

===TASK: By definition, <math>C = \frac{\partial \left\langle E\right\rangle}{\partial T}</math>. From this, show that <math>C = \frac{\mathrm{Var}[E]}{k_B T^2}</math> (Where <math>\mathrm{Var}[E]</math> is the variance in <math>E</math>.)===

Recall from statistical thermodynamics that the average energy of a system is the sum across all microstates of the probability of that microstate multiplied by the energy of that microstate, which is defined mathematically asː <math>\langle E \rangle = \sum_i p_{i}\epsilon_{i}</math>.

The partition function <math>q</math> is defined as <math>q = \sum_{i} exp(-\beta \epsilon_{i})</math> where <math>\beta =\frac{1}{k_BT}</math>and the probability, <math>p_{i}</math> can be defined in terms of the partition function as <math>p_{i} = \frac{exp(-\beta \epsilon_{i})}{\sum_{i} exp(-\beta \epsilon_{i})} = \frac{exp(-\beta \epsilon_{i})}{q}</math>.

As a result, <math>\langle E \rangle</math> can be re-written as <math>\langle E \rangle = \sum_{i} \frac{\epsilon_{i} exp(-\beta \epsilon_{i})}{q} = -\frac{1}{q} \frac{\partial}{\partial \beta}\sum_{i}exp(-\beta \epsilon_{i}) = -\frac{1}{q} \frac{\partial q}{\partial \beta}</math>

Likewise, <math>\langle E^2 \rangle = \sum_i p_{i}\epsilon_{i}^{2} = \sum_{i} \frac{\epsilon_{i}^{2}exp(-\beta \epsilon_{i})}{q} = \frac{1}{q} \frac{\partial^{2}}{\partial \beta^{2}}\sum_{i}exp(-\beta \epsilon_{i}) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}}</math>

From definitionː <math>Var[E] = \Delta E^2 = \langle E^2 \rangle - \langle E \rangle^2 </math>

When the definition of <math>\langle E \rangle</math> and <math>\langle E^2 \rangle</math> is written in terms of partition function <math>q</math>ː <math>Var[E] = \langle E^2 \rangle - \langle E \rangle^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \left(\frac{1}{q}\frac{\partial q}{\partial \beta}\right)^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2</math>.

According to the chain ruleː <math>\frac{\partial}{\partial \beta}\left(\frac{1}{q} \frac{\partial q}{\partial \beta}\right) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2 = -\frac{\partial}{\partial \beta}\langle E \rangle = Var[E]</math>

And using the chain rule againː <math>C = \frac{\partial \langle E \rangle}{\partial T}= \left(-\frac{\partial \langle E \rangle}{\partial \beta}\right) \left(-\frac{\partial \beta}{\partial T}\right) = \frac{Var[E]}{k_B T^2}</math>

===TASK: Write a Python script to make a plot showing the heat capacity versus temperature for each of your lattice sizes from the previous section. You may need to do some research to recall the connection between the variance of a variable, <math>\mathrm{Var}[X]</math>, the mean of its square <math>\left\langle X^2\right\rangle</math>, and its squared mean <math>\left\langle X\right\rangle^2</math>. You may find that the data around the peak is very noisy — this is normal, and is a result of being in the critical region. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. ===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb

{{multiple image
| width =300
| align = left
| image1 = cg14172x2heatcap.png
| caption1 = 2x2 Matrix
| image2 = cg14174x4heatcap.png
| caption2 = 4x4 Matrix
| image3 =cg14178x8heatcap.png
| caption3 = 8x8 Matrix
| image4 =cg141716x16heatcap.png
| caption4 = 16x16 Matrix
| image5=cg141732x32heatcap.png
| caption5= 32x32 Matrix
| footer = Figure 13 - Graphs showing Heat Capacity against Temperature for each matrix size
}}

Here is the source code to produce the figuresː
<pre> def heatCap(energies,energysq,T,latsize):
#defines the heat capacity for a given temperature
energiesq=np.multiply(energies,energies) #creates array of (average energies) squared
varE=np.subtract(energysq,energiesq) #defines variance of average energy
tempsq=np.multiply(T,T) #array of temperature squared
return np.array(np.divide(varE,tempsq))/(latsize**2)

heatCap2x2=heatCap(energies2x2,energysq2x2,temps2x2,2) #creates array of heat capacity for each T

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(temps2x2,heatCap2x2,color='orange') #plots heat capacity for each T
pl.savefig('cg14172x2heatcap.png',bbox_inches='tight') #saves figure
pl.show()
</pre>

A general trend from the above graphs is that the peak of the graph shifts towards lower temperatures as the size of the matrix used increases.

==Section 8 - Locating the Curie Temperature==
===TASK: A C++ program has been used to run some much longer simulations than would be possible on the college computers in Python. You can view its source code here if you are interested. Each file contains six columns: <math>T, E, E^2, M, M^2, C</math> (the final five quantities are per spin), and you can read them with the NumPy loadtxt function as before. For each lattice size, plot the C++ data against your data. For one lattice size, save a PNG of this comparison and add it to your report — add a legend to the graph to label which is which. To do this, you will need to pass the label="..." keyword to the plot function, then call the legend() function of the axis object (documentation here).===

The python code used to read and plot the C++ data is found in the Jupyter notebook CG1417IsingModelGraphs.ipynb.

''Figure 14'' below shows the C++ plotted against my own data for a 16x16 Matrix.

[[File:Cg141716x16C++.png|400px|thumb|left|Figure 14 - Graph showing my own data against the C++ data for a 16x16 matrix.]]

 

Here is the source code the produce the figuresː
<pre>#fitting C++ data

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.plot(temps2x2, np.array(energies2x2)/4,color='black',alpha=0.7,label='Python Data') #python energy against T
enerax.plot(temps2x2C, energies2x2C, color='red',label='C++ Data') #C energy against T
magax.plot(temps2x2, np.array(mag2x2)/4,color='black',alpha=0.7,label='Python Data') #python magnetisation against T
magax.plot(temps2x2C, mag2x2C,color='red',label='C++ Data') #C energy against T
enerax.legend() #shows legend on energy graph
magax.legend() #shows legend on energy graph
pl.show()
</pre>

The relevant variables and dat files were changed for each matrix.

===TASK: write a script to read the data from a particular file, and plot C vs T, as well as a fitted polynomial. Try changing the degree of the polynomial to improve the fit — in general, it might be difficult to get a good fit! Attach a PNG of an example fit to your report.===

The python script to read and plot the fitted polynomial is found in CG1417PolyfitScript.ipynb

Here is the source code for ''Figure 15''

<pre>data_test = np.loadtxt("16x16C.dat")
T_test = data_test[:,0] #gets temperatures
C_test = data_test[:,5] #gets heat capacity data

#first we fit the polynomial to the data
fit_test = np.polyfit(T_test, C_test, 35) # fit a polynomial

#now we generate interpolated values of the fitted polynomial over the range of our function
T_min_test = 0.5 #np.min(T_test)
T_max_test = 5 #np.max(T_test)

T_range_test = np.linspace(T_min_test, T_max_test, 1000) #generate 1000 evenly spaced points between T_min and T_max
fitted_C_values_test = np.polyval(fit_test, T_range_test)# use the fit object to generate the corresponding values of C

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(T_test,C_test,color='orange',label='C++ Data') #plots C data of heat capacity against temp
heatcapax.plot(T_range_test,fitted_C_values_test,label='Fitted Polynomial') #plots fitted polynomial for whole range of temp
heatcapax.legend()
pl.savefig('FIT_TEST16x16_35.png', bbox_inches='tight') #saves figure
pl.show()
</pre>

Below in ''Figure 15'' is a plot of my Heat Capacity against Temperature data for a 16x16 matrix and features a polynomial of degree 35 plotted against it. Even with a polynomial of such a high degree, it poorly fits the curve and does not fit to the peak of the curve either.

[[File:cg1417FIT_TEST16x16_35.png|thumb|left|400px|Figure 15 - Plot of Heat Capacity against Temperature along with a poorly fitted polynomial of degree 35. ]]

 

===TASK: Modify your script from the previous section. You should still plot the whole temperature range, but fit the polynomial only to the peak of the heat capacity! You should find it easier to get a good fit when restricted to this region===

The script was modified as such that the polynomial was fitted in a set range around the peak of the graph, this is demonstrated in ''Figure 17'' which shows a newly fitted polynomial between a much smaller range of temperatures (T = 2.15-2.55) and a much smaller degree polynomial (3).

[[File:CG1417FIT_16x16C_3.png|thumb|left|400px|Figure 16 - Graph showing Heat Capacity against Temperature for a 16x16 matrix along with a fitted polynomial between a much more restricted range of temperatures and a significantly lower degree of polynomial]]

Upon comparison with ''Figure 15'', the new fitted polynomial is a significantly better fit even for a 3rd degree polynomial and is a much more accurate representation of my data around the peak of the graph and will make it easier to determine the maximum value of Heat Capacity.

 

Here is the source code for ''Figure 16''ː
<pre>data16 = np.loadtxt("16x16C.dat") #loads data to variable

T16 = data16[:,0] #gets temps
C16 = data16[:,5] # gets heat capacities

Tmin16 = 2.15 #chosen min temp
Tmax16 = 2.55 #chosen max temp

selection16 = np.logical_and(T16 > Tmin16, T16 < Tmax16) #choose only those rows where both conditions are true
peak_T_values16 = T16[selection16] #choose temp values in range chosen above
peak_C_values16 = C16[selection16] #choose heat cap values in range of t above

fit16 = np.polyfit(peak_T_values16,peak_C_values16,3) #fit 3rd order polynomial
peak_T_range16 = np.linspace(Tmin16, Tmax16, 1000) #defines 1000 temps within data range
fitted_C_values16 = np.polyval(fit16, peak_T_range16) #use the fit object to get corresponding values of heat cap

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(T16,C16,color='orange',label='C++ Data') #plots C data of heat cap against temp
heatcapax.plot(peak_T_range16,fitted_C_values16,label='Fitted Polynomial') #plots fitted polynomial for small range
heatcapax.legend()
pl.savefig('FIT_16x16C_3.png', bbox_inches='tight') #saves figure
pl.show()

</pre>

===TASK: find the temperature at which the maximum in C occurs for each datafile that you were given. Make a text file containing two colums: the lattice side length (2,4,8, etc.), and the temperature at which C is a maximum. This is your estimate of <math>T_C</math> for that side length. Make a plot that uses the scaling relation given above to determine <math>T_{C,\infty}</math>. By doing a little research online, you should be able to find the theoretical exact Curie temperature for the infinite 2D Ising lattice. How does your value compare to this? Are you surprised by how good/bad the agreement is? Attach a PNG of this final graph to your report, and discuss briefly what you think the major sources of error are in your estimate.===

''Figure 17'' below shows a graph of <math>T_{C,L}</math> against <math>\frac{1}{Lattice Size}</math> to determine the Curie Temperature of an infinite 2D Ising Model Lattice <math>T_{C,\infty}</math>. The black dots represent the raw data obtained from obtaining the temperature at which the Heat Capacity was a maximum for the lattices and the red line in a linear curve fit plotted against the data to allow the y-intercept which is the Curie Temperature for the infinite 2D lattice to be determined.

[[File:cg1417CurieTemp.png|400px|thumb|left|Figure 17 - Plot of 1/Lattice Size against Curie Temperature for that lattice size.]]

The value for <math>T_{C,\inf}</math> obtained from the data is <math>T_{C,\infty} = 2.277 \frac{J}{k_B}</math> with a literature value being <math>T_{C,\infty} = 2.269 \frac{J}{k_B}</math> <ref>L. Onsager, Phys. Rev., 1944, 65, 117--149.</ref>for an infinite square 2D lattice. This means that my result slightly over-estimates the Curie Temperature for the infinite lattice and as a result for an infinite lattice the temperature at which spontaneous magnetisation stops would actually occur at a slightly lower temperature than expected. However, the difference between my value and the literature value is only 0.008 which is incredibly small and the amount of agreement between the two values is somewhat surprising, which means that the error in my estimates of the Curie Temperature for each lattice size is relatively small. The points which have the largest residuals and deviation from the line of best fit in ''Figure 17'' corresponds to the smaller lattice sizes of 2x2 and 4x4 where longer range interactions are more significant. The longer range interactions posed by the boundary conditions are nowhere near as significant for the larger sizes and causes the energy of the smaller matrices to be less accurate and have a larger associated error with the energy and thus the Curie Temperature for that lattice size. This affects the accuracy of the line of best fit and to increase the accuracy of this line, larger lattice sizes of 128x128, 256x256 etc should be included in the calculation for the line of best fit and the smaller matrices ignored.

 

Below is the source code used to generate ''Figure 17''
<pre>
Cmax64x64 = np.max(fitted_C_values64) #finds Cmax for 64x64 matrix - done for others already
Tmax64x64 = peak_T_range64[fitted_C_values64 == Cmax64x64] #finds Tmax corresponding to Cmax

LatSize=[2,4,8,16,32,64] #stores lattice sizes
Tmax=[Tmax2x2,Tmax4x4,Tmax8x8,Tmax16x16,Tmax32x32,Tmax64x64] #stores corresponding Tmax data
np.savetxt('CmaxVSTmax.txt', (LatSize,Tmax)) #writes data to txt file

ScalData=np.loadtxt('CmaxVSTmax.txt') #loads data
LatticeSize=ScalData[0] #gets lattice sizes
TempMax=ScalData[1] #gets max temp or curie temp for each lattice

Lmin1min = np.min(np.divide(1,LatticeSize)) #minimum of 1/LatticeSize values
Lmin1max = np.max(np.divide(1,LatticeSize)) #maximum of 1/LatticeSize values

fitTcl = np.polyfit(np.divide(1,LatticeSize),TempMax, 1) #creates fit object

Lmin1values = np.linspace(Lmin1min, Lmin1max, 1000) #finds 1000 values between min and max x-axis value of 1/LatticeSize
fitted_Tcl_values = np.polyval(fitTcl, Lmin1values) #creates corresponding Curie Temp values for each value in Lmin1values

fig = pl.figure()
scalrelax = fig.add_subplot(1,1,1)
scalrelax.set_xlabel('1/Lattice Size')
scalrelax.set_ylabel('Curie Temperature/ J/k_B')
scalrelax.plot(np.divide(1,LatticeSize),TempMax,color='black',marker='.',linestyle='') #plots Curie Temp against 1/LatticeSize
scalrelax.plot(Lmin1values,fitted_Tcl_values,color='red',marker='',linestyle='-') #plots line of best fit for data above
pl.savefig('CurieTemp.png', bbox_inches='tight') #saves figure
pl.show()

</pre>

== References ==

Rep:Y3CMPCG1417

2019-11-20T10:09:55Z

Cg1417: /* TASK: Implement a single cycle of the above algorithm in the montecarlocycle(T) function. This function should return the energy of your lattice and the magnetisation at the end of the cycle. You may assume that the energy returned by your energy()...

==Section 1 - Introduction to the Ising Model==

===TASK: Show that the lowest possible energy for the Ising model is <math>E = -DNJ</math>, where D is the number of dimensions and N is the total number of spins. What is the multiplicity of this state? Calculate its entropy.===

Consider a 1D row of lattice sites of N=3 with spin configuration [+1][+1][+1].

Mathematically the interaction energy is defined asː
<math> -\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} </math> where J is a constant and <math>s_{i}s_{j}</math> is the product between two spins in adjacent lattice sites.

The sum of the interaction energies <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j}</math> can be considered as the sum of the individual interaction energies between spinsː
<math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = \epsilon_{12} + \epsilon_{23} + \epsilon_{13} + \epsilon_{21} + \epsilon_{32} + \epsilon_{31} </math>.

Although lattice sites 1 and 3 are not adjacent they are said to still interact according to the periodic boundary conditions applied.

However, <math>\epsilon_{12} = \epsilon_{21} </math> and <math>\epsilon_{23} = \epsilon_{32}</math> and <math>\epsilon_{13} = \epsilon_{31}</math> which means that all of the interactions within the system are counted twice, hence the total energy needs to be halved, resulting in the following formula being obtainedː <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = 2\epsilon_{12} + 2\epsilon_{13} + 2\epsilon_{23} </math>.

It can be determined that <math>\epsilon_{12} = (+1)(+1) = 1</math> , <math>\epsilon_{13} = (+1)(+1) = 1</math> and <math>\epsilon_{23} = (+1)(+1) = 1</math>.

Thereforeː <math>-\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = -\frac{1}{2} \ J \ (2 + 2 + 2) = -\frac{1}{2} \ J \ 6 = - 3 J = -DNJ</math> for a 1D lattice with <math>D=1</math> and 3 lattice sites <math>N=3</math>

The multiplicity of the system,<math>\Omega = \frac{lattice sites!}{n. spin up!n. spin down!}</math>

Entropy, <math>S</math> is defined as <math>S = k_B ln(\Omega)</math> and so in this case <math>S = k_B ln(\frac{100!}{100!}) = 0</math>

===TASK: Imagine that the system is in the lowest energy configuration. To move to a different state, one of the spins must spontaneously change direction ("flip"). What is the change in energy if this happens <math>(D=3, N=1000)</math>? How much entropy does the system gain by doing soʔ===

In a 3D lattice system, each lattice site has three unique interactions with its neighbours to its left, top and front. In the lowest energy configuration, all spins are parallel and for a system the minimum energy is <math>E = -DNJ</math>, so for the system with <math>N=1000</math> and <math>D=3</math>, the minimum energy is <math>-3000J</math>.

If a single spin is flipped, the product of its spin with its neighbours spin reverses and becomes negative and this increases the total energy of the system. Since 3 unique spin-spin interactions are reversed in sign, the total energy increases by <math>+3J</math>, meaning the new total energy is <math>-2997J</math>

Initially the multiplicity of the system will be <math>\Omega = \frac{1000!}{1000!}</math> , and after the flip, the multiplicity becomes <math> \Omega = \frac{1000!}{999!1!}=1000</math>.

The associated change in entropy, <math>\Delta S = k_B ln(1000) - 0 = 6.91 k_B</math>, which is an expected increase in entropy as the number of possible configurations of the system increases.

===TASK: Calculate the magnetisation of the 1D and 2D lattices in Figure 1. What magnetisation would you expect to observe for an Ising lattice with <math>D = 3,\ N=1000</math> at absolute zero?===

[[File:ThirdYearCMPExpt-IsingSketch.png|thumb|left|Figure 1 - Shows 1D (N = 5), 2D (N = 5x5) and 3D (N = 5x5x5) lattices.]]

Magnetisation is defined as <math>M=\sum_{i} s_i</math>. So for the 1D lattice with <math>N = 5</math> in ''Figure 2'', <math>M = +1</math> and for the 2D lattice with <math>N = 25 , M = +1</math> too.

According to the 3rd Law of thermodynamics, entropy is 0 at absolute zero for a perfect crystalline solid, and consequently it is expected that the lattices will have follow suit and have zero entropy at 0K. To have zero entropy all spins must be parallel as such that magnetisation, <math>M = N</math>. For all the spins to be parallel, there is only one possible configuration. So, for a lattice with <math>N = 1000</math> and <math>D =3</math>, if <math>M = N</math>, then multiplicity, <math>\Omega = 1</math> and entropy, <math>S =k_B ln(1) = 0</math>.

 

==Section 2 - Calculating the Energy and Magnetisation==

===TASK: complete the functions energy() and magnetisation(), which should return the energy of the lattice and the total magnetisation, respectively. In the energy() function you may assume that <math>J=1.0</math> at all times (in fact, we are working in reduced units in which <math>J=k_B</math>, but there will be more information about this in later sections). Do not worry about the efficiency of the code at the moment — we will address the speed in a later part of the experiment.===

<pre>def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
lat=self.lattice #creates lattice and stores it
mag=[]
for i in range(0,len(lat)): #loops through all rows of lattice
for j in range(0,len(lat[i])): #loops through elements of each row
mag+=[lat[i][j]] #adds spin value to mag array
return sum(mag) #sums all spins from mag array
</pre>

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

lat=self.lattice #creates lattice and stores it
left=[]
top=[]

for i in range(0,len(lat)):
for j in range(0,len(lat[i])):
left+=[lat[i][j]*lat[i][j-1]] #multiplies spin by spin to left
top+=[lat[i][j]*lat[i-1][j]] #multiplies spin by spin above it
int_en=left+top #sums spin products from left and top
energy=-sum(int_en) #sums all spin products for each spin to give total

return energy
</pre>

===TASK: Run the ILcheck.py script from the IPython Qt console using the command===

''Figure 2'' shows the results when ILcheck.py was ran on my IsingLattice.py file. The ILcheck.py file was ran several times to ensure the code worked for various random lattices.

[[File:Cg1417ILcheck run.png|thumb|left|500px| Figure 2 - Result from running the ILcheck.py file]]

 

==Section 3 - Introduction to Monte Carlo Simulation==

===TASK: How many configurations are available to a system with 100 spins? To evaluate these expressions, we have to calculate the energy and magnetisation for each of these configurations, then perform the sum. Let's be very, very, generous, and say that we can analyse <math>1\times 10^9</math> configurations per second with our computer. How long will it take to evaluate a single value of <math>\left\langle M\right\rangle_T</math>?===

For a system with 100 lattice sites and two possible spins for each site, there are <math>2^{100}</math>possible configurations for the system. <math>2^{100}= 1.27\times 10^{30} </math>, so if the computer can analyse <math>1\times 10^9</math> configurations per second, then it will take <math>\frac{1.27\times 10^{30}}{10^9} = 1.27\times 10^{21} s</math> to analyse the whole system, which is longer than the age of the universe and therefore is not a practical approach.

===TASK: Implement a single cycle of the above algorithm in the montecarlocycle(T) function. This function should return the energy of your lattice and the magnetisation at the end of the cycle. You may assume that the energy returned by your energy() function is in units of <math>k_B</math>! Complete the statistics() function. This should return the following quantities whenever it is called: <math><E>, <E^2>, <M>, <M^2></math>, and the number of Monte Carlo steps that have elapsed.===
<pre>
E = []
E2 = []
M = []
M2 = []
n_cycles = 0

def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back if rejected else not changed

self.E+=[self.energy()] #records energy
self.E2+=[self.energy()**2] #records energy squared
self.M+=[self.magnetisation()] #records magnetisation
self.M2+=[self.magnetisation()**2] #records magnetisation squared
self.n_cycles=self.n_cycles+1 #adds 1 to run total

return (self.energy(),self.magnetisation())

def statistics(self):
# complete this function so that it calculates the correct values for the averages of E, E*E (E2), M, M*M (M2), and returns them

e=np.mean(self.E)
e2=np.mean(self.E2)
m=np.mean(self.M)
m2=np.mean(self.M2)

return e,e2,m,m2,self.n_cycles
</pre>

''Figure 3'' shows the results of a single run of the montecarlostep() function and the lattice the function operated upon.

[[File:cg1417MonteCarloStep_run.png|thumb|left|Figure 3 - Results from a single montecarlostep() function and the resulting lattice produced along with the correct return from the statistics() function]]

 

===TASK: If <math>T < T_C</math>, do you expect a spontaneous magnetisation (i.e. do you expect <math>\left\langle M\right\rangle \neq 0</math>)? When the state of the simulation appears to stop changing (when you have reached an equilibrium state), use the controls to export the output to PNG and attach this to your report. You should also include the output from your statistics() function.===

If the temperature of the system is less than the Curie Temperature, <math>T_C</math> then spontaneous magnetisation can occur and the system will tend to its lowest energy state where all of the spins are parallel - this is a property of ferromagnetic materials.

[[File:Cg1417ILanim_run.png|400px|thumb|left|Figure 3 - Results from running the ILanim.py file - shows the energy and magnetisation converging over time]]

''Figure 3'' shows that over time the the system spontaneously converges to the minimum energy state with all of the spins parallel to one another and shows, as I expected, that spontaneous magnetisation occurs and also shows that the temperature of this simulation is below the Curie Temperature, <math>T < T_C</math>.

 

==Section 4 - Accelerating the Code==

===TASK: Use the script ILtimetrial.py to record how long your current version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 4'' show the results of running the ILtimetrial.py file on my code three timesː

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1.png
| width1=500
| image2=cg1417ILtimetrial_run2.png
| width2=500
| image3=cg1417ILtimetrial_run3.png
| width3=500
| footer = Figure 4 - Results of running the ILtimetrial.py file on my code three separate times
}}
 

This gave me an avergage time of <math>24.3 s \pm 0.2s</math>

===TASK: Look at the documentation for the NumPy sum function. You should be able to modify your magnetisation() function so that it uses this to evaluate M. The energy is a little trickier. Familiarise yourself with the NumPy roll and multiply functions, and use these to replace your energy double loop (you will need to call roll and multiply twice!).===

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

left=multiply(roll(self.lattice,1,axis=1),self.lattice) #product of spin with spin left of it
top=multiply(roll(self.lattice,-1,axis=0),self.lattice) #product of spin with spin above it

int_en=sum(left+top) #sum of array containing sum of left and top spin products for each spin

energy = -sum(int_en) #calculates the total energy of system
return energy

def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
return sum(sum(self.lattice)) #adds up all spins in lattice
</pre>

===TASK: Use the script ILtimetrial.py to record how long your new version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 5'' shows the result of running the ILtimetrial.py on my new accelerated code.

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1fast.png
| width1=500
| image2=ILtimetrial_run2fast.png
| width2=500
| image3=ILtimetrial_run3fast.png
| width3=500
| footer = Figure 5 - Results of running the ILtimetrial.py file on my new updated and accelerated code.
}}
 

The accelerated code is much faster upon using the roll, multiply and sum modules with a new average time of <math>0.790 s \pm 0.005 </math>

==Section 5 - The effect of temperature==

===TASK: The script ILfinalframe.py runs for a given number of cycles at a given temperature, then plots a depiction of the final lattice state as well as graphs of the energy and magnetisation as a function of cycle number. This is much quicker than animating every frame! Experiment with different temperature and lattice sizes. How many cycles are typically needed for the system to go from its random starting position to the equilibrium state? Modify your statistics() and montecarlostep() functions so that the first N cycles of the simulation are ignored when calculating the averages. You should state in your report what period you chose to ignore, and include graphs from ILfinalframe.py to illustrate your motivation in choosing this figure.===

''Figure 6'' below shows the results from running the ILfinalframe.py for 2x2 lattice at T=1,2,3,5.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2T1.png
| image2 = cg14172x2T2.png
| image3 =cg14172x2T3.png
| image4 =cg14172x2T5.png
| footer_align = left
| footer = Figure 6 - Results of running the ILfinalframe.py file at T=1,2,3,5 for a 2x2 matrix.
}}

 

For a 2x2 matrix, a suitable cut-off point to exclude from the avergage energies and magnetisations is where the energy and magnetisations per spin are constant, which is 30 steps. For T=3 and T=5 the graphs do not converge because it is possible that these temperatures are higher than the Curie Temperature and as such spontaneous magnetisation will not occur and the system will not diverge to the lowest energy state. At the higher temperatures, there are larger thermal fluctations and the Boltzmann factor is more significant allowing the system to move away from the lowest energy state easier. As a result moving forwards, a suitable cut-off point will only be determined from T=1 and T=2 graphs for the larger matrices.

''Figure 7'' shows the results from running a 4x4 lattice at T=1,2 and 3.

{{multiple image
| width =350
| align = left
| image1 = cg14174x4T1.png
| image2 = cg14174x4T2.png
| image3 =cg14174x4T3.png
| footer_align = left
| footer = Figure 7 - Results of running the ILfinalframe.py file at T=1,2,3 for a 4x4 matrix.
}}

From ''Figure 7'', a suitable cut-off point for the energy and magnetisations is 200 as this is after where the energy and magnetisation has converged for T=1, and is after the initial large drop in energy for T=2, even though there are a few small fluctuations after 200 steps. The result from T=3 has been included to show the large fluctuations for the larger temperatures, and supporting my choice to determine the cut-off from T=1 and T=2 only.

''Figure 8'' shows the results for an 8x8 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg14178x8T1.png
| image2 = cg14178x8T2.png
| footer_align = left
| footer = Figure 8 - Results of running the ILfinalframe.py file at T=1,2 for an 8x8 matrix
}}

From ''Figure 8'' above, a suitable cut-off point is 1000 steps as this is where the energy and magnetisation has easily converged by and is also the point after which the initial large drop in energy has been overcome for T=2 too.

''Figure 9'' shows the result of running the ILfinalframe.py for a 16x16 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg141716x16T1.png
| image2 = cg141716x16T2.png
| footer_align = left
| footer = Figure 9 - Results of running the ILfinalframe.py file at T=1,2 for a 16x16 matrix
}}

From ''Figure 9'', a suitable cut-off point is 15000 steps as for T=1 the energy and magnetisations have converged significantly and will not change much, and likewise this is the same for the T=2 frame.

''Figure 10'' below shows the results from a 32x32 matrix at T=1 and T=2.

{{multiple image
| width =350
| align = left
| image1 = cg141732x32T1.png
| image2 = cg141732x32T2.png
| footer_align = left
| footer = Figure 10 - Results of running the ILfinalframe.py file at T=1,2 for a 32x32 matrix
}}

''Figure 10'' above shows the results of running the ILfinalframe.py file for a 32x32 matrix at T=1 and T=2. As a result a suitable cut-off of 50000 steps was chosen as the energy and magnetisation has significantly converged, but not as much as it could at 100000 steps. I chose a slightly lower value to ensure that the run times of my monte-carlo simulations in future tasks were not extremely time consuming.

The montecarlostep() function was changed by adding a condition that values only above the pre-determined cut-off were included when determining the average value of energy; energy squared; magnetisation and magnetisations squared from the statistics function. The statistics() function did not need to be modified.

The following code is from the 32x32 matrixː

<pre>def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back

if self.n_cycles > 50000: #only adds values to array of E,E2,M and M2 is above specific cut-off
self.E+=[self.energy()]
self.E2+=[self.energy()**2]
self.M+=[self.magnetisation()]
self.M2+=[self.magnetisation()**2]
self.n_cycles=self.n_cycles+1

return (self.energy(),self.magnetisation())
</pre>

===TASK: Use ILtemperaturerange.py to plot the average energy and magnetisation for each temperature, with error bars, for an <math>8\times 8</math> lattice. Use your intuition and results from the script ILfinalframe.py to estimate how many cycles each simulation should be. The temperature range 0.25 to 5.0 is sufficient. Use as many temperature points as you feel necessary to illustrate the trend, but do not use a temperature spacing larger than 0.5. The NumPy function savetxt() stores your array of output data on disk — you will need it later. Save the file as 8x8.dat so that you know which lattice size it came from.===

Using the modified code, the file ILtemperaturerange.py was ran on an 8x8 matrix between T=0.5 and T=5 with a step of T=0.02 for 10000 Montecarlo steps and the first 1000 steps of each temperature were excluded when calculating the averages. ''Figure 11'' shows the result of the simulation and also included error bars of standard deviation.

[[File:Cg14178x8error.png|1000px|thumb|left|Figure 11 - Graph showing average energy and average magnetisation for an 8x8 lattice with error bars between T=0.5 and T=5]]

 

Below is the source code for the script to produce the graphː

<pre>data8x8=np.loadtxt('8x8.dat') #loads data
temps8x8=data8x8[:,0] #stores temperatures
energies8x8=data8x8[:,1] #stores average energy for each T
energysq8x8=data8x8[:,2] #stores average energy squared for each T
mag8x8=data8x8[:,3] #stores magnetisation for each T
magsq8x8=data8x8[:,4] #stores magnetisation squared for each T
stde8x8=data8x8[:,5] #edited ILtemperaturerange.py to record the standard deviation of the energy for each T
stdm8x8=data8x8[:,6] #edited ILtemperaturerange.py to record the standard deviation of the magnetisation for each T

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.errorbar(temps8x8, np.array(energies8x8)/64,yerr=np.divide(stde8x8,64),color='black',ecolor='teal',alpha=0.8) #plots energy per spin against T
magax.errorbar(temps8x8, np.array(mag8x8)/64,yerr=np.divide(stdm8x8,64),alpha=0.8,ecolor='salmon',color='black') #plots magnetisation per spin against T on separate graph
pl.savefig('8x8error.png',bbox_inches='tight') #saves figure
pl.show()

</pre>

==Section 6 - The effect of system size==

===TASK: Repeat the final task of the previous section for the following lattice sizes: 2x2, 4x4, 8x8, 16x16, 32x32. Make sure that you name each datafile that your produce after the corresponding lattice size! Write a Python script to make a plot showing the energy per spin versus temperature for each of your lattice sizes. Hint: the NumPy loadtxt function is the reverse of the savetxt function, and can be used to read your previously saved files into the script. Repeat this for the magnetisation. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. How big a lattice do you think is big enough to capture the long range fluctuations?===

The python script for this section is identical as for the 8x8 graph above in Figure 11 with the relevant files and variables changed accordingly.

Each matrix was simulated using the ILtemperaturerange.py file between T=0.5 and T=5 with a step of T=0.02.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2error.png
| caption1 = 2x2 matrix - 5000 steps, cut-off = 30 steps
| image2 = 4x4error.png
| caption2 = 4x4 matrix - 1000 steps, cut-off = 200 steps
| image3 =cg141716x16error.png
| caption3 = 16x16 matrix - 50000 steps, cut-off = 15000 steps
| image4 =cg141732x32error.png
| caption4 = 32x32 matrix - 200000 steps, cut-off = 50000 steps
| footer_align = left
| footer = Figure 12 - Results of running the ILtemperaturerange.py file for 2x2, 4x4, 16x16 and 32x32 matrices.
}}

 

==Section 7 - Determining the Heat Capacity==

===TASK: By definition, <math>C = \frac{\partial \left\langle E\right\rangle}{\partial T}</math>. From this, show that <math>C = \frac{\mathrm{Var}[E]}{k_B T^2}</math> (Where <math>\mathrm{Var}[E]</math> is the variance in <math>E</math>.)===

Recall from statistical thermodynamics that the average energy of a system is the sum across all microstates of the probability of that microstate multiplied by the energy of that microstate, which is defined mathematically asː <math>\langle E \rangle = \sum_i p_{i}\epsilon_{i}</math>.

The partition function <math>q</math> is defined as <math>q = \sum_{i} exp(-\beta \epsilon_{i})</math> where <math>\beta =\frac{1}{k_BT}</math>and the probability, <math>p_{i}</math> can be defined in terms of the partition function as <math>p_{i} = \frac{exp(-\beta \epsilon_{i})}{\sum_{i} exp(-\beta \epsilon_{i})} = \frac{exp(-\beta \epsilon_{i})}{q}</math>.

As a result, <math>\langle E \rangle</math> can be re-written as <math>\langle E \rangle = \sum_{i} \frac{\epsilon_{i} exp(-\beta \epsilon_{i})}{q} = -\frac{1}{q} \frac{\partial}{\partial \beta}\sum_{i}exp(-\beta \epsilon_{i}) = -\frac{1}{q} \frac{\partial q}{\partial \beta}</math>

Likewise, <math>\langle E^2 \rangle = \sum_i p_{i}\epsilon_{i}^{2} = \sum_{i} \frac{\epsilon_{i}^{2}exp(-\beta \epsilon_{i})}{q} = \frac{1}{q} \frac{\partial^{2}}{\partial \beta^{2}}\sum_{i}exp(-\beta \epsilon_{i}) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}}</math>

From definitionː <math>Var[E] = \Delta E^2 = \langle E^2 \rangle - \langle E \rangle^2 </math>

When the definition of <math>\langle E \rangle</math> and <math>\langle E^2 \rangle</math> is written in terms of partition function <math>q</math>ː <math>Var[E] = \langle E^2 \rangle - \langle E \rangle^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \left(\frac{1}{q}\frac{\partial q}{\partial \beta}\right)^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2</math>.

According to the chain ruleː <math>\frac{\partial}{\partial \beta}\left(\frac{1}{q} \frac{\partial q}{\partial \beta}\right) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2 = -\frac{\partial}{\partial \beta}\langle E \rangle = Var[E]</math>

And using the chain rule againː <math>C = \frac{\partial \langle E \rangle}{\partial T}= \left(-\frac{\partial \langle E \rangle}{\partial \beta}\right) \left(-\frac{\partial \beta}{\partial T}\right) = \frac{Var[E]}{k_B T^2}</math>

===TASK: Write a Python script to make a plot showing the heat capacity versus temperature for each of your lattice sizes from the previous section. You may need to do some research to recall the connection between the variance of a variable, <math>\mathrm{Var}[X]</math>, the mean of its square <math>\left\langle X^2\right\rangle</math>, and its squared mean <math>\left\langle X\right\rangle^2</math>. You may find that the data around the peak is very noisy — this is normal, and is a result of being in the critical region. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. ===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb

{{multiple image
| width =300
| align = left
| image1 = cg14172x2heatcap.png
| caption1 = 2x2 Matrix
| image2 = cg14174x4heatcap.png
| caption2 = 4x4 Matrix
| image3 =cg14178x8heatcap.png
| caption3 = 8x8 Matrix
| image4 =cg141716x16heatcap.png
| caption4 = 16x16 Matrix
| image5=cg141732x32heatcap.png
| caption5= 32x32 Matrix
| footer = Figure 13 - Graphs showing Heat Capacity against Temperature for each matrix size
}}

Here is the source code to produce the figuresː
<pre> def heatCap(energies,energysq,T,latsize):
#defines the heat capacity for a given temperature
energiesq=np.multiply(energies,energies) #creates array of (average energies) squared
varE=np.subtract(energysq,energiesq) #defines variance of average energy
tempsq=np.multiply(T,T) #array of temperature squared
return np.array(np.divide(varE,tempsq))/(latsize**2)

heatCap2x2=heatCap(energies2x2,energysq2x2,temps2x2,2) #creates array of heat capacity for each T

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(temps2x2,heatCap2x2,color='orange') #plots heat capacity for each T
pl.savefig('cg14172x2heatcap.png',bbox_inches='tight') #saves figure
pl.show()
</pre>

A general trend from the above graphs is that the peak of the graph shifts towards lower temperatures as the size of the matrix used increases.

==Section 8 - Locating the Curie Temperature==
===TASK: A C++ program has been used to run some much longer simulations than would be possible on the college computers in Python. You can view its source code here if you are interested. Each file contains six columns: <math>T, E, E^2, M, M^2, C</math> (the final five quantities are per spin), and you can read them with the NumPy loadtxt function as before. For each lattice size, plot the C++ data against your data. For one lattice size, save a PNG of this comparison and add it to your report — add a legend to the graph to label which is which. To do this, you will need to pass the label="..." keyword to the plot function, then call the legend() function of the axis object (documentation here).===

The python code used to read and plot the C++ data is found in the Jupyter notebook CG1417IsingModelGraphs.ipynb.

''Figure 14'' below shows the C++ plotted against my own data for a 16x16 Matrix.

[[File:Cg141716x16C++.png|400px|thumb|left|Figure 14 - Graph showing my own data against the C++ data for a 16x16 matrix.]]

 

Here is the source code the produce the figuresː
<pre>#fitting C++ data

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.plot(temps2x2, np.array(energies2x2)/4,color='black',alpha=0.7,label='Python Data') #python energy against T
enerax.plot(temps2x2C, energies2x2C, color='red',label='C++ Data') #C energy against T
magax.plot(temps2x2, np.array(mag2x2)/4,color='black',alpha=0.7,label='Python Data') #python magnetisation against T
magax.plot(temps2x2C, mag2x2C,color='red',label='C++ Data') #C energy against T
enerax.legend() #shows legend on energy graph
magax.legend() #shows legend on energy graph
pl.show()
</pre>

The relevant variables and dat files were changed for each matrix.

===TASK: write a script to read the data from a particular file, and plot C vs T, as well as a fitted polynomial. Try changing the degree of the polynomial to improve the fit — in general, it might be difficult to get a good fit! Attach a PNG of an example fit to your report.===

The python script to read and plot the fitted polynomial is found in CG1417PolyfitScript.ipynb

Here is the source code for ''Figure 15''

<pre>data_test = np.loadtxt("16x16C.dat")
T_test = data_test[:,0] #gets temperatures
C_test = data_test[:,5] #gets heat capacity data

#first we fit the polynomial to the data
fit_test = np.polyfit(T_test, C_test, 35) # fit a polynomial

#now we generate interpolated values of the fitted polynomial over the range of our function
T_min_test = 0.5 #np.min(T_test)
T_max_test = 5 #np.max(T_test)

T_range_test = np.linspace(T_min_test, T_max_test, 1000) #generate 1000 evenly spaced points between T_min and T_max
fitted_C_values_test = np.polyval(fit_test, T_range_test)# use the fit object to generate the corresponding values of C

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(T_test,C_test,color='orange',label='C++ Data') #plots C data of heat capacity against temp
heatcapax.plot(T_range_test,fitted_C_values_test,label='Fitted Polynomial') #plots fitted polynomial for whole range of temp
heatcapax.legend()
pl.savefig('FIT_TEST16x16_35.png', bbox_inches='tight') #saves figure
pl.show()
</pre>

Below in ''Figure 15'' is a plot of my Heat Capacity against Temperature data for a 16x16 matrix and features a polynomial of degree 35 plotted against it. Even with a polynomial of such a high degree, it poorly fits the curve and does not fit to the peak of the curve either.

[[File:cg1417FIT_TEST16x16_35.png|thumb|left|400px|Figure 15 - Plot of Heat Capacity against Temperature along with a poorly fitted polynomial of degree 35. ]]

 

===TASK: Modify your script from the previous section. You should still plot the whole temperature range, but fit the polynomial only to the peak of the heat capacity! You should find it easier to get a good fit when restricted to this region===

The script was modified as such that the polynomial was fitted in a set range around the peak of the graph, this is demonstrated in ''Figure 17'' which shows a newly fitted polynomial between a much smaller range of temperatures (T = 2.15-2.55) and a much smaller degree polynomial (3).

[[File:CG1417FIT_16x16C_3.png|thumb|left|400px|Figure 16 - Graph showing Heat Capacity against Temperature for a 16x16 matrix along with a fitted polynomial between a much more restricted range of temperatures and a significantly lower degree of polynomial]]

Upon comparison with ''Figure 15'', the new fitted polynomial is a significantly better fit even for a 3rd degree polynomial and is a much more accurate representation of my data around the peak of the graph and will make it easier to determine the maximum value of Heat Capacity.

 

Here is the source code for ''Figure 16''ː
<pre>data16 = np.loadtxt("16x16C.dat") #loads data to variable

T16 = data16[:,0] #gets temps
C16 = data16[:,5] # gets heat capacities

Tmin16 = 2.15 #chosen min temp
Tmax16 = 2.55 #chosen max temp

selection16 = np.logical_and(T16 > Tmin16, T16 < Tmax16) #choose only those rows where both conditions are true
peak_T_values16 = T16[selection16] #choose temp values in range chosen above
peak_C_values16 = C16[selection16] #choose heat cap values in range of t above

fit16 = np.polyfit(peak_T_values16,peak_C_values16,3) #fit 3rd order polynomial
peak_T_range16 = np.linspace(Tmin16, Tmax16, 1000) #defines 1000 temps within data range
fitted_C_values16 = np.polyval(fit16, peak_T_range16) #use the fit object to get corresponding values of heat cap

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(T16,C16,color='orange',label='C++ Data') #plots C data of heat cap against temp
heatcapax.plot(peak_T_range16,fitted_C_values16,label='Fitted Polynomial') #plots fitted polynomial for small range
heatcapax.legend()
pl.savefig('FIT_16x16C_3.png', bbox_inches='tight') #saves figure
pl.show()

</pre>

===TASK: find the temperature at which the maximum in C occurs for each datafile that you were given. Make a text file containing two colums: the lattice side length (2,4,8, etc.), and the temperature at which C is a maximum. This is your estimate of <math>T_C</math> for that side length. Make a plot that uses the scaling relation given above to determine <math>T_{C,\infty}</math>. By doing a little research online, you should be able to find the theoretical exact Curie temperature for the infinite 2D Ising lattice. How does your value compare to this? Are you surprised by how good/bad the agreement is? Attach a PNG of this final graph to your report, and discuss briefly what you think the major sources of error are in your estimate.===

''Figure 17'' below shows a graph of <math>T_{C,L}</math> against <math>\frac{1}{Lattice Size}</math> to determine the Curie Temperature of an infinite 2D Ising Model Lattice <math>T_{C,\infty}</math>. The black dots represent the raw data obtained from obtaining the temperature at which the Heat Capacity was a maximum for the lattices and the red line in a linear curve fit plotted against the data to allow the y-intercept which is the Curie Temperature for the infinite 2D lattice to be determined.

[[File:cg1417CurieTemp.png|400px|thumb|left|Figure 17 - Plot of 1/Lattice Size against Curie Temperature for that lattice size.]]

The value for <math>T_{C,\inf}</math> obtained from the data is <math>T_{C,\infty} = 2.277 \frac{J}{k_B}</math> with a literature value being <math>T_{C,\infty} = 2.269 \frac{J}{k_B}</math> <ref>L. Onsager, Phys. Rev., 1944, 65, 117--149.</ref>for an infinite square 2D lattice. This means that my result slightly over-estimates the Curie Temperature for the infinite lattice and as a result for an infinite lattice the temperature at which spontaneous magnetisation stops would actually occur at a slightly lower temperature than expected. However, the difference between my value and the literature value is only 0.008 which is incredibly small and the amount of agreement between the two values is somewhat surprising, which means that the error in my estimates of the Curie Temperature for each lattice size is relatively small. The points which have the largest residuals and deviation from the line of best fit in ''Figure 17'' corresponds to the smaller lattice sizes of 2x2 and 4x4 where longer range interactions are more significant. The longer range interactions posed by the boundary conditions are nowhere near as significant for the larger sizes and causes the energy of the smaller matrices to be less accurate and have a larger associated error with the energy and thus the Curie Temperature for that lattice size. This affects the accuracy of the line of best fit and to increase the accuracy of this line, larger lattice sizes of 128x128, 256x256 etc should be included in the calculation for the line of best fit and the smaller matrices ignored.

 

Below is the source code used to generate ''Figure 17''
<pre>
Cmax64x64 = np.max(fitted_C_values64) #finds Cmax for 64x64 matrix - done for others already
Tmax64x64 = peak_T_range64[fitted_C_values64 == Cmax64x64] #finds Tmax corresponding to Cmax

LatSize=[2,4,8,16,32,64] #stores lattice sizes
Tmax=[Tmax2x2,Tmax4x4,Tmax8x8,Tmax16x16,Tmax32x32,Tmax64x64] #stores corresponding Tmax data
np.savetxt('CmaxVSTmax.txt', (LatSize,Tmax)) #writes data to txt file

ScalData=np.loadtxt('CmaxVSTmax.txt') #loads data
LatticeSize=ScalData[0] #gets lattice sizes
TempMax=ScalData[1] #gets max temp or curie temp for each lattice

Lmin1min = np.min(np.divide(1,LatticeSize)) #minimum of 1/LatticeSize values
Lmin1max = np.max(np.divide(1,LatticeSize)) #maximum of 1/LatticeSize values

fitTcl = np.polyfit(np.divide(1,LatticeSize),TempMax, 1) #creates fit object

Lmin1values = np.linspace(Lmin1min, Lmin1max, 1000) #finds 1000 values between min and max x-axis value of 1/LatticeSize
fitted_Tcl_values = np.polyval(fitTcl, Lmin1values) #creates corresponding Curie Temp values for each value in Lmin1values

fig = pl.figure()
scalrelax = fig.add_subplot(1,1,1)
scalrelax.set_xlabel('1/Lattice Size')
scalrelax.set_ylabel('Curie Temperature/ J/k_B')
scalrelax.plot(np.divide(1,LatticeSize),TempMax,color='black',marker='.',linestyle='') #plots Curie Temp against 1/LatticeSize
scalrelax.plot(Lmin1values,fitted_Tcl_values,color='red',marker='',linestyle='-') #plots line of best fit for data above
pl.savefig('CurieTemp.png', bbox_inches='tight') #saves figure
pl.show()

</pre>

== References ==

File:Cg1417MonteCarloStep run.png

2019-11-20T10:05:03Z

Cg1417:

Rep:Y3CMPCG1417

2019-11-20T10:00:13Z

Cg1417: /* Section 1 - Introduction to the Ising Model */

==Section 1 - Introduction to the Ising Model==

===TASK: Show that the lowest possible energy for the Ising model is <math>E = -DNJ</math>, where D is the number of dimensions and N is the total number of spins. What is the multiplicity of this state? Calculate its entropy.===

Consider a 1D row of lattice sites of N=3 with spin configuration [+1][+1][+1].

Mathematically the interaction energy is defined asː
<math> -\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} </math> where J is a constant and <math>s_{i}s_{j}</math> is the product between two spins in adjacent lattice sites.

The sum of the interaction energies <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j}</math> can be considered as the sum of the individual interaction energies between spinsː
<math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = \epsilon_{12} + \epsilon_{23} + \epsilon_{13} + \epsilon_{21} + \epsilon_{32} + \epsilon_{31} </math>.

Although lattice sites 1 and 3 are not adjacent they are said to still interact according to the periodic boundary conditions applied.

However, <math>\epsilon_{12} = \epsilon_{21} </math> and <math>\epsilon_{23} = \epsilon_{32}</math> and <math>\epsilon_{13} = \epsilon_{31}</math> which means that all of the interactions within the system are counted twice, hence the total energy needs to be halved, resulting in the following formula being obtainedː <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = 2\epsilon_{12} + 2\epsilon_{13} + 2\epsilon_{23} </math>.

It can be determined that <math>\epsilon_{12} = (+1)(+1) = 1</math> , <math>\epsilon_{13} = (+1)(+1) = 1</math> and <math>\epsilon_{23} = (+1)(+1) = 1</math>.

Thereforeː <math>-\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = -\frac{1}{2} \ J \ (2 + 2 + 2) = -\frac{1}{2} \ J \ 6 = - 3 J = -DNJ</math> for a 1D lattice with <math>D=1</math> and 3 lattice sites <math>N=3</math>

The multiplicity of the system,<math>\Omega = \frac{lattice sites!}{n. spin up!n. spin down!}</math>

Entropy, <math>S</math> is defined as <math>S = k_B ln(\Omega)</math> and so in this case <math>S = k_B ln(\frac{100!}{100!}) = 0</math>

===TASK: Imagine that the system is in the lowest energy configuration. To move to a different state, one of the spins must spontaneously change direction ("flip"). What is the change in energy if this happens <math>(D=3, N=1000)</math>? How much entropy does the system gain by doing soʔ===

In a 3D lattice system, each lattice site has three unique interactions with its neighbours to its left, top and front. In the lowest energy configuration, all spins are parallel and for a system the minimum energy is <math>E = -DNJ</math>, so for the system with <math>N=1000</math> and <math>D=3</math>, the minimum energy is <math>-3000J</math>.

If a single spin is flipped, the product of its spin with its neighbours spin reverses and becomes negative and this increases the total energy of the system. Since 3 unique spin-spin interactions are reversed in sign, the total energy increases by <math>+3J</math>, meaning the new total energy is <math>-2997J</math>

Initially the multiplicity of the system will be <math>\Omega = \frac{1000!}{1000!}</math> , and after the flip, the multiplicity becomes <math> \Omega = \frac{1000!}{999!1!}=1000</math>.

The associated change in entropy, <math>\Delta S = k_B ln(1000) - 0 = 6.91 k_B</math>, which is an expected increase in entropy as the number of possible configurations of the system increases.

===TASK: Calculate the magnetisation of the 1D and 2D lattices in Figure 1. What magnetisation would you expect to observe for an Ising lattice with <math>D = 3,\ N=1000</math> at absolute zero?===

[[File:ThirdYearCMPExpt-IsingSketch.png|thumb|left|Figure 1 - Shows 1D (N = 5), 2D (N = 5x5) and 3D (N = 5x5x5) lattices.]]

Magnetisation is defined as <math>M=\sum_{i} s_i</math>. So for the 1D lattice with <math>N = 5</math> in ''Figure 2'', <math>M = +1</math> and for the 2D lattice with <math>N = 25 , M = +1</math> too.

According to the 3rd Law of thermodynamics, entropy is 0 at absolute zero for a perfect crystalline solid, and consequently it is expected that the lattices will have follow suit and have zero entropy at 0K. To have zero entropy all spins must be parallel as such that magnetisation, <math>M = N</math>. For all the spins to be parallel, there is only one possible configuration. So, for a lattice with <math>N = 1000</math> and <math>D =3</math>, if <math>M = N</math>, then multiplicity, <math>\Omega = 1</math> and entropy, <math>S =k_B ln(1) = 0</math>.

 

==Section 2 - Calculating the Energy and Magnetisation==

===TASK: complete the functions energy() and magnetisation(), which should return the energy of the lattice and the total magnetisation, respectively. In the energy() function you may assume that <math>J=1.0</math> at all times (in fact, we are working in reduced units in which <math>J=k_B</math>, but there will be more information about this in later sections). Do not worry about the efficiency of the code at the moment — we will address the speed in a later part of the experiment.===

<pre>def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
lat=self.lattice #creates lattice and stores it
mag=[]
for i in range(0,len(lat)): #loops through all rows of lattice
for j in range(0,len(lat[i])): #loops through elements of each row
mag+=[lat[i][j]] #adds spin value to mag array
return sum(mag) #sums all spins from mag array
</pre>

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

lat=self.lattice #creates lattice and stores it
left=[]
top=[]

for i in range(0,len(lat)):
for j in range(0,len(lat[i])):
left+=[lat[i][j]*lat[i][j-1]] #multiplies spin by spin to left
top+=[lat[i][j]*lat[i-1][j]] #multiplies spin by spin above it
int_en=left+top #sums spin products from left and top
energy=-sum(int_en) #sums all spin products for each spin to give total

return energy
</pre>

===TASK: Run the ILcheck.py script from the IPython Qt console using the command===

''Figure 2'' shows the results when ILcheck.py was ran on my IsingLattice.py file. The ILcheck.py file was ran several times to ensure the code worked for various random lattices.

[[File:Cg1417ILcheck run.png|thumb|left|500px| Figure 2 - Result from running the ILcheck.py file]]

 

==Section 3 - Introduction to Monte Carlo Simulation==

===TASK: How many configurations are available to a system with 100 spins? To evaluate these expressions, we have to calculate the energy and magnetisation for each of these configurations, then perform the sum. Let's be very, very, generous, and say that we can analyse <math>1\times 10^9</math> configurations per second with our computer. How long will it take to evaluate a single value of <math>\left\langle M\right\rangle_T</math>?===

For a system with 100 lattice sites and two possible spins for each site, there are <math>2^{100}</math>possible configurations for the system. <math>2^{100}= 1.27\times 10^{30} </math>, so if the computer can analyse <math>1\times 10^9</math> configurations per second, then it will take <math>\frac{1.27\times 10^{30}}{10^9} = 1.27\times 10^{21} s</math> to analyse the whole system, which is longer than the age of the universe and therefore is not a practical approach.

===TASK: Implement a single cycle of the above algorithm in the montecarlocycle(T) function. This function should return the energy of your lattice and the magnetisation at the end of the cycle. You may assume that the energy returned by your energy() function is in units of <math>k_B</math>! Complete the statistics() function. This should return the following quantities whenever it is called: <math><E>, <E^2>, <M>, <M^2></math>, and the number of Monte Carlo steps that have elapsed.===
<pre>
E = []
E2 = []
M = []
M2 = []
n_cycles = 0

def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back if rejected else not changed

self.E+=[self.energy()] #records energy
self.E2+=[self.energy()**2] #records energy squared
self.M+=[self.magnetisation()] #records magnetisation
self.M2+=[self.magnetisation()**2] #records magnetisation squared
self.n_cycles=self.n_cycles+1 #adds 1 to run total

return (self.energy(),self.magnetisation())

def statistics(self):
# complete this function so that it calculates the correct values for the averages of E, E*E (E2), M, M*M (M2), and returns them

e=np.mean(self.E)
e2=np.mean(self.E2)
m=np.mean(self.M)
m2=np.mean(self.M2)

return e,e2,m,m2,self.n_cycles
</pre>

===TASK: If <math>T < T_C</math>, do you expect a spontaneous magnetisation (i.e. do you expect <math>\left\langle M\right\rangle \neq 0</math>)? When the state of the simulation appears to stop changing (when you have reached an equilibrium state), use the controls to export the output to PNG and attach this to your report. You should also include the output from your statistics() function.===

If the temperature of the system is less than the Curie Temperature, <math>T_C</math> then spontaneous magnetisation can occur and the system will tend to its lowest energy state where all of the spins are parallel - this is a property of ferromagnetic materials.

[[File:Cg1417ILanim_run.png|400px|thumb|left|Figure 3 - Results from running the ILanim.py file - shows the energy and magnetisation converging over time]]

''Figure 3'' shows that over time the the system spontaneously converges to the minimum energy state with all of the spins parallel to one another and shows, as I expected, that spontaneous magnetisation occurs and also shows that the temperature of this simulation is below the Curie Temperature, <math>T < T_C</math>.

 

==Section 4 - Accelerating the Code==

===TASK: Use the script ILtimetrial.py to record how long your current version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 4'' show the results of running the ILtimetrial.py file on my code three timesː

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1.png
| width1=500
| image2=cg1417ILtimetrial_run2.png
| width2=500
| image3=cg1417ILtimetrial_run3.png
| width3=500
| footer = Figure 4 - Results of running the ILtimetrial.py file on my code three separate times
}}
 

This gave me an avergage time of <math>24.3 s \pm 0.2s</math>

===TASK: Look at the documentation for the NumPy sum function. You should be able to modify your magnetisation() function so that it uses this to evaluate M. The energy is a little trickier. Familiarise yourself with the NumPy roll and multiply functions, and use these to replace your energy double loop (you will need to call roll and multiply twice!).===

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

left=multiply(roll(self.lattice,1,axis=1),self.lattice) #product of spin with spin left of it
top=multiply(roll(self.lattice,-1,axis=0),self.lattice) #product of spin with spin above it

int_en=sum(left+top) #sum of array containing sum of left and top spin products for each spin

energy = -sum(int_en) #calculates the total energy of system
return energy

def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
return sum(sum(self.lattice)) #adds up all spins in lattice
</pre>

===TASK: Use the script ILtimetrial.py to record how long your new version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 5'' shows the result of running the ILtimetrial.py on my new accelerated code.

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1fast.png
| width1=500
| image2=ILtimetrial_run2fast.png
| width2=500
| image3=ILtimetrial_run3fast.png
| width3=500
| footer = Figure 5 - Results of running the ILtimetrial.py file on my new updated and accelerated code.
}}
 

The accelerated code is much faster upon using the roll, multiply and sum modules with a new average time of <math>0.790 s \pm 0.005 </math>

==Section 5 - The effect of temperature==

===TASK: The script ILfinalframe.py runs for a given number of cycles at a given temperature, then plots a depiction of the final lattice state as well as graphs of the energy and magnetisation as a function of cycle number. This is much quicker than animating every frame! Experiment with different temperature and lattice sizes. How many cycles are typically needed for the system to go from its random starting position to the equilibrium state? Modify your statistics() and montecarlostep() functions so that the first N cycles of the simulation are ignored when calculating the averages. You should state in your report what period you chose to ignore, and include graphs from ILfinalframe.py to illustrate your motivation in choosing this figure.===

''Figure 6'' below shows the results from running the ILfinalframe.py for 2x2 lattice at T=1,2,3,5.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2T1.png
| image2 = cg14172x2T2.png
| image3 =cg14172x2T3.png
| image4 =cg14172x2T5.png
| footer_align = left
| footer = Figure 6 - Results of running the ILfinalframe.py file at T=1,2,3,5 for a 2x2 matrix.
}}

 

For a 2x2 matrix, a suitable cut-off point to exclude from the avergage energies and magnetisations is where the energy and magnetisations per spin are constant, which is 30 steps. For T=3 and T=5 the graphs do not converge because it is possible that these temperatures are higher than the Curie Temperature and as such spontaneous magnetisation will not occur and the system will not diverge to the lowest energy state. At the higher temperatures, there are larger thermal fluctations and the Boltzmann factor is more significant allowing the system to move away from the lowest energy state easier. As a result moving forwards, a suitable cut-off point will only be determined from T=1 and T=2 graphs for the larger matrices.

''Figure 7'' shows the results from running a 4x4 lattice at T=1,2 and 3.

{{multiple image
| width =350
| align = left
| image1 = cg14174x4T1.png
| image2 = cg14174x4T2.png
| image3 =cg14174x4T3.png
| footer_align = left
| footer = Figure 7 - Results of running the ILfinalframe.py file at T=1,2,3 for a 4x4 matrix.
}}

From ''Figure 7'', a suitable cut-off point for the energy and magnetisations is 200 as this is after where the energy and magnetisation has converged for T=1, and is after the initial large drop in energy for T=2, even though there are a few small fluctuations after 200 steps. The result from T=3 has been included to show the large fluctuations for the larger temperatures, and supporting my choice to determine the cut-off from T=1 and T=2 only.

''Figure 8'' shows the results for an 8x8 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg14178x8T1.png
| image2 = cg14178x8T2.png
| footer_align = left
| footer = Figure 8 - Results of running the ILfinalframe.py file at T=1,2 for an 8x8 matrix
}}

From ''Figure 8'' above, a suitable cut-off point is 1000 steps as this is where the energy and magnetisation has easily converged by and is also the point after which the initial large drop in energy has been overcome for T=2 too.

''Figure 9'' shows the result of running the ILfinalframe.py for a 16x16 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg141716x16T1.png
| image2 = cg141716x16T2.png
| footer_align = left
| footer = Figure 9 - Results of running the ILfinalframe.py file at T=1,2 for a 16x16 matrix
}}

From ''Figure 9'', a suitable cut-off point is 15000 steps as for T=1 the energy and magnetisations have converged significantly and will not change much, and likewise this is the same for the T=2 frame.

''Figure 10'' below shows the results from a 32x32 matrix at T=1 and T=2.

{{multiple image
| width =350
| align = left
| image1 = cg141732x32T1.png
| image2 = cg141732x32T2.png
| footer_align = left
| footer = Figure 10 - Results of running the ILfinalframe.py file at T=1,2 for a 32x32 matrix
}}

''Figure 10'' above shows the results of running the ILfinalframe.py file for a 32x32 matrix at T=1 and T=2. As a result a suitable cut-off of 50000 steps was chosen as the energy and magnetisation has significantly converged, but not as much as it could at 100000 steps. I chose a slightly lower value to ensure that the run times of my monte-carlo simulations in future tasks were not extremely time consuming.

The montecarlostep() function was changed by adding a condition that values only above the pre-determined cut-off were included when determining the average value of energy; energy squared; magnetisation and magnetisations squared from the statistics function. The statistics() function did not need to be modified.

The following code is from the 32x32 matrixː

<pre>def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back

if self.n_cycles > 50000: #only adds values to array of E,E2,M and M2 is above specific cut-off
self.E+=[self.energy()]
self.E2+=[self.energy()**2]
self.M+=[self.magnetisation()]
self.M2+=[self.magnetisation()**2]
self.n_cycles=self.n_cycles+1

return (self.energy(),self.magnetisation())
</pre>

===TASK: Use ILtemperaturerange.py to plot the average energy and magnetisation for each temperature, with error bars, for an <math>8\times 8</math> lattice. Use your intuition and results from the script ILfinalframe.py to estimate how many cycles each simulation should be. The temperature range 0.25 to 5.0 is sufficient. Use as many temperature points as you feel necessary to illustrate the trend, but do not use a temperature spacing larger than 0.5. The NumPy function savetxt() stores your array of output data on disk — you will need it later. Save the file as 8x8.dat so that you know which lattice size it came from.===

Using the modified code, the file ILtemperaturerange.py was ran on an 8x8 matrix between T=0.5 and T=5 with a step of T=0.02 for 10000 Montecarlo steps and the first 1000 steps of each temperature were excluded when calculating the averages. ''Figure 11'' shows the result of the simulation and also included error bars of standard deviation.

[[File:Cg14178x8error.png|1000px|thumb|left|Figure 11 - Graph showing average energy and average magnetisation for an 8x8 lattice with error bars between T=0.5 and T=5]]

 

Below is the source code for the script to produce the graphː

<pre>data8x8=np.loadtxt('8x8.dat') #loads data
temps8x8=data8x8[:,0] #stores temperatures
energies8x8=data8x8[:,1] #stores average energy for each T
energysq8x8=data8x8[:,2] #stores average energy squared for each T
mag8x8=data8x8[:,3] #stores magnetisation for each T
magsq8x8=data8x8[:,4] #stores magnetisation squared for each T
stde8x8=data8x8[:,5] #edited ILtemperaturerange.py to record the standard deviation of the energy for each T
stdm8x8=data8x8[:,6] #edited ILtemperaturerange.py to record the standard deviation of the magnetisation for each T

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.errorbar(temps8x8, np.array(energies8x8)/64,yerr=np.divide(stde8x8,64),color='black',ecolor='teal',alpha=0.8) #plots energy per spin against T
magax.errorbar(temps8x8, np.array(mag8x8)/64,yerr=np.divide(stdm8x8,64),alpha=0.8,ecolor='salmon',color='black') #plots magnetisation per spin against T on separate graph
pl.savefig('8x8error.png',bbox_inches='tight') #saves figure
pl.show()

</pre>

==Section 6 - The effect of system size==

===TASK: Repeat the final task of the previous section for the following lattice sizes: 2x2, 4x4, 8x8, 16x16, 32x32. Make sure that you name each datafile that your produce after the corresponding lattice size! Write a Python script to make a plot showing the energy per spin versus temperature for each of your lattice sizes. Hint: the NumPy loadtxt function is the reverse of the savetxt function, and can be used to read your previously saved files into the script. Repeat this for the magnetisation. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. How big a lattice do you think is big enough to capture the long range fluctuations?===

The python script for this section is identical as for the 8x8 graph above in Figure 11 with the relevant files and variables changed accordingly.

Each matrix was simulated using the ILtemperaturerange.py file between T=0.5 and T=5 with a step of T=0.02.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2error.png
| caption1 = 2x2 matrix - 5000 steps, cut-off = 30 steps
| image2 = 4x4error.png
| caption2 = 4x4 matrix - 1000 steps, cut-off = 200 steps
| image3 =cg141716x16error.png
| caption3 = 16x16 matrix - 50000 steps, cut-off = 15000 steps
| image4 =cg141732x32error.png
| caption4 = 32x32 matrix - 200000 steps, cut-off = 50000 steps
| footer_align = left
| footer = Figure 12 - Results of running the ILtemperaturerange.py file for 2x2, 4x4, 16x16 and 32x32 matrices.
}}

 

==Section 7 - Determining the Heat Capacity==

===TASK: By definition, <math>C = \frac{\partial \left\langle E\right\rangle}{\partial T}</math>. From this, show that <math>C = \frac{\mathrm{Var}[E]}{k_B T^2}</math> (Where <math>\mathrm{Var}[E]</math> is the variance in <math>E</math>.)===

Recall from statistical thermodynamics that the average energy of a system is the sum across all microstates of the probability of that microstate multiplied by the energy of that microstate, which is defined mathematically asː <math>\langle E \rangle = \sum_i p_{i}\epsilon_{i}</math>.

The partition function <math>q</math> is defined as <math>q = \sum_{i} exp(-\beta \epsilon_{i})</math> where <math>\beta =\frac{1}{k_BT}</math>and the probability, <math>p_{i}</math> can be defined in terms of the partition function as <math>p_{i} = \frac{exp(-\beta \epsilon_{i})}{\sum_{i} exp(-\beta \epsilon_{i})} = \frac{exp(-\beta \epsilon_{i})}{q}</math>.

As a result, <math>\langle E \rangle</math> can be re-written as <math>\langle E \rangle = \sum_{i} \frac{\epsilon_{i} exp(-\beta \epsilon_{i})}{q} = -\frac{1}{q} \frac{\partial}{\partial \beta}\sum_{i}exp(-\beta \epsilon_{i}) = -\frac{1}{q} \frac{\partial q}{\partial \beta}</math>

Likewise, <math>\langle E^2 \rangle = \sum_i p_{i}\epsilon_{i}^{2} = \sum_{i} \frac{\epsilon_{i}^{2}exp(-\beta \epsilon_{i})}{q} = \frac{1}{q} \frac{\partial^{2}}{\partial \beta^{2}}\sum_{i}exp(-\beta \epsilon_{i}) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}}</math>

From definitionː <math>Var[E] = \Delta E^2 = \langle E^2 \rangle - \langle E \rangle^2 </math>

When the definition of <math>\langle E \rangle</math> and <math>\langle E^2 \rangle</math> is written in terms of partition function <math>q</math>ː <math>Var[E] = \langle E^2 \rangle - \langle E \rangle^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \left(\frac{1}{q}\frac{\partial q}{\partial \beta}\right)^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2</math>.

According to the chain ruleː <math>\frac{\partial}{\partial \beta}\left(\frac{1}{q} \frac{\partial q}{\partial \beta}\right) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2 = -\frac{\partial}{\partial \beta}\langle E \rangle = Var[E]</math>

And using the chain rule againː <math>C = \frac{\partial \langle E \rangle}{\partial T}= \left(-\frac{\partial \langle E \rangle}{\partial \beta}\right) \left(-\frac{\partial \beta}{\partial T}\right) = \frac{Var[E]}{k_B T^2}</math>

===TASK: Write a Python script to make a plot showing the heat capacity versus temperature for each of your lattice sizes from the previous section. You may need to do some research to recall the connection between the variance of a variable, <math>\mathrm{Var}[X]</math>, the mean of its square <math>\left\langle X^2\right\rangle</math>, and its squared mean <math>\left\langle X\right\rangle^2</math>. You may find that the data around the peak is very noisy — this is normal, and is a result of being in the critical region. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. ===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb

{{multiple image
| width =300
| align = left
| image1 = cg14172x2heatcap.png
| caption1 = 2x2 Matrix
| image2 = cg14174x4heatcap.png
| caption2 = 4x4 Matrix
| image3 =cg14178x8heatcap.png
| caption3 = 8x8 Matrix
| image4 =cg141716x16heatcap.png
| caption4 = 16x16 Matrix
| image5=cg141732x32heatcap.png
| caption5= 32x32 Matrix
| footer = Figure 13 - Graphs showing Heat Capacity against Temperature for each matrix size
}}

Here is the source code to produce the figuresː
<pre> def heatCap(energies,energysq,T,latsize):
#defines the heat capacity for a given temperature
energiesq=np.multiply(energies,energies) #creates array of (average energies) squared
varE=np.subtract(energysq,energiesq) #defines variance of average energy
tempsq=np.multiply(T,T) #array of temperature squared
return np.array(np.divide(varE,tempsq))/(latsize**2)

heatCap2x2=heatCap(energies2x2,energysq2x2,temps2x2,2) #creates array of heat capacity for each T

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(temps2x2,heatCap2x2,color='orange') #plots heat capacity for each T
pl.savefig('cg14172x2heatcap.png',bbox_inches='tight') #saves figure
pl.show()
</pre>

A general trend from the above graphs is that the peak of the graph shifts towards lower temperatures as the size of the matrix used increases.

==Section 8 - Locating the Curie Temperature==
===TASK: A C++ program has been used to run some much longer simulations than would be possible on the college computers in Python. You can view its source code here if you are interested. Each file contains six columns: <math>T, E, E^2, M, M^2, C</math> (the final five quantities are per spin), and you can read them with the NumPy loadtxt function as before. For each lattice size, plot the C++ data against your data. For one lattice size, save a PNG of this comparison and add it to your report — add a legend to the graph to label which is which. To do this, you will need to pass the label="..." keyword to the plot function, then call the legend() function of the axis object (documentation here).===

The python code used to read and plot the C++ data is found in the Jupyter notebook CG1417IsingModelGraphs.ipynb.

''Figure 14'' below shows the C++ plotted against my own data for a 16x16 Matrix.

[[File:Cg141716x16C++.png|400px|thumb|left|Figure 14 - Graph showing my own data against the C++ data for a 16x16 matrix.]]

 

Here is the source code the produce the figuresː
<pre>#fitting C++ data

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.plot(temps2x2, np.array(energies2x2)/4,color='black',alpha=0.7,label='Python Data') #python energy against T
enerax.plot(temps2x2C, energies2x2C, color='red',label='C++ Data') #C energy against T
magax.plot(temps2x2, np.array(mag2x2)/4,color='black',alpha=0.7,label='Python Data') #python magnetisation against T
magax.plot(temps2x2C, mag2x2C,color='red',label='C++ Data') #C energy against T
enerax.legend() #shows legend on energy graph
magax.legend() #shows legend on energy graph
pl.show()
</pre>

The relevant variables and dat files were changed for each matrix.

===TASK: write a script to read the data from a particular file, and plot C vs T, as well as a fitted polynomial. Try changing the degree of the polynomial to improve the fit — in general, it might be difficult to get a good fit! Attach a PNG of an example fit to your report.===

The python script to read and plot the fitted polynomial is found in CG1417PolyfitScript.ipynb

Here is the source code for ''Figure 15''

<pre>data_test = np.loadtxt("16x16C.dat")
T_test = data_test[:,0] #gets temperatures
C_test = data_test[:,5] #gets heat capacity data

#first we fit the polynomial to the data
fit_test = np.polyfit(T_test, C_test, 35) # fit a polynomial

#now we generate interpolated values of the fitted polynomial over the range of our function
T_min_test = 0.5 #np.min(T_test)
T_max_test = 5 #np.max(T_test)

T_range_test = np.linspace(T_min_test, T_max_test, 1000) #generate 1000 evenly spaced points between T_min and T_max
fitted_C_values_test = np.polyval(fit_test, T_range_test)# use the fit object to generate the corresponding values of C

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(T_test,C_test,color='orange',label='C++ Data') #plots C data of heat capacity against temp
heatcapax.plot(T_range_test,fitted_C_values_test,label='Fitted Polynomial') #plots fitted polynomial for whole range of temp
heatcapax.legend()
pl.savefig('FIT_TEST16x16_35.png', bbox_inches='tight') #saves figure
pl.show()
</pre>

Below in ''Figure 15'' is a plot of my Heat Capacity against Temperature data for a 16x16 matrix and features a polynomial of degree 35 plotted against it. Even with a polynomial of such a high degree, it poorly fits the curve and does not fit to the peak of the curve either.

[[File:cg1417FIT_TEST16x16_35.png|thumb|left|400px|Figure 15 - Plot of Heat Capacity against Temperature along with a poorly fitted polynomial of degree 35. ]]

 

===TASK: Modify your script from the previous section. You should still plot the whole temperature range, but fit the polynomial only to the peak of the heat capacity! You should find it easier to get a good fit when restricted to this region===

The script was modified as such that the polynomial was fitted in a set range around the peak of the graph, this is demonstrated in ''Figure 17'' which shows a newly fitted polynomial between a much smaller range of temperatures (T = 2.15-2.55) and a much smaller degree polynomial (3).

[[File:CG1417FIT_16x16C_3.png|thumb|left|400px|Figure 16 - Graph showing Heat Capacity against Temperature for a 16x16 matrix along with a fitted polynomial between a much more restricted range of temperatures and a significantly lower degree of polynomial]]

Upon comparison with ''Figure 15'', the new fitted polynomial is a significantly better fit even for a 3rd degree polynomial and is a much more accurate representation of my data around the peak of the graph and will make it easier to determine the maximum value of Heat Capacity.

 

Here is the source code for ''Figure 16''ː
<pre>data16 = np.loadtxt("16x16C.dat") #loads data to variable

T16 = data16[:,0] #gets temps
C16 = data16[:,5] # gets heat capacities

Tmin16 = 2.15 #chosen min temp
Tmax16 = 2.55 #chosen max temp

selection16 = np.logical_and(T16 > Tmin16, T16 < Tmax16) #choose only those rows where both conditions are true
peak_T_values16 = T16[selection16] #choose temp values in range chosen above
peak_C_values16 = C16[selection16] #choose heat cap values in range of t above

fit16 = np.polyfit(peak_T_values16,peak_C_values16,3) #fit 3rd order polynomial
peak_T_range16 = np.linspace(Tmin16, Tmax16, 1000) #defines 1000 temps within data range
fitted_C_values16 = np.polyval(fit16, peak_T_range16) #use the fit object to get corresponding values of heat cap

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(T16,C16,color='orange',label='C++ Data') #plots C data of heat cap against temp
heatcapax.plot(peak_T_range16,fitted_C_values16,label='Fitted Polynomial') #plots fitted polynomial for small range
heatcapax.legend()
pl.savefig('FIT_16x16C_3.png', bbox_inches='tight') #saves figure
pl.show()

</pre>

===TASK: find the temperature at which the maximum in C occurs for each datafile that you were given. Make a text file containing two colums: the lattice side length (2,4,8, etc.), and the temperature at which C is a maximum. This is your estimate of <math>T_C</math> for that side length. Make a plot that uses the scaling relation given above to determine <math>T_{C,\infty}</math>. By doing a little research online, you should be able to find the theoretical exact Curie temperature for the infinite 2D Ising lattice. How does your value compare to this? Are you surprised by how good/bad the agreement is? Attach a PNG of this final graph to your report, and discuss briefly what you think the major sources of error are in your estimate.===

''Figure 17'' below shows a graph of <math>T_{C,L}</math> against <math>\frac{1}{Lattice Size}</math> to determine the Curie Temperature of an infinite 2D Ising Model Lattice <math>T_{C,\infty}</math>. The black dots represent the raw data obtained from obtaining the temperature at which the Heat Capacity was a maximum for the lattices and the red line in a linear curve fit plotted against the data to allow the y-intercept which is the Curie Temperature for the infinite 2D lattice to be determined.

[[File:cg1417CurieTemp.png|400px|thumb|left|Figure 17 - Plot of 1/Lattice Size against Curie Temperature for that lattice size.]]

The value for <math>T_{C,\inf}</math> obtained from the data is <math>T_{C,\infty} = 2.277 \frac{J}{k_B}</math> with a literature value being <math>T_{C,\infty} = 2.269 \frac{J}{k_B}</math> <ref>L. Onsager, Phys. Rev., 1944, 65, 117--149.</ref>for an infinite square 2D lattice. This means that my result slightly over-estimates the Curie Temperature for the infinite lattice and as a result for an infinite lattice the temperature at which spontaneous magnetisation stops would actually occur at a slightly lower temperature than expected. However, the difference between my value and the literature value is only 0.008 which is incredibly small and the amount of agreement between the two values is somewhat surprising, which means that the error in my estimates of the Curie Temperature for each lattice size is relatively small. The points which have the largest residuals and deviation from the line of best fit in ''Figure 17'' corresponds to the smaller lattice sizes of 2x2 and 4x4 where longer range interactions are more significant. The longer range interactions posed by the boundary conditions are nowhere near as significant for the larger sizes and causes the energy of the smaller matrices to be less accurate and have a larger associated error with the energy and thus the Curie Temperature for that lattice size. This affects the accuracy of the line of best fit and to increase the accuracy of this line, larger lattice sizes of 128x128, 256x256 etc should be included in the calculation for the line of best fit and the smaller matrices ignored.

 

Below is the source code used to generate ''Figure 17''
<pre>
Cmax64x64 = np.max(fitted_C_values64) #finds Cmax for 64x64 matrix - done for others already
Tmax64x64 = peak_T_range64[fitted_C_values64 == Cmax64x64] #finds Tmax corresponding to Cmax

LatSize=[2,4,8,16,32,64] #stores lattice sizes
Tmax=[Tmax2x2,Tmax4x4,Tmax8x8,Tmax16x16,Tmax32x32,Tmax64x64] #stores corresponding Tmax data
np.savetxt('CmaxVSTmax.txt', (LatSize,Tmax)) #writes data to txt file

ScalData=np.loadtxt('CmaxVSTmax.txt') #loads data
LatticeSize=ScalData[0] #gets lattice sizes
TempMax=ScalData[1] #gets max temp or curie temp for each lattice

Lmin1min = np.min(np.divide(1,LatticeSize)) #minimum of 1/LatticeSize values
Lmin1max = np.max(np.divide(1,LatticeSize)) #maximum of 1/LatticeSize values

fitTcl = np.polyfit(np.divide(1,LatticeSize),TempMax, 1) #creates fit object

Lmin1values = np.linspace(Lmin1min, Lmin1max, 1000) #finds 1000 values between min and max x-axis value of 1/LatticeSize
fitted_Tcl_values = np.polyval(fitTcl, Lmin1values) #creates corresponding Curie Temp values for each value in Lmin1values

fig = pl.figure()
scalrelax = fig.add_subplot(1,1,1)
scalrelax.set_xlabel('1/Lattice Size')
scalrelax.set_ylabel('Curie Temperature/ J/k_B')
scalrelax.plot(np.divide(1,LatticeSize),TempMax,color='black',marker='.',linestyle='') #plots Curie Temp against 1/LatticeSize
scalrelax.plot(Lmin1values,fitted_Tcl_values,color='red',marker='',linestyle='-') #plots line of best fit for data above
pl.savefig('CurieTemp.png', bbox_inches='tight') #saves figure
pl.show()

</pre>

== References ==

Rep:Y3CMPCG1417

2019-11-20T09:44:32Z

==Section 1 - Introduction to the Ising Model==

===TASK: Show that the lowest possible energy for the Ising model is <math>E = -DNJ</math>, where D is the number of dimensions and N is the total number of spins. What is the multiplicity of this state? Calculate its entropy.===

Consider a 1D row of lattice sites of N=3 with spin configuration [+1][+1][+1].

Mathematically the interaction energy is defined asː
<math> -\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} </math> where J is a constant and <math>s_{i}s_{j}</math> is the product between two spins in adjacent lattice sites.

The sum of the interaction energies <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j}</math> can be considered as the sum of the individual interaction energies between spinsː
<math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = \epsilon_{12} + \epsilon_{23} + \epsilon_{13} + \epsilon_{21} + \epsilon_{32} + \epsilon_{31} </math>.

Although lattice sites 1 and 3 are not adjacent they are said to still interact according to the periodic boundary conditions applied.

However, <math>\epsilon_{12} = \epsilon_{21} </math> and <math>\epsilon_{23} = \epsilon_{32}</math> and <math>\epsilon_{13} = \epsilon_{31}</math> which means that all of the interactions within the system are counted twice, hence the total energy needs to be halved, resulting in the following formula being obtainedː <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = 2\epsilon_{12} + 2\epsilon_{13} + 2\epsilon_{23} </math>.

It can be determined that <math>\epsilon_{12} = (+1)(+1) = 1</math> , <math>\epsilon_{13} = (+1)(+1) = 1</math> and <math>\epsilon_{23} = (+1)(+1) = 1</math>.

Thereforeː <math>-\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = -\frac{1}{2} \ J \ (2 + 2 + 2) = -\frac{1}{2} \ J \ 6 = - 3 J = -DNJ</math> for a 1D lattice with <math>D=1</math> and 3 lattice sites <math>N=3</math>

The multiplicity of the system,<math>\Omega = \frac{n. spin up!}{n. spin down!}</math>

Entropy, <math>S</math> is defined as <math>S = k_B ln(\Omega)</math> and so in this case <math>S = k_B ln(\frac{100!}{100!}) = 0</math>

===TASK: Imagine that the system is in the lowest energy configuration. To move to a different state, one of the spins must spontaneously change direction ("flip"). What is the change in energy if this happens <math>(D=3, N=1000)</math>? How much entropy does the system gain by doing soʔ===

In a 3D lattice system, each lattice site has three unique interactions with its neighbours to its left, top and front. In the lowest energy configuration, all spins are parallel and for a system the minimum energy is <math>E = -DNJ</math>, so for the system with <math>N=1000</math> and <math>D=3</math>, the minimum energy is <math>-3000J</math>.

If a single spin is flipped, the product of its spin with its neighbours spin reverses and becomes negative and this increases the total energy of the system. Since 3 unique spin-spin interactions are reversed in sign, the total energy increases by <math>+3J</math>, meaning the new total energy is <math>-2997J</math>

Initially the multiplicity of the system will be <math>\Omega = \frac{1000!}{1000!}</math> , and after the flip, the multiplicity becomes <math> \Omega = \frac{1000!}{999!1!}=1000</math>.

The associated change in entropy, <math>\Delta S = k_B ln(1000) - 0 = 6.91 k_B</math>, which is an expected increase in entropy as the number of possible configurations of the system increases.

===TASK: Calculate the magnetisation of the 1D and 2D lattices in Figure 1. What magnetisation would you expect to observe for an Ising lattice with <math>D = 3,\ N=1000</math> at absolute zero?===

[[File:ThirdYearCMPExpt-IsingSketch.png|thumb|left|Figure 1 - Shows 1D (N = 5), 2D (N = 5x5) and 3D (N = 5x5x5) lattices.]]

Magnetisation is defined as <math>M=\sum_{i} s_i</math>. So for the 1D lattice with <math>N = 5</math> in ''Figure 2'', <math>M = +1</math> and for the 2D lattice with <math>N = 25 , M = +1</math> too.

According to the 3rd Law of thermodynamics, entropy is 0 at absolute zero for a perfect crystalline solid, and consequently it is expected that the lattices will have follow suit and have zero entropy at 0K. To have zero entropy all spins must be parallel as such that magnetisation, <math>M = N</math>. For all the spins to be parallel, there is only one possible configuration. So, for a lattice with <math>N = 1000</math> and <math>D =3</math>, if <math>M = N</math>, then multiplicity, <math>\Omega = 1</math> and entropy, <math>S =k_B ln(1) = 0</math>.

 

==Section 2 - Calculating the Energy and Magnetisation==

===TASK: complete the functions energy() and magnetisation(), which should return the energy of the lattice and the total magnetisation, respectively. In the energy() function you may assume that <math>J=1.0</math> at all times (in fact, we are working in reduced units in which <math>J=k_B</math>, but there will be more information about this in later sections). Do not worry about the efficiency of the code at the moment — we will address the speed in a later part of the experiment.===

<pre>def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
lat=self.lattice #creates lattice and stores it
mag=[]
for i in range(0,len(lat)): #loops through all rows of lattice
for j in range(0,len(lat[i])): #loops through elements of each row
mag+=[lat[i][j]] #adds spin value to mag array
return sum(mag) #sums all spins from mag array
</pre>

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

lat=self.lattice #creates lattice and stores it
left=[]
top=[]

for i in range(0,len(lat)):
for j in range(0,len(lat[i])):
left+=[lat[i][j]*lat[i][j-1]] #multiplies spin by spin to left
top+=[lat[i][j]*lat[i-1][j]] #multiplies spin by spin above it
int_en=left+top #sums spin products from left and top
energy=-sum(int_en) #sums all spin products for each spin to give total

return energy
</pre>

===TASK: Run the ILcheck.py script from the IPython Qt console using the command===

''Figure 2'' shows the results when ILcheck.py was ran on my IsingLattice.py file. The ILcheck.py file was ran several times to ensure the code worked for various random lattices.

[[File:Cg1417ILcheck run.png|thumb|left|500px| Figure 2 - Result from running the ILcheck.py file]]

 

==Section 3 - Introduction to Monte Carlo Simulation==

===TASK: How many configurations are available to a system with 100 spins? To evaluate these expressions, we have to calculate the energy and magnetisation for each of these configurations, then perform the sum. Let's be very, very, generous, and say that we can analyse <math>1\times 10^9</math> configurations per second with our computer. How long will it take to evaluate a single value of <math>\left\langle M\right\rangle_T</math>?===

For a system with 100 lattice sites and two possible spins for each site, there are <math>2^{100}</math>possible configurations for the system. <math>2^{100}= 1.27\times 10^{30} </math>, so if the computer can analyse <math>1\times 10^9</math> configurations per second, then it will take <math>\frac{1.27\times 10^{30}}{10^9} = 1.27\times 10^{21} s</math> to analyse the whole system, which is longer than the age of the universe and therefore is not a practical approach.

===TASK: Implement a single cycle of the above algorithm in the montecarlocycle(T) function. This function should return the energy of your lattice and the magnetisation at the end of the cycle. You may assume that the energy returned by your energy() function is in units of <math>k_B</math>! Complete the statistics() function. This should return the following quantities whenever it is called: <math><E>, <E^2>, <M>, <M^2></math>, and the number of Monte Carlo steps that have elapsed.===
<pre>
E = []
E2 = []
M = []
M2 = []
n_cycles = 0

def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back if rejected else not changed

self.E+=[self.energy()] #records energy
self.E2+=[self.energy()**2] #records energy squared
self.M+=[self.magnetisation()] #records magnetisation
self.M2+=[self.magnetisation()**2] #records magnetisation squared
self.n_cycles=self.n_cycles+1 #adds 1 to run total

return (self.energy(),self.magnetisation())

def statistics(self):
# complete this function so that it calculates the correct values for the averages of E, E*E (E2), M, M*M (M2), and returns them

e=np.mean(self.E)
e2=np.mean(self.E2)
m=np.mean(self.M)
m2=np.mean(self.M2)

return e,e2,m,m2,self.n_cycles
</pre>

===TASK: If <math>T < T_C</math>, do you expect a spontaneous magnetisation (i.e. do you expect <math>\left\langle M\right\rangle \neq 0</math>)? When the state of the simulation appears to stop changing (when you have reached an equilibrium state), use the controls to export the output to PNG and attach this to your report. You should also include the output from your statistics() function.===

If the temperature of the system is less than the Curie Temperature, <math>T_C</math> then spontaneous magnetisation can occur and the system will tend to its lowest energy state where all of the spins are parallel - this is a property of ferromagnetic materials.

[[File:Cg1417ILanim_run.png|400px|thumb|left|Figure 3 - Results from running the ILanim.py file - shows the energy and magnetisation converging over time]]

''Figure 3'' shows that over time the the system spontaneously converges to the minimum energy state with all of the spins parallel to one another and shows, as I expected, that spontaneous magnetisation occurs and also shows that the temperature of this simulation is below the Curie Temperature, <math>T < T_C</math>.

 

==Section 4 - Accelerating the Code==

===TASK: Use the script ILtimetrial.py to record how long your current version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 4'' show the results of running the ILtimetrial.py file on my code three timesː

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1.png
| width1=500
| image2=cg1417ILtimetrial_run2.png
| width2=500
| image3=cg1417ILtimetrial_run3.png
| width3=500
| footer = Figure 4 - Results of running the ILtimetrial.py file on my code three separate times
}}
 

This gave me an avergage time of <math>24.3 s \pm 0.2s</math>

===TASK: Look at the documentation for the NumPy sum function. You should be able to modify your magnetisation() function so that it uses this to evaluate M. The energy is a little trickier. Familiarise yourself with the NumPy roll and multiply functions, and use these to replace your energy double loop (you will need to call roll and multiply twice!).===

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

left=multiply(roll(self.lattice,1,axis=1),self.lattice) #product of spin with spin left of it
top=multiply(roll(self.lattice,-1,axis=0),self.lattice) #product of spin with spin above it

int_en=sum(left+top) #sum of array containing sum of left and top spin products for each spin

energy = -sum(int_en) #calculates the total energy of system
return energy

def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
return sum(sum(self.lattice)) #adds up all spins in lattice
</pre>

===TASK: Use the script ILtimetrial.py to record how long your new version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 5'' shows the result of running the ILtimetrial.py on my new accelerated code.

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1fast.png
| width1=500
| image2=ILtimetrial_run2fast.png
| width2=500
| image3=ILtimetrial_run3fast.png
| width3=500
| footer = Figure 5 - Results of running the ILtimetrial.py file on my new updated and accelerated code.
}}
 

The accelerated code is much faster upon using the roll, multiply and sum modules with a new average time of <math>0.790 s \pm 0.005 </math>

==Section 5 - The effect of temperature==

===TASK: The script ILfinalframe.py runs for a given number of cycles at a given temperature, then plots a depiction of the final lattice state as well as graphs of the energy and magnetisation as a function of cycle number. This is much quicker than animating every frame! Experiment with different temperature and lattice sizes. How many cycles are typically needed for the system to go from its random starting position to the equilibrium state? Modify your statistics() and montecarlostep() functions so that the first N cycles of the simulation are ignored when calculating the averages. You should state in your report what period you chose to ignore, and include graphs from ILfinalframe.py to illustrate your motivation in choosing this figure.===

''Figure 6'' below shows the results from running the ILfinalframe.py for 2x2 lattice at T=1,2,3,5.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2T1.png
| image2 = cg14172x2T2.png
| image3 =cg14172x2T3.png
| image4 =cg14172x2T5.png
| footer_align = left
| footer = Figure 6 - Results of running the ILfinalframe.py file at T=1,2,3,5 for a 2x2 matrix.
}}

 

For a 2x2 matrix, a suitable cut-off point to exclude from the avergage energies and magnetisations is where the energy and magnetisations per spin are constant, which is 30 steps. For T=3 and T=5 the graphs do not converge because it is possible that these temperatures are higher than the Curie Temperature and as such spontaneous magnetisation will not occur and the system will not diverge to the lowest energy state. At the higher temperatures, there are larger thermal fluctations and the Boltzmann factor is more significant allowing the system to move away from the lowest energy state easier. As a result moving forwards, a suitable cut-off point will only be determined from T=1 and T=2 graphs for the larger matrices.

''Figure 7'' shows the results from running a 4x4 lattice at T=1,2 and 3.

{{multiple image
| width =350
| align = left
| image1 = cg14174x4T1.png
| image2 = cg14174x4T2.png
| image3 =cg14174x4T3.png
| footer_align = left
| footer = Figure 7 - Results of running the ILfinalframe.py file at T=1,2,3 for a 4x4 matrix.
}}

From ''Figure 7'', a suitable cut-off point for the energy and magnetisations is 200 as this is after where the energy and magnetisation has converged for T=1, and is after the initial large drop in energy for T=2, even though there are a few small fluctuations after 200 steps. The result from T=3 has been included to show the large fluctuations for the larger temperatures, and supporting my choice to determine the cut-off from T=1 and T=2 only.

''Figure 8'' shows the results for an 8x8 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg14178x8T1.png
| image2 = cg14178x8T2.png
| footer_align = left
| footer = Figure 8 - Results of running the ILfinalframe.py file at T=1,2 for an 8x8 matrix
}}

From ''Figure 8'' above, a suitable cut-off point is 1000 steps as this is where the energy and magnetisation has easily converged by and is also the point after which the initial large drop in energy has been overcome for T=2 too.

''Figure 9'' shows the result of running the ILfinalframe.py for a 16x16 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg141716x16T1.png
| image2 = cg141716x16T2.png
| footer_align = left
| footer = Figure 9 - Results of running the ILfinalframe.py file at T=1,2 for a 16x16 matrix
}}

From ''Figure 9'', a suitable cut-off point is 15000 steps as for T=1 the energy and magnetisations have converged significantly and will not change much, and likewise this is the same for the T=2 frame.

''Figure 10'' below shows the results from a 32x32 matrix at T=1 and T=2.

{{multiple image
| width =350
| align = left
| image1 = cg141732x32T1.png
| image2 = cg141732x32T2.png
| footer_align = left
| footer = Figure 10 - Results of running the ILfinalframe.py file at T=1,2 for a 32x32 matrix
}}

''Figure 10'' above shows the results of running the ILfinalframe.py file for a 32x32 matrix at T=1 and T=2. As a result a suitable cut-off of 50000 steps was chosen as the energy and magnetisation has significantly converged, but not as much as it could at 100000 steps. I chose a slightly lower value to ensure that the run times of my monte-carlo simulations in future tasks were not extremely time consuming.

The montecarlostep() function was changed by adding a condition that values only above the pre-determined cut-off were included when determining the average value of energy; energy squared; magnetisation and magnetisations squared from the statistics function. The statistics() function did not need to be modified.

The following code is from the 32x32 matrixː

<pre>def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back

if self.n_cycles > 50000: #only adds values to array of E,E2,M and M2 is above specific cut-off
self.E+=[self.energy()]
self.E2+=[self.energy()**2]
self.M+=[self.magnetisation()]
self.M2+=[self.magnetisation()**2]
self.n_cycles=self.n_cycles+1

return (self.energy(),self.magnetisation())
</pre>

===TASK: Use ILtemperaturerange.py to plot the average energy and magnetisation for each temperature, with error bars, for an <math>8\times 8</math> lattice. Use your intuition and results from the script ILfinalframe.py to estimate how many cycles each simulation should be. The temperature range 0.25 to 5.0 is sufficient. Use as many temperature points as you feel necessary to illustrate the trend, but do not use a temperature spacing larger than 0.5. The NumPy function savetxt() stores your array of output data on disk — you will need it later. Save the file as 8x8.dat so that you know which lattice size it came from.===

Using the modified code, the file ILtemperaturerange.py was ran on an 8x8 matrix between T=0.5 and T=5 with a step of T=0.02 for 10000 Montecarlo steps and the first 1000 steps of each temperature were excluded when calculating the averages. ''Figure 11'' shows the result of the simulation and also included error bars of standard deviation.

[[File:Cg14178x8error.png|1000px|thumb|left|Figure 11 - Graph showing average energy and average magnetisation for an 8x8 lattice with error bars between T=0.5 and T=5]]

 

Below is the source code for the script to produce the graphː

<pre>data8x8=np.loadtxt('8x8.dat') #loads data
temps8x8=data8x8[:,0] #stores temperatures
energies8x8=data8x8[:,1] #stores average energy for each T
energysq8x8=data8x8[:,2] #stores average energy squared for each T
mag8x8=data8x8[:,3] #stores magnetisation for each T
magsq8x8=data8x8[:,4] #stores magnetisation squared for each T
stde8x8=data8x8[:,5] #edited ILtemperaturerange.py to record the standard deviation of the energy for each T
stdm8x8=data8x8[:,6] #edited ILtemperaturerange.py to record the standard deviation of the magnetisation for each T

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.errorbar(temps8x8, np.array(energies8x8)/64,yerr=np.divide(stde8x8,64),color='black',ecolor='teal',alpha=0.8) #plots energy per spin against T
magax.errorbar(temps8x8, np.array(mag8x8)/64,yerr=np.divide(stdm8x8,64),alpha=0.8,ecolor='salmon',color='black') #plots magnetisation per spin against T on separate graph
pl.savefig('8x8error.png',bbox_inches='tight') #saves figure
pl.show()

</pre>

==Section 6 - The effect of system size==

===TASK: Repeat the final task of the previous section for the following lattice sizes: 2x2, 4x4, 8x8, 16x16, 32x32. Make sure that you name each datafile that your produce after the corresponding lattice size! Write a Python script to make a plot showing the energy per spin versus temperature for each of your lattice sizes. Hint: the NumPy loadtxt function is the reverse of the savetxt function, and can be used to read your previously saved files into the script. Repeat this for the magnetisation. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. How big a lattice do you think is big enough to capture the long range fluctuations?===

The python script for this section is identical as for the 8x8 graph above in Figure 11 with the relevant files and variables changed accordingly.

Each matrix was simulated using the ILtemperaturerange.py file between T=0.5 and T=5 with a step of T=0.02.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2error.png
| caption1 = 2x2 matrix - 5000 steps, cut-off = 30 steps
| image2 = 4x4error.png
| caption2 = 4x4 matrix - 1000 steps, cut-off = 200 steps
| image3 =cg141716x16error.png
| caption3 = 16x16 matrix - 50000 steps, cut-off = 15000 steps
| image4 =cg141732x32error.png
| caption4 = 32x32 matrix - 200000 steps, cut-off = 50000 steps
| footer_align = left
| footer = Figure 12 - Results of running the ILtemperaturerange.py file for 2x2, 4x4, 16x16 and 32x32 matrices.
}}

 

==Section 7 - Determining the Heat Capacity==

===TASK: By definition, <math>C = \frac{\partial \left\langle E\right\rangle}{\partial T}</math>. From this, show that <math>C = \frac{\mathrm{Var}[E]}{k_B T^2}</math> (Where <math>\mathrm{Var}[E]</math> is the variance in <math>E</math>.)===

Recall from statistical thermodynamics that the average energy of a system is the sum across all microstates of the probability of that microstate multiplied by the energy of that microstate, which is defined mathematically asː <math>\langle E \rangle = \sum_i p_{i}\epsilon_{i}</math>.

The partition function <math>q</math> is defined as <math>q = \sum_{i} exp(-\beta \epsilon_{i})</math> where <math>\beta =\frac{1}{k_BT}</math>and the probability, <math>p_{i}</math> can be defined in terms of the partition function as <math>p_{i} = \frac{exp(-\beta \epsilon_{i})}{\sum_{i} exp(-\beta \epsilon_{i})} = \frac{exp(-\beta \epsilon_{i})}{q}</math>.

As a result, <math>\langle E \rangle</math> can be re-written as <math>\langle E \rangle = \sum_{i} \frac{\epsilon_{i} exp(-\beta \epsilon_{i})}{q} = -\frac{1}{q} \frac{\partial}{\partial \beta}\sum_{i}exp(-\beta \epsilon_{i}) = -\frac{1}{q} \frac{\partial q}{\partial \beta}</math>

Likewise, <math>\langle E^2 \rangle = \sum_i p_{i}\epsilon_{i}^{2} = \sum_{i} \frac{\epsilon_{i}^{2}exp(-\beta \epsilon_{i})}{q} = \frac{1}{q} \frac{\partial^{2}}{\partial \beta^{2}}\sum_{i}exp(-\beta \epsilon_{i}) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}}</math>

From definitionː <math>Var[E] = \Delta E^2 = \langle E^2 \rangle - \langle E \rangle^2 </math>

When the definition of <math>\langle E \rangle</math> and <math>\langle E^2 \rangle</math> is written in terms of partition function <math>q</math>ː <math>Var[E] = \langle E^2 \rangle - \langle E \rangle^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \left(\frac{1}{q}\frac{\partial q}{\partial \beta}\right)^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2</math>.

According to the chain ruleː <math>\frac{\partial}{\partial \beta}\left(\frac{1}{q} \frac{\partial q}{\partial \beta}\right) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2 = -\frac{\partial}{\partial \beta}\langle E \rangle = Var[E]</math>

And using the chain rule againː <math>C = \frac{\partial \langle E \rangle}{\partial T}= \left(-\frac{\partial \langle E \rangle}{\partial \beta}\right) \left(-\frac{\partial \beta}{\partial T}\right) = \frac{Var[E]}{k_B T^2}</math>

===TASK: Write a Python script to make a plot showing the heat capacity versus temperature for each of your lattice sizes from the previous section. You may need to do some research to recall the connection between the variance of a variable, <math>\mathrm{Var}[X]</math>, the mean of its square <math>\left\langle X^2\right\rangle</math>, and its squared mean <math>\left\langle X\right\rangle^2</math>. You may find that the data around the peak is very noisy — this is normal, and is a result of being in the critical region. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. ===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb

{{multiple image
| width =300
| align = left
| image1 = cg14172x2heatcap.png
| caption1 = 2x2 Matrix
| image2 = cg14174x4heatcap.png
| caption2 = 4x4 Matrix
| image3 =cg14178x8heatcap.png
| caption3 = 8x8 Matrix
| image4 =cg141716x16heatcap.png
| caption4 = 16x16 Matrix
| image5=cg141732x32heatcap.png
| caption5= 32x32 Matrix
| footer = Figure 13 - Graphs showing Heat Capacity against Temperature for each matrix size
}}

Here is the source code to produce the figuresː
<pre> def heatCap(energies,energysq,T,latsize):
#defines the heat capacity for a given temperature
energiesq=np.multiply(energies,energies) #creates array of (average energies) squared
varE=np.subtract(energysq,energiesq) #defines variance of average energy
tempsq=np.multiply(T,T) #array of temperature squared
return np.array(np.divide(varE,tempsq))/(latsize**2)

heatCap2x2=heatCap(energies2x2,energysq2x2,temps2x2,2) #creates array of heat capacity for each T

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(temps2x2,heatCap2x2,color='orange') #plots heat capacity for each T
pl.savefig('cg14172x2heatcap.png',bbox_inches='tight') #saves figure
pl.show()
</pre>

A general trend from the above graphs is that the peak of the graph shifts towards lower temperatures as the size of the matrix used increases.

==Section 8 - Locating the Curie Temperature==
===TASK: A C++ program has been used to run some much longer simulations than would be possible on the college computers in Python. You can view its source code here if you are interested. Each file contains six columns: <math>T, E, E^2, M, M^2, C</math> (the final five quantities are per spin), and you can read them with the NumPy loadtxt function as before. For each lattice size, plot the C++ data against your data. For one lattice size, save a PNG of this comparison and add it to your report — add a legend to the graph to label which is which. To do this, you will need to pass the label="..." keyword to the plot function, then call the legend() function of the axis object (documentation here).===

The python code used to read and plot the C++ data is found in the Jupyter notebook CG1417IsingModelGraphs.ipynb.

''Figure 14'' below shows the C++ plotted against my own data for a 16x16 Matrix.

[[File:Cg141716x16C++.png|400px|thumb|left|Figure 14 - Graph showing my own data against the C++ data for a 16x16 matrix.]]

 

Here is the source code the produce the figuresː
<pre>#fitting C++ data

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.plot(temps2x2, np.array(energies2x2)/4,color='black',alpha=0.7,label='Python Data') #python energy against T
enerax.plot(temps2x2C, energies2x2C, color='red',label='C++ Data') #C energy against T
magax.plot(temps2x2, np.array(mag2x2)/4,color='black',alpha=0.7,label='Python Data') #python magnetisation against T
magax.plot(temps2x2C, mag2x2C,color='red',label='C++ Data') #C energy against T
enerax.legend() #shows legend on energy graph
magax.legend() #shows legend on energy graph
pl.show()
</pre>

The relevant variables and dat files were changed for each matrix.

===TASK: write a script to read the data from a particular file, and plot C vs T, as well as a fitted polynomial. Try changing the degree of the polynomial to improve the fit — in general, it might be difficult to get a good fit! Attach a PNG of an example fit to your report.===

The python script to read and plot the fitted polynomial is found in CG1417PolyfitScript.ipynb

Here is the source code for ''Figure 15''

<pre>data_test = np.loadtxt("16x16C.dat")
T_test = data_test[:,0] #gets temperatures
C_test = data_test[:,5] #gets heat capacity data

#first we fit the polynomial to the data
fit_test = np.polyfit(T_test, C_test, 35) # fit a polynomial

#now we generate interpolated values of the fitted polynomial over the range of our function
T_min_test = 0.5 #np.min(T_test)
T_max_test = 5 #np.max(T_test)

T_range_test = np.linspace(T_min_test, T_max_test, 1000) #generate 1000 evenly spaced points between T_min and T_max
fitted_C_values_test = np.polyval(fit_test, T_range_test)# use the fit object to generate the corresponding values of C

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(T_test,C_test,color='orange',label='C++ Data') #plots C data of heat capacity against temp
heatcapax.plot(T_range_test,fitted_C_values_test,label='Fitted Polynomial') #plots fitted polynomial for whole range of temp
heatcapax.legend()
pl.savefig('FIT_TEST16x16_35.png', bbox_inches='tight') #saves figure
pl.show()
</pre>

Below in ''Figure 15'' is a plot of my Heat Capacity against Temperature data for a 16x16 matrix and features a polynomial of degree 35 plotted against it. Even with a polynomial of such a high degree, it poorly fits the curve and does not fit to the peak of the curve either.

[[File:cg1417FIT_TEST16x16_35.png|thumb|left|400px|Figure 15 - Plot of Heat Capacity against Temperature along with a poorly fitted polynomial of degree 35. ]]

 

===TASK: Modify your script from the previous section. You should still plot the whole temperature range, but fit the polynomial only to the peak of the heat capacity! You should find it easier to get a good fit when restricted to this region===

The script was modified as such that the polynomial was fitted in a set range around the peak of the graph, this is demonstrated in ''Figure 17'' which shows a newly fitted polynomial between a much smaller range of temperatures (T = 2.15-2.55) and a much smaller degree polynomial (3).

[[File:CG1417FIT_16x16C_3.png|thumb|left|400px|Figure 16 - Graph showing Heat Capacity against Temperature for a 16x16 matrix along with a fitted polynomial between a much more restricted range of temperatures and a significantly lower degree of polynomial]]

Upon comparison with ''Figure 15'', the new fitted polynomial is a significantly better fit even for a 3rd degree polynomial and is a much more accurate representation of my data around the peak of the graph and will make it easier to determine the maximum value of Heat Capacity.

 

Here is the source code for ''Figure 16''ː
<pre>data16 = np.loadtxt("16x16C.dat") #loads data to variable

T16 = data16[:,0] #gets temps
C16 = data16[:,5] # gets heat capacities

Tmin16 = 2.15 #chosen min temp
Tmax16 = 2.55 #chosen max temp

selection16 = np.logical_and(T16 > Tmin16, T16 < Tmax16) #choose only those rows where both conditions are true
peak_T_values16 = T16[selection16] #choose temp values in range chosen above
peak_C_values16 = C16[selection16] #choose heat cap values in range of t above

fit16 = np.polyfit(peak_T_values16,peak_C_values16,3) #fit 3rd order polynomial
peak_T_range16 = np.linspace(Tmin16, Tmax16, 1000) #defines 1000 temps within data range
fitted_C_values16 = np.polyval(fit16, peak_T_range16) #use the fit object to get corresponding values of heat cap

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(T16,C16,color='orange',label='C++ Data') #plots C data of heat cap against temp
heatcapax.plot(peak_T_range16,fitted_C_values16,label='Fitted Polynomial') #plots fitted polynomial for small range
heatcapax.legend()
pl.savefig('FIT_16x16C_3.png', bbox_inches='tight') #saves figure
pl.show()

</pre>

===TASK: find the temperature at which the maximum in C occurs for each datafile that you were given. Make a text file containing two colums: the lattice side length (2,4,8, etc.), and the temperature at which C is a maximum. This is your estimate of <math>T_C</math> for that side length. Make a plot that uses the scaling relation given above to determine <math>T_{C,\infty}</math>. By doing a little research online, you should be able to find the theoretical exact Curie temperature for the infinite 2D Ising lattice. How does your value compare to this? Are you surprised by how good/bad the agreement is? Attach a PNG of this final graph to your report, and discuss briefly what you think the major sources of error are in your estimate.===

''Figure 17'' below shows a graph of <math>T_{C,L}</math> against <math>\frac{1}{Lattice Size}</math> to determine the Curie Temperature of an infinite 2D Ising Model Lattice <math>T_{C,\infty}</math>. The black dots represent the raw data obtained from obtaining the temperature at which the Heat Capacity was a maximum for the lattices and the red line in a linear curve fit plotted against the data to allow the y-intercept which is the Curie Temperature for the infinite 2D lattice to be determined.

[[File:cg1417CurieTemp.png|400px|thumb|left|Figure 17 - Plot of 1/Lattice Size against Curie Temperature for that lattice size.]]

The value for <math>T_{C,\inf}</math> obtained from the data is <math>T_{C,\infty} = 2.277 \frac{J}{k_B}</math> with a literature value being <math>T_{C,\infty} = 2.269 \frac{J}{k_B}</math> <ref>L. Onsager, Phys. Rev., 1944, 65, 117--149.</ref>for an infinite square 2D lattice. This means that my result slightly over-estimates the Curie Temperature for the infinite lattice and as a result for an infinite lattice the temperature at which spontaneous magnetisation stops would actually occur at a slightly lower temperature than expected. However, the difference between my value and the literature value is only 0.008 which is incredibly small and the amount of agreement between the two values is somewhat surprising, which means that the error in my estimates of the Curie Temperature for each lattice size is relatively small. The points which have the largest residuals and deviation from the line of best fit in ''Figure 17'' corresponds to the smaller lattice sizes of 2x2 and 4x4 where longer range interactions are more significant. The longer range interactions posed by the boundary conditions are nowhere near as significant for the larger sizes and causes the energy of the smaller matrices to be less accurate and have a larger associated error with the energy and thus the Curie Temperature for that lattice size. This affects the accuracy of the line of best fit and to increase the accuracy of this line, larger lattice sizes of 128x128, 256x256 etc should be included in the calculation for the line of best fit and the smaller matrices ignored.

 

Below is the source code used to generate ''Figure 17''
<pre>
Cmax64x64 = np.max(fitted_C_values64) #finds Cmax for 64x64 matrix - done for others already
Tmax64x64 = peak_T_range64[fitted_C_values64 == Cmax64x64] #finds Tmax corresponding to Cmax

LatSize=[2,4,8,16,32,64] #stores lattice sizes
Tmax=[Tmax2x2,Tmax4x4,Tmax8x8,Tmax16x16,Tmax32x32,Tmax64x64] #stores corresponding Tmax data
np.savetxt('CmaxVSTmax.txt', (LatSize,Tmax)) #writes data to txt file

ScalData=np.loadtxt('CmaxVSTmax.txt') #loads data
LatticeSize=ScalData[0] #gets lattice sizes
TempMax=ScalData[1] #gets max temp or curie temp for each lattice

Lmin1min = np.min(np.divide(1,LatticeSize)) #minimum of 1/LatticeSize values
Lmin1max = np.max(np.divide(1,LatticeSize)) #maximum of 1/LatticeSize values

fitTcl = np.polyfit(np.divide(1,LatticeSize),TempMax, 1) #creates fit object

Lmin1values = np.linspace(Lmin1min, Lmin1max, 1000) #finds 1000 values between min and max x-axis value of 1/LatticeSize
fitted_Tcl_values = np.polyval(fitTcl, Lmin1values) #creates corresponding Curie Temp values for each value in Lmin1values

fig = pl.figure()
scalrelax = fig.add_subplot(1,1,1)
scalrelax.set_xlabel('1/Lattice Size')
scalrelax.set_ylabel('Curie Temperature/ J/k_B')
scalrelax.plot(np.divide(1,LatticeSize),TempMax,color='black',marker='.',linestyle='') #plots Curie Temp against 1/LatticeSize
scalrelax.plot(Lmin1values,fitted_Tcl_values,color='red',marker='',linestyle='-') #plots line of best fit for data above
pl.savefig('CurieTemp.png', bbox_inches='tight') #saves figure
pl.show()

</pre>

== References ==

Rep:Y3CMPCG1417

2019-11-20T09:36:27Z

==Section 1 - Introduction to the Ising Model==

===TASK: Show that the lowest possible energy for the Ising model is <math>E = -DNJ</math>, where D is the number of dimensions and N is the total number of spins. What is the multiplicity of this state? Calculate its entropy.===

Consider a 1D row of lattice sites of N=3 with spin configuration [+1][+1][+1].

Mathematically the interaction energy is defined asː
<math> -\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} </math> where J is a constant and <math>s_{i}s_{j}</math> is the product between two spins in adjacent lattice sites.

The sum of the interaction energies <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j}</math> can be considered as the sum of the individual interaction energies between spinsː
<math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = \epsilon_{12} + \epsilon_{23} + \epsilon_{13} + \epsilon_{21} + \epsilon_{32} + \epsilon_{31} </math>.

Although lattice sites 1 and 3 are not adjacent they are said to still interact according to the periodic boundary conditions applied.

However, <math>\epsilon_{12} = \epsilon_{21} </math> and <math>\epsilon_{23} = \epsilon_{32}</math> and <math>\epsilon_{13} = \epsilon_{31}</math> which means that all of the interactions within the system are counted twice, hence the total energy needs to be halved, resulting in the following formula being obtainedː <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = 2\epsilon_{12} + 2\epsilon_{13} + 2\epsilon_{23} </math>.

It can be determined that <math>\epsilon_{12} = (+1)(+1) = 1</math> , <math>\epsilon_{13} = (+1)(+1) = 1</math> and <math>\epsilon_{23} = (+1)(+1) = 1</math>.

Thereforeː <math>-\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = -\frac{1}{2} \ J \ (2 + 2 + 2) = -\frac{1}{2} \ J \ 6 = - 3 J = -DNJ</math> for a 1D lattice with <math>D=1</math> and 3 lattice sites <math>N=3</math>

The multiplicity of the system,<math>\Omega = \frac{n. spin up!}{n. spin down!}</math>

Entropy, <math>S</math> is defined as <math>S = k_B ln(\Omega)</math> and so in this case <math>S = k_B ln(\frac{100!}{100!}) = 0</math>

===TASK: Imagine that the system is in the lowest energy configuration. To move to a different state, one of the spins must spontaneously change direction ("flip"). What is the change in energy if this happens <math>(D=3, N=1000)</math>? How much entropy does the system gain by doing soʔ===

In a 3D lattice system, each lattice site has three unique interactions with its neighbours to its left, top and front. In the lowest energy configuration, all spins are parallel and for a system the minimum energy is <math>E = -DNJ</math>, so for the system with <math>N=1000</math> and <math>D=3</math>, the minimum energy is <math>-3000J</math>.

If a single spin is flipped, the product of its spin with its neighbours spin reverses and becomes negative and this increases the total energy of the system. Since 3 unique spin-spin interactions are reversed in sign, the total energy increases by <math>+3J</math>, meaning the new total energy is <math>-2997J</math>

Initially the multiplicity of the system will be <math>\Omega = \frac{1000!}{1000!}</math> , and after the flip, the multiplicity becomes <math> \Omega = \frac{1000!}{999!1!}=1000</math>.

The associated change in entropy, <math>\Delta S = k_B ln(1000) - 0 = 6.91 k_B</math>, which is an expected increase in entropy as the number of possible configurations of the system increases.

===TASK: Calculate the magnetisation of the 1D and 2D lattices in Figure 1. What magnetisation would you expect to observe for an Ising lattice with <math>D = 3,\ N=1000</math> at absolute zero?===

[[File:ThirdYearCMPExpt-IsingSketch.png|thumb|left|Figure 1 - Shows 1D (N = 5), 2D (N = 5x5) and 3D (N = 5x5x5) lattices.]]

Magnetisation is defined as <math>M=\sum_{i} s_i</math>. So for the 1D lattice with <math>N = 5</math> in ''Figure 2'', <math>M = +1</math> and for the 2D lattice with <math>N = 25 , M = +1</math> too.

According to the 3rd Law of thermodynamics, entropy is 0 at absolute zero for a perfect crystalline solid, and consequently it is expected that the lattices will have follow suit and have zero entropy at 0K. To have zero entropy all spins must be parallel as such that magnetisation, <math>M = N</math>. For all the spins to be parallel, there is only one possible configuration. So, for a lattice with <math>N = 1000</math> and <math>D =3</math>, if <math>M = N</math>, then multiplicity, <math>\Omega = 1</math> and entropy, <math>S =k_B ln(1) = 0</math>.

 

==Section 2 - Calculating the Energy and Magnetisation==

===TASK: complete the functions energy() and magnetisation(), which should return the energy of the lattice and the total magnetisation, respectively. In the energy() function you may assume that <math>J=1.0</math> at all times (in fact, we are working in reduced units in which <math>J=k_B</math>, but there will be more information about this in later sections). Do not worry about the efficiency of the code at the moment — we will address the speed in a later part of the experiment.===

<pre>def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
lat=self.lattice #creates lattice and stores it
mag=[]
for i in range(0,len(lat)): #loops through all rows of lattice
for j in range(0,len(lat[i])): #loops through elements of each row
mag+=[lat[i][j]] #adds spin value to mag array
return sum(mag) #sums all spins from mag array
</pre>

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

lat=self.lattice #creates lattice and stores it
left=[]
top=[]

for i in range(0,len(lat)):
for j in range(0,len(lat[i])):
left+=[lat[i][j]*lat[i][j-1]] #multiplies spin by spin to left
top+=[lat[i][j]*lat[i-1][j]] #multiplies spin by spin above it
int_en=left+top #sums spin products from left and top
energy=-sum(int_en) #sums all spin products for each spin to give total

return energy
</pre>

===TASK: Run the ILcheck.py script from the IPython Qt console using the command===

''Figure 2'' shows the results when ILcheck.py was ran on my IsingLattice.py file. The ILcheck.py file was ran several times to ensure the code worked for various random lattices.

[[File:Cg1417ILcheck run.png|thumb|left|500px| Figure 2 - Result from running the ILcheck.py file]]

 

==Section 3 - Introduction to Monte Carlo Simulation==

===TASK: How many configurations are available to a system with 100 spins? To evaluate these expressions, we have to calculate the energy and magnetisation for each of these configurations, then perform the sum. Let's be very, very, generous, and say that we can analyse <math>1\times 10^9</math> configurations per second with our computer. How long will it take to evaluate a single value of <math>\left\langle M\right\rangle_T</math>?===

For a system with 100 lattice sites and two possible spins for each site, there are <math>2^{100}</math>possible configurations for the system. <math>2^{100}= 1.27\times 10^{30} </math>, so if the computer can analyse <math>1\times 10^9</math> configurations per second, then it will take <math>\frac{1.27\times 10^{30}}{10^9} = 1.27\times 10^{21} s</math> to analyse the whole system, which is longer than the age of the universe and therefore is not a practical approach.

===TASK: Implement a single cycle of the above algorithm in the montecarlocycle(T) function. This function should return the energy of your lattice and the magnetisation at the end of the cycle. You may assume that the energy returned by your energy() function is in units of <math>k_B</math>! Complete the statistics() function. This should return the following quantities whenever it is called: <math><E>, <E^2>, <M>, <M^2></math>, and the number of Monte Carlo steps that have elapsed.===
<pre>
E = []
E2 = []
M = []
M2 = []
n_cycles = 0

def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back if rejected else not changed

self.E+=[self.energy()] #records energy
self.E2+=[self.energy()**2] #records energy squared
self.M+=[self.magnetisation()] #records magnetisation
self.M2+=[self.magnetisation()**2] #records magnetisation squared
self.n_cycles=self.n_cycles+1 #adds 1 to run total

return (self.energy(),self.magnetisation())

def statistics(self):
# complete this function so that it calculates the correct values for the averages of E, E*E (E2), M, M*M (M2), and returns them

e=np.mean(self.E)
e2=np.mean(self.E2)
m=np.mean(self.M)
m2=np.mean(self.M2)

return e,e2,m,m2,self.n_cycles
</pre>

===TASK: If <math>T < T_C</math>, do you expect a spontaneous magnetisation (i.e. do you expect <math>\left\langle M\right\rangle \neq 0</math>)? When the state of the simulation appears to stop changing (when you have reached an equilibrium state), use the controls to export the output to PNG and attach this to your report. You should also include the output from your statistics() function.===

If the temperature of the system is less than the Curie Temperature, <math>T_C</math> then spontaneous magnetisation can occur and the system will tend to its lowest energy state where all of the spins are parallel - this is a property of ferromagnetic materials.

[[File:Cg1417ILanim_run.png|400px|thumb|left|Figure 3 - Results from running the ILanim.py file - shows the energy and magnetisation converging over time]]

''Figure 3'' shows that over time the the system spontaneously converges to the minimum energy state with all of the spins parallel to one another and shows, as I expected, that spontaneous magnetisation occurs and also shows that the temperature of this simulation is below the Curie Temperature, <math>T < T_C</math>.

 

==Section 4 - Accelerating the Code==

===TASK: Use the script ILtimetrial.py to record how long your current version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 4'' show the results of running the ILtimetrial.py file on my code three timesː

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1.png
| width1=500
| image2=cg1417ILtimetrial_run2.png
| width2=500
| image3=cg1417ILtimetrial_run3.png
| width3=500
| footer = Figure 4 - Results of running the ILtimetrial.py file on my code three separate times
}}
 

This gave me an avergage time of <math>24.3 s \pm 0.2s</math>

===TASK: Look at the documentation for the NumPy sum function. You should be able to modify your magnetisation() function so that it uses this to evaluate M. The energy is a little trickier. Familiarise yourself with the NumPy roll and multiply functions, and use these to replace your energy double loop (you will need to call roll and multiply twice!).===

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

left=multiply(roll(self.lattice,1,axis=1),self.lattice) #product of spin with spin left of it
top=multiply(roll(self.lattice,-1,axis=0),self.lattice) #product of spin with spin above it

int_en=sum(left+top) #sum of array containing sum of left and top spin products for each spin

energy = -sum(int_en) #calculates the total energy of system
return energy

def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
return sum(sum(self.lattice)) #adds up all spins in lattice
</pre>

===TASK: Use the script ILtimetrial.py to record how long your new version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 5'' shows the result of running the ILtimetrial.py on my new accelerated code.

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1fast.png
| width1=500
| image2=ILtimetrial_run2fast.png
| width2=500
| image3=ILtimetrial_run3fast.png
| width3=500
| footer = Figure 5 - Results of running the ILtimetrial.py file on my new updated and accelerated code.
}}
 

The accelerated code is much faster upon using the roll, multiply and sum modules with a new average time of <math>0.790 s \pm 0.005 </math>

==Section 5 - The effect of temperature==

===TASK: The script ILfinalframe.py runs for a given number of cycles at a given temperature, then plots a depiction of the final lattice state as well as graphs of the energy and magnetisation as a function of cycle number. This is much quicker than animating every frame! Experiment with different temperature and lattice sizes. How many cycles are typically needed for the system to go from its random starting position to the equilibrium state? Modify your statistics() and montecarlostep() functions so that the first N cycles of the simulation are ignored when calculating the averages. You should state in your report what period you chose to ignore, and include graphs from ILfinalframe.py to illustrate your motivation in choosing this figure.===

''Figure 6'' below shows the results from running the ILfinalframe.py for 2x2 lattice at T=1,2,3,5.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2T1.png
| image2 = cg14172x2T2.png
| image3 =cg14172x2T3.png
| image4 =cg14172x2T5.png
| footer_align = left
| footer = Figure 6 - Results of running the ILfinalframe.py file at T=1,2,3,5 for a 2x2 matrix.
}}

 

For a 2x2 matrix, a suitable cut-off point to exclude from the avergage energies and magnetisations is where the energy and magnetisations per spin are constant, which is 30 steps. For T=3 and T=5 the graphs do not converge because it is possible that these temperatures are higher than the Curie Temperature and as such spontaneous magnetisation will not occur and the system will not diverge to the lowest energy state. At the higher temperatures, there are larger thermal fluctations and the Boltzmann factor is more significant allowing the system to move away from the lowest energy state easier. As a result moving forwards, a suitable cut-off point will only be determined from T=1 and T=2 graphs for the larger matrices.

''Figure 7'' shows the results from running a 4x4 lattice at T=1,2 and 3.

{{multiple image
| width =350
| align = left
| image1 = cg14174x4T1.png
| image2 = cg14174x4T2.png
| image3 =cg14174x4T3.png
| footer_align = left
| footer = Figure 7 - Results of running the ILfinalframe.py file at T=1,2,3 for a 4x4 matrix.
}}

From ''Figure 7'', a suitable cut-off point for the energy and magnetisations is 200 as this is after where the energy and magnetisation has converged for T=1, and is after the initial large drop in energy for T=2, even though there are a few small fluctuations after 200 steps. The result from T=3 has been included to show the large fluctuations for the larger temperatures, and supporting my choice to determine the cut-off from T=1 and T=2 only.

''Figure 8'' shows the results for an 8x8 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg14178x8T1.png
| image2 = cg14178x8T2.png
| footer_align = left
| footer = Figure 8 - Results of running the ILfinalframe.py file at T=1,2 for an 8x8 matrix
}}

From ''Figure 8'' above, a suitable cut-off point is 1000 steps as this is where the energy and magnetisation has easily converged by and is also the point after which the initial large drop in energy has been overcome for T=2 too.

''Figure 9'' shows the result of running the ILfinalframe.py for a 16x16 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg141716x16T1.png
| image2 = cg141716x16T2.png
| footer_align = left
| footer = Figure 9 - Results of running the ILfinalframe.py file at T=1,2 for a 16x16 matrix
}}

From ''Figure 9'', a suitable cut-off point is 15000 steps as for T=1 the energy and magnetisations have converged significantly and will not change much, and likewise this is the same for the T=2 frame.

''Figure 10'' below shows the results from a 32x32 matrix at T=1 and T=2.

{{multiple image
| width =350
| align = left
| image1 = cg141732x32T1.png
| image2 = cg141732x32T2.png
| footer_align = left
| footer = Figure 10 - Results of running the ILfinalframe.py file at T=1,2 for a 32x32 matrix
}}

''Figure 10'' above shows the results of running the ILfinalframe.py file for a 32x32 matrix at T=1 and T=2. As a result a suitable cut-off of 50000 steps was chosen as the energy and magnetisation has significantly converged, but not as much as it could at 100000 steps. I chose a slightly lower value to ensure that the run times of my monte-carlo simulations in future tasks were not extremely time consuming.

The montecarlostep() function was changed by adding a condition that values only above the pre-determined cut-off were included when determining the average value of energy; energy squared; magnetisation and magnetisations squared from the statistics function. The statistics() function did not need to be modified.

The following code is from the 32x32 matrixː

<pre>def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back

if self.n_cycles > 50000: #only adds values to array of E,E2,M and M2 is above specific cut-off
self.E+=[self.energy()]
self.E2+=[self.energy()**2]
self.M+=[self.magnetisation()]
self.M2+=[self.magnetisation()**2]
self.n_cycles=self.n_cycles+1

return (self.energy(),self.magnetisation())
</pre>

===TASK: Use ILtemperaturerange.py to plot the average energy and magnetisation for each temperature, with error bars, for an <math>8\times 8</math> lattice. Use your intuition and results from the script ILfinalframe.py to estimate how many cycles each simulation should be. The temperature range 0.25 to 5.0 is sufficient. Use as many temperature points as you feel necessary to illustrate the trend, but do not use a temperature spacing larger than 0.5. The NumPy function savetxt() stores your array of output data on disk — you will need it later. Save the file as 8x8.dat so that you know which lattice size it came from.===

Using the modified code, the file ILtemperaturerange.py was ran on an 8x8 matrix between T=0.5 and T=5 with a step of T=0.02 for 10000 Montecarlo steps and the first 1000 steps of each temperature were excluded when calculating the averages. ''Figure 11'' shows the result of the simulation and also included error bars of standard deviation.

[[File:Cg14178x8error.png|1000px|thumb|left|Figure 11 - Graph showing average energy and average magnetisation for an 8x8 lattice with error bars between T=0.5 and T=5]]

 

Below is the source code for the script to produce the graphː

<pre>data8x8=np.loadtxt('8x8.dat') #loads data
temps8x8=data8x8[:,0] #stores temperatures
energies8x8=data8x8[:,1] #stores average energy for each T
energysq8x8=data8x8[:,2] #stores average energy squared for each T
mag8x8=data8x8[:,3] #stores magnetisation for each T
magsq8x8=data8x8[:,4] #stores magnetisation squared for each T
stde8x8=data8x8[:,5] #edited ILtemperaturerange.py to record the standard deviation of the energy for each T
stdm8x8=data8x8[:,6] #edited ILtemperaturerange.py to record the standard deviation of the magnetisation for each T

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.errorbar(temps8x8, np.array(energies8x8)/64,yerr=np.divide(stde8x8,64),color='black',ecolor='teal',alpha=0.8) #plots energy per spin against T
magax.errorbar(temps8x8, np.array(mag8x8)/64,yerr=np.divide(stdm8x8,64),alpha=0.8,ecolor='salmon',color='black') #plots magnetisation per spin against T on separate graph
pl.savefig('8x8error.png',bbox_inches='tight') #saves figure
pl.show()

</pre>

==Section 6 - The effect of system size==

===TASK: Repeat the final task of the previous section for the following lattice sizes: 2x2, 4x4, 8x8, 16x16, 32x32. Make sure that you name each datafile that your produce after the corresponding lattice size! Write a Python script to make a plot showing the energy per spin versus temperature for each of your lattice sizes. Hint: the NumPy loadtxt function is the reverse of the savetxt function, and can be used to read your previously saved files into the script. Repeat this for the magnetisation. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. How big a lattice do you think is big enough to capture the long range fluctuations?===

The python script for this section is identical as for the 8x8 graph above in Figure 11 with the relevant files and variables changed accordingly.

Each matrix was simulated using the ILtemperaturerange.py file between T=0.5 and T=5 with a step of T=0.02.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2error.png
| caption1 = 2x2 matrix - 5000 steps, cut-off = 30 steps
| image2 = 4x4error.png
| caption2 = 4x4 matrix - 1000 steps, cut-off = 200 steps
| image3 =cg141716x16error.png
| caption3 = 16x16 matrix - 50000 steps, cut-off = 15000 steps
| image4 =cg141732x32error.png
| caption4 = 32x32 matrix - 200000 steps, cut-off = 50000 steps
| footer_align = left
| footer = Figure 12 - Results of running the ILtemperaturerange.py file for 2x2, 4x4, 16x16 and 32x32 matrices.
}}

 

==Section 7 - Determining the Heat Capacity==

===TASK: By definition, <math>C = \frac{\partial \left\langle E\right\rangle}{\partial T}</math>. From this, show that <math>C = \frac{\mathrm{Var}[E]}{k_B T^2}</math> (Where <math>\mathrm{Var}[E]</math> is the variance in <math>E</math>.)===

Recall from statistical thermodynamics that the average energy of a system is the sum across all microstates of the probability of that microstate multiplied by the energy of that microstate, which is defined mathematically asː <math>\langle E \rangle = \sum_i p_{i}\epsilon_{i}</math>.

The partition function <math>q</math> is defined as <math>q = \sum_{i} exp(-\beta \epsilon_{i})</math> where <math>\beta =\frac{1}{k_BT}</math>and the probability, <math>p_{i}</math> can be defined in terms of the partition function as <math>p_{i} = \frac{exp(-\beta \epsilon_{i})}{\sum_{i} exp(-\beta \epsilon_{i})} = \frac{exp(-\beta \epsilon_{i})}{q}</math>.

As a result, <math>\langle E \rangle</math> can be re-written as <math>\langle E \rangle = \sum_{i} \frac{\epsilon_{i} exp(-\beta \epsilon_{i})}{q} = -\frac{1}{q} \frac{\partial}{\partial \beta}\sum_{i}exp(-\beta \epsilon_{i}) = -\frac{1}{q} \frac{\partial q}{\partial \beta}</math>

Likewise, <math>\langle E^2 \rangle = \sum_i p_{i}\epsilon_{i}^{2} = \sum_{i} \frac{\epsilon_{i}^{2}exp(-\beta \epsilon_{i})}{q} = \frac{1}{q} \frac{\partial^{2}}{\partial \beta^{2}}\sum_{i}exp(-\beta \epsilon_{i}) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}}</math>

From definitionː <math>Var[E] = \Delta E^2 = \langle E^2 \rangle - \langle E \rangle^2 </math>

When the definition of <math>\langle E \rangle</math> and <math>\langle E^2 \rangle</math> is written in terms of partition function <math>q</math>ː <math>Var[E] = \langle E^2 \rangle - \langle E \rangle^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \left(\frac{1}{q}\frac{\partial q}{\partial \beta}\right)^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2</math>.

According to the chain ruleː <math>\frac{\partial}{\partial \beta}\left(\frac{1}{q} \frac{\partial q}{\partial \beta}\right) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2 = -\frac{\partial}{\partial \beta}\langle E \rangle = Var[E]</math>

And using the chain rule againː <math>C = \frac{\partial \langle E \rangle}{\partial T}= \left(-\frac{\partial \langle E \rangle}{\partial \beta}\right) \left(-\frac{\partial \beta}{\partial T}\right) = \frac{Var[E]}{k_B T^2}</math>

===TASK: Write a Python script to make a plot showing the heat capacity versus temperature for each of your lattice sizes from the previous section. You may need to do some research to recall the connection between the variance of a variable, <math>\mathrm{Var}[X]</math>, the mean of its square <math>\left\langle X^2\right\rangle</math>, and its squared mean <math>\left\langle X\right\rangle^2</math>. You may find that the data around the peak is very noisy — this is normal, and is a result of being in the critical region. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. ===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb

{{multiple image
| width =300
| align = left
| image1 = cg14172x2heatcap.png
| caption1 = 2x2 Matrix
| image2 = cg14174x4heatcap.png
| caption2 = 4x4 Matrix
| image3 =cg14178x8heatcap.png
| caption3 = 8x8 Matrix
| image4 =cg141716x16heatcap.png
| caption4 = 16x16 Matrix
| image5=cg141732x32heatcap.png
| caption5= 32x32 Matrix
| footer = Figure 13 - Graphs showing Heat Capacity against Temperature for each matrix size
}}

Here is the source code to produce the figuresː
<pre> def heatCap(energies,energysq,T,latsize):
#defines the heat capacity for a given temperature
energiesq=np.multiply(energies,energies) #creates array of (average energies) squared
varE=np.subtract(energysq,energiesq) #defines variance of average energy
tempsq=np.multiply(T,T) #array of temperature squared
return np.array(np.divide(varE,tempsq))/(latsize**2)

heatCap2x2=heatCap(energies2x2,energysq2x2,temps2x2,2) #creates array of heat capacity for each T

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(temps2x2,heatCap2x2,color='orange') #plots heat capacity for each T
pl.savefig('cg14172x2heatcap.png',bbox_inches='tight') #saves figure
pl.show()
</pre>

A general trend from the above graphs is that the peak of the graph shifts towards lower temperatures as the size of the matrix used increases.

==Section 8 - Locating the Curie Temperature==
===TASK: A C++ program has been used to run some much longer simulations than would be possible on the college computers in Python. You can view its source code here if you are interested. Each file contains six columns: <math>T, E, E^2, M, M^2, C</math> (the final five quantities are per spin), and you can read them with the NumPy loadtxt function as before. For each lattice size, plot the C++ data against your data. For one lattice size, save a PNG of this comparison and add it to your report — add a legend to the graph to label which is which. To do this, you will need to pass the label="..." keyword to the plot function, then call the legend() function of the axis object (documentation here).===

The python code used to read and plot the C++ data is found in the Jupyter notebook CG1417IsingModelGraphs.ipynb.

''Figure 14'' below shows the C++ plotted against my own data for a 16x16 Matrix.

[[File:Cg141716x16C++.png|400px|thumb|left|Figure 14 - Graph showing my own data against the C++ data for a 16x16 matrix.]]

 

Here is the source code the produce the figuresː
<pre>#fitting C++ data

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.plot(temps2x2, np.array(energies2x2)/4,color='black',alpha=0.7,label='Python Data') #python energy against T
enerax.plot(temps2x2C, energies2x2C, color='red',label='C++ Data') #C energy against T
magax.plot(temps2x2, np.array(mag2x2)/4,color='black',alpha=0.7,label='Python Data') #python magnetisation against T
magax.plot(temps2x2C, mag2x2C,color='red',label='C++ Data') #C energy against T
enerax.legend() #shows legend on energy graph
magax.legend() #shows legend on energy graph
pl.show()
</pre>

The relevant variables and dat files were changed for each matrix.

===TASK: write a script to read the data from a particular file, and plot C vs T, as well as a fitted polynomial. Try changing the degree of the polynomial to improve the fit — in general, it might be difficult to get a good fit! Attach a PNG of an example fit to your report.===

The python script to read and plot the fitted polynomial is found in CG1417PolyfitScript.ipynb

Here is the source code for ''Figure 15''

<pre>data_test = np.loadtxt("16x16C.dat")
T_test = data_test[:,0] #gets temperatures
C_test = data_test[:,5] #gets heat capacity data

#first we fit the polynomial to the data
fit_test = np.polyfit(T_test, C_test, 35) # fit a polynomial

#now we generate interpolated values of the fitted polynomial over the range of our function
T_min_test = 0.5 #np.min(T_test)
T_max_test = 5 #np.max(T_test)

T_range_test = np.linspace(T_min_test, T_max_test, 1000) #generate 1000 evenly spaced points between T_min and T_max
fitted_C_values_test = np.polyval(fit_test, T_range_test)# use the fit object to generate the corresponding values of C

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(T_test,C_test,color='orange',label='C++ Data') #plots C data of heat capacity against temp
heatcapax.plot(T_range_test,fitted_C_values_test,label='Fitted Polynomial') #plots fitted polynomial for whole range of temp
heatcapax.legend()
pl.savefig('FIT_TEST16x16_35.png', bbox_inches='tight') #saves figure
pl.show()
</pre>

Below in ''Figure 15'' is a plot of my Heat Capacity against Temperature data for a 16x16 matrix and features a polynomial of degree 35 plotted against it. Even with a polynomial of such a high degree, it poorly fits the curve and does not fit to the peak of the curve either.

[[File:cg1417FIT_TEST16x16_35.png|thumb|left|400px|Figure 15 - Plot of Heat Capacity against Temperature along with a poorly fitted polynomial of degree 35. ]]

 

===TASK: Modify your script from the previous section. You should still plot the whole temperature range, but fit the polynomial only to the peak of the heat capacity! You should find it easier to get a good fit when restricted to this region===

The script was modified as such that the polynomial was fitted in a set range around the peak of the graph, this is demonstrated in ''Figure 17'' which shows a newly fitted polynomial between a much smaller range of temperatures (T = 2.15-2.55) and a much smaller degree polynomial (3).

[[File:CG1417FIT_16x16C_3.png|thumb|left|400px|Figure 16 - Graph showing Heat Capacity against Temperature for a 16x16 matrix along with a fitted polynomial between a much more restricted range of temperatures and a significantly lower degree of polynomial]]

Upon comparison with ''Figure 15'', the new fitted polynomial is a significantly better fit even for a 3rd degree polynomial and is a much more accurate representation of my data around the peak of the graph and will make it easier to determine the maximum value of Heat Capacity.

 

Here is the source code for ''Figure 16''ː
<pre>data16 = np.loadtxt("16x16C.dat") #loads data to variable

T16 = data16[:,0] #gets temps
C16 = data16[:,5] # gets heat capacities

Tmin16 = 2.15 #chosen min temp
Tmax16 = 2.55 #chosen max temp

selection16 = np.logical_and(T16 > Tmin16, T16 < Tmax16) #choose only those rows where both conditions are true
peak_T_values16 = T16[selection16] #choose temp values in range chosen above
peak_C_values16 = C16[selection16] #choose heat cap values in range of t above

fit16 = np.polyfit(peak_T_values16,peak_C_values16,3) #fit 3rd order polynomial
peak_T_range16 = np.linspace(Tmin16, Tmax16, 1000) #defines 1000 temps within data range
fitted_C_values16 = np.polyval(fit16, peak_T_range16) #use the fit object to get corresponding values of heat cap

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(T16,C16,color='orange',label='C++ Data') #plots C data of heat cap against temp
heatcapax.plot(peak_T_range16,fitted_C_values16,label='Fitted Polynomial') #plots fitted polynomial for small range
heatcapax.legend()
pl.savefig('FIT_16x16C_3.png', bbox_inches='tight') #saves figure
pl.show()

</pre>

===TASK: find the temperature at which the maximum in C occurs for each datafile that you were given. Make a text file containing two colums: the lattice side length (2,4,8, etc.), and the temperature at which C is a maximum. This is your estimate of <math>T_C</math> for that side length. Make a plot that uses the scaling relation given above to determine <math>T_{C,\infty}</math>. By doing a little research online, you should be able to find the theoretical exact Curie temperature for the infinite 2D Ising lattice. How does your value compare to this? Are you surprised by how good/bad the agreement is? Attach a PNG of this final graph to your report, and discuss briefly what you think the major sources of error are in your estimate.===

''Figure 17'' below shows a graph of <math>T_{C,L}</math> against <math>\frac{1}{Lattice Size}</math> to determine the Curie Temperature of an infinite 2D Ising Model Lattice <math>T_{C,\infty}</math>. The black dots represent the raw data obtained from obtaining the temperature at which the Heat Capacity was a maximum for the lattices and the red line in a linear curve fit plotted against the data to allow the y-intercept which is the Curie Temperature for the infinite 2D lattice to be determined.

[[File:cg1417CurieTemp.png|400px|thumb|left|Figure 17 - Plot of 1/Lattice Size against Curie Temperature for that lattice size.]]

The value for <math>T_{C,\inf}</math> obtained from the data is <math>T_{C,\infty} = 2.277 \frac{J}{k_B}</math> with a literature value being <math>T_{C,\infty} = 2.269 \frac{J}{k_B}</math> <ref>L. Onsager, Phys. Rev., 1944, 65, 117--149.</ref>for an infinite square 2D lattice. This means that my result slightly over-estimates the Curie Temperature for the infinite lattice and as a result for an infinite lattice the temperature at which spontaneous magnetisation stops would actually occur at a slightly lower temperature than expected. However, the difference between my value and the literature value is only 0.008 which is incredibly small and the amount of agreement between the two values is somewhat surprising, which means that the error in my estimates of the Curie Temperature for each lattice size is relatively small. The points which have the largest residuals and deviation from the line of best fit in ''Figure 17'' corresponds to the smaller lattice sizes of 2x2 and 4x4 where longer range interactions are more significant. The longer range interactions posed by the boundary conditions are nowhere near as significant for the larger sizes and causes the energy of the smaller matrices to be less accurate and have a larger associated error with the energy and thus the Curie Temperature for that lattice size. This affects the accuracy of the line of best fit and to increase the accuracy of this line, larger lattice sizes of 128x128, 256x256 etc should be included in the calculation for the line of best fit and the smaller matrices ignored.

 

== References ==

Rep:Y3CMPCG1417

2019-11-20T09:30:53Z

==Section 1 - Introduction to the Ising Model==

===TASK: Show that the lowest possible energy for the Ising model is <math>E = -DNJ</math>, where D is the number of dimensions and N is the total number of spins. What is the multiplicity of this state? Calculate its entropy.===

Consider a 1D row of lattice sites of N=3 with spin configuration [+1][+1][+1].

Mathematically the interaction energy is defined asː
<math> -\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} </math> where J is a constant and <math>s_{i}s_{j}</math> is the product between two spins in adjacent lattice sites.

The sum of the interaction energies <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j}</math> can be considered as the sum of the individual interaction energies between spinsː
<math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = \epsilon_{12} + \epsilon_{23} + \epsilon_{13} + \epsilon_{21} + \epsilon_{32} + \epsilon_{31} </math>.

Although lattice sites 1 and 3 are not adjacent they are said to still interact according to the periodic boundary conditions applied.

However, <math>\epsilon_{12} = \epsilon_{21} </math> and <math>\epsilon_{23} = \epsilon_{32}</math> and <math>\epsilon_{13} = \epsilon_{31}</math> which means that all of the interactions within the system are counted twice, hence the total energy needs to be halved, resulting in the following formula being obtainedː <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = 2\epsilon_{12} + 2\epsilon_{13} + 2\epsilon_{23} </math>.

It can be determined that <math>\epsilon_{12} = (+1)(+1) = 1</math> , <math>\epsilon_{13} = (+1)(+1) = 1</math> and <math>\epsilon_{23} = (+1)(+1) = 1</math>.

Thereforeː <math>-\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = -\frac{1}{2} \ J \ (2 + 2 + 2) = -\frac{1}{2} \ J \ 6 = - 3 J = -DNJ</math> for a 1D lattice with <math>D=1</math> and 3 lattice sites <math>N=3</math>

The multiplicity of the system,<math>\Omega = \frac{n. spin up!}{n. spin down!}</math>

Entropy, <math>S</math> is defined as <math>S = k_B ln(\Omega)</math> and so in this case <math>S = k_B ln(\frac{100!}{100!}) = 0</math>

===TASK: Imagine that the system is in the lowest energy configuration. To move to a different state, one of the spins must spontaneously change direction ("flip"). What is the change in energy if this happens <math>(D=3, N=1000)</math>? How much entropy does the system gain by doing soʔ===

In a 3D lattice system, each lattice site has three unique interactions with its neighbours to its left, top and front. In the lowest energy configuration, all spins are parallel and for a system the minimum energy is <math>E = -DNJ</math>, so for the system with <math>N=1000</math> and <math>D=3</math>, the minimum energy is <math>-3000J</math>.

If a single spin is flipped, the product of its spin with its neighbours spin reverses and becomes negative and this increases the total energy of the system. Since 3 unique spin-spin interactions are reversed in sign, the total energy increases by <math>+3J</math>, meaning the new total energy is <math>-2997J</math>

Initially the multiplicity of the system will be <math>\Omega = \frac{1000!}{1000!}</math> , and after the flip, the multiplicity becomes <math> \Omega = \frac{1000!}{999!1!}=1000</math>.

The associated change in entropy, <math>\Delta S = k_B ln(1000) - 0 = 6.91 k_B</math>, which is an expected increase in entropy as the number of possible configurations of the system increases.

===TASK: Calculate the magnetisation of the 1D and 2D lattices in Figure 1. What magnetisation would you expect to observe for an Ising lattice with <math>D = 3,\ N=1000</math> at absolute zero?===

[[File:ThirdYearCMPExpt-IsingSketch.png|thumb|left|Figure 1 - Shows 1D (N = 5), 2D (N = 5x5) and 3D (N = 5x5x5) lattices.]]

Magnetisation is defined as <math>M=\sum_{i} s_i</math>. So for the 1D lattice with <math>N = 5</math> in ''Figure 2'', <math>M = +1</math> and for the 2D lattice with <math>N = 25 , M = +1</math> too.

According to the 3rd Law of thermodynamics, entropy is 0 at absolute zero for a perfect crystalline solid, and consequently it is expected that the lattices will have follow suit and have zero entropy at 0K. To have zero entropy all spins must be parallel as such that magnetisation, <math>M = N</math>. For all the spins to be parallel, there is only one possible configuration. So, for a lattice with <math>N = 1000</math> and <math>D =3</math>, if <math>M = N</math>, then multiplicity, <math>\Omega = 1</math> and entropy, <math>S =k_B ln(1) = 0</math>.

 

==Section 2 - Calculating the Energy and Magnetisation==

===TASK: complete the functions energy() and magnetisation(), which should return the energy of the lattice and the total magnetisation, respectively. In the energy() function you may assume that <math>J=1.0</math> at all times (in fact, we are working in reduced units in which <math>J=k_B</math>, but there will be more information about this in later sections). Do not worry about the efficiency of the code at the moment — we will address the speed in a later part of the experiment.===

<pre>def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
lat=self.lattice #creates lattice and stores it
mag=[]
for i in range(0,len(lat)): #loops through all rows of lattice
for j in range(0,len(lat[i])): #loops through elements of each row
mag+=[lat[i][j]] #adds spin value to mag array
return sum(mag) #sums all spins from mag array
</pre>

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

lat=self.lattice #creates lattice and stores it
left=[]
top=[]

for i in range(0,len(lat)):
for j in range(0,len(lat[i])):
left+=[lat[i][j]*lat[i][j-1]] #multiplies spin by spin to left
top+=[lat[i][j]*lat[i-1][j]] #multiplies spin by spin above it
int_en=left+top #sums spin products from left and top
energy=-sum(int_en) #sums all spin products for each spin to give total

return energy
</pre>

===TASK: Run the ILcheck.py script from the IPython Qt console using the command===

''Figure 2'' shows the results when ILcheck.py was ran on my IsingLattice.py file. The ILcheck.py file was ran several times to ensure the code worked for various random lattices.

[[File:Cg1417ILcheck run.png|thumb|left|500px| Figure 2 - Result from running the ILcheck.py file]]

 

==Section 3 - Introduction to Monte Carlo Simulation==

===TASK: How many configurations are available to a system with 100 spins? To evaluate these expressions, we have to calculate the energy and magnetisation for each of these configurations, then perform the sum. Let's be very, very, generous, and say that we can analyse <math>1\times 10^9</math> configurations per second with our computer. How long will it take to evaluate a single value of <math>\left\langle M\right\rangle_T</math>?===

For a system with 100 lattice sites and two possible spins for each site, there are <math>2^{100}</math>possible configurations for the system. <math>2^{100}= 1.27\times 10^{30} </math>, so if the computer can analyse <math>1\times 10^9</math> configurations per second, then it will take <math>\frac{1.27\times 10^{30}}{10^9} = 1.27\times 10^{21} s</math> to analyse the whole system, which is longer than the age of the universe and therefore is not a practical approach.

===TASK: Implement a single cycle of the above algorithm in the montecarlocycle(T) function. This function should return the energy of your lattice and the magnetisation at the end of the cycle. You may assume that the energy returned by your energy() function is in units of <math>k_B</math>! Complete the statistics() function. This should return the following quantities whenever it is called: <math><E>, <E^2>, <M>, <M^2></math>, and the number of Monte Carlo steps that have elapsed.===
<pre>
E = []
E2 = []
M = []
M2 = []
n_cycles = 0

def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back if rejected else not changed

self.E+=[self.energy()] #records energy
self.E2+=[self.energy()**2] #records energy squared
self.M+=[self.magnetisation()] #records magnetisation
self.M2+=[self.magnetisation()**2] #records magnetisation squared
self.n_cycles=self.n_cycles+1 #adds 1 to run total

return (self.energy(),self.magnetisation())

def statistics(self):
# complete this function so that it calculates the correct values for the averages of E, E*E (E2), M, M*M (M2), and returns them

e=np.mean(self.E)
e2=np.mean(self.E2)
m=np.mean(self.M)
m2=np.mean(self.M2)

return e,e2,m,m2,self.n_cycles
</pre>

===TASK: If <math>T < T_C</math>, do you expect a spontaneous magnetisation (i.e. do you expect <math>\left\langle M\right\rangle \neq 0</math>)? When the state of the simulation appears to stop changing (when you have reached an equilibrium state), use the controls to export the output to PNG and attach this to your report. You should also include the output from your statistics() function.===

If the temperature of the system is less than the Curie Temperature, <math>T_C</math> then spontaneous magnetisation can occur and the system will tend to its lowest energy state where all of the spins are parallel - this is a property of ferromagnetic materials.

[[File:Cg1417ILanim_run.png|400px|thumb|left|Figure 3 - Results from running the ILanim.py file - shows the energy and magnetisation converging over time]]

''Figure 3'' shows that over time the the system spontaneously converges to the minimum energy state with all of the spins parallel to one another and shows, as I expected, that spontaneous magnetisation occurs and also shows that the temperature of this simulation is below the Curie Temperature, <math>T < T_C</math>.

 

==Section 4 - Accelerating the Code==

===TASK: Use the script ILtimetrial.py to record how long your current version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 4'' show the results of running the ILtimetrial.py file on my code three timesː

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1.png
| width1=500
| image2=cg1417ILtimetrial_run2.png
| width2=500
| image3=cg1417ILtimetrial_run3.png
| width3=500
| footer = Figure 4 - Results of running the ILtimetrial.py file on my code three separate times
}}
 

This gave me an avergage time of <math>24.3 s \pm 0.2s</math>

===TASK: Look at the documentation for the NumPy sum function. You should be able to modify your magnetisation() function so that it uses this to evaluate M. The energy is a little trickier. Familiarise yourself with the NumPy roll and multiply functions, and use these to replace your energy double loop (you will need to call roll and multiply twice!).===

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

left=multiply(roll(self.lattice,1,axis=1),self.lattice) #product of spin with spin left of it
top=multiply(roll(self.lattice,-1,axis=0),self.lattice) #product of spin with spin above it

int_en=sum(left+top) #sum of array containing sum of left and top spin products for each spin

energy = -sum(int_en) #calculates the total energy of system
return energy

def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
return sum(sum(self.lattice)) #adds up all spins in lattice
</pre>

===TASK: Use the script ILtimetrial.py to record how long your new version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 5'' shows the result of running the ILtimetrial.py on my new accelerated code.

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1fast.png
| width1=500
| image2=ILtimetrial_run2fast.png
| width2=500
| image3=ILtimetrial_run3fast.png
| width3=500
| footer = Figure 5 - Results of running the ILtimetrial.py file on my new updated and accelerated code.
}}
 

The accelerated code is much faster upon using the roll, multiply and sum modules with a new average time of <math>0.790 s \pm 0.005 </math>

==Section 5 - The effect of temperature==

===TASK: The script ILfinalframe.py runs for a given number of cycles at a given temperature, then plots a depiction of the final lattice state as well as graphs of the energy and magnetisation as a function of cycle number. This is much quicker than animating every frame! Experiment with different temperature and lattice sizes. How many cycles are typically needed for the system to go from its random starting position to the equilibrium state? Modify your statistics() and montecarlostep() functions so that the first N cycles of the simulation are ignored when calculating the averages. You should state in your report what period you chose to ignore, and include graphs from ILfinalframe.py to illustrate your motivation in choosing this figure.===

''Figure 6'' below shows the results from running the ILfinalframe.py for 2x2 lattice at T=1,2,3,5.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2T1.png
| image2 = cg14172x2T2.png
| image3 =cg14172x2T3.png
| image4 =cg14172x2T5.png
| footer_align = left
| footer = Figure 6 - Results of running the ILfinalframe.py file at T=1,2,3,5 for a 2x2 matrix.
}}

 

For a 2x2 matrix, a suitable cut-off point to exclude from the avergage energies and magnetisations is where the energy and magnetisations per spin are constant, which is 30 steps. For T=3 and T=5 the graphs do not converge because it is possible that these temperatures are higher than the Curie Temperature and as such spontaneous magnetisation will not occur and the system will not diverge to the lowest energy state. At the higher temperatures, there are larger thermal fluctations and the Boltzmann factor is more significant allowing the system to move away from the lowest energy state easier. As a result moving forwards, a suitable cut-off point will only be determined from T=1 and T=2 graphs for the larger matrices.

''Figure 7'' shows the results from running a 4x4 lattice at T=1,2 and 3.

{{multiple image
| width =350
| align = left
| image1 = cg14174x4T1.png
| image2 = cg14174x4T2.png
| image3 =cg14174x4T3.png
| footer_align = left
| footer = Figure 7 - Results of running the ILfinalframe.py file at T=1,2,3 for a 4x4 matrix.
}}

From ''Figure 7'', a suitable cut-off point for the energy and magnetisations is 200 as this is after where the energy and magnetisation has converged for T=1, and is after the initial large drop in energy for T=2, even though there are a few small fluctuations after 200 steps. The result from T=3 has been included to show the large fluctuations for the larger temperatures, and supporting my choice to determine the cut-off from T=1 and T=2 only.

''Figure 8'' shows the results for an 8x8 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg14178x8T1.png
| image2 = cg14178x8T2.png
| footer_align = left
| footer = Figure 8 - Results of running the ILfinalframe.py file at T=1,2 for an 8x8 matrix
}}

From ''Figure 8'' above, a suitable cut-off point is 1000 steps as this is where the energy and magnetisation has easily converged by and is also the point after which the initial large drop in energy has been overcome for T=2 too.

''Figure 9'' shows the result of running the ILfinalframe.py for a 16x16 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg141716x16T1.png
| image2 = cg141716x16T2.png
| footer_align = left
| footer = Figure 9 - Results of running the ILfinalframe.py file at T=1,2 for a 16x16 matrix
}}

From ''Figure 9'', a suitable cut-off point is 15000 steps as for T=1 the energy and magnetisations have converged significantly and will not change much, and likewise this is the same for the T=2 frame.

''Figure 10'' below shows the results from a 32x32 matrix at T=1 and T=2.

{{multiple image
| width =350
| align = left
| image1 = cg141732x32T1.png
| image2 = cg141732x32T2.png
| footer_align = left
| footer = Figure 10 - Results of running the ILfinalframe.py file at T=1,2 for a 32x32 matrix
}}

''Figure 10'' above shows the results of running the ILfinalframe.py file for a 32x32 matrix at T=1 and T=2. As a result a suitable cut-off of 50000 steps was chosen as the energy and magnetisation has significantly converged, but not as much as it could at 100000 steps. I chose a slightly lower value to ensure that the run times of my monte-carlo simulations in future tasks were not extremely time consuming.

The montecarlostep() function was changed by adding a condition that values only above the pre-determined cut-off were included when determining the average value of energy; energy squared; magnetisation and magnetisations squared from the statistics function. The statistics() function did not need to be modified.

The following code is from the 32x32 matrixː

<pre>def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back

if self.n_cycles > 50000: #only adds values to array of E,E2,M and M2 is above specific cut-off
self.E+=[self.energy()]
self.E2+=[self.energy()**2]
self.M+=[self.magnetisation()]
self.M2+=[self.magnetisation()**2]
self.n_cycles=self.n_cycles+1

return (self.energy(),self.magnetisation())
</pre>

===TASK: Use ILtemperaturerange.py to plot the average energy and magnetisation for each temperature, with error bars, for an <math>8\times 8</math> lattice. Use your intuition and results from the script ILfinalframe.py to estimate how many cycles each simulation should be. The temperature range 0.25 to 5.0 is sufficient. Use as many temperature points as you feel necessary to illustrate the trend, but do not use a temperature spacing larger than 0.5. The NumPy function savetxt() stores your array of output data on disk — you will need it later. Save the file as 8x8.dat so that you know which lattice size it came from.===

Using the modified code, the file ILtemperaturerange.py was ran on an 8x8 matrix between T=0.5 and T=5 with a step of T=0.02 for 10000 Montecarlo steps and the first 1000 steps of each temperature were excluded when calculating the averages. ''Figure 11'' shows the result of the simulation and also included error bars of standard deviation.

[[File:Cg14178x8error.png|1000px|thumb|left|Figure 11 - Graph showing average energy and average magnetisation for an 8x8 lattice with error bars between T=0.5 and T=5]]

 

Below is the source code for the script to produce the graphː

<pre>data8x8=np.loadtxt('8x8.dat') #loads data
temps8x8=data8x8[:,0] #stores temperatures
energies8x8=data8x8[:,1] #stores average energy for each T
energysq8x8=data8x8[:,2] #stores average energy squared for each T
mag8x8=data8x8[:,3] #stores magnetisation for each T
magsq8x8=data8x8[:,4] #stores magnetisation squared for each T
stde8x8=data8x8[:,5] #edited ILtemperaturerange.py to record the standard deviation of the energy for each T
stdm8x8=data8x8[:,6] #edited ILtemperaturerange.py to record the standard deviation of the magnetisation for each T

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.errorbar(temps8x8, np.array(energies8x8)/64,yerr=np.divide(stde8x8,64),color='black',ecolor='teal',alpha=0.8) #plots energy per spin against T
magax.errorbar(temps8x8, np.array(mag8x8)/64,yerr=np.divide(stdm8x8,64),alpha=0.8,ecolor='salmon',color='black') #plots magnetisation per spin against T on separate graph
pl.savefig('8x8error.png',bbox_inches='tight') #saves figure
pl.show()

</pre>

==Section 6 - The effect of system size==

===TASK: Repeat the final task of the previous section for the following lattice sizes: 2x2, 4x4, 8x8, 16x16, 32x32. Make sure that you name each datafile that your produce after the corresponding lattice size! Write a Python script to make a plot showing the energy per spin versus temperature for each of your lattice sizes. Hint: the NumPy loadtxt function is the reverse of the savetxt function, and can be used to read your previously saved files into the script. Repeat this for the magnetisation. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. How big a lattice do you think is big enough to capture the long range fluctuations?===

The python script for this section is identical as for the 8x8 graph above in Figure 11 with the relevant files and variables changed accordingly.

Each matrix was simulated using the ILtemperaturerange.py file between T=0.5 and T=5 with a step of T=0.02.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2error.png
| caption1 = 2x2 matrix - 5000 steps, cut-off = 30 steps
| image2 = 4x4error.png
| caption2 = 4x4 matrix - 1000 steps, cut-off = 200 steps
| image3 =cg141716x16error.png
| caption3 = 16x16 matrix - 50000 steps, cut-off = 15000 steps
| image4 =cg141732x32error.png
| caption4 = 32x32 matrix - 200000 steps, cut-off = 50000 steps
| footer_align = left
| footer = Figure 12 - Results of running the ILtemperaturerange.py file for 2x2, 4x4, 16x16 and 32x32 matrices.
}}

 

==Section 7 - Determining the Heat Capacity==

===TASK: By definition, <math>C = \frac{\partial \left\langle E\right\rangle}{\partial T}</math>. From this, show that <math>C = \frac{\mathrm{Var}[E]}{k_B T^2}</math> (Where <math>\mathrm{Var}[E]</math> is the variance in <math>E</math>.)===

Recall from statistical thermodynamics that the average energy of a system is the sum across all microstates of the probability of that microstate multiplied by the energy of that microstate, which is defined mathematically asː <math>\langle E \rangle = \sum_i p_{i}\epsilon_{i}</math>.

The partition function <math>q</math> is defined as <math>q = \sum_{i} exp(-\beta \epsilon_{i})</math> where <math>\beta =\frac{1}{k_BT}</math>and the probability, <math>p_{i}</math> can be defined in terms of the partition function as <math>p_{i} = \frac{exp(-\beta \epsilon_{i})}{\sum_{i} exp(-\beta \epsilon_{i})} = \frac{exp(-\beta \epsilon_{i})}{q}</math>.

As a result, <math>\langle E \rangle</math> can be re-written as <math>\langle E \rangle = \sum_{i} \frac{\epsilon_{i} exp(-\beta \epsilon_{i})}{q} = -\frac{1}{q} \frac{\partial}{\partial \beta}\sum_{i}exp(-\beta \epsilon_{i}) = -\frac{1}{q} \frac{\partial q}{\partial \beta}</math>

Likewise, <math>\langle E^2 \rangle = \sum_i p_{i}\epsilon_{i}^{2} = \sum_{i} \frac{\epsilon_{i}^{2}exp(-\beta \epsilon_{i})}{q} = \frac{1}{q} \frac{\partial^{2}}{\partial \beta^{2}}\sum_{i}exp(-\beta \epsilon_{i}) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}}</math>

From definitionː <math>Var[E] = \Delta E^2 = \langle E^2 \rangle - \langle E \rangle^2 </math>

When the definition of <math>\langle E \rangle</math> and <math>\langle E^2 \rangle</math> is written in terms of partition function <math>q</math>ː <math>Var[E] = \langle E^2 \rangle - \langle E \rangle^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \left(\frac{1}{q}\frac{\partial q}{\partial \beta}\right)^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2</math>.

According to the chain ruleː <math>\frac{\partial}{\partial \beta}\left(\frac{1}{q} \frac{\partial q}{\partial \beta}\right) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2 = -\frac{\partial}{\partial \beta}\langle E \rangle = Var[E]</math>

And using the chain rule againː <math>C = \frac{\partial \langle E \rangle}{\partial T}= \left(-\frac{\partial \langle E \rangle}{\partial \beta}\right) \left(-\frac{\partial \beta}{\partial T}\right) = \frac{Var[E]}{k_B T^2}</math>

===TASK: Write a Python script to make a plot showing the heat capacity versus temperature for each of your lattice sizes from the previous section. You may need to do some research to recall the connection between the variance of a variable, <math>\mathrm{Var}[X]</math>, the mean of its square <math>\left\langle X^2\right\rangle</math>, and its squared mean <math>\left\langle X\right\rangle^2</math>. You may find that the data around the peak is very noisy — this is normal, and is a result of being in the critical region. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. ===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb

{{multiple image
| width =300
| align = left
| image1 = cg14172x2heatcap.png
| caption1 = 2x2 Matrix
| image2 = cg14174x4heatcap.png
| caption2 = 4x4 Matrix
| image3 =cg14178x8heatcap.png
| caption3 = 8x8 Matrix
| image4 =cg141716x16heatcap.png
| caption4 = 16x16 Matrix
| image5=cg141732x32heatcap.png
| caption5= 32x32 Matrix
| footer = Figure 13 - Graphs showing Heat Capacity against Temperature for each matrix size
}}

Here is the source code to produce the figuresː
<pre> def heatCap(energies,energysq,T,latsize):
#defines the heat capacity for a given temperature
energiesq=np.multiply(energies,energies) #creates array of (average energies) squared
varE=np.subtract(energysq,energiesq) #defines variance of average energy
tempsq=np.multiply(T,T) #array of temperature squared
return np.array(np.divide(varE,tempsq))/(latsize**2)

heatCap2x2=heatCap(energies2x2,energysq2x2,temps2x2,2) #creates array of heat capacity for each T

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(temps2x2,heatCap2x2,color='orange') #plots heat capacity for each T
pl.savefig('cg14172x2heatcap.png',bbox_inches='tight') #saves figure
pl.show()
</pre>

A general trend from the above graphs is that the peak of the graph shifts towards lower temperatures as the size of the matrix used increases.

==Section 8 - Locating the Curie Temperature==
===TASK: A C++ program has been used to run some much longer simulations than would be possible on the college computers in Python. You can view its source code here if you are interested. Each file contains six columns: <math>T, E, E^2, M, M^2, C</math> (the final five quantities are per spin), and you can read them with the NumPy loadtxt function as before. For each lattice size, plot the C++ data against your data. For one lattice size, save a PNG of this comparison and add it to your report — add a legend to the graph to label which is which. To do this, you will need to pass the label="..." keyword to the plot function, then call the legend() function of the axis object (documentation here).===

The python code used to read and plot the C++ data is found in the Jupyter notebook CG1417IsingModelGraphs.ipynb.

''Figure 14'' below shows the C++ plotted against my own data for a 16x16 Matrix.

[[File:Cg141716x16C++.png|400px|thumb|left|Figure 14 - Graph showing my own data against the C++ data for a 16x16 matrix.]]

 

Here is the source code the produce the figuresː
<pre>#fitting C++ data

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.plot(temps2x2, np.array(energies2x2)/4,color='black',alpha=0.7,label='Python Data') #python energy against T
enerax.plot(temps2x2C, energies2x2C, color='red',label='C++ Data') #C energy against T
magax.plot(temps2x2, np.array(mag2x2)/4,color='black',alpha=0.7,label='Python Data') #python magnetisation against T
magax.plot(temps2x2C, mag2x2C,color='red',label='C++ Data') #C energy against T
enerax.legend() #shows legend on energy graph
magax.legend() #shows legend on energy graph
pl.show()
</pre>

The relevant variables and dat files were changed for each matrix.

===TASK: write a script to read the data from a particular file, and plot C vs T, as well as a fitted polynomial. Try changing the degree of the polynomial to improve the fit — in general, it might be difficult to get a good fit! Attach a PNG of an example fit to your report.===

The python script to read and plot the fitted polynomial is found in CG1417PolyfitScript.ipynb

Here is the source code for ''Figure 15''

<pre>data_test = np.loadtxt("16x16C.dat")
T_test = data_test[:,0] #gets temperatures
C_test = data_test[:,5] #gets heat capacity data

#first we fit the polynomial to the data
fit_test = np.polyfit(T_test, C_test, 35) # fit a polynomial

#now we generate interpolated values of the fitted polynomial over the range of our function
T_min_test = 0.5 #np.min(T_test)
T_max_test = 5 #np.max(T_test)

T_range_test = np.linspace(T_min_test, T_max_test, 1000) #generate 1000 evenly spaced points between T_min and T_max
fitted_C_values_test = np.polyval(fit_test, T_range_test)# use the fit object to generate the corresponding values of C

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(T_test,C_test,color='orange',label='C++ Data') #plots C data of heat capacity against temp
heatcapax.plot(T_range_test,fitted_C_values_test,label='Fitted Polynomial') #plots fitted polynomial for whole range of temp
heatcapax.legend()
pl.savefig('FIT_TEST16x16_35.png', bbox_inches='tight') #saves figure
pl.show()
</pre>

Below in ''Figure 15'' is a plot of my Heat Capacity against Temperature data for a 16x16 matrix and features a polynomial of degree 35 plotted against it. Even with a polynomial of such a high degree, it poorly fits the curve and does not fit to the peak of the curve either.

[[File:cg1417FIT_TEST16x16_35.png|thumb|left|400px|Figure 15 - Plot of Heat Capacity against Temperature along with a poorly fitted polynomial of degree 35. ]]

 

===TASK: Modify your script from the previous section. You should still plot the whole temperature range, but fit the polynomial only to the peak of the heat capacity! You should find it easier to get a good fit when restricted to this region===

The script was modified as such that the polynomial was fitted in a set range around the peak of the graph, this is demonstrated in ''Figure 17'' which shows a newly fitted polynomial between a much smaller range of temperatures (T = 2.15-2.55) and a much smaller degree polynomial (3).

[[File:CG1417FIT_16x16C_3.png|thumb|left|400px|Figure 16 - Graph showing Heat Capacity against Temperature for a 16x16 matrix along with a fitted polynomial between a much more restricted range of temperatures and a significantly lower degree of polynomial]]

Upon comparison with ''Figure 15'', the new fitted polynomial is a significantly better fit even for a 3rd degree polynomial and is a much more accurate representation of my data around the peak of the graph and will make it easier to determine the maximum value of Heat Capacity.

 

===TASK: find the temperature at which the maximum in C occurs for each datafile that you were given. Make a text file containing two colums: the lattice side length (2,4,8, etc.), and the temperature at which C is a maximum. This is your estimate of <math>T_C</math> for that side length. Make a plot that uses the scaling relation given above to determine <math>T_{C,\infty}</math>. By doing a little research online, you should be able to find the theoretical exact Curie temperature for the infinite 2D Ising lattice. How does your value compare to this? Are you surprised by how good/bad the agreement is? Attach a PNG of this final graph to your report, and discuss briefly what you think the major sources of error are in your estimate.===

''Figure 17'' below shows a graph of <math>T_{C,L}</math> against <math>\frac{1}{Lattice Size}</math> to determine the Curie Temperature of an infinite 2D Ising Model Lattice <math>T_{C,\infty}</math>. The black dots represent the raw data obtained from obtaining the temperature at which the Heat Capacity was a maximum for the lattices and the red line in a linear curve fit plotted against the data to allow the y-intercept which is the Curie Temperature for the infinite 2D lattice to be determined.

[[File:cg1417CurieTemp.png|400px|thumb|left|Figure 17 - Plot of 1/Lattice Size against Curie Temperature for that lattice size.]]

The value for <math>T_{C,\inf}</math> obtained from the data is <math>T_{C,\infty} = 2.277 \frac{J}{k_B}</math> with a literature value being <math>T_{C,\infty} = 2.269 \frac{J}{k_B}</math> <ref>L. Onsager, Phys. Rev., 1944, 65, 117--149.</ref>for an infinite square 2D lattice. This means that my result slightly over-estimates the Curie Temperature for the infinite lattice and as a result for an infinite lattice the temperature at which spontaneous magnetisation stops would actually occur at a slightly lower temperature than expected. However, the difference between my value and the literature value is only 0.008 which is incredibly small and the amount of agreement between the two values is somewhat surprising, which means that the error in my estimates of the Curie Temperature for each lattice size is relatively small. The points which have the largest residuals and deviation from the line of best fit in ''Figure 17'' corresponds to the smaller lattice sizes of 2x2 and 4x4 where longer range interactions are more significant. The longer range interactions posed by the boundary conditions are nowhere near as significant for the larger sizes and causes the energy of the smaller matrices to be less accurate and have a larger associated error with the energy and thus the Curie Temperature for that lattice size. This affects the accuracy of the line of best fit and to increase the accuracy of this line, larger lattice sizes of 128x128, 256x256 etc should be included in the calculation for the line of best fit and the smaller matrices ignored.

 

== References ==

Rep:Y3CMPCG1417

2019-11-20T09:28:23Z

==Section 1 - Introduction to the Ising Model==

===TASK: Show that the lowest possible energy for the Ising model is <math>E = -DNJ</math>, where D is the number of dimensions and N is the total number of spins. What is the multiplicity of this state? Calculate its entropy.===

Consider a 1D row of lattice sites of N=3 with spin configuration [+1][+1][+1].

Mathematically the interaction energy is defined asː
<math> -\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} </math> where J is a constant and <math>s_{i}s_{j}</math> is the product between two spins in adjacent lattice sites.

The sum of the interaction energies <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j}</math> can be considered as the sum of the individual interaction energies between spinsː
<math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = \epsilon_{12} + \epsilon_{23} + \epsilon_{13} + \epsilon_{21} + \epsilon_{32} + \epsilon_{31} </math>.

Although lattice sites 1 and 3 are not adjacent they are said to still interact according to the periodic boundary conditions applied.

However, <math>\epsilon_{12} = \epsilon_{21} </math> and <math>\epsilon_{23} = \epsilon_{32}</math> and <math>\epsilon_{13} = \epsilon_{31}</math> which means that all of the interactions within the system are counted twice, hence the total energy needs to be halved, resulting in the following formula being obtainedː <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = 2\epsilon_{12} + 2\epsilon_{13} + 2\epsilon_{23} </math>.

It can be determined that <math>\epsilon_{12} = (+1)(+1) = 1</math> , <math>\epsilon_{13} = (+1)(+1) = 1</math> and <math>\epsilon_{23} = (+1)(+1) = 1</math>.

Thereforeː <math>-\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = -\frac{1}{2} \ J \ (2 + 2 + 2) = -\frac{1}{2} \ J \ 6 = - 3 J = -DNJ</math> for a 1D lattice with <math>D=1</math> and 3 lattice sites <math>N=3</math>

The multiplicity of the system,<math>\Omega = \frac{n. spin up!}{n. spin down!}</math>

Entropy, <math>S</math> is defined as <math>S = k_B ln(\Omega)</math> and so in this case <math>S = k_B ln(\frac{100!}{100!}) = 0</math>

===TASK: Imagine that the system is in the lowest energy configuration. To move to a different state, one of the spins must spontaneously change direction ("flip"). What is the change in energy if this happens <math>(D=3, N=1000)</math>? How much entropy does the system gain by doing soʔ===

In a 3D lattice system, each lattice site has three unique interactions with its neighbours to its left, top and front. In the lowest energy configuration, all spins are parallel and for a system the minimum energy is <math>E = -DNJ</math>, so for the system with <math>N=1000</math> and <math>D=3</math>, the minimum energy is <math>-3000J</math>.

If a single spin is flipped, the product of its spin with its neighbours spin reverses and becomes negative and this increases the total energy of the system. Since 3 unique spin-spin interactions are reversed in sign, the total energy increases by <math>+3J</math>, meaning the new total energy is <math>-2997J</math>

Initially the multiplicity of the system will be <math>\Omega = \frac{1000!}{1000!}</math> , and after the flip, the multiplicity becomes <math> \Omega = \frac{1000!}{999!1!}=1000</math>.

The associated change in entropy, <math>\Delta S = k_B ln(1000) - 0 = 6.91 k_B</math>, which is an expected increase in entropy as the number of possible configurations of the system increases.

===TASK: Calculate the magnetisation of the 1D and 2D lattices in Figure 1. What magnetisation would you expect to observe for an Ising lattice with <math>D = 3,\ N=1000</math> at absolute zero?===

[[File:ThirdYearCMPExpt-IsingSketch.png|thumb|left|Figure 1 - Shows 1D (N = 5), 2D (N = 5x5) and 3D (N = 5x5x5) lattices.]]

Magnetisation is defined as <math>M=\sum_{i} s_i</math>. So for the 1D lattice with <math>N = 5</math> in ''Figure 2'', <math>M = +1</math> and for the 2D lattice with <math>N = 25 , M = +1</math> too.

According to the 3rd Law of thermodynamics, entropy is 0 at absolute zero for a perfect crystalline solid, and consequently it is expected that the lattices will have follow suit and have zero entropy at 0K. To have zero entropy all spins must be parallel as such that magnetisation, <math>M = N</math>. For all the spins to be parallel, there is only one possible configuration. So, for a lattice with <math>N = 1000</math> and <math>D =3</math>, if <math>M = N</math>, then multiplicity, <math>\Omega = 1</math> and entropy, <math>S =k_B ln(1) = 0</math>.

 

==Section 2 - Calculating the Energy and Magnetisation==

===TASK: complete the functions energy() and magnetisation(), which should return the energy of the lattice and the total magnetisation, respectively. In the energy() function you may assume that <math>J=1.0</math> at all times (in fact, we are working in reduced units in which <math>J=k_B</math>, but there will be more information about this in later sections). Do not worry about the efficiency of the code at the moment — we will address the speed in a later part of the experiment.===

<pre>def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
lat=self.lattice #creates lattice and stores it
mag=[]
for i in range(0,len(lat)): #loops through all rows of lattice
for j in range(0,len(lat[i])): #loops through elements of each row
mag+=[lat[i][j]] #adds spin value to mag array
return sum(mag) #sums all spins from mag array
</pre>

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

lat=self.lattice #creates lattice and stores it
left=[]
top=[]

for i in range(0,len(lat)):
for j in range(0,len(lat[i])):
left+=[lat[i][j]*lat[i][j-1]] #multiplies spin by spin to left
top+=[lat[i][j]*lat[i-1][j]] #multiplies spin by spin above it
int_en=left+top #sums spin products from left and top
energy=-sum(int_en) #sums all spin products for each spin to give total

return energy
</pre>

===TASK: Run the ILcheck.py script from the IPython Qt console using the command===

''Figure 2'' shows the results when ILcheck.py was ran on my IsingLattice.py file. The ILcheck.py file was ran several times to ensure the code worked for various random lattices.

[[File:Cg1417ILcheck run.png|thumb|left|500px| Figure 2 - Result from running the ILcheck.py file]]

 

==Section 3 - Introduction to Monte Carlo Simulation==

===TASK: How many configurations are available to a system with 100 spins? To evaluate these expressions, we have to calculate the energy and magnetisation for each of these configurations, then perform the sum. Let's be very, very, generous, and say that we can analyse <math>1\times 10^9</math> configurations per second with our computer. How long will it take to evaluate a single value of <math>\left\langle M\right\rangle_T</math>?===

For a system with 100 lattice sites and two possible spins for each site, there are <math>2^{100}</math>possible configurations for the system. <math>2^{100}= 1.27\times 10^{30} </math>, so if the computer can analyse <math>1\times 10^9</math> configurations per second, then it will take <math>\frac{1.27\times 10^{30}}{10^9} = 1.27\times 10^{21} s</math> to analyse the whole system, which is longer than the age of the universe and therefore is not a practical approach.

===TASK: Implement a single cycle of the above algorithm in the montecarlocycle(T) function. This function should return the energy of your lattice and the magnetisation at the end of the cycle. You may assume that the energy returned by your energy() function is in units of <math>k_B</math>! Complete the statistics() function. This should return the following quantities whenever it is called: <math><E>, <E^2>, <M>, <M^2></math>, and the number of Monte Carlo steps that have elapsed.===
<pre>
E = []
E2 = []
M = []
M2 = []
n_cycles = 0

def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back if rejected else not changed

self.E+=[self.energy()] #records energy
self.E2+=[self.energy()**2] #records energy squared
self.M+=[self.magnetisation()] #records magnetisation
self.M2+=[self.magnetisation()**2] #records magnetisation squared
self.n_cycles=self.n_cycles+1 #adds 1 to run total

return (self.energy(),self.magnetisation())

def statistics(self):
# complete this function so that it calculates the correct values for the averages of E, E*E (E2), M, M*M (M2), and returns them

e=np.mean(self.E)
e2=np.mean(self.E2)
m=np.mean(self.M)
m2=np.mean(self.M2)

return e,e2,m,m2,self.n_cycles
</pre>

===TASK: If <math>T < T_C</math>, do you expect a spontaneous magnetisation (i.e. do you expect <math>\left\langle M\right\rangle \neq 0</math>)? When the state of the simulation appears to stop changing (when you have reached an equilibrium state), use the controls to export the output to PNG and attach this to your report. You should also include the output from your statistics() function.===

If the temperature of the system is less than the Curie Temperature, <math>T_C</math> then spontaneous magnetisation can occur and the system will tend to its lowest energy state where all of the spins are parallel - this is a property of ferromagnetic materials.

[[File:Cg1417ILanim_run.png|400px|thumb|left|Figure 3 - Results from running the ILanim.py file - shows the energy and magnetisation converging over time]]

''Figure 3'' shows that over time the the system spontaneously converges to the minimum energy state with all of the spins parallel to one another and shows, as I expected, that spontaneous magnetisation occurs and also shows that the temperature of this simulation is below the Curie Temperature, <math>T < T_C</math>.

 

==Section 4 - Accelerating the Code==

===TASK: Use the script ILtimetrial.py to record how long your current version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 4'' show the results of running the ILtimetrial.py file on my code three timesː

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1.png
| width1=500
| image2=cg1417ILtimetrial_run2.png
| width2=500
| image3=cg1417ILtimetrial_run3.png
| width3=500
| footer = Figure 4 - Results of running the ILtimetrial.py file on my code three separate times
}}
 

This gave me an avergage time of <math>24.3 s \pm 0.2s</math>

===TASK: Look at the documentation for the NumPy sum function. You should be able to modify your magnetisation() function so that it uses this to evaluate M. The energy is a little trickier. Familiarise yourself with the NumPy roll and multiply functions, and use these to replace your energy double loop (you will need to call roll and multiply twice!).===

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

left=multiply(roll(self.lattice,1,axis=1),self.lattice) #product of spin with spin left of it
top=multiply(roll(self.lattice,-1,axis=0),self.lattice) #product of spin with spin above it

int_en=sum(left+top) #sum of array containing sum of left and top spin products for each spin

energy = -sum(int_en) #calculates the total energy of system
return energy

def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
return sum(sum(self.lattice)) #adds up all spins in lattice
</pre>

===TASK: Use the script ILtimetrial.py to record how long your new version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 5'' shows the result of running the ILtimetrial.py on my new accelerated code.

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1fast.png
| width1=500
| image2=ILtimetrial_run2fast.png
| width2=500
| image3=ILtimetrial_run3fast.png
| width3=500
| footer = Figure 5 - Results of running the ILtimetrial.py file on my new updated and accelerated code.
}}
 

The accelerated code is much faster upon using the roll, multiply and sum modules with a new average time of <math>0.790 s \pm 0.005 </math>

==Section 5 - The effect of temperature==

===TASK: The script ILfinalframe.py runs for a given number of cycles at a given temperature, then plots a depiction of the final lattice state as well as graphs of the energy and magnetisation as a function of cycle number. This is much quicker than animating every frame! Experiment with different temperature and lattice sizes. How many cycles are typically needed for the system to go from its random starting position to the equilibrium state? Modify your statistics() and montecarlostep() functions so that the first N cycles of the simulation are ignored when calculating the averages. You should state in your report what period you chose to ignore, and include graphs from ILfinalframe.py to illustrate your motivation in choosing this figure.===

''Figure 6'' below shows the results from running the ILfinalframe.py for 2x2 lattice at T=1,2,3,5.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2T1.png
| image2 = cg14172x2T2.png
| image3 =cg14172x2T3.png
| image4 =cg14172x2T5.png
| footer_align = left
| footer = Figure 6 - Results of running the ILfinalframe.py file at T=1,2,3,5 for a 2x2 matrix.
}}

 

For a 2x2 matrix, a suitable cut-off point to exclude from the avergage energies and magnetisations is where the energy and magnetisations per spin are constant, which is 30 steps. For T=3 and T=5 the graphs do not converge because it is possible that these temperatures are higher than the Curie Temperature and as such spontaneous magnetisation will not occur and the system will not diverge to the lowest energy state. At the higher temperatures, there are larger thermal fluctations and the Boltzmann factor is more significant allowing the system to move away from the lowest energy state easier. As a result moving forwards, a suitable cut-off point will only be determined from T=1 and T=2 graphs for the larger matrices.

''Figure 7'' shows the results from running a 4x4 lattice at T=1,2 and 3.

{{multiple image
| width =350
| align = left
| image1 = cg14174x4T1.png
| image2 = cg14174x4T2.png
| image3 =cg14174x4T3.png
| footer_align = left
| footer = Figure 7 - Results of running the ILfinalframe.py file at T=1,2,3 for a 4x4 matrix.
}}

From ''Figure 7'', a suitable cut-off point for the energy and magnetisations is 200 as this is after where the energy and magnetisation has converged for T=1, and is after the initial large drop in energy for T=2, even though there are a few small fluctuations after 200 steps. The result from T=3 has been included to show the large fluctuations for the larger temperatures, and supporting my choice to determine the cut-off from T=1 and T=2 only.

''Figure 8'' shows the results for an 8x8 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg14178x8T1.png
| image2 = cg14178x8T2.png
| footer_align = left
| footer = Figure 8 - Results of running the ILfinalframe.py file at T=1,2 for an 8x8 matrix
}}

From ''Figure 8'' above, a suitable cut-off point is 1000 steps as this is where the energy and magnetisation has easily converged by and is also the point after which the initial large drop in energy has been overcome for T=2 too.

''Figure 9'' shows the result of running the ILfinalframe.py for a 16x16 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg141716x16T1.png
| image2 = cg141716x16T2.png
| footer_align = left
| footer = Figure 9 - Results of running the ILfinalframe.py file at T=1,2 for a 16x16 matrix
}}

From ''Figure 9'', a suitable cut-off point is 15000 steps as for T=1 the energy and magnetisations have converged significantly and will not change much, and likewise this is the same for the T=2 frame.

''Figure 10'' below shows the results from a 32x32 matrix at T=1 and T=2.

{{multiple image
| width =350
| align = left
| image1 = cg141732x32T1.png
| image2 = cg141732x32T2.png
| footer_align = left
| footer = Figure 10 - Results of running the ILfinalframe.py file at T=1,2 for a 32x32 matrix
}}

''Figure 10'' above shows the results of running the ILfinalframe.py file for a 32x32 matrix at T=1 and T=2. As a result a suitable cut-off of 50000 steps was chosen as the energy and magnetisation has significantly converged, but not as much as it could at 100000 steps. I chose a slightly lower value to ensure that the run times of my monte-carlo simulations in future tasks were not extremely time consuming.

The montecarlostep() function was changed by adding a condition that values only above the pre-determined cut-off were included when determining the average value of energy; energy squared; magnetisation and magnetisations squared from the statistics function. The statistics() function did not need to be modified.

The following code is from the 32x32 matrixː

<pre>def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back

if self.n_cycles > 50000: #only adds values to array of E,E2,M and M2 is above specific cut-off
self.E+=[self.energy()]
self.E2+=[self.energy()**2]
self.M+=[self.magnetisation()]
self.M2+=[self.magnetisation()**2]
self.n_cycles=self.n_cycles+1

return (self.energy(),self.magnetisation())
</pre>

===TASK: Use ILtemperaturerange.py to plot the average energy and magnetisation for each temperature, with error bars, for an <math>8\times 8</math> lattice. Use your intuition and results from the script ILfinalframe.py to estimate how many cycles each simulation should be. The temperature range 0.25 to 5.0 is sufficient. Use as many temperature points as you feel necessary to illustrate the trend, but do not use a temperature spacing larger than 0.5. The NumPy function savetxt() stores your array of output data on disk — you will need it later. Save the file as 8x8.dat so that you know which lattice size it came from.===

Using the modified code, the file ILtemperaturerange.py was ran on an 8x8 matrix between T=0.5 and T=5 with a step of T=0.02 for 10000 Montecarlo steps and the first 1000 steps of each temperature were excluded when calculating the averages. ''Figure 11'' shows the result of the simulation and also included error bars of standard deviation.

[[File:Cg14178x8error.png|1000px|thumb|left|Figure 11 - Graph showing average energy and average magnetisation for an 8x8 lattice with error bars between T=0.5 and T=5]]

 

Below is the source code for the script to produce the graphː

<pre>data8x8=np.loadtxt('8x8.dat') #loads data
temps8x8=data8x8[:,0] #stores temperatures
energies8x8=data8x8[:,1] #stores average energy for each T
energysq8x8=data8x8[:,2] #stores average energy squared for each T
mag8x8=data8x8[:,3] #stores magnetisation for each T
magsq8x8=data8x8[:,4] #stores magnetisation squared for each T
stde8x8=data8x8[:,5] #edited ILtemperaturerange.py to record the standard deviation of the energy for each T
stdm8x8=data8x8[:,6] #edited ILtemperaturerange.py to record the standard deviation of the magnetisation for each T

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.errorbar(temps8x8, np.array(energies8x8)/64,yerr=np.divide(stde8x8,64),color='black',ecolor='teal',alpha=0.8) #plots energy per spin against T
magax.errorbar(temps8x8, np.array(mag8x8)/64,yerr=np.divide(stdm8x8,64),alpha=0.8,ecolor='salmon',color='black') #plots magnetisation per spin against T on separate graph
pl.savefig('8x8error.png',bbox_inches='tight') #saves figure
pl.show()

</pre>

==Section 6 - The effect of system size==

===TASK: Repeat the final task of the previous section for the following lattice sizes: 2x2, 4x4, 8x8, 16x16, 32x32. Make sure that you name each datafile that your produce after the corresponding lattice size! Write a Python script to make a plot showing the energy per spin versus temperature for each of your lattice sizes. Hint: the NumPy loadtxt function is the reverse of the savetxt function, and can be used to read your previously saved files into the script. Repeat this for the magnetisation. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. How big a lattice do you think is big enough to capture the long range fluctuations?===

The python script for this section is identical as for the 8x8 graph above in Figure 11 with the relevant files and variables changed accordingly.

Each matrix was simulated using the ILtemperaturerange.py file between T=0.5 and T=5 with a step of T=0.02.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2error.png
| caption1 = 2x2 matrix - 5000 steps, cut-off = 30 steps
| image2 = 4x4error.png
| caption2 = 4x4 matrix - 1000 steps, cut-off = 200 steps
| image3 =cg141716x16error.png
| caption3 = 16x16 matrix - 50000 steps, cut-off = 15000 steps
| image4 =cg141732x32error.png
| caption4 = 32x32 matrix - 200000 steps, cut-off = 50000 steps
| footer_align = left
| footer = Figure 12 - Results of running the ILtemperaturerange.py file for 2x2, 4x4, 16x16 and 32x32 matrices.
}}

 

==Section 7 - Determining the Heat Capacity==

===TASK: By definition, <math>C = \frac{\partial \left\langle E\right\rangle}{\partial T}</math>. From this, show that <math>C = \frac{\mathrm{Var}[E]}{k_B T^2}</math> (Where <math>\mathrm{Var}[E]</math> is the variance in <math>E</math>.)===

Recall from statistical thermodynamics that the average energy of a system is the sum across all microstates of the probability of that microstate multiplied by the energy of that microstate, which is defined mathematically asː <math>\langle E \rangle = \sum_i p_{i}\epsilon_{i}</math>.

The partition function <math>q</math> is defined as <math>q = \sum_{i} exp(-\beta \epsilon_{i})</math> where <math>\beta =\frac{1}{k_BT}</math>and the probability, <math>p_{i}</math> can be defined in terms of the partition function as <math>p_{i} = \frac{exp(-\beta \epsilon_{i})}{\sum_{i} exp(-\beta \epsilon_{i})} = \frac{exp(-\beta \epsilon_{i})}{q}</math>.

As a result, <math>\langle E \rangle</math> can be re-written as <math>\langle E \rangle = \sum_{i} \frac{\epsilon_{i} exp(-\beta \epsilon_{i})}{q} = -\frac{1}{q} \frac{\partial}{\partial \beta}\sum_{i}exp(-\beta \epsilon_{i}) = -\frac{1}{q} \frac{\partial q}{\partial \beta}</math>

Likewise, <math>\langle E^2 \rangle = \sum_i p_{i}\epsilon_{i}^{2} = \sum_{i} \frac{\epsilon_{i}^{2}exp(-\beta \epsilon_{i})}{q} = \frac{1}{q} \frac{\partial^{2}}{\partial \beta^{2}}\sum_{i}exp(-\beta \epsilon_{i}) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}}</math>

From definitionː <math>Var[E] = \Delta E^2 = \langle E^2 \rangle - \langle E \rangle^2 </math>

When the definition of <math>\langle E \rangle</math> and <math>\langle E^2 \rangle</math> is written in terms of partition function <math>q</math>ː <math>Var[E] = \langle E^2 \rangle - \langle E \rangle^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \left(\frac{1}{q}\frac{\partial q}{\partial \beta}\right)^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2</math>.

According to the chain ruleː <math>\frac{\partial}{\partial \beta}\left(\frac{1}{q} \frac{\partial q}{\partial \beta}\right) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2 = -\frac{\partial}{\partial \beta}\langle E \rangle = Var[E]</math>

And using the chain rule againː <math>C = \frac{\partial \langle E \rangle}{\partial T}= \left(-\frac{\partial \langle E \rangle}{\partial \beta}\right) \left(-\frac{\partial \beta}{\partial T}\right) = \frac{Var[E]}{k_B T^2}</math>

===TASK: Write a Python script to make a plot showing the heat capacity versus temperature for each of your lattice sizes from the previous section. You may need to do some research to recall the connection between the variance of a variable, <math>\mathrm{Var}[X]</math>, the mean of its square <math>\left\langle X^2\right\rangle</math>, and its squared mean <math>\left\langle X\right\rangle^2</math>. You may find that the data around the peak is very noisy — this is normal, and is a result of being in the critical region. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. ===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb

{{multiple image
| width =300
| align = left
| image1 = cg14172x2heatcap.png
| caption1 = 2x2 Matrix
| image2 = cg14174x4heatcap.png
| caption2 = 4x4 Matrix
| image3 =cg14178x8heatcap.png
| caption3 = 8x8 Matrix
| image4 =cg141716x16heatcap.png
| caption4 = 16x16 Matrix
| image5=cg141732x32heatcap.png
| caption5= 32x32 Matrix
| footer = Figure 13 - Graphs showing Heat Capacity against Temperature for each matrix size
}}

Here is the source code to produce the figuresː
<pre> def heatCap(energies,energysq,T,latsize):
#defines the heat capacity for a given temperature
energiesq=np.multiply(energies,energies) #creates array of (average energies) squared
varE=np.subtract(energysq,energiesq) #defines variance of average energy
tempsq=np.multiply(T,T) #array of temperature squared
return np.array(np.divide(varE,tempsq))/(latsize**2)

heatCap2x2=heatCap(energies2x2,energysq2x2,temps2x2,2) #creates array of heat capacity for each T

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(temps2x2,heatCap2x2,color='orange') #plots heat capacity for each T
pl.savefig('cg14172x2heatcap.png',bbox_inches='tight') #saves figure
pl.show()
</pre>

A general trend from the above graphs is that the peak of the graph shifts towards lower temperatures as the size of the matrix used increases.

==Section 8 - Locating the Curie Temperature==
===TASK: A C++ program has been used to run some much longer simulations than would be possible on the college computers in Python. You can view its source code here if you are interested. Each file contains six columns: <math>T, E, E^2, M, M^2, C</math> (the final five quantities are per spin), and you can read them with the NumPy loadtxt function as before. For each lattice size, plot the C++ data against your data. For one lattice size, save a PNG of this comparison and add it to your report — add a legend to the graph to label which is which. To do this, you will need to pass the label="..." keyword to the plot function, then call the legend() function of the axis object (documentation here).===

The python code used to read and plot the C++ data is found in the Jupyter notebook CG1417IsingModelGraphs.ipynb.

''Figure 14'' below shows the C++ plotted against my own data for a 16x16 Matrix.

[[File:Cg141716x16C++.png|400px|thumb|left|Figure 14 - Graph showing my own data against the C++ data for a 16x16 matrix.]]

 

Here is the source code the produce the figuresː
<pre>#fitting C++ data

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.plot(temps2x2, np.array(energies2x2)/4,color='black',alpha=0.7,label='Python Data') #python energy against T
enerax.plot(temps2x2C, energies2x2C, color='red',label='C++ Data') #C energy against T
magax.plot(temps2x2, np.array(mag2x2)/4,color='black',alpha=0.7,label='Python Data') #python magnetisation against T
magax.plot(temps2x2C, mag2x2C,color='red',label='C++ Data') #C energy against T
enerax.legend() #shows legend on energy graph
magax.legend() #shows legend on energy graph
pl.show()
</pre>

The relevant variables and dat files were changed for each matrix.

===TASK: write a script to read the data from a particular file, and plot C vs T, as well as a fitted polynomial. Try changing the degree of the polynomial to improve the fit — in general, it might be difficult to get a good fit! Attach a PNG of an example fit to your report.===

The python script to read and plot the fitted polynomial is found in CG1417PolyfitScript.ipynb

Below in ''Figure 15'' is a plot of my Heat Capacity against Temperature data for a 16x16 matrix and features a polynomial of degree 35 plotted against it. Even with a polynomial of such a high degree, it poorly fits the curve and does not fit to the peak of the curve either.

[[File:cg1417FIT_TEST16x16_35.png|thumb|left|400px|Figure 15 - Plot of Heat Capacity against Temperature along with a poorly fitted polynomial of degree 35. ]]

 

===TASK: Modify your script from the previous section. You should still plot the whole temperature range, but fit the polynomial only to the peak of the heat capacity! You should find it easier to get a good fit when restricted to this region===

The script was modified as such that the polynomial was fitted in a set range around the peak of the graph, this is demonstrated in ''Figure 17'' which shows a newly fitted polynomial between a much smaller range of temperatures (T = 2.15-2.55) and a much smaller degree polynomial (3).

[[File:CG1417FIT_16x16C_3.png|thumb|left|400px|Figure 16 - Graph showing Heat Capacity against Temperature for a 16x16 matrix along with a fitted polynomial between a much more restricted range of temperatures and a significantly lower degree of polynomial]]

Upon comparison with ''Figure 15'', the new fitted polynomial is a significantly better fit even for a 3rd degree polynomial and is a much more accurate representation of my data around the peak of the graph and will make it easier to determine the maximum value of Heat Capacity.

 

===TASK: find the temperature at which the maximum in C occurs for each datafile that you were given. Make a text file containing two colums: the lattice side length (2,4,8, etc.), and the temperature at which C is a maximum. This is your estimate of <math>T_C</math> for that side length. Make a plot that uses the scaling relation given above to determine <math>T_{C,\infty}</math>. By doing a little research online, you should be able to find the theoretical exact Curie temperature for the infinite 2D Ising lattice. How does your value compare to this? Are you surprised by how good/bad the agreement is? Attach a PNG of this final graph to your report, and discuss briefly what you think the major sources of error are in your estimate.===

''Figure 17'' below shows a graph of <math>T_{C,L}</math> against <math>\frac{1}{Lattice Size}</math> to determine the Curie Temperature of an infinite 2D Ising Model Lattice <math>T_{C,\infty}</math>. The black dots represent the raw data obtained from obtaining the temperature at which the Heat Capacity was a maximum for the lattices and the red line in a linear curve fit plotted against the data to allow the y-intercept which is the Curie Temperature for the infinite 2D lattice to be determined.

[[File:cg1417CurieTemp.png|400px|thumb|left|Figure 17 - Plot of 1/Lattice Size against Curie Temperature for that lattice size.]]

The value for <math>T_{C,\inf}</math> obtained from the data is <math>T_{C,\infty} = 2.277 \frac{J}{k_B}</math> with a literature value being <math>T_{C,\infty} = 2.269 \frac{J}{k_B}</math> <ref>L. Onsager, Phys. Rev., 1944, 65, 117--149.</ref>for an infinite square 2D lattice. This means that my result slightly over-estimates the Curie Temperature for the infinite lattice and as a result for an infinite lattice the temperature at which spontaneous magnetisation stops would actually occur at a slightly lower temperature than expected. However, the difference between my value and the literature value is only 0.008 which is incredibly small and the amount of agreement between the two values is somewhat surprising, which means that the error in my estimates of the Curie Temperature for each lattice size is relatively small. The points which have the largest residuals and deviation from the line of best fit in ''Figure 17'' corresponds to the smaller lattice sizes of 2x2 and 4x4 where longer range interactions are more significant. The longer range interactions posed by the boundary conditions are nowhere near as significant for the larger sizes and causes the energy of the smaller matrices to be less accurate and have a larger associated error with the energy and thus the Curie Temperature for that lattice size. This affects the accuracy of the line of best fit and to increase the accuracy of this line, larger lattice sizes of 128x128, 256x256 etc should be included in the calculation for the line of best fit and the smaller matrices ignored.

 

== References ==

Rep:Y3CMPCG1417

2019-11-20T09:24:53Z

==Section 1 - Introduction to the Ising Model==

===TASK: Show that the lowest possible energy for the Ising model is <math>E = -DNJ</math>, where D is the number of dimensions and N is the total number of spins. What is the multiplicity of this state? Calculate its entropy.===

Consider a 1D row of lattice sites of N=3 with spin configuration [+1][+1][+1].

Mathematically the interaction energy is defined asː
<math> -\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} </math> where J is a constant and <math>s_{i}s_{j}</math> is the product between two spins in adjacent lattice sites.

The sum of the interaction energies <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j}</math> can be considered as the sum of the individual interaction energies between spinsː
<math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = \epsilon_{12} + \epsilon_{23} + \epsilon_{13} + \epsilon_{21} + \epsilon_{32} + \epsilon_{31} </math>.

Although lattice sites 1 and 3 are not adjacent they are said to still interact according to the periodic boundary conditions applied.

However, <math>\epsilon_{12} = \epsilon_{21} </math> and <math>\epsilon_{23} = \epsilon_{32}</math> and <math>\epsilon_{13} = \epsilon_{31}</math> which means that all of the interactions within the system are counted twice, hence the total energy needs to be halved, resulting in the following formula being obtainedː <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = 2\epsilon_{12} + 2\epsilon_{13} + 2\epsilon_{23} </math>.

It can be determined that <math>\epsilon_{12} = (+1)(+1) = 1</math> , <math>\epsilon_{13} = (+1)(+1) = 1</math> and <math>\epsilon_{23} = (+1)(+1) = 1</math>.

Thereforeː <math>-\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = -\frac{1}{2} \ J \ (2 + 2 + 2) = -\frac{1}{2} \ J \ 6 = - 3 J = -DNJ</math> for a 1D lattice with <math>D=1</math> and 3 lattice sites <math>N=3</math>

The multiplicity of the system,<math>\Omega = \frac{n. spin up!}{n. spin down!}</math>

Entropy, <math>S</math> is defined as <math>S = k_B ln(\Omega)</math> and so in this case <math>S = k_B ln(\frac{100!}{100!}) = 0</math>

===TASK: Imagine that the system is in the lowest energy configuration. To move to a different state, one of the spins must spontaneously change direction ("flip"). What is the change in energy if this happens <math>(D=3, N=1000)</math>? How much entropy does the system gain by doing soʔ===

In a 3D lattice system, each lattice site has three unique interactions with its neighbours to its left, top and front. In the lowest energy configuration, all spins are parallel and for a system the minimum energy is <math>E = -DNJ</math>, so for the system with <math>N=1000</math> and <math>D=3</math>, the minimum energy is <math>-3000J</math>.

If a single spin is flipped, the product of its spin with its neighbours spin reverses and becomes negative and this increases the total energy of the system. Since 3 unique spin-spin interactions are reversed in sign, the total energy increases by <math>+3J</math>, meaning the new total energy is <math>-2997J</math>

Initially the multiplicity of the system will be <math>\Omega = \frac{1000!}{1000!}</math> , and after the flip, the multiplicity becomes <math> \Omega = \frac{1000!}{999!1!}=1000</math>.

The associated change in entropy, <math>\Delta S = k_B ln(1000) - 0 = 6.91 k_B</math>, which is an expected increase in entropy as the number of possible configurations of the system increases.

===TASK: Calculate the magnetisation of the 1D and 2D lattices in Figure 1. What magnetisation would you expect to observe for an Ising lattice with <math>D = 3,\ N=1000</math> at absolute zero?===

[[File:ThirdYearCMPExpt-IsingSketch.png|thumb|left|Figure 1 - Shows 1D (N = 5), 2D (N = 5x5) and 3D (N = 5x5x5) lattices.]]

Magnetisation is defined as <math>M=\sum_{i} s_i</math>. So for the 1D lattice with <math>N = 5</math> in ''Figure 2'', <math>M = +1</math> and for the 2D lattice with <math>N = 25 , M = +1</math> too.

According to the 3rd Law of thermodynamics, entropy is 0 at absolute zero for a perfect crystalline solid, and consequently it is expected that the lattices will have follow suit and have zero entropy at 0K. To have zero entropy all spins must be parallel as such that magnetisation, <math>M = N</math>. For all the spins to be parallel, there is only one possible configuration. So, for a lattice with <math>N = 1000</math> and <math>D =3</math>, if <math>M = N</math>, then multiplicity, <math>\Omega = 1</math> and entropy, <math>S =k_B ln(1) = 0</math>.

 

==Section 2 - Calculating the Energy and Magnetisation==

===TASK: complete the functions energy() and magnetisation(), which should return the energy of the lattice and the total magnetisation, respectively. In the energy() function you may assume that <math>J=1.0</math> at all times (in fact, we are working in reduced units in which <math>J=k_B</math>, but there will be more information about this in later sections). Do not worry about the efficiency of the code at the moment — we will address the speed in a later part of the experiment.===

<pre>def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
lat=self.lattice #creates lattice and stores it
mag=[]
for i in range(0,len(lat)): #loops through all rows of lattice
for j in range(0,len(lat[i])): #loops through elements of each row
mag+=[lat[i][j]] #adds spin value to mag array
return sum(mag) #sums all spins from mag array
</pre>

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

lat=self.lattice #creates lattice and stores it
left=[]
top=[]

for i in range(0,len(lat)):
for j in range(0,len(lat[i])):
left+=[lat[i][j]*lat[i][j-1]] #multiplies spin by spin to left
top+=[lat[i][j]*lat[i-1][j]] #multiplies spin by spin above it
int_en=left+top #sums spin products from left and top
energy=-sum(int_en) #sums all spin products for each spin to give total

return energy
</pre>

===TASK: Run the ILcheck.py script from the IPython Qt console using the command===

''Figure 2'' shows the results when ILcheck.py was ran on my IsingLattice.py file. The ILcheck.py file was ran several times to ensure the code worked for various random lattices.

[[File:Cg1417ILcheck run.png|thumb|left|500px| Figure 2 - Result from running the ILcheck.py file]]

 

==Section 3 - Introduction to Monte Carlo Simulation==

===TASK: How many configurations are available to a system with 100 spins? To evaluate these expressions, we have to calculate the energy and magnetisation for each of these configurations, then perform the sum. Let's be very, very, generous, and say that we can analyse <math>1\times 10^9</math> configurations per second with our computer. How long will it take to evaluate a single value of <math>\left\langle M\right\rangle_T</math>?===

For a system with 100 lattice sites and two possible spins for each site, there are <math>2^{100}</math>possible configurations for the system. <math>2^{100}= 1.27\times 10^{30} </math>, so if the computer can analyse <math>1\times 10^9</math> configurations per second, then it will take <math>\frac{1.27\times 10^{30}}{10^9} = 1.27\times 10^{21} s</math> to analyse the whole system, which is longer than the age of the universe and therefore is not a practical approach.

===TASK: Implement a single cycle of the above algorithm in the montecarlocycle(T) function. This function should return the energy of your lattice and the magnetisation at the end of the cycle. You may assume that the energy returned by your energy() function is in units of <math>k_B</math>! Complete the statistics() function. This should return the following quantities whenever it is called: <math><E>, <E^2>, <M>, <M^2></math>, and the number of Monte Carlo steps that have elapsed.===
<pre>
E = []
E2 = []
M = []
M2 = []
n_cycles = 0

def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back if rejected else not changed

self.E+=[self.energy()] #records energy
self.E2+=[self.energy()**2] #records energy squared
self.M+=[self.magnetisation()] #records magnetisation
self.M2+=[self.magnetisation()**2] #records magnetisation squared
self.n_cycles=self.n_cycles+1 #adds 1 to run total

return (self.energy(),self.magnetisation())

def statistics(self):
# complete this function so that it calculates the correct values for the averages of E, E*E (E2), M, M*M (M2), and returns them

e=np.mean(self.E)
e2=np.mean(self.E2)
m=np.mean(self.M)
m2=np.mean(self.M2)

return e,e2,m,m2,self.n_cycles
</pre>

===TASK: If <math>T < T_C</math>, do you expect a spontaneous magnetisation (i.e. do you expect <math>\left\langle M\right\rangle \neq 0</math>)? When the state of the simulation appears to stop changing (when you have reached an equilibrium state), use the controls to export the output to PNG and attach this to your report. You should also include the output from your statistics() function.===

If the temperature of the system is less than the Curie Temperature, <math>T_C</math> then spontaneous magnetisation can occur and the system will tend to its lowest energy state where all of the spins are parallel - this is a property of ferromagnetic materials.

[[File:Cg1417ILanim_run.png|400px|thumb|left|Figure 3 - Results from running the ILanim.py file - shows the energy and magnetisation converging over time]]

''Figure 3'' shows that over time the the system spontaneously converges to the minimum energy state with all of the spins parallel to one another and shows, as I expected, that spontaneous magnetisation occurs and also shows that the temperature of this simulation is below the Curie Temperature, <math>T < T_C</math>.

 

==Section 4 - Accelerating the Code==

===TASK: Use the script ILtimetrial.py to record how long your current version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 4'' show the results of running the ILtimetrial.py file on my code three timesː

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1.png
| width1=500
| image2=cg1417ILtimetrial_run2.png
| width2=500
| image3=cg1417ILtimetrial_run3.png
| width3=500
| footer = Figure 4 - Results of running the ILtimetrial.py file on my code three separate times
}}
 

This gave me an avergage time of <math>24.3 s \pm 0.2s</math>

===TASK: Look at the documentation for the NumPy sum function. You should be able to modify your magnetisation() function so that it uses this to evaluate M. The energy is a little trickier. Familiarise yourself with the NumPy roll and multiply functions, and use these to replace your energy double loop (you will need to call roll and multiply twice!).===

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

left=multiply(roll(self.lattice,1,axis=1),self.lattice) #product of spin with spin left of it
top=multiply(roll(self.lattice,-1,axis=0),self.lattice) #product of spin with spin above it

int_en=sum(left+top) #sum of array containing sum of left and top spin products for each spin

energy = -sum(int_en) #calculates the total energy of system
return energy

def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
return sum(sum(self.lattice)) #adds up all spins in lattice
</pre>

===TASK: Use the script ILtimetrial.py to record how long your new version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 5'' shows the result of running the ILtimetrial.py on my new accelerated code.

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1fast.png
| width1=500
| image2=ILtimetrial_run2fast.png
| width2=500
| image3=ILtimetrial_run3fast.png
| width3=500
| footer = Figure 5 - Results of running the ILtimetrial.py file on my new updated and accelerated code.
}}
 

The accelerated code is much faster upon using the roll, multiply and sum modules with a new average time of <math>0.790 s \pm 0.005 </math>

==Section 5 - The effect of temperature==

===TASK: The script ILfinalframe.py runs for a given number of cycles at a given temperature, then plots a depiction of the final lattice state as well as graphs of the energy and magnetisation as a function of cycle number. This is much quicker than animating every frame! Experiment with different temperature and lattice sizes. How many cycles are typically needed for the system to go from its random starting position to the equilibrium state? Modify your statistics() and montecarlostep() functions so that the first N cycles of the simulation are ignored when calculating the averages. You should state in your report what period you chose to ignore, and include graphs from ILfinalframe.py to illustrate your motivation in choosing this figure.===

''Figure 6'' below shows the results from running the ILfinalframe.py for 2x2 lattice at T=1,2,3,5.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2T1.png
| image2 = cg14172x2T2.png
| image3 =cg14172x2T3.png
| image4 =cg14172x2T5.png
| footer_align = left
| footer = Figure 6 - Results of running the ILfinalframe.py file at T=1,2,3,5 for a 2x2 matrix.
}}

 

For a 2x2 matrix, a suitable cut-off point to exclude from the avergage energies and magnetisations is where the energy and magnetisations per spin are constant, which is 30 steps. For T=3 and T=5 the graphs do not converge because it is possible that these temperatures are higher than the Curie Temperature and as such spontaneous magnetisation will not occur and the system will not diverge to the lowest energy state. At the higher temperatures, there are larger thermal fluctations and the Boltzmann factor is more significant allowing the system to move away from the lowest energy state easier. As a result moving forwards, a suitable cut-off point will only be determined from T=1 and T=2 graphs for the larger matrices.

''Figure 7'' shows the results from running a 4x4 lattice at T=1,2 and 3.

{{multiple image
| width =350
| align = left
| image1 = cg14174x4T1.png
| image2 = cg14174x4T2.png
| image3 =cg14174x4T3.png
| footer_align = left
| footer = Figure 7 - Results of running the ILfinalframe.py file at T=1,2,3 for a 4x4 matrix.
}}

From ''Figure 7'', a suitable cut-off point for the energy and magnetisations is 200 as this is after where the energy and magnetisation has converged for T=1, and is after the initial large drop in energy for T=2, even though there are a few small fluctuations after 200 steps. The result from T=3 has been included to show the large fluctuations for the larger temperatures, and supporting my choice to determine the cut-off from T=1 and T=2 only.

''Figure 8'' shows the results for an 8x8 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg14178x8T1.png
| image2 = cg14178x8T2.png
| footer_align = left
| footer = Figure 8 - Results of running the ILfinalframe.py file at T=1,2 for an 8x8 matrix
}}

From ''Figure 8'' above, a suitable cut-off point is 1000 steps as this is where the energy and magnetisation has easily converged by and is also the point after which the initial large drop in energy has been overcome for T=2 too.

''Figure 9'' shows the result of running the ILfinalframe.py for a 16x16 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg141716x16T1.png
| image2 = cg141716x16T2.png
| footer_align = left
| footer = Figure 9 - Results of running the ILfinalframe.py file at T=1,2 for a 16x16 matrix
}}

From ''Figure 9'', a suitable cut-off point is 15000 steps as for T=1 the energy and magnetisations have converged significantly and will not change much, and likewise this is the same for the T=2 frame.

''Figure 10'' below shows the results from a 32x32 matrix at T=1 and T=2.

{{multiple image
| width =350
| align = left
| image1 = cg141732x32T1.png
| image2 = cg141732x32T2.png
| footer_align = left
| footer = Figure 10 - Results of running the ILfinalframe.py file at T=1,2 for a 32x32 matrix
}}

''Figure 10'' above shows the results of running the ILfinalframe.py file for a 32x32 matrix at T=1 and T=2. As a result a suitable cut-off of 50000 steps was chosen as the energy and magnetisation has significantly converged, but not as much as it could at 100000 steps. I chose a slightly lower value to ensure that the run times of my monte-carlo simulations in future tasks were not extremely time consuming.

The montecarlostep() function was changed by adding a condition that values only above the pre-determined cut-off were included when determining the average value of energy; energy squared; magnetisation and magnetisations squared from the statistics function. The statistics() function did not need to be modified.

The following code is from the 32x32 matrixː

<pre>def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back

if self.n_cycles > 50000: #only adds values to array of E,E2,M and M2 is above specific cut-off
self.E+=[self.energy()]
self.E2+=[self.energy()**2]
self.M+=[self.magnetisation()]
self.M2+=[self.magnetisation()**2]
self.n_cycles=self.n_cycles+1

return (self.energy(),self.magnetisation())
</pre>

===TASK: Use ILtemperaturerange.py to plot the average energy and magnetisation for each temperature, with error bars, for an <math>8\times 8</math> lattice. Use your intuition and results from the script ILfinalframe.py to estimate how many cycles each simulation should be. The temperature range 0.25 to 5.0 is sufficient. Use as many temperature points as you feel necessary to illustrate the trend, but do not use a temperature spacing larger than 0.5. The NumPy function savetxt() stores your array of output data on disk — you will need it later. Save the file as 8x8.dat so that you know which lattice size it came from.===

Using the modified code, the file ILtemperaturerange.py was ran on an 8x8 matrix between T=0.5 and T=5 with a step of T=0.02 for 10000 Montecarlo steps and the first 1000 steps of each temperature were excluded when calculating the averages. ''Figure 11'' shows the result of the simulation and also included error bars of standard deviation.

[[File:Cg14178x8error.png|1000px|thumb|left|Figure 11 - Graph showing average energy and average magnetisation for an 8x8 lattice with error bars between T=0.5 and T=5]]

 

Below is the source code for the script to produce the graphː

<pre>data8x8=np.loadtxt('8x8.dat') #loads data
temps8x8=data8x8[:,0] #stores temperatures
energies8x8=data8x8[:,1] #stores average energy for each T
energysq8x8=data8x8[:,2] #stores average energy squared for each T
mag8x8=data8x8[:,3] #stores magnetisation for each T
magsq8x8=data8x8[:,4] #stores magnetisation squared for each T
stde8x8=data8x8[:,5] #edited ILtemperaturerange.py to record the standard deviation of the energy for each T
stdm8x8=data8x8[:,6] #edited ILtemperaturerange.py to record the standard deviation of the magnetisation for each T

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.errorbar(temps8x8, np.array(energies8x8)/64,yerr=np.divide(stde8x8,64),color='black',ecolor='teal',alpha=0.8) #plots energy per spin against T
magax.errorbar(temps8x8, np.array(mag8x8)/64,yerr=np.divide(stdm8x8,64),alpha=0.8,ecolor='salmon',color='black') #plots magnetisation per spin against T on separate graph
pl.savefig('8x8error.png',bbox_inches='tight') #saves figure
pl.show()

</pre>

==Section 6 - The effect of system size==

===TASK: Repeat the final task of the previous section for the following lattice sizes: 2x2, 4x4, 8x8, 16x16, 32x32. Make sure that you name each datafile that your produce after the corresponding lattice size! Write a Python script to make a plot showing the energy per spin versus temperature for each of your lattice sizes. Hint: the NumPy loadtxt function is the reverse of the savetxt function, and can be used to read your previously saved files into the script. Repeat this for the magnetisation. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. How big a lattice do you think is big enough to capture the long range fluctuations?===

The python script for this section is identical as for the 8x8 graph above in Figure 11 with the relevant files and variables changed accordingly.

Each matrix was simulated using the ILtemperaturerange.py file between T=0.5 and T=5 with a step of T=0.02.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2error.png
| caption1 = 2x2 matrix - 5000 steps, cut-off = 30 steps
| image2 = 4x4error.png
| caption2 = 4x4 matrix - 1000 steps, cut-off = 200 steps
| image3 =cg141716x16error.png
| caption3 = 16x16 matrix - 50000 steps, cut-off = 15000 steps
| image4 =cg141732x32error.png
| caption4 = 32x32 matrix - 200000 steps, cut-off = 50000 steps
| footer_align = left
| footer = Figure 12 - Results of running the ILtemperaturerange.py file for 2x2, 4x4, 16x16 and 32x32 matrices.
}}

 

==Section 7 - Determining the Heat Capacity==

===TASK: By definition, <math>C = \frac{\partial \left\langle E\right\rangle}{\partial T}</math>. From this, show that <math>C = \frac{\mathrm{Var}[E]}{k_B T^2}</math> (Where <math>\mathrm{Var}[E]</math> is the variance in <math>E</math>.)===

Recall from statistical thermodynamics that the average energy of a system is the sum across all microstates of the probability of that microstate multiplied by the energy of that microstate, which is defined mathematically asː <math>\langle E \rangle = \sum_i p_{i}\epsilon_{i}</math>.

The partition function <math>q</math> is defined as <math>q = \sum_{i} exp(-\beta \epsilon_{i})</math> where <math>\beta =\frac{1}{k_BT}</math>and the probability, <math>p_{i}</math> can be defined in terms of the partition function as <math>p_{i} = \frac{exp(-\beta \epsilon_{i})}{\sum_{i} exp(-\beta \epsilon_{i})} = \frac{exp(-\beta \epsilon_{i})}{q}</math>.

As a result, <math>\langle E \rangle</math> can be re-written as <math>\langle E \rangle = \sum_{i} \frac{\epsilon_{i} exp(-\beta \epsilon_{i})}{q} = -\frac{1}{q} \frac{\partial}{\partial \beta}\sum_{i}exp(-\beta \epsilon_{i}) = -\frac{1}{q} \frac{\partial q}{\partial \beta}</math>

Likewise, <math>\langle E^2 \rangle = \sum_i p_{i}\epsilon_{i}^{2} = \sum_{i} \frac{\epsilon_{i}^{2}exp(-\beta \epsilon_{i})}{q} = \frac{1}{q} \frac{\partial^{2}}{\partial \beta^{2}}\sum_{i}exp(-\beta \epsilon_{i}) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}}</math>

From definitionː <math>Var[E] = \Delta E^2 = \langle E^2 \rangle - \langle E \rangle^2 </math>

When the definition of <math>\langle E \rangle</math> and <math>\langle E^2 \rangle</math> is written in terms of partition function <math>q</math>ː <math>Var[E] = \langle E^2 \rangle - \langle E \rangle^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \left(\frac{1}{q}\frac{\partial q}{\partial \beta}\right)^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2</math>.

According to the chain ruleː <math>\frac{\partial}{\partial \beta}\left(\frac{1}{q} \frac{\partial q}{\partial \beta}\right) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2 = -\frac{\partial}{\partial \beta}\langle E \rangle = Var[E]</math>

And using the chain rule againː <math>C = \frac{\partial \langle E \rangle}{\partial T}= \left(-\frac{\partial \langle E \rangle}{\partial \beta}\right) \left(-\frac{\partial \beta}{\partial T}\right) = \frac{Var[E]}{k_B T^2}</math>

===TASK: Write a Python script to make a plot showing the heat capacity versus temperature for each of your lattice sizes from the previous section. You may need to do some research to recall the connection between the variance of a variable, <math>\mathrm{Var}[X]</math>, the mean of its square <math>\left\langle X^2\right\rangle</math>, and its squared mean <math>\left\langle X\right\rangle^2</math>. You may find that the data around the peak is very noisy — this is normal, and is a result of being in the critical region. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. ===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb

{{multiple image
| width =300
| align = left
| image1 = cg14172x2heatcap.png
| caption1 = 2x2 Matrix
| image2 = cg14174x4heatcap.png
| caption2 = 4x4 Matrix
| image3 =cg14178x8heatcap.png
| caption3 = 8x8 Matrix
| image4 =cg141716x16heatcap.png
| caption4 = 16x16 Matrix
| image5=cg141732x32heatcap.png
| caption5= 32x32 Matrix
| footer = Figure 13 - Graphs showing Heat Capacity against Temperature for each matrix size
}}

Here is the source code to produce the figuresː
<pre> def heatCap(energies,energysq,T,latsize):
#defines the heat capacity for a given temperature
energiesq=np.multiply(energies,energies) #creates array of (average energies) squared
varE=np.subtract(energysq,energiesq) #defines variance of average energy
tempsq=np.multiply(T,T) #array of temperature squared
return np.array(np.divide(varE,tempsq))/(latsize**2)

heatCap2x2=heatCap(energies2x2,energysq2x2,temps2x2,2) #creates array of heat capacity for each T

fig = pl.figure()
heatcapax = fig.add_subplot(1,1,1)
heatcapax.set_xlabel('Temperature')
heatcapax.set_ylabel('Heat Capacity')
heatcapax.plot(temps2x2,heatCap2x2,color='orange') #plots heat capacity for each T
pl.savefig('cg14172x2heatcap.png',bbox_inches='tight') #saves figure
pl.show()
</pre>

A general trend from the above graphs is that the peak of the graph shifts towards lower temperatures as the size of the matrix used increases.

==Section 8 - Locating the Curie Temperature==
===TASK: A C++ program has been used to run some much longer simulations than would be possible on the college computers in Python. You can view its source code here if you are interested. Each file contains six columns: <math>T, E, E^2, M, M^2, C</math> (the final five quantities are per spin), and you can read them with the NumPy loadtxt function as before. For each lattice size, plot the C++ data against your data. For one lattice size, save a PNG of this comparison and add it to your report — add a legend to the graph to label which is which. To do this, you will need to pass the label="..." keyword to the plot function, then call the legend() function of the axis object (documentation here).===

The python code used to read and plot the C++ data is found in the Jupyter notebook CG1417IsingModelGraphs.ipynb.

''Figure 14'' below shows the C++ plotted against my own data for a 16x16 Matrix.

[[File:Cg141716x16C++.png|400px|thumb|left|Figure 14 - Graph showing my own data against the C++ data for a 16x16 matrix.]]

 

===TASK: write a script to read the data from a particular file, and plot C vs T, as well as a fitted polynomial. Try changing the degree of the polynomial to improve the fit — in general, it might be difficult to get a good fit! Attach a PNG of an example fit to your report.===

The python script to read and plot the fitted polynomial is found in CG1417PolyfitScript.ipynb

Below in ''Figure 15'' is a plot of my Heat Capacity against Temperature data for a 16x16 matrix and features a polynomial of degree 35 plotted against it. Even with a polynomial of such a high degree, it poorly fits the curve and does not fit to the peak of the curve either.

[[File:cg1417FIT_TEST16x16_35.png|thumb|left|400px|Figure 15 - Plot of Heat Capacity against Temperature along with a poorly fitted polynomial of degree 35. ]]

 

===TASK: Modify your script from the previous section. You should still plot the whole temperature range, but fit the polynomial only to the peak of the heat capacity! You should find it easier to get a good fit when restricted to this region===

The script was modified as such that the polynomial was fitted in a set range around the peak of the graph, this is demonstrated in ''Figure 17'' which shows a newly fitted polynomial between a much smaller range of temperatures (T = 2.15-2.55) and a much smaller degree polynomial (3).

[[File:CG1417FIT_16x16C_3.png|thumb|left|400px|Figure 16 - Graph showing Heat Capacity against Temperature for a 16x16 matrix along with a fitted polynomial between a much more restricted range of temperatures and a significantly lower degree of polynomial]]

Upon comparison with ''Figure 15'', the new fitted polynomial is a significantly better fit even for a 3rd degree polynomial and is a much more accurate representation of my data around the peak of the graph and will make it easier to determine the maximum value of Heat Capacity.

 

===TASK: find the temperature at which the maximum in C occurs for each datafile that you were given. Make a text file containing two colums: the lattice side length (2,4,8, etc.), and the temperature at which C is a maximum. This is your estimate of <math>T_C</math> for that side length. Make a plot that uses the scaling relation given above to determine <math>T_{C,\infty}</math>. By doing a little research online, you should be able to find the theoretical exact Curie temperature for the infinite 2D Ising lattice. How does your value compare to this? Are you surprised by how good/bad the agreement is? Attach a PNG of this final graph to your report, and discuss briefly what you think the major sources of error are in your estimate.===

''Figure 17'' below shows a graph of <math>T_{C,L}</math> against <math>\frac{1}{Lattice Size}</math> to determine the Curie Temperature of an infinite 2D Ising Model Lattice <math>T_{C,\infty}</math>. The black dots represent the raw data obtained from obtaining the temperature at which the Heat Capacity was a maximum for the lattices and the red line in a linear curve fit plotted against the data to allow the y-intercept which is the Curie Temperature for the infinite 2D lattice to be determined.

[[File:cg1417CurieTemp.png|400px|thumb|left|Figure 17 - Plot of 1/Lattice Size against Curie Temperature for that lattice size.]]

The value for <math>T_{C,\inf}</math> obtained from the data is <math>T_{C,\infty} = 2.277 \frac{J}{k_B}</math> with a literature value being <math>T_{C,\infty} = 2.269 \frac{J}{k_B}</math> <ref>L. Onsager, Phys. Rev., 1944, 65, 117--149.</ref>for an infinite square 2D lattice. This means that my result slightly over-estimates the Curie Temperature for the infinite lattice and as a result for an infinite lattice the temperature at which spontaneous magnetisation stops would actually occur at a slightly lower temperature than expected. However, the difference between my value and the literature value is only 0.008 which is incredibly small and the amount of agreement between the two values is somewhat surprising, which means that the error in my estimates of the Curie Temperature for each lattice size is relatively small. The points which have the largest residuals and deviation from the line of best fit in ''Figure 17'' corresponds to the smaller lattice sizes of 2x2 and 4x4 where longer range interactions are more significant. The longer range interactions posed by the boundary conditions are nowhere near as significant for the larger sizes and causes the energy of the smaller matrices to be less accurate and have a larger associated error with the energy and thus the Curie Temperature for that lattice size. This affects the accuracy of the line of best fit and to increase the accuracy of this line, larger lattice sizes of 128x128, 256x256 etc should be included in the calculation for the line of best fit and the smaller matrices ignored.

 

== References ==

Rep:Y3CMPCG1417

2019-11-20T09:21:14Z

Cg1417: /* TASK: Repeat the final task of the previous section for the following lattice sizes: 2x2, 4x4, 8x8, 16x16, 32x32. Make sure that you name each datafile that your produce after the corresponding lattice size! Write a Python script to make a plot show...

==Section 1 - Introduction to the Ising Model==

===TASK: Show that the lowest possible energy for the Ising model is <math>E = -DNJ</math>, where D is the number of dimensions and N is the total number of spins. What is the multiplicity of this state? Calculate its entropy.===

Consider a 1D row of lattice sites of N=3 with spin configuration [+1][+1][+1].

Mathematically the interaction energy is defined asː
<math> -\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} </math> where J is a constant and <math>s_{i}s_{j}</math> is the product between two spins in adjacent lattice sites.

The sum of the interaction energies <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j}</math> can be considered as the sum of the individual interaction energies between spinsː
<math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = \epsilon_{12} + \epsilon_{23} + \epsilon_{13} + \epsilon_{21} + \epsilon_{32} + \epsilon_{31} </math>.

Although lattice sites 1 and 3 are not adjacent they are said to still interact according to the periodic boundary conditions applied.

However, <math>\epsilon_{12} = \epsilon_{21} </math> and <math>\epsilon_{23} = \epsilon_{32}</math> and <math>\epsilon_{13} = \epsilon_{31}</math> which means that all of the interactions within the system are counted twice, hence the total energy needs to be halved, resulting in the following formula being obtainedː <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = 2\epsilon_{12} + 2\epsilon_{13} + 2\epsilon_{23} </math>.

It can be determined that <math>\epsilon_{12} = (+1)(+1) = 1</math> , <math>\epsilon_{13} = (+1)(+1) = 1</math> and <math>\epsilon_{23} = (+1)(+1) = 1</math>.

Thereforeː <math>-\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = -\frac{1}{2} \ J \ (2 + 2 + 2) = -\frac{1}{2} \ J \ 6 = - 3 J = -DNJ</math> for a 1D lattice with <math>D=1</math> and 3 lattice sites <math>N=3</math>

The multiplicity of the system,<math>\Omega = \frac{n. spin up!}{n. spin down!}</math>

Entropy, <math>S</math> is defined as <math>S = k_B ln(\Omega)</math> and so in this case <math>S = k_B ln(\frac{100!}{100!}) = 0</math>

===TASK: Imagine that the system is in the lowest energy configuration. To move to a different state, one of the spins must spontaneously change direction ("flip"). What is the change in energy if this happens <math>(D=3, N=1000)</math>? How much entropy does the system gain by doing soʔ===

In a 3D lattice system, each lattice site has three unique interactions with its neighbours to its left, top and front. In the lowest energy configuration, all spins are parallel and for a system the minimum energy is <math>E = -DNJ</math>, so for the system with <math>N=1000</math> and <math>D=3</math>, the minimum energy is <math>-3000J</math>.

If a single spin is flipped, the product of its spin with its neighbours spin reverses and becomes negative and this increases the total energy of the system. Since 3 unique spin-spin interactions are reversed in sign, the total energy increases by <math>+3J</math>, meaning the new total energy is <math>-2997J</math>

Initially the multiplicity of the system will be <math>\Omega = \frac{1000!}{1000!}</math> , and after the flip, the multiplicity becomes <math> \Omega = \frac{1000!}{999!1!}=1000</math>.

The associated change in entropy, <math>\Delta S = k_B ln(1000) - 0 = 6.91 k_B</math>, which is an expected increase in entropy as the number of possible configurations of the system increases.

===TASK: Calculate the magnetisation of the 1D and 2D lattices in Figure 1. What magnetisation would you expect to observe for an Ising lattice with <math>D = 3,\ N=1000</math> at absolute zero?===

[[File:ThirdYearCMPExpt-IsingSketch.png|thumb|left|Figure 1 - Shows 1D (N = 5), 2D (N = 5x5) and 3D (N = 5x5x5) lattices.]]

Magnetisation is defined as <math>M=\sum_{i} s_i</math>. So for the 1D lattice with <math>N = 5</math> in ''Figure 2'', <math>M = +1</math> and for the 2D lattice with <math>N = 25 , M = +1</math> too.

According to the 3rd Law of thermodynamics, entropy is 0 at absolute zero for a perfect crystalline solid, and consequently it is expected that the lattices will have follow suit and have zero entropy at 0K. To have zero entropy all spins must be parallel as such that magnetisation, <math>M = N</math>. For all the spins to be parallel, there is only one possible configuration. So, for a lattice with <math>N = 1000</math> and <math>D =3</math>, if <math>M = N</math>, then multiplicity, <math>\Omega = 1</math> and entropy, <math>S =k_B ln(1) = 0</math>.

 

==Section 2 - Calculating the Energy and Magnetisation==

===TASK: complete the functions energy() and magnetisation(), which should return the energy of the lattice and the total magnetisation, respectively. In the energy() function you may assume that <math>J=1.0</math> at all times (in fact, we are working in reduced units in which <math>J=k_B</math>, but there will be more information about this in later sections). Do not worry about the efficiency of the code at the moment — we will address the speed in a later part of the experiment.===

<pre>def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
lat=self.lattice #creates lattice and stores it
mag=[]
for i in range(0,len(lat)): #loops through all rows of lattice
for j in range(0,len(lat[i])): #loops through elements of each row
mag+=[lat[i][j]] #adds spin value to mag array
return sum(mag) #sums all spins from mag array
</pre>

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

lat=self.lattice #creates lattice and stores it
left=[]
top=[]

for i in range(0,len(lat)):
for j in range(0,len(lat[i])):
left+=[lat[i][j]*lat[i][j-1]] #multiplies spin by spin to left
top+=[lat[i][j]*lat[i-1][j]] #multiplies spin by spin above it
int_en=left+top #sums spin products from left and top
energy=-sum(int_en) #sums all spin products for each spin to give total

return energy
</pre>

===TASK: Run the ILcheck.py script from the IPython Qt console using the command===

''Figure 2'' shows the results when ILcheck.py was ran on my IsingLattice.py file. The ILcheck.py file was ran several times to ensure the code worked for various random lattices.

[[File:Cg1417ILcheck run.png|thumb|left|500px| Figure 2 - Result from running the ILcheck.py file]]

 

==Section 3 - Introduction to Monte Carlo Simulation==

===TASK: How many configurations are available to a system with 100 spins? To evaluate these expressions, we have to calculate the energy and magnetisation for each of these configurations, then perform the sum. Let's be very, very, generous, and say that we can analyse <math>1\times 10^9</math> configurations per second with our computer. How long will it take to evaluate a single value of <math>\left\langle M\right\rangle_T</math>?===

For a system with 100 lattice sites and two possible spins for each site, there are <math>2^{100}</math>possible configurations for the system. <math>2^{100}= 1.27\times 10^{30} </math>, so if the computer can analyse <math>1\times 10^9</math> configurations per second, then it will take <math>\frac{1.27\times 10^{30}}{10^9} = 1.27\times 10^{21} s</math> to analyse the whole system, which is longer than the age of the universe and therefore is not a practical approach.

===TASK: Implement a single cycle of the above algorithm in the montecarlocycle(T) function. This function should return the energy of your lattice and the magnetisation at the end of the cycle. You may assume that the energy returned by your energy() function is in units of <math>k_B</math>! Complete the statistics() function. This should return the following quantities whenever it is called: <math><E>, <E^2>, <M>, <M^2></math>, and the number of Monte Carlo steps that have elapsed.===
<pre>
E = []
E2 = []
M = []
M2 = []
n_cycles = 0

def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back if rejected else not changed

self.E+=[self.energy()] #records energy
self.E2+=[self.energy()**2] #records energy squared
self.M+=[self.magnetisation()] #records magnetisation
self.M2+=[self.magnetisation()**2] #records magnetisation squared
self.n_cycles=self.n_cycles+1 #adds 1 to run total

return (self.energy(),self.magnetisation())

def statistics(self):
# complete this function so that it calculates the correct values for the averages of E, E*E (E2), M, M*M (M2), and returns them

e=np.mean(self.E)
e2=np.mean(self.E2)
m=np.mean(self.M)
m2=np.mean(self.M2)

return e,e2,m,m2,self.n_cycles
</pre>

===TASK: If <math>T < T_C</math>, do you expect a spontaneous magnetisation (i.e. do you expect <math>\left\langle M\right\rangle \neq 0</math>)? When the state of the simulation appears to stop changing (when you have reached an equilibrium state), use the controls to export the output to PNG and attach this to your report. You should also include the output from your statistics() function.===

If the temperature of the system is less than the Curie Temperature, <math>T_C</math> then spontaneous magnetisation can occur and the system will tend to its lowest energy state where all of the spins are parallel - this is a property of ferromagnetic materials.

[[File:Cg1417ILanim_run.png|400px|thumb|left|Figure 3 - Results from running the ILanim.py file - shows the energy and magnetisation converging over time]]

''Figure 3'' shows that over time the the system spontaneously converges to the minimum energy state with all of the spins parallel to one another and shows, as I expected, that spontaneous magnetisation occurs and also shows that the temperature of this simulation is below the Curie Temperature, <math>T < T_C</math>.

 

==Section 4 - Accelerating the Code==

===TASK: Use the script ILtimetrial.py to record how long your current version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 4'' show the results of running the ILtimetrial.py file on my code three timesː

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1.png
| width1=500
| image2=cg1417ILtimetrial_run2.png
| width2=500
| image3=cg1417ILtimetrial_run3.png
| width3=500
| footer = Figure 4 - Results of running the ILtimetrial.py file on my code three separate times
}}
 

This gave me an avergage time of <math>24.3 s \pm 0.2s</math>

===TASK: Look at the documentation for the NumPy sum function. You should be able to modify your magnetisation() function so that it uses this to evaluate M. The energy is a little trickier. Familiarise yourself with the NumPy roll and multiply functions, and use these to replace your energy double loop (you will need to call roll and multiply twice!).===

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

left=multiply(roll(self.lattice,1,axis=1),self.lattice) #product of spin with spin left of it
top=multiply(roll(self.lattice,-1,axis=0),self.lattice) #product of spin with spin above it

int_en=sum(left+top) #sum of array containing sum of left and top spin products for each spin

energy = -sum(int_en) #calculates the total energy of system
return energy

def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
return sum(sum(self.lattice)) #adds up all spins in lattice
</pre>

===TASK: Use the script ILtimetrial.py to record how long your new version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 5'' shows the result of running the ILtimetrial.py on my new accelerated code.

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1fast.png
| width1=500
| image2=ILtimetrial_run2fast.png
| width2=500
| image3=ILtimetrial_run3fast.png
| width3=500
| footer = Figure 5 - Results of running the ILtimetrial.py file on my new updated and accelerated code.
}}
 

The accelerated code is much faster upon using the roll, multiply and sum modules with a new average time of <math>0.790 s \pm 0.005 </math>

==Section 5 - The effect of temperature==

===TASK: The script ILfinalframe.py runs for a given number of cycles at a given temperature, then plots a depiction of the final lattice state as well as graphs of the energy and magnetisation as a function of cycle number. This is much quicker than animating every frame! Experiment with different temperature and lattice sizes. How many cycles are typically needed for the system to go from its random starting position to the equilibrium state? Modify your statistics() and montecarlostep() functions so that the first N cycles of the simulation are ignored when calculating the averages. You should state in your report what period you chose to ignore, and include graphs from ILfinalframe.py to illustrate your motivation in choosing this figure.===

''Figure 6'' below shows the results from running the ILfinalframe.py for 2x2 lattice at T=1,2,3,5.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2T1.png
| image2 = cg14172x2T2.png
| image3 =cg14172x2T3.png
| image4 =cg14172x2T5.png
| footer_align = left
| footer = Figure 6 - Results of running the ILfinalframe.py file at T=1,2,3,5 for a 2x2 matrix.
}}

 

For a 2x2 matrix, a suitable cut-off point to exclude from the avergage energies and magnetisations is where the energy and magnetisations per spin are constant, which is 30 steps. For T=3 and T=5 the graphs do not converge because it is possible that these temperatures are higher than the Curie Temperature and as such spontaneous magnetisation will not occur and the system will not diverge to the lowest energy state. At the higher temperatures, there are larger thermal fluctations and the Boltzmann factor is more significant allowing the system to move away from the lowest energy state easier. As a result moving forwards, a suitable cut-off point will only be determined from T=1 and T=2 graphs for the larger matrices.

''Figure 7'' shows the results from running a 4x4 lattice at T=1,2 and 3.

{{multiple image
| width =350
| align = left
| image1 = cg14174x4T1.png
| image2 = cg14174x4T2.png
| image3 =cg14174x4T3.png
| footer_align = left
| footer = Figure 7 - Results of running the ILfinalframe.py file at T=1,2,3 for a 4x4 matrix.
}}

From ''Figure 7'', a suitable cut-off point for the energy and magnetisations is 200 as this is after where the energy and magnetisation has converged for T=1, and is after the initial large drop in energy for T=2, even though there are a few small fluctuations after 200 steps. The result from T=3 has been included to show the large fluctuations for the larger temperatures, and supporting my choice to determine the cut-off from T=1 and T=2 only.

''Figure 8'' shows the results for an 8x8 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg14178x8T1.png
| image2 = cg14178x8T2.png
| footer_align = left
| footer = Figure 8 - Results of running the ILfinalframe.py file at T=1,2 for an 8x8 matrix
}}

From ''Figure 8'' above, a suitable cut-off point is 1000 steps as this is where the energy and magnetisation has easily converged by and is also the point after which the initial large drop in energy has been overcome for T=2 too.

''Figure 9'' shows the result of running the ILfinalframe.py for a 16x16 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg141716x16T1.png
| image2 = cg141716x16T2.png
| footer_align = left
| footer = Figure 9 - Results of running the ILfinalframe.py file at T=1,2 for a 16x16 matrix
}}

From ''Figure 9'', a suitable cut-off point is 15000 steps as for T=1 the energy and magnetisations have converged significantly and will not change much, and likewise this is the same for the T=2 frame.

''Figure 10'' below shows the results from a 32x32 matrix at T=1 and T=2.

{{multiple image
| width =350
| align = left
| image1 = cg141732x32T1.png
| image2 = cg141732x32T2.png
| footer_align = left
| footer = Figure 10 - Results of running the ILfinalframe.py file at T=1,2 for a 32x32 matrix
}}

''Figure 10'' above shows the results of running the ILfinalframe.py file for a 32x32 matrix at T=1 and T=2. As a result a suitable cut-off of 50000 steps was chosen as the energy and magnetisation has significantly converged, but not as much as it could at 100000 steps. I chose a slightly lower value to ensure that the run times of my monte-carlo simulations in future tasks were not extremely time consuming.

The montecarlostep() function was changed by adding a condition that values only above the pre-determined cut-off were included when determining the average value of energy; energy squared; magnetisation and magnetisations squared from the statistics function. The statistics() function did not need to be modified.

The following code is from the 32x32 matrixː

<pre>def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back

if self.n_cycles > 50000: #only adds values to array of E,E2,M and M2 is above specific cut-off
self.E+=[self.energy()]
self.E2+=[self.energy()**2]
self.M+=[self.magnetisation()]
self.M2+=[self.magnetisation()**2]
self.n_cycles=self.n_cycles+1

return (self.energy(),self.magnetisation())
</pre>

===TASK: Use ILtemperaturerange.py to plot the average energy and magnetisation for each temperature, with error bars, for an <math>8\times 8</math> lattice. Use your intuition and results from the script ILfinalframe.py to estimate how many cycles each simulation should be. The temperature range 0.25 to 5.0 is sufficient. Use as many temperature points as you feel necessary to illustrate the trend, but do not use a temperature spacing larger than 0.5. The NumPy function savetxt() stores your array of output data on disk — you will need it later. Save the file as 8x8.dat so that you know which lattice size it came from.===

Using the modified code, the file ILtemperaturerange.py was ran on an 8x8 matrix between T=0.5 and T=5 with a step of T=0.02 for 10000 Montecarlo steps and the first 1000 steps of each temperature were excluded when calculating the averages. ''Figure 11'' shows the result of the simulation and also included error bars of standard deviation.

[[File:Cg14178x8error.png|1000px|thumb|left|Figure 11 - Graph showing average energy and average magnetisation for an 8x8 lattice with error bars between T=0.5 and T=5]]

 

Below is the source code for the script to produce the graphː

<pre>data8x8=np.loadtxt('8x8.dat') #loads data
temps8x8=data8x8[:,0] #stores temperatures
energies8x8=data8x8[:,1] #stores average energy for each T
energysq8x8=data8x8[:,2] #stores average energy squared for each T
mag8x8=data8x8[:,3] #stores magnetisation for each T
magsq8x8=data8x8[:,4] #stores magnetisation squared for each T
stde8x8=data8x8[:,5] #edited ILtemperaturerange.py to record the standard deviation of the energy for each T
stdm8x8=data8x8[:,6] #edited ILtemperaturerange.py to record the standard deviation of the magnetisation for each T

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.errorbar(temps8x8, np.array(energies8x8)/64,yerr=np.divide(stde8x8,64),color='black',ecolor='teal',alpha=0.8) #plots energy per spin against T
magax.errorbar(temps8x8, np.array(mag8x8)/64,yerr=np.divide(stdm8x8,64),alpha=0.8,ecolor='salmon',color='black') #plots magnetisation per spin against T on separate graph
pl.savefig('8x8error.png',bbox_inches='tight') #saves figure
pl.show()

</pre>

==Section 6 - The effect of system size==

===TASK: Repeat the final task of the previous section for the following lattice sizes: 2x2, 4x4, 8x8, 16x16, 32x32. Make sure that you name each datafile that your produce after the corresponding lattice size! Write a Python script to make a plot showing the energy per spin versus temperature for each of your lattice sizes. Hint: the NumPy loadtxt function is the reverse of the savetxt function, and can be used to read your previously saved files into the script. Repeat this for the magnetisation. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. How big a lattice do you think is big enough to capture the long range fluctuations?===

The python script for this section is identical as for the 8x8 graph above in Figure 11 with the relevant files and variables changed accordingly.

Each matrix was simulated using the ILtemperaturerange.py file between T=0.5 and T=5 with a step of T=0.02.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2error.png
| caption1 = 2x2 matrix - 5000 steps, cut-off = 30 steps
| image2 = 4x4error.png
| caption2 = 4x4 matrix - 1000 steps, cut-off = 200 steps
| image3 =cg141716x16error.png
| caption3 = 16x16 matrix - 50000 steps, cut-off = 15000 steps
| image4 =cg141732x32error.png
| caption4 = 32x32 matrix - 200000 steps, cut-off = 50000 steps
| footer_align = left
| footer = Figure 12 - Results of running the ILtemperaturerange.py file for 2x2, 4x4, 16x16 and 32x32 matrices.
}}

 

==Section 7 - Determining the Heat Capacity==

===TASK: By definition, <math>C = \frac{\partial \left\langle E\right\rangle}{\partial T}</math>. From this, show that <math>C = \frac{\mathrm{Var}[E]}{k_B T^2}</math> (Where <math>\mathrm{Var}[E]</math> is the variance in <math>E</math>.)===

Recall from statistical thermodynamics that the average energy of a system is the sum across all microstates of the probability of that microstate multiplied by the energy of that microstate, which is defined mathematically asː <math>\langle E \rangle = \sum_i p_{i}\epsilon_{i}</math>.

The partition function <math>q</math> is defined as <math>q = \sum_{i} exp(-\beta \epsilon_{i})</math> where <math>\beta =\frac{1}{k_BT}</math>and the probability, <math>p_{i}</math> can be defined in terms of the partition function as <math>p_{i} = \frac{exp(-\beta \epsilon_{i})}{\sum_{i} exp(-\beta \epsilon_{i})} = \frac{exp(-\beta \epsilon_{i})}{q}</math>.

As a result, <math>\langle E \rangle</math> can be re-written as <math>\langle E \rangle = \sum_{i} \frac{\epsilon_{i} exp(-\beta \epsilon_{i})}{q} = -\frac{1}{q} \frac{\partial}{\partial \beta}\sum_{i}exp(-\beta \epsilon_{i}) = -\frac{1}{q} \frac{\partial q}{\partial \beta}</math>

Likewise, <math>\langle E^2 \rangle = \sum_i p_{i}\epsilon_{i}^{2} = \sum_{i} \frac{\epsilon_{i}^{2}exp(-\beta \epsilon_{i})}{q} = \frac{1}{q} \frac{\partial^{2}}{\partial \beta^{2}}\sum_{i}exp(-\beta \epsilon_{i}) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}}</math>

From definitionː <math>Var[E] = \Delta E^2 = \langle E^2 \rangle - \langle E \rangle^2 </math>

When the definition of <math>\langle E \rangle</math> and <math>\langle E^2 \rangle</math> is written in terms of partition function <math>q</math>ː <math>Var[E] = \langle E^2 \rangle - \langle E \rangle^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \left(\frac{1}{q}\frac{\partial q}{\partial \beta}\right)^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2</math>.

According to the chain ruleː <math>\frac{\partial}{\partial \beta}\left(\frac{1}{q} \frac{\partial q}{\partial \beta}\right) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2 = -\frac{\partial}{\partial \beta}\langle E \rangle = Var[E]</math>

And using the chain rule againː <math>C = \frac{\partial \langle E \rangle}{\partial T}= \left(-\frac{\partial \langle E \rangle}{\partial \beta}\right) \left(-\frac{\partial \beta}{\partial T}\right) = \frac{Var[E]}{k_B T^2}</math>

===TASK: Write a Python script to make a plot showing the heat capacity versus temperature for each of your lattice sizes from the previous section. You may need to do some research to recall the connection between the variance of a variable, <math>\mathrm{Var}[X]</math>, the mean of its square <math>\left\langle X^2\right\rangle</math>, and its squared mean <math>\left\langle X\right\rangle^2</math>. You may find that the data around the peak is very noisy — this is normal, and is a result of being in the critical region. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. ===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb

{{multiple image
| width =300
| align = left
| image1 = cg14172x2heatcap.png
| caption1 = 2x2 Matrix
| image2 = cg14174x4heatcap.png
| caption2 = 4x4 Matrix
| image3 =cg14178x8heatcap.png
| caption3 = 8x8 Matrix
| image4 =cg141716x16heatcap.png
| caption4 = 16x16 Matrix
| image5=cg141732x32heatcap.png
| caption5= 32x32 Matrix
| footer = Figure 13 - Graphs showing Heat Capacity against Temperature for each matrix size
}}

A general trend from the above graphs is that the peak of the graph shifts towards lower temperatures as the size of the matrix used increases.

==Section 8 - Locating the Curie Temperature==
===TASK: A C++ program has been used to run some much longer simulations than would be possible on the college computers in Python. You can view its source code here if you are interested. Each file contains six columns: <math>T, E, E^2, M, M^2, C</math> (the final five quantities are per spin), and you can read them with the NumPy loadtxt function as before. For each lattice size, plot the C++ data against your data. For one lattice size, save a PNG of this comparison and add it to your report — add a legend to the graph to label which is which. To do this, you will need to pass the label="..." keyword to the plot function, then call the legend() function of the axis object (documentation here).===

The python code used to read and plot the C++ data is found in the Jupyter notebook CG1417IsingModelGraphs.ipynb.

''Figure 14'' below shows the C++ plotted against my own data for a 16x16 Matrix.

[[File:Cg141716x16C++.png|400px|thumb|left|Figure 14 - Graph showing my own data against the C++ data for a 16x16 matrix.]]

 

===TASK: write a script to read the data from a particular file, and plot C vs T, as well as a fitted polynomial. Try changing the degree of the polynomial to improve the fit — in general, it might be difficult to get a good fit! Attach a PNG of an example fit to your report.===

The python script to read and plot the fitted polynomial is found in CG1417PolyfitScript.ipynb

Below in ''Figure 15'' is a plot of my Heat Capacity against Temperature data for a 16x16 matrix and features a polynomial of degree 35 plotted against it. Even with a polynomial of such a high degree, it poorly fits the curve and does not fit to the peak of the curve either.

[[File:cg1417FIT_TEST16x16_35.png|thumb|left|400px|Figure 15 - Plot of Heat Capacity against Temperature along with a poorly fitted polynomial of degree 35. ]]

 

===TASK: Modify your script from the previous section. You should still plot the whole temperature range, but fit the polynomial only to the peak of the heat capacity! You should find it easier to get a good fit when restricted to this region===

The script was modified as such that the polynomial was fitted in a set range around the peak of the graph, this is demonstrated in ''Figure 17'' which shows a newly fitted polynomial between a much smaller range of temperatures (T = 2.15-2.55) and a much smaller degree polynomial (3).

[[File:CG1417FIT_16x16C_3.png|thumb|left|400px|Figure 16 - Graph showing Heat Capacity against Temperature for a 16x16 matrix along with a fitted polynomial between a much more restricted range of temperatures and a significantly lower degree of polynomial]]

Upon comparison with ''Figure 15'', the new fitted polynomial is a significantly better fit even for a 3rd degree polynomial and is a much more accurate representation of my data around the peak of the graph and will make it easier to determine the maximum value of Heat Capacity.

 

===TASK: find the temperature at which the maximum in C occurs for each datafile that you were given. Make a text file containing two colums: the lattice side length (2,4,8, etc.), and the temperature at which C is a maximum. This is your estimate of <math>T_C</math> for that side length. Make a plot that uses the scaling relation given above to determine <math>T_{C,\infty}</math>. By doing a little research online, you should be able to find the theoretical exact Curie temperature for the infinite 2D Ising lattice. How does your value compare to this? Are you surprised by how good/bad the agreement is? Attach a PNG of this final graph to your report, and discuss briefly what you think the major sources of error are in your estimate.===

''Figure 17'' below shows a graph of <math>T_{C,L}</math> against <math>\frac{1}{Lattice Size}</math> to determine the Curie Temperature of an infinite 2D Ising Model Lattice <math>T_{C,\infty}</math>. The black dots represent the raw data obtained from obtaining the temperature at which the Heat Capacity was a maximum for the lattices and the red line in a linear curve fit plotted against the data to allow the y-intercept which is the Curie Temperature for the infinite 2D lattice to be determined.

[[File:cg1417CurieTemp.png|400px|thumb|left|Figure 17 - Plot of 1/Lattice Size against Curie Temperature for that lattice size.]]

The value for <math>T_{C,\inf}</math> obtained from the data is <math>T_{C,\infty} = 2.277 \frac{J}{k_B}</math> with a literature value being <math>T_{C,\infty} = 2.269 \frac{J}{k_B}</math> <ref>L. Onsager, Phys. Rev., 1944, 65, 117--149.</ref>for an infinite square 2D lattice. This means that my result slightly over-estimates the Curie Temperature for the infinite lattice and as a result for an infinite lattice the temperature at which spontaneous magnetisation stops would actually occur at a slightly lower temperature than expected. However, the difference between my value and the literature value is only 0.008 which is incredibly small and the amount of agreement between the two values is somewhat surprising, which means that the error in my estimates of the Curie Temperature for each lattice size is relatively small. The points which have the largest residuals and deviation from the line of best fit in ''Figure 17'' corresponds to the smaller lattice sizes of 2x2 and 4x4 where longer range interactions are more significant. The longer range interactions posed by the boundary conditions are nowhere near as significant for the larger sizes and causes the energy of the smaller matrices to be less accurate and have a larger associated error with the energy and thus the Curie Temperature for that lattice size. This affects the accuracy of the line of best fit and to increase the accuracy of this line, larger lattice sizes of 128x128, 256x256 etc should be included in the calculation for the line of best fit and the smaller matrices ignored.

 

== References ==

Rep:Y3CMPCG1417

2019-11-20T09:19:31Z

==Section 1 - Introduction to the Ising Model==

===TASK: Show that the lowest possible energy for the Ising model is <math>E = -DNJ</math>, where D is the number of dimensions and N is the total number of spins. What is the multiplicity of this state? Calculate its entropy.===

Consider a 1D row of lattice sites of N=3 with spin configuration [+1][+1][+1].

Mathematically the interaction energy is defined asː
<math> -\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} </math> where J is a constant and <math>s_{i}s_{j}</math> is the product between two spins in adjacent lattice sites.

The sum of the interaction energies <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j}</math> can be considered as the sum of the individual interaction energies between spinsː
<math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = \epsilon_{12} + \epsilon_{23} + \epsilon_{13} + \epsilon_{21} + \epsilon_{32} + \epsilon_{31} </math>.

Although lattice sites 1 and 3 are not adjacent they are said to still interact according to the periodic boundary conditions applied.

However, <math>\epsilon_{12} = \epsilon_{21} </math> and <math>\epsilon_{23} = \epsilon_{32}</math> and <math>\epsilon_{13} = \epsilon_{31}</math> which means that all of the interactions within the system are counted twice, hence the total energy needs to be halved, resulting in the following formula being obtainedː <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = 2\epsilon_{12} + 2\epsilon_{13} + 2\epsilon_{23} </math>.

It can be determined that <math>\epsilon_{12} = (+1)(+1) = 1</math> , <math>\epsilon_{13} = (+1)(+1) = 1</math> and <math>\epsilon_{23} = (+1)(+1) = 1</math>.

Thereforeː <math>-\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = -\frac{1}{2} \ J \ (2 + 2 + 2) = -\frac{1}{2} \ J \ 6 = - 3 J = -DNJ</math> for a 1D lattice with <math>D=1</math> and 3 lattice sites <math>N=3</math>

The multiplicity of the system,<math>\Omega = \frac{n. spin up!}{n. spin down!}</math>

Entropy, <math>S</math> is defined as <math>S = k_B ln(\Omega)</math> and so in this case <math>S = k_B ln(\frac{100!}{100!}) = 0</math>

===TASK: Imagine that the system is in the lowest energy configuration. To move to a different state, one of the spins must spontaneously change direction ("flip"). What is the change in energy if this happens <math>(D=3, N=1000)</math>? How much entropy does the system gain by doing soʔ===

In a 3D lattice system, each lattice site has three unique interactions with its neighbours to its left, top and front. In the lowest energy configuration, all spins are parallel and for a system the minimum energy is <math>E = -DNJ</math>, so for the system with <math>N=1000</math> and <math>D=3</math>, the minimum energy is <math>-3000J</math>.

If a single spin is flipped, the product of its spin with its neighbours spin reverses and becomes negative and this increases the total energy of the system. Since 3 unique spin-spin interactions are reversed in sign, the total energy increases by <math>+3J</math>, meaning the new total energy is <math>-2997J</math>

Initially the multiplicity of the system will be <math>\Omega = \frac{1000!}{1000!}</math> , and after the flip, the multiplicity becomes <math> \Omega = \frac{1000!}{999!1!}=1000</math>.

The associated change in entropy, <math>\Delta S = k_B ln(1000) - 0 = 6.91 k_B</math>, which is an expected increase in entropy as the number of possible configurations of the system increases.

===TASK: Calculate the magnetisation of the 1D and 2D lattices in Figure 1. What magnetisation would you expect to observe for an Ising lattice with <math>D = 3,\ N=1000</math> at absolute zero?===

[[File:ThirdYearCMPExpt-IsingSketch.png|thumb|left|Figure 1 - Shows 1D (N = 5), 2D (N = 5x5) and 3D (N = 5x5x5) lattices.]]

Magnetisation is defined as <math>M=\sum_{i} s_i</math>. So for the 1D lattice with <math>N = 5</math> in ''Figure 2'', <math>M = +1</math> and for the 2D lattice with <math>N = 25 , M = +1</math> too.

According to the 3rd Law of thermodynamics, entropy is 0 at absolute zero for a perfect crystalline solid, and consequently it is expected that the lattices will have follow suit and have zero entropy at 0K. To have zero entropy all spins must be parallel as such that magnetisation, <math>M = N</math>. For all the spins to be parallel, there is only one possible configuration. So, for a lattice with <math>N = 1000</math> and <math>D =3</math>, if <math>M = N</math>, then multiplicity, <math>\Omega = 1</math> and entropy, <math>S =k_B ln(1) = 0</math>.

 

==Section 2 - Calculating the Energy and Magnetisation==

===TASK: complete the functions energy() and magnetisation(), which should return the energy of the lattice and the total magnetisation, respectively. In the energy() function you may assume that <math>J=1.0</math> at all times (in fact, we are working in reduced units in which <math>J=k_B</math>, but there will be more information about this in later sections). Do not worry about the efficiency of the code at the moment — we will address the speed in a later part of the experiment.===

<pre>def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
lat=self.lattice #creates lattice and stores it
mag=[]
for i in range(0,len(lat)): #loops through all rows of lattice
for j in range(0,len(lat[i])): #loops through elements of each row
mag+=[lat[i][j]] #adds spin value to mag array
return sum(mag) #sums all spins from mag array
</pre>

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

lat=self.lattice #creates lattice and stores it
left=[]
top=[]

for i in range(0,len(lat)):
for j in range(0,len(lat[i])):
left+=[lat[i][j]*lat[i][j-1]] #multiplies spin by spin to left
top+=[lat[i][j]*lat[i-1][j]] #multiplies spin by spin above it
int_en=left+top #sums spin products from left and top
energy=-sum(int_en) #sums all spin products for each spin to give total

return energy
</pre>

===TASK: Run the ILcheck.py script from the IPython Qt console using the command===

''Figure 2'' shows the results when ILcheck.py was ran on my IsingLattice.py file. The ILcheck.py file was ran several times to ensure the code worked for various random lattices.

[[File:Cg1417ILcheck run.png|thumb|left|500px| Figure 2 - Result from running the ILcheck.py file]]

 

==Section 3 - Introduction to Monte Carlo Simulation==

===TASK: How many configurations are available to a system with 100 spins? To evaluate these expressions, we have to calculate the energy and magnetisation for each of these configurations, then perform the sum. Let's be very, very, generous, and say that we can analyse <math>1\times 10^9</math> configurations per second with our computer. How long will it take to evaluate a single value of <math>\left\langle M\right\rangle_T</math>?===

For a system with 100 lattice sites and two possible spins for each site, there are <math>2^{100}</math>possible configurations for the system. <math>2^{100}= 1.27\times 10^{30} </math>, so if the computer can analyse <math>1\times 10^9</math> configurations per second, then it will take <math>\frac{1.27\times 10^{30}}{10^9} = 1.27\times 10^{21} s</math> to analyse the whole system, which is longer than the age of the universe and therefore is not a practical approach.

===TASK: Implement a single cycle of the above algorithm in the montecarlocycle(T) function. This function should return the energy of your lattice and the magnetisation at the end of the cycle. You may assume that the energy returned by your energy() function is in units of <math>k_B</math>! Complete the statistics() function. This should return the following quantities whenever it is called: <math><E>, <E^2>, <M>, <M^2></math>, and the number of Monte Carlo steps that have elapsed.===
<pre>
E = []
E2 = []
M = []
M2 = []
n_cycles = 0

def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back if rejected else not changed

self.E+=[self.energy()] #records energy
self.E2+=[self.energy()**2] #records energy squared
self.M+=[self.magnetisation()] #records magnetisation
self.M2+=[self.magnetisation()**2] #records magnetisation squared
self.n_cycles=self.n_cycles+1 #adds 1 to run total

return (self.energy(),self.magnetisation())

def statistics(self):
# complete this function so that it calculates the correct values for the averages of E, E*E (E2), M, M*M (M2), and returns them

e=np.mean(self.E)
e2=np.mean(self.E2)
m=np.mean(self.M)
m2=np.mean(self.M2)

return e,e2,m,m2,self.n_cycles
</pre>

===TASK: If <math>T < T_C</math>, do you expect a spontaneous magnetisation (i.e. do you expect <math>\left\langle M\right\rangle \neq 0</math>)? When the state of the simulation appears to stop changing (when you have reached an equilibrium state), use the controls to export the output to PNG and attach this to your report. You should also include the output from your statistics() function.===

If the temperature of the system is less than the Curie Temperature, <math>T_C</math> then spontaneous magnetisation can occur and the system will tend to its lowest energy state where all of the spins are parallel - this is a property of ferromagnetic materials.

[[File:Cg1417ILanim_run.png|400px|thumb|left|Figure 3 - Results from running the ILanim.py file - shows the energy and magnetisation converging over time]]

''Figure 3'' shows that over time the the system spontaneously converges to the minimum energy state with all of the spins parallel to one another and shows, as I expected, that spontaneous magnetisation occurs and also shows that the temperature of this simulation is below the Curie Temperature, <math>T < T_C</math>.

 

==Section 4 - Accelerating the Code==

===TASK: Use the script ILtimetrial.py to record how long your current version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 4'' show the results of running the ILtimetrial.py file on my code three timesː

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1.png
| width1=500
| image2=cg1417ILtimetrial_run2.png
| width2=500
| image3=cg1417ILtimetrial_run3.png
| width3=500
| footer = Figure 4 - Results of running the ILtimetrial.py file on my code three separate times
}}
 

This gave me an avergage time of <math>24.3 s \pm 0.2s</math>

===TASK: Look at the documentation for the NumPy sum function. You should be able to modify your magnetisation() function so that it uses this to evaluate M. The energy is a little trickier. Familiarise yourself with the NumPy roll and multiply functions, and use these to replace your energy double loop (you will need to call roll and multiply twice!).===

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

left=multiply(roll(self.lattice,1,axis=1),self.lattice) #product of spin with spin left of it
top=multiply(roll(self.lattice,-1,axis=0),self.lattice) #product of spin with spin above it

int_en=sum(left+top) #sum of array containing sum of left and top spin products for each spin

energy = -sum(int_en) #calculates the total energy of system
return energy

def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
return sum(sum(self.lattice)) #adds up all spins in lattice
</pre>

===TASK: Use the script ILtimetrial.py to record how long your new version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 5'' shows the result of running the ILtimetrial.py on my new accelerated code.

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1fast.png
| width1=500
| image2=ILtimetrial_run2fast.png
| width2=500
| image3=ILtimetrial_run3fast.png
| width3=500
| footer = Figure 5 - Results of running the ILtimetrial.py file on my new updated and accelerated code.
}}
 

The accelerated code is much faster upon using the roll, multiply and sum modules with a new average time of <math>0.790 s \pm 0.005 </math>

==Section 5 - The effect of temperature==

===TASK: The script ILfinalframe.py runs for a given number of cycles at a given temperature, then plots a depiction of the final lattice state as well as graphs of the energy and magnetisation as a function of cycle number. This is much quicker than animating every frame! Experiment with different temperature and lattice sizes. How many cycles are typically needed for the system to go from its random starting position to the equilibrium state? Modify your statistics() and montecarlostep() functions so that the first N cycles of the simulation are ignored when calculating the averages. You should state in your report what period you chose to ignore, and include graphs from ILfinalframe.py to illustrate your motivation in choosing this figure.===

''Figure 6'' below shows the results from running the ILfinalframe.py for 2x2 lattice at T=1,2,3,5.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2T1.png
| image2 = cg14172x2T2.png
| image3 =cg14172x2T3.png
| image4 =cg14172x2T5.png
| footer_align = left
| footer = Figure 6 - Results of running the ILfinalframe.py file at T=1,2,3,5 for a 2x2 matrix.
}}

 

For a 2x2 matrix, a suitable cut-off point to exclude from the avergage energies and magnetisations is where the energy and magnetisations per spin are constant, which is 30 steps. For T=3 and T=5 the graphs do not converge because it is possible that these temperatures are higher than the Curie Temperature and as such spontaneous magnetisation will not occur and the system will not diverge to the lowest energy state. At the higher temperatures, there are larger thermal fluctations and the Boltzmann factor is more significant allowing the system to move away from the lowest energy state easier. As a result moving forwards, a suitable cut-off point will only be determined from T=1 and T=2 graphs for the larger matrices.

''Figure 7'' shows the results from running a 4x4 lattice at T=1,2 and 3.

{{multiple image
| width =350
| align = left
| image1 = cg14174x4T1.png
| image2 = cg14174x4T2.png
| image3 =cg14174x4T3.png
| footer_align = left
| footer = Figure 7 - Results of running the ILfinalframe.py file at T=1,2,3 for a 4x4 matrix.
}}

From ''Figure 7'', a suitable cut-off point for the energy and magnetisations is 200 as this is after where the energy and magnetisation has converged for T=1, and is after the initial large drop in energy for T=2, even though there are a few small fluctuations after 200 steps. The result from T=3 has been included to show the large fluctuations for the larger temperatures, and supporting my choice to determine the cut-off from T=1 and T=2 only.

''Figure 8'' shows the results for an 8x8 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg14178x8T1.png
| image2 = cg14178x8T2.png
| footer_align = left
| footer = Figure 8 - Results of running the ILfinalframe.py file at T=1,2 for an 8x8 matrix
}}

From ''Figure 8'' above, a suitable cut-off point is 1000 steps as this is where the energy and magnetisation has easily converged by and is also the point after which the initial large drop in energy has been overcome for T=2 too.

''Figure 9'' shows the result of running the ILfinalframe.py for a 16x16 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg141716x16T1.png
| image2 = cg141716x16T2.png
| footer_align = left
| footer = Figure 9 - Results of running the ILfinalframe.py file at T=1,2 for a 16x16 matrix
}}

From ''Figure 9'', a suitable cut-off point is 15000 steps as for T=1 the energy and magnetisations have converged significantly and will not change much, and likewise this is the same for the T=2 frame.

''Figure 10'' below shows the results from a 32x32 matrix at T=1 and T=2.

{{multiple image
| width =350
| align = left
| image1 = cg141732x32T1.png
| image2 = cg141732x32T2.png
| footer_align = left
| footer = Figure 10 - Results of running the ILfinalframe.py file at T=1,2 for a 32x32 matrix
}}

''Figure 10'' above shows the results of running the ILfinalframe.py file for a 32x32 matrix at T=1 and T=2. As a result a suitable cut-off of 50000 steps was chosen as the energy and magnetisation has significantly converged, but not as much as it could at 100000 steps. I chose a slightly lower value to ensure that the run times of my monte-carlo simulations in future tasks were not extremely time consuming.

The montecarlostep() function was changed by adding a condition that values only above the pre-determined cut-off were included when determining the average value of energy; energy squared; magnetisation and magnetisations squared from the statistics function. The statistics() function did not need to be modified.

The following code is from the 32x32 matrixː

<pre>def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back

if self.n_cycles > 50000: #only adds values to array of E,E2,M and M2 is above specific cut-off
self.E+=[self.energy()]
self.E2+=[self.energy()**2]
self.M+=[self.magnetisation()]
self.M2+=[self.magnetisation()**2]
self.n_cycles=self.n_cycles+1

return (self.energy(),self.magnetisation())
</pre>

===TASK: Use ILtemperaturerange.py to plot the average energy and magnetisation for each temperature, with error bars, for an <math>8\times 8</math> lattice. Use your intuition and results from the script ILfinalframe.py to estimate how many cycles each simulation should be. The temperature range 0.25 to 5.0 is sufficient. Use as many temperature points as you feel necessary to illustrate the trend, but do not use a temperature spacing larger than 0.5. The NumPy function savetxt() stores your array of output data on disk — you will need it later. Save the file as 8x8.dat so that you know which lattice size it came from.===

Using the modified code, the file ILtemperaturerange.py was ran on an 8x8 matrix between T=0.5 and T=5 with a step of T=0.02 for 10000 Montecarlo steps and the first 1000 steps of each temperature were excluded when calculating the averages. ''Figure 11'' shows the result of the simulation and also included error bars of standard deviation.

[[File:Cg14178x8error.png|1000px|thumb|left|Figure 11 - Graph showing average energy and average magnetisation for an 8x8 lattice with error bars between T=0.5 and T=5]]

 

Below is the source code for the script to produce the graphː

<pre>data8x8=np.loadtxt('8x8.dat') #loads data
temps8x8=data8x8[:,0] #stores temperatures
energies8x8=data8x8[:,1] #stores average energy for each T
energysq8x8=data8x8[:,2] #stores average energy squared for each T
mag8x8=data8x8[:,3] #stores magnetisation for each T
magsq8x8=data8x8[:,4] #stores magnetisation squared for each T
stde8x8=data8x8[:,5] #edited ILtemperaturerange.py to record the standard deviation of the energy for each T
stdm8x8=data8x8[:,6] #edited ILtemperaturerange.py to record the standard deviation of the magnetisation for each T

fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.5, 0.5])
enerax.set_xlim([0.5,5.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-2, 2])
magax.set_xlim([0.5,5.1])
enerax.errorbar(temps8x8, np.array(energies8x8)/64,yerr=np.divide(stde8x8,64),color='black',ecolor='teal',alpha=0.8) #plots energy per spin against T
magax.errorbar(temps8x8, np.array(mag8x8)/64,yerr=np.divide(stdm8x8,64),alpha=0.8,ecolor='salmon',color='black') #plots magnetisation per spin against T on separate graph
pl.savefig('8x8error.png',bbox_inches='tight') #saves figure
pl.show()

</pre>

==Section 6 - The effect of system size==

===TASK: Repeat the final task of the previous section for the following lattice sizes: 2x2, 4x4, 8x8, 16x16, 32x32. Make sure that you name each datafile that your produce after the corresponding lattice size! Write a Python script to make a plot showing the energy per spin versus temperature for each of your lattice sizes. Hint: the NumPy loadtxt function is the reverse of the savetxt function, and can be used to read your previously saved files into the script. Repeat this for the magnetisation. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. How big a lattice do you think is big enough to capture the long range fluctuations?===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb.

Each matrix was simulated using the ILtemperaturerange.py file between T=0.5 and T=5 with a step of T=0.02.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2error.png
| caption1 = 2x2 matrix - 5000 steps, cut-off = 30 steps
| image2 = 4x4error.png
| caption2 = 4x4 matrix - 1000 steps, cut-off = 200 steps
| image3 =cg141716x16error.png
| caption3 = 16x16 matrix - 50000 steps, cut-off = 15000 steps
| image4 =cg141732x32error.png
| caption4 = 32x32 matrix - 200000 steps, cut-off = 50000 steps
| footer_align = left
| footer = Figure 12 - Results of running the ILtemperaturerange.py file for 2x2, 4x4, 16x16 and 32x32 matrices.
}}

 

==Section 7 - Determining the Heat Capacity==

===TASK: By definition, <math>C = \frac{\partial \left\langle E\right\rangle}{\partial T}</math>. From this, show that <math>C = \frac{\mathrm{Var}[E]}{k_B T^2}</math> (Where <math>\mathrm{Var}[E]</math> is the variance in <math>E</math>.)===

Recall from statistical thermodynamics that the average energy of a system is the sum across all microstates of the probability of that microstate multiplied by the energy of that microstate, which is defined mathematically asː <math>\langle E \rangle = \sum_i p_{i}\epsilon_{i}</math>.

The partition function <math>q</math> is defined as <math>q = \sum_{i} exp(-\beta \epsilon_{i})</math> where <math>\beta =\frac{1}{k_BT}</math>and the probability, <math>p_{i}</math> can be defined in terms of the partition function as <math>p_{i} = \frac{exp(-\beta \epsilon_{i})}{\sum_{i} exp(-\beta \epsilon_{i})} = \frac{exp(-\beta \epsilon_{i})}{q}</math>.

As a result, <math>\langle E \rangle</math> can be re-written as <math>\langle E \rangle = \sum_{i} \frac{\epsilon_{i} exp(-\beta \epsilon_{i})}{q} = -\frac{1}{q} \frac{\partial}{\partial \beta}\sum_{i}exp(-\beta \epsilon_{i}) = -\frac{1}{q} \frac{\partial q}{\partial \beta}</math>

Likewise, <math>\langle E^2 \rangle = \sum_i p_{i}\epsilon_{i}^{2} = \sum_{i} \frac{\epsilon_{i}^{2}exp(-\beta \epsilon_{i})}{q} = \frac{1}{q} \frac{\partial^{2}}{\partial \beta^{2}}\sum_{i}exp(-\beta \epsilon_{i}) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}}</math>

From definitionː <math>Var[E] = \Delta E^2 = \langle E^2 \rangle - \langle E \rangle^2 </math>

When the definition of <math>\langle E \rangle</math> and <math>\langle E^2 \rangle</math> is written in terms of partition function <math>q</math>ː <math>Var[E] = \langle E^2 \rangle - \langle E \rangle^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \left(\frac{1}{q}\frac{\partial q}{\partial \beta}\right)^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2</math>.

According to the chain ruleː <math>\frac{\partial}{\partial \beta}\left(\frac{1}{q} \frac{\partial q}{\partial \beta}\right) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2 = -\frac{\partial}{\partial \beta}\langle E \rangle = Var[E]</math>

And using the chain rule againː <math>C = \frac{\partial \langle E \rangle}{\partial T}= \left(-\frac{\partial \langle E \rangle}{\partial \beta}\right) \left(-\frac{\partial \beta}{\partial T}\right) = \frac{Var[E]}{k_B T^2}</math>

===TASK: Write a Python script to make a plot showing the heat capacity versus temperature for each of your lattice sizes from the previous section. You may need to do some research to recall the connection between the variance of a variable, <math>\mathrm{Var}[X]</math>, the mean of its square <math>\left\langle X^2\right\rangle</math>, and its squared mean <math>\left\langle X\right\rangle^2</math>. You may find that the data around the peak is very noisy — this is normal, and is a result of being in the critical region. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. ===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb

{{multiple image
| width =300
| align = left
| image1 = cg14172x2heatcap.png
| caption1 = 2x2 Matrix
| image2 = cg14174x4heatcap.png
| caption2 = 4x4 Matrix
| image3 =cg14178x8heatcap.png
| caption3 = 8x8 Matrix
| image4 =cg141716x16heatcap.png
| caption4 = 16x16 Matrix
| image5=cg141732x32heatcap.png
| caption5= 32x32 Matrix
| footer = Figure 13 - Graphs showing Heat Capacity against Temperature for each matrix size
}}

A general trend from the above graphs is that the peak of the graph shifts towards lower temperatures as the size of the matrix used increases.

==Section 8 - Locating the Curie Temperature==
===TASK: A C++ program has been used to run some much longer simulations than would be possible on the college computers in Python. You can view its source code here if you are interested. Each file contains six columns: <math>T, E, E^2, M, M^2, C</math> (the final five quantities are per spin), and you can read them with the NumPy loadtxt function as before. For each lattice size, plot the C++ data against your data. For one lattice size, save a PNG of this comparison and add it to your report — add a legend to the graph to label which is which. To do this, you will need to pass the label="..." keyword to the plot function, then call the legend() function of the axis object (documentation here).===

The python code used to read and plot the C++ data is found in the Jupyter notebook CG1417IsingModelGraphs.ipynb.

''Figure 14'' below shows the C++ plotted against my own data for a 16x16 Matrix.

[[File:Cg141716x16C++.png|400px|thumb|left|Figure 14 - Graph showing my own data against the C++ data for a 16x16 matrix.]]

 

===TASK: write a script to read the data from a particular file, and plot C vs T, as well as a fitted polynomial. Try changing the degree of the polynomial to improve the fit — in general, it might be difficult to get a good fit! Attach a PNG of an example fit to your report.===

The python script to read and plot the fitted polynomial is found in CG1417PolyfitScript.ipynb

Below in ''Figure 15'' is a plot of my Heat Capacity against Temperature data for a 16x16 matrix and features a polynomial of degree 35 plotted against it. Even with a polynomial of such a high degree, it poorly fits the curve and does not fit to the peak of the curve either.

[[File:cg1417FIT_TEST16x16_35.png|thumb|left|400px|Figure 15 - Plot of Heat Capacity against Temperature along with a poorly fitted polynomial of degree 35. ]]

 

===TASK: Modify your script from the previous section. You should still plot the whole temperature range, but fit the polynomial only to the peak of the heat capacity! You should find it easier to get a good fit when restricted to this region===

The script was modified as such that the polynomial was fitted in a set range around the peak of the graph, this is demonstrated in ''Figure 17'' which shows a newly fitted polynomial between a much smaller range of temperatures (T = 2.15-2.55) and a much smaller degree polynomial (3).

[[File:CG1417FIT_16x16C_3.png|thumb|left|400px|Figure 16 - Graph showing Heat Capacity against Temperature for a 16x16 matrix along with a fitted polynomial between a much more restricted range of temperatures and a significantly lower degree of polynomial]]

Upon comparison with ''Figure 15'', the new fitted polynomial is a significantly better fit even for a 3rd degree polynomial and is a much more accurate representation of my data around the peak of the graph and will make it easier to determine the maximum value of Heat Capacity.

 

===TASK: find the temperature at which the maximum in C occurs for each datafile that you were given. Make a text file containing two colums: the lattice side length (2,4,8, etc.), and the temperature at which C is a maximum. This is your estimate of <math>T_C</math> for that side length. Make a plot that uses the scaling relation given above to determine <math>T_{C,\infty}</math>. By doing a little research online, you should be able to find the theoretical exact Curie temperature for the infinite 2D Ising lattice. How does your value compare to this? Are you surprised by how good/bad the agreement is? Attach a PNG of this final graph to your report, and discuss briefly what you think the major sources of error are in your estimate.===

''Figure 17'' below shows a graph of <math>T_{C,L}</math> against <math>\frac{1}{Lattice Size}</math> to determine the Curie Temperature of an infinite 2D Ising Model Lattice <math>T_{C,\infty}</math>. The black dots represent the raw data obtained from obtaining the temperature at which the Heat Capacity was a maximum for the lattices and the red line in a linear curve fit plotted against the data to allow the y-intercept which is the Curie Temperature for the infinite 2D lattice to be determined.

[[File:cg1417CurieTemp.png|400px|thumb|left|Figure 17 - Plot of 1/Lattice Size against Curie Temperature for that lattice size.]]

The value for <math>T_{C,\inf}</math> obtained from the data is <math>T_{C,\infty} = 2.277 \frac{J}{k_B}</math> with a literature value being <math>T_{C,\infty} = 2.269 \frac{J}{k_B}</math> <ref>L. Onsager, Phys. Rev., 1944, 65, 117--149.</ref>for an infinite square 2D lattice. This means that my result slightly over-estimates the Curie Temperature for the infinite lattice and as a result for an infinite lattice the temperature at which spontaneous magnetisation stops would actually occur at a slightly lower temperature than expected. However, the difference between my value and the literature value is only 0.008 which is incredibly small and the amount of agreement between the two values is somewhat surprising, which means that the error in my estimates of the Curie Temperature for each lattice size is relatively small. The points which have the largest residuals and deviation from the line of best fit in ''Figure 17'' corresponds to the smaller lattice sizes of 2x2 and 4x4 where longer range interactions are more significant. The longer range interactions posed by the boundary conditions are nowhere near as significant for the larger sizes and causes the energy of the smaller matrices to be less accurate and have a larger associated error with the energy and thus the Curie Temperature for that lattice size. This affects the accuracy of the line of best fit and to increase the accuracy of this line, larger lattice sizes of 128x128, 256x256 etc should be included in the calculation for the line of best fit and the smaller matrices ignored.

 

== References ==

Rep:Y3CMPCG1417

2019-11-20T08:50:33Z

Cg1417: /* References */

==Section 1 - Introduction to the Ising Model==

===TASK: Show that the lowest possible energy for the Ising model is <math>E = -DNJ</math>, where D is the number of dimensions and N is the total number of spins. What is the multiplicity of this state? Calculate its entropy.===

Consider a 1D row of lattice sites of N=3 with spin configuration [+1][+1][+1].

Mathematically the interaction energy is defined asː
<math> -\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} </math> where J is a constant and <math>s_{i}s_{j}</math> is the product between two spins in adjacent lattice sites.

The sum of the interaction energies <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j}</math> can be considered as the sum of the individual interaction energies between spinsː
<math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = \epsilon_{12} + \epsilon_{23} + \epsilon_{13} + \epsilon_{21} + \epsilon_{32} + \epsilon_{31} </math>.

Although lattice sites 1 and 3 are not adjacent they are said to still interact according to the periodic boundary conditions applied.

However, <math>\epsilon_{12} = \epsilon_{21} </math> and <math>\epsilon_{23} = \epsilon_{32}</math> and <math>\epsilon_{13} = \epsilon_{31}</math> which means that all of the interactions within the system are counted twice, hence the total energy needs to be halved, resulting in the following formula being obtainedː <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = 2\epsilon_{12} + 2\epsilon_{13} + 2\epsilon_{23} </math>.

It can be determined that <math>\epsilon_{12} = (+1)(+1) = 1</math> , <math>\epsilon_{13} = (+1)(+1) = 1</math> and <math>\epsilon_{23} = (+1)(+1) = 1</math>.

Thereforeː <math>-\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = -\frac{1}{2} \ J \ (2 + 2 + 2) = -\frac{1}{2} \ J \ 6 = - 3 J = -DNJ</math> for a 1D lattice with <math>D=1</math> and 3 lattice sites <math>N=3</math>

The multiplicity of the system,<math>\Omega = \frac{n. spin up!}{n. spin down!}</math>

Entropy, <math>S</math> is defined as <math>S = k_B ln(\Omega)</math> and so in this case <math>S = k_B ln(\frac{100!}{100!}) = 0</math>

===TASK: Imagine that the system is in the lowest energy configuration. To move to a different state, one of the spins must spontaneously change direction ("flip"). What is the change in energy if this happens <math>(D=3, N=1000)</math>? How much entropy does the system gain by doing soʔ===

In a 3D lattice system, each lattice site has three unique interactions with its neighbours to its left, top and front. In the lowest energy configuration, all spins are parallel and for a system the minimum energy is <math>E = -DNJ</math>, so for the system with <math>N=1000</math> and <math>D=3</math>, the minimum energy is <math>-3000J</math>.

If a single spin is flipped, the product of its spin with its neighbours spin reverses and becomes negative and this increases the total energy of the system. Since 3 unique spin-spin interactions are reversed in sign, the total energy increases by <math>+3J</math>, meaning the new total energy is <math>-2997J</math>

Initially the multiplicity of the system will be <math>\Omega = \frac{1000!}{1000!}</math> , and after the flip, the multiplicity becomes <math> \Omega = \frac{1000!}{999!1!}=1000</math>.

The associated change in entropy, <math>\Delta S = k_B ln(1000) - 0 = 6.91 k_B</math>, which is an expected increase in entropy as the number of possible configurations of the system increases.

===TASK: Calculate the magnetisation of the 1D and 2D lattices in Figure 1. What magnetisation would you expect to observe for an Ising lattice with <math>D = 3,\ N=1000</math> at absolute zero?===

[[File:ThirdYearCMPExpt-IsingSketch.png|thumb|left|Figure 1 - Shows 1D (N = 5), 2D (N = 5x5) and 3D (N = 5x5x5) lattices.]]

Magnetisation is defined as <math>M=\sum_{i} s_i</math>. So for the 1D lattice with <math>N = 5</math> in ''Figure 2'', <math>M = +1</math> and for the 2D lattice with <math>N = 25 , M = +1</math> too.

According to the 3rd Law of thermodynamics, entropy is 0 at absolute zero for a perfect crystalline solid, and consequently it is expected that the lattices will have follow suit and have zero entropy at 0K. To have zero entropy all spins must be parallel as such that magnetisation, <math>M = N</math>. For all the spins to be parallel, there is only one possible configuration. So, for a lattice with <math>N = 1000</math> and <math>D =3</math>, if <math>M = N</math>, then multiplicity, <math>\Omega = 1</math> and entropy, <math>S =k_B ln(1) = 0</math>.

 

==Section 2 - Calculating the Energy and Magnetisation==

===TASK: complete the functions energy() and magnetisation(), which should return the energy of the lattice and the total magnetisation, respectively. In the energy() function you may assume that <math>J=1.0</math> at all times (in fact, we are working in reduced units in which <math>J=k_B</math>, but there will be more information about this in later sections). Do not worry about the efficiency of the code at the moment — we will address the speed in a later part of the experiment.===

<pre>def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
lat=self.lattice #creates lattice and stores it
mag=[]
for i in range(0,len(lat)): #loops through all rows of lattice
for j in range(0,len(lat[i])): #loops through elements of each row
mag+=[lat[i][j]] #adds spin value to mag array
return sum(mag) #sums all spins from mag array
</pre>

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

lat=self.lattice #creates lattice and stores it
left=[]
top=[]

for i in range(0,len(lat)):
for j in range(0,len(lat[i])):
left+=[lat[i][j]*lat[i][j-1]] #multiplies spin by spin to left
top+=[lat[i][j]*lat[i-1][j]] #multiplies spin by spin above it
int_en=left+top #sums spin products from left and top
energy=-sum(int_en) #sums all spin products for each spin to give total

return energy
</pre>

===TASK: Run the ILcheck.py script from the IPython Qt console using the command===

''Figure 2'' shows the results when ILcheck.py was ran on my IsingLattice.py file. The ILcheck.py file was ran several times to ensure the code worked for various random lattices.

[[File:Cg1417ILcheck run.png|thumb|left|500px| Figure 2 - Result from running the ILcheck.py file]]

 

==Section 3 - Introduction to Monte Carlo Simulation==

===TASK: How many configurations are available to a system with 100 spins? To evaluate these expressions, we have to calculate the energy and magnetisation for each of these configurations, then perform the sum. Let's be very, very, generous, and say that we can analyse <math>1\times 10^9</math> configurations per second with our computer. How long will it take to evaluate a single value of <math>\left\langle M\right\rangle_T</math>?===

For a system with 100 lattice sites and two possible spins for each site, there are <math>2^{100}</math>possible configurations for the system. <math>2^{100}= 1.27\times 10^{30} </math>, so if the computer can analyse <math>1\times 10^9</math> configurations per second, then it will take <math>\frac{1.27\times 10^{30}}{10^9} = 1.27\times 10^{21} s</math> to analyse the whole system, which is longer than the age of the universe and therefore is not a practical approach.

===TASK: Implement a single cycle of the above algorithm in the montecarlocycle(T) function. This function should return the energy of your lattice and the magnetisation at the end of the cycle. You may assume that the energy returned by your energy() function is in units of <math>k_B</math>! Complete the statistics() function. This should return the following quantities whenever it is called: <math><E>, <E^2>, <M>, <M^2></math>, and the number of Monte Carlo steps that have elapsed.===
<pre>
E = []
E2 = []
M = []
M2 = []
n_cycles = 0

def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back if rejected else not changed

self.E+=[self.energy()] #records energy
self.E2+=[self.energy()**2] #records energy squared
self.M+=[self.magnetisation()] #records magnetisation
self.M2+=[self.magnetisation()**2] #records magnetisation squared
self.n_cycles=self.n_cycles+1 #adds 1 to run total

return (self.energy(),self.magnetisation())

def statistics(self):
# complete this function so that it calculates the correct values for the averages of E, E*E (E2), M, M*M (M2), and returns them

e=np.mean(self.E)
e2=np.mean(self.E2)
m=np.mean(self.M)
m2=np.mean(self.M2)

return e,e2,m,m2,self.n_cycles
</pre>

===TASK: If <math>T < T_C</math>, do you expect a spontaneous magnetisation (i.e. do you expect <math>\left\langle M\right\rangle \neq 0</math>)? When the state of the simulation appears to stop changing (when you have reached an equilibrium state), use the controls to export the output to PNG and attach this to your report. You should also include the output from your statistics() function.===

If the temperature of the system is less than the Curie Temperature, <math>T_C</math> then spontaneous magnetisation can occur and the system will tend to its lowest energy state where all of the spins are parallel - this is a property of ferromagnetic materials.

[[File:Cg1417ILanim_run.png|400px|thumb|left|Figure 3 - Results from running the ILanim.py file - shows the energy and magnetisation converging over time]]

''Figure 3'' shows that over time the the system spontaneously converges to the minimum energy state with all of the spins parallel to one another and shows, as I expected, that spontaneous magnetisation occurs and also shows that the temperature of this simulation is below the Curie Temperature, <math>T < T_C</math>.

 

==Section 4 - Accelerating the Code==

===TASK: Use the script ILtimetrial.py to record how long your current version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 4'' show the results of running the ILtimetrial.py file on my code three timesː

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1.png
| width1=500
| image2=cg1417ILtimetrial_run2.png
| width2=500
| image3=cg1417ILtimetrial_run3.png
| width3=500
| footer = Figure 4 - Results of running the ILtimetrial.py file on my code three separate times
}}
 

This gave me an avergage time of <math>24.3 s \pm 0.2s</math>

===TASK: Look at the documentation for the NumPy sum function. You should be able to modify your magnetisation() function so that it uses this to evaluate M. The energy is a little trickier. Familiarise yourself with the NumPy roll and multiply functions, and use these to replace your energy double loop (you will need to call roll and multiply twice!).===

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

left=multiply(roll(self.lattice,1,axis=1),self.lattice) #product of spin with spin left of it
top=multiply(roll(self.lattice,-1,axis=0),self.lattice) #product of spin with spin above it

int_en=sum(left+top) #sum of array containing sum of left and top spin products for each spin

energy = -sum(int_en) #calculates the total energy of system
return energy

def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
return sum(sum(self.lattice)) #adds up all spins in lattice
</pre>

===TASK: Use the script ILtimetrial.py to record how long your new version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 5'' shows the result of running the ILtimetrial.py on my new accelerated code.

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1fast.png
| width1=500
| image2=ILtimetrial_run2fast.png
| width2=500
| image3=ILtimetrial_run3fast.png
| width3=500
| footer = Figure 5 - Results of running the ILtimetrial.py file on my new updated and accelerated code.
}}
 

The accelerated code is much faster upon using the roll, multiply and sum modules with a new average time of <math>0.790 s \pm 0.005 </math>

==Section 5 - The effect of temperature==

===TASK: The script ILfinalframe.py runs for a given number of cycles at a given temperature, then plots a depiction of the final lattice state as well as graphs of the energy and magnetisation as a function of cycle number. This is much quicker than animating every frame! Experiment with different temperature and lattice sizes. How many cycles are typically needed for the system to go from its random starting position to the equilibrium state? Modify your statistics() and montecarlostep() functions so that the first N cycles of the simulation are ignored when calculating the averages. You should state in your report what period you chose to ignore, and include graphs from ILfinalframe.py to illustrate your motivation in choosing this figure.===

''Figure 6'' below shows the results from running the ILfinalframe.py for 2x2 lattice at T=1,2,3,5.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2T1.png
| image2 = cg14172x2T2.png
| image3 =cg14172x2T3.png
| image4 =cg14172x2T5.png
| footer_align = left
| footer = Figure 6 - Results of running the ILfinalframe.py file at T=1,2,3,5 for a 2x2 matrix.
}}

 

For a 2x2 matrix, a suitable cut-off point to exclude from the avergage energies and magnetisations is where the energy and magnetisations per spin are constant, which is 30 steps. For T=3 and T=5 the graphs do not converge because it is possible that these temperatures are higher than the Curie Temperature and as such spontaneous magnetisation will not occur and the system will not diverge to the lowest energy state. At the higher temperatures, there are larger thermal fluctations and the Boltzmann factor is more significant allowing the system to move away from the lowest energy state easier. As a result moving forwards, a suitable cut-off point will only be determined from T=1 and T=2 graphs for the larger matrices.

''Figure 7'' shows the results from running a 4x4 lattice at T=1,2 and 3.

{{multiple image
| width =350
| align = left
| image1 = cg14174x4T1.png
| image2 = cg14174x4T2.png
| image3 =cg14174x4T3.png
| footer_align = left
| footer = Figure 7 - Results of running the ILfinalframe.py file at T=1,2,3 for a 4x4 matrix.
}}

From ''Figure 7'', a suitable cut-off point for the energy and magnetisations is 200 as this is after where the energy and magnetisation has converged for T=1, and is after the initial large drop in energy for T=2, even though there are a few small fluctuations after 200 steps. The result from T=3 has been included to show the large fluctuations for the larger temperatures, and supporting my choice to determine the cut-off from T=1 and T=2 only.

''Figure 8'' shows the results for an 8x8 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg14178x8T1.png
| image2 = cg14178x8T2.png
| footer_align = left
| footer = Figure 8 - Results of running the ILfinalframe.py file at T=1,2 for an 8x8 matrix
}}

From ''Figure 8'' above, a suitable cut-off point is 1000 steps as this is where the energy and magnetisation has easily converged by and is also the point after which the initial large drop in energy has been overcome for T=2 too.

''Figure 9'' shows the result of running the ILfinalframe.py for a 16x16 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg141716x16T1.png
| image2 = cg141716x16T2.png
| footer_align = left
| footer = Figure 9 - Results of running the ILfinalframe.py file at T=1,2 for a 16x16 matrix
}}

From ''Figure 9'', a suitable cut-off point is 15000 steps as for T=1 the energy and magnetisations have converged significantly and will not change much, and likewise this is the same for the T=2 frame.

''Figure 10'' below shows the results from a 32x32 matrix at T=1 and T=2.

{{multiple image
| width =350
| align = left
| image1 = cg141732x32T1.png
| image2 = cg141732x32T2.png
| footer_align = left
| footer = Figure 10 - Results of running the ILfinalframe.py file at T=1,2 for a 32x32 matrix
}}

''Figure 10'' above shows the results of running the ILfinalframe.py file for a 32x32 matrix at T=1 and T=2. As a result a suitable cut-off of 50000 steps was chosen as the energy and magnetisation has significantly converged, but not as much as it could at 100000 steps. I chose a slightly lower value to ensure that the run times of my monte-carlo simulations in future tasks were not extremely time consuming.

The montecarlostep() function was changed by adding a condition that values only above the pre-determined cut-off were included when determining the average value of energy; energy squared; magnetisation and magnetisations squared from the statistics function. The statistics() function did not need to be modified.

The following code is from the 32x32 matrixː

<pre>def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back

if self.n_cycles > 50000: #only adds values to array of E,E2,M and M2 is above specific cut-off
self.E+=[self.energy()]
self.E2+=[self.energy()**2]
self.M+=[self.magnetisation()]
self.M2+=[self.magnetisation()**2]
self.n_cycles=self.n_cycles+1

return (self.energy(),self.magnetisation())
</pre>

===TASK: Use ILtemperaturerange.py to plot the average energy and magnetisation for each temperature, with error bars, for an <math>8\times 8</math> lattice. Use your intuition and results from the script ILfinalframe.py to estimate how many cycles each simulation should be. The temperature range 0.25 to 5.0 is sufficient. Use as many temperature points as you feel necessary to illustrate the trend, but do not use a temperature spacing larger than 0.5. The NumPy function savetxt() stores your array of output data on disk — you will need it later. Save the file as 8x8.dat so that you know which lattice size it came from.===

Using the modified code, the file ILtemperaturerange.py was ran on an 8x8 matrix between T=0.5 and T=5 with a step of T=0.02 for 10000 Montecarlo steps and the first 1000 steps of each temperature were excluded when calculating the averages. ''Figure 11'' shows the result of the simulation and also included error bars of standard deviation.

[[File:Cg14178x8error.png|1000px|thumb|left|Figure 11 - Graph showing average energy and average magnetisation for an 8x8 lattice with error bars between T=0.5 and T=5]]

 

==Section 6 - The effect of system size==

===TASK: Repeat the final task of the previous section for the following lattice sizes: 2x2, 4x4, 8x8, 16x16, 32x32. Make sure that you name each datafile that your produce after the corresponding lattice size! Write a Python script to make a plot showing the energy per spin versus temperature for each of your lattice sizes. Hint: the NumPy loadtxt function is the reverse of the savetxt function, and can be used to read your previously saved files into the script. Repeat this for the magnetisation. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. How big a lattice do you think is big enough to capture the long range fluctuations?===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb.

Each matrix was simulated using the ILtemperaturerange.py file between T=0.5 and T=5 with a step of T=0.02.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2error.png
| caption1 = 2x2 matrix - 5000 steps, cut-off = 30 steps
| image2 = 4x4error.png
| caption2 = 4x4 matrix - 1000 steps, cut-off = 200 steps
| image3 =cg141716x16error.png
| caption3 = 16x16 matrix - 50000 steps, cut-off = 15000 steps
| image4 =cg141732x32error.png
| caption4 = 32x32 matrix - 200000 steps, cut-off = 50000 steps
| footer_align = left
| footer = Figure 12 - Results of running the ILtemperaturerange.py file for 2x2, 4x4, 16x16 and 32x32 matrices.
}}

 

==Section 7 - Determining the Heat Capacity==

===TASK: By definition, <math>C = \frac{\partial \left\langle E\right\rangle}{\partial T}</math>. From this, show that <math>C = \frac{\mathrm{Var}[E]}{k_B T^2}</math> (Where <math>\mathrm{Var}[E]</math> is the variance in <math>E</math>.)===

Recall from statistical thermodynamics that the average energy of a system is the sum across all microstates of the probability of that microstate multiplied by the energy of that microstate, which is defined mathematically asː <math>\langle E \rangle = \sum_i p_{i}\epsilon_{i}</math>.

The partition function <math>q</math> is defined as <math>q = \sum_{i} exp(-\beta \epsilon_{i})</math> where <math>\beta =\frac{1}{k_BT}</math>and the probability, <math>p_{i}</math> can be defined in terms of the partition function as <math>p_{i} = \frac{exp(-\beta \epsilon_{i})}{\sum_{i} exp(-\beta \epsilon_{i})} = \frac{exp(-\beta \epsilon_{i})}{q}</math>.

As a result, <math>\langle E \rangle</math> can be re-written as <math>\langle E \rangle = \sum_{i} \frac{\epsilon_{i} exp(-\beta \epsilon_{i})}{q} = -\frac{1}{q} \frac{\partial}{\partial \beta}\sum_{i}exp(-\beta \epsilon_{i}) = -\frac{1}{q} \frac{\partial q}{\partial \beta}</math>

Likewise, <math>\langle E^2 \rangle = \sum_i p_{i}\epsilon_{i}^{2} = \sum_{i} \frac{\epsilon_{i}^{2}exp(-\beta \epsilon_{i})}{q} = \frac{1}{q} \frac{\partial^{2}}{\partial \beta^{2}}\sum_{i}exp(-\beta \epsilon_{i}) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}}</math>

From definitionː <math>Var[E] = \Delta E^2 = \langle E^2 \rangle - \langle E \rangle^2 </math>

When the definition of <math>\langle E \rangle</math> and <math>\langle E^2 \rangle</math> is written in terms of partition function <math>q</math>ː <math>Var[E] = \langle E^2 \rangle - \langle E \rangle^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \left(\frac{1}{q}\frac{\partial q}{\partial \beta}\right)^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2</math>.

According to the chain ruleː <math>\frac{\partial}{\partial \beta}\left(\frac{1}{q} \frac{\partial q}{\partial \beta}\right) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2 = -\frac{\partial}{\partial \beta}\langle E \rangle = Var[E]</math>

And using the chain rule againː <math>C = \frac{\partial \langle E \rangle}{\partial T}= \left(-\frac{\partial \langle E \rangle}{\partial \beta}\right) \left(-\frac{\partial \beta}{\partial T}\right) = \frac{Var[E]}{k_B T^2}</math>

===TASK: Write a Python script to make a plot showing the heat capacity versus temperature for each of your lattice sizes from the previous section. You may need to do some research to recall the connection between the variance of a variable, <math>\mathrm{Var}[X]</math>, the mean of its square <math>\left\langle X^2\right\rangle</math>, and its squared mean <math>\left\langle X\right\rangle^2</math>. You may find that the data around the peak is very noisy — this is normal, and is a result of being in the critical region. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. ===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb

{{multiple image
| width =300
| align = left
| image1 = cg14172x2heatcap.png
| caption1 = 2x2 Matrix
| image2 = cg14174x4heatcap.png
| caption2 = 4x4 Matrix
| image3 =cg14178x8heatcap.png
| caption3 = 8x8 Matrix
| image4 =cg141716x16heatcap.png
| caption4 = 16x16 Matrix
| image5=cg141732x32heatcap.png
| caption5= 32x32 Matrix
| footer = Figure 13 - Graphs showing Heat Capacity against Temperature for each matrix size
}}

A general trend from the above graphs is that the peak of the graph shifts towards lower temperatures as the size of the matrix used increases.

==Section 8 - Locating the Curie Temperature==
===TASK: A C++ program has been used to run some much longer simulations than would be possible on the college computers in Python. You can view its source code here if you are interested. Each file contains six columns: <math>T, E, E^2, M, M^2, C</math> (the final five quantities are per spin), and you can read them with the NumPy loadtxt function as before. For each lattice size, plot the C++ data against your data. For one lattice size, save a PNG of this comparison and add it to your report — add a legend to the graph to label which is which. To do this, you will need to pass the label="..." keyword to the plot function, then call the legend() function of the axis object (documentation here).===

The python code used to read and plot the C++ data is found in the Jupyter notebook CG1417IsingModelGraphs.ipynb.

''Figure 14'' below shows the C++ plotted against my own data for a 16x16 Matrix.

[[File:Cg141716x16C++.png|400px|thumb|left|Figure 14 - Graph showing my own data against the C++ data for a 16x16 matrix.]]

 

===TASK: write a script to read the data from a particular file, and plot C vs T, as well as a fitted polynomial. Try changing the degree of the polynomial to improve the fit — in general, it might be difficult to get a good fit! Attach a PNG of an example fit to your report.===

The python script to read and plot the fitted polynomial is found in CG1417PolyfitScript.ipynb

Below in ''Figure 15'' is a plot of my Heat Capacity against Temperature data for a 16x16 matrix and features a polynomial of degree 35 plotted against it. Even with a polynomial of such a high degree, it poorly fits the curve and does not fit to the peak of the curve either.

[[File:cg1417FIT_TEST16x16_35.png|thumb|left|400px|Figure 15 - Plot of Heat Capacity against Temperature along with a poorly fitted polynomial of degree 35. ]]

 

===TASK: Modify your script from the previous section. You should still plot the whole temperature range, but fit the polynomial only to the peak of the heat capacity! You should find it easier to get a good fit when restricted to this region===

The script was modified as such that the polynomial was fitted in a set range around the peak of the graph, this is demonstrated in ''Figure 17'' which shows a newly fitted polynomial between a much smaller range of temperatures (T = 2.15-2.55) and a much smaller degree polynomial (3).

[[File:CG1417FIT_16x16C_3.png|thumb|left|400px|Figure 16 - Graph showing Heat Capacity against Temperature for a 16x16 matrix along with a fitted polynomial between a much more restricted range of temperatures and a significantly lower degree of polynomial]]

Upon comparison with ''Figure 15'', the new fitted polynomial is a significantly better fit even for a 3rd degree polynomial and is a much more accurate representation of my data around the peak of the graph and will make it easier to determine the maximum value of Heat Capacity.

 

===TASK: find the temperature at which the maximum in C occurs for each datafile that you were given. Make a text file containing two colums: the lattice side length (2,4,8, etc.), and the temperature at which C is a maximum. This is your estimate of <math>T_C</math> for that side length. Make a plot that uses the scaling relation given above to determine <math>T_{C,\infty}</math>. By doing a little research online, you should be able to find the theoretical exact Curie temperature for the infinite 2D Ising lattice. How does your value compare to this? Are you surprised by how good/bad the agreement is? Attach a PNG of this final graph to your report, and discuss briefly what you think the major sources of error are in your estimate.===

''Figure 17'' below shows a graph of <math>T_{C,L}</math> against <math>\frac{1}{Lattice Size}</math> to determine the Curie Temperature of an infinite 2D Ising Model Lattice <math>T_{C,\infty}</math>. The black dots represent the raw data obtained from obtaining the temperature at which the Heat Capacity was a maximum for the lattices and the red line in a linear curve fit plotted against the data to allow the y-intercept which is the Curie Temperature for the infinite 2D lattice to be determined.

[[File:cg1417CurieTemp.png|400px|thumb|left|Figure 17 - Plot of 1/Lattice Size against Curie Temperature for that lattice size.]]

The value for <math>T_{C,\inf}</math> obtained from the data is <math>T_{C,\infty} = 2.277 \frac{J}{k_B}</math> with a literature value being <math>T_{C,\infty} = 2.269 \frac{J}{k_B}</math> <ref>L. Onsager, Phys. Rev., 1944, 65, 117--149.</ref>for an infinite square 2D lattice. This means that my result slightly over-estimates the Curie Temperature for the infinite lattice and as a result for an infinite lattice the temperature at which spontaneous magnetisation stops would actually occur at a slightly lower temperature than expected. However, the difference between my value and the literature value is only 0.008 which is incredibly small and the amount of agreement between the two values is somewhat surprising, which means that the error in my estimates of the Curie Temperature for each lattice size is relatively small. The points which have the largest residuals and deviation from the line of best fit in ''Figure 17'' corresponds to the smaller lattice sizes of 2x2 and 4x4 where longer range interactions are more significant. The longer range interactions posed by the boundary conditions are nowhere near as significant for the larger sizes and causes the energy of the smaller matrices to be less accurate and have a larger associated error with the energy and thus the Curie Temperature for that lattice size. This affects the accuracy of the line of best fit and to increase the accuracy of this line, larger lattice sizes of 128x128, 256x256 etc should be included in the calculation for the line of best fit and the smaller matrices ignored.

 

== References ==

Rep:Y3CMPCG1417

2019-11-20T08:50:13Z

==Section 1 - Introduction to the Ising Model==

===TASK: Show that the lowest possible energy for the Ising model is <math>E = -DNJ</math>, where D is the number of dimensions and N is the total number of spins. What is the multiplicity of this state? Calculate its entropy.===

Consider a 1D row of lattice sites of N=3 with spin configuration [+1][+1][+1].

Mathematically the interaction energy is defined asː
<math> -\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} </math> where J is a constant and <math>s_{i}s_{j}</math> is the product between two spins in adjacent lattice sites.

The sum of the interaction energies <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j}</math> can be considered as the sum of the individual interaction energies between spinsː
<math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = \epsilon_{12} + \epsilon_{23} + \epsilon_{13} + \epsilon_{21} + \epsilon_{32} + \epsilon_{31} </math>.

Although lattice sites 1 and 3 are not adjacent they are said to still interact according to the periodic boundary conditions applied.

However, <math>\epsilon_{12} = \epsilon_{21} </math> and <math>\epsilon_{23} = \epsilon_{32}</math> and <math>\epsilon_{13} = \epsilon_{31}</math> which means that all of the interactions within the system are counted twice, hence the total energy needs to be halved, resulting in the following formula being obtainedː <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = 2\epsilon_{12} + 2\epsilon_{13} + 2\epsilon_{23} </math>.

It can be determined that <math>\epsilon_{12} = (+1)(+1) = 1</math> , <math>\epsilon_{13} = (+1)(+1) = 1</math> and <math>\epsilon_{23} = (+1)(+1) = 1</math>.

Thereforeː <math>-\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = -\frac{1}{2} \ J \ (2 + 2 + 2) = -\frac{1}{2} \ J \ 6 = - 3 J = -DNJ</math> for a 1D lattice with <math>D=1</math> and 3 lattice sites <math>N=3</math>

The multiplicity of the system,<math>\Omega = \frac{n. spin up!}{n. spin down!}</math>

Entropy, <math>S</math> is defined as <math>S = k_B ln(\Omega)</math> and so in this case <math>S = k_B ln(\frac{100!}{100!}) = 0</math>

===TASK: Imagine that the system is in the lowest energy configuration. To move to a different state, one of the spins must spontaneously change direction ("flip"). What is the change in energy if this happens <math>(D=3, N=1000)</math>? How much entropy does the system gain by doing soʔ===

In a 3D lattice system, each lattice site has three unique interactions with its neighbours to its left, top and front. In the lowest energy configuration, all spins are parallel and for a system the minimum energy is <math>E = -DNJ</math>, so for the system with <math>N=1000</math> and <math>D=3</math>, the minimum energy is <math>-3000J</math>.

If a single spin is flipped, the product of its spin with its neighbours spin reverses and becomes negative and this increases the total energy of the system. Since 3 unique spin-spin interactions are reversed in sign, the total energy increases by <math>+3J</math>, meaning the new total energy is <math>-2997J</math>

Initially the multiplicity of the system will be <math>\Omega = \frac{1000!}{1000!}</math> , and after the flip, the multiplicity becomes <math> \Omega = \frac{1000!}{999!1!}=1000</math>.

The associated change in entropy, <math>\Delta S = k_B ln(1000) - 0 = 6.91 k_B</math>, which is an expected increase in entropy as the number of possible configurations of the system increases.

===TASK: Calculate the magnetisation of the 1D and 2D lattices in Figure 1. What magnetisation would you expect to observe for an Ising lattice with <math>D = 3,\ N=1000</math> at absolute zero?===

[[File:ThirdYearCMPExpt-IsingSketch.png|thumb|left|Figure 1 - Shows 1D (N = 5), 2D (N = 5x5) and 3D (N = 5x5x5) lattices.]]

Magnetisation is defined as <math>M=\sum_{i} s_i</math>. So for the 1D lattice with <math>N = 5</math> in ''Figure 2'', <math>M = +1</math> and for the 2D lattice with <math>N = 25 , M = +1</math> too.

According to the 3rd Law of thermodynamics, entropy is 0 at absolute zero for a perfect crystalline solid, and consequently it is expected that the lattices will have follow suit and have zero entropy at 0K. To have zero entropy all spins must be parallel as such that magnetisation, <math>M = N</math>. For all the spins to be parallel, there is only one possible configuration. So, for a lattice with <math>N = 1000</math> and <math>D =3</math>, if <math>M = N</math>, then multiplicity, <math>\Omega = 1</math> and entropy, <math>S =k_B ln(1) = 0</math>.

 

==Section 2 - Calculating the Energy and Magnetisation==

===TASK: complete the functions energy() and magnetisation(), which should return the energy of the lattice and the total magnetisation, respectively. In the energy() function you may assume that <math>J=1.0</math> at all times (in fact, we are working in reduced units in which <math>J=k_B</math>, but there will be more information about this in later sections). Do not worry about the efficiency of the code at the moment — we will address the speed in a later part of the experiment.===

<pre>def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
lat=self.lattice #creates lattice and stores it
mag=[]
for i in range(0,len(lat)): #loops through all rows of lattice
for j in range(0,len(lat[i])): #loops through elements of each row
mag+=[lat[i][j]] #adds spin value to mag array
return sum(mag) #sums all spins from mag array
</pre>

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

lat=self.lattice #creates lattice and stores it
left=[]
top=[]

for i in range(0,len(lat)):
for j in range(0,len(lat[i])):
left+=[lat[i][j]*lat[i][j-1]] #multiplies spin by spin to left
top+=[lat[i][j]*lat[i-1][j]] #multiplies spin by spin above it
int_en=left+top #sums spin products from left and top
energy=-sum(int_en) #sums all spin products for each spin to give total

return energy
</pre>

===TASK: Run the ILcheck.py script from the IPython Qt console using the command===

''Figure 2'' shows the results when ILcheck.py was ran on my IsingLattice.py file. The ILcheck.py file was ran several times to ensure the code worked for various random lattices.

[[File:Cg1417ILcheck run.png|thumb|left|500px| Figure 2 - Result from running the ILcheck.py file]]

 

==Section 3 - Introduction to Monte Carlo Simulation==

===TASK: How many configurations are available to a system with 100 spins? To evaluate these expressions, we have to calculate the energy and magnetisation for each of these configurations, then perform the sum. Let's be very, very, generous, and say that we can analyse <math>1\times 10^9</math> configurations per second with our computer. How long will it take to evaluate a single value of <math>\left\langle M\right\rangle_T</math>?===

For a system with 100 lattice sites and two possible spins for each site, there are <math>2^{100}</math>possible configurations for the system. <math>2^{100}= 1.27\times 10^{30} </math>, so if the computer can analyse <math>1\times 10^9</math> configurations per second, then it will take <math>\frac{1.27\times 10^{30}}{10^9} = 1.27\times 10^{21} s</math> to analyse the whole system, which is longer than the age of the universe and therefore is not a practical approach.

===TASK: Implement a single cycle of the above algorithm in the montecarlocycle(T) function. This function should return the energy of your lattice and the magnetisation at the end of the cycle. You may assume that the energy returned by your energy() function is in units of <math>k_B</math>! Complete the statistics() function. This should return the following quantities whenever it is called: <math><E>, <E^2>, <M>, <M^2></math>, and the number of Monte Carlo steps that have elapsed.===
<pre>
E = []
E2 = []
M = []
M2 = []
n_cycles = 0

def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back if rejected else not changed

self.E+=[self.energy()] #records energy
self.E2+=[self.energy()**2] #records energy squared
self.M+=[self.magnetisation()] #records magnetisation
self.M2+=[self.magnetisation()**2] #records magnetisation squared
self.n_cycles=self.n_cycles+1 #adds 1 to run total

return (self.energy(),self.magnetisation())

def statistics(self):
# complete this function so that it calculates the correct values for the averages of E, E*E (E2), M, M*M (M2), and returns them

e=np.mean(self.E)
e2=np.mean(self.E2)
m=np.mean(self.M)
m2=np.mean(self.M2)

return e,e2,m,m2,self.n_cycles
</pre>

===TASK: If <math>T < T_C</math>, do you expect a spontaneous magnetisation (i.e. do you expect <math>\left\langle M\right\rangle \neq 0</math>)? When the state of the simulation appears to stop changing (when you have reached an equilibrium state), use the controls to export the output to PNG and attach this to your report. You should also include the output from your statistics() function.===

If the temperature of the system is less than the Curie Temperature, <math>T_C</math> then spontaneous magnetisation can occur and the system will tend to its lowest energy state where all of the spins are parallel - this is a property of ferromagnetic materials.

[[File:Cg1417ILanim_run.png|400px|thumb|left|Figure 3 - Results from running the ILanim.py file - shows the energy and magnetisation converging over time]]

''Figure 3'' shows that over time the the system spontaneously converges to the minimum energy state with all of the spins parallel to one another and shows, as I expected, that spontaneous magnetisation occurs and also shows that the temperature of this simulation is below the Curie Temperature, <math>T < T_C</math>.

 

==Section 4 - Accelerating the Code==

===TASK: Use the script ILtimetrial.py to record how long your current version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 4'' show the results of running the ILtimetrial.py file on my code three timesː

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1.png
| width1=500
| image2=cg1417ILtimetrial_run2.png
| width2=500
| image3=cg1417ILtimetrial_run3.png
| width3=500
| footer = Figure 4 - Results of running the ILtimetrial.py file on my code three separate times
}}
 

This gave me an avergage time of <math>24.3 s \pm 0.2s</math>

===TASK: Look at the documentation for the NumPy sum function. You should be able to modify your magnetisation() function so that it uses this to evaluate M. The energy is a little trickier. Familiarise yourself with the NumPy roll and multiply functions, and use these to replace your energy double loop (you will need to call roll and multiply twice!).===

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

left=multiply(roll(self.lattice,1,axis=1),self.lattice) #product of spin with spin left of it
top=multiply(roll(self.lattice,-1,axis=0),self.lattice) #product of spin with spin above it

int_en=sum(left+top) #sum of array containing sum of left and top spin products for each spin

energy = -sum(int_en) #calculates the total energy of system
return energy

def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
return sum(sum(self.lattice)) #adds up all spins in lattice
</pre>

===TASK: Use the script ILtimetrial.py to record how long your new version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 5'' shows the result of running the ILtimetrial.py on my new accelerated code.

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1fast.png
| width1=500
| image2=ILtimetrial_run2fast.png
| width2=500
| image3=ILtimetrial_run3fast.png
| width3=500
| footer = Figure 5 - Results of running the ILtimetrial.py file on my new updated and accelerated code.
}}
 

The accelerated code is much faster upon using the roll, multiply and sum modules with a new average time of <math>0.790 s \pm 0.005 </math>

==Section 5 - The effect of temperature==

===TASK: The script ILfinalframe.py runs for a given number of cycles at a given temperature, then plots a depiction of the final lattice state as well as graphs of the energy and magnetisation as a function of cycle number. This is much quicker than animating every frame! Experiment with different temperature and lattice sizes. How many cycles are typically needed for the system to go from its random starting position to the equilibrium state? Modify your statistics() and montecarlostep() functions so that the first N cycles of the simulation are ignored when calculating the averages. You should state in your report what period you chose to ignore, and include graphs from ILfinalframe.py to illustrate your motivation in choosing this figure.===

''Figure 6'' below shows the results from running the ILfinalframe.py for 2x2 lattice at T=1,2,3,5.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2T1.png
| image2 = cg14172x2T2.png
| image3 =cg14172x2T3.png
| image4 =cg14172x2T5.png
| footer_align = left
| footer = Figure 6 - Results of running the ILfinalframe.py file at T=1,2,3,5 for a 2x2 matrix.
}}

 

For a 2x2 matrix, a suitable cut-off point to exclude from the avergage energies and magnetisations is where the energy and magnetisations per spin are constant, which is 30 steps. For T=3 and T=5 the graphs do not converge because it is possible that these temperatures are higher than the Curie Temperature and as such spontaneous magnetisation will not occur and the system will not diverge to the lowest energy state. At the higher temperatures, there are larger thermal fluctations and the Boltzmann factor is more significant allowing the system to move away from the lowest energy state easier. As a result moving forwards, a suitable cut-off point will only be determined from T=1 and T=2 graphs for the larger matrices.

''Figure 7'' shows the results from running a 4x4 lattice at T=1,2 and 3.

{{multiple image
| width =350
| align = left
| image1 = cg14174x4T1.png
| image2 = cg14174x4T2.png
| image3 =cg14174x4T3.png
| footer_align = left
| footer = Figure 7 - Results of running the ILfinalframe.py file at T=1,2,3 for a 4x4 matrix.
}}

From ''Figure 7'', a suitable cut-off point for the energy and magnetisations is 200 as this is after where the energy and magnetisation has converged for T=1, and is after the initial large drop in energy for T=2, even though there are a few small fluctuations after 200 steps. The result from T=3 has been included to show the large fluctuations for the larger temperatures, and supporting my choice to determine the cut-off from T=1 and T=2 only.

''Figure 8'' shows the results for an 8x8 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg14178x8T1.png
| image2 = cg14178x8T2.png
| footer_align = left
| footer = Figure 8 - Results of running the ILfinalframe.py file at T=1,2 for an 8x8 matrix
}}

From ''Figure 8'' above, a suitable cut-off point is 1000 steps as this is where the energy and magnetisation has easily converged by and is also the point after which the initial large drop in energy has been overcome for T=2 too.

''Figure 9'' shows the result of running the ILfinalframe.py for a 16x16 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg141716x16T1.png
| image2 = cg141716x16T2.png
| footer_align = left
| footer = Figure 9 - Results of running the ILfinalframe.py file at T=1,2 for a 16x16 matrix
}}

From ''Figure 9'', a suitable cut-off point is 15000 steps as for T=1 the energy and magnetisations have converged significantly and will not change much, and likewise this is the same for the T=2 frame.

''Figure 10'' below shows the results from a 32x32 matrix at T=1 and T=2.

{{multiple image
| width =350
| align = left
| image1 = cg141732x32T1.png
| image2 = cg141732x32T2.png
| footer_align = left
| footer = Figure 10 - Results of running the ILfinalframe.py file at T=1,2 for a 32x32 matrix
}}

''Figure 10'' above shows the results of running the ILfinalframe.py file for a 32x32 matrix at T=1 and T=2. As a result a suitable cut-off of 50000 steps was chosen as the energy and magnetisation has significantly converged, but not as much as it could at 100000 steps. I chose a slightly lower value to ensure that the run times of my monte-carlo simulations in future tasks were not extremely time consuming.

The montecarlostep() function was changed by adding a condition that values only above the pre-determined cut-off were included when determining the average value of energy; energy squared; magnetisation and magnetisations squared from the statistics function. The statistics() function did not need to be modified.

The following code is from the 32x32 matrixː

<pre>def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back

if self.n_cycles > 50000: #only adds values to array of E,E2,M and M2 is above specific cut-off
self.E+=[self.energy()]
self.E2+=[self.energy()**2]
self.M+=[self.magnetisation()]
self.M2+=[self.magnetisation()**2]
self.n_cycles=self.n_cycles+1

return (self.energy(),self.magnetisation())
</pre>

===TASK: Use ILtemperaturerange.py to plot the average energy and magnetisation for each temperature, with error bars, for an <math>8\times 8</math> lattice. Use your intuition and results from the script ILfinalframe.py to estimate how many cycles each simulation should be. The temperature range 0.25 to 5.0 is sufficient. Use as many temperature points as you feel necessary to illustrate the trend, but do not use a temperature spacing larger than 0.5. The NumPy function savetxt() stores your array of output data on disk — you will need it later. Save the file as 8x8.dat so that you know which lattice size it came from.===

Using the modified code, the file ILtemperaturerange.py was ran on an 8x8 matrix between T=0.5 and T=5 with a step of T=0.02 for 10000 Montecarlo steps and the first 1000 steps of each temperature were excluded when calculating the averages. ''Figure 11'' shows the result of the simulation and also included error bars of standard deviation.

[[File:Cg14178x8error.png|1000px|thumb|left|Figure 11 - Graph showing average energy and average magnetisation for an 8x8 lattice with error bars between T=0.5 and T=5]]

 

==Section 6 - The effect of system size==

===TASK: Repeat the final task of the previous section for the following lattice sizes: 2x2, 4x4, 8x8, 16x16, 32x32. Make sure that you name each datafile that your produce after the corresponding lattice size! Write a Python script to make a plot showing the energy per spin versus temperature for each of your lattice sizes. Hint: the NumPy loadtxt function is the reverse of the savetxt function, and can be used to read your previously saved files into the script. Repeat this for the magnetisation. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. How big a lattice do you think is big enough to capture the long range fluctuations?===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb.

Each matrix was simulated using the ILtemperaturerange.py file between T=0.5 and T=5 with a step of T=0.02.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2error.png
| caption1 = 2x2 matrix - 5000 steps, cut-off = 30 steps
| image2 = 4x4error.png
| caption2 = 4x4 matrix - 1000 steps, cut-off = 200 steps
| image3 =cg141716x16error.png
| caption3 = 16x16 matrix - 50000 steps, cut-off = 15000 steps
| image4 =cg141732x32error.png
| caption4 = 32x32 matrix - 200000 steps, cut-off = 50000 steps
| footer_align = left
| footer = Figure 12 - Results of running the ILtemperaturerange.py file for 2x2, 4x4, 16x16 and 32x32 matrices.
}}

 

==Section 7 - Determining the Heat Capacity==

===TASK: By definition, <math>C = \frac{\partial \left\langle E\right\rangle}{\partial T}</math>. From this, show that <math>C = \frac{\mathrm{Var}[E]}{k_B T^2}</math> (Where <math>\mathrm{Var}[E]</math> is the variance in <math>E</math>.)===

Recall from statistical thermodynamics that the average energy of a system is the sum across all microstates of the probability of that microstate multiplied by the energy of that microstate, which is defined mathematically asː <math>\langle E \rangle = \sum_i p_{i}\epsilon_{i}</math>.

The partition function <math>q</math> is defined as <math>q = \sum_{i} exp(-\beta \epsilon_{i})</math> where <math>\beta =\frac{1}{k_BT}</math>and the probability, <math>p_{i}</math> can be defined in terms of the partition function as <math>p_{i} = \frac{exp(-\beta \epsilon_{i})}{\sum_{i} exp(-\beta \epsilon_{i})} = \frac{exp(-\beta \epsilon_{i})}{q}</math>.

As a result, <math>\langle E \rangle</math> can be re-written as <math>\langle E \rangle = \sum_{i} \frac{\epsilon_{i} exp(-\beta \epsilon_{i})}{q} = -\frac{1}{q} \frac{\partial}{\partial \beta}\sum_{i}exp(-\beta \epsilon_{i}) = -\frac{1}{q} \frac{\partial q}{\partial \beta}</math>

Likewise, <math>\langle E^2 \rangle = \sum_i p_{i}\epsilon_{i}^{2} = \sum_{i} \frac{\epsilon_{i}^{2}exp(-\beta \epsilon_{i})}{q} = \frac{1}{q} \frac{\partial^{2}}{\partial \beta^{2}}\sum_{i}exp(-\beta \epsilon_{i}) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}}</math>

From definitionː <math>Var[E] = \Delta E^2 = \langle E^2 \rangle - \langle E \rangle^2 </math>

When the definition of <math>\langle E \rangle</math> and <math>\langle E^2 \rangle</math> is written in terms of partition function <math>q</math>ː <math>Var[E] = \langle E^2 \rangle - \langle E \rangle^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \left(\frac{1}{q}\frac{\partial q}{\partial \beta}\right)^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2</math>.

According to the chain ruleː <math>\frac{\partial}{\partial \beta}\left(\frac{1}{q} \frac{\partial q}{\partial \beta}\right) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2 = -\frac{\partial}{\partial \beta}\langle E \rangle = Var[E]</math>

And using the chain rule againː <math>C = \frac{\partial \langle E \rangle}{\partial T}= \left(-\frac{\partial \langle E \rangle}{\partial \beta}\right) \left(-\frac{\partial \beta}{\partial T}\right) = \frac{Var[E]}{k_B T^2}</math>

===TASK: Write a Python script to make a plot showing the heat capacity versus temperature for each of your lattice sizes from the previous section. You may need to do some research to recall the connection between the variance of a variable, <math>\mathrm{Var}[X]</math>, the mean of its square <math>\left\langle X^2\right\rangle</math>, and its squared mean <math>\left\langle X\right\rangle^2</math>. You may find that the data around the peak is very noisy — this is normal, and is a result of being in the critical region. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. ===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb

{{multiple image
| width =300
| align = left
| image1 = cg14172x2heatcap.png
| caption1 = 2x2 Matrix
| image2 = cg14174x4heatcap.png
| caption2 = 4x4 Matrix
| image3 =cg14178x8heatcap.png
| caption3 = 8x8 Matrix
| image4 =cg141716x16heatcap.png
| caption4 = 16x16 Matrix
| image5=cg141732x32heatcap.png
| caption5= 32x32 Matrix
| footer = Figure 13 - Graphs showing Heat Capacity against Temperature for each matrix size
}}

A general trend from the above graphs is that the peak of the graph shifts towards lower temperatures as the size of the matrix used increases.

==Section 8 - Locating the Curie Temperature==
===TASK: A C++ program has been used to run some much longer simulations than would be possible on the college computers in Python. You can view its source code here if you are interested. Each file contains six columns: <math>T, E, E^2, M, M^2, C</math> (the final five quantities are per spin), and you can read them with the NumPy loadtxt function as before. For each lattice size, plot the C++ data against your data. For one lattice size, save a PNG of this comparison and add it to your report — add a legend to the graph to label which is which. To do this, you will need to pass the label="..." keyword to the plot function, then call the legend() function of the axis object (documentation here).===

The python code used to read and plot the C++ data is found in the Jupyter notebook CG1417IsingModelGraphs.ipynb.

''Figure 14'' below shows the C++ plotted against my own data for a 16x16 Matrix.

[[File:Cg141716x16C++.png|400px|thumb|left|Figure 14 - Graph showing my own data against the C++ data for a 16x16 matrix.]]

 

===TASK: write a script to read the data from a particular file, and plot C vs T, as well as a fitted polynomial. Try changing the degree of the polynomial to improve the fit — in general, it might be difficult to get a good fit! Attach a PNG of an example fit to your report.===

The python script to read and plot the fitted polynomial is found in CG1417PolyfitScript.ipynb

Below in ''Figure 15'' is a plot of my Heat Capacity against Temperature data for a 16x16 matrix and features a polynomial of degree 35 plotted against it. Even with a polynomial of such a high degree, it poorly fits the curve and does not fit to the peak of the curve either.

[[File:cg1417FIT_TEST16x16_35.png|thumb|left|400px|Figure 15 - Plot of Heat Capacity against Temperature along with a poorly fitted polynomial of degree 35. ]]

 

===TASK: Modify your script from the previous section. You should still plot the whole temperature range, but fit the polynomial only to the peak of the heat capacity! You should find it easier to get a good fit when restricted to this region===

The script was modified as such that the polynomial was fitted in a set range around the peak of the graph, this is demonstrated in ''Figure 17'' which shows a newly fitted polynomial between a much smaller range of temperatures (T = 2.15-2.55) and a much smaller degree polynomial (3).

[[File:CG1417FIT_16x16C_3.png|thumb|left|400px|Figure 16 - Graph showing Heat Capacity against Temperature for a 16x16 matrix along with a fitted polynomial between a much more restricted range of temperatures and a significantly lower degree of polynomial]]

Upon comparison with ''Figure 15'', the new fitted polynomial is a significantly better fit even for a 3rd degree polynomial and is a much more accurate representation of my data around the peak of the graph and will make it easier to determine the maximum value of Heat Capacity.

 

===TASK: find the temperature at which the maximum in C occurs for each datafile that you were given. Make a text file containing two colums: the lattice side length (2,4,8, etc.), and the temperature at which C is a maximum. This is your estimate of <math>T_C</math> for that side length. Make a plot that uses the scaling relation given above to determine <math>T_{C,\infty}</math>. By doing a little research online, you should be able to find the theoretical exact Curie temperature for the infinite 2D Ising lattice. How does your value compare to this? Are you surprised by how good/bad the agreement is? Attach a PNG of this final graph to your report, and discuss briefly what you think the major sources of error are in your estimate.===

''Figure 17'' below shows a graph of <math>T_{C,L}</math> against <math>\frac{1}{Lattice Size}</math> to determine the Curie Temperature of an infinite 2D Ising Model Lattice <math>T_{C,\infty}</math>. The black dots represent the raw data obtained from obtaining the temperature at which the Heat Capacity was a maximum for the lattices and the red line in a linear curve fit plotted against the data to allow the y-intercept which is the Curie Temperature for the infinite 2D lattice to be determined.

[[File:cg1417CurieTemp.png|400px|thumb|left|Figure 17 - Plot of 1/Lattice Size against Curie Temperature for that lattice size.]]

The value for <math>T_{C,\inf}</math> obtained from the data is <math>T_{C,\infty} = 2.277 \frac{J}{k_B}</math> with a literature value being <math>T_{C,\infty} = 2.269 \frac{J}{k_B}</math> <ref>L. Onsager, Phys. Rev., 1944, 65, 117--149.</ref>for an infinite square 2D lattice. This means that my result slightly over-estimates the Curie Temperature for the infinite lattice and as a result for an infinite lattice the temperature at which spontaneous magnetisation stops would actually occur at a slightly lower temperature than expected. However, the difference between my value and the literature value is only 0.008 which is incredibly small and the amount of agreement between the two values is somewhat surprising, which means that the error in my estimates of the Curie Temperature for each lattice size is relatively small. The points which have the largest residuals and deviation from the line of best fit in ''Figure 17'' corresponds to the smaller lattice sizes of 2x2 and 4x4 where longer range interactions are more significant. The longer range interactions posed by the boundary conditions are nowhere near as significant for the larger sizes and causes the energy of the smaller matrices to be less accurate and have a larger associated error with the energy and thus the Curie Temperature for that lattice size. This affects the accuracy of the line of best fit and to increase the accuracy of this line, larger lattice sizes of 128x128, 256x256 etc should be included in the calculation for the line of best fit and the smaller matrices ignored.

 

== References ==
*L. Onsager, Phys. Rev., 1944, 65, 117--149.

Rep:Y3CMPCG1417

2019-11-20T08:39:52Z

==Section 1 - Introduction to the Ising Model==

===TASK: Show that the lowest possible energy for the Ising model is <math>E = -DNJ</math>, where D is the number of dimensions and N is the total number of spins. What is the multiplicity of this state? Calculate its entropy.===

Consider a 1D row of lattice sites of N=3 with spin configuration [+1][+1][+1].

Mathematically the interaction energy is defined asː
<math> -\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} </math> where J is a constant and <math>s_{i}s_{j}</math> is the product between two spins in adjacent lattice sites.

The sum of the interaction energies <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j}</math> can be considered as the sum of the individual interaction energies between spinsː
<math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = \epsilon_{12} + \epsilon_{23} + \epsilon_{13} + \epsilon_{21} + \epsilon_{32} + \epsilon_{31} </math>.

Although lattice sites 1 and 3 are not adjacent they are said to still interact according to the periodic boundary conditions applied.

However, <math>\epsilon_{12} = \epsilon_{21} </math> and <math>\epsilon_{23} = \epsilon_{32}</math> and <math>\epsilon_{13} = \epsilon_{31}</math> which means that all of the interactions within the system are counted twice, hence the total energy needs to be halved, resulting in the following formula being obtainedː <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = 2\epsilon_{12} + 2\epsilon_{13} + 2\epsilon_{23} </math>.

It can be determined that <math>\epsilon_{12} = (+1)(+1) = 1</math> , <math>\epsilon_{13} = (+1)(+1) = 1</math> and <math>\epsilon_{23} = (+1)(+1) = 1</math>.

Thereforeː <math>-\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = -\frac{1}{2} \ J \ (2 + 2 + 2) = -\frac{1}{2} \ J \ 6 = - 3 J = -DNJ</math> for a 1D lattice with <math>D=1</math> and 3 lattice sites <math>N=3</math>

The multiplicity of the system,<math>\Omega = \frac{n. spin up!}{n. spin down!}</math>

Entropy, <math>S</math> is defined as <math>S = k_B ln(\Omega)</math> and so in this case <math>S = k_B ln(\frac{100!}{100!}) = 0</math>

===TASK: Imagine that the system is in the lowest energy configuration. To move to a different state, one of the spins must spontaneously change direction ("flip"). What is the change in energy if this happens <math>(D=3, N=1000)</math>? How much entropy does the system gain by doing soʔ===

In a 3D lattice system, each lattice site has three unique interactions with its neighbours to its left, top and front. In the lowest energy configuration, all spins are parallel and for a system the minimum energy is <math>E = -DNJ</math>, so for the system with <math>N=1000</math> and <math>D=3</math>, the minimum energy is <math>-3000J</math>.

If a single spin is flipped, the product of its spin with its neighbours spin reverses and becomes negative and this increases the total energy of the system. Since 3 unique spin-spin interactions are reversed in sign, the total energy increases by <math>+3J</math>, meaning the new total energy is <math>-2997J</math>

Initially the multiplicity of the system will be <math>\Omega = \frac{1000!}{1000!}</math> , and after the flip, the multiplicity becomes <math> \Omega = \frac{1000!}{999!1!}=1000</math>.

The associated change in entropy, <math>\Delta S = k_B ln(1000) - 0 = 6.91 k_B</math>, which is an expected increase in entropy as the number of possible configurations of the system increases.

===TASK: Calculate the magnetisation of the 1D and 2D lattices in Figure 1. What magnetisation would you expect to observe for an Ising lattice with <math>D = 3,\ N=1000</math> at absolute zero?===

[[File:ThirdYearCMPExpt-IsingSketch.png|thumb|left|Figure 1 - Shows 1D (N = 5), 2D (N = 5x5) and 3D (N = 5x5x5) lattices.]]

Magnetisation is defined as <math>M=\sum_{i} s_i</math>. So for the 1D lattice with <math>N = 5</math> in ''Figure 2'', <math>M = +1</math> and for the 2D lattice with <math>N = 25 , M = +1</math> too.

According to the 3rd Law of thermodynamics, entropy is 0 at absolute zero for a perfect crystalline solid, and consequently it is expected that the lattices will have follow suit and have zero entropy at 0K. To have zero entropy all spins must be parallel as such that magnetisation, <math>M = N</math>. For all the spins to be parallel, there is only one possible configuration. So, for a lattice with <math>N = 1000</math> and <math>D =3</math>, if <math>M = N</math>, then multiplicity, <math>\Omega = 1</math> and entropy, <math>S =k_B ln(1) = 0</math>.

 

==Section 2 - Calculating the Energy and Magnetisation==

===TASK: complete the functions energy() and magnetisation(), which should return the energy of the lattice and the total magnetisation, respectively. In the energy() function you may assume that <math>J=1.0</math> at all times (in fact, we are working in reduced units in which <math>J=k_B</math>, but there will be more information about this in later sections). Do not worry about the efficiency of the code at the moment — we will address the speed in a later part of the experiment.===

<pre>def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
lat=self.lattice #creates lattice and stores it
mag=[]
for i in range(0,len(lat)): #loops through all rows of lattice
for j in range(0,len(lat[i])): #loops through elements of each row
mag+=[lat[i][j]] #adds spin value to mag array
return sum(mag) #sums all spins from mag array
</pre>

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

lat=self.lattice #creates lattice and stores it
left=[]
top=[]

for i in range(0,len(lat)):
for j in range(0,len(lat[i])):
left+=[lat[i][j]*lat[i][j-1]] #multiplies spin by spin to left
top+=[lat[i][j]*lat[i-1][j]] #multiplies spin by spin above it
int_en=left+top #sums spin products from left and top
energy=-sum(int_en) #sums all spin products for each spin to give total

return energy
</pre>

===TASK: Run the ILcheck.py script from the IPython Qt console using the command===

''Figure 2'' shows the results when ILcheck.py was ran on my IsingLattice.py file. The ILcheck.py file was ran several times to ensure the code worked for various random lattices.

[[File:Cg1417ILcheck run.png|thumb|left|500px| Figure 2 - Result from running the ILcheck.py file]]

 

==Section 3 - Introduction to Monte Carlo Simulation==

===TASK: How many configurations are available to a system with 100 spins? To evaluate these expressions, we have to calculate the energy and magnetisation for each of these configurations, then perform the sum. Let's be very, very, generous, and say that we can analyse <math>1\times 10^9</math> configurations per second with our computer. How long will it take to evaluate a single value of <math>\left\langle M\right\rangle_T</math>?===

For a system with 100 lattice sites and two possible spins for each site, there are <math>2^{100}</math>possible configurations for the system. <math>2^{100}= 1.27\times 10^{30} </math>, so if the computer can analyse <math>1\times 10^9</math> configurations per second, then it will take <math>\frac{1.27\times 10^{30}}{10^9} = 1.27\times 10^{21} s</math> to analyse the whole system, which is longer than the age of the universe and therefore is not a practical approach.

===TASK: Implement a single cycle of the above algorithm in the montecarlocycle(T) function. This function should return the energy of your lattice and the magnetisation at the end of the cycle. You may assume that the energy returned by your energy() function is in units of <math>k_B</math>! Complete the statistics() function. This should return the following quantities whenever it is called: <math><E>, <E^2>, <M>, <M^2></math>, and the number of Monte Carlo steps that have elapsed.===
<pre>
E = []
E2 = []
M = []
M2 = []
n_cycles = 0

def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back if rejected else not changed

self.E+=[self.energy()] #records energy
self.E2+=[self.energy()**2] #records energy squared
self.M+=[self.magnetisation()] #records magnetisation
self.M2+=[self.magnetisation()**2] #records magnetisation squared
self.n_cycles=self.n_cycles+1 #adds 1 to run total

return (self.energy(),self.magnetisation())

def statistics(self):
# complete this function so that it calculates the correct values for the averages of E, E*E (E2), M, M*M (M2), and returns them

e=np.mean(self.E)
e2=np.mean(self.E2)
m=np.mean(self.M)
m2=np.mean(self.M2)

return e,e2,m,m2,self.n_cycles
</pre>

===TASK: If <math>T < T_C</math>, do you expect a spontaneous magnetisation (i.e. do you expect <math>\left\langle M\right\rangle \neq 0</math>)? When the state of the simulation appears to stop changing (when you have reached an equilibrium state), use the controls to export the output to PNG and attach this to your report. You should also include the output from your statistics() function.===

If the temperature of the system is less than the Curie Temperature, <math>T_C</math> then spontaneous magnetisation can occur and the system will tend to its lowest energy state where all of the spins are parallel - this is a property of ferromagnetic materials.

[[File:Cg1417ILanim_run.png|400px|thumb|left|Figure 3 - Results from running the ILanim.py file - shows the energy and magnetisation converging over time]]

''Figure 3'' shows that over time the the system spontaneously converges to the minimum energy state with all of the spins parallel to one another and shows, as I expected, that spontaneous magnetisation occurs and also shows that the temperature of this simulation is below the Curie Temperature, <math>T < T_C</math>.

 

==Section 4 - Accelerating the Code==

===TASK: Use the script ILtimetrial.py to record how long your current version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 4'' show the results of running the ILtimetrial.py file on my code three timesː

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1.png
| width1=500
| image2=cg1417ILtimetrial_run2.png
| width2=500
| image3=cg1417ILtimetrial_run3.png
| width3=500
| footer = Figure 4 - Results of running the ILtimetrial.py file on my code three separate times
}}
 

This gave me an avergage time of <math>24.3 s \pm 0.2s</math>

===TASK: Look at the documentation for the NumPy sum function. You should be able to modify your magnetisation() function so that it uses this to evaluate M. The energy is a little trickier. Familiarise yourself with the NumPy roll and multiply functions, and use these to replace your energy double loop (you will need to call roll and multiply twice!).===

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

left=multiply(roll(self.lattice,1,axis=1),self.lattice) #product of spin with spin left of it
top=multiply(roll(self.lattice,-1,axis=0),self.lattice) #product of spin with spin above it

int_en=sum(left+top) #sum of array containing sum of left and top spin products for each spin

energy = -sum(int_en) #calculates the total energy of system
return energy

def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
return sum(sum(self.lattice)) #adds up all spins in lattice
</pre>

===TASK: Use the script ILtimetrial.py to record how long your new version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 5'' shows the result of running the ILtimetrial.py on my new accelerated code.

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1fast.png
| width1=500
| image2=ILtimetrial_run2fast.png
| width2=500
| image3=ILtimetrial_run3fast.png
| width3=500
| footer = Figure 5 - Results of running the ILtimetrial.py file on my new updated and accelerated code.
}}
 

The accelerated code is much faster upon using the roll, multiply and sum modules with a new average time of <math>0.790 s \pm 0.005 </math>

==Section 5 - The effect of temperature==

===TASK: The script ILfinalframe.py runs for a given number of cycles at a given temperature, then plots a depiction of the final lattice state as well as graphs of the energy and magnetisation as a function of cycle number. This is much quicker than animating every frame! Experiment with different temperature and lattice sizes. How many cycles are typically needed for the system to go from its random starting position to the equilibrium state? Modify your statistics() and montecarlostep() functions so that the first N cycles of the simulation are ignored when calculating the averages. You should state in your report what period you chose to ignore, and include graphs from ILfinalframe.py to illustrate your motivation in choosing this figure.===

''Figure 6'' below shows the results from running the ILfinalframe.py for 2x2 lattice at T=1,2,3,5.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2T1.png
| image2 = cg14172x2T2.png
| image3 =cg14172x2T3.png
| image4 =cg14172x2T5.png
| footer_align = left
| footer = Figure 6 - Results of running the ILfinalframe.py file at T=1,2,3,5 for a 2x2 matrix.
}}

 

For a 2x2 matrix, a suitable cut-off point to exclude from the avergage energies and magnetisations is where the energy and magnetisations per spin are constant, which is 30 steps. For T=3 and T=5 the graphs do not converge because it is possible that these temperatures are higher than the Curie Temperature and as such spontaneous magnetisation will not occur and the system will not diverge to the lowest energy state. At the higher temperatures, there are larger thermal fluctations and the Boltzmann factor is more significant allowing the system to move away from the lowest energy state easier. As a result moving forwards, a suitable cut-off point will only be determined from T=1 and T=2 graphs for the larger matrices.

''Figure 7'' shows the results from running a 4x4 lattice at T=1,2 and 3.

{{multiple image
| width =350
| align = left
| image1 = cg14174x4T1.png
| image2 = cg14174x4T2.png
| image3 =cg14174x4T3.png
| footer_align = left
| footer = Figure 7 - Results of running the ILfinalframe.py file at T=1,2,3 for a 4x4 matrix.
}}

From ''Figure 7'', a suitable cut-off point for the energy and magnetisations is 200 as this is after where the energy and magnetisation has converged for T=1, and is after the initial large drop in energy for T=2, even though there are a few small fluctuations after 200 steps. The result from T=3 has been included to show the large fluctuations for the larger temperatures, and supporting my choice to determine the cut-off from T=1 and T=2 only.

''Figure 8'' shows the results for an 8x8 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg14178x8T1.png
| image2 = cg14178x8T2.png
| footer_align = left
| footer = Figure 8 - Results of running the ILfinalframe.py file at T=1,2 for an 8x8 matrix
}}

From ''Figure 8'' above, a suitable cut-off point is 1000 steps as this is where the energy and magnetisation has easily converged by and is also the point after which the initial large drop in energy has been overcome for T=2 too.

''Figure 9'' shows the result of running the ILfinalframe.py for a 16x16 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg141716x16T1.png
| image2 = cg141716x16T2.png
| footer_align = left
| footer = Figure 9 - Results of running the ILfinalframe.py file at T=1,2 for a 16x16 matrix
}}

From ''Figure 9'', a suitable cut-off point is 15000 steps as for T=1 the energy and magnetisations have converged significantly and will not change much, and likewise this is the same for the T=2 frame.

''Figure 10'' below shows the results from a 32x32 matrix at T=1 and T=2.

{{multiple image
| width =350
| align = left
| image1 = cg141732x32T1.png
| image2 = cg141732x32T2.png
| footer_align = left
| footer = Figure 10 - Results of running the ILfinalframe.py file at T=1,2 for a 32x32 matrix
}}

''Figure 10'' above shows the results of running the ILfinalframe.py file for a 32x32 matrix at T=1 and T=2. As a result a suitable cut-off of 50000 steps was chosen as the energy and magnetisation has significantly converged, but not as much as it could at 100000 steps. I chose a slightly lower value to ensure that the run times of my monte-carlo simulations in future tasks were not extremely time consuming.

The montecarlostep() function was changed by adding a condition that values only above the pre-determined cut-off were included when determining the average value of energy; energy squared; magnetisation and magnetisations squared from the statistics function. The statistics() function did not need to be modified.

The following code is from the 32x32 matrixː

<pre>def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back

if self.n_cycles > 50000: #only adds values to array of E,E2,M and M2 is above specific cut-off
self.E+=[self.energy()]
self.E2+=[self.energy()**2]
self.M+=[self.magnetisation()]
self.M2+=[self.magnetisation()**2]
self.n_cycles=self.n_cycles+1

return (self.energy(),self.magnetisation())
</pre>

===TASK: Use ILtemperaturerange.py to plot the average energy and magnetisation for each temperature, with error bars, for an <math>8\times 8</math> lattice. Use your intuition and results from the script ILfinalframe.py to estimate how many cycles each simulation should be. The temperature range 0.25 to 5.0 is sufficient. Use as many temperature points as you feel necessary to illustrate the trend, but do not use a temperature spacing larger than 0.5. The NumPy function savetxt() stores your array of output data on disk — you will need it later. Save the file as 8x8.dat so that you know which lattice size it came from.===

Using the modified code, the file ILtemperaturerange.py was ran on an 8x8 matrix between T=0.5 and T=5 with a step of T=0.02 for 10000 Montecarlo steps and the first 1000 steps of each temperature were excluded when calculating the averages. ''Figure 11'' shows the result of the simulation and also included error bars of standard deviation.

[[File:Cg14178x8error.png|1000px|thumb|left|Figure 11 - Graph showing average energy and average magnetisation for an 8x8 lattice with error bars between T=0.5 and T=5]]

 

==Section 6 - The effect of system size==

===TASK: Repeat the final task of the previous section for the following lattice sizes: 2x2, 4x4, 8x8, 16x16, 32x32. Make sure that you name each datafile that your produce after the corresponding lattice size! Write a Python script to make a plot showing the energy per spin versus temperature for each of your lattice sizes. Hint: the NumPy loadtxt function is the reverse of the savetxt function, and can be used to read your previously saved files into the script. Repeat this for the magnetisation. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. How big a lattice do you think is big enough to capture the long range fluctuations?===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb.

Each matrix was simulated using the ILtemperaturerange.py file between T=0.5 and T=5 with a step of T=0.02.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2error.png
| caption1 = 2x2 matrix - 5000 steps, cut-off = 30 steps
| image2 = 4x4error.png
| caption2 = 4x4 matrix - 1000 steps, cut-off = 200 steps
| image3 =cg141716x16error.png
| caption3 = 16x16 matrix - 50000 steps, cut-off = 15000 steps
| image4 =cg141732x32error.png
| caption4 = 32x32 matrix - 200000 steps, cut-off = 50000 steps
| footer_align = left
| footer = Figure 12 - Results of running the ILtemperaturerange.py file for 2x2, 4x4, 16x16 and 32x32 matrices.
}}

 

==Section 7 - Determining the Heat Capacity==

===TASK: By definition, <math>C = \frac{\partial \left\langle E\right\rangle}{\partial T}</math>. From this, show that <math>C = \frac{\mathrm{Var}[E]}{k_B T^2}</math> (Where <math>\mathrm{Var}[E]</math> is the variance in <math>E</math>.)===

Recall from statistical thermodynamics that the average energy of a system is the sum across all microstates of the probability of that microstate multiplied by the energy of that microstate, which is defined mathematically asː <math>\langle E \rangle = \sum_i p_{i}\epsilon_{i}</math>.

The partition function <math>q</math> is defined as <math>q = \sum_{i} exp(-\beta \epsilon_{i})</math> where <math>\beta =\frac{1}{k_BT}</math>and the probability, <math>p_{i}</math> can be defined in terms of the partition function as <math>p_{i} = \frac{exp(-\beta \epsilon_{i})}{\sum_{i} exp(-\beta \epsilon_{i})} = \frac{exp(-\beta \epsilon_{i})}{q}</math>.

As a result, <math>\langle E \rangle</math> can be re-written as <math>\langle E \rangle = \sum_{i} \frac{\epsilon_{i} exp(-\beta \epsilon_{i})}{q} = -\frac{1}{q} \frac{\partial}{\partial \beta}\sum_{i}exp(-\beta \epsilon_{i}) = -\frac{1}{q} \frac{\partial q}{\partial \beta}</math>

Likewise, <math>\langle E^2 \rangle = \sum_i p_{i}\epsilon_{i}^{2} = \sum_{i} \frac{\epsilon_{i}^{2}exp(-\beta \epsilon_{i})}{q} = \frac{1}{q} \frac{\partial^{2}}{\partial \beta^{2}}\sum_{i}exp(-\beta \epsilon_{i}) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}}</math>

From definitionː <math>Var[E] = \Delta E^2 = \langle E^2 \rangle - \langle E \rangle^2 </math>

When the definition of <math>\langle E \rangle</math> and <math>\langle E^2 \rangle</math> is written in terms of partition function <math>q</math>ː <math>Var[E] = \langle E^2 \rangle - \langle E \rangle^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \left(\frac{1}{q}\frac{\partial q}{\partial \beta}\right)^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2</math>.

According to the chain ruleː <math>\frac{\partial}{\partial \beta}\left(\frac{1}{q} \frac{\partial q}{\partial \beta}\right) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2 = -\frac{\partial}{\partial \beta}\langle E \rangle = Var[E]</math>

And using the chain rule againː <math>C = \frac{\partial \langle E \rangle}{\partial T}= \left(-\frac{\partial \langle E \rangle}{\partial \beta}\right) \left(-\frac{\partial \beta}{\partial T}\right) = \frac{Var[E]}{k_B T^2}</math>

===TASK: Write a Python script to make a plot showing the heat capacity versus temperature for each of your lattice sizes from the previous section. You may need to do some research to recall the connection between the variance of a variable, <math>\mathrm{Var}[X]</math>, the mean of its square <math>\left\langle X^2\right\rangle</math>, and its squared mean <math>\left\langle X\right\rangle^2</math>. You may find that the data around the peak is very noisy — this is normal, and is a result of being in the critical region. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. ===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb

{{multiple image
| width =300
| align = left
| image1 = cg14172x2heatcap.png
| caption1 = 2x2 Matrix
| image2 = cg14174x4heatcap.png
| caption2 = 4x4 Matrix
| image3 =cg14178x8heatcap.png
| caption3 = 8x8 Matrix
| image4 =cg141716x16heatcap.png
| caption4 = 16x16 Matrix
| image5=cg141732x32heatcap.png
| caption5= 32x32 Matrix
| footer = Figure 13 - Graphs showing Heat Capacity against Temperature for each matrix size
}}

A general trend from the above graphs is that the peak of the graph shifts towards lower temperatures as the size of the matrix used increases.

==Section 8 - Locating the Curie Temperature==
===TASK: A C++ program has been used to run some much longer simulations than would be possible on the college computers in Python. You can view its source code here if you are interested. Each file contains six columns: <math>T, E, E^2, M, M^2, C</math> (the final five quantities are per spin), and you can read them with the NumPy loadtxt function as before. For each lattice size, plot the C++ data against your data. For one lattice size, save a PNG of this comparison and add it to your report — add a legend to the graph to label which is which. To do this, you will need to pass the label="..." keyword to the plot function, then call the legend() function of the axis object (documentation here).===

The python code used to read and plot the C++ data is found in the Jupyter notebook CG1417IsingModelGraphs.ipynb.

''Figure 14'' below shows the C++ plotted against my own data for a 16x16 Matrix.

[[File:Cg141716x16C++.png|400px|thumb|left|Figure 14 - Graph showing my own data against the C++ data for a 16x16 matrix.]]

 

===TASK: write a script to read the data from a particular file, and plot C vs T, as well as a fitted polynomial. Try changing the degree of the polynomial to improve the fit — in general, it might be difficult to get a good fit! Attach a PNG of an example fit to your report.===

The python script to read and plot the fitted polynomial is found in CG1417PolyfitScript.ipynb

Below in ''Figure 15'' is a plot of my Heat Capacity against Temperature data for a 16x16 matrix and features a polynomial of degree 35 plotted against it. Even with a polynomial of such a high degree, it poorly fits the curve and does not fit to the peak of the curve either.

[[File:cg1417FIT_TEST16x16_35.png|thumb|left|400px|Figure 15 - Plot of Heat Capacity against Temperature along with a poorly fitted polynomial of degree 35. ]]

 

===TASK: Modify your script from the previous section. You should still plot the whole temperature range, but fit the polynomial only to the peak of the heat capacity! You should find it easier to get a good fit when restricted to this region===

The script was modified as such that the polynomial was fitted in a set range around the peak of the graph, this is demonstrated in ''Figure 17'' which shows a newly fitted polynomial between a much smaller range of temperatures (T = 2.15-2.55) and a much smaller degree polynomial (3).

[[File:CG1417FIT_16x16C_3.png|thumb|left|400px|Figure 16 - Graph showing Heat Capacity against Temperature for a 16x16 matrix along with a fitted polynomial between a much more restricted range of temperatures and a significantly lower degree of polynomial]]

Upon comparison with ''Figure 15'', the new fitted polynomial is a significantly better fit even for a 3rd degree polynomial and is a much more accurate representation of my data around the peak of the graph and will make it easier to determine the maximum value of Heat Capacity.

 

===TASK: find the temperature at which the maximum in C occurs for each datafile that you were given. Make a text file containing two colums: the lattice side length (2,4,8, etc.), and the temperature at which C is a maximum. This is your estimate of <math>T_C</math> for that side length. Make a plot that uses the scaling relation given above to determine <math>T_{C,\infty}</math>. By doing a little research online, you should be able to find the theoretical exact Curie temperature for the infinite 2D Ising lattice. How does your value compare to this? Are you surprised by how good/bad the agreement is? Attach a PNG of this final graph to your report, and discuss briefly what you think the major sources of error are in your estimate.===

''Figure 17'' below shows a graph of <math>T_{C,L}</math> against <math>\frac{1}{Lattice Size}</math> to determine the Curie Temperature of an infinite 2D Ising Model Lattice <math>T_{C,\infty}</math>. The black dots represent the raw data obtained from obtaining the temperature at which the Heat Capacity was a maximum for the lattices and the red line in a linear curve fit plotted against the data to allow the y-intercept which is the Curie Temperature for the infinite 2D lattice to be determined.

[[File:cg1417CurieTemp.png|400px|thumb|left|Figure 17 - Plot of 1/Lattice Size against Curie Temperature for that lattice size.]]

The value for <math>T_{C,\inf}</math> obtained from the data is <math>T_{C,\infty} = 2.277 \frac{J}{k_B}</math> with a literature value being <math>T_{C,\infty} = 2.269 \frac{J}{k_B}</math> for an infinite square 2D lattice. This means that my result slightly over-estimates the Curie Temperature for the infinite lattice and as a result for an infinite lattice the temperature at which spontaneous magnetisation stops would actually occur at a slightly lower temperature than expected. However, the difference between my value and the literature value is only 0.008 which is incredibly small and the amount of agreement between the two values is somewhat surprising, which means that the error in my estimates of the Curie Temperature for each lattice size is relatively small. The points which have the largest residuals and deviation from the line of best fit in ''Figure 17'' corresponds to the smaller lattice sizes of 2x2 and 4x4 where longer range interactions are more significant. The longer range interactions posed by the boundary conditions are nowhere near as significant for the larger sizes and causes the energy of the smaller matrices to be less accurate and have a larger associated error with the energy and thus the Curie Temperature for that lattice size. This affects the accuracy of the line of best fit and to increase the accuracy of this line, larger lattice sizes of 128x128, 256x256 etc should be included in the calculation for the line of best fit and the smaller matrices ignored.

Rep:Y3CMPCG1417

2019-11-20T08:23:44Z

==Section 1 - Introduction to the Ising Model==

===TASK: Show that the lowest possible energy for the Ising model is <math>E = -DNJ</math>, where D is the number of dimensions and N is the total number of spins. What is the multiplicity of this state? Calculate its entropy.===

Consider a 1D row of lattice sites of N=3 with spin configuration [+1][+1][+1].

Mathematically the interaction energy is defined asː
<math> -\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} </math> where J is a constant and <math>s_{i}s_{j}</math> is the product between two spins in adjacent lattice sites.

The sum of the interaction energies <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j}</math> can be considered as the sum of the individual interaction energies between spinsː
<math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = \epsilon_{12} + \epsilon_{23} + \epsilon_{13} + \epsilon_{21} + \epsilon_{32} + \epsilon_{31} </math>.

Although lattice sites 1 and 3 are not adjacent they are said to still interact according to the periodic boundary conditions applied.

However, <math>\epsilon_{12} = \epsilon_{21} </math> and <math>\epsilon_{23} = \epsilon_{32}</math> and <math>\epsilon_{13} = \epsilon_{31}</math> which means that all of the interactions within the system are counted twice, hence the total energy needs to be halved, resulting in the following formula being obtainedː <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = 2\epsilon_{12} + 2\epsilon_{13} + 2\epsilon_{23} </math>.

It can be determined that <math>\epsilon_{12} = (+1)(+1) = 1</math> , <math>\epsilon_{13} = (+1)(+1) = 1</math> and <math>\epsilon_{23} = (+1)(+1) = 1</math>.

Thereforeː <math>-\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = -\frac{1}{2} \ J \ (2 + 2 + 2) = -\frac{1}{2} \ J \ 6 = - 3 J = -DNJ</math> for a 1D lattice with <math>D=1</math> and 3 lattice sites <math>N=3</math>

The multiplicity of the system,<math>\Omega = \frac{n. spin up!}{n. spin down!}</math>

Entropy, <math>S</math> is defined as <math>S = k_B ln(\Omega)</math> and so in this case <math>S = k_B ln(\frac{100!}{100!}) = 0</math>

===TASK: Imagine that the system is in the lowest energy configuration. To move to a different state, one of the spins must spontaneously change direction ("flip"). What is the change in energy if this happens <math>(D=3, N=1000)</math>? How much entropy does the system gain by doing soʔ===

In a 3D lattice system, each lattice site has three unique interactions with its neighbours to its left, top and front. In the lowest energy configuration, all spins are parallel and for a system the minimum energy is <math>E = -DNJ</math>, so for the system with <math>N=1000</math> and <math>D=3</math>, the minimum energy is <math>-3000J</math>.

If a single spin is flipped, the product of its spin with its neighbours spin reverses and becomes negative and this increases the total energy of the system. Since 3 unique spin-spin interactions are reversed in sign, the total energy increases by <math>+3J</math>, meaning the new total energy is <math>-2997J</math>

Initially the multiplicity of the system will be <math>\Omega = \frac{1000!}{1000!}</math> , and after the flip, the multiplicity becomes <math> \Omega = \frac{1000!}{999!1!}=1000</math>.

The associated change in entropy, <math>\Delta S = k_B ln(1000) - 0 = 6.91 k_B</math>, which is an expected increase in entropy as the number of possible configurations of the system increases.

===TASK: Calculate the magnetisation of the 1D and 2D lattices in Figure 1. What magnetisation would you expect to observe for an Ising lattice with <math>D = 3,\ N=1000</math> at absolute zero?===

[[File:ThirdYearCMPExpt-IsingSketch.png|thumb|left|Figure 1 - Shows 1D (N = 5), 2D (N = 5x5) and 3D (N = 5x5x5) lattices.]]

Magnetisation is defined as <math>M=\sum_{i} s_i</math>. So for the 1D lattice with <math>N = 5</math> in ''Figure 2'', <math>M = +1</math> and for the 2D lattice with <math>N = 25 , M = +1</math> too.

According to the 3rd Law of thermodynamics, entropy is 0 at absolute zero for a perfect crystalline solid, and consequently it is expected that the lattices will have follow suit and have zero entropy at 0K. To have zero entropy all spins must be parallel as such that magnetisation, <math>M = N</math>. For all the spins to be parallel, there is only one possible configuration. So, for a lattice with <math>N = 1000</math> and <math>D =3</math>, if <math>M = N</math>, then multiplicity, <math>\Omega = 1</math> and entropy, <math>S =k_B ln(1) = 0</math>.

 

==Section 2 - Calculating the Energy and Magnetisation==

===TASK: complete the functions energy() and magnetisation(), which should return the energy of the lattice and the total magnetisation, respectively. In the energy() function you may assume that <math>J=1.0</math> at all times (in fact, we are working in reduced units in which <math>J=k_B</math>, but there will be more information about this in later sections). Do not worry about the efficiency of the code at the moment — we will address the speed in a later part of the experiment.===

<pre>def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
lat=self.lattice #creates lattice and stores it
mag=[]
for i in range(0,len(lat)): #loops through all rows of lattice
for j in range(0,len(lat[i])): #loops through elements of each row
mag+=[lat[i][j]] #adds spin value to mag array
return sum(mag) #sums all spins from mag array
</pre>

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

lat=self.lattice #creates lattice and stores it
left=[]
top=[]

for i in range(0,len(lat)):
for j in range(0,len(lat[i])):
left+=[lat[i][j]*lat[i][j-1]] #multiplies spin by spin to left
top+=[lat[i][j]*lat[i-1][j]] #multiplies spin by spin above it
int_en=left+top #sums spin products from left and top
energy=-sum(int_en) #sums all spin products for each spin to give total

return energy
</pre>

===TASK: Run the ILcheck.py script from the IPython Qt console using the command===

''Figure 2'' shows the results when ILcheck.py was ran on my IsingLattice.py file. The ILcheck.py file was ran several times to ensure the code worked for various random lattices.

[[File:Cg1417ILcheck run.png|thumb|left|500px| Figure 2 - Result from running the ILcheck.py file]]

 

==Section 3 - Introduction to Monte Carlo Simulation==

===TASK: How many configurations are available to a system with 100 spins? To evaluate these expressions, we have to calculate the energy and magnetisation for each of these configurations, then perform the sum. Let's be very, very, generous, and say that we can analyse <math>1\times 10^9</math> configurations per second with our computer. How long will it take to evaluate a single value of <math>\left\langle M\right\rangle_T</math>?===

For a system with 100 lattice sites and two possible spins for each site, there are <math>2^{100}</math>possible configurations for the system. <math>2^{100}= 1.27\times 10^{30} </math>, so if the computer can analyse <math>1\times 10^9</math> configurations per second, then it will take <math>\frac{1.27\times 10^{30}}{10^9} = 1.27\times 10^{21} s</math> to analyse the whole system, which is longer than the age of the universe and therefore is not a practical approach.

===TASK: Implement a single cycle of the above algorithm in the montecarlocycle(T) function. This function should return the energy of your lattice and the magnetisation at the end of the cycle. You may assume that the energy returned by your energy() function is in units of <math>k_B</math>! Complete the statistics() function. This should return the following quantities whenever it is called: <math><E>, <E^2>, <M>, <M^2></math>, and the number of Monte Carlo steps that have elapsed.===
<pre>
E = []
E2 = []
M = []
M2 = []
n_cycles = 0

def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back if rejected else not changed

self.E+=[self.energy()] #records energy
self.E2+=[self.energy()**2] #records energy squared
self.M+=[self.magnetisation()] #records magnetisation
self.M2+=[self.magnetisation()**2] #records magnetisation squared
self.n_cycles=self.n_cycles+1 #adds 1 to run total

return (self.energy(),self.magnetisation())

def statistics(self):
# complete this function so that it calculates the correct values for the averages of E, E*E (E2), M, M*M (M2), and returns them

e=np.mean(self.E)
e2=np.mean(self.E2)
m=np.mean(self.M)
m2=np.mean(self.M2)

return e,e2,m,m2,self.n_cycles
</pre>

===TASK: If <math>T < T_C</math>, do you expect a spontaneous magnetisation (i.e. do you expect <math>\left\langle M\right\rangle \neq 0</math>)? When the state of the simulation appears to stop changing (when you have reached an equilibrium state), use the controls to export the output to PNG and attach this to your report. You should also include the output from your statistics() function.===

If the temperature of the system is less than the Curie Temperature, <math>T_C</math> then spontaneous magnetisation can occur and the system will tend to its lowest energy state where all of the spins are parallel - this is a property of ferromagnetic materials.

[[File:Cg1417ILanim_run.png|400px|thumb|left|Figure 3 - Results from running the ILanim.py file - shows the energy and magnetisation converging over time]]

''Figure 3'' shows that over time the the system spontaneously converges to the minimum energy state with all of the spins parallel to one another and shows, as I expected, that spontaneous magnetisation occurs and also shows that the temperature of this simulation is below the Curie Temperature, <math>T < T_C</math>.

 

==Section 4 - Accelerating the Code==

===TASK: Use the script ILtimetrial.py to record how long your current version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 4'' show the results of running the ILtimetrial.py file on my code three timesː

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1.png
| width1=500
| image2=cg1417ILtimetrial_run2.png
| width2=500
| image3=cg1417ILtimetrial_run3.png
| width3=500
| footer = Figure 4 - Results of running the ILtimetrial.py file on my code three separate times
}}
 

This gave me an avergage time of <math>24.3 s \pm 0.2s</math>

===TASK: Look at the documentation for the NumPy sum function. You should be able to modify your magnetisation() function so that it uses this to evaluate M. The energy is a little trickier. Familiarise yourself with the NumPy roll and multiply functions, and use these to replace your energy double loop (you will need to call roll and multiply twice!).===

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

left=multiply(roll(self.lattice,1,axis=1),self.lattice) #product of spin with spin left of it
top=multiply(roll(self.lattice,-1,axis=0),self.lattice) #product of spin with spin above it

int_en=sum(left+top) #sum of array containing sum of left and top spin products for each spin

energy = -sum(int_en) #calculates the total energy of system
return energy

def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
return sum(sum(self.lattice)) #adds up all spins in lattice
</pre>

===TASK: Use the script ILtimetrial.py to record how long your new version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 5'' shows the result of running the ILtimetrial.py on my new accelerated code.

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1fast.png
| width1=500
| image2=ILtimetrial_run2fast.png
| width2=500
| image3=ILtimetrial_run3fast.png
| width3=500
| footer = Figure 5 - Results of running the ILtimetrial.py file on my new updated and accelerated code.
}}
 

The accelerated code is much faster upon using the roll, multiply and sum modules with a new average time of <math>0.790 s \pm 0.005 </math>

==Section 5 - The effect of temperature==

===TASK: The script ILfinalframe.py runs for a given number of cycles at a given temperature, then plots a depiction of the final lattice state as well as graphs of the energy and magnetisation as a function of cycle number. This is much quicker than animating every frame! Experiment with different temperature and lattice sizes. How many cycles are typically needed for the system to go from its random starting position to the equilibrium state? Modify your statistics() and montecarlostep() functions so that the first N cycles of the simulation are ignored when calculating the averages. You should state in your report what period you chose to ignore, and include graphs from ILfinalframe.py to illustrate your motivation in choosing this figure.===

''Figure 6'' below shows the results from running the ILfinalframe.py for 2x2 lattice at T=1,2,3,5.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2T1.png
| image2 = cg14172x2T2.png
| image3 =cg14172x2T3.png
| image4 =cg14172x2T5.png
| footer_align = left
| footer = Figure 6 - Results of running the ILfinalframe.py file at T=1,2,3,5 for a 2x2 matrix.
}}

 

For a 2x2 matrix, a suitable cut-off point to exclude from the avergage energies and magnetisations is where the energy and magnetisations per spin are constant, which is 30 steps. For T=3 and T=5 the graphs do not converge because it is possible that these temperatures are higher than the Curie Temperature and as such spontaneous magnetisation will not occur and the system will not diverge to the lowest energy state. At the higher temperatures, there are larger thermal fluctations and the Boltzmann factor is more significant allowing the system to move away from the lowest energy state easier. As a result moving forwards, a suitable cut-off point will only be determined from T=1 and T=2 graphs for the larger matrices.

''Figure 7'' shows the results from running a 4x4 lattice at T=1,2 and 3.

{{multiple image
| width =350
| align = left
| image1 = cg14174x4T1.png
| image2 = cg14174x4T2.png
| image3 =cg14174x4T3.png
| footer_align = left
| footer = Figure 7 - Results of running the ILfinalframe.py file at T=1,2,3 for a 4x4 matrix.
}}

From ''Figure 7'', a suitable cut-off point for the energy and magnetisations is 200 as this is after where the energy and magnetisation has converged for T=1, and is after the initial large drop in energy for T=2, even though there are a few small fluctuations after 200 steps. The result from T=3 has been included to show the large fluctuations for the larger temperatures, and supporting my choice to determine the cut-off from T=1 and T=2 only.

''Figure 8'' shows the results for an 8x8 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg14178x8T1.png
| image2 = cg14178x8T2.png
| footer_align = left
| footer = Figure 8 - Results of running the ILfinalframe.py file at T=1,2 for an 8x8 matrix
}}

From ''Figure 8'' above, a suitable cut-off point is 1000 steps as this is where the energy and magnetisation has easily converged by and is also the point after which the initial large drop in energy has been overcome for T=2 too.

''Figure 9'' shows the result of running the ILfinalframe.py for a 16x16 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg141716x16T1.png
| image2 = cg141716x16T2.png
| footer_align = left
| footer = Figure 9 - Results of running the ILfinalframe.py file at T=1,2 for a 16x16 matrix
}}

From ''Figure 9'', a suitable cut-off point is 15000 steps as for T=1 the energy and magnetisations have converged significantly and will not change much, and likewise this is the same for the T=2 frame.

''Figure 10'' below shows the results from a 32x32 matrix at T=1 and T=2.

{{multiple image
| width =350
| align = left
| image1 = cg141732x32T1.png
| image2 = cg141732x32T2.png
| footer_align = left
| footer = Figure 10 - Results of running the ILfinalframe.py file at T=1,2 for a 32x32 matrix
}}

''Figure 10'' above shows the results of running the ILfinalframe.py file for a 32x32 matrix at T=1 and T=2. As a result a suitable cut-off of 50000 steps was chosen as the energy and magnetisation has significantly converged, but not as much as it could at 100000 steps. I chose a slightly lower value to ensure that the run times of my monte-carlo simulations in future tasks were not extremely time consuming.

The montecarlostep() function was changed by adding a condition that values only above the pre-determined cut-off were included when determining the average value of energy; energy squared; magnetisation and magnetisations squared from the statistics function. The statistics() function did not need to be modified.

The following code is from the 32x32 matrixː

<pre>def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back

if self.n_cycles > 50000: #only adds values to array of E,E2,M and M2 is above specific cut-off
self.E+=[self.energy()]
self.E2+=[self.energy()**2]
self.M+=[self.magnetisation()]
self.M2+=[self.magnetisation()**2]
self.n_cycles=self.n_cycles+1

return (self.energy(),self.magnetisation())
</pre>

===TASK: Use ILtemperaturerange.py to plot the average energy and magnetisation for each temperature, with error bars, for an <math>8\times 8</math> lattice. Use your intuition and results from the script ILfinalframe.py to estimate how many cycles each simulation should be. The temperature range 0.25 to 5.0 is sufficient. Use as many temperature points as you feel necessary to illustrate the trend, but do not use a temperature spacing larger than 0.5. The NumPy function savetxt() stores your array of output data on disk — you will need it later. Save the file as 8x8.dat so that you know which lattice size it came from.===

Using the modified code, the file ILtemperaturerange.py was ran on an 8x8 matrix between T=0.5 and T=5 with a step of T=0.02 for 10000 Montecarlo steps and the first 1000 steps of each temperature were excluded when calculating the averages. ''Figure 11'' shows the result of the simulation and also included error bars of standard deviation.

[[File:Cg14178x8error.png|1000px|thumb|left|Figure 11 - Graph showing average energy and average magnetisation for an 8x8 lattice with error bars between T=0.5 and T=5]]

 

==Section 6 - The effect of system size==

===TASK: Repeat the final task of the previous section for the following lattice sizes: 2x2, 4x4, 8x8, 16x16, 32x32. Make sure that you name each datafile that your produce after the corresponding lattice size! Write a Python script to make a plot showing the energy per spin versus temperature for each of your lattice sizes. Hint: the NumPy loadtxt function is the reverse of the savetxt function, and can be used to read your previously saved files into the script. Repeat this for the magnetisation. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. How big a lattice do you think is big enough to capture the long range fluctuations?===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb.

Each matrix was simulated using the ILtemperaturerange.py file between T=0.5 and T=5 with a step of T=0.02.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2error.png
| caption1 = 2x2 matrix - 5000 steps, cut-off = 30 steps
| image2 = 4x4error.png
| caption2 = 4x4 matrix - 1000 steps, cut-off = 200 steps
| image3 =cg141716x16error.png
| caption3 = 16x16 matrix - 50000 steps, cut-off = 15000 steps
| image4 =cg141732x32error.png
| caption4 = 32x32 matrix - 200000 steps, cut-off = 50000 steps
| footer_align = left
| footer = Figure 12 - Results of running the ILtemperaturerange.py file for 2x2, 4x4, 16x16 and 32x32 matrices.
}}

 

==Section 7 - Determining the Heat Capacity==

===TASK: By definition, <math>C = \frac{\partial \left\langle E\right\rangle}{\partial T}</math>. From this, show that <math>C = \frac{\mathrm{Var}[E]}{k_B T^2}</math> (Where <math>\mathrm{Var}[E]</math> is the variance in <math>E</math>.)===

Recall from statistical thermodynamics that the average energy of a system is the sum across all microstates of the probability of that microstate multiplied by the energy of that microstate, which is defined mathematically asː <math>\langle E \rangle = \sum_i p_{i}\epsilon_{i}</math>.

The partition function <math>q</math> is defined as <math>q = \sum_{i} exp(-\beta \epsilon_{i})</math> where <math>\beta =\frac{1}{k_BT}</math>and the probability, <math>p_{i}</math> can be defined in terms of the partition function as <math>p_{i} = \frac{exp(-\beta \epsilon_{i})}{\sum_{i} exp(-\beta \epsilon_{i})} = \frac{exp(-\beta \epsilon_{i})}{q}</math>.

As a result, <math>\langle E \rangle</math> can be re-written as <math>\langle E \rangle = \sum_{i} \frac{\epsilon_{i} exp(-\beta \epsilon_{i})}{q} = -\frac{1}{q} \frac{\partial}{\partial \beta}\sum_{i}exp(-\beta \epsilon_{i}) = -\frac{1}{q} \frac{\partial q}{\partial \beta}</math>

Likewise, <math>\langle E^2 \rangle = \sum_i p_{i}\epsilon_{i}^{2} = \sum_{i} \frac{\epsilon_{i}^{2}exp(-\beta \epsilon_{i})}{q} = \frac{1}{q} \frac{\partial^{2}}{\partial \beta^{2}}\sum_{i}exp(-\beta \epsilon_{i}) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}}</math>

From definitionː <math>Var[E] = \Delta E^2 = \langle E^2 \rangle - \langle E \rangle^2 </math>

When the definition of <math>\langle E \rangle</math> and <math>\langle E^2 \rangle</math> is written in terms of partition function <math>q</math>ː <math>Var[E] = \langle E^2 \rangle - \langle E \rangle^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \left(\frac{1}{q}\frac{\partial q}{\partial \beta}\right)^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2</math>.

According to the chain ruleː <math>\frac{\partial}{\partial \beta}\left(\frac{1}{q} \frac{\partial q}{\partial \beta}\right) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2 = -\frac{\partial}{\partial \beta}\langle E \rangle = Var[E]</math>

And using the chain rule againː <math>C = \frac{\partial \langle E \rangle}{\partial T}= \left(-\frac{\partial \langle E \rangle}{\partial \beta}\right) \left(-\frac{\partial \beta}{\partial T}\right) = \frac{Var[E]}{k_B T^2}</math>

===TASK: Write a Python script to make a plot showing the heat capacity versus temperature for each of your lattice sizes from the previous section. You may need to do some research to recall the connection between the variance of a variable, <math>\mathrm{Var}[X]</math>, the mean of its square <math>\left\langle X^2\right\rangle</math>, and its squared mean <math>\left\langle X\right\rangle^2</math>. You may find that the data around the peak is very noisy — this is normal, and is a result of being in the critical region. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. ===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb

{{multiple image
| width =300
| align = left
| image1 = cg14172x2heatcap.png
| caption1 = 2x2 Matrix
| image2 = cg14174x4heatcap.png
| caption2 = 4x4 Matrix
| image3 =cg14178x8heatcap.png
| caption3 = 8x8 Matrix
| image4 =cg141716x16heatcap.png
| caption4 = 16x16 Matrix
| image5=cg141732x32heatcap.png
| caption5= 32x32 Matrix
| footer = Figure 13 - Graphs showing Heat Capacity against Temperature for each matrix size
}}

A general trend from the above graphs is that the peak of the graph shifts towards lower temperatures as the size of the matrix used increases.

==Section 8 - Locating the Curie Temperature==
===TASK: A C++ program has been used to run some much longer simulations than would be possible on the college computers in Python. You can view its source code here if you are interested. Each file contains six columns: <math>T, E, E^2, M, M^2, C</math> (the final five quantities are per spin), and you can read them with the NumPy loadtxt function as before. For each lattice size, plot the C++ data against your data. For one lattice size, save a PNG of this comparison and add it to your report — add a legend to the graph to label which is which. To do this, you will need to pass the label="..." keyword to the plot function, then call the legend() function of the axis object (documentation here).===

The python code used to read and plot the C++ data is found in the Jupyter notebook CG1417IsingModelGraphs.ipynb.

''Figure 14'' below shows the C++ plotted against my own data for a 16x16 Matrix.

[[File:Cg141716x16C++.png|400px|thumb|left|Figure 14 - Graph showing my own data against the C++ data for a 16x16 matrix.]]

 

===TASK: write a script to read the data from a particular file, and plot C vs T, as well as a fitted polynomial. Try changing the degree of the polynomial to improve the fit — in general, it might be difficult to get a good fit! Attach a PNG of an example fit to your report.===

The python script to read and plot the fitted polynomial is found in CG1417PolyfitScript.ipynb

Below in ''Figure 15'' is a plot of my Heat Capacity against Temperature data for a 16x16 matrix and features a polynomial of degree 35 plotted against it. Even with a polynomial of such a high degree, it poorly fits the curve and does not fit to the peak of the curve either.

[[File:cg1417FIT_TEST16x16_35.png|thumb|left|400px|Figure 15 - Plot of Heat Capacity against Temperature along with a poorly fitted polynomial of degree 35. ]]

 

===TASK: Modify your script from the previous section. You should still plot the whole temperature range, but fit the polynomial only to the peak of the heat capacity! You should find it easier to get a good fit when restricted to this region===

The script was modified as such that the polynomial was fitted in a set range around the peak of the graph, this is demonstrated in ''Figure 17'' which shows a newly fitted polynomial between a much smaller range of temperatures (T = 2.15-2.55) and a much smaller degree polynomial (3).

[[File:CG1417FIT_16x16C_3.png|thumb|left|400px|Figure 16 - Graph showing Heat Capacity against Temperature for a 16x16 matrix along with a fitted polynomial between a much more restricted range of temperatures and a significantly lower degree of polynomial]]

Upon comparison with ''Figure 15'', the new fitted polynomial is a significantly better fit even for a 3rd degree polynomial and is a much more accurate representation of my data around the peak of the graph and will make it easier to determine the maximum value of Heat Capacity.

 

===TASK: find the temperature at which the maximum in C occurs for each datafile that you were given. Make a text file containing two colums: the lattice side length (2,4,8, etc.), and the temperature at which C is a maximum. This is your estimate of <math>T_C</math> for that side length. Make a plot that uses the scaling relation given above to determine <math>T_{C,\infty}</math>. By doing a little research online, you should be able to find the theoretical exact Curie temperature for the infinite 2D Ising lattice. How does your value compare to this? Are you surprised by how good/bad the agreement is? Attach a PNG of this final graph to your report, and discuss briefly what you think the major sources of error are in your estimate.===

''Figure 17'' below shows a graph of <math>T_{C,L}</math> against <math>\frac{1}{Lattice Size}</math> to determine the Curie Temperature of an infinite 2D Ising Model Lattice <math>T_{C,\infty}</math>. The black dots represent the raw data obtained from obtaining the temperature at which the Heat Capacity was a maximum for the lattices and the red line in a linear curve fit plotted against the data to allow the y-intercept which is the Curie Temperature for the infinite 2D lattice to be determined.

[[File:cg1417CurieTemp.png|400px|thumb|left|Figure 17 - Plot of 1/Lattice Size against Curie Temperature for that lattice size.]]

The value for <math>T_{C,\inf}</math> obtained from the data is <math>T_{C,\infty} = 2.277 \frac{J}{k_B}</math> with a literature value being <math>T_{C,\infty} = 2.269 \frac{J}{k_B}</math> for an infinite square 2D lattice. This means that my result slightly over-estimates the Curie Temperature for the infinite lattice and as a result for an infinite lattice the temperature at which spontaneous magnetisation stops would actually occur at a slightly lower temperature than expected. However, the difference between my value and the literature value is only 0.008 which is incredibly small and the amount of agreement between the two values is somewhat surprising, which means that the error in my estimates of the Curie Temperature for each lattice size is relatively small. A potential source of error from the values of the Curie Temperature for each lattice size could come from the

Rep:Y3CMPCG1417

2019-11-20T08:22:25Z

Cg1417: /* Section 3 - Introduction to Monte Carlo Simulation */

==Section 1 - Introduction to the Ising Model==

===TASK: Show that the lowest possible energy for the Ising model is <math>E = -DNJ</math>, where D is the number of dimensions and N is the total number of spins. What is the multiplicity of this state? Calculate its entropy.===

Consider a 1D row of lattice sites of N=3 with spin configuration [+1][+1][+1].

Mathematically the interaction energy is defined asː
<math> -\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} </math> where J is a constant and <math>s_{i}s_{j}</math> is the product between two spins in adjacent lattice sites.

The sum of the interaction energies <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j}</math> can be considered as the sum of the individual interaction energies between spinsː
<math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = \epsilon_{12} + \epsilon_{23} + \epsilon_{13} + \epsilon_{21} + \epsilon_{32} + \epsilon_{31} </math>.

Although lattice sites 1 and 3 are not adjacent they are said to still interact according to the periodic boundary conditions applied.

However, <math>\epsilon_{12} = \epsilon_{21} </math> and <math>\epsilon_{23} = \epsilon_{32}</math> and <math>\epsilon_{13} = \epsilon_{31}</math> which means that all of the interactions within the system are counted twice, hence the total energy needs to be halved, resulting in the following formula being obtainedː <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = 2\epsilon_{12} + 2\epsilon_{13} + 2\epsilon_{23} </math>.

It can be determined that <math>\epsilon_{12} = (+1)(+1) = 1</math> , <math>\epsilon_{13} = (+1)(+1) = 1</math> and <math>\epsilon_{23} = (+1)(+1) = 1</math>.

Thereforeː <math>-\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = -\frac{1}{2} \ J \ (2 + 2 + 2) = -\frac{1}{2} \ J \ 6 = - 3 J = -DNJ</math> for a 1D lattice with <math>D=1</math> and 3 lattice sites <math>N=3</math>

The multiplicity of the system,<math>\Omega = \frac{n. spin up!}{n. spin down!}</math>

Entropy, <math>S</math> is defined as <math>S = k_B ln(\Omega)</math> and so in this case <math>S = k_B ln(\frac{100!}{100!}) = 0</math>

===TASK: Imagine that the system is in the lowest energy configuration. To move to a different state, one of the spins must spontaneously change direction ("flip"). What is the change in energy if this happens <math>(D=3, N=1000)</math>? How much entropy does the system gain by doing soʔ===

In a 3D lattice system, each lattice site has three unique interactions with its neighbours to its left, top and front. In the lowest energy configuration, all spins are parallel and for a system the minimum energy is <math>E = -DNJ</math>, so for the system with <math>N=1000</math> and <math>D=3</math>, the minimum energy is <math>-3000J</math>.

If a single spin is flipped, the product of its spin with its neighbours spin reverses and becomes negative and this increases the total energy of the system. Since 3 unique spin-spin interactions are reversed in sign, the total energy increases by <math>+3J</math>, meaning the new total energy is <math>-2997J</math>

Initially the multiplicity of the system will be <math>\Omega = \frac{1000!}{1000!}</math> , and after the flip, the multiplicity becomes <math> \Omega = \frac{1000!}{999!1!}=1000</math>.

The associated change in entropy, <math>\Delta S = k_B ln(1000) - 0 = 6.91 k_B</math>, which is an expected increase in entropy as the number of possible configurations of the system increases.

===TASK: Calculate the magnetisation of the 1D and 2D lattices in Figure 1. What magnetisation would you expect to observe for an Ising lattice with <math>D = 3,\ N=1000</math> at absolute zero?===

[[File:ThirdYearCMPExpt-IsingSketch.png|thumb|left|Figure 1 - Shows 1D (N = 5), 2D (N = 5x5) and 3D (N = 5x5x5) lattices.]]

Magnetisation is defined as <math>M=\sum_{i} s_i</math>. So for the 1D lattice with <math>N = 5</math> in ''Figure 2'', <math>M = +1</math> and for the 2D lattice with <math>N = 25 , M = +1</math> too.

According to the 3rd Law of thermodynamics, entropy is 0 at absolute zero for a perfect crystalline solid, and consequently it is expected that the lattices will have follow suit and have zero entropy at 0K. To have zero entropy all spins must be parallel as such that magnetisation, <math>M = N</math>. For all the spins to be parallel, there is only one possible configuration. So, for a lattice with <math>N = 1000</math> and <math>D =3</math>, if <math>M = N</math>, then multiplicity, <math>\Omega = 1</math> and entropy, <math>S =k_B ln(1) = 0</math>.

 

==Section 2 - Calculating the Energy and Magnetisation==

===TASK: complete the functions energy() and magnetisation(), which should return the energy of the lattice and the total magnetisation, respectively. In the energy() function you may assume that <math>J=1.0</math> at all times (in fact, we are working in reduced units in which <math>J=k_B</math>, but there will be more information about this in later sections). Do not worry about the efficiency of the code at the moment — we will address the speed in a later part of the experiment.===

<pre>def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
lat=self.lattice #creates lattice and stores it
mag=[]
for i in range(0,len(lat)): #loops through all rows of lattice
for j in range(0,len(lat[i])): #loops through elements of each row
mag+=[lat[i][j]] #adds spin value to mag array
return sum(mag) #sums all spins from mag array
</pre>

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

lat=self.lattice #creates lattice and stores it
left=[]
top=[]

for i in range(0,len(lat)):
for j in range(0,len(lat[i])):
left+=[lat[i][j]*lat[i][j-1]] #multiplies spin by spin to left
top+=[lat[i][j]*lat[i-1][j]] #multiplies spin by spin above it
int_en=left+top #sums spin products from left and top
energy=-sum(int_en) #sums all spin products for each spin to give total

return energy
</pre>

===TASK: Run the ILcheck.py script from the IPython Qt console using the command===

''Figure 2'' shows the results when ILcheck.py was ran on my IsingLattice.py file. The ILcheck.py file was ran several times to ensure the code worked for various random lattices.

[[File:Cg1417ILcheck run.png|thumb|left|500px| Figure 2 - Result from running the ILcheck.py file]]

 

==Section 3 - Introduction to Monte Carlo Simulation==

===TASK: How many configurations are available to a system with 100 spins? To evaluate these expressions, we have to calculate the energy and magnetisation for each of these configurations, then perform the sum. Let's be very, very, generous, and say that we can analyse <math>1\times 10^9</math> configurations per second with our computer. How long will it take to evaluate a single value of <math>\left\langle M\right\rangle_T</math>?===

For a system with 100 lattice sites and two possible spins for each site, there are <math>2^{100}</math>possible configurations for the system. <math>2^{100}= 1.27\times 10^{30} </math>, so if the computer can analyse <math>1\times 10^9</math> configurations per second, then it will take <math>\frac{1.27\times 10^{30}}{10^9} = 1.27\times 10^{21} s</math> to analyse the whole system, which is longer than the age of the universe and therefore is not a practical approach.

===TASK: Implement a single cycle of the above algorithm in the montecarlocycle(T) function. This function should return the energy of your lattice and the magnetisation at the end of the cycle. You may assume that the energy returned by your energy() function is in units of <math>k_B</math>! Complete the statistics() function. This should return the following quantities whenever it is called: <math><E>, <E^2>, <M>, <M^2></math>, and the number of Monte Carlo steps that have elapsed.===
<pre>
E = []
E2 = []
M = []
M2 = []
n_cycles = 0

def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back if rejected else not changed

self.E+=[self.energy()] #records energy
self.E2+=[self.energy()**2] #records energy squared
self.M+=[self.magnetisation()] #records magnetisation
self.M2+=[self.magnetisation()**2] #records magnetisation squared
self.n_cycles=self.n_cycles+1 #adds 1 to run total

return (self.energy(),self.magnetisation())

def statistics(self):
# complete this function so that it calculates the correct values for the averages of E, E*E (E2), M, M*M (M2), and returns them

e=np.mean(self.E)
e2=np.mean(self.E2)
m=np.mean(self.M)
m2=np.mean(self.M2)

return e,e2,m,m2,self.n_cycles
</pre>

===TASK: If <math>T < T_C</math>, do you expect a spontaneous magnetisation (i.e. do you expect <math>\left\langle M\right\rangle \neq 0</math>)? When the state of the simulation appears to stop changing (when you have reached an equilibrium state), use the controls to export the output to PNG and attach this to your report. You should also include the output from your statistics() function.===

If the temperature of the system is less than the Curie Temperature, <math>T_C</math> then spontaneous magnetisation can occur and the system will tend to its lowest energy state where all of the spins are parallel - this is a property of ferromagnetic materials.

[[File:Cg1417ILanim_run.png|400px|thumb|left|Figure 3 - Results from running the ILanim.py file - shows the energy and magnetisation converging over time]]

''Figure 3'' shows that over time the the system spontaneously converges to the minimum energy state with all of the spins parallel to one another and shows, as I expected, that spontaneous magnetisation occurs and also shows that the temperature of this simulation is below the Curie Temperature, <math>T < T_C</math>.

 

==Section 4 - Accelerating the Code==

===TASK: Use the script ILtimetrial.py to record how long your current version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 4'' show the results of running the ILtimetrial.py file on my code three timesː

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1.png
| width1=500
| image2=cg1417ILtimetrial_run2.png
| width2=500
| image3=cg1417ILtimetrial_run3.png
| width3=500
| footer = Figure 4 - Results of running the ILtimetrial.py file on my code three separate times
}}
 

This gave me an avergage time of <math>24.3 s \pm 0.2s</math>

===TASK: Look at the documentation for the NumPy sum function. You should be able to modify your magnetisation() function so that it uses this to evaluate M. The energy is a little trickier. Familiarise yourself with the NumPy roll and multiply functions, and use these to replace your energy double loop (you will need to call roll and multiply twice!).===

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

left=multiply(roll(self.lattice,1,axis=1),self.lattice) #product of spin with spin left of it
top=multiply(roll(self.lattice,-1,axis=0),self.lattice) #product of spin with spin above it

int_en=sum(left+top) #sum of array containing sum of left and top spin products for each spin

energy = -sum(int_en) #calculates the total energy of system
return energy

def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
return sum(sum(self.lattice)) #adds up all spins in lattice
</pre>

===TASK: Use the script ILtimetrial.py to record how long your new version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 5'' shows the result of running the ILtimetrial.py on my new accelerated code.

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1fast.png
| width1=500
| image2=ILtimetrial_run2fast.png
| width2=500
| image3=ILtimetrial_run3fast.png
| width3=500
| footer = Figure 5 - Results of running the ILtimetrial.py file on my new updated and accelerated code.
}}
 

The accelerated code is much faster upon using the roll, multiply and s with a new average time of <math>0.790 s \pm 0.005 </math>

==Section 5 - The effect of temperature==

===TASK: The script ILfinalframe.py runs for a given number of cycles at a given temperature, then plots a depiction of the final lattice state as well as graphs of the energy and magnetisation as a function of cycle number. This is much quicker than animating every frame! Experiment with different temperature and lattice sizes. How many cycles are typically needed for the system to go from its random starting position to the equilibrium state? Modify your statistics() and montecarlostep() functions so that the first N cycles of the simulation are ignored when calculating the averages. You should state in your report what period you chose to ignore, and include graphs from ILfinalframe.py to illustrate your motivation in choosing this figure.===

''Figure 6'' below shows the results from running the ILfinalframe.py for 2x2 lattice at T=1,2,3,5.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2T1.png
| image2 = cg14172x2T2.png
| image3 =cg14172x2T3.png
| image4 =cg14172x2T5.png
| footer_align = left
| footer = Figure 6 - Results of running the ILfinalframe.py file at T=1,2,3,5 for a 2x2 matrix.
}}

 

For a 2x2 matrix, a suitable cut-off point to exclude from the avergage energies and magnetisations is where the energy and magnetisations per spin are constant, which is 30 steps. For T=3 and T=5 the graphs do not converge because it is possible that these temperatures are higher than the Curie Temperature and as such spontaneous magnetisation will not occur and the system will not diverge to the lowest energy state. At the higher temperatures, there are larger thermal fluctations and the Boltzmann factor is more significant allowing the system to move away from the lowest energy state easier. As a result moving forwards, a suitable cut-off point will only be determined from T=1 and T=2 graphs for the larger matrices.

''Figure 7'' shows the results from running a 4x4 lattice at T=1,2 and 3.

{{multiple image
| width =350
| align = left
| image1 = cg14174x4T1.png
| image2 = cg14174x4T2.png
| image3 =cg14174x4T3.png
| footer_align = left
| footer = Figure 7 - Results of running the ILfinalframe.py file at T=1,2,3 for a 4x4 matrix.
}}

From ''Figure 7'', a suitable cut-off point for the energy and magnetisations is 200 as this is after where the energy and magnetisation has converged for T=1, and is after the initial large drop in energy for T=2, even though there are a few small fluctuations after 200 steps. The result from T=3 has been included to show the large fluctuations for the larger temperatures, and supporting my choice to determine the cut-off from T=1 and T=2 only.

''Figure 8'' shows the results for an 8x8 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg14178x8T1.png
| image2 = cg14178x8T2.png
| footer_align = left
| footer = Figure 8 - Results of running the ILfinalframe.py file at T=1,2 for an 8x8 matrix
}}

From ''Figure 8'' above, a suitable cut-off point is 1000 steps as this is where the energy and magnetisation has easily converged by and is also the point after which the initial large drop in energy has been overcome for T=2 too.

''Figure 9'' shows the result of running the ILfinalframe.py for a 16x16 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg141716x16T1.png
| image2 = cg141716x16T2.png
| footer_align = left
| footer = Figure 9 - Results of running the ILfinalframe.py file at T=1,2 for a 16x16 matrix
}}

From ''Figure 9'', a suitable cut-off point is 15000 steps as for T=1 the energy and magnetisations have converged significantly and will not change much, and likewise this is the same for the T=2 frame.

''Figure 10'' below shows the results from a 32x32 matrix at T=1 and T=2.

{{multiple image
| width =350
| align = left
| image1 = cg141732x32T1.png
| image2 = cg141732x32T2.png
| footer_align = left
| footer = Figure 10 - Results of running the ILfinalframe.py file at T=1,2 for a 32x32 matrix
}}

''Figure 10'' above shows the results of running the ILfinalframe.py file for a 32x32 matrix at T=1 and T=2. As a result a suitable cut-off of 50000 steps was chosen as the energy and magnetisation has significantly converged, but not as much as it could at 100000 steps. I chose a slightly lower value to ensure that the run times of my monte-carlo simulations in future tasks were not extremely time consuming.

The montecarlostep() function was changed by adding a condition that values only above the pre-determined cut-off were included when determining the average value of energy; energy squared; magnetisation and magnetisations squared from the statistics function. The statistics() function did not need to be modified.

The following code is from the 32x32 matrixː

<pre>def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back

if self.n_cycles > 50000: #only adds values to array of E,E2,M and M2 is above specific cut-off
self.E+=[self.energy()]
self.E2+=[self.energy()**2]
self.M+=[self.magnetisation()]
self.M2+=[self.magnetisation()**2]
self.n_cycles=self.n_cycles+1

return (self.energy(),self.magnetisation())
</pre>

===TASK: Use ILtemperaturerange.py to plot the average energy and magnetisation for each temperature, with error bars, for an <math>8\times 8</math> lattice. Use your intuition and results from the script ILfinalframe.py to estimate how many cycles each simulation should be. The temperature range 0.25 to 5.0 is sufficient. Use as many temperature points as you feel necessary to illustrate the trend, but do not use a temperature spacing larger than 0.5. The NumPy function savetxt() stores your array of output data on disk — you will need it later. Save the file as 8x8.dat so that you know which lattice size it came from.===

Using the modified code, the file ILtemperaturerange.py was ran on an 8x8 matrix between T=0.5 and T=5 with a step of T=0.02 for 10000 Montecarlo steps and the first 1000 steps of each temperature were excluded when calculating the averages. ''Figure 11'' shows the result of the simulation and also included error bars of standard deviation.

[[File:Cg14178x8error.png|1000px|thumb|left|Figure 11 - Graph showing average energy and average magnetisation for an 8x8 lattice with error bars between T=0.5 and T=5]]

 

==Section 6 - The effect of system size==

===TASK: Repeat the final task of the previous section for the following lattice sizes: 2x2, 4x4, 8x8, 16x16, 32x32. Make sure that you name each datafile that your produce after the corresponding lattice size! Write a Python script to make a plot showing the energy per spin versus temperature for each of your lattice sizes. Hint: the NumPy loadtxt function is the reverse of the savetxt function, and can be used to read your previously saved files into the script. Repeat this for the magnetisation. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. How big a lattice do you think is big enough to capture the long range fluctuations?===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb.

Each matrix was simulated using the ILtemperaturerange.py file between T=0.5 and T=5 with a step of T=0.02.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2error.png
| caption1 = 2x2 matrix - 5000 steps, cut-off = 30 steps
| image2 = 4x4error.png
| caption2 = 4x4 matrix - 1000 steps, cut-off = 200 steps
| image3 =cg141716x16error.png
| caption3 = 16x16 matrix - 50000 steps, cut-off = 15000 steps
| image4 =cg141732x32error.png
| caption4 = 32x32 matrix - 200000 steps, cut-off = 50000 steps
| footer_align = left
| footer = Figure 12 - Results of running the ILtemperaturerange.py file for 2x2, 4x4, 16x16 and 32x32 matrices.
}}

 

==Section 7 - Determining the Heat Capacity==

===TASK: By definition, <math>C = \frac{\partial \left\langle E\right\rangle}{\partial T}</math>. From this, show that <math>C = \frac{\mathrm{Var}[E]}{k_B T^2}</math> (Where <math>\mathrm{Var}[E]</math> is the variance in <math>E</math>.)===

Recall from statistical thermodynamics that the average energy of a system is the sum across all microstates of the probability of that microstate multiplied by the energy of that microstate, which is defined mathematically asː <math>\langle E \rangle = \sum_i p_{i}\epsilon_{i}</math>.

The partition function <math>q</math> is defined as <math>q = \sum_{i} exp(-\beta \epsilon_{i})</math> where <math>\beta =\frac{1}{k_BT}</math>and the probability, <math>p_{i}</math> can be defined in terms of the partition function as <math>p_{i} = \frac{exp(-\beta \epsilon_{i})}{\sum_{i} exp(-\beta \epsilon_{i})} = \frac{exp(-\beta \epsilon_{i})}{q}</math>.

As a result, <math>\langle E \rangle</math> can be re-written as <math>\langle E \rangle = \sum_{i} \frac{\epsilon_{i} exp(-\beta \epsilon_{i})}{q} = -\frac{1}{q} \frac{\partial}{\partial \beta}\sum_{i}exp(-\beta \epsilon_{i}) = -\frac{1}{q} \frac{\partial q}{\partial \beta}</math>

Likewise, <math>\langle E^2 \rangle = \sum_i p_{i}\epsilon_{i}^{2} = \sum_{i} \frac{\epsilon_{i}^{2}exp(-\beta \epsilon_{i})}{q} = \frac{1}{q} \frac{\partial^{2}}{\partial \beta^{2}}\sum_{i}exp(-\beta \epsilon_{i}) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}}</math>

From definitionː <math>Var[E] = \Delta E^2 = \langle E^2 \rangle - \langle E \rangle^2 </math>

When the definition of <math>\langle E \rangle</math> and <math>\langle E^2 \rangle</math> is written in terms of partition function <math>q</math>ː <math>Var[E] = \langle E^2 \rangle - \langle E \rangle^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \left(\frac{1}{q}\frac{\partial q}{\partial \beta}\right)^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2</math>.

According to the chain ruleː <math>\frac{\partial}{\partial \beta}\left(\frac{1}{q} \frac{\partial q}{\partial \beta}\right) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2 = -\frac{\partial}{\partial \beta}\langle E \rangle = Var[E]</math>

And using the chain rule againː <math>C = \frac{\partial \langle E \rangle}{\partial T}= \left(-\frac{\partial \langle E \rangle}{\partial \beta}\right) \left(-\frac{\partial \beta}{\partial T}\right) = \frac{Var[E]}{k_B T^2}</math>

===TASK: Write a Python script to make a plot showing the heat capacity versus temperature for each of your lattice sizes from the previous section. You may need to do some research to recall the connection between the variance of a variable, <math>\mathrm{Var}[X]</math>, the mean of its square <math>\left\langle X^2\right\rangle</math>, and its squared mean <math>\left\langle X\right\rangle^2</math>. You may find that the data around the peak is very noisy — this is normal, and is a result of being in the critical region. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. ===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb

{{multiple image
| width =300
| align = left
| image1 = cg14172x2heatcap.png
| caption1 = 2x2 Matrix
| image2 = cg14174x4heatcap.png
| caption2 = 4x4 Matrix
| image3 =cg14178x8heatcap.png
| caption3 = 8x8 Matrix
| image4 =cg141716x16heatcap.png
| caption4 = 16x16 Matrix
| image5=cg141732x32heatcap.png
| caption5= 32x32 Matrix
| footer = Figure 13 - Graphs showing Heat Capacity against Temperature for each matrix size
}}

A general trend from the above graphs is that the peak of the graph shifts towards lower temperatures as the size of the matrix used increases.

==Section 8 - Locating the Curie Temperature==
===TASK: A C++ program has been used to run some much longer simulations than would be possible on the college computers in Python. You can view its source code here if you are interested. Each file contains six columns: <math>T, E, E^2, M, M^2, C</math> (the final five quantities are per spin), and you can read them with the NumPy loadtxt function as before. For each lattice size, plot the C++ data against your data. For one lattice size, save a PNG of this comparison and add it to your report — add a legend to the graph to label which is which. To do this, you will need to pass the label="..." keyword to the plot function, then call the legend() function of the axis object (documentation here).===

The python code used to read and plot the C++ data is found in the Jupyter notebook CG1417IsingModelGraphs.ipynb.

''Figure 14'' below shows the C++ plotted against my own data for a 16x16 Matrix.

[[File:Cg141716x16C++.png|400px|thumb|left|Figure 14 - Graph showing my own data against the C++ data for a 16x16 matrix.]]

 

===TASK: write a script to read the data from a particular file, and plot C vs T, as well as a fitted polynomial. Try changing the degree of the polynomial to improve the fit — in general, it might be difficult to get a good fit! Attach a PNG of an example fit to your report.===

The python script to read and plot the fitted polynomial is found in CG1417PolyfitScript.ipynb

Below in ''Figure 15'' is a plot of my Heat Capacity against Temperature data for a 16x16 matrix and features a polynomial of degree 35 plotted against it. Even with a polynomial of such a high degree, it poorly fits the curve and does not fit to the peak of the curve either.

[[File:cg1417FIT_TEST16x16_35.png|thumb|left|400px|Figure 15 - Plot of Heat Capacity against Temperature along with a poorly fitted polynomial of degree 35. ]]

 

===TASK: Modify your script from the previous section. You should still plot the whole temperature range, but fit the polynomial only to the peak of the heat capacity! You should find it easier to get a good fit when restricted to this region===

The script was modified as such that the polynomial was fitted in a set range around the peak of the graph, this is demonstrated in ''Figure 17'' which shows a newly fitted polynomial between a much smaller range of temperatures (T = 2.15-2.55) and a much smaller degree polynomial (3).

[[File:CG1417FIT_16x16C_3.png|thumb|left|400px|Figure 16 - Graph showing Heat Capacity against Temperature for a 16x16 matrix along with a fitted polynomial between a much more restricted range of temperatures and a significantly lower degree of polynomial]]

Upon comparison with ''Figure 15'', the new fitted polynomial is a significantly better fit even for a 3rd degree polynomial and is a much more accurate representation of my data around the peak of the graph and will make it easier to determine the maximum value of Heat Capacity.

 

===TASK: find the temperature at which the maximum in C occurs for each datafile that you were given. Make a text file containing two colums: the lattice side length (2,4,8, etc.), and the temperature at which C is a maximum. This is your estimate of <math>T_C</math> for that side length. Make a plot that uses the scaling relation given above to determine <math>T_{C,\infty}</math>. By doing a little research online, you should be able to find the theoretical exact Curie temperature for the infinite 2D Ising lattice. How does your value compare to this? Are you surprised by how good/bad the agreement is? Attach a PNG of this final graph to your report, and discuss briefly what you think the major sources of error are in your estimate.===

''Figure 17'' below shows a graph of <math>T_{C,L}</math> against <math>\frac{1}{Lattice Size}</math> to determine the Curie Temperature of an infinite 2D Ising Model Lattice <math>T_{C,\infty}</math>. The black dots represent the raw data obtained from obtaining the temperature at which the Heat Capacity was a maximum for the lattices and the red line in a linear curve fit plotted against the data to allow the y-intercept which is the Curie Temperature for the infinite 2D lattice to be determined.

[[File:cg1417CurieTemp.png|400px|thumb|left|Figure 17 - Plot of 1/Lattice Size against Curie Temperature for that lattice size.]]

The value for <math>T_{C,\inf}</math> obtained from the data is <math>T_{C,\infty} = 2.277 \frac{J}{k_B}</math> with a literature value being <math>T_{C,\infty} = 2.269 \frac{J}{k_B}</math> for an infinite square 2D lattice. This means that my result slightly over-estimates the Curie Temperature for the infinite lattice and as a result for an infinite lattice the temperature at which spontaneous magnetisation stops would actually occur at a slightly lower temperature than expected. However, the difference between my value and the literature value is only 0.008 which is incredibly small and the amount of agreement between the two values is somewhat surprising, which means that the error in my estimates of the Curie Temperature for each lattice size is relatively small. A potential source of error from the values of the Curie Temperature for each lattice size could come from the

Rep:Y3CMPCG1417

2019-11-20T08:21:55Z

Cg1417: /* TASK: Calculate the magnetisation of the 1D and 2D lattices in Figure 1. What magnetisation would you expect to observe for an Ising lattice with D = 3,\ N=1000 at absolute zero? */

==Section 1 - Introduction to the Ising Model==

===TASK: Show that the lowest possible energy for the Ising model is <math>E = -DNJ</math>, where D is the number of dimensions and N is the total number of spins. What is the multiplicity of this state? Calculate its entropy.===

Consider a 1D row of lattice sites of N=3 with spin configuration [+1][+1][+1].

Mathematically the interaction energy is defined asː
<math> -\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} </math> where J is a constant and <math>s_{i}s_{j}</math> is the product between two spins in adjacent lattice sites.

The sum of the interaction energies <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j}</math> can be considered as the sum of the individual interaction energies between spinsː
<math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = \epsilon_{12} + \epsilon_{23} + \epsilon_{13} + \epsilon_{21} + \epsilon_{32} + \epsilon_{31} </math>.

Although lattice sites 1 and 3 are not adjacent they are said to still interact according to the periodic boundary conditions applied.

However, <math>\epsilon_{12} = \epsilon_{21} </math> and <math>\epsilon_{23} = \epsilon_{32}</math> and <math>\epsilon_{13} = \epsilon_{31}</math> which means that all of the interactions within the system are counted twice, hence the total energy needs to be halved, resulting in the following formula being obtainedː <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = 2\epsilon_{12} + 2\epsilon_{13} + 2\epsilon_{23} </math>.

It can be determined that <math>\epsilon_{12} = (+1)(+1) = 1</math> , <math>\epsilon_{13} = (+1)(+1) = 1</math> and <math>\epsilon_{23} = (+1)(+1) = 1</math>.

Thereforeː <math>-\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = -\frac{1}{2} \ J \ (2 + 2 + 2) = -\frac{1}{2} \ J \ 6 = - 3 J = -DNJ</math> for a 1D lattice with <math>D=1</math> and 3 lattice sites <math>N=3</math>

The multiplicity of the system,<math>\Omega = \frac{n. spin up!}{n. spin down!}</math>

Entropy, <math>S</math> is defined as <math>S = k_B ln(\Omega)</math> and so in this case <math>S = k_B ln(\frac{100!}{100!}) = 0</math>

===TASK: Imagine that the system is in the lowest energy configuration. To move to a different state, one of the spins must spontaneously change direction ("flip"). What is the change in energy if this happens <math>(D=3, N=1000)</math>? How much entropy does the system gain by doing soʔ===

In a 3D lattice system, each lattice site has three unique interactions with its neighbours to its left, top and front. In the lowest energy configuration, all spins are parallel and for a system the minimum energy is <math>E = -DNJ</math>, so for the system with <math>N=1000</math> and <math>D=3</math>, the minimum energy is <math>-3000J</math>.

If a single spin is flipped, the product of its spin with its neighbours spin reverses and becomes negative and this increases the total energy of the system. Since 3 unique spin-spin interactions are reversed in sign, the total energy increases by <math>+3J</math>, meaning the new total energy is <math>-2997J</math>

Initially the multiplicity of the system will be <math>\Omega = \frac{1000!}{1000!}</math> , and after the flip, the multiplicity becomes <math> \Omega = \frac{1000!}{999!1!}=1000</math>.

The associated change in entropy, <math>\Delta S = k_B ln(1000) - 0 = 6.91 k_B</math>, which is an expected increase in entropy as the number of possible configurations of the system increases.

===TASK: Calculate the magnetisation of the 1D and 2D lattices in Figure 1. What magnetisation would you expect to observe for an Ising lattice with <math>D = 3,\ N=1000</math> at absolute zero?===

[[File:ThirdYearCMPExpt-IsingSketch.png|thumb|left|Figure 1 - Shows 1D (N = 5), 2D (N = 5x5) and 3D (N = 5x5x5) lattices.]]

Magnetisation is defined as <math>M=\sum_{i} s_i</math>. So for the 1D lattice with <math>N = 5</math> in ''Figure 2'', <math>M = +1</math> and for the 2D lattice with <math>N = 25 , M = +1</math> too.

According to the 3rd Law of thermodynamics, entropy is 0 at absolute zero for a perfect crystalline solid, and consequently it is expected that the lattices will have follow suit and have zero entropy at 0K. To have zero entropy all spins must be parallel as such that magnetisation, <math>M = N</math>. For all the spins to be parallel, there is only one possible configuration. So, for a lattice with <math>N = 1000</math> and <math>D =3</math>, if <math>M = N</math>, then multiplicity, <math>\Omega = 1</math> and entropy, <math>S =k_B ln(1) = 0</math>.

 

==Section 2 - Calculating the Energy and Magnetisation==

===TASK: complete the functions energy() and magnetisation(), which should return the energy of the lattice and the total magnetisation, respectively. In the energy() function you may assume that <math>J=1.0</math> at all times (in fact, we are working in reduced units in which <math>J=k_B</math>, but there will be more information about this in later sections). Do not worry about the efficiency of the code at the moment — we will address the speed in a later part of the experiment.===

<pre>def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
lat=self.lattice #creates lattice and stores it
mag=[]
for i in range(0,len(lat)): #loops through all rows of lattice
for j in range(0,len(lat[i])): #loops through elements of each row
mag+=[lat[i][j]] #adds spin value to mag array
return sum(mag) #sums all spins from mag array
</pre>

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

lat=self.lattice #creates lattice and stores it
left=[]
top=[]

for i in range(0,len(lat)):
for j in range(0,len(lat[i])):
left+=[lat[i][j]*lat[i][j-1]] #multiplies spin by spin to left
top+=[lat[i][j]*lat[i-1][j]] #multiplies spin by spin above it
int_en=left+top #sums spin products from left and top
energy=-sum(int_en) #sums all spin products for each spin to give total

return energy
</pre>

===TASK: Run the ILcheck.py script from the IPython Qt console using the command===

''Figure 2'' shows the results when ILcheck.py was ran on my IsingLattice.py file. The ILcheck.py file was ran several times to ensure the code worked for various random lattices.

[[File:Cg1417ILcheck run.png|thumb|left|500px| Figure 2 - Result from running the ILcheck.py file]]

 

==Section 3 - Introduction to Monte Carlo Simulation==

===TASK: How many configurations are available to a system with 100 spins? To evaluate these expressions, we have to calculate the energy and magnetisation for each of these configurations, then perform the sum. Let's be very, very, generous, and say that we can analyse <math>1\times 10^9</math> configurations per second with our computer. How long will it take to evaluate a single value of <math>\left\langle M\right\rangle_T</math>?===

For a system with 100 lattice sites and two possible spins for each site, there are <math>2^{100}</math>possible configurations for the system. <math>2^{100}= 1.27\times 10^{30} </math>, so if the computer can analyse <math>1\times 10^9</math> configurations per second, then it will take <math>\frac{1.27\times 10^{30}}{10^9} = 1.27\times 10^{21} s</math> to analyse the whole system, which is older than the age of the universe and therefore is not a practical approach.

===TASK: Implement a single cycle of the above algorithm in the montecarlocycle(T) function. This function should return the energy of your lattice and the magnetisation at the end of the cycle. You may assume that the energy returned by your energy() function is in units of <math>k_B</math>! Complete the statistics() function. This should return the following quantities whenever it is called: <math><E>, <E^2>, <M>, <M^2></math>, and the number of Monte Carlo steps that have elapsed.===
<pre>
E = []
E2 = []
M = []
M2 = []
n_cycles = 0

def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back if rejected else not changed

self.E+=[self.energy()] #records energy
self.E2+=[self.energy()**2] #records energy squared
self.M+=[self.magnetisation()] #records magnetisation
self.M2+=[self.magnetisation()**2] #records magnetisation squared
self.n_cycles=self.n_cycles+1 #adds 1 to run total

return (self.energy(),self.magnetisation())

def statistics(self):
# complete this function so that it calculates the correct values for the averages of E, E*E (E2), M, M*M (M2), and returns them

e=np.mean(self.E)
e2=np.mean(self.E2)
m=np.mean(self.M)
m2=np.mean(self.M2)

return e,e2,m,m2,self.n_cycles
</pre>

===TASK: If <math>T < T_C</math>, do you expect a spontaneous magnetisation (i.e. do you expect <math>\left\langle M\right\rangle \neq 0</math>)? When the state of the simulation appears to stop changing (when you have reached an equilibrium state), use the controls to export the output to PNG and attach this to your report. You should also include the output from your statistics() function.===

If the temperature of the system is less than the Curie Temperature, <math>T_C</math> then spontaneous magnetisation can occur and the system will tend to its lowest energy state where all of the spins are parallel - this is a property of ferromagnetic materials.

[[File:Cg1417ILanim_run.png|400px|thumb|left|Figure 3 - Results from running the ILanim.py file - shows the energy and magnetisation converging over time]]

''Figure 3'' shows that over time the the system spontaneously converges to the minimum energy state with all of the spins parallel to one another and shows, as I expected, that spontaneous magnetisation occurs and also shows that the temperature of this simulation is below the Curie Temperature, <math>T < T_C</math>.

 

==Section 4 - Accelerating the Code==

===TASK: Use the script ILtimetrial.py to record how long your current version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 4'' show the results of running the ILtimetrial.py file on my code three timesː

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1.png
| width1=500
| image2=cg1417ILtimetrial_run2.png
| width2=500
| image3=cg1417ILtimetrial_run3.png
| width3=500
| footer = Figure 4 - Results of running the ILtimetrial.py file on my code three separate times
}}
 

This gave me an avergage time of <math>24.3 s \pm 0.2s</math>

===TASK: Look at the documentation for the NumPy sum function. You should be able to modify your magnetisation() function so that it uses this to evaluate M. The energy is a little trickier. Familiarise yourself with the NumPy roll and multiply functions, and use these to replace your energy double loop (you will need to call roll and multiply twice!).===

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

left=multiply(roll(self.lattice,1,axis=1),self.lattice) #product of spin with spin left of it
top=multiply(roll(self.lattice,-1,axis=0),self.lattice) #product of spin with spin above it

int_en=sum(left+top) #sum of array containing sum of left and top spin products for each spin

energy = -sum(int_en) #calculates the total energy of system
return energy

def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
return sum(sum(self.lattice)) #adds up all spins in lattice
</pre>

===TASK: Use the script ILtimetrial.py to record how long your new version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 5'' shows the result of running the ILtimetrial.py on my new accelerated code.

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1fast.png
| width1=500
| image2=ILtimetrial_run2fast.png
| width2=500
| image3=ILtimetrial_run3fast.png
| width3=500
| footer = Figure 5 - Results of running the ILtimetrial.py file on my new updated and accelerated code.
}}
 

The accelerated code is much faster upon using the roll, multiply and s with a new average time of <math>0.790 s \pm 0.005 </math>

==Section 5 - The effect of temperature==

===TASK: The script ILfinalframe.py runs for a given number of cycles at a given temperature, then plots a depiction of the final lattice state as well as graphs of the energy and magnetisation as a function of cycle number. This is much quicker than animating every frame! Experiment with different temperature and lattice sizes. How many cycles are typically needed for the system to go from its random starting position to the equilibrium state? Modify your statistics() and montecarlostep() functions so that the first N cycles of the simulation are ignored when calculating the averages. You should state in your report what period you chose to ignore, and include graphs from ILfinalframe.py to illustrate your motivation in choosing this figure.===

''Figure 6'' below shows the results from running the ILfinalframe.py for 2x2 lattice at T=1,2,3,5.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2T1.png
| image2 = cg14172x2T2.png
| image3 =cg14172x2T3.png
| image4 =cg14172x2T5.png
| footer_align = left
| footer = Figure 6 - Results of running the ILfinalframe.py file at T=1,2,3,5 for a 2x2 matrix.
}}

 

For a 2x2 matrix, a suitable cut-off point to exclude from the avergage energies and magnetisations is where the energy and magnetisations per spin are constant, which is 30 steps. For T=3 and T=5 the graphs do not converge because it is possible that these temperatures are higher than the Curie Temperature and as such spontaneous magnetisation will not occur and the system will not diverge to the lowest energy state. At the higher temperatures, there are larger thermal fluctations and the Boltzmann factor is more significant allowing the system to move away from the lowest energy state easier. As a result moving forwards, a suitable cut-off point will only be determined from T=1 and T=2 graphs for the larger matrices.

''Figure 7'' shows the results from running a 4x4 lattice at T=1,2 and 3.

{{multiple image
| width =350
| align = left
| image1 = cg14174x4T1.png
| image2 = cg14174x4T2.png
| image3 =cg14174x4T3.png
| footer_align = left
| footer = Figure 7 - Results of running the ILfinalframe.py file at T=1,2,3 for a 4x4 matrix.
}}

From ''Figure 7'', a suitable cut-off point for the energy and magnetisations is 200 as this is after where the energy and magnetisation has converged for T=1, and is after the initial large drop in energy for T=2, even though there are a few small fluctuations after 200 steps. The result from T=3 has been included to show the large fluctuations for the larger temperatures, and supporting my choice to determine the cut-off from T=1 and T=2 only.

''Figure 8'' shows the results for an 8x8 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg14178x8T1.png
| image2 = cg14178x8T2.png
| footer_align = left
| footer = Figure 8 - Results of running the ILfinalframe.py file at T=1,2 for an 8x8 matrix
}}

From ''Figure 8'' above, a suitable cut-off point is 1000 steps as this is where the energy and magnetisation has easily converged by and is also the point after which the initial large drop in energy has been overcome for T=2 too.

''Figure 9'' shows the result of running the ILfinalframe.py for a 16x16 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg141716x16T1.png
| image2 = cg141716x16T2.png
| footer_align = left
| footer = Figure 9 - Results of running the ILfinalframe.py file at T=1,2 for a 16x16 matrix
}}

From ''Figure 9'', a suitable cut-off point is 15000 steps as for T=1 the energy and magnetisations have converged significantly and will not change much, and likewise this is the same for the T=2 frame.

''Figure 10'' below shows the results from a 32x32 matrix at T=1 and T=2.

{{multiple image
| width =350
| align = left
| image1 = cg141732x32T1.png
| image2 = cg141732x32T2.png
| footer_align = left
| footer = Figure 10 - Results of running the ILfinalframe.py file at T=1,2 for a 32x32 matrix
}}

''Figure 10'' above shows the results of running the ILfinalframe.py file for a 32x32 matrix at T=1 and T=2. As a result a suitable cut-off of 50000 steps was chosen as the energy and magnetisation has significantly converged, but not as much as it could at 100000 steps. I chose a slightly lower value to ensure that the run times of my monte-carlo simulations in future tasks were not extremely time consuming.

The montecarlostep() function was changed by adding a condition that values only above the pre-determined cut-off were included when determining the average value of energy; energy squared; magnetisation and magnetisations squared from the statistics function. The statistics() function did not need to be modified.

The following code is from the 32x32 matrixː

<pre>def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back

if self.n_cycles > 50000: #only adds values to array of E,E2,M and M2 is above specific cut-off
self.E+=[self.energy()]
self.E2+=[self.energy()**2]
self.M+=[self.magnetisation()]
self.M2+=[self.magnetisation()**2]
self.n_cycles=self.n_cycles+1

return (self.energy(),self.magnetisation())
</pre>

===TASK: Use ILtemperaturerange.py to plot the average energy and magnetisation for each temperature, with error bars, for an <math>8\times 8</math> lattice. Use your intuition and results from the script ILfinalframe.py to estimate how many cycles each simulation should be. The temperature range 0.25 to 5.0 is sufficient. Use as many temperature points as you feel necessary to illustrate the trend, but do not use a temperature spacing larger than 0.5. The NumPy function savetxt() stores your array of output data on disk — you will need it later. Save the file as 8x8.dat so that you know which lattice size it came from.===

Using the modified code, the file ILtemperaturerange.py was ran on an 8x8 matrix between T=0.5 and T=5 with a step of T=0.02 for 10000 Montecarlo steps and the first 1000 steps of each temperature were excluded when calculating the averages. ''Figure 11'' shows the result of the simulation and also included error bars of standard deviation.

[[File:Cg14178x8error.png|1000px|thumb|left|Figure 11 - Graph showing average energy and average magnetisation for an 8x8 lattice with error bars between T=0.5 and T=5]]

 

==Section 6 - The effect of system size==

===TASK: Repeat the final task of the previous section for the following lattice sizes: 2x2, 4x4, 8x8, 16x16, 32x32. Make sure that you name each datafile that your produce after the corresponding lattice size! Write a Python script to make a plot showing the energy per spin versus temperature for each of your lattice sizes. Hint: the NumPy loadtxt function is the reverse of the savetxt function, and can be used to read your previously saved files into the script. Repeat this for the magnetisation. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. How big a lattice do you think is big enough to capture the long range fluctuations?===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb.

Each matrix was simulated using the ILtemperaturerange.py file between T=0.5 and T=5 with a step of T=0.02.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2error.png
| caption1 = 2x2 matrix - 5000 steps, cut-off = 30 steps
| image2 = 4x4error.png
| caption2 = 4x4 matrix - 1000 steps, cut-off = 200 steps
| image3 =cg141716x16error.png
| caption3 = 16x16 matrix - 50000 steps, cut-off = 15000 steps
| image4 =cg141732x32error.png
| caption4 = 32x32 matrix - 200000 steps, cut-off = 50000 steps
| footer_align = left
| footer = Figure 12 - Results of running the ILtemperaturerange.py file for 2x2, 4x4, 16x16 and 32x32 matrices.
}}

 

==Section 7 - Determining the Heat Capacity==

===TASK: By definition, <math>C = \frac{\partial \left\langle E\right\rangle}{\partial T}</math>. From this, show that <math>C = \frac{\mathrm{Var}[E]}{k_B T^2}</math> (Where <math>\mathrm{Var}[E]</math> is the variance in <math>E</math>.)===

Recall from statistical thermodynamics that the average energy of a system is the sum across all microstates of the probability of that microstate multiplied by the energy of that microstate, which is defined mathematically asː <math>\langle E \rangle = \sum_i p_{i}\epsilon_{i}</math>.

The partition function <math>q</math> is defined as <math>q = \sum_{i} exp(-\beta \epsilon_{i})</math> where <math>\beta =\frac{1}{k_BT}</math>and the probability, <math>p_{i}</math> can be defined in terms of the partition function as <math>p_{i} = \frac{exp(-\beta \epsilon_{i})}{\sum_{i} exp(-\beta \epsilon_{i})} = \frac{exp(-\beta \epsilon_{i})}{q}</math>.

As a result, <math>\langle E \rangle</math> can be re-written as <math>\langle E \rangle = \sum_{i} \frac{\epsilon_{i} exp(-\beta \epsilon_{i})}{q} = -\frac{1}{q} \frac{\partial}{\partial \beta}\sum_{i}exp(-\beta \epsilon_{i}) = -\frac{1}{q} \frac{\partial q}{\partial \beta}</math>

Likewise, <math>\langle E^2 \rangle = \sum_i p_{i}\epsilon_{i}^{2} = \sum_{i} \frac{\epsilon_{i}^{2}exp(-\beta \epsilon_{i})}{q} = \frac{1}{q} \frac{\partial^{2}}{\partial \beta^{2}}\sum_{i}exp(-\beta \epsilon_{i}) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}}</math>

From definitionː <math>Var[E] = \Delta E^2 = \langle E^2 \rangle - \langle E \rangle^2 </math>

When the definition of <math>\langle E \rangle</math> and <math>\langle E^2 \rangle</math> is written in terms of partition function <math>q</math>ː <math>Var[E] = \langle E^2 \rangle - \langle E \rangle^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \left(\frac{1}{q}\frac{\partial q}{\partial \beta}\right)^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2</math>.

According to the chain ruleː <math>\frac{\partial}{\partial \beta}\left(\frac{1}{q} \frac{\partial q}{\partial \beta}\right) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2 = -\frac{\partial}{\partial \beta}\langle E \rangle = Var[E]</math>

And using the chain rule againː <math>C = \frac{\partial \langle E \rangle}{\partial T}= \left(-\frac{\partial \langle E \rangle}{\partial \beta}\right) \left(-\frac{\partial \beta}{\partial T}\right) = \frac{Var[E]}{k_B T^2}</math>

===TASK: Write a Python script to make a plot showing the heat capacity versus temperature for each of your lattice sizes from the previous section. You may need to do some research to recall the connection between the variance of a variable, <math>\mathrm{Var}[X]</math>, the mean of its square <math>\left\langle X^2\right\rangle</math>, and its squared mean <math>\left\langle X\right\rangle^2</math>. You may find that the data around the peak is very noisy — this is normal, and is a result of being in the critical region. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. ===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb

{{multiple image
| width =300
| align = left
| image1 = cg14172x2heatcap.png
| caption1 = 2x2 Matrix
| image2 = cg14174x4heatcap.png
| caption2 = 4x4 Matrix
| image3 =cg14178x8heatcap.png
| caption3 = 8x8 Matrix
| image4 =cg141716x16heatcap.png
| caption4 = 16x16 Matrix
| image5=cg141732x32heatcap.png
| caption5= 32x32 Matrix
| footer = Figure 13 - Graphs showing Heat Capacity against Temperature for each matrix size
}}

A general trend from the above graphs is that the peak of the graph shifts towards lower temperatures as the size of the matrix used increases.

==Section 8 - Locating the Curie Temperature==
===TASK: A C++ program has been used to run some much longer simulations than would be possible on the college computers in Python. You can view its source code here if you are interested. Each file contains six columns: <math>T, E, E^2, M, M^2, C</math> (the final five quantities are per spin), and you can read them with the NumPy loadtxt function as before. For each lattice size, plot the C++ data against your data. For one lattice size, save a PNG of this comparison and add it to your report — add a legend to the graph to label which is which. To do this, you will need to pass the label="..." keyword to the plot function, then call the legend() function of the axis object (documentation here).===

The python code used to read and plot the C++ data is found in the Jupyter notebook CG1417IsingModelGraphs.ipynb.

''Figure 14'' below shows the C++ plotted against my own data for a 16x16 Matrix.

[[File:Cg141716x16C++.png|400px|thumb|left|Figure 14 - Graph showing my own data against the C++ data for a 16x16 matrix.]]

 

===TASK: write a script to read the data from a particular file, and plot C vs T, as well as a fitted polynomial. Try changing the degree of the polynomial to improve the fit — in general, it might be difficult to get a good fit! Attach a PNG of an example fit to your report.===

The python script to read and plot the fitted polynomial is found in CG1417PolyfitScript.ipynb

Below in ''Figure 15'' is a plot of my Heat Capacity against Temperature data for a 16x16 matrix and features a polynomial of degree 35 plotted against it. Even with a polynomial of such a high degree, it poorly fits the curve and does not fit to the peak of the curve either.

[[File:cg1417FIT_TEST16x16_35.png|thumb|left|400px|Figure 15 - Plot of Heat Capacity against Temperature along with a poorly fitted polynomial of degree 35. ]]

 

===TASK: Modify your script from the previous section. You should still plot the whole temperature range, but fit the polynomial only to the peak of the heat capacity! You should find it easier to get a good fit when restricted to this region===

The script was modified as such that the polynomial was fitted in a set range around the peak of the graph, this is demonstrated in ''Figure 17'' which shows a newly fitted polynomial between a much smaller range of temperatures (T = 2.15-2.55) and a much smaller degree polynomial (3).

[[File:CG1417FIT_16x16C_3.png|thumb|left|400px|Figure 16 - Graph showing Heat Capacity against Temperature for a 16x16 matrix along with a fitted polynomial between a much more restricted range of temperatures and a significantly lower degree of polynomial]]

Upon comparison with ''Figure 15'', the new fitted polynomial is a significantly better fit even for a 3rd degree polynomial and is a much more accurate representation of my data around the peak of the graph and will make it easier to determine the maximum value of Heat Capacity.

 

===TASK: find the temperature at which the maximum in C occurs for each datafile that you were given. Make a text file containing two colums: the lattice side length (2,4,8, etc.), and the temperature at which C is a maximum. This is your estimate of <math>T_C</math> for that side length. Make a plot that uses the scaling relation given above to determine <math>T_{C,\infty}</math>. By doing a little research online, you should be able to find the theoretical exact Curie temperature for the infinite 2D Ising lattice. How does your value compare to this? Are you surprised by how good/bad the agreement is? Attach a PNG of this final graph to your report, and discuss briefly what you think the major sources of error are in your estimate.===

''Figure 17'' below shows a graph of <math>T_{C,L}</math> against <math>\frac{1}{Lattice Size}</math> to determine the Curie Temperature of an infinite 2D Ising Model Lattice <math>T_{C,\infty}</math>. The black dots represent the raw data obtained from obtaining the temperature at which the Heat Capacity was a maximum for the lattices and the red line in a linear curve fit plotted against the data to allow the y-intercept which is the Curie Temperature for the infinite 2D lattice to be determined.

[[File:cg1417CurieTemp.png|400px|thumb|left|Figure 17 - Plot of 1/Lattice Size against Curie Temperature for that lattice size.]]

The value for <math>T_{C,\inf}</math> obtained from the data is <math>T_{C,\infty} = 2.277 \frac{J}{k_B}</math> with a literature value being <math>T_{C,\infty} = 2.269 \frac{J}{k_B}</math> for an infinite square 2D lattice. This means that my result slightly over-estimates the Curie Temperature for the infinite lattice and as a result for an infinite lattice the temperature at which spontaneous magnetisation stops would actually occur at a slightly lower temperature than expected. However, the difference between my value and the literature value is only 0.008 which is incredibly small and the amount of agreement between the two values is somewhat surprising, which means that the error in my estimates of the Curie Temperature for each lattice size is relatively small. A potential source of error from the values of the Curie Temperature for each lattice size could come from the

Rep:Y3CMPCG1417

2019-11-20T08:21:09Z

Cg1417: /* Section 1 - Introduction to the Ising Model */

==Section 1 - Introduction to the Ising Model==

===TASK: Show that the lowest possible energy for the Ising model is <math>E = -DNJ</math>, where D is the number of dimensions and N is the total number of spins. What is the multiplicity of this state? Calculate its entropy.===

Consider a 1D row of lattice sites of N=3 with spin configuration [+1][+1][+1].

Mathematically the interaction energy is defined asː
<math> -\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} </math> where J is a constant and <math>s_{i}s_{j}</math> is the product between two spins in adjacent lattice sites.

The sum of the interaction energies <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j}</math> can be considered as the sum of the individual interaction energies between spinsː
<math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = \epsilon_{12} + \epsilon_{23} + \epsilon_{13} + \epsilon_{21} + \epsilon_{32} + \epsilon_{31} </math>.

Although lattice sites 1 and 3 are not adjacent they are said to still interact according to the periodic boundary conditions applied.

However, <math>\epsilon_{12} = \epsilon_{21} </math> and <math>\epsilon_{23} = \epsilon_{32}</math> and <math>\epsilon_{13} = \epsilon_{31}</math> which means that all of the interactions within the system are counted twice, hence the total energy needs to be halved, resulting in the following formula being obtainedː <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = 2\epsilon_{12} + 2\epsilon_{13} + 2\epsilon_{23} </math>.

It can be determined that <math>\epsilon_{12} = (+1)(+1) = 1</math> , <math>\epsilon_{13} = (+1)(+1) = 1</math> and <math>\epsilon_{23} = (+1)(+1) = 1</math>.

Thereforeː <math>-\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = -\frac{1}{2} \ J \ (2 + 2 + 2) = -\frac{1}{2} \ J \ 6 = - 3 J = -DNJ</math> for a 1D lattice with <math>D=1</math> and 3 lattice sites <math>N=3</math>

The multiplicity of the system,<math>\Omega = \frac{n. spin up!}{n. spin down!}</math>

Entropy, <math>S</math> is defined as <math>S = k_B ln(\Omega)</math> and so in this case <math>S = k_B ln(\frac{100!}{100!}) = 0</math>

===TASK: Imagine that the system is in the lowest energy configuration. To move to a different state, one of the spins must spontaneously change direction ("flip"). What is the change in energy if this happens <math>(D=3, N=1000)</math>? How much entropy does the system gain by doing soʔ===

In a 3D lattice system, each lattice site has three unique interactions with its neighbours to its left, top and front. In the lowest energy configuration, all spins are parallel and for a system the minimum energy is <math>E = -DNJ</math>, so for the system with <math>N=1000</math> and <math>D=3</math>, the minimum energy is <math>-3000J</math>.

If a single spin is flipped, the product of its spin with its neighbours spin reverses and becomes negative and this increases the total energy of the system. Since 3 unique spin-spin interactions are reversed in sign, the total energy increases by <math>+3J</math>, meaning the new total energy is <math>-2997J</math>

Initially the multiplicity of the system will be <math>\Omega = \frac{1000!}{1000!}</math> , and after the flip, the multiplicity becomes <math> \Omega = \frac{1000!}{999!1!}=1000</math>.

The associated change in entropy, <math>\Delta S = k_B ln(1000) - 0 = 6.91 k_B</math>, which is an expected increase in entropy as the number of possible configurations of the system increases.

===TASK: Calculate the magnetisation of the 1D and 2D lattices in Figure 1. What magnetisation would you expect to observe for an Ising lattice with <math>D = 3,\ N=1000</math> at absolute zero?===

[[File:ThirdYearCMPExpt-IsingSketch.png|thumb|left|Figure 1 - Shows 1D (N = 5), 2D (N = 5x5) and 3D (N = 5x5x5) lattices.]]

Magnetisation is defined as <math>M=\sum_{i} s_i</math>. So for the 1D lattice with <math>N = 5</math> in ''Figure 2'', <math>M = +1</math> and for the 2D lattice with <math>N = 25 , M = +1</math> too.

According to the 3rd Law of thermodynamics, entropy is 0 at absolute zero for a perfect crystalline solid, and consequently it is expected that the lattices will have follow suit and have zero entropy at 0K. To have zero entropy all spins must be parallel as such that magnetisation, <math>M = N</math>. For all the spins to be parallel, there is only one possible configuration. So, for a lattice with <math>N = 1000</math> and <math>D =3</math>, if <math>M = N</math>, then multiplicity, <math>\Omega = 1</math> and entropy, <math>S =k_B ln(1) = 0</math>.

==Section 2 - Calculating the Energy and Magnetisation==

===TASK: complete the functions energy() and magnetisation(), which should return the energy of the lattice and the total magnetisation, respectively. In the energy() function you may assume that <math>J=1.0</math> at all times (in fact, we are working in reduced units in which <math>J=k_B</math>, but there will be more information about this in later sections). Do not worry about the efficiency of the code at the moment — we will address the speed in a later part of the experiment.===

<pre>def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
lat=self.lattice #creates lattice and stores it
mag=[]
for i in range(0,len(lat)): #loops through all rows of lattice
for j in range(0,len(lat[i])): #loops through elements of each row
mag+=[lat[i][j]] #adds spin value to mag array
return sum(mag) #sums all spins from mag array
</pre>

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

lat=self.lattice #creates lattice and stores it
left=[]
top=[]

for i in range(0,len(lat)):
for j in range(0,len(lat[i])):
left+=[lat[i][j]*lat[i][j-1]] #multiplies spin by spin to left
top+=[lat[i][j]*lat[i-1][j]] #multiplies spin by spin above it
int_en=left+top #sums spin products from left and top
energy=-sum(int_en) #sums all spin products for each spin to give total

return energy
</pre>

===TASK: Run the ILcheck.py script from the IPython Qt console using the command===

''Figure 2'' shows the results when ILcheck.py was ran on my IsingLattice.py file. The ILcheck.py file was ran several times to ensure the code worked for various random lattices.

[[File:Cg1417ILcheck run.png|thumb|left|500px| Figure 2 - Result from running the ILcheck.py file]]

 

==Section 3 - Introduction to Monte Carlo Simulation==

===TASK: How many configurations are available to a system with 100 spins? To evaluate these expressions, we have to calculate the energy and magnetisation for each of these configurations, then perform the sum. Let's be very, very, generous, and say that we can analyse <math>1\times 10^9</math> configurations per second with our computer. How long will it take to evaluate a single value of <math>\left\langle M\right\rangle_T</math>?===

For a system with 100 lattice sites and two possible spins for each site, there are <math>2^{100}</math>possible configurations for the system. <math>2^{100}= 1.27\times 10^{30} </math>, so if the computer can analyse <math>1\times 10^9</math> configurations per second, then it will take <math>\frac{1.27\times 10^{30}}{10^9} = 1.27\times 10^{21} s</math> to analyse the whole system, which is older than the age of the universe and therefore is not a practical approach.

===TASK: Implement a single cycle of the above algorithm in the montecarlocycle(T) function. This function should return the energy of your lattice and the magnetisation at the end of the cycle. You may assume that the energy returned by your energy() function is in units of <math>k_B</math>! Complete the statistics() function. This should return the following quantities whenever it is called: <math><E>, <E^2>, <M>, <M^2></math>, and the number of Monte Carlo steps that have elapsed.===
<pre>
E = []
E2 = []
M = []
M2 = []
n_cycles = 0

def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back if rejected else not changed

self.E+=[self.energy()] #records energy
self.E2+=[self.energy()**2] #records energy squared
self.M+=[self.magnetisation()] #records magnetisation
self.M2+=[self.magnetisation()**2] #records magnetisation squared
self.n_cycles=self.n_cycles+1 #adds 1 to run total

return (self.energy(),self.magnetisation())

def statistics(self):
# complete this function so that it calculates the correct values for the averages of E, E*E (E2), M, M*M (M2), and returns them

e=np.mean(self.E)
e2=np.mean(self.E2)
m=np.mean(self.M)
m2=np.mean(self.M2)

return e,e2,m,m2,self.n_cycles
</pre>

===TASK: If <math>T < T_C</math>, do you expect a spontaneous magnetisation (i.e. do you expect <math>\left\langle M\right\rangle \neq 0</math>)? When the state of the simulation appears to stop changing (when you have reached an equilibrium state), use the controls to export the output to PNG and attach this to your report. You should also include the output from your statistics() function.===

If the temperature of the system is less than the Curie Temperature, <math>T_C</math> then spontaneous magnetisation can occur and the system will tend to its lowest energy state where all of the spins are parallel - this is a property of ferromagnetic materials.

[[File:Cg1417ILanim_run.png|400px|thumb|left|Figure 3 - Results from running the ILanim.py file - shows the energy and magnetisation converging over time]]

''Figure 3'' shows that over time the the system spontaneously converges to the minimum energy state with all of the spins parallel to one another and shows, as I expected, that spontaneous magnetisation occurs and also shows that the temperature of this simulation is below the Curie Temperature, <math>T < T_C</math>.

 

==Section 4 - Accelerating the Code==

===TASK: Use the script ILtimetrial.py to record how long your current version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 4'' show the results of running the ILtimetrial.py file on my code three timesː

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1.png
| width1=500
| image2=cg1417ILtimetrial_run2.png
| width2=500
| image3=cg1417ILtimetrial_run3.png
| width3=500
| footer = Figure 4 - Results of running the ILtimetrial.py file on my code three separate times
}}
 

This gave me an avergage time of <math>24.3 s \pm 0.2s</math>

===TASK: Look at the documentation for the NumPy sum function. You should be able to modify your magnetisation() function so that it uses this to evaluate M. The energy is a little trickier. Familiarise yourself with the NumPy roll and multiply functions, and use these to replace your energy double loop (you will need to call roll and multiply twice!).===

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

left=multiply(roll(self.lattice,1,axis=1),self.lattice) #product of spin with spin left of it
top=multiply(roll(self.lattice,-1,axis=0),self.lattice) #product of spin with spin above it

int_en=sum(left+top) #sum of array containing sum of left and top spin products for each spin

energy = -sum(int_en) #calculates the total energy of system
return energy

def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
return sum(sum(self.lattice)) #adds up all spins in lattice
</pre>

===TASK: Use the script ILtimetrial.py to record how long your new version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 5'' shows the result of running the ILtimetrial.py on my new accelerated code.

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1fast.png
| width1=500
| image2=ILtimetrial_run2fast.png
| width2=500
| image3=ILtimetrial_run3fast.png
| width3=500
| footer = Figure 5 - Results of running the ILtimetrial.py file on my new updated and accelerated code.
}}
 

The accelerated code is much faster upon using the roll, multiply and s with a new average time of <math>0.790 s \pm 0.005 </math>

==Section 5 - The effect of temperature==

===TASK: The script ILfinalframe.py runs for a given number of cycles at a given temperature, then plots a depiction of the final lattice state as well as graphs of the energy and magnetisation as a function of cycle number. This is much quicker than animating every frame! Experiment with different temperature and lattice sizes. How many cycles are typically needed for the system to go from its random starting position to the equilibrium state? Modify your statistics() and montecarlostep() functions so that the first N cycles of the simulation are ignored when calculating the averages. You should state in your report what period you chose to ignore, and include graphs from ILfinalframe.py to illustrate your motivation in choosing this figure.===

''Figure 6'' below shows the results from running the ILfinalframe.py for 2x2 lattice at T=1,2,3,5.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2T1.png
| image2 = cg14172x2T2.png
| image3 =cg14172x2T3.png
| image4 =cg14172x2T5.png
| footer_align = left
| footer = Figure 6 - Results of running the ILfinalframe.py file at T=1,2,3,5 for a 2x2 matrix.
}}

 

For a 2x2 matrix, a suitable cut-off point to exclude from the avergage energies and magnetisations is where the energy and magnetisations per spin are constant, which is 30 steps. For T=3 and T=5 the graphs do not converge because it is possible that these temperatures are higher than the Curie Temperature and as such spontaneous magnetisation will not occur and the system will not diverge to the lowest energy state. At the higher temperatures, there are larger thermal fluctations and the Boltzmann factor is more significant allowing the system to move away from the lowest energy state easier. As a result moving forwards, a suitable cut-off point will only be determined from T=1 and T=2 graphs for the larger matrices.

''Figure 7'' shows the results from running a 4x4 lattice at T=1,2 and 3.

{{multiple image
| width =350
| align = left
| image1 = cg14174x4T1.png
| image2 = cg14174x4T2.png
| image3 =cg14174x4T3.png
| footer_align = left
| footer = Figure 7 - Results of running the ILfinalframe.py file at T=1,2,3 for a 4x4 matrix.
}}

From ''Figure 7'', a suitable cut-off point for the energy and magnetisations is 200 as this is after where the energy and magnetisation has converged for T=1, and is after the initial large drop in energy for T=2, even though there are a few small fluctuations after 200 steps. The result from T=3 has been included to show the large fluctuations for the larger temperatures, and supporting my choice to determine the cut-off from T=1 and T=2 only.

''Figure 8'' shows the results for an 8x8 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg14178x8T1.png
| image2 = cg14178x8T2.png
| footer_align = left
| footer = Figure 8 - Results of running the ILfinalframe.py file at T=1,2 for an 8x8 matrix
}}

From ''Figure 8'' above, a suitable cut-off point is 1000 steps as this is where the energy and magnetisation has easily converged by and is also the point after which the initial large drop in energy has been overcome for T=2 too.

''Figure 9'' shows the result of running the ILfinalframe.py for a 16x16 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg141716x16T1.png
| image2 = cg141716x16T2.png
| footer_align = left
| footer = Figure 9 - Results of running the ILfinalframe.py file at T=1,2 for a 16x16 matrix
}}

From ''Figure 9'', a suitable cut-off point is 15000 steps as for T=1 the energy and magnetisations have converged significantly and will not change much, and likewise this is the same for the T=2 frame.

''Figure 10'' below shows the results from a 32x32 matrix at T=1 and T=2.

{{multiple image
| width =350
| align = left
| image1 = cg141732x32T1.png
| image2 = cg141732x32T2.png
| footer_align = left
| footer = Figure 10 - Results of running the ILfinalframe.py file at T=1,2 for a 32x32 matrix
}}

''Figure 10'' above shows the results of running the ILfinalframe.py file for a 32x32 matrix at T=1 and T=2. As a result a suitable cut-off of 50000 steps was chosen as the energy and magnetisation has significantly converged, but not as much as it could at 100000 steps. I chose a slightly lower value to ensure that the run times of my monte-carlo simulations in future tasks were not extremely time consuming.

The montecarlostep() function was changed by adding a condition that values only above the pre-determined cut-off were included when determining the average value of energy; energy squared; magnetisation and magnetisations squared from the statistics function. The statistics() function did not need to be modified.

The following code is from the 32x32 matrixː

<pre>def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back

if self.n_cycles > 50000: #only adds values to array of E,E2,M and M2 is above specific cut-off
self.E+=[self.energy()]
self.E2+=[self.energy()**2]
self.M+=[self.magnetisation()]
self.M2+=[self.magnetisation()**2]
self.n_cycles=self.n_cycles+1

return (self.energy(),self.magnetisation())
</pre>

===TASK: Use ILtemperaturerange.py to plot the average energy and magnetisation for each temperature, with error bars, for an <math>8\times 8</math> lattice. Use your intuition and results from the script ILfinalframe.py to estimate how many cycles each simulation should be. The temperature range 0.25 to 5.0 is sufficient. Use as many temperature points as you feel necessary to illustrate the trend, but do not use a temperature spacing larger than 0.5. The NumPy function savetxt() stores your array of output data on disk — you will need it later. Save the file as 8x8.dat so that you know which lattice size it came from.===

Using the modified code, the file ILtemperaturerange.py was ran on an 8x8 matrix between T=0.5 and T=5 with a step of T=0.02 for 10000 Montecarlo steps and the first 1000 steps of each temperature were excluded when calculating the averages. ''Figure 11'' shows the result of the simulation and also included error bars of standard deviation.

[[File:Cg14178x8error.png|1000px|thumb|left|Figure 11 - Graph showing average energy and average magnetisation for an 8x8 lattice with error bars between T=0.5 and T=5]]

 

==Section 6 - The effect of system size==

===TASK: Repeat the final task of the previous section for the following lattice sizes: 2x2, 4x4, 8x8, 16x16, 32x32. Make sure that you name each datafile that your produce after the corresponding lattice size! Write a Python script to make a plot showing the energy per spin versus temperature for each of your lattice sizes. Hint: the NumPy loadtxt function is the reverse of the savetxt function, and can be used to read your previously saved files into the script. Repeat this for the magnetisation. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. How big a lattice do you think is big enough to capture the long range fluctuations?===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb.

Each matrix was simulated using the ILtemperaturerange.py file between T=0.5 and T=5 with a step of T=0.02.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2error.png
| caption1 = 2x2 matrix - 5000 steps, cut-off = 30 steps
| image2 = 4x4error.png
| caption2 = 4x4 matrix - 1000 steps, cut-off = 200 steps
| image3 =cg141716x16error.png
| caption3 = 16x16 matrix - 50000 steps, cut-off = 15000 steps
| image4 =cg141732x32error.png
| caption4 = 32x32 matrix - 200000 steps, cut-off = 50000 steps
| footer_align = left
| footer = Figure 12 - Results of running the ILtemperaturerange.py file for 2x2, 4x4, 16x16 and 32x32 matrices.
}}

 

==Section 7 - Determining the Heat Capacity==

===TASK: By definition, <math>C = \frac{\partial \left\langle E\right\rangle}{\partial T}</math>. From this, show that <math>C = \frac{\mathrm{Var}[E]}{k_B T^2}</math> (Where <math>\mathrm{Var}[E]</math> is the variance in <math>E</math>.)===

Recall from statistical thermodynamics that the average energy of a system is the sum across all microstates of the probability of that microstate multiplied by the energy of that microstate, which is defined mathematically asː <math>\langle E \rangle = \sum_i p_{i}\epsilon_{i}</math>.

The partition function <math>q</math> is defined as <math>q = \sum_{i} exp(-\beta \epsilon_{i})</math> where <math>\beta =\frac{1}{k_BT}</math>and the probability, <math>p_{i}</math> can be defined in terms of the partition function as <math>p_{i} = \frac{exp(-\beta \epsilon_{i})}{\sum_{i} exp(-\beta \epsilon_{i})} = \frac{exp(-\beta \epsilon_{i})}{q}</math>.

As a result, <math>\langle E \rangle</math> can be re-written as <math>\langle E \rangle = \sum_{i} \frac{\epsilon_{i} exp(-\beta \epsilon_{i})}{q} = -\frac{1}{q} \frac{\partial}{\partial \beta}\sum_{i}exp(-\beta \epsilon_{i}) = -\frac{1}{q} \frac{\partial q}{\partial \beta}</math>

Likewise, <math>\langle E^2 \rangle = \sum_i p_{i}\epsilon_{i}^{2} = \sum_{i} \frac{\epsilon_{i}^{2}exp(-\beta \epsilon_{i})}{q} = \frac{1}{q} \frac{\partial^{2}}{\partial \beta^{2}}\sum_{i}exp(-\beta \epsilon_{i}) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}}</math>

From definitionː <math>Var[E] = \Delta E^2 = \langle E^2 \rangle - \langle E \rangle^2 </math>

When the definition of <math>\langle E \rangle</math> and <math>\langle E^2 \rangle</math> is written in terms of partition function <math>q</math>ː <math>Var[E] = \langle E^2 \rangle - \langle E \rangle^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \left(\frac{1}{q}\frac{\partial q}{\partial \beta}\right)^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2</math>.

According to the chain ruleː <math>\frac{\partial}{\partial \beta}\left(\frac{1}{q} \frac{\partial q}{\partial \beta}\right) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2 = -\frac{\partial}{\partial \beta}\langle E \rangle = Var[E]</math>

And using the chain rule againː <math>C = \frac{\partial \langle E \rangle}{\partial T}= \left(-\frac{\partial \langle E \rangle}{\partial \beta}\right) \left(-\frac{\partial \beta}{\partial T}\right) = \frac{Var[E]}{k_B T^2}</math>

===TASK: Write a Python script to make a plot showing the heat capacity versus temperature for each of your lattice sizes from the previous section. You may need to do some research to recall the connection between the variance of a variable, <math>\mathrm{Var}[X]</math>, the mean of its square <math>\left\langle X^2\right\rangle</math>, and its squared mean <math>\left\langle X\right\rangle^2</math>. You may find that the data around the peak is very noisy — this is normal, and is a result of being in the critical region. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. ===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb

{{multiple image
| width =300
| align = left
| image1 = cg14172x2heatcap.png
| caption1 = 2x2 Matrix
| image2 = cg14174x4heatcap.png
| caption2 = 4x4 Matrix
| image3 =cg14178x8heatcap.png
| caption3 = 8x8 Matrix
| image4 =cg141716x16heatcap.png
| caption4 = 16x16 Matrix
| image5=cg141732x32heatcap.png
| caption5= 32x32 Matrix
| footer = Figure 13 - Graphs showing Heat Capacity against Temperature for each matrix size
}}

A general trend from the above graphs is that the peak of the graph shifts towards lower temperatures as the size of the matrix used increases.

==Section 8 - Locating the Curie Temperature==
===TASK: A C++ program has been used to run some much longer simulations than would be possible on the college computers in Python. You can view its source code here if you are interested. Each file contains six columns: <math>T, E, E^2, M, M^2, C</math> (the final five quantities are per spin), and you can read them with the NumPy loadtxt function as before. For each lattice size, plot the C++ data against your data. For one lattice size, save a PNG of this comparison and add it to your report — add a legend to the graph to label which is which. To do this, you will need to pass the label="..." keyword to the plot function, then call the legend() function of the axis object (documentation here).===

The python code used to read and plot the C++ data is found in the Jupyter notebook CG1417IsingModelGraphs.ipynb.

''Figure 14'' below shows the C++ plotted against my own data for a 16x16 Matrix.

[[File:Cg141716x16C++.png|400px|thumb|left|Figure 14 - Graph showing my own data against the C++ data for a 16x16 matrix.]]

 

===TASK: write a script to read the data from a particular file, and plot C vs T, as well as a fitted polynomial. Try changing the degree of the polynomial to improve the fit — in general, it might be difficult to get a good fit! Attach a PNG of an example fit to your report.===

The python script to read and plot the fitted polynomial is found in CG1417PolyfitScript.ipynb

Below in ''Figure 15'' is a plot of my Heat Capacity against Temperature data for a 16x16 matrix and features a polynomial of degree 35 plotted against it. Even with a polynomial of such a high degree, it poorly fits the curve and does not fit to the peak of the curve either.

[[File:cg1417FIT_TEST16x16_35.png|thumb|left|400px|Figure 15 - Plot of Heat Capacity against Temperature along with a poorly fitted polynomial of degree 35. ]]

 

===TASK: Modify your script from the previous section. You should still plot the whole temperature range, but fit the polynomial only to the peak of the heat capacity! You should find it easier to get a good fit when restricted to this region===

The script was modified as such that the polynomial was fitted in a set range around the peak of the graph, this is demonstrated in ''Figure 17'' which shows a newly fitted polynomial between a much smaller range of temperatures (T = 2.15-2.55) and a much smaller degree polynomial (3).

[[File:CG1417FIT_16x16C_3.png|thumb|left|400px|Figure 16 - Graph showing Heat Capacity against Temperature for a 16x16 matrix along with a fitted polynomial between a much more restricted range of temperatures and a significantly lower degree of polynomial]]

Upon comparison with ''Figure 15'', the new fitted polynomial is a significantly better fit even for a 3rd degree polynomial and is a much more accurate representation of my data around the peak of the graph and will make it easier to determine the maximum value of Heat Capacity.

 

===TASK: find the temperature at which the maximum in C occurs for each datafile that you were given. Make a text file containing two colums: the lattice side length (2,4,8, etc.), and the temperature at which C is a maximum. This is your estimate of <math>T_C</math> for that side length. Make a plot that uses the scaling relation given above to determine <math>T_{C,\infty}</math>. By doing a little research online, you should be able to find the theoretical exact Curie temperature for the infinite 2D Ising lattice. How does your value compare to this? Are you surprised by how good/bad the agreement is? Attach a PNG of this final graph to your report, and discuss briefly what you think the major sources of error are in your estimate.===

''Figure 17'' below shows a graph of <math>T_{C,L}</math> against <math>\frac{1}{Lattice Size}</math> to determine the Curie Temperature of an infinite 2D Ising Model Lattice <math>T_{C,\infty}</math>. The black dots represent the raw data obtained from obtaining the temperature at which the Heat Capacity was a maximum for the lattices and the red line in a linear curve fit plotted against the data to allow the y-intercept which is the Curie Temperature for the infinite 2D lattice to be determined.

[[File:cg1417CurieTemp.png|400px|thumb|left|Figure 17 - Plot of 1/Lattice Size against Curie Temperature for that lattice size.]]

The value for <math>T_{C,\inf}</math> obtained from the data is <math>T_{C,\infty} = 2.277 \frac{J}{k_B}</math> with a literature value being <math>T_{C,\infty} = 2.269 \frac{J}{k_B}</math> for an infinite square 2D lattice. This means that my result slightly over-estimates the Curie Temperature for the infinite lattice and as a result for an infinite lattice the temperature at which spontaneous magnetisation stops would actually occur at a slightly lower temperature than expected. However, the difference between my value and the literature value is only 0.008 which is incredibly small and the amount of agreement between the two values is somewhat surprising, which means that the error in my estimates of the Curie Temperature for each lattice size is relatively small. A potential source of error from the values of the Curie Temperature for each lattice size could come from the

Rep:Y3CMPCG1417

2019-11-20T07:56:47Z

==Section 1 - Introduction to the Ising Model==

===TASK: Show that the lowest possible energy for the Ising model is <math>E = -DNJ</math>, where D is the number of dimensions and N is the total number of spins. What is the multiplicity of this state? Calculate its entropy.===

Consider a 1D row of lattice sites of N=3 with spin configuration [+1][+1][+1].

Mathematically the interaction energy is defined asː
<math> -\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} </math> where J is a constant and <math>s_{i}s_{j}</math> is the product between two spins in adjacent lattice sites.

The sum of the interaction energies <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j}</math> can be considered as the sum of the individual interaction energies between spinsː
<math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = \epsilon_{12} + \epsilon_{23} + \epsilon_{13} + \epsilon_{21} + \epsilon_{32} + \epsilon_{31} </math>.

Although lattice sites 1 and 3 are not adjacent they are said to still interact according to the periodic boundary conditions applied.

However, <math>\epsilon_{12} = \epsilon_{21} </math> and <math>\epsilon_{23} = \epsilon_{32}</math> and <math>\epsilon_{13} = \epsilon_{31}</math> which means that all of the interactions within the system are counted twice, hence the total energy needs to be halved, resulting in the following formula being obtainedː <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = 2\epsilon_{12} + 2\epsilon_{13} + 2\epsilon_{23} </math>.

It can be determined that <math>\epsilon_{12} = (+1)(+1) = 1</math> , <math>\epsilon_{13} = (+1)(+1) = 1</math> and <math>\epsilon_{23} = (+1)(+1) = 1</math>.

Thereforeː <math>-\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = -\frac{1}{2} \ J \ (2 + 2 + 2) = -\frac{1}{2} \ J \ 6 = - 3 J = -DNJ</math> for a 1D lattice with <math>D=1</math> and 3 lattice sites <math>N=3</math>

The multiplicity of the system,<math>\Omega = 2S+1</math> where <math>S</math> is the total magnetisation of the system.

In this case, <math>\Omega = 2(3)+1 = 7</math>

Entropy, <math>S</math> is defined as <math>S = k_B ln(\Omega)</math> and so in this case <math>S = k_B ln7 = 1.95 k_B</math>

===TASK: Imagine that the system is in the lowest energy configuration. To move to a different state, one of the spins must spontaneously change direction ("flip"). What is the change in energy if this happens <math>(D=3, N=1000)</math>? How much entropy does the system gain by doing soʔ===

In a 3D lattice system, each lattice site has three unique interactions with its neighbours to its left, top and front. In the lowest energy configuration, all spins are parallel and for a system the minimum energy is <math>E = -DNJ</math>, so for the system with <math>N=1000</math> and <math>D=3</math>, the minimum energy is <math>-3000J</math>.

If a single spin is flipped, the product of its spin with its neighbours spin reverses and becomes negative and this increases the total energy of the system. Since 3 unique spin-spin interactions are reversed in sign, the total energy increases by <math>+3J</math>, meaning the new total energy is <math>-2997J</math>

Initially the multiplicity of the system will be <math>\Omega = 2(1000)+1=2001</math> , and after the flip, the multiplicity becomes <math>\Omega = 2(1000-1)+1=1999</math>.

The associated change in entropy, <math>\Delta S = k_B ln(1999) - k_B ln(2001)= k_B ln(\frac{1999}{2001}) = -0.001 k_B</math>, which is a very small decrease in entropy as the system starts

===TASK: Calculate the magnetisation of the 1D and 2D lattices in Figure 1. What magnetisation would you expect to observe for an Ising lattice with <math>D = 3,\ N=1000</math> at absolute zero?===

[[File:ThirdYearCMPExpt-IsingSketch.png|thumb|left|Figure 1 - Shows 1D (N = 5), 2D (N = 5x5) and 3D (N = 5x5x5) lattices.]]

Magnetisation is defined as <math>M=\sum_{i} s_i</math>. So for the 1D lattice with <math>N = 5</math> in ''Figure 2'', <math>M = +1</math> and for the 2D lattice with <math>N = 25 , M = +1</math> too.

According to the 3rd Law of thermodynamics, entropy is 0 at absolute zero for a perfect crystalline solid, and consequently it is expected that the lattices will have follow suit and have zero entropy at 0K. To have zero entropy all spins must be paired as such that magnetisation, <math>M = 0</math> - which is only possible in the lattices contains an even numbers of lattice sites (N = even). So, for a lattice with <math>N = 1000</math> and <math>D =3</math>, if <math>M = 0</math>, then multiplicity, <math>\Omega = 1</math> and entropy, <math>S =k_B ln(\Omega) = 0</math>.

==Section 2 - Calculating the Energy and Magnetisation==

===TASK: complete the functions energy() and magnetisation(), which should return the energy of the lattice and the total magnetisation, respectively. In the energy() function you may assume that <math>J=1.0</math> at all times (in fact, we are working in reduced units in which <math>J=k_B</math>, but there will be more information about this in later sections). Do not worry about the efficiency of the code at the moment — we will address the speed in a later part of the experiment.===

<pre>def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
lat=self.lattice #creates lattice and stores it
mag=[]
for i in range(0,len(lat)): #loops through all rows of lattice
for j in range(0,len(lat[i])): #loops through elements of each row
mag+=[lat[i][j]] #adds spin value to mag array
return sum(mag) #sums all spins from mag array
</pre>

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

lat=self.lattice #creates lattice and stores it
left=[]
top=[]

for i in range(0,len(lat)):
for j in range(0,len(lat[i])):
left+=[lat[i][j]*lat[i][j-1]] #multiplies spin by spin to left
top+=[lat[i][j]*lat[i-1][j]] #multiplies spin by spin above it
int_en=left+top #sums spin products from left and top
energy=-sum(int_en) #sums all spin products for each spin to give total

return energy
</pre>

===TASK: Run the ILcheck.py script from the IPython Qt console using the command===

''Figure 2'' shows the results when ILcheck.py was ran on my IsingLattice.py file. The ILcheck.py file was ran several times to ensure the code worked for various random lattices.

[[File:Cg1417ILcheck run.png|thumb|left|500px| Figure 2 - Result from running the ILcheck.py file]]

 

==Section 3 - Introduction to Monte Carlo Simulation==

===TASK: How many configurations are available to a system with 100 spins? To evaluate these expressions, we have to calculate the energy and magnetisation for each of these configurations, then perform the sum. Let's be very, very, generous, and say that we can analyse <math>1\times 10^9</math> configurations per second with our computer. How long will it take to evaluate a single value of <math>\left\langle M\right\rangle_T</math>?===

For a system with 100 lattice sites and two possible spins for each site, there are <math>2^{100}</math>possible configurations for the system. <math>2^{100}= 1.27\times 10^{30} </math>, so if the computer can analyse <math>1\times 10^9</math> configurations per second, then it will take <math>\frac{1.27\times 10^{30}}{10^9} = 1.27\times 10^{21} s</math> to analyse the whole system, which is older than the age of the universe and therefore is not a practical approach.

===TASK: Implement a single cycle of the above algorithm in the montecarlocycle(T) function. This function should return the energy of your lattice and the magnetisation at the end of the cycle. You may assume that the energy returned by your energy() function is in units of <math>k_B</math>! Complete the statistics() function. This should return the following quantities whenever it is called: <math><E>, <E^2>, <M>, <M^2></math>, and the number of Monte Carlo steps that have elapsed.===
<pre>
E = []
E2 = []
M = []
M2 = []
n_cycles = 0

def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back if rejected else not changed

self.E+=[self.energy()] #records energy
self.E2+=[self.energy()**2] #records energy squared
self.M+=[self.magnetisation()] #records magnetisation
self.M2+=[self.magnetisation()**2] #records magnetisation squared
self.n_cycles=self.n_cycles+1 #adds 1 to run total

return (self.energy(),self.magnetisation())

def statistics(self):
# complete this function so that it calculates the correct values for the averages of E, E*E (E2), M, M*M (M2), and returns them

e=np.mean(self.E)
e2=np.mean(self.E2)
m=np.mean(self.M)
m2=np.mean(self.M2)

return e,e2,m,m2,self.n_cycles
</pre>

===TASK: If <math>T < T_C</math>, do you expect a spontaneous magnetisation (i.e. do you expect <math>\left\langle M\right\rangle \neq 0</math>)? When the state of the simulation appears to stop changing (when you have reached an equilibrium state), use the controls to export the output to PNG and attach this to your report. You should also include the output from your statistics() function.===

If the temperature of the system is less than the Curie Temperature, <math>T_C</math> then spontaneous magnetisation can occur and the system will tend to its lowest energy state where all of the spins are parallel - this is a property of ferromagnetic materials.

[[File:Cg1417ILanim_run.png|400px|thumb|left|Figure 3 - Results from running the ILanim.py file - shows the energy and magnetisation converging over time]]

''Figure 3'' shows that over time the the system spontaneously converges to the minimum energy state with all of the spins parallel to one another and shows, as I expected, that spontaneous magnetisation occurs and also shows that the temperature of this simulation is below the Curie Temperature, <math>T < T_C</math>.

 

==Section 4 - Accelerating the Code==

===TASK: Use the script ILtimetrial.py to record how long your current version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 4'' show the results of running the ILtimetrial.py file on my code three timesː

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1.png
| width1=500
| image2=cg1417ILtimetrial_run2.png
| width2=500
| image3=cg1417ILtimetrial_run3.png
| width3=500
| footer = Figure 4 - Results of running the ILtimetrial.py file on my code three separate times
}}
 

This gave me an avergage time of <math>24.3 s \pm 0.2s</math>

===TASK: Look at the documentation for the NumPy sum function. You should be able to modify your magnetisation() function so that it uses this to evaluate M. The energy is a little trickier. Familiarise yourself with the NumPy roll and multiply functions, and use these to replace your energy double loop (you will need to call roll and multiply twice!).===

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

left=multiply(roll(self.lattice,1,axis=1),self.lattice) #product of spin with spin left of it
top=multiply(roll(self.lattice,-1,axis=0),self.lattice) #product of spin with spin above it

int_en=sum(left+top) #sum of array containing sum of left and top spin products for each spin

energy = -sum(int_en) #calculates the total energy of system
return energy

def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
return sum(sum(self.lattice)) #adds up all spins in lattice
</pre>

===TASK: Use the script ILtimetrial.py to record how long your new version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 5'' shows the result of running the ILtimetrial.py on my new accelerated code.

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1fast.png
| width1=500
| image2=ILtimetrial_run2fast.png
| width2=500
| image3=ILtimetrial_run3fast.png
| width3=500
| footer = Figure 5 - Results of running the ILtimetrial.py file on my new updated and accelerated code.
}}
 

The accelerated code is much faster upon using the roll, multiply and s with a new average time of <math>0.790 s \pm 0.005 </math>

==Section 5 - The effect of temperature==

===TASK: The script ILfinalframe.py runs for a given number of cycles at a given temperature, then plots a depiction of the final lattice state as well as graphs of the energy and magnetisation as a function of cycle number. This is much quicker than animating every frame! Experiment with different temperature and lattice sizes. How many cycles are typically needed for the system to go from its random starting position to the equilibrium state? Modify your statistics() and montecarlostep() functions so that the first N cycles of the simulation are ignored when calculating the averages. You should state in your report what period you chose to ignore, and include graphs from ILfinalframe.py to illustrate your motivation in choosing this figure.===

''Figure 6'' below shows the results from running the ILfinalframe.py for 2x2 lattice at T=1,2,3,5.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2T1.png
| image2 = cg14172x2T2.png
| image3 =cg14172x2T3.png
| image4 =cg14172x2T5.png
| footer_align = left
| footer = Figure 6 - Results of running the ILfinalframe.py file at T=1,2,3,5 for a 2x2 matrix.
}}

 

For a 2x2 matrix, a suitable cut-off point to exclude from the avergage energies and magnetisations is where the energy and magnetisations per spin are constant, which is 30 steps. For T=3 and T=5 the graphs do not converge because it is possible that these temperatures are higher than the Curie Temperature and as such spontaneous magnetisation will not occur and the system will not diverge to the lowest energy state. At the higher temperatures, there are larger thermal fluctations and the Boltzmann factor is more significant allowing the system to move away from the lowest energy state easier. As a result moving forwards, a suitable cut-off point will only be determined from T=1 and T=2 graphs for the larger matrices.

''Figure 7'' shows the results from running a 4x4 lattice at T=1,2 and 3.

{{multiple image
| width =350
| align = left
| image1 = cg14174x4T1.png
| image2 = cg14174x4T2.png
| image3 =cg14174x4T3.png
| footer_align = left
| footer = Figure 7 - Results of running the ILfinalframe.py file at T=1,2,3 for a 4x4 matrix.
}}

From ''Figure 7'', a suitable cut-off point for the energy and magnetisations is 200 as this is after where the energy and magnetisation has converged for T=1, and is after the initial large drop in energy for T=2, even though there are a few small fluctuations after 200 steps. The result from T=3 has been included to show the large fluctuations for the larger temperatures, and supporting my choice to determine the cut-off from T=1 and T=2 only.

''Figure 8'' shows the results for an 8x8 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg14178x8T1.png
| image2 = cg14178x8T2.png
| footer_align = left
| footer = Figure 8 - Results of running the ILfinalframe.py file at T=1,2 for an 8x8 matrix
}}

From ''Figure 8'' above, a suitable cut-off point is 1000 steps as this is where the energy and magnetisation has easily converged by and is also the point after which the initial large drop in energy has been overcome for T=2 too.

''Figure 9'' shows the result of running the ILfinalframe.py for a 16x16 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg141716x16T1.png
| image2 = cg141716x16T2.png
| footer_align = left
| footer = Figure 9 - Results of running the ILfinalframe.py file at T=1,2 for a 16x16 matrix
}}

From ''Figure 9'', a suitable cut-off point is 15000 steps as for T=1 the energy and magnetisations have converged significantly and will not change much, and likewise this is the same for the T=2 frame.

''Figure 10'' below shows the results from a 32x32 matrix at T=1 and T=2.

{{multiple image
| width =350
| align = left
| image1 = cg141732x32T1.png
| image2 = cg141732x32T2.png
| footer_align = left
| footer = Figure 10 - Results of running the ILfinalframe.py file at T=1,2 for a 32x32 matrix
}}

''Figure 10'' above shows the results of running the ILfinalframe.py file for a 32x32 matrix at T=1 and T=2. As a result a suitable cut-off of 50000 steps was chosen as the energy and magnetisation has significantly converged, but not as much as it could at 100000 steps. I chose a slightly lower value to ensure that the run times of my monte-carlo simulations in future tasks were not extremely time consuming.

The montecarlostep() function was changed by adding a condition that values only above the pre-determined cut-off were included when determining the average value of energy; energy squared; magnetisation and magnetisations squared from the statistics function. The statistics() function did not need to be modified.

The following code is from the 32x32 matrixː

<pre>def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back

if self.n_cycles > 50000: #only adds values to array of E,E2,M and M2 is above specific cut-off
self.E+=[self.energy()]
self.E2+=[self.energy()**2]
self.M+=[self.magnetisation()]
self.M2+=[self.magnetisation()**2]
self.n_cycles=self.n_cycles+1

return (self.energy(),self.magnetisation())
</pre>

===TASK: Use ILtemperaturerange.py to plot the average energy and magnetisation for each temperature, with error bars, for an <math>8\times 8</math> lattice. Use your intuition and results from the script ILfinalframe.py to estimate how many cycles each simulation should be. The temperature range 0.25 to 5.0 is sufficient. Use as many temperature points as you feel necessary to illustrate the trend, but do not use a temperature spacing larger than 0.5. The NumPy function savetxt() stores your array of output data on disk — you will need it later. Save the file as 8x8.dat so that you know which lattice size it came from.===

Using the modified code, the file ILtemperaturerange.py was ran on an 8x8 matrix between T=0.5 and T=5 with a step of T=0.02 for 10000 Montecarlo steps and the first 1000 steps of each temperature were excluded when calculating the averages. ''Figure 11'' shows the result of the simulation and also included error bars of standard deviation.

[[File:Cg14178x8error.png|1000px|thumb|left|Figure 11 - Graph showing average energy and average magnetisation for an 8x8 lattice with error bars between T=0.5 and T=5]]

 

==Section 6 - The effect of system size==

===TASK: Repeat the final task of the previous section for the following lattice sizes: 2x2, 4x4, 8x8, 16x16, 32x32. Make sure that you name each datafile that your produce after the corresponding lattice size! Write a Python script to make a plot showing the energy per spin versus temperature for each of your lattice sizes. Hint: the NumPy loadtxt function is the reverse of the savetxt function, and can be used to read your previously saved files into the script. Repeat this for the magnetisation. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. How big a lattice do you think is big enough to capture the long range fluctuations?===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb.

Each matrix was simulated using the ILtemperaturerange.py file between T=0.5 and T=5 with a step of T=0.02.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2error.png
| caption1 = 2x2 matrix - 5000 steps, cut-off = 30 steps
| image2 = 4x4error.png
| caption2 = 4x4 matrix - 1000 steps, cut-off = 200 steps
| image3 =cg141716x16error.png
| caption3 = 16x16 matrix - 50000 steps, cut-off = 15000 steps
| image4 =cg141732x32error.png
| caption4 = 32x32 matrix - 200000 steps, cut-off = 50000 steps
| footer_align = left
| footer = Figure 12 - Results of running the ILtemperaturerange.py file for 2x2, 4x4, 16x16 and 32x32 matrices.
}}

 

==Section 7 - Determining the Heat Capacity==

===TASK: By definition, <math>C = \frac{\partial \left\langle E\right\rangle}{\partial T}</math>. From this, show that <math>C = \frac{\mathrm{Var}[E]}{k_B T^2}</math> (Where <math>\mathrm{Var}[E]</math> is the variance in <math>E</math>.)===

Recall from statistical thermodynamics that the average energy of a system is the sum across all microstates of the probability of that microstate multiplied by the energy of that microstate, which is defined mathematically asː <math>\langle E \rangle = \sum_i p_{i}\epsilon_{i}</math>.

The partition function <math>q</math> is defined as <math>q = \sum_{i} exp(-\beta \epsilon_{i})</math> where <math>\beta =\frac{1}{k_BT}</math>and the probability, <math>p_{i}</math> can be defined in terms of the partition function as <math>p_{i} = \frac{exp(-\beta \epsilon_{i})}{\sum_{i} exp(-\beta \epsilon_{i})} = \frac{exp(-\beta \epsilon_{i})}{q}</math>.

As a result, <math>\langle E \rangle</math> can be re-written as <math>\langle E \rangle = \sum_{i} \frac{\epsilon_{i} exp(-\beta \epsilon_{i})}{q} = -\frac{1}{q} \frac{\partial}{\partial \beta}\sum_{i}exp(-\beta \epsilon_{i}) = -\frac{1}{q} \frac{\partial q}{\partial \beta}</math>

Likewise, <math>\langle E^2 \rangle = \sum_i p_{i}\epsilon_{i}^{2} = \sum_{i} \frac{\epsilon_{i}^{2}exp(-\beta \epsilon_{i})}{q} = \frac{1}{q} \frac{\partial^{2}}{\partial \beta^{2}}\sum_{i}exp(-\beta \epsilon_{i}) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}}</math>

From definitionː <math>Var[E] = \Delta E^2 = \langle E^2 \rangle - \langle E \rangle^2 </math>

When the definition of <math>\langle E \rangle</math> and <math>\langle E^2 \rangle</math> is written in terms of partition function <math>q</math>ː <math>Var[E] = \langle E^2 \rangle - \langle E \rangle^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \left(\frac{1}{q}\frac{\partial q}{\partial \beta}\right)^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2</math>.

According to the chain ruleː <math>\frac{\partial}{\partial \beta}\left(\frac{1}{q} \frac{\partial q}{\partial \beta}\right) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2 = -\frac{\partial}{\partial \beta}\langle E \rangle = Var[E]</math>

And using the chain rule againː <math>C = \frac{\partial \langle E \rangle}{\partial T}= \left(-\frac{\partial \langle E \rangle}{\partial \beta}\right) \left(-\frac{\partial \beta}{\partial T}\right) = \frac{Var[E]}{k_B T^2}</math>

===TASK: Write a Python script to make a plot showing the heat capacity versus temperature for each of your lattice sizes from the previous section. You may need to do some research to recall the connection between the variance of a variable, <math>\mathrm{Var}[X]</math>, the mean of its square <math>\left\langle X^2\right\rangle</math>, and its squared mean <math>\left\langle X\right\rangle^2</math>. You may find that the data around the peak is very noisy — this is normal, and is a result of being in the critical region. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. ===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb

{{multiple image
| width =300
| align = left
| image1 = cg14172x2heatcap.png
| caption1 = 2x2 Matrix
| image2 = cg14174x4heatcap.png
| caption2 = 4x4 Matrix
| image3 =cg14178x8heatcap.png
| caption3 = 8x8 Matrix
| image4 =cg141716x16heatcap.png
| caption4 = 16x16 Matrix
| image5=cg141732x32heatcap.png
| caption5= 32x32 Matrix
| footer = Figure 13 - Graphs showing Heat Capacity against Temperature for each matrix size
}}

A general trend from the above graphs is that the peak of the graph shifts towards lower temperatures as the size of the matrix used increases.

==Section 8 - Locating the Curie Temperature==
===TASK: A C++ program has been used to run some much longer simulations than would be possible on the college computers in Python. You can view its source code here if you are interested. Each file contains six columns: <math>T, E, E^2, M, M^2, C</math> (the final five quantities are per spin), and you can read them with the NumPy loadtxt function as before. For each lattice size, plot the C++ data against your data. For one lattice size, save a PNG of this comparison and add it to your report — add a legend to the graph to label which is which. To do this, you will need to pass the label="..." keyword to the plot function, then call the legend() function of the axis object (documentation here).===

The python code used to read and plot the C++ data is found in the Jupyter notebook CG1417IsingModelGraphs.ipynb.

''Figure 14'' below shows the C++ plotted against my own data for a 16x16 Matrix.

[[File:Cg141716x16C++.png|400px|thumb|left|Figure 14 - Graph showing my own data against the C++ data for a 16x16 matrix.]]

 

===TASK: write a script to read the data from a particular file, and plot C vs T, as well as a fitted polynomial. Try changing the degree of the polynomial to improve the fit — in general, it might be difficult to get a good fit! Attach a PNG of an example fit to your report.===

The python script to read and plot the fitted polynomial is found in CG1417PolyfitScript.ipynb

Below in ''Figure 15'' is a plot of my Heat Capacity against Temperature data for a 16x16 matrix and features a polynomial of degree 35 plotted against it. Even with a polynomial of such a high degree, it poorly fits the curve and does not fit to the peak of the curve either.

[[File:cg1417FIT_TEST16x16_35.png|thumb|left|400px|Figure 15 - Plot of Heat Capacity against Temperature along with a poorly fitted polynomial of degree 35. ]]

 

===TASK: Modify your script from the previous section. You should still plot the whole temperature range, but fit the polynomial only to the peak of the heat capacity! You should find it easier to get a good fit when restricted to this region===

The script was modified as such that the polynomial was fitted in a set range around the peak of the graph, this is demonstrated in ''Figure 17'' which shows a newly fitted polynomial between a much smaller range of temperatures (T = 2.15-2.55) and a much smaller degree polynomial (3).

[[File:CG1417FIT_16x16C_3.png|thumb|left|400px|Figure 16 - Graph showing Heat Capacity against Temperature for a 16x16 matrix along with a fitted polynomial between a much more restricted range of temperatures and a significantly lower degree of polynomial]]

Upon comparison with ''Figure 15'', the new fitted polynomial is a significantly better fit even for a 3rd degree polynomial and is a much more accurate representation of my data around the peak of the graph and will make it easier to determine the maximum value of Heat Capacity.

 

===TASK: find the temperature at which the maximum in C occurs for each datafile that you were given. Make a text file containing two colums: the lattice side length (2,4,8, etc.), and the temperature at which C is a maximum. This is your estimate of <math>T_C</math> for that side length. Make a plot that uses the scaling relation given above to determine <math>T_{C,\infty}</math>. By doing a little research online, you should be able to find the theoretical exact Curie temperature for the infinite 2D Ising lattice. How does your value compare to this? Are you surprised by how good/bad the agreement is? Attach a PNG of this final graph to your report, and discuss briefly what you think the major sources of error are in your estimate.===

''Figure 17'' below shows a graph of <math>T_{C,L}</math> against <math>\frac{1}{Lattice Size}</math> to determine the Curie Temperature of an infinite 2D Ising Model Lattice <math>T_{C,\infty}</math>. The black dots represent the raw data obtained from obtaining the temperature at which the Heat Capacity was a maximum for the lattices and the red line in a linear curve fit plotted against the data to allow the y-intercept which is the Curie Temperature for the infinite 2D lattice to be determined.

[[File:cg1417CurieTemp.png|400px|thumb|left|Figure 17 - Plot of 1/Lattice Size against Curie Temperature for that lattice size.]]

The value for <math>T_{C,\inf}</math> obtained from the data is <math>T_{C,\infty} = 2.277 \frac{J}{k_B}</math> with a literature value being <math>T_{C,\infty} = 2.269 \frac{J}{k_B}</math> for an infinite square 2D lattice. This means that my result slightly over-estimates the Curie Temperature for the infinite lattice and as a result for an infinite lattice the temperature at which spontaneous magnetisation stops would actually occur at a slightly lower temperature than expected. However, the difference between my value and the literature value is only 0.008 which is incredibly small and the amount of agreement between the two values is somewhat surprising, which means that the error in my estimates of the Curie Temperature for each lattice size is relatively small. A potential source of error from the values of the Curie Temperature for each lattice size could come from the

Rep:Y3CMPCG1417

2019-11-20T07:56:31Z

Cg1417: /* Section 8 - Locating the Curie Temperature */

==Section 1 - Introduction to the Ising Model==

===TASK: Show that the lowest possible energy for the Ising model is <math>E = -DNJ</math>, where D is the number of dimensions and N is the total number of spins. What is the multiplicity of this state? Calculate its entropy.===

Consider a 1D row of lattice sites of N=3 with spin configuration [+1][+1][+1].

Mathematically the interaction energy is defined asː
<math> -\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} </math> where J is a constant and <math>s_{i}s_{j}</math> is the product between two spins in adjacent lattice sites.

The sum of the interaction energies <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j}</math> can be considered as the sum of the individual interaction energies between spinsː
<math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = \epsilon_{12} + \epsilon_{23} + \epsilon_{13} + \epsilon_{21} + \epsilon_{32} + \epsilon_{31} </math>.

Although lattice sites 1 and 3 are not adjacent they are said to still interact according to the periodic boundary conditions applied.

However, <math>\epsilon_{12} = \epsilon_{21} </math> and <math>\epsilon_{23} = \epsilon_{32}</math> and <math>\epsilon_{13} = \epsilon_{31}</math> which means that all of the interactions within the system are counted twice, hence the total energy needs to be halved, resulting in the following formula being obtainedː <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = 2\epsilon_{12} + 2\epsilon_{13} + 2\epsilon_{23} </math>.

It can be determined that <math>\epsilon_{12} = (+1)(+1) = 1</math> , <math>\epsilon_{13} = (+1)(+1) = 1</math> and <math>\epsilon_{23} = (+1)(+1) = 1</math>.

Thereforeː <math>-\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = -\frac{1}{2} \ J \ (2 + 2 + 2) = -\frac{1}{2} \ J \ 6 = - 3 J = -DNJ</math> for a 1D lattice with <math>D=1</math> and 3 lattice sites <math>N=3</math>

The multiplicity of the system,<math>\Omega = 2S+1</math> where <math>S</math> is the total magnetisation of the system.

In this case, <math>\Omega = 2(3)+1 = 7</math>

Entropy, <math>S</math> is defined as <math>S = k_B ln(\Omega)</math> and so in this case <math>S = k_B ln7 = 1.95 k_B</math>

===TASK: Imagine that the system is in the lowest energy configuration. To move to a different state, one of the spins must spontaneously change direction ("flip"). What is the change in energy if this happens <math>(D=3, N=1000)</math>? How much entropy does the system gain by doing soʔ===

In a 3D lattice system, each lattice site has three unique interactions with its neighbours to its left, top and front. In the lowest energy configuration, all spins are parallel and for a system the minimum energy is <math>E = -DNJ</math>, so for the system with <math>N=1000</math> and <math>D=3</math>, the minimum energy is <math>-3000J</math>.

If a single spin is flipped, the product of its spin with its neighbours spin reverses and becomes negative and this increases the total energy of the system. Since 3 unique spin-spin interactions are reversed in sign, the total energy increases by <math>+3J</math>, meaning the new total energy is <math>-2997J</math>

Initially the multiplicity of the system will be <math>\Omega = 2(1000)+1=2001</math> , and after the flip, the multiplicity becomes <math>\Omega = 2(1000-1)+1=1999</math>.

The associated change in entropy, <math>\Delta S = k_B ln(1999) - k_B ln(2001)= k_B ln(\frac{1999}{2001}) = -0.001 k_B</math>, which is a very small decrease in entropy as the system starts

===TASK: Calculate the magnetisation of the 1D and 2D lattices in Figure 1. What magnetisation would you expect to observe for an Ising lattice with <math>D = 3,\ N=1000</math> at absolute zero?===

[[File:ThirdYearCMPExpt-IsingSketch.png|thumb|left|Figure 1 - Shows 1D (N = 5), 2D (N = 5x5) and 3D (N = 5x5x5) lattices.]]

Magnetisation is defined as <math>M=\sum_{i} s_i</math>. So for the 1D lattice with <math>N = 5</math> in ''Figure 2'', <math>M = +1</math> and for the 2D lattice with <math>N = 25 , M = +1</math> too.

According to the 3rd Law of thermodynamics, entropy is 0 at absolute zero for a perfect crystalline solid, and consequently it is expected that the lattices will have follow suit and have zero entropy at 0K. To have zero entropy all spins must be paired as such that magnetisation, <math>M = 0</math> - which is only possible in the lattices contains an even numbers of lattice sites (N = even). So, for a lattice with <math>N = 1000</math> and <math>D =3</math>, if <math>M = 0</math>, then multiplicity, <math>\Omega = 1</math> and entropy, <math>S =k_B ln(\Omega) = 0</math>.

==Section 2 - Calculating the Energy and Magnetisation==

===TASK: complete the functions energy() and magnetisation(), which should return the energy of the lattice and the total magnetisation, respectively. In the energy() function you may assume that <math>J=1.0</math> at all times (in fact, we are working in reduced units in which <math>J=k_B</math>, but there will be more information about this in later sections). Do not worry about the efficiency of the code at the moment — we will address the speed in a later part of the experiment.===

<pre>def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
lat=self.lattice #creates lattice and stores it
mag=[]
for i in range(0,len(lat)): #loops through all rows of lattice
for j in range(0,len(lat[i])): #loops through elements of each row
mag+=[lat[i][j]] #adds spin value to mag array
return sum(mag) #sums all spins from mag array
</pre>

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

lat=self.lattice #creates lattice and stores it
left=[]
top=[]

for i in range(0,len(lat)):
for j in range(0,len(lat[i])):
left+=[lat[i][j]*lat[i][j-1]] #multiplies spin by spin to left
top+=[lat[i][j]*lat[i-1][j]] #multiplies spin by spin above it
int_en=left+top #sums spin products from left and top
energy=-sum(int_en) #sums all spin products for each spin to give total

return energy
</pre>

===TASK: Run the ILcheck.py script from the IPython Qt console using the command===

''Figure 2'' shows the results when ILcheck.py was ran on my IsingLattice.py file. The ILcheck.py file was ran several times to ensure the code worked for various random lattices.

[[File:Cg1417ILcheck run.png|thumb|left|500px| Figure 2 - Result from running the ILcheck.py file]]

 

==Section 3 - Introduction to Monte Carlo Simulation==

===TASK: How many configurations are available to a system with 100 spins? To evaluate these expressions, we have to calculate the energy and magnetisation for each of these configurations, then perform the sum. Let's be very, very, generous, and say that we can analyse <math>1\times 10^9</math> configurations per second with our computer. How long will it take to evaluate a single value of <math>\left\langle M\right\rangle_T</math>?===

For a system with 100 lattice sites and two possible spins for each site, there are <math>2^{100}</math>possible configurations for the system. <math>2^{100}= 1.27\times 10^{30} </math>, so if the computer can analyse <math>1\times 10^9</math> configurations per second, then it will take <math>\frac{1.27\times 10^{30}}{10^9} = 1.27\times 10^{21} s</math> to analyse the whole system, which is older than the age of the universe and therefore is not a practical approach.

===TASK: Implement a single cycle of the above algorithm in the montecarlocycle(T) function. This function should return the energy of your lattice and the magnetisation at the end of the cycle. You may assume that the energy returned by your energy() function is in units of <math>k_B</math>! Complete the statistics() function. This should return the following quantities whenever it is called: <math><E>, <E^2>, <M>, <M^2></math>, and the number of Monte Carlo steps that have elapsed.===
<pre>
E = []
E2 = []
M = []
M2 = []
n_cycles = 0

def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back if rejected else not changed

self.E+=[self.energy()] #records energy
self.E2+=[self.energy()**2] #records energy squared
self.M+=[self.magnetisation()] #records magnetisation
self.M2+=[self.magnetisation()**2] #records magnetisation squared
self.n_cycles=self.n_cycles+1 #adds 1 to run total

return (self.energy(),self.magnetisation())

def statistics(self):
# complete this function so that it calculates the correct values for the averages of E, E*E (E2), M, M*M (M2), and returns them

e=np.mean(self.E)
e2=np.mean(self.E2)
m=np.mean(self.M)
m2=np.mean(self.M2)

return e,e2,m,m2,self.n_cycles
</pre>

===TASK: If <math>T < T_C</math>, do you expect a spontaneous magnetisation (i.e. do you expect <math>\left\langle M\right\rangle \neq 0</math>)? When the state of the simulation appears to stop changing (when you have reached an equilibrium state), use the controls to export the output to PNG and attach this to your report. You should also include the output from your statistics() function.===

If the temperature of the system is less than the Curie Temperature, <math>T_C</math> then spontaneous magnetisation can occur and the system will tend to its lowest energy state where all of the spins are parallel - this is a property of ferromagnetic materials.

[[File:Cg1417ILanim_run.png|400px|thumb|left|Figure 3 - Results from running the ILanim.py file - shows the energy and magnetisation converging over time]]

''Figure 3'' shows that over time the the system spontaneously converges to the minimum energy state with all of the spins parallel to one another and shows, as I expected, that spontaneous magnetisation occurs and also shows that the temperature of this simulation is below the Curie Temperature, <math>T < T_C</math>.

 

==Section 4 - Accelerating the Code==

===TASK: Use the script ILtimetrial.py to record how long your current version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 4'' show the results of running the ILtimetrial.py file on my code three timesː

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1.png
| width1=500
| image2=cg1417ILtimetrial_run2.png
| width2=500
| image3=cg1417ILtimetrial_run3.png
| width3=500
| footer = Figure 4 - Results of running the ILtimetrial.py file on my code three separate times
}}
 

This gave me an avergage time of <math>24.3 s \pm 0.2s</math>

===TASK: Look at the documentation for the NumPy sum function. You should be able to modify your magnetisation() function so that it uses this to evaluate M. The energy is a little trickier. Familiarise yourself with the NumPy roll and multiply functions, and use these to replace your energy double loop (you will need to call roll and multiply twice!).===

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

left=multiply(roll(self.lattice,1,axis=1),self.lattice) #product of spin with spin left of it
top=multiply(roll(self.lattice,-1,axis=0),self.lattice) #product of spin with spin above it

int_en=sum(left+top) #sum of array containing sum of left and top spin products for each spin

energy = -sum(int_en) #calculates the total energy of system
return energy

def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
return sum(sum(self.lattice)) #adds up all spins in lattice
</pre>

===TASK: Use the script ILtimetrial.py to record how long your new version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 5'' shows the result of running the ILtimetrial.py on my new accelerated code.

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1fast.png
| width1=500
| image2=ILtimetrial_run2fast.png
| width2=500
| image3=ILtimetrial_run3fast.png
| width3=500
| footer = Figure 5 - Results of running the ILtimetrial.py file on my new updated and accelerated code.
}}
 

The accelerated code is much faster upon using the roll, multiply and s with a new average time of <math>0.790 s \pm 0.005 </math>

==Section 5 - The effect of temperature==

===TASK: The script ILfinalframe.py runs for a given number of cycles at a given temperature, then plots a depiction of the final lattice state as well as graphs of the energy and magnetisation as a function of cycle number. This is much quicker than animating every frame! Experiment with different temperature and lattice sizes. How many cycles are typically needed for the system to go from its random starting position to the equilibrium state? Modify your statistics() and montecarlostep() functions so that the first N cycles of the simulation are ignored when calculating the averages. You should state in your report what period you chose to ignore, and include graphs from ILfinalframe.py to illustrate your motivation in choosing this figure.===

''Figure 6'' below shows the results from running the ILfinalframe.py for 2x2 lattice at T=1,2,3,5.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2T1.png
| image2 = cg14172x2T2.png
| image3 =cg14172x2T3.png
| image4 =cg14172x2T5.png
| footer_align = left
| footer = Figure 6 - Results of running the ILfinalframe.py file at T=1,2,3,5 for a 2x2 matrix.
}}

 

For a 2x2 matrix, a suitable cut-off point to exclude from the avergage energies and magnetisations is where the energy and magnetisations per spin are constant, which is 30 steps. For T=3 and T=5 the graphs do not converge because it is possible that these temperatures are higher than the Curie Temperature and as such spontaneous magnetisation will not occur and the system will not diverge to the lowest energy state. At the higher temperatures, there are larger thermal fluctations and the Boltzmann factor is more significant allowing the system to move away from the lowest energy state easier. As a result moving forwards, a suitable cut-off point will only be determined from T=1 and T=2 graphs for the larger matrices.

''Figure 7'' shows the results from running a 4x4 lattice at T=1,2 and 3.

{{multiple image
| width =350
| align = left
| image1 = cg14174x4T1.png
| image2 = cg14174x4T2.png
| image3 =cg14174x4T3.png
| footer_align = left
| footer = Figure 7 - Results of running the ILfinalframe.py file at T=1,2,3 for a 4x4 matrix.
}}

From ''Figure 7'', a suitable cut-off point for the energy and magnetisations is 200 as this is after where the energy and magnetisation has converged for T=1, and is after the initial large drop in energy for T=2, even though there are a few small fluctuations after 200 steps. The result from T=3 has been included to show the large fluctuations for the larger temperatures, and supporting my choice to determine the cut-off from T=1 and T=2 only.

''Figure 8'' shows the results for an 8x8 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg14178x8T1.png
| image2 = cg14178x8T2.png
| footer_align = left
| footer = Figure 8 - Results of running the ILfinalframe.py file at T=1,2 for an 8x8 matrix
}}

From ''Figure 8'' above, a suitable cut-off point is 1000 steps as this is where the energy and magnetisation has easily converged by and is also the point after which the initial large drop in energy has been overcome for T=2 too.

''Figure 9'' shows the result of running the ILfinalframe.py for a 16x16 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg141716x16T1.png
| image2 = cg141716x16T2.png
| footer_align = left
| footer = Figure 9 - Results of running the ILfinalframe.py file at T=1,2 for a 16x16 matrix
}}

From ''Figure 9'', a suitable cut-off point is 15000 steps as for T=1 the energy and magnetisations have converged significantly and will not change much, and likewise this is the same for the T=2 frame.

''Figure 10'' below shows the results from a 32x32 matrix at T=1 and T=2.

{{multiple image
| width =350
| align = left
| image1 = cg141732x32T1.png
| image2 = cg141732x32T2.png
| footer_align = left
| footer = Figure 10 - Results of running the ILfinalframe.py file at T=1,2 for a 32x32 matrix
}}

''Figure 10'' above shows the results of running the ILfinalframe.py file for a 32x32 matrix at T=1 and T=2. As a result a suitable cut-off of 50000 steps was chosen as the energy and magnetisation has significantly converged, but not as much as it could at 100000 steps. I chose a slightly lower value to ensure that the run times of my monte-carlo simulations in future tasks were not extremely time consuming.

The montecarlostep() function was changed by adding a condition that values only above the pre-determined cut-off were included when determining the average value of energy; energy squared; magnetisation and magnetisations squared from the statistics function. The statistics() function did not need to be modified.

The following code is from the 32x32 matrixː

<pre>def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back

if self.n_cycles > 50000: #only adds values to array of E,E2,M and M2 is above specific cut-off
self.E+=[self.energy()]
self.E2+=[self.energy()**2]
self.M+=[self.magnetisation()]
self.M2+=[self.magnetisation()**2]
self.n_cycles=self.n_cycles+1

return (self.energy(),self.magnetisation())
</pre>

===TASK: Use ILtemperaturerange.py to plot the average energy and magnetisation for each temperature, with error bars, for an <math>8\times 8</math> lattice. Use your intuition and results from the script ILfinalframe.py to estimate how many cycles each simulation should be. The temperature range 0.25 to 5.0 is sufficient. Use as many temperature points as you feel necessary to illustrate the trend, but do not use a temperature spacing larger than 0.5. The NumPy function savetxt() stores your array of output data on disk — you will need it later. Save the file as 8x8.dat so that you know which lattice size it came from.===

Using the modified code, the file ILtemperaturerange.py was ran on an 8x8 matrix between T=0.5 and T=5 with a step of T=0.02 for 10000 Montecarlo steps and the first 1000 steps of each temperature were excluded when calculating the averages. ''Figure 11'' shows the result of the simulation and also included error bars of standard deviation.

[[File:Cg14178x8error.png|1000px|thumb|left|Figure 11 - Graph showing average energy and average magnetisation for an 8x8 lattice with error bars between T=0.5 and T=5]]

 

==Section 6 - The effect of system size==

===TASK: Repeat the final task of the previous section for the following lattice sizes: 2x2, 4x4, 8x8, 16x16, 32x32. Make sure that you name each datafile that your produce after the corresponding lattice size! Write a Python script to make a plot showing the energy per spin versus temperature for each of your lattice sizes. Hint: the NumPy loadtxt function is the reverse of the savetxt function, and can be used to read your previously saved files into the script. Repeat this for the magnetisation. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. How big a lattice do you think is big enough to capture the long range fluctuations?===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb.

Each matrix was simulated using the ILtemperaturerange.py file between T=0.5 and T=5 with a step of T=0.02.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2error.png
| caption1 = 2x2 matrix - 5000 steps, cut-off = 30 steps
| image2 = 4x4error.png
| caption2 = 4x4 matrix - 1000 steps, cut-off = 200 steps
| image3 =cg141716x16error.png
| caption3 = 16x16 matrix - 50000 steps, cut-off = 15000 steps
| image4 =cg141732x32error.png
| caption4 = 32x32 matrix - 200000 steps, cut-off = 50000 steps
| footer_align = left
| footer = Figure 12 - Results of running the ILtemperaturerange.py file for 2x2, 4x4, 16x16 and 32x32 matrices.
}}

 

==Section 7 - Determining the Heat Capacity==

===TASK: By definition, <math>C = \frac{\partial \left\langle E\right\rangle}{\partial T}</math>. From this, show that <math>C = \frac{\mathrm{Var}[E]}{k_B T^2}</math> (Where <math>\mathrm{Var}[E]</math> is the variance in <math>E</math>.)===

Recall from statistical thermodynamics that the average energy of a system is the sum across all microstates of the probability of that microstate multiplied by the energy of that microstate, which is defined mathematically asː <math>\langle E \rangle = \sum_i p_{i}\epsilon_{i}</math>.

The partition function <math>q</math> is defined as <math>q = \sum_{i} exp(-\beta \epsilon_{i})</math> where <math>\beta =\frac{1}{k_BT}</math>and the probability, <math>p_{i}</math> can be defined in terms of the partition function as <math>p_{i} = \frac{exp(-\beta \epsilon_{i})}{\sum_{i} exp(-\beta \epsilon_{i})} = \frac{exp(-\beta \epsilon_{i})}{q}</math>.

As a result, <math>\langle E \rangle</math> can be re-written as <math>\langle E \rangle = \sum_{i} \frac{\epsilon_{i} exp(-\beta \epsilon_{i})}{q} = -\frac{1}{q} \frac{\partial}{\partial \beta}\sum_{i}exp(-\beta \epsilon_{i}) = -\frac{1}{q} \frac{\partial q}{\partial \beta}</math>

Likewise, <math>\langle E^2 \rangle = \sum_i p_{i}\epsilon_{i}^{2} = \sum_{i} \frac{\epsilon_{i}^{2}exp(-\beta \epsilon_{i})}{q} = \frac{1}{q} \frac{\partial^{2}}{\partial \beta^{2}}\sum_{i}exp(-\beta \epsilon_{i}) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}}</math>

From definitionː <math>Var[E] = \Delta E^2 = \langle E^2 \rangle - \langle E \rangle^2 </math>

When the definition of <math>\langle E \rangle</math> and <math>\langle E^2 \rangle</math> is written in terms of partition function <math>q</math>ː <math>Var[E] = \langle E^2 \rangle - \langle E \rangle^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \left(\frac{1}{q}\frac{\partial q}{\partial \beta}\right)^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2</math>.

According to the chain ruleː <math>\frac{\partial}{\partial \beta}\left(\frac{1}{q} \frac{\partial q}{\partial \beta}\right) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2 = -\frac{\partial}{\partial \beta}\langle E \rangle = Var[E]</math>

And using the chain rule againː <math>C = \frac{\partial \langle E \rangle}{\partial T}= \left(-\frac{\partial \langle E \rangle}{\partial \beta}\right) \left(-\frac{\partial \beta}{\partial T}\right) = \frac{Var[E]}{k_B T^2}</math>

===TASK: Write a Python script to make a plot showing the heat capacity versus temperature for each of your lattice sizes from the previous section. You may need to do some research to recall the connection between the variance of a variable, <math>\mathrm{Var}[X]</math>, the mean of its square <math>\left\langle X^2\right\rangle</math>, and its squared mean <math>\left\langle X\right\rangle^2</math>. You may find that the data around the peak is very noisy — this is normal, and is a result of being in the critical region. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. ===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb

{{multiple image
| width =300
| align = left
| image1 = cg14172x2heatcap.png
| caption1 = 2x2 Matrix
| image2 = cg14174x4heatcap.png
| caption2 = 4x4 Matrix
| image3 =cg14178x8heatcap.png
| caption3 = 8x8 Matrix
| image4 =cg141716x16heatcap.png
| caption4 = 16x16 Matrix
| image5=cg141732x32heatcap.png
| caption5= 32x32 Matrix
| footer = Figure 13 - Graphs showing Heat Capacity against Temperature for each matrix size
}}

A general trend from the above graphs is that the peak of the graph shifts towards lower temperatures as the size of the matrix used increases.

==Section 8 - Locating the Curie Temperature==
===TASK: A C++ program has been used to run some much longer simulations than would be possible on the college computers in Python. You can view its source code here if you are interested. Each file contains six columns: <math>T, E, E^2, M, M^2, C</math> (the final five quantities are per spin), and you can read them with the NumPy loadtxt function as before. For each lattice size, plot the C++ data against your data. For one lattice size, save a PNG of this comparison and add it to your report — add a legend to the graph to label which is which. To do this, you will need to pass the label="..." keyword to the plot function, then call the legend() function of the axis object (documentation here).===

The python code used to read and plot the C++ data is found in the Jupyter notebook CG1417IsingModelGraphs.ipynb.

''Figure 14'' below shows the C++ plotted against my own data for a 16x16 Matrix.

[[File:Cg141716x16C++.png|400px|thumb|left|Figure 14 - Graph showing my own data against the C++ data for a 16x16 matrix.]]

 

===TASK: write a script to read the data from a particular file, and plot C vs T, as well as a fitted polynomial. Try changing the degree of the polynomial to improve the fit — in general, it might be difficult to get a good fit! Attach a PNG of an example fit to your report.===

The python script to read and plot the fitted polynomial is found in CG1417PolyfitScript.ipynb

Below in ''Figure 15'' is a plot of my Heat Capacity against Temperature data for a 16x16 matrix and features a polynomial of degree 35 plotted against it. Even with a polynomial of such a high degree, it poorly fits the curve and does not fit to the peak of the curve either.

[[File:cg1417FIT_TEST16x16_35.png|thumb|left|400px|Figure 15 - Plot of Heat Capacity against Temperature along with a poorly fitted polynomial of degree 35. ]]

 

===TASK: Modify your script from the previous section. You should still plot the whole temperature range, but fit the polynomial only to the peak of the heat capacity! You should find it easier to get a good fit when restricted to this region===

The script was modified as such that the polynomial was fitted in a set range around the peak of the graph, this is demonstrated in ''Figure 17'' which shows a newly fitted polynomial between a much smaller range of temperatures (T = 2.15-2.55) and a much smaller degree polynomial (3).

[[File:CG1417FIT_16x16C_3.png|thumb|left|400px|Figure 16 - Graph showing Heat Capacity against Temperature for a 16x16 matrix along with a fitted polynomial between a much more restricted range of temperatures and a significantly lower degree of polynomial]]

Upon comparison with ''Figure 15'', the new fitted polynomial is a significantly better fit even for a 3rd degree polynomial and is a much more accurate representation of my data around the peak of the graph and will make it easier to determine the maximum value of Heat Capacity.

 

===TASK: find the temperature at which the maximum in C occurs for each datafile that you were given. Make a text file containing two colums: the lattice side length (2,4,8, etc.), and the temperature at which C is a maximum. This is your estimate of <math>T_C</math> for that side length. Make a plot that uses the scaling relation given above to determine <math>T_{C,\infty}</math>. By doing a little research online, you should be able to find the theoretical exact Curie temperature for the infinite 2D Ising lattice. How does your value compare to this? Are you surprised by how good/bad the agreement is? Attach a PNG of this final graph to your report, and discuss briefly what you think the major sources of error are in your estimate.===

Figure 17 below shows a graph of <math>T_{C,L}</math> against <math>\frac{1}{Lattice Size}</math> to determine the Curie Temperature of an infinite 2D Ising Model Lattice <math>T_{C,\infty}</math>. The black dots represent the raw data obtained from obtaining the temperature at which the Heat Capacity was a maximum for the lattices and the red line in a linear curve fit plotted against the data to allow the y-intercept which is the Curie Temperature for the infinite 2D lattice to be determined.

[[File:cg1417CurieTemp.png|400px|thumb|left|Figure 17 - Plot of 1/Lattice Size against Curie Temperature for that lattice size.]]

The value for <math>T_{C,\inf}</math> obtained from the data is <math>T_{C,\infty} = 2.277 \frac{J}{k_B}</math> with a literature value being <math>T_{C,\infty} = 2.269 \frac{J}{k_B}</math> for an infinite square 2D lattice. This means that my result slightly over-estimates the Curie Temperature for the infinite lattice and as a result for an infinite lattice the temperature at which spontaneous magnetisation stops would actually occur at a slightly lower temperature than expected. However, the difference between my value and the literature value is only 0.008 which is incredibly small and the amount of agreement between the two values is somewhat surprising, which means that the error in my estimates of the Curie Temperature for each lattice size is relatively small. A potential source of error from the values of the Curie Temperature for each lattice size could come from the

Rep:Y3CMPCG1417

2019-11-20T07:55:23Z

==Section 1 - Introduction to the Ising Model==

===TASK: Show that the lowest possible energy for the Ising model is <math>E = -DNJ</math>, where D is the number of dimensions and N is the total number of spins. What is the multiplicity of this state? Calculate its entropy.===

Consider a 1D row of lattice sites of N=3 with spin configuration [+1][+1][+1].

Mathematically the interaction energy is defined asː
<math> -\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} </math> where J is a constant and <math>s_{i}s_{j}</math> is the product between two spins in adjacent lattice sites.

The sum of the interaction energies <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j}</math> can be considered as the sum of the individual interaction energies between spinsː
<math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = \epsilon_{12} + \epsilon_{23} + \epsilon_{13} + \epsilon_{21} + \epsilon_{32} + \epsilon_{31} </math>.

Although lattice sites 1 and 3 are not adjacent they are said to still interact according to the periodic boundary conditions applied.

However, <math>\epsilon_{12} = \epsilon_{21} </math> and <math>\epsilon_{23} = \epsilon_{32}</math> and <math>\epsilon_{13} = \epsilon_{31}</math> which means that all of the interactions within the system are counted twice, hence the total energy needs to be halved, resulting in the following formula being obtainedː <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = 2\epsilon_{12} + 2\epsilon_{13} + 2\epsilon_{23} </math>.

It can be determined that <math>\epsilon_{12} = (+1)(+1) = 1</math> , <math>\epsilon_{13} = (+1)(+1) = 1</math> and <math>\epsilon_{23} = (+1)(+1) = 1</math>.

Thereforeː <math>-\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = -\frac{1}{2} \ J \ (2 + 2 + 2) = -\frac{1}{2} \ J \ 6 = - 3 J = -DNJ</math> for a 1D lattice with <math>D=1</math> and 3 lattice sites <math>N=3</math>

The multiplicity of the system,<math>\Omega = 2S+1</math> where <math>S</math> is the total magnetisation of the system.

In this case, <math>\Omega = 2(3)+1 = 7</math>

Entropy, <math>S</math> is defined as <math>S = k_B ln(\Omega)</math> and so in this case <math>S = k_B ln7 = 1.95 k_B</math>

===TASK: Imagine that the system is in the lowest energy configuration. To move to a different state, one of the spins must spontaneously change direction ("flip"). What is the change in energy if this happens <math>(D=3, N=1000)</math>? How much entropy does the system gain by doing soʔ===

In a 3D lattice system, each lattice site has three unique interactions with its neighbours to its left, top and front. In the lowest energy configuration, all spins are parallel and for a system the minimum energy is <math>E = -DNJ</math>, so for the system with <math>N=1000</math> and <math>D=3</math>, the minimum energy is <math>-3000J</math>.

If a single spin is flipped, the product of its spin with its neighbours spin reverses and becomes negative and this increases the total energy of the system. Since 3 unique spin-spin interactions are reversed in sign, the total energy increases by <math>+3J</math>, meaning the new total energy is <math>-2997J</math>

Initially the multiplicity of the system will be <math>\Omega = 2(1000)+1=2001</math> , and after the flip, the multiplicity becomes <math>\Omega = 2(1000-1)+1=1999</math>.

The associated change in entropy, <math>\Delta S = k_B ln(1999) - k_B ln(2001)= k_B ln(\frac{1999}{2001}) = -0.001 k_B</math>, which is a very small decrease in entropy as the system starts

===TASK: Calculate the magnetisation of the 1D and 2D lattices in Figure 1. What magnetisation would you expect to observe for an Ising lattice with <math>D = 3,\ N=1000</math> at absolute zero?===

[[File:ThirdYearCMPExpt-IsingSketch.png|thumb|left|Figure 1 - Shows 1D (N = 5), 2D (N = 5x5) and 3D (N = 5x5x5) lattices.]]

Magnetisation is defined as <math>M=\sum_{i} s_i</math>. So for the 1D lattice with <math>N = 5</math> in ''Figure 2'', <math>M = +1</math> and for the 2D lattice with <math>N = 25 , M = +1</math> too.

According to the 3rd Law of thermodynamics, entropy is 0 at absolute zero for a perfect crystalline solid, and consequently it is expected that the lattices will have follow suit and have zero entropy at 0K. To have zero entropy all spins must be paired as such that magnetisation, <math>M = 0</math> - which is only possible in the lattices contains an even numbers of lattice sites (N = even). So, for a lattice with <math>N = 1000</math> and <math>D =3</math>, if <math>M = 0</math>, then multiplicity, <math>\Omega = 1</math> and entropy, <math>S =k_B ln(\Omega) = 0</math>.

==Section 2 - Calculating the Energy and Magnetisation==

===TASK: complete the functions energy() and magnetisation(), which should return the energy of the lattice and the total magnetisation, respectively. In the energy() function you may assume that <math>J=1.0</math> at all times (in fact, we are working in reduced units in which <math>J=k_B</math>, but there will be more information about this in later sections). Do not worry about the efficiency of the code at the moment — we will address the speed in a later part of the experiment.===

<pre>def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
lat=self.lattice #creates lattice and stores it
mag=[]
for i in range(0,len(lat)): #loops through all rows of lattice
for j in range(0,len(lat[i])): #loops through elements of each row
mag+=[lat[i][j]] #adds spin value to mag array
return sum(mag) #sums all spins from mag array
</pre>

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

lat=self.lattice #creates lattice and stores it
left=[]
top=[]

for i in range(0,len(lat)):
for j in range(0,len(lat[i])):
left+=[lat[i][j]*lat[i][j-1]] #multiplies spin by spin to left
top+=[lat[i][j]*lat[i-1][j]] #multiplies spin by spin above it
int_en=left+top #sums spin products from left and top
energy=-sum(int_en) #sums all spin products for each spin to give total

return energy
</pre>

===TASK: Run the ILcheck.py script from the IPython Qt console using the command===

''Figure 2'' shows the results when ILcheck.py was ran on my IsingLattice.py file. The ILcheck.py file was ran several times to ensure the code worked for various random lattices.

[[File:Cg1417ILcheck run.png|thumb|left|500px| Figure 2 - Result from running the ILcheck.py file]]

 

==Section 3 - Introduction to Monte Carlo Simulation==

===TASK: How many configurations are available to a system with 100 spins? To evaluate these expressions, we have to calculate the energy and magnetisation for each of these configurations, then perform the sum. Let's be very, very, generous, and say that we can analyse <math>1\times 10^9</math> configurations per second with our computer. How long will it take to evaluate a single value of <math>\left\langle M\right\rangle_T</math>?===

For a system with 100 lattice sites and two possible spins for each site, there are <math>2^{100}</math>possible configurations for the system. <math>2^{100}= 1.27\times 10^{30} </math>, so if the computer can analyse <math>1\times 10^9</math> configurations per second, then it will take <math>\frac{1.27\times 10^{30}}{10^9} = 1.27\times 10^{21} s</math> to analyse the whole system, which is older than the age of the universe and therefore is not a practical approach.

===TASK: Implement a single cycle of the above algorithm in the montecarlocycle(T) function. This function should return the energy of your lattice and the magnetisation at the end of the cycle. You may assume that the energy returned by your energy() function is in units of <math>k_B</math>! Complete the statistics() function. This should return the following quantities whenever it is called: <math><E>, <E^2>, <M>, <M^2></math>, and the number of Monte Carlo steps that have elapsed.===
<pre>
E = []
E2 = []
M = []
M2 = []
n_cycles = 0

def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back if rejected else not changed

self.E+=[self.energy()] #records energy
self.E2+=[self.energy()**2] #records energy squared
self.M+=[self.magnetisation()] #records magnetisation
self.M2+=[self.magnetisation()**2] #records magnetisation squared
self.n_cycles=self.n_cycles+1 #adds 1 to run total

return (self.energy(),self.magnetisation())

def statistics(self):
# complete this function so that it calculates the correct values for the averages of E, E*E (E2), M, M*M (M2), and returns them

e=np.mean(self.E)
e2=np.mean(self.E2)
m=np.mean(self.M)
m2=np.mean(self.M2)

return e,e2,m,m2,self.n_cycles
</pre>

===TASK: If <math>T < T_C</math>, do you expect a spontaneous magnetisation (i.e. do you expect <math>\left\langle M\right\rangle \neq 0</math>)? When the state of the simulation appears to stop changing (when you have reached an equilibrium state), use the controls to export the output to PNG and attach this to your report. You should also include the output from your statistics() function.===

If the temperature of the system is less than the Curie Temperature, <math>T_C</math> then spontaneous magnetisation can occur and the system will tend to its lowest energy state where all of the spins are parallel - this is a property of ferromagnetic materials.

[[File:Cg1417ILanim_run.png|400px|thumb|left|Figure 3 - Results from running the ILanim.py file - shows the energy and magnetisation converging over time]]

''Figure 3'' shows that over time the the system spontaneously converges to the minimum energy state with all of the spins parallel to one another and shows, as I expected, that spontaneous magnetisation occurs and also shows that the temperature of this simulation is below the Curie Temperature, <math>T < T_C</math>.

 

==Section 4 - Accelerating the Code==

===TASK: Use the script ILtimetrial.py to record how long your current version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 4'' show the results of running the ILtimetrial.py file on my code three timesː

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1.png
| width1=500
| image2=cg1417ILtimetrial_run2.png
| width2=500
| image3=cg1417ILtimetrial_run3.png
| width3=500
| footer = Figure 4 - Results of running the ILtimetrial.py file on my code three separate times
}}
 

This gave me an avergage time of <math>24.3 s \pm 0.2s</math>

===TASK: Look at the documentation for the NumPy sum function. You should be able to modify your magnetisation() function so that it uses this to evaluate M. The energy is a little trickier. Familiarise yourself with the NumPy roll and multiply functions, and use these to replace your energy double loop (you will need to call roll and multiply twice!).===

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

left=multiply(roll(self.lattice,1,axis=1),self.lattice) #product of spin with spin left of it
top=multiply(roll(self.lattice,-1,axis=0),self.lattice) #product of spin with spin above it

int_en=sum(left+top) #sum of array containing sum of left and top spin products for each spin

energy = -sum(int_en) #calculates the total energy of system
return energy

def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
return sum(sum(self.lattice)) #adds up all spins in lattice
</pre>

===TASK: Use the script ILtimetrial.py to record how long your new version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 5'' shows the result of running the ILtimetrial.py on my new accelerated code.

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1fast.png
| width1=500
| image2=ILtimetrial_run2fast.png
| width2=500
| image3=ILtimetrial_run3fast.png
| width3=500
| footer = Figure 5 - Results of running the ILtimetrial.py file on my new updated and accelerated code.
}}
 

The accelerated code is much faster upon using the roll, multiply and s with a new average time of <math>0.790 s \pm 0.005 </math>

==Section 5 - The effect of temperature==

===TASK: The script ILfinalframe.py runs for a given number of cycles at a given temperature, then plots a depiction of the final lattice state as well as graphs of the energy and magnetisation as a function of cycle number. This is much quicker than animating every frame! Experiment with different temperature and lattice sizes. How many cycles are typically needed for the system to go from its random starting position to the equilibrium state? Modify your statistics() and montecarlostep() functions so that the first N cycles of the simulation are ignored when calculating the averages. You should state in your report what period you chose to ignore, and include graphs from ILfinalframe.py to illustrate your motivation in choosing this figure.===

''Figure 6'' below shows the results from running the ILfinalframe.py for 2x2 lattice at T=1,2,3,5.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2T1.png
| image2 = cg14172x2T2.png
| image3 =cg14172x2T3.png
| image4 =cg14172x2T5.png
| footer_align = left
| footer = Figure 6 - Results of running the ILfinalframe.py file at T=1,2,3,5 for a 2x2 matrix.
}}

 

For a 2x2 matrix, a suitable cut-off point to exclude from the avergage energies and magnetisations is where the energy and magnetisations per spin are constant, which is 30 steps. For T=3 and T=5 the graphs do not converge because it is possible that these temperatures are higher than the Curie Temperature and as such spontaneous magnetisation will not occur and the system will not diverge to the lowest energy state. At the higher temperatures, there are larger thermal fluctations and the Boltzmann factor is more significant allowing the system to move away from the lowest energy state easier. As a result moving forwards, a suitable cut-off point will only be determined from T=1 and T=2 graphs for the larger matrices.

''Figure 7'' shows the results from running a 4x4 lattice at T=1,2 and 3.

{{multiple image
| width =350
| align = left
| image1 = cg14174x4T1.png
| image2 = cg14174x4T2.png
| image3 =cg14174x4T3.png
| footer_align = left
| footer = Figure 7 - Results of running the ILfinalframe.py file at T=1,2,3 for a 4x4 matrix.
}}

From ''Figure 7'', a suitable cut-off point for the energy and magnetisations is 200 as this is after where the energy and magnetisation has converged for T=1, and is after the initial large drop in energy for T=2, even though there are a few small fluctuations after 200 steps. The result from T=3 has been included to show the large fluctuations for the larger temperatures, and supporting my choice to determine the cut-off from T=1 and T=2 only.

''Figure 8'' shows the results for an 8x8 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg14178x8T1.png
| image2 = cg14178x8T2.png
| footer_align = left
| footer = Figure 8 - Results of running the ILfinalframe.py file at T=1,2 for an 8x8 matrix
}}

From ''Figure 8'' above, a suitable cut-off point is 1000 steps as this is where the energy and magnetisation has easily converged by and is also the point after which the initial large drop in energy has been overcome for T=2 too.

''Figure 9'' shows the result of running the ILfinalframe.py for a 16x16 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg141716x16T1.png
| image2 = cg141716x16T2.png
| footer_align = left
| footer = Figure 9 - Results of running the ILfinalframe.py file at T=1,2 for a 16x16 matrix
}}

From ''Figure 9'', a suitable cut-off point is 15000 steps as for T=1 the energy and magnetisations have converged significantly and will not change much, and likewise this is the same for the T=2 frame.

''Figure 10'' below shows the results from a 32x32 matrix at T=1 and T=2.

{{multiple image
| width =350
| align = left
| image1 = cg141732x32T1.png
| image2 = cg141732x32T2.png
| footer_align = left
| footer = Figure 10 - Results of running the ILfinalframe.py file at T=1,2 for a 32x32 matrix
}}

''Figure 10'' above shows the results of running the ILfinalframe.py file for a 32x32 matrix at T=1 and T=2. As a result a suitable cut-off of 50000 steps was chosen as the energy and magnetisation has significantly converged, but not as much as it could at 100000 steps. I chose a slightly lower value to ensure that the run times of my monte-carlo simulations in future tasks were not extremely time consuming.

The montecarlostep() function was changed by adding a condition that values only above the pre-determined cut-off were included when determining the average value of energy; energy squared; magnetisation and magnetisations squared from the statistics function. The statistics() function did not need to be modified.

The following code is from the 32x32 matrixː

<pre>def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back

if self.n_cycles > 50000: #only adds values to array of E,E2,M and M2 is above specific cut-off
self.E+=[self.energy()]
self.E2+=[self.energy()**2]
self.M+=[self.magnetisation()]
self.M2+=[self.magnetisation()**2]
self.n_cycles=self.n_cycles+1

return (self.energy(),self.magnetisation())
</pre>

===TASK: Use ILtemperaturerange.py to plot the average energy and magnetisation for each temperature, with error bars, for an <math>8\times 8</math> lattice. Use your intuition and results from the script ILfinalframe.py to estimate how many cycles each simulation should be. The temperature range 0.25 to 5.0 is sufficient. Use as many temperature points as you feel necessary to illustrate the trend, but do not use a temperature spacing larger than 0.5. The NumPy function savetxt() stores your array of output data on disk — you will need it later. Save the file as 8x8.dat so that you know which lattice size it came from.===

Using the modified code, the file ILtemperaturerange.py was ran on an 8x8 matrix between T=0.5 and T=5 with a step of T=0.02 for 10000 Montecarlo steps and the first 1000 steps of each temperature were excluded when calculating the averages. ''Figure 11'' shows the result of the simulation and also included error bars of standard deviation.

[[File:Cg14178x8error.png|1000px|thumb|left|Figure 11 - Graph showing average energy and average magnetisation for an 8x8 lattice with error bars between T=0.5 and T=5]]

 

==Section 6 - The effect of system size==

===TASK: Repeat the final task of the previous section for the following lattice sizes: 2x2, 4x4, 8x8, 16x16, 32x32. Make sure that you name each datafile that your produce after the corresponding lattice size! Write a Python script to make a plot showing the energy per spin versus temperature for each of your lattice sizes. Hint: the NumPy loadtxt function is the reverse of the savetxt function, and can be used to read your previously saved files into the script. Repeat this for the magnetisation. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. How big a lattice do you think is big enough to capture the long range fluctuations?===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb.

Each matrix was simulated using the ILtemperaturerange.py file between T=0.5 and T=5 with a step of T=0.02.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2error.png
| caption1 = 2x2 matrix - 5000 steps, cut-off = 30 steps
| image2 = 4x4error.png
| caption2 = 4x4 matrix - 1000 steps, cut-off = 200 steps
| image3 =cg141716x16error.png
| caption3 = 16x16 matrix - 50000 steps, cut-off = 15000 steps
| image4 =cg141732x32error.png
| caption4 = 32x32 matrix - 200000 steps, cut-off = 50000 steps
| footer_align = left
| footer = Figure 12 - Results of running the ILtemperaturerange.py file for 2x2, 4x4, 16x16 and 32x32 matrices.
}}

 

==Section 7 - Determining the Heat Capacity==

===TASK: By definition, <math>C = \frac{\partial \left\langle E\right\rangle}{\partial T}</math>. From this, show that <math>C = \frac{\mathrm{Var}[E]}{k_B T^2}</math> (Where <math>\mathrm{Var}[E]</math> is the variance in <math>E</math>.)===

Recall from statistical thermodynamics that the average energy of a system is the sum across all microstates of the probability of that microstate multiplied by the energy of that microstate, which is defined mathematically asː <math>\langle E \rangle = \sum_i p_{i}\epsilon_{i}</math>.

The partition function <math>q</math> is defined as <math>q = \sum_{i} exp(-\beta \epsilon_{i})</math> where <math>\beta =\frac{1}{k_BT}</math>and the probability, <math>p_{i}</math> can be defined in terms of the partition function as <math>p_{i} = \frac{exp(-\beta \epsilon_{i})}{\sum_{i} exp(-\beta \epsilon_{i})} = \frac{exp(-\beta \epsilon_{i})}{q}</math>.

As a result, <math>\langle E \rangle</math> can be re-written as <math>\langle E \rangle = \sum_{i} \frac{\epsilon_{i} exp(-\beta \epsilon_{i})}{q} = -\frac{1}{q} \frac{\partial}{\partial \beta}\sum_{i}exp(-\beta \epsilon_{i}) = -\frac{1}{q} \frac{\partial q}{\partial \beta}</math>

Likewise, <math>\langle E^2 \rangle = \sum_i p_{i}\epsilon_{i}^{2} = \sum_{i} \frac{\epsilon_{i}^{2}exp(-\beta \epsilon_{i})}{q} = \frac{1}{q} \frac{\partial^{2}}{\partial \beta^{2}}\sum_{i}exp(-\beta \epsilon_{i}) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}}</math>

From definitionː <math>Var[E] = \Delta E^2 = \langle E^2 \rangle - \langle E \rangle^2 </math>

When the definition of <math>\langle E \rangle</math> and <math>\langle E^2 \rangle</math> is written in terms of partition function <math>q</math>ː <math>Var[E] = \langle E^2 \rangle - \langle E \rangle^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \left(\frac{1}{q}\frac{\partial q}{\partial \beta}\right)^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2</math>.

According to the chain ruleː <math>\frac{\partial}{\partial \beta}\left(\frac{1}{q} \frac{\partial q}{\partial \beta}\right) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2 = -\frac{\partial}{\partial \beta}\langle E \rangle = Var[E]</math>

And using the chain rule againː <math>C = \frac{\partial \langle E \rangle}{\partial T}= \left(-\frac{\partial \langle E \rangle}{\partial \beta}\right) \left(-\frac{\partial \beta}{\partial T}\right) = \frac{Var[E]}{k_B T^2}</math>

===TASK: Write a Python script to make a plot showing the heat capacity versus temperature for each of your lattice sizes from the previous section. You may need to do some research to recall the connection between the variance of a variable, <math>\mathrm{Var}[X]</math>, the mean of its square <math>\left\langle X^2\right\rangle</math>, and its squared mean <math>\left\langle X\right\rangle^2</math>. You may find that the data around the peak is very noisy — this is normal, and is a result of being in the critical region. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. ===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb

{{multiple image
| width =300
| align = left
| image1 = cg14172x2heatcap.png
| caption1 = 2x2 Matrix
| image2 = cg14174x4heatcap.png
| caption2 = 4x4 Matrix
| image3 =cg14178x8heatcap.png
| caption3 = 8x8 Matrix
| image4 =cg141716x16heatcap.png
| caption4 = 16x16 Matrix
| image5=cg141732x32heatcap.png
| caption5= 32x32 Matrix
| footer = Figure 13 - Graphs showing Heat Capacity against Temperature for each matrix size
}}

A general trend from the above graphs is that the peak of the graph shifts towards lower temperatures as the size of the matrix used increases.

==Section 8 - Locating the Curie Temperature==
===TASK: A C++ program has been used to run some much longer simulations than would be possible on the college computers in Python. You can view its source code here if you are interested. Each file contains six columns: <math>T, E, E^2, M, M^2, C</math> (the final five quantities are per spin), and you can read them with the NumPy loadtxt function as before. For each lattice size, plot the C++ data against your data. For one lattice size, save a PNG of this comparison and add it to your report — add a legend to the graph to label which is which. To do this, you will need to pass the label="..." keyword to the plot function, then call the legend() function of the axis object (documentation here).===

The python code used to read and plot the C++ data is found in the Jupyter notebook CG1417IsingModelGraphs.ipynb.

''Figure 14'' below shows the C++ plotted against my own data for a 16x16 Matrix.

[[File:Cg141716x16C++.png|400px|thumb|left|Figure 15 - Graph showing my own data against the C++ data for a 16x16 matrix.]]

 

===TASK: write a script to read the data from a particular file, and plot C vs T, as well as a fitted polynomial. Try changing the degree of the polynomial to improve the fit — in general, it might be difficult to get a good fit! Attach a PNG of an example fit to your report.===

The python script to read and plot the fitted polynomial is found in CG1417PolyfitScript.ipynb

Below in ''Figure 16'' is a plot of my Heat Capacity against Temperature data for a 16x16 matrix and features a polynomial of degree 35 plotted against it. Even with a polynomial of such a high degree, it poorly fits the curve and does not fit to the peak of the curve either.

[[File:cg1417FIT_TEST16x16_35.png|thumb|left|400px|Figure 16 - Plot of Heat Capacity against Temperature along with a poorly fitted polynomial of degree 35. ]]

 

===TASK: Modify your script from the previous section. You should still plot the whole temperature range, but fit the polynomial only to the peak of the heat capacity! You should find it easier to get a good fit when restricted to this region===

The script was modified as such that the polynomial was fitted in a set range around the peak of the graph, this is demonstrated in ''Figure 17'' which shows a newly fitted polynomial between a much smaller range of temperatures (T = 2.15-2.55) and a much smaller degree polynomial (3).

[[File:CG1417FIT_16x16C_3.png|thumb|left|400px|Figure 17 - Graph showing Heat Capacity against Temperature for a 16x16 matrix along with a fitted polynomial between a much more restricted range of temperatures and a significantly lower degree of polynomial]]

Upon comparison with ''Figure 16'', the new fitted polynomial is a significantly better fit even for a 3rd degree polynomial and is a much more accurate representation of my data around the peak of the graph and will make it easier to determine the maximum value of Heat Capacity.

 

===TASK: find the temperature at which the maximum in C occurs for each datafile that you were given. Make a text file containing two colums: the lattice side length (2,4,8, etc.), and the temperature at which C is a maximum. This is your estimate of <math>T_C</math> for that side length. Make a plot that uses the scaling relation given above to determine <math>T_{C,\infty}</math>. By doing a little research online, you should be able to find the theoretical exact Curie temperature for the infinite 2D Ising lattice. How does your value compare to this? Are you surprised by how good/bad the agreement is? Attach a PNG of this final graph to your report, and discuss briefly what you think the major sources of error are in your estimate.===

Figure 17 below shows a graph of <math>T_{C,L}</math> against <math>\frac{1}{Lattice Size}</math> to determine the Curie Temperature of an infinite 2D Ising Model Lattice <math>T_{C,\infty}</math>. The black dots represent the raw data obtained from obtaining the temperature at which the Heat Capacity was a maximum for the lattices and the red line in a linear curve fit plotted against the data to allow the y-intercept which is the Curie Temperature for the infinite 2D lattice to be determined.

[[File:cg1417CurieTemp.png|400px|thumb|left|Figure 17 - Plot of 1/Lattice Size against Curie Temperature for that lattice size.]]

The value for <math>T_{C,\inf}</math> obtained from the data is <math>T_{C,\infty} = 2.277 \frac{J}{k_B}</math> with a literature value being <math>T_{C,\infty} = 2.269 \frac{J}{k_B}</math> for an infinite square 2D lattice. This means that my result slightly over-estimates the Curie Temperature for the infinite lattice and as a result for an infinite lattice the temperature at which spontaneous magnetisation stops would actually occur at a slightly lower temperature than expected. However, the difference between my value and the literature value is only 0.008 which is incredibly small and the amount of agreement between the two values is somewhat surprising, which means that the error in my estimates of the Curie Temperature for each lattice size is relatively small. A potential source of error from the values of the Curie Temperature for each lattice size could come from the

Rep:Y3CMPCG1417

2019-11-20T07:54:45Z

==Section 1 - Introduction to the Ising Model==

===TASK: Show that the lowest possible energy for the Ising model is <math>E = -DNJ</math>, where D is the number of dimensions and N is the total number of spins. What is the multiplicity of this state? Calculate its entropy.===

Consider a 1D row of lattice sites of N=3 with spin configuration [+1][+1][+1].

Mathematically the interaction energy is defined asː
<math> -\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} </math> where J is a constant and <math>s_{i}s_{j}</math> is the product between two spins in adjacent lattice sites.

The sum of the interaction energies <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j}</math> can be considered as the sum of the individual interaction energies between spinsː
<math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = \epsilon_{12} + \epsilon_{23} + \epsilon_{13} + \epsilon_{21} + \epsilon_{32} + \epsilon_{31} </math>.

Although lattice sites 1 and 3 are not adjacent they are said to still interact according to the periodic boundary conditions applied.

However, <math>\epsilon_{12} = \epsilon_{21} </math> and <math>\epsilon_{23} = \epsilon_{32}</math> and <math>\epsilon_{13} = \epsilon_{31}</math> which means that all of the interactions within the system are counted twice, hence the total energy needs to be halved, resulting in the following formula being obtainedː <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = 2\epsilon_{12} + 2\epsilon_{13} + 2\epsilon_{23} </math>.

It can be determined that <math>\epsilon_{12} = (+1)(+1) = 1</math> , <math>\epsilon_{13} = (+1)(+1) = 1</math> and <math>\epsilon_{23} = (+1)(+1) = 1</math>.

Thereforeː <math>-\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = -\frac{1}{2} \ J \ (2 + 2 + 2) = -\frac{1}{2} \ J \ 6 = - 3 J = -DNJ</math> for a 1D lattice with <math>D=1</math> and 3 lattice sites <math>N=3</math>

The multiplicity of the system,<math>\Omega = 2S+1</math> where <math>S</math> is the total magnetisation of the system.

In this case, <math>\Omega = 2(3)+1 = 7</math>

Entropy, <math>S</math> is defined as <math>S = k_B ln(\Omega)</math> and so in this case <math>S = k_B ln7 = 1.95 k_B</math>

===TASK: Imagine that the system is in the lowest energy configuration. To move to a different state, one of the spins must spontaneously change direction ("flip"). What is the change in energy if this happens <math>(D=3, N=1000)</math>? How much entropy does the system gain by doing soʔ===

In a 3D lattice system, each lattice site has three unique interactions with its neighbours to its left, top and front. In the lowest energy configuration, all spins are parallel and for a system the minimum energy is <math>E = -DNJ</math>, so for the system with <math>N=1000</math> and <math>D=3</math>, the minimum energy is <math>-3000J</math>.

If a single spin is flipped, the product of its spin with its neighbours spin reverses and becomes negative and this increases the total energy of the system. Since 3 unique spin-spin interactions are reversed in sign, the total energy increases by <math>+3J</math>, meaning the new total energy is <math>-2997J</math>

Initially the multiplicity of the system will be <math>\Omega = 2(1000)+1=2001</math> , and after the flip, the multiplicity becomes <math>\Omega = 2(1000-1)+1=1999</math>.

The associated change in entropy, <math>\Delta S = k_B ln(1999) - k_B ln(2001)= k_B ln(\frac{1999}{2001}) = -0.001 k_B</math>, which is a very small decrease in entropy as the system starts

===TASK: Calculate the magnetisation of the 1D and 2D lattices in Figure 1. What magnetisation would you expect to observe for an Ising lattice with <math>D = 3,\ N=1000</math> at absolute zero?===

[[File:ThirdYearCMPExpt-IsingSketch.png|thumb|left|Figure 1 - Shows 1D (N = 5), 2D (N = 5x5) and 3D (N = 5x5x5) lattices.]]

Magnetisation is defined as <math>M=\sum_{i} s_i</math>. So for the 1D lattice with <math>N = 5</math> in ''Figure 2'', <math>M = +1</math> and for the 2D lattice with <math>N = 25 , M = +1</math> too.

According to the 3rd Law of thermodynamics, entropy is 0 at absolute zero for a perfect crystalline solid, and consequently it is expected that the lattices will have follow suit and have zero entropy at 0K. To have zero entropy all spins must be paired as such that magnetisation, <math>M = 0</math> - which is only possible in the lattices contains an even numbers of lattice sites (N = even). So, for a lattice with <math>N = 1000</math> and <math>D =3</math>, if <math>M = 0</math>, then multiplicity, <math>\Omega = 1</math> and entropy, <math>S =k_B ln(\Omega) = 0</math>.

==Section 2 - Calculating the Energy and Magnetisation==

===TASK: complete the functions energy() and magnetisation(), which should return the energy of the lattice and the total magnetisation, respectively. In the energy() function you may assume that <math>J=1.0</math> at all times (in fact, we are working in reduced units in which <math>J=k_B</math>, but there will be more information about this in later sections). Do not worry about the efficiency of the code at the moment — we will address the speed in a later part of the experiment.===

<pre>def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
lat=self.lattice #creates lattice and stores it
mag=[]
for i in range(0,len(lat)): #loops through all rows of lattice
for j in range(0,len(lat[i])): #loops through elements of each row
mag+=[lat[i][j]] #adds spin value to mag array
return sum(mag) #sums all spins from mag array
</pre>

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

lat=self.lattice #creates lattice and stores it
left=[]
top=[]

for i in range(0,len(lat)):
for j in range(0,len(lat[i])):
left+=[lat[i][j]*lat[i][j-1]] #multiplies spin by spin to left
top+=[lat[i][j]*lat[i-1][j]] #multiplies spin by spin above it
int_en=left+top #sums spin products from left and top
energy=-sum(int_en) #sums all spin products for each spin to give total

return energy
</pre>

===TASK: Run the ILcheck.py script from the IPython Qt console using the command===

''Figure 2'' shows the results when ILcheck.py was ran on my IsingLattice.py file. The ILcheck.py file was ran several times to ensure the code worked for various random lattices.

[[File:Cg1417ILcheck run.png|thumb|left|500px| Figure 2 - Result from running the ILcheck.py file]]

 

==Section 3 - Introduction to Monte Carlo Simulation==

===TASK: How many configurations are available to a system with 100 spins? To evaluate these expressions, we have to calculate the energy and magnetisation for each of these configurations, then perform the sum. Let's be very, very, generous, and say that we can analyse <math>1\times 10^9</math> configurations per second with our computer. How long will it take to evaluate a single value of <math>\left\langle M\right\rangle_T</math>?===

For a system with 100 lattice sites and two possible spins for each site, there are <math>2^{100}</math>possible configurations for the system. <math>2^{100}= 1.27\times 10^{30} </math>, so if the computer can analyse <math>1\times 10^9</math> configurations per second, then it will take <math>\frac{1.27\times 10^{30}}{10^9} = 1.27\times 10^{21} s</math> to analyse the whole system, which is older than the age of the universe and therefore is not a practical approach.

===TASK: Implement a single cycle of the above algorithm in the montecarlocycle(T) function. This function should return the energy of your lattice and the magnetisation at the end of the cycle. You may assume that the energy returned by your energy() function is in units of <math>k_B</math>! Complete the statistics() function. This should return the following quantities whenever it is called: <math><E>, <E^2>, <M>, <M^2></math>, and the number of Monte Carlo steps that have elapsed.===
<pre>
E = []
E2 = []
M = []
M2 = []
n_cycles = 0

def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back if rejected else not changed

self.E+=[self.energy()] #records energy
self.E2+=[self.energy()**2] #records energy squared
self.M+=[self.magnetisation()] #records magnetisation
self.M2+=[self.magnetisation()**2] #records magnetisation squared
self.n_cycles=self.n_cycles+1 #adds 1 to run total

return (self.energy(),self.magnetisation())

def statistics(self):
# complete this function so that it calculates the correct values for the averages of E, E*E (E2), M, M*M (M2), and returns them

e=np.mean(self.E)
e2=np.mean(self.E2)
m=np.mean(self.M)
m2=np.mean(self.M2)

return e,e2,m,m2,self.n_cycles
</pre>

===TASK: If <math>T < T_C</math>, do you expect a spontaneous magnetisation (i.e. do you expect <math>\left\langle M\right\rangle \neq 0</math>)? When the state of the simulation appears to stop changing (when you have reached an equilibrium state), use the controls to export the output to PNG and attach this to your report. You should also include the output from your statistics() function.===

If the temperature of the system is less than the Curie Temperature, <math>T_C</math> then spontaneous magnetisation can occur and the system will tend to its lowest energy state where all of the spins are parallel - this is a property of ferromagnetic materials.

[[File:Cg1417ILanim_run.png|400px|thumb|left|Figure 3 - Results from running the ILanim.py file - shows the energy and magnetisation converging over time]]

''Figure 3'' shows that over time the the system spontaneously converges to the minimum energy state with all of the spins parallel to one another and shows, as I expected, that spontaneous magnetisation occurs and also shows that the temperature of this simulation is below the Curie Temperature, <math>T < T_C</math>.

 

==Section 4 - Accelerating the Code==

===TASK: Use the script ILtimetrial.py to record how long your current version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 4'' show the results of running the ILtimetrial.py file on my code three timesː

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1.png
| width1=500
| image2=cg1417ILtimetrial_run2.png
| width2=500
| image3=cg1417ILtimetrial_run3.png
| width3=500
| footer = Figure 4 - Results of running the ILtimetrial.py file on my code three separate times
}}
 

This gave me an avergage time of <math>24.3 s \pm 0.2s</math>

===TASK: Look at the documentation for the NumPy sum function. You should be able to modify your magnetisation() function so that it uses this to evaluate M. The energy is a little trickier. Familiarise yourself with the NumPy roll and multiply functions, and use these to replace your energy double loop (you will need to call roll and multiply twice!).===

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

left=multiply(roll(self.lattice,1,axis=1),self.lattice) #product of spin with spin left of it
top=multiply(roll(self.lattice,-1,axis=0),self.lattice) #product of spin with spin above it

int_en=sum(left+top) #sum of array containing sum of left and top spin products for each spin

energy = -sum(int_en) #calculates the total energy of system
return energy

def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
return sum(sum(self.lattice)) #adds up all spins in lattice
</pre>

===TASK: Use the script ILtimetrial.py to record how long your new version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 5'' shows the result of running the ILtimetrial.py on my new accelerated code.

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1fast.png
| width1=500
| image2=ILtimetrial_run2fast.png
| width2=500
| image3=ILtimetrial_run3fast.png
| width3=500
| footer = Figure 5 - Results of running the ILtimetrial.py file on my new updated and accelerated code.
}}
 

The accelerated code is much faster upon using the roll, multiply and s with a new average time of <math>0.790 s \pm 0.005 </math>

==Section 5 - The effect of temperature==

===TASK: The script ILfinalframe.py runs for a given number of cycles at a given temperature, then plots a depiction of the final lattice state as well as graphs of the energy and magnetisation as a function of cycle number. This is much quicker than animating every frame! Experiment with different temperature and lattice sizes. How many cycles are typically needed for the system to go from its random starting position to the equilibrium state? Modify your statistics() and montecarlostep() functions so that the first N cycles of the simulation are ignored when calculating the averages. You should state in your report what period you chose to ignore, and include graphs from ILfinalframe.py to illustrate your motivation in choosing this figure.===

''Figure 6'' below shows the results from running the ILfinalframe.py for 2x2 lattice at T=1,2,3,5.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2T1.png
| image2 = cg14172x2T2.png
| image3 =cg14172x2T3.png
| image4 =cg14172x2T5.png
| footer_align = left
| footer = Figure 6 - Results of running the ILfinalframe.py file at T=1,2,3,5 for a 2x2 matrix.
}}

 

For a 2x2 matrix, a suitable cut-off point to exclude from the avergage energies and magnetisations is where the energy and magnetisations per spin are constant, which is 30 steps. For T=3 and T=5 the graphs do not converge because it is possible that these temperatures are higher than the Curie Temperature and as such spontaneous magnetisation will not occur and the system will not diverge to the lowest energy state. At the higher temperatures, there are larger thermal fluctations and the Boltzmann factor is more significant allowing the system to move away from the lowest energy state easier. As a result moving forwards, a suitable cut-off point will only be determined from T=1 and T=2 graphs for the larger matrices.

''Figure 7'' shows the results from running a 4x4 lattice at T=1,2 and 3.

{{multiple image
| width =350
| align = left
| image1 = cg14174x4T1.png
| image2 = cg14174x4T2.png
| image3 =cg14174x4T3.png
| footer_align = left
| footer = Figure 7 - Results of running the ILfinalframe.py file at T=1,2,3 for a 4x4 matrix.
}}

From ''Figure 7'', a suitable cut-off point for the energy and magnetisations is 200 as this is after where the energy and magnetisation has converged for T=1, and is after the initial large drop in energy for T=2, even though there are a few small fluctuations after 200 steps. The result from T=3 has been included to show the large fluctuations for the larger temperatures, and supporting my choice to determine the cut-off from T=1 and T=2 only.

''Figure 8'' shows the results for an 8x8 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg14178x8T1.png
| image2 = cg14178x8T2.png
| footer_align = left
| footer = Figure 8 - Results of running the ILfinalframe.py file at T=1,2 for an 8x8 matrix
}}

From ''Figure 8'' above, a suitable cut-off point is 1000 steps as this is where the energy and magnetisation has easily converged by and is also the point after which the initial large drop in energy has been overcome for T=2 too.

''Figure 9'' shows the result of running the ILfinalframe.py for a 16x16 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg141716x16T1.png
| image2 = cg141716x16T2.png
| footer_align = left
| footer = Figure 9 - Results of running the ILfinalframe.py file at T=1,2 for a 16x16 matrix
}}

From ''Figure 9'', a suitable cut-off point is 15000 steps as for T=1 the energy and magnetisations have converged significantly and will not change much, and likewise this is the same for the T=2 frame.

''Figure 10'' below shows the results from a 32x32 matrix at T=1 and T=2.

{{multiple image
| width =350
| align = left
| image1 = cg141732x32T1.png
| image2 = cg141732x32T2.png
| footer_align = left
| footer = Figure 10 - Results of running the ILfinalframe.py file at T=1,2 for a 32x32 matrix
}}

''Figure 10'' above shows the results of running the ILfinalframe.py file for a 32x32 matrix at T=1 and T=2. As a result a suitable cut-off of 50000 steps was chosen as the energy and magnetisation has significantly converged, but not as much as it could at 100000 steps. I chose a slightly lower value to ensure that the run times of my monte-carlo simulations in future tasks were not extremely time consuming.

The montecarlostep() function was changed by adding a condition that values only above the pre-determined cut-off were included when determining the average value of energy; energy squared; magnetisation and magnetisations squared from the statistics function. The statistics() function did not need to be modified.

The following code is from the 32x32 matrixː

<pre>def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back

if self.n_cycles > 50000: #only adds values to array of E,E2,M and M2 is above specific cut-off
self.E+=[self.energy()]
self.E2+=[self.energy()**2]
self.M+=[self.magnetisation()]
self.M2+=[self.magnetisation()**2]
self.n_cycles=self.n_cycles+1

return (self.energy(),self.magnetisation())
</pre>

===TASK: Use ILtemperaturerange.py to plot the average energy and magnetisation for each temperature, with error bars, for an <math>8\times 8</math> lattice. Use your intuition and results from the script ILfinalframe.py to estimate how many cycles each simulation should be. The temperature range 0.25 to 5.0 is sufficient. Use as many temperature points as you feel necessary to illustrate the trend, but do not use a temperature spacing larger than 0.5. The NumPy function savetxt() stores your array of output data on disk — you will need it later. Save the file as 8x8.dat so that you know which lattice size it came from.===

Using the modified code, the file ILtemperaturerange.py was ran on an 8x8 matrix between T=0.5 and T=5 with a step of T=0.02 for 10000 Montecarlo steps and the first 1000 steps of each temperature were excluded when calculating the averages. ''Figure 11'' shows the result of the simulation and also included error bars of standard deviation.

[[File:Cg14178x8error.png|1000px|thumb|left|Figure 11 - Graph showing average energy and average magnetisation for an 8x8 lattice with error bars between T=0.5 and T=5]]

 

==Section 6 - The effect of system size==

===TASK: Repeat the final task of the previous section for the following lattice sizes: 2x2, 4x4, 8x8, 16x16, 32x32. Make sure that you name each datafile that your produce after the corresponding lattice size! Write a Python script to make a plot showing the energy per spin versus temperature for each of your lattice sizes. Hint: the NumPy loadtxt function is the reverse of the savetxt function, and can be used to read your previously saved files into the script. Repeat this for the magnetisation. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. How big a lattice do you think is big enough to capture the long range fluctuations?===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb.

Each matrix was simulated using the ILtemperaturerange.py file between T=0.5 and T=5 with a step of T=0.02.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2error.png
| caption1 = 2x2 matrix - 5000 steps, cut-off = 30 steps
| image2 = 4x4error.png
| caption2 = 4x4 matrix - 1000 steps, cut-off = 200 steps
| image3 =cg141716x16error.png
| caption3 = 16x16 matrix - 50000 steps, cut-off = 15000 steps
| image4 =cg141732x32error.png
| caption4 = 32x32 matrix - 200000 steps, cut-off = 50000 steps
| footer_align = left
| footer = Figure 12 - Results of running the ILtemperaturerange.py file for 2x2, 4x4, 16x16 and 32x32 matrices.
}}

 

==Section 7 - Determining the Heat Capacity==

===TASK: By definition, <math>C = \frac{\partial \left\langle E\right\rangle}{\partial T}</math>. From this, show that <math>C = \frac{\mathrm{Var}[E]}{k_B T^2}</math> (Where <math>\mathrm{Var}[E]</math> is the variance in <math>E</math>.)===

Recall from statistical thermodynamics that the average energy of a system is the sum across all microstates of the probability of that microstate multiplied by the energy of that microstate, which is defined mathematically asː <math>\langle E \rangle = \sum_i p_{i}\epsilon_{i}</math>.

The partition function <math>q</math> is defined as <math>q = \sum_{i} exp(-\beta \epsilon_{i})</math> where <math>\beta =\frac{1}{k_BT}</math>and the probability, <math>p_{i}</math> can be defined in terms of the partition function as <math>p_{i} = \frac{exp(-\beta \epsilon_{i})}{\sum_{i} exp(-\beta \epsilon_{i})} = \frac{exp(-\beta \epsilon_{i})}{q}</math>.

As a result, <math>\langle E \rangle</math> can be re-written as <math>\langle E \rangle = \sum_{i} \frac{\epsilon_{i} exp(-\beta \epsilon_{i})}{q} = -\frac{1}{q} \frac{\partial}{\partial \beta}\sum_{i}exp(-\beta \epsilon_{i}) = -\frac{1}{q} \frac{\partial q}{\partial \beta}</math>

Likewise, <math>\langle E^2 \rangle = \sum_i p_{i}\epsilon_{i}^{2} = \sum_{i} \frac{\epsilon_{i}^{2}exp(-\beta \epsilon_{i})}{q} = \frac{1}{q} \frac{\partial^{2}}{\partial \beta^{2}}\sum_{i}exp(-\beta \epsilon_{i}) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}}</math>

From definitionː <math>Var[E] = \Delta E^2 = \langle E^2 \rangle - \langle E \rangle^2 </math>

When the definition of <math>\langle E \rangle</math> and <math>\langle E^2 \rangle</math> is written in terms of partition function <math>q</math>ː <math>Var[E] = \langle E^2 \rangle - \langle E \rangle^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \left(\frac{1}{q}\frac{\partial q}{\partial \beta}\right)^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2</math>.

According to the chain ruleː <math>\frac{\partial}{\partial \beta}\left(\frac{1}{q} \frac{\partial q}{\partial \beta}\right) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2 = -\frac{\partial}{\partial \beta}\langle E \rangle = Var[E]</math>

And using the chain rule againː <math>C = \frac{\partial \langle E \rangle}{\partial T}= \left(-\frac{\partial \langle E \rangle}{\partial \beta}\right) \left(-\frac{\partial \beta}{\partial T}\right) = \frac{Var[E]}{k_B T^2}</math>

===TASK: Write a Python script to make a plot showing the heat capacity versus temperature for each of your lattice sizes from the previous section. You may need to do some research to recall the connection between the variance of a variable, <math>\mathrm{Var}[X]</math>, the mean of its square <math>\left\langle X^2\right\rangle</math>, and its squared mean <math>\left\langle X\right\rangle^2</math>. You may find that the data around the peak is very noisy — this is normal, and is a result of being in the critical region. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. ===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb

{{multiple image
| width =300
| align = left
| image1 = cg14172x2heatcap.png
| caption1 = 2x2 Matrix
| image2 = cg14174x4heatcap.png
| caption2 = 4x4 Matrix
| image3 =cg14178x8heatcap.png
| caption3 = 8x8 Matrix
| image4 =cg141716x16heatcap.png
| caption4 = 16x16 Matrix
| image5=cg141732x32heatcap.png
| caption5= 32x32 Matrix
| footer = Figure 13 - Graphs showing Heat Capacity against Temperature for each matrix size
}}

A general trend from the above graphs is that the peak of the graph shifts towards lower temperatures as the size of the matrix used increases.

==Section 8 - Locating the Curie Temperature==
===TASK: A C++ program has been used to run some much longer simulations than would be possible on the college computers in Python. You can view its source code here if you are interested. Each file contains six columns: <math>T, E, E^2, M, M^2, C</math> (the final five quantities are per spin), and you can read them with the NumPy loadtxt function as before. For each lattice size, plot the C++ data against your data. For one lattice size, save a PNG of this comparison and add it to your report — add a legend to the graph to label which is which. To do this, you will need to pass the label="..." keyword to the plot function, then call the legend() function of the axis object (documentation here).===

The python code used to read and plot the C++ data is found in the Jupyter notebook CG1417IsingModelGraphs.ipynb.

''Figure 15'' below shows the C++ plotted against my own data for a 16x16 Matrix.

[[File:Cg141716x16C++.png|400px|thumb|left|Figure 15 - Graph showing my own data against the C++ data for a 16x16 matrix.]]

 

===TASK: write a script to read the data from a particular file, and plot C vs T, as well as a fitted polynomial. Try changing the degree of the polynomial to improve the fit — in general, it might be difficult to get a good fit! Attach a PNG of an example fit to your report.===

The python script to read and plot the fitted polynomial is found in CG1417PolyfitScript.ipynb

Below in ''Figure 16'' is a plot of my Heat Capacity against Temperature data for a 16x16 matrix and features a polynomial of degree 35 plotted against it. Even with a polynomial of such a high degree, it poorly fits the curve and does not fit to the peak of the curve either.

[[File:cg1417FIT_TEST16x16_35.png|thumb|left|400px|Figure 16 - Plot of Heat Capacity against Temperature along with a poorly fitted polynomial of degree 35. ]]

 

===TASK: Modify your script from the previous section. You should still plot the whole temperature range, but fit the polynomial only to the peak of the heat capacity! You should find it easier to get a good fit when restricted to this region===

The script was modified as such that the polynomial was fitted in a set range around the peak of the graph, this is demonstrated in ''Figure 17'' which shows a newly fitted polynomial between a much smaller range of temperatures (T = 2.15-2.55) and a much smaller degree polynomial (3).

[[File:CG1417FIT_16x16C_3.png|thumb|left|400px|Figure 17 - Graph showing Heat Capacity against Temperature for a 16x16 matrix along with a fitted polynomial between a much more restricted range of temperatures and a significantly lower degree of polynomial]]

Upon comparison with ''Figure 16'', the new fitted polynomial is a significantly better fit even for a 3rd degree polynomial and is a much more accurate representation of my data around the peak of the graph and will make it easier to determine the maximum value of Heat Capacity.

 

===TASK: find the temperature at which the maximum in C occurs for each datafile that you were given. Make a text file containing two colums: the lattice side length (2,4,8, etc.), and the temperature at which C is a maximum. This is your estimate of <math>T_C</math> for that side length. Make a plot that uses the scaling relation given above to determine <math>T_{C,\infty}</math>. By doing a little research online, you should be able to find the theoretical exact Curie temperature for the infinite 2D Ising lattice. How does your value compare to this? Are you surprised by how good/bad the agreement is? Attach a PNG of this final graph to your report, and discuss briefly what you think the major sources of error are in your estimate.===

Figure 17 below shows a graph of <math>T_{C,L}</math> against <math>\frac{1}{Lattice Size}</math> to determine the Curie Temperature of an infinite 2D Ising Model Lattice <math>T_{C,\infty}</math>. The black dots represent the raw data obtained from obtaining the temperature at which the Heat Capacity was a maximum for the lattices and the red line in a linear curve fit plotted against the data to allow the y-intercept which is the Curie Temperature for the infinite 2D lattice to be determined.

[[File:cg1417CurieTemp.png|400px|thumb|left|Figure 17 - Plot of 1/Lattice Size against Curie Temperature for that lattice size.]]

The value for <math>T_{C,\inf}</math> obtained from the data is <math>T_{C,\infty} = 2.277 \frac{J}{k_B}</math> with a literature value being <math>T_{C,\infty} = 2.269 \frac{J}{k_B}</math> for an infinite square 2D lattice. This means that my result slightly over-estimates the Curie Temperature for the infinite lattice and as a result for an infinite lattice the temperature at which spontaneous magnetisation stops would actually occur at a slightly lower temperature than expected. However, the difference between my value and the literature value is only 0.008 which is incredibly small and the amount of agreement between the two values is somewhat surprising, which means that the error in my estimates of the Curie Temperature for each lattice size is relatively small. A potential source of error from the values of the Curie Temperature for each lattice size could come from the

Rep:Y3CMPCG1417

2019-11-20T07:54:34Z

Cg1417: /* Section 6 - The effect of system size */

==Section 1 - Introduction to the Ising Model==

===TASK: Show that the lowest possible energy for the Ising model is <math>E = -DNJ</math>, where D is the number of dimensions and N is the total number of spins. What is the multiplicity of this state? Calculate its entropy.===

Consider a 1D row of lattice sites of N=3 with spin configuration [+1][+1][+1].

Mathematically the interaction energy is defined asː
<math> -\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} </math> where J is a constant and <math>s_{i}s_{j}</math> is the product between two spins in adjacent lattice sites.

The sum of the interaction energies <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j}</math> can be considered as the sum of the individual interaction energies between spinsː
<math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = \epsilon_{12} + \epsilon_{23} + \epsilon_{13} + \epsilon_{21} + \epsilon_{32} + \epsilon_{31} </math>.

Although lattice sites 1 and 3 are not adjacent they are said to still interact according to the periodic boundary conditions applied.

However, <math>\epsilon_{12} = \epsilon_{21} </math> and <math>\epsilon_{23} = \epsilon_{32}</math> and <math>\epsilon_{13} = \epsilon_{31}</math> which means that all of the interactions within the system are counted twice, hence the total energy needs to be halved, resulting in the following formula being obtainedː <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = 2\epsilon_{12} + 2\epsilon_{13} + 2\epsilon_{23} </math>.

It can be determined that <math>\epsilon_{12} = (+1)(+1) = 1</math> , <math>\epsilon_{13} = (+1)(+1) = 1</math> and <math>\epsilon_{23} = (+1)(+1) = 1</math>.

Thereforeː <math>-\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = -\frac{1}{2} \ J \ (2 + 2 + 2) = -\frac{1}{2} \ J \ 6 = - 3 J = -DNJ</math> for a 1D lattice with <math>D=1</math> and 3 lattice sites <math>N=3</math>

The multiplicity of the system,<math>\Omega = 2S+1</math> where <math>S</math> is the total magnetisation of the system.

In this case, <math>\Omega = 2(3)+1 = 7</math>

Entropy, <math>S</math> is defined as <math>S = k_B ln(\Omega)</math> and so in this case <math>S = k_B ln7 = 1.95 k_B</math>

===TASK: Imagine that the system is in the lowest energy configuration. To move to a different state, one of the spins must spontaneously change direction ("flip"). What is the change in energy if this happens <math>(D=3, N=1000)</math>? How much entropy does the system gain by doing soʔ===

In a 3D lattice system, each lattice site has three unique interactions with its neighbours to its left, top and front. In the lowest energy configuration, all spins are parallel and for a system the minimum energy is <math>E = -DNJ</math>, so for the system with <math>N=1000</math> and <math>D=3</math>, the minimum energy is <math>-3000J</math>.

If a single spin is flipped, the product of its spin with its neighbours spin reverses and becomes negative and this increases the total energy of the system. Since 3 unique spin-spin interactions are reversed in sign, the total energy increases by <math>+3J</math>, meaning the new total energy is <math>-2997J</math>

Initially the multiplicity of the system will be <math>\Omega = 2(1000)+1=2001</math> , and after the flip, the multiplicity becomes <math>\Omega = 2(1000-1)+1=1999</math>.

The associated change in entropy, <math>\Delta S = k_B ln(1999) - k_B ln(2001)= k_B ln(\frac{1999}{2001}) = -0.001 k_B</math>, which is a very small decrease in entropy as the system starts

===TASK: Calculate the magnetisation of the 1D and 2D lattices in Figure 1. What magnetisation would you expect to observe for an Ising lattice with <math>D = 3,\ N=1000</math> at absolute zero?===

[[File:ThirdYearCMPExpt-IsingSketch.png|thumb|left|Figure 1 - Shows 1D (N = 5), 2D (N = 5x5) and 3D (N = 5x5x5) lattices.]]

Magnetisation is defined as <math>M=\sum_{i} s_i</math>. So for the 1D lattice with <math>N = 5</math> in ''Figure 2'', <math>M = +1</math> and for the 2D lattice with <math>N = 25 , M = +1</math> too.

According to the 3rd Law of thermodynamics, entropy is 0 at absolute zero for a perfect crystalline solid, and consequently it is expected that the lattices will have follow suit and have zero entropy at 0K. To have zero entropy all spins must be paired as such that magnetisation, <math>M = 0</math> - which is only possible in the lattices contains an even numbers of lattice sites (N = even). So, for a lattice with <math>N = 1000</math> and <math>D =3</math>, if <math>M = 0</math>, then multiplicity, <math>\Omega = 1</math> and entropy, <math>S =k_B ln(\Omega) = 0</math>.

==Section 2 - Calculating the Energy and Magnetisation==

===TASK: complete the functions energy() and magnetisation(), which should return the energy of the lattice and the total magnetisation, respectively. In the energy() function you may assume that <math>J=1.0</math> at all times (in fact, we are working in reduced units in which <math>J=k_B</math>, but there will be more information about this in later sections). Do not worry about the efficiency of the code at the moment — we will address the speed in a later part of the experiment.===

<pre>def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
lat=self.lattice #creates lattice and stores it
mag=[]
for i in range(0,len(lat)): #loops through all rows of lattice
for j in range(0,len(lat[i])): #loops through elements of each row
mag+=[lat[i][j]] #adds spin value to mag array
return sum(mag) #sums all spins from mag array
</pre>

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

lat=self.lattice #creates lattice and stores it
left=[]
top=[]

for i in range(0,len(lat)):
for j in range(0,len(lat[i])):
left+=[lat[i][j]*lat[i][j-1]] #multiplies spin by spin to left
top+=[lat[i][j]*lat[i-1][j]] #multiplies spin by spin above it
int_en=left+top #sums spin products from left and top
energy=-sum(int_en) #sums all spin products for each spin to give total

return energy
</pre>

===TASK: Run the ILcheck.py script from the IPython Qt console using the command===

''Figure 2'' shows the results when ILcheck.py was ran on my IsingLattice.py file. The ILcheck.py file was ran several times to ensure the code worked for various random lattices.

[[File:Cg1417ILcheck run.png|thumb|left|500px| Figure 2 - Result from running the ILcheck.py file]]

 

==Section 3 - Introduction to Monte Carlo Simulation==

===TASK: How many configurations are available to a system with 100 spins? To evaluate these expressions, we have to calculate the energy and magnetisation for each of these configurations, then perform the sum. Let's be very, very, generous, and say that we can analyse <math>1\times 10^9</math> configurations per second with our computer. How long will it take to evaluate a single value of <math>\left\langle M\right\rangle_T</math>?===

For a system with 100 lattice sites and two possible spins for each site, there are <math>2^{100}</math>possible configurations for the system. <math>2^{100}= 1.27\times 10^{30} </math>, so if the computer can analyse <math>1\times 10^9</math> configurations per second, then it will take <math>\frac{1.27\times 10^{30}}{10^9} = 1.27\times 10^{21} s</math> to analyse the whole system, which is older than the age of the universe and therefore is not a practical approach.

===TASK: Implement a single cycle of the above algorithm in the montecarlocycle(T) function. This function should return the energy of your lattice and the magnetisation at the end of the cycle. You may assume that the energy returned by your energy() function is in units of <math>k_B</math>! Complete the statistics() function. This should return the following quantities whenever it is called: <math><E>, <E^2>, <M>, <M^2></math>, and the number of Monte Carlo steps that have elapsed.===
<pre>
E = []
E2 = []
M = []
M2 = []
n_cycles = 0

def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back if rejected else not changed

self.E+=[self.energy()] #records energy
self.E2+=[self.energy()**2] #records energy squared
self.M+=[self.magnetisation()] #records magnetisation
self.M2+=[self.magnetisation()**2] #records magnetisation squared
self.n_cycles=self.n_cycles+1 #adds 1 to run total

return (self.energy(),self.magnetisation())

def statistics(self):
# complete this function so that it calculates the correct values for the averages of E, E*E (E2), M, M*M (M2), and returns them

e=np.mean(self.E)
e2=np.mean(self.E2)
m=np.mean(self.M)
m2=np.mean(self.M2)

return e,e2,m,m2,self.n_cycles
</pre>

===TASK: If <math>T < T_C</math>, do you expect a spontaneous magnetisation (i.e. do you expect <math>\left\langle M\right\rangle \neq 0</math>)? When the state of the simulation appears to stop changing (when you have reached an equilibrium state), use the controls to export the output to PNG and attach this to your report. You should also include the output from your statistics() function.===

If the temperature of the system is less than the Curie Temperature, <math>T_C</math> then spontaneous magnetisation can occur and the system will tend to its lowest energy state where all of the spins are parallel - this is a property of ferromagnetic materials.

[[File:Cg1417ILanim_run.png|400px|thumb|left|Figure 3 - Results from running the ILanim.py file - shows the energy and magnetisation converging over time]]

''Figure 3'' shows that over time the the system spontaneously converges to the minimum energy state with all of the spins parallel to one another and shows, as I expected, that spontaneous magnetisation occurs and also shows that the temperature of this simulation is below the Curie Temperature, <math>T < T_C</math>.

 

==Section 4 - Accelerating the Code==

===TASK: Use the script ILtimetrial.py to record how long your current version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 4'' show the results of running the ILtimetrial.py file on my code three timesː

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1.png
| width1=500
| image2=cg1417ILtimetrial_run2.png
| width2=500
| image3=cg1417ILtimetrial_run3.png
| width3=500
| footer = Figure 4 - Results of running the ILtimetrial.py file on my code three separate times
}}
 

This gave me an avergage time of <math>24.3 s \pm 0.2s</math>

===TASK: Look at the documentation for the NumPy sum function. You should be able to modify your magnetisation() function so that it uses this to evaluate M. The energy is a little trickier. Familiarise yourself with the NumPy roll and multiply functions, and use these to replace your energy double loop (you will need to call roll and multiply twice!).===

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

left=multiply(roll(self.lattice,1,axis=1),self.lattice) #product of spin with spin left of it
top=multiply(roll(self.lattice,-1,axis=0),self.lattice) #product of spin with spin above it

int_en=sum(left+top) #sum of array containing sum of left and top spin products for each spin

energy = -sum(int_en) #calculates the total energy of system
return energy

def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
return sum(sum(self.lattice)) #adds up all spins in lattice
</pre>

===TASK: Use the script ILtimetrial.py to record how long your new version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 5'' shows the result of running the ILtimetrial.py on my new accelerated code.

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1fast.png
| width1=500
| image2=ILtimetrial_run2fast.png
| width2=500
| image3=ILtimetrial_run3fast.png
| width3=500
| footer = Figure 5 - Results of running the ILtimetrial.py file on my new updated and accelerated code.
}}
 

The accelerated code is much faster upon using the roll, multiply and s with a new average time of <math>0.790 s \pm 0.005 </math>

==Section 5 - The effect of temperature==

===TASK: The script ILfinalframe.py runs for a given number of cycles at a given temperature, then plots a depiction of the final lattice state as well as graphs of the energy and magnetisation as a function of cycle number. This is much quicker than animating every frame! Experiment with different temperature and lattice sizes. How many cycles are typically needed for the system to go from its random starting position to the equilibrium state? Modify your statistics() and montecarlostep() functions so that the first N cycles of the simulation are ignored when calculating the averages. You should state in your report what period you chose to ignore, and include graphs from ILfinalframe.py to illustrate your motivation in choosing this figure.===

''Figure 6'' below shows the results from running the ILfinalframe.py for 2x2 lattice at T=1,2,3,5.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2T1.png
| image2 = cg14172x2T2.png
| image3 =cg14172x2T3.png
| image4 =cg14172x2T5.png
| footer_align = left
| footer = Figure 6 - Results of running the ILfinalframe.py file at T=1,2,3,5 for a 2x2 matrix.
}}

 

For a 2x2 matrix, a suitable cut-off point to exclude from the avergage energies and magnetisations is where the energy and magnetisations per spin are constant, which is 30 steps. For T=3 and T=5 the graphs do not converge because it is possible that these temperatures are higher than the Curie Temperature and as such spontaneous magnetisation will not occur and the system will not diverge to the lowest energy state. At the higher temperatures, there are larger thermal fluctations and the Boltzmann factor is more significant allowing the system to move away from the lowest energy state easier. As a result moving forwards, a suitable cut-off point will only be determined from T=1 and T=2 graphs for the larger matrices.

''Figure 7'' shows the results from running a 4x4 lattice at T=1,2 and 3.

{{multiple image
| width =350
| align = left
| image1 = cg14174x4T1.png
| image2 = cg14174x4T2.png
| image3 =cg14174x4T3.png
| footer_align = left
| footer = Figure 7 - Results of running the ILfinalframe.py file at T=1,2,3 for a 4x4 matrix.
}}

From ''Figure 7'', a suitable cut-off point for the energy and magnetisations is 200 as this is after where the energy and magnetisation has converged for T=1, and is after the initial large drop in energy for T=2, even though there are a few small fluctuations after 200 steps. The result from T=3 has been included to show the large fluctuations for the larger temperatures, and supporting my choice to determine the cut-off from T=1 and T=2 only.

''Figure 8'' shows the results for an 8x8 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg14178x8T1.png
| image2 = cg14178x8T2.png
| footer_align = left
| footer = Figure 8 - Results of running the ILfinalframe.py file at T=1,2 for an 8x8 matrix
}}

From ''Figure 8'' above, a suitable cut-off point is 1000 steps as this is where the energy and magnetisation has easily converged by and is also the point after which the initial large drop in energy has been overcome for T=2 too.

''Figure 9'' shows the result of running the ILfinalframe.py for a 16x16 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg141716x16T1.png
| image2 = cg141716x16T2.png
| footer_align = left
| footer = Figure 9 - Results of running the ILfinalframe.py file at T=1,2 for a 16x16 matrix
}}

From ''Figure 9'', a suitable cut-off point is 15000 steps as for T=1 the energy and magnetisations have converged significantly and will not change much, and likewise this is the same for the T=2 frame.

''Figure 10'' below shows the results from a 32x32 matrix at T=1 and T=2.

{{multiple image
| width =350
| align = left
| image1 = cg141732x32T1.png
| image2 = cg141732x32T2.png
| footer_align = left
| footer = Figure 10 - Results of running the ILfinalframe.py file at T=1,2 for a 32x32 matrix
}}

''Figure 10'' above shows the results of running the ILfinalframe.py file for a 32x32 matrix at T=1 and T=2. As a result a suitable cut-off of 50000 steps was chosen as the energy and magnetisation has significantly converged, but not as much as it could at 100000 steps. I chose a slightly lower value to ensure that the run times of my monte-carlo simulations in future tasks were not extremely time consuming.

The montecarlostep() function was changed by adding a condition that values only above the pre-determined cut-off were included when determining the average value of energy; energy squared; magnetisation and magnetisations squared from the statistics function. The statistics() function did not need to be modified.

The following code is from the 32x32 matrixː

<pre>def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back

if self.n_cycles > 50000: #only adds values to array of E,E2,M and M2 is above specific cut-off
self.E+=[self.energy()]
self.E2+=[self.energy()**2]
self.M+=[self.magnetisation()]
self.M2+=[self.magnetisation()**2]
self.n_cycles=self.n_cycles+1

return (self.energy(),self.magnetisation())
</pre>

===TASK: Use ILtemperaturerange.py to plot the average energy and magnetisation for each temperature, with error bars, for an <math>8\times 8</math> lattice. Use your intuition and results from the script ILfinalframe.py to estimate how many cycles each simulation should be. The temperature range 0.25 to 5.0 is sufficient. Use as many temperature points as you feel necessary to illustrate the trend, but do not use a temperature spacing larger than 0.5. The NumPy function savetxt() stores your array of output data on disk — you will need it later. Save the file as 8x8.dat so that you know which lattice size it came from.===

Using the modified code, the file ILtemperaturerange.py was ran on an 8x8 matrix between T=0.5 and T=5 with a step of T=0.02 for 10000 Montecarlo steps and the first 1000 steps of each temperature were excluded when calculating the averages. ''Figure 11'' shows the result of the simulation and also included error bars of standard deviation.

[[File:Cg14178x8error.png|1000px|thumb|left|Figure 11 - Graph showing average energy and average magnetisation for an 8x8 lattice with error bars between T=0.5 and T=5]]

 

==Section 6 - The effect of system size==

===TASK: Repeat the final task of the previous section for the following lattice sizes: 2x2, 4x4, 8x8, 16x16, 32x32. Make sure that you name each datafile that your produce after the corresponding lattice size! Write a Python script to make a plot showing the energy per spin versus temperature for each of your lattice sizes. Hint: the NumPy loadtxt function is the reverse of the savetxt function, and can be used to read your previously saved files into the script. Repeat this for the magnetisation. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. How big a lattice do you think is big enough to capture the long range fluctuations?===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb.

Each matrix was simulated using the ILtemperaturerange.py file between T=0.5 and T=5 with a step of T=0.02.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2error.png
| caption1 = 2x2 matrix - 5000 steps, cut-off = 30 steps
| image2 = 4x4error.png
| caption2 = 4x4 matrix - 1000 steps, cut-off = 200 steps
| image3 =cg141716x16error.png
| caption3 = 16x16 matrix - 50000 steps, cut-off = 15000 steps
| image4 =cg141732x32error.png
| caption4 = 32x32 matrix - 200000 steps, cut-off = 50000 steps
| footer_align = left
| footer = Figure 12 - Results of running the ILtemperaturerange.py file for 2x2, 4x4, 16x16 and 32x32 matrices.
}}

 

==Section 7 - Determining the Heat Capacity==

===TASK: By definition, <math>C = \frac{\partial \left\langle E\right\rangle}{\partial T}</math>. From this, show that <math>C = \frac{\mathrm{Var}[E]}{k_B T^2}</math> (Where <math>\mathrm{Var}[E]</math> is the variance in <math>E</math>.)===

Recall from statistical thermodynamics that the average energy of a system is the sum across all microstates of the probability of that microstate multiplied by the energy of that microstate, which is defined mathematically asː <math>\langle E \rangle = \sum_i p_{i}\epsilon_{i}</math>.

The partition function <math>q</math> is defined as <math>q = \sum_{i} exp(-\beta \epsilon_{i})</math> where <math>\beta =\frac{1}{k_BT}</math>and the probability, <math>p_{i}</math> can be defined in terms of the partition function as <math>p_{i} = \frac{exp(-\beta \epsilon_{i})}{\sum_{i} exp(-\beta \epsilon_{i})} = \frac{exp(-\beta \epsilon_{i})}{q}</math>.

As a result, <math>\langle E \rangle</math> can be re-written as <math>\langle E \rangle = \sum_{i} \frac{\epsilon_{i} exp(-\beta \epsilon_{i})}{q} = -\frac{1}{q} \frac{\partial}{\partial \beta}\sum_{i}exp(-\beta \epsilon_{i}) = -\frac{1}{q} \frac{\partial q}{\partial \beta}</math>

Likewise, <math>\langle E^2 \rangle = \sum_i p_{i}\epsilon_{i}^{2} = \sum_{i} \frac{\epsilon_{i}^{2}exp(-\beta \epsilon_{i})}{q} = \frac{1}{q} \frac{\partial^{2}}{\partial \beta^{2}}\sum_{i}exp(-\beta \epsilon_{i}) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}}</math>

From definitionː <math>Var[E] = \Delta E^2 = \langle E^2 \rangle - \langle E \rangle^2 </math>

When the definition of <math>\langle E \rangle</math> and <math>\langle E^2 \rangle</math> is written in terms of partition function <math>q</math>ː <math>Var[E] = \langle E^2 \rangle - \langle E \rangle^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \left(\frac{1}{q}\frac{\partial q}{\partial \beta}\right)^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2</math>.

According to the chain ruleː <math>\frac{\partial}{\partial \beta}\left(\frac{1}{q} \frac{\partial q}{\partial \beta}\right) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2 = -\frac{\partial}{\partial \beta}\langle E \rangle = Var[E]</math>

And using the chain rule againː <math>C = \frac{\partial \langle E \rangle}{\partial T}= \left(-\frac{\partial \langle E \rangle}{\partial \beta}\right) \left(-\frac{\partial \beta}{\partial T}\right) = \frac{Var[E]}{k_B T^2}</math>

===TASK: Write a Python script to make a plot showing the heat capacity versus temperature for each of your lattice sizes from the previous section. You may need to do some research to recall the connection between the variance of a variable, <math>\mathrm{Var}[X]</math>, the mean of its square <math>\left\langle X^2\right\rangle</math>, and its squared mean <math>\left\langle X\right\rangle^2</math>. You may find that the data around the peak is very noisy — this is normal, and is a result of being in the critical region. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. ===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb

{{multiple image
| width =300
| align = left
| image1 = cg14172x2heatcap.png
| caption1 = 2x2 Matrix
| image2 = cg14174x4heatcap.png
| caption2 = 4x4 Matrix
| image3 =cg14178x8heatcap.png
| caption3 = 8x8 Matrix
| image4 =cg141716x16heatcap.png
| caption4 = 16x16 Matrix
| image5=cg141732x32heatcap.png
| caption5= 32x32 Matrix
| footer = Figure 14 - Graphs showing Heat Capacity against Temperature for each matrix size
}}

A general trend from the above graphs is that the peak of the graph shifts towards lower temperatures as the size of the matrix used increases.

==Section 8 - Locating the Curie Temperature==
===TASK: A C++ program has been used to run some much longer simulations than would be possible on the college computers in Python. You can view its source code here if you are interested. Each file contains six columns: <math>T, E, E^2, M, M^2, C</math> (the final five quantities are per spin), and you can read them with the NumPy loadtxt function as before. For each lattice size, plot the C++ data against your data. For one lattice size, save a PNG of this comparison and add it to your report — add a legend to the graph to label which is which. To do this, you will need to pass the label="..." keyword to the plot function, then call the legend() function of the axis object (documentation here).===

The python code used to read and plot the C++ data is found in the Jupyter notebook CG1417IsingModelGraphs.ipynb.

''Figure 15'' below shows the C++ plotted against my own data for a 16x16 Matrix.

[[File:Cg141716x16C++.png|400px|thumb|left|Figure 15 - Graph showing my own data against the C++ data for a 16x16 matrix.]]

 

===TASK: write a script to read the data from a particular file, and plot C vs T, as well as a fitted polynomial. Try changing the degree of the polynomial to improve the fit — in general, it might be difficult to get a good fit! Attach a PNG of an example fit to your report.===

The python script to read and plot the fitted polynomial is found in CG1417PolyfitScript.ipynb

Below in ''Figure 16'' is a plot of my Heat Capacity against Temperature data for a 16x16 matrix and features a polynomial of degree 35 plotted against it. Even with a polynomial of such a high degree, it poorly fits the curve and does not fit to the peak of the curve either.

[[File:cg1417FIT_TEST16x16_35.png|thumb|left|400px|Figure 16 - Plot of Heat Capacity against Temperature along with a poorly fitted polynomial of degree 35. ]]

 

===TASK: Modify your script from the previous section. You should still plot the whole temperature range, but fit the polynomial only to the peak of the heat capacity! You should find it easier to get a good fit when restricted to this region===

The script was modified as such that the polynomial was fitted in a set range around the peak of the graph, this is demonstrated in ''Figure 17'' which shows a newly fitted polynomial between a much smaller range of temperatures (T = 2.15-2.55) and a much smaller degree polynomial (3).

[[File:CG1417FIT_16x16C_3.png|thumb|left|400px|Figure 17 - Graph showing Heat Capacity against Temperature for a 16x16 matrix along with a fitted polynomial between a much more restricted range of temperatures and a significantly lower degree of polynomial]]

Upon comparison with ''Figure 16'', the new fitted polynomial is a significantly better fit even for a 3rd degree polynomial and is a much more accurate representation of my data around the peak of the graph and will make it easier to determine the maximum value of Heat Capacity.

 

===TASK: find the temperature at which the maximum in C occurs for each datafile that you were given. Make a text file containing two colums: the lattice side length (2,4,8, etc.), and the temperature at which C is a maximum. This is your estimate of <math>T_C</math> for that side length. Make a plot that uses the scaling relation given above to determine <math>T_{C,\infty}</math>. By doing a little research online, you should be able to find the theoretical exact Curie temperature for the infinite 2D Ising lattice. How does your value compare to this? Are you surprised by how good/bad the agreement is? Attach a PNG of this final graph to your report, and discuss briefly what you think the major sources of error are in your estimate.===

Figure 17 below shows a graph of <math>T_{C,L}</math> against <math>\frac{1}{Lattice Size}</math> to determine the Curie Temperature of an infinite 2D Ising Model Lattice <math>T_{C,\infty}</math>. The black dots represent the raw data obtained from obtaining the temperature at which the Heat Capacity was a maximum for the lattices and the red line in a linear curve fit plotted against the data to allow the y-intercept which is the Curie Temperature for the infinite 2D lattice to be determined.

[[File:cg1417CurieTemp.png|400px|thumb|left|Figure 17 - Plot of 1/Lattice Size against Curie Temperature for that lattice size.]]

The value for <math>T_{C,\inf}</math> obtained from the data is <math>T_{C,\infty} = 2.277 \frac{J}{k_B}</math> with a literature value being <math>T_{C,\infty} = 2.269 \frac{J}{k_B}</math> for an infinite square 2D lattice. This means that my result slightly over-estimates the Curie Temperature for the infinite lattice and as a result for an infinite lattice the temperature at which spontaneous magnetisation stops would actually occur at a slightly lower temperature than expected. However, the difference between my value and the literature value is only 0.008 which is incredibly small and the amount of agreement between the two values is somewhat surprising, which means that the error in my estimates of the Curie Temperature for each lattice size is relatively small. A potential source of error from the values of the Curie Temperature for each lattice size could come from the

Rep:Y3CMPCG1417

2019-11-20T07:54:17Z

==Section 1 - Introduction to the Ising Model==

===TASK: Show that the lowest possible energy for the Ising model is <math>E = -DNJ</math>, where D is the number of dimensions and N is the total number of spins. What is the multiplicity of this state? Calculate its entropy.===

Consider a 1D row of lattice sites of N=3 with spin configuration [+1][+1][+1].

Mathematically the interaction energy is defined asː
<math> -\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} </math> where J is a constant and <math>s_{i}s_{j}</math> is the product between two spins in adjacent lattice sites.

The sum of the interaction energies <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j}</math> can be considered as the sum of the individual interaction energies between spinsː
<math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = \epsilon_{12} + \epsilon_{23} + \epsilon_{13} + \epsilon_{21} + \epsilon_{32} + \epsilon_{31} </math>.

Although lattice sites 1 and 3 are not adjacent they are said to still interact according to the periodic boundary conditions applied.

However, <math>\epsilon_{12} = \epsilon_{21} </math> and <math>\epsilon_{23} = \epsilon_{32}</math> and <math>\epsilon_{13} = \epsilon_{31}</math> which means that all of the interactions within the system are counted twice, hence the total energy needs to be halved, resulting in the following formula being obtainedː <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = 2\epsilon_{12} + 2\epsilon_{13} + 2\epsilon_{23} </math>.

It can be determined that <math>\epsilon_{12} = (+1)(+1) = 1</math> , <math>\epsilon_{13} = (+1)(+1) = 1</math> and <math>\epsilon_{23} = (+1)(+1) = 1</math>.

Thereforeː <math>-\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = -\frac{1}{2} \ J \ (2 + 2 + 2) = -\frac{1}{2} \ J \ 6 = - 3 J = -DNJ</math> for a 1D lattice with <math>D=1</math> and 3 lattice sites <math>N=3</math>

The multiplicity of the system,<math>\Omega = 2S+1</math> where <math>S</math> is the total magnetisation of the system.

In this case, <math>\Omega = 2(3)+1 = 7</math>

Entropy, <math>S</math> is defined as <math>S = k_B ln(\Omega)</math> and so in this case <math>S = k_B ln7 = 1.95 k_B</math>

===TASK: Imagine that the system is in the lowest energy configuration. To move to a different state, one of the spins must spontaneously change direction ("flip"). What is the change in energy if this happens <math>(D=3, N=1000)</math>? How much entropy does the system gain by doing soʔ===

In a 3D lattice system, each lattice site has three unique interactions with its neighbours to its left, top and front. In the lowest energy configuration, all spins are parallel and for a system the minimum energy is <math>E = -DNJ</math>, so for the system with <math>N=1000</math> and <math>D=3</math>, the minimum energy is <math>-3000J</math>.

If a single spin is flipped, the product of its spin with its neighbours spin reverses and becomes negative and this increases the total energy of the system. Since 3 unique spin-spin interactions are reversed in sign, the total energy increases by <math>+3J</math>, meaning the new total energy is <math>-2997J</math>

Initially the multiplicity of the system will be <math>\Omega = 2(1000)+1=2001</math> , and after the flip, the multiplicity becomes <math>\Omega = 2(1000-1)+1=1999</math>.

The associated change in entropy, <math>\Delta S = k_B ln(1999) - k_B ln(2001)= k_B ln(\frac{1999}{2001}) = -0.001 k_B</math>, which is a very small decrease in entropy as the system starts

===TASK: Calculate the magnetisation of the 1D and 2D lattices in Figure 1. What magnetisation would you expect to observe for an Ising lattice with <math>D = 3,\ N=1000</math> at absolute zero?===

[[File:ThirdYearCMPExpt-IsingSketch.png|thumb|left|Figure 1 - Shows 1D (N = 5), 2D (N = 5x5) and 3D (N = 5x5x5) lattices.]]

Magnetisation is defined as <math>M=\sum_{i} s_i</math>. So for the 1D lattice with <math>N = 5</math> in ''Figure 2'', <math>M = +1</math> and for the 2D lattice with <math>N = 25 , M = +1</math> too.

According to the 3rd Law of thermodynamics, entropy is 0 at absolute zero for a perfect crystalline solid, and consequently it is expected that the lattices will have follow suit and have zero entropy at 0K. To have zero entropy all spins must be paired as such that magnetisation, <math>M = 0</math> - which is only possible in the lattices contains an even numbers of lattice sites (N = even). So, for a lattice with <math>N = 1000</math> and <math>D =3</math>, if <math>M = 0</math>, then multiplicity, <math>\Omega = 1</math> and entropy, <math>S =k_B ln(\Omega) = 0</math>.

==Section 2 - Calculating the Energy and Magnetisation==

===TASK: complete the functions energy() and magnetisation(), which should return the energy of the lattice and the total magnetisation, respectively. In the energy() function you may assume that <math>J=1.0</math> at all times (in fact, we are working in reduced units in which <math>J=k_B</math>, but there will be more information about this in later sections). Do not worry about the efficiency of the code at the moment — we will address the speed in a later part of the experiment.===

<pre>def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
lat=self.lattice #creates lattice and stores it
mag=[]
for i in range(0,len(lat)): #loops through all rows of lattice
for j in range(0,len(lat[i])): #loops through elements of each row
mag+=[lat[i][j]] #adds spin value to mag array
return sum(mag) #sums all spins from mag array
</pre>

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

lat=self.lattice #creates lattice and stores it
left=[]
top=[]

for i in range(0,len(lat)):
for j in range(0,len(lat[i])):
left+=[lat[i][j]*lat[i][j-1]] #multiplies spin by spin to left
top+=[lat[i][j]*lat[i-1][j]] #multiplies spin by spin above it
int_en=left+top #sums spin products from left and top
energy=-sum(int_en) #sums all spin products for each spin to give total

return energy
</pre>

===TASK: Run the ILcheck.py script from the IPython Qt console using the command===

''Figure 2'' shows the results when ILcheck.py was ran on my IsingLattice.py file. The ILcheck.py file was ran several times to ensure the code worked for various random lattices.

[[File:Cg1417ILcheck run.png|thumb|left|500px| Figure 2 - Result from running the ILcheck.py file]]

 

==Section 3 - Introduction to Monte Carlo Simulation==

===TASK: How many configurations are available to a system with 100 spins? To evaluate these expressions, we have to calculate the energy and magnetisation for each of these configurations, then perform the sum. Let's be very, very, generous, and say that we can analyse <math>1\times 10^9</math> configurations per second with our computer. How long will it take to evaluate a single value of <math>\left\langle M\right\rangle_T</math>?===

For a system with 100 lattice sites and two possible spins for each site, there are <math>2^{100}</math>possible configurations for the system. <math>2^{100}= 1.27\times 10^{30} </math>, so if the computer can analyse <math>1\times 10^9</math> configurations per second, then it will take <math>\frac{1.27\times 10^{30}}{10^9} = 1.27\times 10^{21} s</math> to analyse the whole system, which is older than the age of the universe and therefore is not a practical approach.

===TASK: Implement a single cycle of the above algorithm in the montecarlocycle(T) function. This function should return the energy of your lattice and the magnetisation at the end of the cycle. You may assume that the energy returned by your energy() function is in units of <math>k_B</math>! Complete the statistics() function. This should return the following quantities whenever it is called: <math><E>, <E^2>, <M>, <M^2></math>, and the number of Monte Carlo steps that have elapsed.===
<pre>
E = []
E2 = []
M = []
M2 = []
n_cycles = 0

def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back if rejected else not changed

self.E+=[self.energy()] #records energy
self.E2+=[self.energy()**2] #records energy squared
self.M+=[self.magnetisation()] #records magnetisation
self.M2+=[self.magnetisation()**2] #records magnetisation squared
self.n_cycles=self.n_cycles+1 #adds 1 to run total

return (self.energy(),self.magnetisation())

def statistics(self):
# complete this function so that it calculates the correct values for the averages of E, E*E (E2), M, M*M (M2), and returns them

e=np.mean(self.E)
e2=np.mean(self.E2)
m=np.mean(self.M)
m2=np.mean(self.M2)

return e,e2,m,m2,self.n_cycles
</pre>

===TASK: If <math>T < T_C</math>, do you expect a spontaneous magnetisation (i.e. do you expect <math>\left\langle M\right\rangle \neq 0</math>)? When the state of the simulation appears to stop changing (when you have reached an equilibrium state), use the controls to export the output to PNG and attach this to your report. You should also include the output from your statistics() function.===

If the temperature of the system is less than the Curie Temperature, <math>T_C</math> then spontaneous magnetisation can occur and the system will tend to its lowest energy state where all of the spins are parallel - this is a property of ferromagnetic materials.

[[File:Cg1417ILanim_run.png|400px|thumb|left|Figure 3 - Results from running the ILanim.py file - shows the energy and magnetisation converging over time]]

''Figure 3'' shows that over time the the system spontaneously converges to the minimum energy state with all of the spins parallel to one another and shows, as I expected, that spontaneous magnetisation occurs and also shows that the temperature of this simulation is below the Curie Temperature, <math>T < T_C</math>.

 

==Section 4 - Accelerating the Code==

===TASK: Use the script ILtimetrial.py to record how long your current version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 4'' show the results of running the ILtimetrial.py file on my code three timesː

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1.png
| width1=500
| image2=cg1417ILtimetrial_run2.png
| width2=500
| image3=cg1417ILtimetrial_run3.png
| width3=500
| footer = Figure 4 - Results of running the ILtimetrial.py file on my code three separate times
}}
 

This gave me an avergage time of <math>24.3 s \pm 0.2s</math>

===TASK: Look at the documentation for the NumPy sum function. You should be able to modify your magnetisation() function so that it uses this to evaluate M. The energy is a little trickier. Familiarise yourself with the NumPy roll and multiply functions, and use these to replace your energy double loop (you will need to call roll and multiply twice!).===

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

left=multiply(roll(self.lattice,1,axis=1),self.lattice) #product of spin with spin left of it
top=multiply(roll(self.lattice,-1,axis=0),self.lattice) #product of spin with spin above it

int_en=sum(left+top) #sum of array containing sum of left and top spin products for each spin

energy = -sum(int_en) #calculates the total energy of system
return energy

def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
return sum(sum(self.lattice)) #adds up all spins in lattice
</pre>

===TASK: Use the script ILtimetrial.py to record how long your new version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 5'' shows the result of running the ILtimetrial.py on my new accelerated code.

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1fast.png
| width1=500
| image2=ILtimetrial_run2fast.png
| width2=500
| image3=ILtimetrial_run3fast.png
| width3=500
| footer = Figure 5 - Results of running the ILtimetrial.py file on my new updated and accelerated code.
}}
 

The accelerated code is much faster upon using the roll, multiply and s with a new average time of <math>0.790 s \pm 0.005 </math>

==Section 5 - The effect of temperature==

===TASK: The script ILfinalframe.py runs for a given number of cycles at a given temperature, then plots a depiction of the final lattice state as well as graphs of the energy and magnetisation as a function of cycle number. This is much quicker than animating every frame! Experiment with different temperature and lattice sizes. How many cycles are typically needed for the system to go from its random starting position to the equilibrium state? Modify your statistics() and montecarlostep() functions so that the first N cycles of the simulation are ignored when calculating the averages. You should state in your report what period you chose to ignore, and include graphs from ILfinalframe.py to illustrate your motivation in choosing this figure.===

''Figure 6'' below shows the results from running the ILfinalframe.py for 2x2 lattice at T=1,2,3,5.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2T1.png
| image2 = cg14172x2T2.png
| image3 =cg14172x2T3.png
| image4 =cg14172x2T5.png
| footer_align = left
| footer = Figure 6 - Results of running the ILfinalframe.py file at T=1,2,3,5 for a 2x2 matrix.
}}

 

For a 2x2 matrix, a suitable cut-off point to exclude from the avergage energies and magnetisations is where the energy and magnetisations per spin are constant, which is 30 steps. For T=3 and T=5 the graphs do not converge because it is possible that these temperatures are higher than the Curie Temperature and as such spontaneous magnetisation will not occur and the system will not diverge to the lowest energy state. At the higher temperatures, there are larger thermal fluctations and the Boltzmann factor is more significant allowing the system to move away from the lowest energy state easier. As a result moving forwards, a suitable cut-off point will only be determined from T=1 and T=2 graphs for the larger matrices.

''Figure 7'' shows the results from running a 4x4 lattice at T=1,2 and 3.

{{multiple image
| width =350
| align = left
| image1 = cg14174x4T1.png
| image2 = cg14174x4T2.png
| image3 =cg14174x4T3.png
| footer_align = left
| footer = Figure 7 - Results of running the ILfinalframe.py file at T=1,2,3 for a 4x4 matrix.
}}

From ''Figure 7'', a suitable cut-off point for the energy and magnetisations is 200 as this is after where the energy and magnetisation has converged for T=1, and is after the initial large drop in energy for T=2, even though there are a few small fluctuations after 200 steps. The result from T=3 has been included to show the large fluctuations for the larger temperatures, and supporting my choice to determine the cut-off from T=1 and T=2 only.

''Figure 8'' shows the results for an 8x8 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg14178x8T1.png
| image2 = cg14178x8T2.png
| footer_align = left
| footer = Figure 8 - Results of running the ILfinalframe.py file at T=1,2 for an 8x8 matrix
}}

From ''Figure 8'' above, a suitable cut-off point is 1000 steps as this is where the energy and magnetisation has easily converged by and is also the point after which the initial large drop in energy has been overcome for T=2 too.

''Figure 9'' shows the result of running the ILfinalframe.py for a 16x16 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg141716x16T1.png
| image2 = cg141716x16T2.png
| footer_align = left
| footer = Figure 9 - Results of running the ILfinalframe.py file at T=1,2 for a 16x16 matrix
}}

From ''Figure 9'', a suitable cut-off point is 15000 steps as for T=1 the energy and magnetisations have converged significantly and will not change much, and likewise this is the same for the T=2 frame.

''Figure 10'' below shows the results from a 32x32 matrix at T=1 and T=2.

{{multiple image
| width =350
| align = left
| image1 = cg141732x32T1.png
| image2 = cg141732x32T2.png
| footer_align = left
| footer = Figure 10 - Results of running the ILfinalframe.py file at T=1,2 for a 32x32 matrix
}}

''Figure 10'' above shows the results of running the ILfinalframe.py file for a 32x32 matrix at T=1 and T=2. As a result a suitable cut-off of 50000 steps was chosen as the energy and magnetisation has significantly converged, but not as much as it could at 100000 steps. I chose a slightly lower value to ensure that the run times of my monte-carlo simulations in future tasks were not extremely time consuming.

The montecarlostep() function was changed by adding a condition that values only above the pre-determined cut-off were included when determining the average value of energy; energy squared; magnetisation and magnetisations squared from the statistics function. The statistics() function did not need to be modified.

The following code is from the 32x32 matrixː

<pre>def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back

if self.n_cycles > 50000: #only adds values to array of E,E2,M and M2 is above specific cut-off
self.E+=[self.energy()]
self.E2+=[self.energy()**2]
self.M+=[self.magnetisation()]
self.M2+=[self.magnetisation()**2]
self.n_cycles=self.n_cycles+1

return (self.energy(),self.magnetisation())
</pre>

===TASK: Use ILtemperaturerange.py to plot the average energy and magnetisation for each temperature, with error bars, for an <math>8\times 8</math> lattice. Use your intuition and results from the script ILfinalframe.py to estimate how many cycles each simulation should be. The temperature range 0.25 to 5.0 is sufficient. Use as many temperature points as you feel necessary to illustrate the trend, but do not use a temperature spacing larger than 0.5. The NumPy function savetxt() stores your array of output data on disk — you will need it later. Save the file as 8x8.dat so that you know which lattice size it came from.===

Using the modified code, the file ILtemperaturerange.py was ran on an 8x8 matrix between T=0.5 and T=5 with a step of T=0.02 for 10000 Montecarlo steps and the first 1000 steps of each temperature were excluded when calculating the averages. ''Figure 11'' shows the result of the simulation and also included error bars of standard deviation.

[[File:Cg14178x8error.png|1000px|thumb|left|Figure 11 - Graph showing average energy and average magnetisation for an 8x8 lattice with error bars between T=0.5 and T=5]]

 

==Section 6 - The effect of system size==

===TASK: Repeat the final task of the previous section for the following lattice sizes: 2x2, 4x4, 8x8, 16x16, 32x32. Make sure that you name each datafile that your produce after the corresponding lattice size! Write a Python script to make a plot showing the energy per spin versus temperature for each of your lattice sizes. Hint: the NumPy loadtxt function is the reverse of the savetxt function, and can be used to read your previously saved files into the script. Repeat this for the magnetisation. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. How big a lattice do you think is big enough to capture the long range fluctuations?===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb.

Each matrix was simulated using the ILtemperaturerange.py file between T=0.5 and T=5 with a step of T=0.02.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2error.png
| caption1 = 2x2 matrix - 5000 steps, cut-off = 30 steps
| image2 = 4x4error.png
| caption2 = 4x4 matrix - 1000 steps, cut-off = 200 steps
| image3 =cg141716x16error.png
| caption3 = 16x16 matrix - 50000 steps, cut-off = 15000 steps
| image4 =cg141732x32error.png
| caption4 = 32x32 matrix - 200000 steps, cut-off = 50000 steps
| footer_align = left
| footer = Figure 13 - Results of running the ILtemperaturerange.py file for 2x2, 4x4, 16x16 and 32x32 matrices.
}}

 

==Section 7 - Determining the Heat Capacity==

===TASK: By definition, <math>C = \frac{\partial \left\langle E\right\rangle}{\partial T}</math>. From this, show that <math>C = \frac{\mathrm{Var}[E]}{k_B T^2}</math> (Where <math>\mathrm{Var}[E]</math> is the variance in <math>E</math>.)===

Recall from statistical thermodynamics that the average energy of a system is the sum across all microstates of the probability of that microstate multiplied by the energy of that microstate, which is defined mathematically asː <math>\langle E \rangle = \sum_i p_{i}\epsilon_{i}</math>.

The partition function <math>q</math> is defined as <math>q = \sum_{i} exp(-\beta \epsilon_{i})</math> where <math>\beta =\frac{1}{k_BT}</math>and the probability, <math>p_{i}</math> can be defined in terms of the partition function as <math>p_{i} = \frac{exp(-\beta \epsilon_{i})}{\sum_{i} exp(-\beta \epsilon_{i})} = \frac{exp(-\beta \epsilon_{i})}{q}</math>.

As a result, <math>\langle E \rangle</math> can be re-written as <math>\langle E \rangle = \sum_{i} \frac{\epsilon_{i} exp(-\beta \epsilon_{i})}{q} = -\frac{1}{q} \frac{\partial}{\partial \beta}\sum_{i}exp(-\beta \epsilon_{i}) = -\frac{1}{q} \frac{\partial q}{\partial \beta}</math>

Likewise, <math>\langle E^2 \rangle = \sum_i p_{i}\epsilon_{i}^{2} = \sum_{i} \frac{\epsilon_{i}^{2}exp(-\beta \epsilon_{i})}{q} = \frac{1}{q} \frac{\partial^{2}}{\partial \beta^{2}}\sum_{i}exp(-\beta \epsilon_{i}) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}}</math>

From definitionː <math>Var[E] = \Delta E^2 = \langle E^2 \rangle - \langle E \rangle^2 </math>

When the definition of <math>\langle E \rangle</math> and <math>\langle E^2 \rangle</math> is written in terms of partition function <math>q</math>ː <math>Var[E] = \langle E^2 \rangle - \langle E \rangle^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \left(\frac{1}{q}\frac{\partial q}{\partial \beta}\right)^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2</math>.

According to the chain ruleː <math>\frac{\partial}{\partial \beta}\left(\frac{1}{q} \frac{\partial q}{\partial \beta}\right) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2 = -\frac{\partial}{\partial \beta}\langle E \rangle = Var[E]</math>

And using the chain rule againː <math>C = \frac{\partial \langle E \rangle}{\partial T}= \left(-\frac{\partial \langle E \rangle}{\partial \beta}\right) \left(-\frac{\partial \beta}{\partial T}\right) = \frac{Var[E]}{k_B T^2}</math>

===TASK: Write a Python script to make a plot showing the heat capacity versus temperature for each of your lattice sizes from the previous section. You may need to do some research to recall the connection between the variance of a variable, <math>\mathrm{Var}[X]</math>, the mean of its square <math>\left\langle X^2\right\rangle</math>, and its squared mean <math>\left\langle X\right\rangle^2</math>. You may find that the data around the peak is very noisy — this is normal, and is a result of being in the critical region. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. ===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb

{{multiple image
| width =300
| align = left
| image1 = cg14172x2heatcap.png
| caption1 = 2x2 Matrix
| image2 = cg14174x4heatcap.png
| caption2 = 4x4 Matrix
| image3 =cg14178x8heatcap.png
| caption3 = 8x8 Matrix
| image4 =cg141716x16heatcap.png
| caption4 = 16x16 Matrix
| image5=cg141732x32heatcap.png
| caption5= 32x32 Matrix
| footer = Figure 14 - Graphs showing Heat Capacity against Temperature for each matrix size
}}

A general trend from the above graphs is that the peak of the graph shifts towards lower temperatures as the size of the matrix used increases.

==Section 8 - Locating the Curie Temperature==
===TASK: A C++ program has been used to run some much longer simulations than would be possible on the college computers in Python. You can view its source code here if you are interested. Each file contains six columns: <math>T, E, E^2, M, M^2, C</math> (the final five quantities are per spin), and you can read them with the NumPy loadtxt function as before. For each lattice size, plot the C++ data against your data. For one lattice size, save a PNG of this comparison and add it to your report — add a legend to the graph to label which is which. To do this, you will need to pass the label="..." keyword to the plot function, then call the legend() function of the axis object (documentation here).===

The python code used to read and plot the C++ data is found in the Jupyter notebook CG1417IsingModelGraphs.ipynb.

''Figure 15'' below shows the C++ plotted against my own data for a 16x16 Matrix.

[[File:Cg141716x16C++.png|400px|thumb|left|Figure 15 - Graph showing my own data against the C++ data for a 16x16 matrix.]]

 

===TASK: write a script to read the data from a particular file, and plot C vs T, as well as a fitted polynomial. Try changing the degree of the polynomial to improve the fit — in general, it might be difficult to get a good fit! Attach a PNG of an example fit to your report.===

The python script to read and plot the fitted polynomial is found in CG1417PolyfitScript.ipynb

Below in ''Figure 16'' is a plot of my Heat Capacity against Temperature data for a 16x16 matrix and features a polynomial of degree 35 plotted against it. Even with a polynomial of such a high degree, it poorly fits the curve and does not fit to the peak of the curve either.

[[File:cg1417FIT_TEST16x16_35.png|thumb|left|400px|Figure 16 - Plot of Heat Capacity against Temperature along with a poorly fitted polynomial of degree 35. ]]

 

===TASK: Modify your script from the previous section. You should still plot the whole temperature range, but fit the polynomial only to the peak of the heat capacity! You should find it easier to get a good fit when restricted to this region===

The script was modified as such that the polynomial was fitted in a set range around the peak of the graph, this is demonstrated in ''Figure 17'' which shows a newly fitted polynomial between a much smaller range of temperatures (T = 2.15-2.55) and a much smaller degree polynomial (3).

[[File:CG1417FIT_16x16C_3.png|thumb|left|400px|Figure 17 - Graph showing Heat Capacity against Temperature for a 16x16 matrix along with a fitted polynomial between a much more restricted range of temperatures and a significantly lower degree of polynomial]]

Upon comparison with ''Figure 16'', the new fitted polynomial is a significantly better fit even for a 3rd degree polynomial and is a much more accurate representation of my data around the peak of the graph and will make it easier to determine the maximum value of Heat Capacity.

 

===TASK: find the temperature at which the maximum in C occurs for each datafile that you were given. Make a text file containing two colums: the lattice side length (2,4,8, etc.), and the temperature at which C is a maximum. This is your estimate of <math>T_C</math> for that side length. Make a plot that uses the scaling relation given above to determine <math>T_{C,\infty}</math>. By doing a little research online, you should be able to find the theoretical exact Curie temperature for the infinite 2D Ising lattice. How does your value compare to this? Are you surprised by how good/bad the agreement is? Attach a PNG of this final graph to your report, and discuss briefly what you think the major sources of error are in your estimate.===

Figure 17 below shows a graph of <math>T_{C,L}</math> against <math>\frac{1}{Lattice Size}</math> to determine the Curie Temperature of an infinite 2D Ising Model Lattice <math>T_{C,\infty}</math>. The black dots represent the raw data obtained from obtaining the temperature at which the Heat Capacity was a maximum for the lattices and the red line in a linear curve fit plotted against the data to allow the y-intercept which is the Curie Temperature for the infinite 2D lattice to be determined.

[[File:cg1417CurieTemp.png|400px|thumb|left|Figure 17 - Plot of 1/Lattice Size against Curie Temperature for that lattice size.]]

The value for <math>T_{C,\inf}</math> obtained from the data is <math>T_{C,\infty} = 2.277 \frac{J}{k_B}</math> with a literature value being <math>T_{C,\infty} = 2.269 \frac{J}{k_B}</math> for an infinite square 2D lattice. This means that my result slightly over-estimates the Curie Temperature for the infinite lattice and as a result for an infinite lattice the temperature at which spontaneous magnetisation stops would actually occur at a slightly lower temperature than expected. However, the difference between my value and the literature value is only 0.008 which is incredibly small and the amount of agreement between the two values is somewhat surprising, which means that the error in my estimates of the Curie Temperature for each lattice size is relatively small. A potential source of error from the values of the Curie Temperature for each lattice size could come from the

Rep:Y3CMPCG1417

2019-11-20T07:53:48Z

==Section 1 - Introduction to the Ising Model==

===TASK: Show that the lowest possible energy for the Ising model is <math>E = -DNJ</math>, where D is the number of dimensions and N is the total number of spins. What is the multiplicity of this state? Calculate its entropy.===

Consider a 1D row of lattice sites of N=3 with spin configuration [+1][+1][+1].

Mathematically the interaction energy is defined asː
<math> -\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} </math> where J is a constant and <math>s_{i}s_{j}</math> is the product between two spins in adjacent lattice sites.

The sum of the interaction energies <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j}</math> can be considered as the sum of the individual interaction energies between spinsː
<math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = \epsilon_{12} + \epsilon_{23} + \epsilon_{13} + \epsilon_{21} + \epsilon_{32} + \epsilon_{31} </math>.

Although lattice sites 1 and 3 are not adjacent they are said to still interact according to the periodic boundary conditions applied.

However, <math>\epsilon_{12} = \epsilon_{21} </math> and <math>\epsilon_{23} = \epsilon_{32}</math> and <math>\epsilon_{13} = \epsilon_{31}</math> which means that all of the interactions within the system are counted twice, hence the total energy needs to be halved, resulting in the following formula being obtainedː <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = 2\epsilon_{12} + 2\epsilon_{13} + 2\epsilon_{23} </math>.

It can be determined that <math>\epsilon_{12} = (+1)(+1) = 1</math> , <math>\epsilon_{13} = (+1)(+1) = 1</math> and <math>\epsilon_{23} = (+1)(+1) = 1</math>.

Thereforeː <math>-\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = -\frac{1}{2} \ J \ (2 + 2 + 2) = -\frac{1}{2} \ J \ 6 = - 3 J = -DNJ</math> for a 1D lattice with <math>D=1</math> and 3 lattice sites <math>N=3</math>

The multiplicity of the system,<math>\Omega = 2S+1</math> where <math>S</math> is the total magnetisation of the system.

In this case, <math>\Omega = 2(3)+1 = 7</math>

Entropy, <math>S</math> is defined as <math>S = k_B ln(\Omega)</math> and so in this case <math>S = k_B ln7 = 1.95 k_B</math>

===TASK: Imagine that the system is in the lowest energy configuration. To move to a different state, one of the spins must spontaneously change direction ("flip"). What is the change in energy if this happens <math>(D=3, N=1000)</math>? How much entropy does the system gain by doing soʔ===

In a 3D lattice system, each lattice site has three unique interactions with its neighbours to its left, top and front. In the lowest energy configuration, all spins are parallel and for a system the minimum energy is <math>E = -DNJ</math>, so for the system with <math>N=1000</math> and <math>D=3</math>, the minimum energy is <math>-3000J</math>.

If a single spin is flipped, the product of its spin with its neighbours spin reverses and becomes negative and this increases the total energy of the system. Since 3 unique spin-spin interactions are reversed in sign, the total energy increases by <math>+3J</math>, meaning the new total energy is <math>-2997J</math>

Initially the multiplicity of the system will be <math>\Omega = 2(1000)+1=2001</math> , and after the flip, the multiplicity becomes <math>\Omega = 2(1000-1)+1=1999</math>.

The associated change in entropy, <math>\Delta S = k_B ln(1999) - k_B ln(2001)= k_B ln(\frac{1999}{2001}) = -0.001 k_B</math>, which is a very small decrease in entropy as the system starts

===TASK: Calculate the magnetisation of the 1D and 2D lattices in Figure 1. What magnetisation would you expect to observe for an Ising lattice with <math>D = 3,\ N=1000</math> at absolute zero?===

[[File:ThirdYearCMPExpt-IsingSketch.png|thumb|left|Figure 1 - Shows 1D (N = 5), 2D (N = 5x5) and 3D (N = 5x5x5) lattices.]]

Magnetisation is defined as <math>M=\sum_{i} s_i</math>. So for the 1D lattice with <math>N = 5</math> in ''Figure 2'', <math>M = +1</math> and for the 2D lattice with <math>N = 25 , M = +1</math> too.

According to the 3rd Law of thermodynamics, entropy is 0 at absolute zero for a perfect crystalline solid, and consequently it is expected that the lattices will have follow suit and have zero entropy at 0K. To have zero entropy all spins must be paired as such that magnetisation, <math>M = 0</math> - which is only possible in the lattices contains an even numbers of lattice sites (N = even). So, for a lattice with <math>N = 1000</math> and <math>D =3</math>, if <math>M = 0</math>, then multiplicity, <math>\Omega = 1</math> and entropy, <math>S =k_B ln(\Omega) = 0</math>.

==Section 2 - Calculating the Energy and Magnetisation==

===TASK: complete the functions energy() and magnetisation(), which should return the energy of the lattice and the total magnetisation, respectively. In the energy() function you may assume that <math>J=1.0</math> at all times (in fact, we are working in reduced units in which <math>J=k_B</math>, but there will be more information about this in later sections). Do not worry about the efficiency of the code at the moment — we will address the speed in a later part of the experiment.===

<pre>def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
lat=self.lattice #creates lattice and stores it
mag=[]
for i in range(0,len(lat)): #loops through all rows of lattice
for j in range(0,len(lat[i])): #loops through elements of each row
mag+=[lat[i][j]] #adds spin value to mag array
return sum(mag) #sums all spins from mag array
</pre>

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

lat=self.lattice #creates lattice and stores it
left=[]
top=[]

for i in range(0,len(lat)):
for j in range(0,len(lat[i])):
left+=[lat[i][j]*lat[i][j-1]] #multiplies spin by spin to left
top+=[lat[i][j]*lat[i-1][j]] #multiplies spin by spin above it
int_en=left+top #sums spin products from left and top
energy=-sum(int_en) #sums all spin products for each spin to give total

return energy
</pre>

===TASK: Run the ILcheck.py script from the IPython Qt console using the command===

''Figure 2'' shows the results when ILcheck.py was ran on my IsingLattice.py file. The ILcheck.py file was ran several times to ensure the code worked for various random lattices.

[[File:Cg1417ILcheck run.png|thumb|left|500px| Figure 2 - Result from running the ILcheck.py file]]

 

==Section 3 - Introduction to Monte Carlo Simulation==

===TASK: How many configurations are available to a system with 100 spins? To evaluate these expressions, we have to calculate the energy and magnetisation for each of these configurations, then perform the sum. Let's be very, very, generous, and say that we can analyse <math>1\times 10^9</math> configurations per second with our computer. How long will it take to evaluate a single value of <math>\left\langle M\right\rangle_T</math>?===

For a system with 100 lattice sites and two possible spins for each site, there are <math>2^{100}</math>possible configurations for the system. <math>2^{100}= 1.27\times 10^{30} </math>, so if the computer can analyse <math>1\times 10^9</math> configurations per second, then it will take <math>\frac{1.27\times 10^{30}}{10^9} = 1.27\times 10^{21} s</math> to analyse the whole system, which is older than the age of the universe and therefore is not a practical approach.

===TASK: Implement a single cycle of the above algorithm in the montecarlocycle(T) function. This function should return the energy of your lattice and the magnetisation at the end of the cycle. You may assume that the energy returned by your energy() function is in units of <math>k_B</math>! Complete the statistics() function. This should return the following quantities whenever it is called: <math><E>, <E^2>, <M>, <M^2></math>, and the number of Monte Carlo steps that have elapsed.===
<pre>
E = []
E2 = []
M = []
M2 = []
n_cycles = 0

def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back if rejected else not changed

self.E+=[self.energy()] #records energy
self.E2+=[self.energy()**2] #records energy squared
self.M+=[self.magnetisation()] #records magnetisation
self.M2+=[self.magnetisation()**2] #records magnetisation squared
self.n_cycles=self.n_cycles+1 #adds 1 to run total

return (self.energy(),self.magnetisation())

def statistics(self):
# complete this function so that it calculates the correct values for the averages of E, E*E (E2), M, M*M (M2), and returns them

e=np.mean(self.E)
e2=np.mean(self.E2)
m=np.mean(self.M)
m2=np.mean(self.M2)

return e,e2,m,m2,self.n_cycles
</pre>

===TASK: If <math>T < T_C</math>, do you expect a spontaneous magnetisation (i.e. do you expect <math>\left\langle M\right\rangle \neq 0</math>)? When the state of the simulation appears to stop changing (when you have reached an equilibrium state), use the controls to export the output to PNG and attach this to your report. You should also include the output from your statistics() function.===

If the temperature of the system is less than the Curie Temperature, <math>T_C</math> then spontaneous magnetisation can occur and the system will tend to its lowest energy state where all of the spins are parallel - this is a property of ferromagnetic materials.

[[File:Cg1417ILanim_run.png|400px|thumb|left|Figure 3 - Results from running the ILanim.py file - shows the energy and magnetisation converging over time]]

''Figure 3'' shows that over time the the system spontaneously converges to the minimum energy state with all of the spins parallel to one another and shows, as I expected, that spontaneous magnetisation occurs and also shows that the temperature of this simulation is below the Curie Temperature, <math>T < T_C</math>.

 

==Section 4 - Accelerating the Code==

===TASK: Use the script ILtimetrial.py to record how long your current version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 4'' show the results of running the ILtimetrial.py file on my code three timesː

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1.png
| width1=500
| image2=cg1417ILtimetrial_run2.png
| width2=500
| image3=cg1417ILtimetrial_run3.png
| width3=500
| footer = Figure 4 - Results of running the ILtimetrial.py file on my code three separate times
}}
 

This gave me an avergage time of <math>24.3 s \pm 0.2s</math>

===TASK: Look at the documentation for the NumPy sum function. You should be able to modify your magnetisation() function so that it uses this to evaluate M. The energy is a little trickier. Familiarise yourself with the NumPy roll and multiply functions, and use these to replace your energy double loop (you will need to call roll and multiply twice!).===

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

left=multiply(roll(self.lattice,1,axis=1),self.lattice) #product of spin with spin left of it
top=multiply(roll(self.lattice,-1,axis=0),self.lattice) #product of spin with spin above it

int_en=sum(left+top) #sum of array containing sum of left and top spin products for each spin

energy = -sum(int_en) #calculates the total energy of system
return energy

def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
return sum(sum(self.lattice)) #adds up all spins in lattice
</pre>

===TASK: Use the script ILtimetrial.py to record how long your new version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 5'' shows the result of running the ILtimetrial.py on my new accelerated code.

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1fast.png
| width1=500
| image2=ILtimetrial_run2fast.png
| width2=500
| image3=ILtimetrial_run3fast.png
| width3=500
| footer = Figure 5 - Results of running the ILtimetrial.py file on my new updated and accelerated code.
}}
 

The accelerated code is much faster upon using the roll, multiply and s with a new average time of <math>0.790 s \pm 0.005 </math>

==Section 5 - The effect of temperature==

===TASK: The script ILfinalframe.py runs for a given number of cycles at a given temperature, then plots a depiction of the final lattice state as well as graphs of the energy and magnetisation as a function of cycle number. This is much quicker than animating every frame! Experiment with different temperature and lattice sizes. How many cycles are typically needed for the system to go from its random starting position to the equilibrium state? Modify your statistics() and montecarlostep() functions so that the first N cycles of the simulation are ignored when calculating the averages. You should state in your report what period you chose to ignore, and include graphs from ILfinalframe.py to illustrate your motivation in choosing this figure.===

''Figure 6'' below shows the results from running the ILfinalframe.py for 2x2 lattice at T=1,2,3,5.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2T1.png
| image2 = cg14172x2T2.png
| image3 =cg14172x2T3.png
| image4 =cg14172x2T5.png
| footer_align = left
| footer = Figure 6 - Results of running the ILfinalframe.py file at T=1,2,3,5 for a 2x2 matrix.
}}

 

For a 2x2 matrix, a suitable cut-off point to exclude from the avergage energies and magnetisations is where the energy and magnetisations per spin are constant, which is 30 steps. For T=3 and T=5 the graphs do not converge because it is possible that these temperatures are higher than the Curie Temperature and as such spontaneous magnetisation will not occur and the system will not diverge to the lowest energy state. At the higher temperatures, there are larger thermal fluctations and the Boltzmann factor is more significant allowing the system to move away from the lowest energy state easier. As a result moving forwards, a suitable cut-off point will only be determined from T=1 and T=2 graphs for the larger matrices.

''Figure 7'' shows the results from running a 4x4 lattice at T=1,2 and 3.

{{multiple image
| width =350
| align = left
| image1 = cg14174x4T1.png
| image2 = cg14174x4T2.png
| image3 =cg14174x4T3.png
| footer_align = left
| footer = Figure 7 - Results of running the ILfinalframe.py file at T=1,2,3 for a 4x4 matrix.
}}

From ''Figure 7'', a suitable cut-off point for the energy and magnetisations is 200 as this is after where the energy and magnetisation has converged for T=1, and is after the initial large drop in energy for T=2, even though there are a few small fluctuations after 200 steps. The result from T=3 has been included to show the large fluctuations for the larger temperatures, and supporting my choice to determine the cut-off from T=1 and T=2 only.

''Figure 8'' shows the results for an 8x8 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg14178x8T1.png
| image2 = cg14178x8T2.png
| footer_align = left
| footer = Figure 8 - Results of running the ILfinalframe.py file at T=1,2 for an 8x8 matrix
}}

From ''Figure 8'' above, a suitable cut-off point is 1000 steps as this is where the energy and magnetisation has easily converged by and is also the point after which the initial large drop in energy has been overcome for T=2 too.

''Figure 9'' shows the result of running the ILfinalframe.py for a 16x16 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg141716x16T1.png
| image2 = cg141716x16T2.png
| footer_align = left
| footer = Figure 9 - Results of running the ILfinalframe.py file at T=1,2 for a 16x16 matrix
}}

From ''Figure 9'', a suitable cut-off point is 15000 steps as for T=1 the energy and magnetisations have converged significantly and will not change much, and likewise this is the same for the T=2 frame.

''Figure 10'' below shows the results from a 32x32 matrix at T=1 and T=2.

{{multiple image
| width =350
| align = left
| image1 = cg141732x32T1.png
| image2 = cg141732x32T2.png
| footer_align = left
| footer = Figure 10 - Results of running the ILfinalframe.py file at T=1,2 for a 32x32 matrix
}}

''Figure 10'' above shows the results of running the ILfinalframe.py file for a 32x32 matrix at T=1 and T=2. As a result a suitable cut-off of 50000 steps was chosen as the energy and magnetisation has significantly converged, but not as much as it could at 100000 steps. I chose a slightly lower value to ensure that the run times of my monte-carlo simulations in future tasks were not extremely time consuming.

The montecarlostep() function was changed by adding a condition that values only above the pre-determined cut-off were included when determining the average value of energy; energy squared; magnetisation and magnetisations squared from the statistics function. The statistics() function did not need to be modified.

The following code is from the 32x32 matrixː

<pre>def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back

if self.n_cycles > 50000: #only adds values to array of E,E2,M and M2 is above specific cut-off
self.E+=[self.energy()]
self.E2+=[self.energy()**2]
self.M+=[self.magnetisation()]
self.M2+=[self.magnetisation()**2]
self.n_cycles=self.n_cycles+1

return (self.energy(),self.magnetisation())
</pre>

===TASK: Use ILtemperaturerange.py to plot the average energy and magnetisation for each temperature, with error bars, for an <math>8\times 8</math> lattice. Use your intuition and results from the script ILfinalframe.py to estimate how many cycles each simulation should be. The temperature range 0.25 to 5.0 is sufficient. Use as many temperature points as you feel necessary to illustrate the trend, but do not use a temperature spacing larger than 0.5. The NumPy function savetxt() stores your array of output data on disk — you will need it later. Save the file as 8x8.dat so that you know which lattice size it came from.===

Using the modified code, the file ILtemperaturerange.py was ran on an 8x8 matrix between T=0.5 and T=5 with a step of T=0.02 for 10000 Montecarlo steps and the first 1000 steps of each temperature were excluded when calculating the averages. Figure 12 shows the result of the simulation and also included error bars of standard deviation.

[[File:Cg14178x8error.png|1000px|thumb|left|Figure 12 - Graph showing average energy and average magnetisation for an 8x8 lattice with error bars between T=0.5 and T=5]]

 

==Section 6 - The effect of system size==

===TASK: Repeat the final task of the previous section for the following lattice sizes: 2x2, 4x4, 8x8, 16x16, 32x32. Make sure that you name each datafile that your produce after the corresponding lattice size! Write a Python script to make a plot showing the energy per spin versus temperature for each of your lattice sizes. Hint: the NumPy loadtxt function is the reverse of the savetxt function, and can be used to read your previously saved files into the script. Repeat this for the magnetisation. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. How big a lattice do you think is big enough to capture the long range fluctuations?===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb.

Each matrix was simulated using the ILtemperaturerange.py file between T=0.5 and T=5 with a step of T=0.02.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2error.png
| caption1 = 2x2 matrix - 5000 steps, cut-off = 30 steps
| image2 = 4x4error.png
| caption2 = 4x4 matrix - 1000 steps, cut-off = 200 steps
| image3 =cg141716x16error.png
| caption3 = 16x16 matrix - 50000 steps, cut-off = 15000 steps
| image4 =cg141732x32error.png
| caption4 = 32x32 matrix - 200000 steps, cut-off = 50000 steps
| footer_align = left
| footer = Figure 13 - Results of running the ILtemperaturerange.py file for 2x2, 4x4, 16x16 and 32x32 matrices.
}}

 

==Section 7 - Determining the Heat Capacity==

===TASK: By definition, <math>C = \frac{\partial \left\langle E\right\rangle}{\partial T}</math>. From this, show that <math>C = \frac{\mathrm{Var}[E]}{k_B T^2}</math> (Where <math>\mathrm{Var}[E]</math> is the variance in <math>E</math>.)===

Recall from statistical thermodynamics that the average energy of a system is the sum across all microstates of the probability of that microstate multiplied by the energy of that microstate, which is defined mathematically asː <math>\langle E \rangle = \sum_i p_{i}\epsilon_{i}</math>.

The partition function <math>q</math> is defined as <math>q = \sum_{i} exp(-\beta \epsilon_{i})</math> where <math>\beta =\frac{1}{k_BT}</math>and the probability, <math>p_{i}</math> can be defined in terms of the partition function as <math>p_{i} = \frac{exp(-\beta \epsilon_{i})}{\sum_{i} exp(-\beta \epsilon_{i})} = \frac{exp(-\beta \epsilon_{i})}{q}</math>.

As a result, <math>\langle E \rangle</math> can be re-written as <math>\langle E \rangle = \sum_{i} \frac{\epsilon_{i} exp(-\beta \epsilon_{i})}{q} = -\frac{1}{q} \frac{\partial}{\partial \beta}\sum_{i}exp(-\beta \epsilon_{i}) = -\frac{1}{q} \frac{\partial q}{\partial \beta}</math>

Likewise, <math>\langle E^2 \rangle = \sum_i p_{i}\epsilon_{i}^{2} = \sum_{i} \frac{\epsilon_{i}^{2}exp(-\beta \epsilon_{i})}{q} = \frac{1}{q} \frac{\partial^{2}}{\partial \beta^{2}}\sum_{i}exp(-\beta \epsilon_{i}) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}}</math>

From definitionː <math>Var[E] = \Delta E^2 = \langle E^2 \rangle - \langle E \rangle^2 </math>

When the definition of <math>\langle E \rangle</math> and <math>\langle E^2 \rangle</math> is written in terms of partition function <math>q</math>ː <math>Var[E] = \langle E^2 \rangle - \langle E \rangle^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \left(\frac{1}{q}\frac{\partial q}{\partial \beta}\right)^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2</math>.

According to the chain ruleː <math>\frac{\partial}{\partial \beta}\left(\frac{1}{q} \frac{\partial q}{\partial \beta}\right) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2 = -\frac{\partial}{\partial \beta}\langle E \rangle = Var[E]</math>

And using the chain rule againː <math>C = \frac{\partial \langle E \rangle}{\partial T}= \left(-\frac{\partial \langle E \rangle}{\partial \beta}\right) \left(-\frac{\partial \beta}{\partial T}\right) = \frac{Var[E]}{k_B T^2}</math>

===TASK: Write a Python script to make a plot showing the heat capacity versus temperature for each of your lattice sizes from the previous section. You may need to do some research to recall the connection between the variance of a variable, <math>\mathrm{Var}[X]</math>, the mean of its square <math>\left\langle X^2\right\rangle</math>, and its squared mean <math>\left\langle X\right\rangle^2</math>. You may find that the data around the peak is very noisy — this is normal, and is a result of being in the critical region. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. ===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb

{{multiple image
| width =300
| align = left
| image1 = cg14172x2heatcap.png
| caption1 = 2x2 Matrix
| image2 = cg14174x4heatcap.png
| caption2 = 4x4 Matrix
| image3 =cg14178x8heatcap.png
| caption3 = 8x8 Matrix
| image4 =cg141716x16heatcap.png
| caption4 = 16x16 Matrix
| image5=cg141732x32heatcap.png
| caption5= 32x32 Matrix
| footer = Figure 14 - Graphs showing Heat Capacity against Temperature for each matrix size
}}

A general trend from the above graphs is that the peak of the graph shifts towards lower temperatures as the size of the matrix used increases.

==Section 8 - Locating the Curie Temperature==
===TASK: A C++ program has been used to run some much longer simulations than would be possible on the college computers in Python. You can view its source code here if you are interested. Each file contains six columns: <math>T, E, E^2, M, M^2, C</math> (the final five quantities are per spin), and you can read them with the NumPy loadtxt function as before. For each lattice size, plot the C++ data against your data. For one lattice size, save a PNG of this comparison and add it to your report — add a legend to the graph to label which is which. To do this, you will need to pass the label="..." keyword to the plot function, then call the legend() function of the axis object (documentation here).===

The python code used to read and plot the C++ data is found in the Jupyter notebook CG1417IsingModelGraphs.ipynb.

''Figure 15'' below shows the C++ plotted against my own data for a 16x16 Matrix.

[[File:Cg141716x16C++.png|400px|thumb|left|Figure 15 - Graph showing my own data against the C++ data for a 16x16 matrix.]]

 

===TASK: write a script to read the data from a particular file, and plot C vs T, as well as a fitted polynomial. Try changing the degree of the polynomial to improve the fit — in general, it might be difficult to get a good fit! Attach a PNG of an example fit to your report.===

The python script to read and plot the fitted polynomial is found in CG1417PolyfitScript.ipynb

Below in ''Figure 16'' is a plot of my Heat Capacity against Temperature data for a 16x16 matrix and features a polynomial of degree 35 plotted against it. Even with a polynomial of such a high degree, it poorly fits the curve and does not fit to the peak of the curve either.

[[File:cg1417FIT_TEST16x16_35.png|thumb|left|400px|Figure 16 - Plot of Heat Capacity against Temperature along with a poorly fitted polynomial of degree 35. ]]

 

===TASK: Modify your script from the previous section. You should still plot the whole temperature range, but fit the polynomial only to the peak of the heat capacity! You should find it easier to get a good fit when restricted to this region===

The script was modified as such that the polynomial was fitted in a set range around the peak of the graph, this is demonstrated in ''Figure 17'' which shows a newly fitted polynomial between a much smaller range of temperatures (T = 2.15-2.55) and a much smaller degree polynomial (3).

[[File:CG1417FIT_16x16C_3.png|thumb|left|400px|Figure 17 - Graph showing Heat Capacity against Temperature for a 16x16 matrix along with a fitted polynomial between a much more restricted range of temperatures and a significantly lower degree of polynomial]]

Upon comparison with ''Figure 16'', the new fitted polynomial is a significantly better fit even for a 3rd degree polynomial and is a much more accurate representation of my data around the peak of the graph and will make it easier to determine the maximum value of Heat Capacity.

 

===TASK: find the temperature at which the maximum in C occurs for each datafile that you were given. Make a text file containing two colums: the lattice side length (2,4,8, etc.), and the temperature at which C is a maximum. This is your estimate of <math>T_C</math> for that side length. Make a plot that uses the scaling relation given above to determine <math>T_{C,\infty}</math>. By doing a little research online, you should be able to find the theoretical exact Curie temperature for the infinite 2D Ising lattice. How does your value compare to this? Are you surprised by how good/bad the agreement is? Attach a PNG of this final graph to your report, and discuss briefly what you think the major sources of error are in your estimate.===

Figure 17 below shows a graph of <math>T_{C,L}</math> against <math>\frac{1}{Lattice Size}</math> to determine the Curie Temperature of an infinite 2D Ising Model Lattice <math>T_{C,\infty}</math>. The black dots represent the raw data obtained from obtaining the temperature at which the Heat Capacity was a maximum for the lattices and the red line in a linear curve fit plotted against the data to allow the y-intercept which is the Curie Temperature for the infinite 2D lattice to be determined.

[[File:cg1417CurieTemp.png|400px|thumb|left|Figure 17 - Plot of 1/Lattice Size against Curie Temperature for that lattice size.]]

The value for <math>T_{C,\inf}</math> obtained from the data is <math>T_{C,\infty} = 2.277 \frac{J}{k_B}</math> with a literature value being <math>T_{C,\infty} = 2.269 \frac{J}{k_B}</math> for an infinite square 2D lattice. This means that my result slightly over-estimates the Curie Temperature for the infinite lattice and as a result for an infinite lattice the temperature at which spontaneous magnetisation stops would actually occur at a slightly lower temperature than expected. However, the difference between my value and the literature value is only 0.008 which is incredibly small and the amount of agreement between the two values is somewhat surprising, which means that the error in my estimates of the Curie Temperature for each lattice size is relatively small. A potential source of error from the values of the Curie Temperature for each lattice size could come from the

Rep:Y3CMPCG1417

2019-11-20T07:52:43Z

==Section 1 - Introduction to the Ising Model==

===TASK: Show that the lowest possible energy for the Ising model is <math>E = -DNJ</math>, where D is the number of dimensions and N is the total number of spins. What is the multiplicity of this state? Calculate its entropy.===

Consider a 1D row of lattice sites of N=3 with spin configuration [+1][+1][+1].

Mathematically the interaction energy is defined asː
<math> -\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} </math> where J is a constant and <math>s_{i}s_{j}</math> is the product between two spins in adjacent lattice sites.

The sum of the interaction energies <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j}</math> can be considered as the sum of the individual interaction energies between spinsː
<math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = \epsilon_{12} + \epsilon_{23} + \epsilon_{13} + \epsilon_{21} + \epsilon_{32} + \epsilon_{31} </math>.

Although lattice sites 1 and 3 are not adjacent they are said to still interact according to the periodic boundary conditions applied.

However, <math>\epsilon_{12} = \epsilon_{21} </math> and <math>\epsilon_{23} = \epsilon_{32}</math> and <math>\epsilon_{13} = \epsilon_{31}</math> which means that all of the interactions within the system are counted twice, hence the total energy needs to be halved, resulting in the following formula being obtainedː <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = 2\epsilon_{12} + 2\epsilon_{13} + 2\epsilon_{23} </math>.

It can be determined that <math>\epsilon_{12} = (+1)(+1) = 1</math> , <math>\epsilon_{13} = (+1)(+1) = 1</math> and <math>\epsilon_{23} = (+1)(+1) = 1</math>.

Thereforeː <math>-\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = -\frac{1}{2} \ J \ (2 + 2 + 2) = -\frac{1}{2} \ J \ 6 = - 3 J = -DNJ</math> for a 1D lattice with <math>D=1</math> and 3 lattice sites <math>N=3</math>

The multiplicity of the system,<math>\Omega = 2S+1</math> where <math>S</math> is the total magnetisation of the system.

In this case, <math>\Omega = 2(3)+1 = 7</math>

Entropy, <math>S</math> is defined as <math>S = k_B ln(\Omega)</math> and so in this case <math>S = k_B ln7 = 1.95 k_B</math>

===TASK: Imagine that the system is in the lowest energy configuration. To move to a different state, one of the spins must spontaneously change direction ("flip"). What is the change in energy if this happens <math>(D=3, N=1000)</math>? How much entropy does the system gain by doing soʔ===

In a 3D lattice system, each lattice site has three unique interactions with its neighbours to its left, top and front. In the lowest energy configuration, all spins are parallel and for a system the minimum energy is <math>E = -DNJ</math>, so for the system with <math>N=1000</math> and <math>D=3</math>, the minimum energy is <math>-3000J</math>.

If a single spin is flipped, the product of its spin with its neighbours spin reverses and becomes negative and this increases the total energy of the system. Since 3 unique spin-spin interactions are reversed in sign, the total energy increases by <math>+3J</math>, meaning the new total energy is <math>-2997J</math>

Initially the multiplicity of the system will be <math>\Omega = 2(1000)+1=2001</math> , and after the flip, the multiplicity becomes <math>\Omega = 2(1000-1)+1=1999</math>.

The associated change in entropy, <math>\Delta S = k_B ln(1999) - k_B ln(2001)= k_B ln(\frac{1999}{2001}) = -0.001 k_B</math>, which is a very small decrease in entropy as the system starts

===TASK: Calculate the magnetisation of the 1D and 2D lattices in Figure 1. What magnetisation would you expect to observe for an Ising lattice with <math>D = 3,\ N=1000</math> at absolute zero?===

[[File:ThirdYearCMPExpt-IsingSketch.png|thumb|left|Figure 1 - Shows 1D (N = 5), 2D (N = 5x5) and 3D (N = 5x5x5) lattices.]]

Magnetisation is defined as <math>M=\sum_{i} s_i</math>. So for the 1D lattice with <math>N = 5</math> in ''Figure 2'', <math>M = +1</math> and for the 2D lattice with <math>N = 25 , M = +1</math> too.

According to the 3rd Law of thermodynamics, entropy is 0 at absolute zero for a perfect crystalline solid, and consequently it is expected that the lattices will have follow suit and have zero entropy at 0K. To have zero entropy all spins must be paired as such that magnetisation, <math>M = 0</math> - which is only possible in the lattices contains an even numbers of lattice sites (N = even). So, for a lattice with <math>N = 1000</math> and <math>D =3</math>, if <math>M = 0</math>, then multiplicity, <math>\Omega = 1</math> and entropy, <math>S =k_B ln(\Omega) = 0</math>.

==Section 2 - Calculating the Energy and Magnetisation==

===TASK: complete the functions energy() and magnetisation(), which should return the energy of the lattice and the total magnetisation, respectively. In the energy() function you may assume that <math>J=1.0</math> at all times (in fact, we are working in reduced units in which <math>J=k_B</math>, but there will be more information about this in later sections). Do not worry about the efficiency of the code at the moment — we will address the speed in a later part of the experiment.===

<pre>def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
lat=self.lattice #creates lattice and stores it
mag=[]
for i in range(0,len(lat)): #loops through all rows of lattice
for j in range(0,len(lat[i])): #loops through elements of each row
mag+=[lat[i][j]] #adds spin value to mag array
return sum(mag) #sums all spins from mag array
</pre>

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

lat=self.lattice #creates lattice and stores it
left=[]
top=[]

for i in range(0,len(lat)):
for j in range(0,len(lat[i])):
left+=[lat[i][j]*lat[i][j-1]] #multiplies spin by spin to left
top+=[lat[i][j]*lat[i-1][j]] #multiplies spin by spin above it
int_en=left+top #sums spin products from left and top
energy=-sum(int_en) #sums all spin products for each spin to give total

return energy
</pre>

===TASK: Run the ILcheck.py script from the IPython Qt console using the command===

''Figure 2'' shows the results when ILcheck.py was ran on my IsingLattice.py file. The ILcheck.py file was ran several times to ensure the code worked for various random lattices.

[[File:Cg1417ILcheck run.png|thumb|left|500px| Figure 2 - Result from running the ILcheck.py file]]

 

==Section 3 - Introduction to Monte Carlo Simulation==

===TASK: How many configurations are available to a system with 100 spins? To evaluate these expressions, we have to calculate the energy and magnetisation for each of these configurations, then perform the sum. Let's be very, very, generous, and say that we can analyse <math>1\times 10^9</math> configurations per second with our computer. How long will it take to evaluate a single value of <math>\left\langle M\right\rangle_T</math>?===

For a system with 100 lattice sites and two possible spins for each site, there are <math>2^{100}</math>possible configurations for the system. <math>2^{100}= 1.27\times 10^{30} </math>, so if the computer can analyse <math>1\times 10^9</math> configurations per second, then it will take <math>\frac{1.27\times 10^{30}}{10^9} = 1.27\times 10^{21} s</math> to analyse the whole system, which is older than the age of the universe and therefore is not a practical approach.

===TASK: Implement a single cycle of the above algorithm in the montecarlocycle(T) function. This function should return the energy of your lattice and the magnetisation at the end of the cycle. You may assume that the energy returned by your energy() function is in units of <math>k_B</math>! Complete the statistics() function. This should return the following quantities whenever it is called: <math><E>, <E^2>, <M>, <M^2></math>, and the number of Monte Carlo steps that have elapsed.===
<pre>
E = []
E2 = []
M = []
M2 = []
n_cycles = 0

def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back if rejected else not changed

self.E+=[self.energy()] #records energy
self.E2+=[self.energy()**2] #records energy squared
self.M+=[self.magnetisation()] #records magnetisation
self.M2+=[self.magnetisation()**2] #records magnetisation squared
self.n_cycles=self.n_cycles+1 #adds 1 to run total

return (self.energy(),self.magnetisation())

def statistics(self):
# complete this function so that it calculates the correct values for the averages of E, E*E (E2), M, M*M (M2), and returns them

e=np.mean(self.E)
e2=np.mean(self.E2)
m=np.mean(self.M)
m2=np.mean(self.M2)

return e,e2,m,m2,self.n_cycles
</pre>

===TASK: If <math>T < T_C</math>, do you expect a spontaneous magnetisation (i.e. do you expect <math>\left\langle M\right\rangle \neq 0</math>)? When the state of the simulation appears to stop changing (when you have reached an equilibrium state), use the controls to export the output to PNG and attach this to your report. You should also include the output from your statistics() function.===

If the temperature of the system is less than the Curie Temperature, <math>T_C</math> then spontaneous magnetisation can occur and the system will tend to its lowest energy state where all of the spins are parallel - this is a property of ferromagnetic materials.

[[File:Cg1417ILanim_run.png|400px|thumb|left|Figure 3 - Results from running the ILanim.py file - shows the energy and magnetisation converging over time]]

''Figure 3'' shows that over time the the system spontaneously converges to the minimum energy state with all of the spins parallel to one another and shows, as I expected, that spontaneous magnetisation occurs and also shows that the temperature of this simulation is below the Curie Temperature, <math>T < T_C</math>.

 

==Section 4 - Accelerating the Code==

===TASK: Use the script ILtimetrial.py to record how long your current version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 4'' show the results of running the ILtimetrial.py file on my code three timesː

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1.png
| width1=500
| image2=cg1417ILtimetrial_run2.png
| width2=500
| image3=cg1417ILtimetrial_run3.png
| width3=500
| footer = Figure 4 - Results of running the ILtimetrial.py file on my code three separate times
}}
 

This gave me an avergage time of <math>24.3 s \pm 0.2s</math>

===TASK: Look at the documentation for the NumPy sum function. You should be able to modify your magnetisation() function so that it uses this to evaluate M. The energy is a little trickier. Familiarise yourself with the NumPy roll and multiply functions, and use these to replace your energy double loop (you will need to call roll and multiply twice!).===

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

left=multiply(roll(self.lattice,1,axis=1),self.lattice) #product of spin with spin left of it
top=multiply(roll(self.lattice,-1,axis=0),self.lattice) #product of spin with spin above it

int_en=sum(left+top) #sum of array containing sum of left and top spin products for each spin

energy = -sum(int_en) #calculates the total energy of system
return energy

def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
return sum(sum(self.lattice)) #adds up all spins in lattice
</pre>

===TASK: Use the script ILtimetrial.py to record how long your new version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 5'' shows the result of running the ILtimetrial.py on my new accelerated code.

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1fast.png
| width1=500
| image2=ILtimetrial_run2fast.png
| width2=500
| image3=ILtimetrial_run3fast.png
| width3=500
| footer = Figure 5 - Results of running the ILtimetrial.py file on my new updated and accelerated code.
}}
 

The accelerated code is much faster upon using the roll, multiply and s with a new average time of <math>0.790 s \pm 0.005 </math>

==Section 5 - The effect of temperature==

===TASK: The script ILfinalframe.py runs for a given number of cycles at a given temperature, then plots a depiction of the final lattice state as well as graphs of the energy and magnetisation as a function of cycle number. This is much quicker than animating every frame! Experiment with different temperature and lattice sizes. How many cycles are typically needed for the system to go from its random starting position to the equilibrium state? Modify your statistics() and montecarlostep() functions so that the first N cycles of the simulation are ignored when calculating the averages. You should state in your report what period you chose to ignore, and include graphs from ILfinalframe.py to illustrate your motivation in choosing this figure.===

''Figure 7'' below shows the results from running the ILfinalframe.py for 2x2 lattice at T=1,2,3,5.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2T1.png
| image2 = cg14172x2T2.png
| image3 =cg14172x2T3.png
| image4 =cg14172x2T5.png
| footer_align = left
| footer = Figure 7 - Results of running the ILfinalframe.py file at T=1,2,3,5 for a 2x2 matrix.
}}

 

For a 2x2 matrix, a suitable cut-off point to exclude from the avergage energies and magnetisations is where the energy and magnetisations per spin are constant, which is 30 steps. For T=3 and T=5 the graphs do not converge because it is possible that these temperatures are higher than the Curie Temperature and as such spontaneous magnetisation will not occur and the system will not diverge to the lowest energy state. At the higher temperatures, there are larger thermal fluctations and the Boltzmann factor is more significant allowing the system to move away from the lowest energy state easier. As a result moving forwards, a suitable cut-off point will only be determined from T=1 and T=2 graphs for the larger matrices.

''Figure 8'' shows the results from running a 4x4 lattice at T=1,2 and 3.

{{multiple image
| width =350
| align = left
| image1 = cg14174x4T1.png
| image2 = cg14174x4T2.png
| image3 =cg14174x4T3.png
| footer_align = left
| footer = Figure 8 - Results of running the ILfinalframe.py file at T=1,2,3 for a 4x4 matrix.
}}

From ''Figure 8'', a suitable cut-off point for the energy and magnetisations is 200 as this is after where the energy and magnetisation has converged for T=1, and is after the initial large drop in energy for T=2, even though there are a few small fluctuations after 200 steps. The result from T=3 has been included to show the large fluctuations for the larger temperatures, and supporting my choice to determine the cut-off from T=1 and T=2 only.

''Figure 9'' shows the results for an 8x8 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg14178x8T1.png
| image2 = cg14178x8T2.png
| footer_align = left
| footer = Figure 9 - Results of running the ILfinalframe.py file at T=1,2 for an 8x8 matrix
}}

From ''Figure 9'' above, a suitable cut-off point is 1000 steps as this is where the energy and magnetisation has easily converged by and is also the point after which the initial large drop in energy has been overcome for T=2 too.

''Figure 10'' shows the result of running the ILfinalframe.py for a 16x16 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg141716x16T1.png
| image2 = cg141716x16T2.png
| footer_align = left
| footer = Figure 10 - Results of running the ILfinalframe.py file at T=1,2 for a 16x16 matrix
}}

From ''Figure 10'', a suitable cut-off point is 15000 steps as for T=1 the energy and magnetisations have converged significantly and will not change much, and likewise this is the same for the T=2 frame.

''Figure 11'' below shows the results from a 32x32 matrix at T=1 and T=2.

{{multiple image
| width =350
| align = left
| image1 = cg141732x32T1.png
| image2 = cg141732x32T2.png
| footer_align = left
| footer = Figure 11 - Results of running the ILfinalframe.py file at T=1,2 for a 32x32 matrix
}}

''Figure 11'' above shows the results of running the ILfinalframe.py file for a 32x32 matrix at T=1 and T=2. As a result a suitable cut-off of 50000 steps was chosen as the energy and magnetisation has significantly converged, but not as much as it could at 100000 steps. I chose a slightly lower value to ensure that the run times of my monte-carlo simulations in future tasks were not extremely time consuming.

The montecarlostep() function was changed by adding a condition that values only above the pre-determined cut-off were included when determining the average value of energy; energy squared; magnetisation and magnetisations squared from the statistics function. The statistics() function did not need to be modified.

The following code is from the 32x32 matrixː

<pre>def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back

if self.n_cycles > 50000: #only adds values to array of E,E2,M and M2 is above specific cut-off
self.E+=[self.energy()]
self.E2+=[self.energy()**2]
self.M+=[self.magnetisation()]
self.M2+=[self.magnetisation()**2]
self.n_cycles=self.n_cycles+1

return (self.energy(),self.magnetisation())
</pre>

===TASK: Use ILtemperaturerange.py to plot the average energy and magnetisation for each temperature, with error bars, for an <math>8\times 8</math> lattice. Use your intuition and results from the script ILfinalframe.py to estimate how many cycles each simulation should be. The temperature range 0.25 to 5.0 is sufficient. Use as many temperature points as you feel necessary to illustrate the trend, but do not use a temperature spacing larger than 0.5. The NumPy function savetxt() stores your array of output data on disk — you will need it later. Save the file as 8x8.dat so that you know which lattice size it came from.===

Using the modified code, the file ILtemperaturerange.py was ran on an 8x8 matrix between T=0.5 and T=5 with a step of T=0.02 for 10000 Montecarlo steps and the first 1000 steps of each temperature were excluded when calculating the averages. Figure 12 shows the result of the simulation and also included error bars of standard deviation.

[[File:Cg14178x8error.png|1000px|thumb|left|Figure 12 - Graph showing average energy and average magnetisation for an 8x8 lattice with error bars between T=0.5 and T=5]]

 

==Section 6 - The effect of system size==

===TASK: Repeat the final task of the previous section for the following lattice sizes: 2x2, 4x4, 8x8, 16x16, 32x32. Make sure that you name each datafile that your produce after the corresponding lattice size! Write a Python script to make a plot showing the energy per spin versus temperature for each of your lattice sizes. Hint: the NumPy loadtxt function is the reverse of the savetxt function, and can be used to read your previously saved files into the script. Repeat this for the magnetisation. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. How big a lattice do you think is big enough to capture the long range fluctuations?===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb.

Each matrix was simulated using the ILtemperaturerange.py file between T=0.5 and T=5 with a step of T=0.02.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2error.png
| caption1 = 2x2 matrix - 5000 steps, cut-off = 30 steps
| image2 = 4x4error.png
| caption2 = 4x4 matrix - 1000 steps, cut-off = 200 steps
| image3 =cg141716x16error.png
| caption3 = 16x16 matrix - 50000 steps, cut-off = 15000 steps
| image4 =cg141732x32error.png
| caption4 = 32x32 matrix - 200000 steps, cut-off = 50000 steps
| footer_align = left
| footer = Figure 13 - Results of running the ILtemperaturerange.py file for 2x2, 4x4, 16x16 and 32x32 matrices.
}}

 

==Section 7 - Determining the Heat Capacity==

===TASK: By definition, <math>C = \frac{\partial \left\langle E\right\rangle}{\partial T}</math>. From this, show that <math>C = \frac{\mathrm{Var}[E]}{k_B T^2}</math> (Where <math>\mathrm{Var}[E]</math> is the variance in <math>E</math>.)===

Recall from statistical thermodynamics that the average energy of a system is the sum across all microstates of the probability of that microstate multiplied by the energy of that microstate, which is defined mathematically asː <math>\langle E \rangle = \sum_i p_{i}\epsilon_{i}</math>.

The partition function <math>q</math> is defined as <math>q = \sum_{i} exp(-\beta \epsilon_{i})</math> where <math>\beta =\frac{1}{k_BT}</math>and the probability, <math>p_{i}</math> can be defined in terms of the partition function as <math>p_{i} = \frac{exp(-\beta \epsilon_{i})}{\sum_{i} exp(-\beta \epsilon_{i})} = \frac{exp(-\beta \epsilon_{i})}{q}</math>.

As a result, <math>\langle E \rangle</math> can be re-written as <math>\langle E \rangle = \sum_{i} \frac{\epsilon_{i} exp(-\beta \epsilon_{i})}{q} = -\frac{1}{q} \frac{\partial}{\partial \beta}\sum_{i}exp(-\beta \epsilon_{i}) = -\frac{1}{q} \frac{\partial q}{\partial \beta}</math>

Likewise, <math>\langle E^2 \rangle = \sum_i p_{i}\epsilon_{i}^{2} = \sum_{i} \frac{\epsilon_{i}^{2}exp(-\beta \epsilon_{i})}{q} = \frac{1}{q} \frac{\partial^{2}}{\partial \beta^{2}}\sum_{i}exp(-\beta \epsilon_{i}) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}}</math>

From definitionː <math>Var[E] = \Delta E^2 = \langle E^2 \rangle - \langle E \rangle^2 </math>

When the definition of <math>\langle E \rangle</math> and <math>\langle E^2 \rangle</math> is written in terms of partition function <math>q</math>ː <math>Var[E] = \langle E^2 \rangle - \langle E \rangle^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \left(\frac{1}{q}\frac{\partial q}{\partial \beta}\right)^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2</math>.

According to the chain ruleː <math>\frac{\partial}{\partial \beta}\left(\frac{1}{q} \frac{\partial q}{\partial \beta}\right) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2 = -\frac{\partial}{\partial \beta}\langle E \rangle = Var[E]</math>

And using the chain rule againː <math>C = \frac{\partial \langle E \rangle}{\partial T}= \left(-\frac{\partial \langle E \rangle}{\partial \beta}\right) \left(-\frac{\partial \beta}{\partial T}\right) = \frac{Var[E]}{k_B T^2}</math>

===TASK: Write a Python script to make a plot showing the heat capacity versus temperature for each of your lattice sizes from the previous section. You may need to do some research to recall the connection between the variance of a variable, <math>\mathrm{Var}[X]</math>, the mean of its square <math>\left\langle X^2\right\rangle</math>, and its squared mean <math>\left\langle X\right\rangle^2</math>. You may find that the data around the peak is very noisy — this is normal, and is a result of being in the critical region. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. ===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb

{{multiple image
| width =300
| align = left
| image1 = cg14172x2heatcap.png
| caption1 = 2x2 Matrix
| image2 = cg14174x4heatcap.png
| caption2 = 4x4 Matrix
| image3 =cg14178x8heatcap.png
| caption3 = 8x8 Matrix
| image4 =cg141716x16heatcap.png
| caption4 = 16x16 Matrix
| image5=cg141732x32heatcap.png
| caption5= 32x32 Matrix
| footer = Figure 14 - Graphs showing Heat Capacity against Temperature for each matrix size
}}

A general trend from the above graphs is that the peak of the graph shifts towards lower temperatures as the size of the matrix used increases.

==Section 8 - Locating the Curie Temperature==
===TASK: A C++ program has been used to run some much longer simulations than would be possible on the college computers in Python. You can view its source code here if you are interested. Each file contains six columns: <math>T, E, E^2, M, M^2, C</math> (the final five quantities are per spin), and you can read them with the NumPy loadtxt function as before. For each lattice size, plot the C++ data against your data. For one lattice size, save a PNG of this comparison and add it to your report — add a legend to the graph to label which is which. To do this, you will need to pass the label="..." keyword to the plot function, then call the legend() function of the axis object (documentation here).===

The python code used to read and plot the C++ data is found in the Jupyter notebook CG1417IsingModelGraphs.ipynb.

''Figure 15'' below shows the C++ plotted against my own data for a 16x16 Matrix.

[[File:Cg141716x16C++.png|400px|thumb|left|Figure 15 - Graph showing my own data against the C++ data for a 16x16 matrix.]]

 

===TASK: write a script to read the data from a particular file, and plot C vs T, as well as a fitted polynomial. Try changing the degree of the polynomial to improve the fit — in general, it might be difficult to get a good fit! Attach a PNG of an example fit to your report.===

The python script to read and plot the fitted polynomial is found in CG1417PolyfitScript.ipynb

Below in ''Figure 16'' is a plot of my Heat Capacity against Temperature data for a 16x16 matrix and features a polynomial of degree 35 plotted against it. Even with a polynomial of such a high degree, it poorly fits the curve and does not fit to the peak of the curve either.

[[File:cg1417FIT_TEST16x16_35.png|thumb|left|400px|Figure 16 - Plot of Heat Capacity against Temperature along with a poorly fitted polynomial of degree 35. ]]

 

===TASK: Modify your script from the previous section. You should still plot the whole temperature range, but fit the polynomial only to the peak of the heat capacity! You should find it easier to get a good fit when restricted to this region===

The script was modified as such that the polynomial was fitted in a set range around the peak of the graph, this is demonstrated in ''Figure 17'' which shows a newly fitted polynomial between a much smaller range of temperatures (T = 2.15-2.55) and a much smaller degree polynomial (3).

[[File:CG1417FIT_16x16C_3.png|thumb|left|400px|Figure 17 - Graph showing Heat Capacity against Temperature for a 16x16 matrix along with a fitted polynomial between a much more restricted range of temperatures and a significantly lower degree of polynomial]]

Upon comparison with ''Figure 16'', the new fitted polynomial is a significantly better fit even for a 3rd degree polynomial and is a much more accurate representation of my data around the peak of the graph and will make it easier to determine the maximum value of Heat Capacity.

 

===TASK: find the temperature at which the maximum in C occurs for each datafile that you were given. Make a text file containing two colums: the lattice side length (2,4,8, etc.), and the temperature at which C is a maximum. This is your estimate of <math>T_C</math> for that side length. Make a plot that uses the scaling relation given above to determine <math>T_{C,\infty}</math>. By doing a little research online, you should be able to find the theoretical exact Curie temperature for the infinite 2D Ising lattice. How does your value compare to this? Are you surprised by how good/bad the agreement is? Attach a PNG of this final graph to your report, and discuss briefly what you think the major sources of error are in your estimate.===

Figure 17 below shows a graph of <math>T_{C,L}</math> against <math>\frac{1}{Lattice Size}</math> to determine the Curie Temperature of an infinite 2D Ising Model Lattice <math>T_{C,\infty}</math>. The black dots represent the raw data obtained from obtaining the temperature at which the Heat Capacity was a maximum for the lattices and the red line in a linear curve fit plotted against the data to allow the y-intercept which is the Curie Temperature for the infinite 2D lattice to be determined.

[[File:cg1417CurieTemp.png|400px|thumb|left|Figure 17 - Plot of 1/Lattice Size against Curie Temperature for that lattice size.]]

The value for <math>T_{C,\inf}</math> obtained from the data is <math>T_{C,\infty} = 2.277 \frac{J}{k_B}</math> with a literature value being <math>T_{C,\infty} = 2.269 \frac{J}{k_B}</math> for an infinite square 2D lattice. This means that my result slightly over-estimates the Curie Temperature for the infinite lattice and as a result for an infinite lattice the temperature at which spontaneous magnetisation stops would actually occur at a slightly lower temperature than expected. However, the difference between my value and the literature value is only 0.008 which is incredibly small and the amount of agreement between the two values is somewhat surprising, which means that the error in my estimates of the Curie Temperature for each lattice size is relatively small. A potential source of error from the values of the Curie Temperature for each lattice size could come from the

Rep:Y3CMPCG1417

2019-11-20T07:52:28Z

==Section 1 - Introduction to the Ising Model==

===TASK: Show that the lowest possible energy for the Ising model is <math>E = -DNJ</math>, where D is the number of dimensions and N is the total number of spins. What is the multiplicity of this state? Calculate its entropy.===

Consider a 1D row of lattice sites of N=3 with spin configuration [+1][+1][+1].

Mathematically the interaction energy is defined asː
<math> -\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} </math> where J is a constant and <math>s_{i}s_{j}</math> is the product between two spins in adjacent lattice sites.

The sum of the interaction energies <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j}</math> can be considered as the sum of the individual interaction energies between spinsː
<math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = \epsilon_{12} + \epsilon_{23} + \epsilon_{13} + \epsilon_{21} + \epsilon_{32} + \epsilon_{31} </math>.

Although lattice sites 1 and 3 are not adjacent they are said to still interact according to the periodic boundary conditions applied.

However, <math>\epsilon_{12} = \epsilon_{21} </math> and <math>\epsilon_{23} = \epsilon_{32}</math> and <math>\epsilon_{13} = \epsilon_{31}</math> which means that all of the interactions within the system are counted twice, hence the total energy needs to be halved, resulting in the following formula being obtainedː <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = 2\epsilon_{12} + 2\epsilon_{13} + 2\epsilon_{23} </math>.

It can be determined that <math>\epsilon_{12} = (+1)(+1) = 1</math> , <math>\epsilon_{13} = (+1)(+1) = 1</math> and <math>\epsilon_{23} = (+1)(+1) = 1</math>.

Thereforeː <math>-\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = -\frac{1}{2} \ J \ (2 + 2 + 2) = -\frac{1}{2} \ J \ 6 = - 3 J = -DNJ</math> for a 1D lattice with <math>D=1</math> and 3 lattice sites <math>N=3</math>

The multiplicity of the system,<math>\Omega = 2S+1</math> where <math>S</math> is the total magnetisation of the system.

In this case, <math>\Omega = 2(3)+1 = 7</math>

Entropy, <math>S</math> is defined as <math>S = k_B ln(\Omega)</math> and so in this case <math>S = k_B ln7 = 1.95 k_B</math>

===TASK: Imagine that the system is in the lowest energy configuration. To move to a different state, one of the spins must spontaneously change direction ("flip"). What is the change in energy if this happens <math>(D=3, N=1000)</math>? How much entropy does the system gain by doing soʔ===

In a 3D lattice system, each lattice site has three unique interactions with its neighbours to its left, top and front. In the lowest energy configuration, all spins are parallel and for a system the minimum energy is <math>E = -DNJ</math>, so for the system with <math>N=1000</math> and <math>D=3</math>, the minimum energy is <math>-3000J</math>.

If a single spin is flipped, the product of its spin with its neighbours spin reverses and becomes negative and this increases the total energy of the system. Since 3 unique spin-spin interactions are reversed in sign, the total energy increases by <math>+3J</math>, meaning the new total energy is <math>-2997J</math>

Initially the multiplicity of the system will be <math>\Omega = 2(1000)+1=2001</math> , and after the flip, the multiplicity becomes <math>\Omega = 2(1000-1)+1=1999</math>.

The associated change in entropy, <math>\Delta S = k_B ln(1999) - k_B ln(2001)= k_B ln(\frac{1999}{2001}) = -0.001 k_B</math>, which is a very small decrease in entropy as the system starts

===TASK: Calculate the magnetisation of the 1D and 2D lattices in Figure 1. What magnetisation would you expect to observe for an Ising lattice with <math>D = 3,\ N=1000</math> at absolute zero?===

[[File:ThirdYearCMPExpt-IsingSketch.png|thumb|left|Figure 1 - Shows 1D (N = 5), 2D (N = 5x5) and 3D (N = 5x5x5) lattices.]]

Magnetisation is defined as <math>M=\sum_{i} s_i</math>. So for the 1D lattice with <math>N = 5</math> in ''Figure 2'', <math>M = +1</math> and for the 2D lattice with <math>N = 25 , M = +1</math> too.

According to the 3rd Law of thermodynamics, entropy is 0 at absolute zero for a perfect crystalline solid, and consequently it is expected that the lattices will have follow suit and have zero entropy at 0K. To have zero entropy all spins must be paired as such that magnetisation, <math>M = 0</math> - which is only possible in the lattices contains an even numbers of lattice sites (N = even). So, for a lattice with <math>N = 1000</math> and <math>D =3</math>, if <math>M = 0</math>, then multiplicity, <math>\Omega = 1</math> and entropy, <math>S =k_B ln(\Omega) = 0</math>.

==Section 2 - Calculating the Energy and Magnetisation==

===TASK: complete the functions energy() and magnetisation(), which should return the energy of the lattice and the total magnetisation, respectively. In the energy() function you may assume that <math>J=1.0</math> at all times (in fact, we are working in reduced units in which <math>J=k_B</math>, but there will be more information about this in later sections). Do not worry about the efficiency of the code at the moment — we will address the speed in a later part of the experiment.===

<pre>def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
lat=self.lattice #creates lattice and stores it
mag=[]
for i in range(0,len(lat)): #loops through all rows of lattice
for j in range(0,len(lat[i])): #loops through elements of each row
mag+=[lat[i][j]] #adds spin value to mag array
return sum(mag) #sums all spins from mag array
</pre>

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

lat=self.lattice #creates lattice and stores it
left=[]
top=[]

for i in range(0,len(lat)):
for j in range(0,len(lat[i])):
left+=[lat[i][j]*lat[i][j-1]] #multiplies spin by spin to left
top+=[lat[i][j]*lat[i-1][j]] #multiplies spin by spin above it
int_en=left+top #sums spin products from left and top
energy=-sum(int_en) #sums all spin products for each spin to give total

return energy
</pre>

===TASK: Run the ILcheck.py script from the IPython Qt console using the command===

''Figure 2'' shows the results when ILcheck.py was ran on my IsingLattice.py file. The ILcheck.py file was ran several times to ensure the code worked for various random lattices.

[[File:Cg1417ILcheck run.png|thumb|left|500px| Figure 2 - Result from running the ILcheck.py file]]

 

==Section 3 - Introduction to Monte Carlo Simulation==

===TASK: How many configurations are available to a system with 100 spins? To evaluate these expressions, we have to calculate the energy and magnetisation for each of these configurations, then perform the sum. Let's be very, very, generous, and say that we can analyse <math>1\times 10^9</math> configurations per second with our computer. How long will it take to evaluate a single value of <math>\left\langle M\right\rangle_T</math>?===

For a system with 100 lattice sites and two possible spins for each site, there are <math>2^{100}</math>possible configurations for the system. <math>2^{100}= 1.27\times 10^{30} </math>, so if the computer can analyse <math>1\times 10^9</math> configurations per second, then it will take <math>\frac{1.27\times 10^{30}}{10^9} = 1.27\times 10^{21} s</math> to analyse the whole system, which is older than the age of the universe and therefore is not a practical approach.

===TASK: Implement a single cycle of the above algorithm in the montecarlocycle(T) function. This function should return the energy of your lattice and the magnetisation at the end of the cycle. You may assume that the energy returned by your energy() function is in units of <math>k_B</math>! Complete the statistics() function. This should return the following quantities whenever it is called: <math><E>, <E^2>, <M>, <M^2></math>, and the number of Monte Carlo steps that have elapsed.===
<pre>
E = []
E2 = []
M = []
M2 = []
n_cycles = 0

def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back if rejected else not changed

self.E+=[self.energy()] #records energy
self.E2+=[self.energy()**2] #records energy squared
self.M+=[self.magnetisation()] #records magnetisation
self.M2+=[self.magnetisation()**2] #records magnetisation squared
self.n_cycles=self.n_cycles+1 #adds 1 to run total

return (self.energy(),self.magnetisation())

def statistics(self):
# complete this function so that it calculates the correct values for the averages of E, E*E (E2), M, M*M (M2), and returns them

e=np.mean(self.E)
e2=np.mean(self.E2)
m=np.mean(self.M)
m2=np.mean(self.M2)

return e,e2,m,m2,self.n_cycles
</pre>

===TASK: If <math>T < T_C</math>, do you expect a spontaneous magnetisation (i.e. do you expect <math>\left\langle M\right\rangle \neq 0</math>)? When the state of the simulation appears to stop changing (when you have reached an equilibrium state), use the controls to export the output to PNG and attach this to your report. You should also include the output from your statistics() function.===

If the temperature of the system is less than the Curie Temperature, <math>T_C</math> then spontaneous magnetisation can occur and the system will tend to its lowest energy state where all of the spins are parallel - this is a property of ferromagnetic materials.

[[File:Cg1417ILanim_run.png|400px|thumb|left|Figure 3 - Results from running the ILanim.py file - shows the energy and magnetisation converging over time]]

''Figure 3'' shows that over time the the system spontaneously converges to the minimum energy state with all of the spins parallel to one another and shows, as I expected, that spontaneous magnetisation occurs and also shows that the temperature of this simulation is below the Curie Temperature, <math>T < T_C</math>.

 

==Section 4 - Accelerating the Code==

===TASK: Use the script ILtimetrial.py to record how long your current version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 4'' show the results of running the ILtimetrial.py file on my code three timesː

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1.png
| width1=500
| image2=cg1417ILtimetrial_run2.png
| width2=500
| image3=cg1417ILtimetrial_run3.png
| width3=500
| footer = Figure 4 - Results of running the ILtimetrial.py file on my code three separate times
}}
 

This gave me an avergage time of <math>24.3 s \pm 0.2s</math>

===TASK: Look at the documentation for the NumPy sum function. You should be able to modify your magnetisation() function so that it uses this to evaluate M. The energy is a little trickier. Familiarise yourself with the NumPy roll and multiply functions, and use these to replace your energy double loop (you will need to call roll and multiply twice!).===

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

left=multiply(roll(self.lattice,1,axis=1),self.lattice) #product of spin with spin left of it
top=multiply(roll(self.lattice,-1,axis=0),self.lattice) #product of spin with spin above it

int_en=sum(left+top) #sum of array containing sum of left and top spin products for each spin

energy = -sum(int_en) #calculates the total energy of system
return energy

def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
return sum(sum(self.lattice)) #adds up all spins in lattice
</pre>

===TASK: Use the script ILtimetrial.py to record how long your new version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 6'' shows the result of running the ILtimetrial.py on my new accelerated code.

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1fast.png
| width1=500
| image2=ILtimetrial_run2fast.png
| width2=500
| image3=ILtimetrial_run3fast.png
| width3=500
| footer = Figure 6 - Results of running the ILtimetrial.py file on my new updated and accelerated code.
}}
 

The accelerated code is much faster upon using the roll, multiply and s with a new average time of <math>0.790 s \pm 0.005 </math>

==Section 5 - The effect of temperature==

===TASK: The script ILfinalframe.py runs for a given number of cycles at a given temperature, then plots a depiction of the final lattice state as well as graphs of the energy and magnetisation as a function of cycle number. This is much quicker than animating every frame! Experiment with different temperature and lattice sizes. How many cycles are typically needed for the system to go from its random starting position to the equilibrium state? Modify your statistics() and montecarlostep() functions so that the first N cycles of the simulation are ignored when calculating the averages. You should state in your report what period you chose to ignore, and include graphs from ILfinalframe.py to illustrate your motivation in choosing this figure.===

''Figure 7'' below shows the results from running the ILfinalframe.py for 2x2 lattice at T=1,2,3,5.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2T1.png
| image2 = cg14172x2T2.png
| image3 =cg14172x2T3.png
| image4 =cg14172x2T5.png
| footer_align = left
| footer = Figure 7 - Results of running the ILfinalframe.py file at T=1,2,3,5 for a 2x2 matrix.
}}

 

For a 2x2 matrix, a suitable cut-off point to exclude from the avergage energies and magnetisations is where the energy and magnetisations per spin are constant, which is 30 steps. For T=3 and T=5 the graphs do not converge because it is possible that these temperatures are higher than the Curie Temperature and as such spontaneous magnetisation will not occur and the system will not diverge to the lowest energy state. At the higher temperatures, there are larger thermal fluctations and the Boltzmann factor is more significant allowing the system to move away from the lowest energy state easier. As a result moving forwards, a suitable cut-off point will only be determined from T=1 and T=2 graphs for the larger matrices.

''Figure 8'' shows the results from running a 4x4 lattice at T=1,2 and 3.

{{multiple image
| width =350
| align = left
| image1 = cg14174x4T1.png
| image2 = cg14174x4T2.png
| image3 =cg14174x4T3.png
| footer_align = left
| footer = Figure 8 - Results of running the ILfinalframe.py file at T=1,2,3 for a 4x4 matrix.
}}

From ''Figure 8'', a suitable cut-off point for the energy and magnetisations is 200 as this is after where the energy and magnetisation has converged for T=1, and is after the initial large drop in energy for T=2, even though there are a few small fluctuations after 200 steps. The result from T=3 has been included to show the large fluctuations for the larger temperatures, and supporting my choice to determine the cut-off from T=1 and T=2 only.

''Figure 9'' shows the results for an 8x8 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg14178x8T1.png
| image2 = cg14178x8T2.png
| footer_align = left
| footer = Figure 9 - Results of running the ILfinalframe.py file at T=1,2 for an 8x8 matrix
}}

From ''Figure 9'' above, a suitable cut-off point is 1000 steps as this is where the energy and magnetisation has easily converged by and is also the point after which the initial large drop in energy has been overcome for T=2 too.

''Figure 10'' shows the result of running the ILfinalframe.py for a 16x16 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg141716x16T1.png
| image2 = cg141716x16T2.png
| footer_align = left
| footer = Figure 10 - Results of running the ILfinalframe.py file at T=1,2 for a 16x16 matrix
}}

From ''Figure 10'', a suitable cut-off point is 15000 steps as for T=1 the energy and magnetisations have converged significantly and will not change much, and likewise this is the same for the T=2 frame.

''Figure 11'' below shows the results from a 32x32 matrix at T=1 and T=2.

{{multiple image
| width =350
| align = left
| image1 = cg141732x32T1.png
| image2 = cg141732x32T2.png
| footer_align = left
| footer = Figure 11 - Results of running the ILfinalframe.py file at T=1,2 for a 32x32 matrix
}}

''Figure 11'' above shows the results of running the ILfinalframe.py file for a 32x32 matrix at T=1 and T=2. As a result a suitable cut-off of 50000 steps was chosen as the energy and magnetisation has significantly converged, but not as much as it could at 100000 steps. I chose a slightly lower value to ensure that the run times of my monte-carlo simulations in future tasks were not extremely time consuming.

The montecarlostep() function was changed by adding a condition that values only above the pre-determined cut-off were included when determining the average value of energy; energy squared; magnetisation and magnetisations squared from the statistics function. The statistics() function did not need to be modified.

The following code is from the 32x32 matrixː

<pre>def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back

if self.n_cycles > 50000: #only adds values to array of E,E2,M and M2 is above specific cut-off
self.E+=[self.energy()]
self.E2+=[self.energy()**2]
self.M+=[self.magnetisation()]
self.M2+=[self.magnetisation()**2]
self.n_cycles=self.n_cycles+1

return (self.energy(),self.magnetisation())
</pre>

===TASK: Use ILtemperaturerange.py to plot the average energy and magnetisation for each temperature, with error bars, for an <math>8\times 8</math> lattice. Use your intuition and results from the script ILfinalframe.py to estimate how many cycles each simulation should be. The temperature range 0.25 to 5.0 is sufficient. Use as many temperature points as you feel necessary to illustrate the trend, but do not use a temperature spacing larger than 0.5. The NumPy function savetxt() stores your array of output data on disk — you will need it later. Save the file as 8x8.dat so that you know which lattice size it came from.===

Using the modified code, the file ILtemperaturerange.py was ran on an 8x8 matrix between T=0.5 and T=5 with a step of T=0.02 for 10000 Montecarlo steps and the first 1000 steps of each temperature were excluded when calculating the averages. Figure 12 shows the result of the simulation and also included error bars of standard deviation.

[[File:Cg14178x8error.png|1000px|thumb|left|Figure 12 - Graph showing average energy and average magnetisation for an 8x8 lattice with error bars between T=0.5 and T=5]]

 

==Section 6 - The effect of system size==

===TASK: Repeat the final task of the previous section for the following lattice sizes: 2x2, 4x4, 8x8, 16x16, 32x32. Make sure that you name each datafile that your produce after the corresponding lattice size! Write a Python script to make a plot showing the energy per spin versus temperature for each of your lattice sizes. Hint: the NumPy loadtxt function is the reverse of the savetxt function, and can be used to read your previously saved files into the script. Repeat this for the magnetisation. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. How big a lattice do you think is big enough to capture the long range fluctuations?===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb.

Each matrix was simulated using the ILtemperaturerange.py file between T=0.5 and T=5 with a step of T=0.02.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2error.png
| caption1 = 2x2 matrix - 5000 steps, cut-off = 30 steps
| image2 = 4x4error.png
| caption2 = 4x4 matrix - 1000 steps, cut-off = 200 steps
| image3 =cg141716x16error.png
| caption3 = 16x16 matrix - 50000 steps, cut-off = 15000 steps
| image4 =cg141732x32error.png
| caption4 = 32x32 matrix - 200000 steps, cut-off = 50000 steps
| footer_align = left
| footer = Figure 13 - Results of running the ILtemperaturerange.py file for 2x2, 4x4, 16x16 and 32x32 matrices.
}}

 

==Section 7 - Determining the Heat Capacity==

===TASK: By definition, <math>C = \frac{\partial \left\langle E\right\rangle}{\partial T}</math>. From this, show that <math>C = \frac{\mathrm{Var}[E]}{k_B T^2}</math> (Where <math>\mathrm{Var}[E]</math> is the variance in <math>E</math>.)===

Recall from statistical thermodynamics that the average energy of a system is the sum across all microstates of the probability of that microstate multiplied by the energy of that microstate, which is defined mathematically asː <math>\langle E \rangle = \sum_i p_{i}\epsilon_{i}</math>.

The partition function <math>q</math> is defined as <math>q = \sum_{i} exp(-\beta \epsilon_{i})</math> where <math>\beta =\frac{1}{k_BT}</math>and the probability, <math>p_{i}</math> can be defined in terms of the partition function as <math>p_{i} = \frac{exp(-\beta \epsilon_{i})}{\sum_{i} exp(-\beta \epsilon_{i})} = \frac{exp(-\beta \epsilon_{i})}{q}</math>.

As a result, <math>\langle E \rangle</math> can be re-written as <math>\langle E \rangle = \sum_{i} \frac{\epsilon_{i} exp(-\beta \epsilon_{i})}{q} = -\frac{1}{q} \frac{\partial}{\partial \beta}\sum_{i}exp(-\beta \epsilon_{i}) = -\frac{1}{q} \frac{\partial q}{\partial \beta}</math>

Likewise, <math>\langle E^2 \rangle = \sum_i p_{i}\epsilon_{i}^{2} = \sum_{i} \frac{\epsilon_{i}^{2}exp(-\beta \epsilon_{i})}{q} = \frac{1}{q} \frac{\partial^{2}}{\partial \beta^{2}}\sum_{i}exp(-\beta \epsilon_{i}) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}}</math>

From definitionː <math>Var[E] = \Delta E^2 = \langle E^2 \rangle - \langle E \rangle^2 </math>

When the definition of <math>\langle E \rangle</math> and <math>\langle E^2 \rangle</math> is written in terms of partition function <math>q</math>ː <math>Var[E] = \langle E^2 \rangle - \langle E \rangle^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \left(\frac{1}{q}\frac{\partial q}{\partial \beta}\right)^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2</math>.

According to the chain ruleː <math>\frac{\partial}{\partial \beta}\left(\frac{1}{q} \frac{\partial q}{\partial \beta}\right) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2 = -\frac{\partial}{\partial \beta}\langle E \rangle = Var[E]</math>

And using the chain rule againː <math>C = \frac{\partial \langle E \rangle}{\partial T}= \left(-\frac{\partial \langle E \rangle}{\partial \beta}\right) \left(-\frac{\partial \beta}{\partial T}\right) = \frac{Var[E]}{k_B T^2}</math>

===TASK: Write a Python script to make a plot showing the heat capacity versus temperature for each of your lattice sizes from the previous section. You may need to do some research to recall the connection between the variance of a variable, <math>\mathrm{Var}[X]</math>, the mean of its square <math>\left\langle X^2\right\rangle</math>, and its squared mean <math>\left\langle X\right\rangle^2</math>. You may find that the data around the peak is very noisy — this is normal, and is a result of being in the critical region. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. ===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb

{{multiple image
| width =300
| align = left
| image1 = cg14172x2heatcap.png
| caption1 = 2x2 Matrix
| image2 = cg14174x4heatcap.png
| caption2 = 4x4 Matrix
| image3 =cg14178x8heatcap.png
| caption3 = 8x8 Matrix
| image4 =cg141716x16heatcap.png
| caption4 = 16x16 Matrix
| image5=cg141732x32heatcap.png
| caption5= 32x32 Matrix
| footer = Figure 14 - Graphs showing Heat Capacity against Temperature for each matrix size
}}

A general trend from the above graphs is that the peak of the graph shifts towards lower temperatures as the size of the matrix used increases.

==Section 8 - Locating the Curie Temperature==
===TASK: A C++ program has been used to run some much longer simulations than would be possible on the college computers in Python. You can view its source code here if you are interested. Each file contains six columns: <math>T, E, E^2, M, M^2, C</math> (the final five quantities are per spin), and you can read them with the NumPy loadtxt function as before. For each lattice size, plot the C++ data against your data. For one lattice size, save a PNG of this comparison and add it to your report — add a legend to the graph to label which is which. To do this, you will need to pass the label="..." keyword to the plot function, then call the legend() function of the axis object (documentation here).===

The python code used to read and plot the C++ data is found in the Jupyter notebook CG1417IsingModelGraphs.ipynb.

''Figure 15'' below shows the C++ plotted against my own data for a 16x16 Matrix.

[[File:Cg141716x16C++.png|400px|thumb|left|Figure 15 - Graph showing my own data against the C++ data for a 16x16 matrix.]]

 

===TASK: write a script to read the data from a particular file, and plot C vs T, as well as a fitted polynomial. Try changing the degree of the polynomial to improve the fit — in general, it might be difficult to get a good fit! Attach a PNG of an example fit to your report.===

The python script to read and plot the fitted polynomial is found in CG1417PolyfitScript.ipynb

Below in ''Figure 16'' is a plot of my Heat Capacity against Temperature data for a 16x16 matrix and features a polynomial of degree 35 plotted against it. Even with a polynomial of such a high degree, it poorly fits the curve and does not fit to the peak of the curve either.

[[File:cg1417FIT_TEST16x16_35.png|thumb|left|400px|Figure 16 - Plot of Heat Capacity against Temperature along with a poorly fitted polynomial of degree 35. ]]

 

===TASK: Modify your script from the previous section. You should still plot the whole temperature range, but fit the polynomial only to the peak of the heat capacity! You should find it easier to get a good fit when restricted to this region===

The script was modified as such that the polynomial was fitted in a set range around the peak of the graph, this is demonstrated in ''Figure 17'' which shows a newly fitted polynomial between a much smaller range of temperatures (T = 2.15-2.55) and a much smaller degree polynomial (3).

[[File:CG1417FIT_16x16C_3.png|thumb|left|400px|Figure 17 - Graph showing Heat Capacity against Temperature for a 16x16 matrix along with a fitted polynomial between a much more restricted range of temperatures and a significantly lower degree of polynomial]]

Upon comparison with ''Figure 16'', the new fitted polynomial is a significantly better fit even for a 3rd degree polynomial and is a much more accurate representation of my data around the peak of the graph and will make it easier to determine the maximum value of Heat Capacity.

 

===TASK: find the temperature at which the maximum in C occurs for each datafile that you were given. Make a text file containing two colums: the lattice side length (2,4,8, etc.), and the temperature at which C is a maximum. This is your estimate of <math>T_C</math> for that side length. Make a plot that uses the scaling relation given above to determine <math>T_{C,\infty}</math>. By doing a little research online, you should be able to find the theoretical exact Curie temperature for the infinite 2D Ising lattice. How does your value compare to this? Are you surprised by how good/bad the agreement is? Attach a PNG of this final graph to your report, and discuss briefly what you think the major sources of error are in your estimate.===

Figure 17 below shows a graph of <math>T_{C,L}</math> against <math>\frac{1}{Lattice Size}</math> to determine the Curie Temperature of an infinite 2D Ising Model Lattice <math>T_{C,\infty}</math>. The black dots represent the raw data obtained from obtaining the temperature at which the Heat Capacity was a maximum for the lattices and the red line in a linear curve fit plotted against the data to allow the y-intercept which is the Curie Temperature for the infinite 2D lattice to be determined.

[[File:cg1417CurieTemp.png|400px|thumb|left|Figure 17 - Plot of 1/Lattice Size against Curie Temperature for that lattice size.]]

The value for <math>T_{C,\inf}</math> obtained from the data is <math>T_{C,\infty} = 2.277 \frac{J}{k_B}</math> with a literature value being <math>T_{C,\infty} = 2.269 \frac{J}{k_B}</math> for an infinite square 2D lattice. This means that my result slightly over-estimates the Curie Temperature for the infinite lattice and as a result for an infinite lattice the temperature at which spontaneous magnetisation stops would actually occur at a slightly lower temperature than expected. However, the difference between my value and the literature value is only 0.008 which is incredibly small and the amount of agreement between the two values is somewhat surprising, which means that the error in my estimates of the Curie Temperature for each lattice size is relatively small. A potential source of error from the values of the Curie Temperature for each lattice size could come from the

Rep:Y3CMPCG1417

2019-11-20T07:51:46Z

==Section 1 - Introduction to the Ising Model==

===TASK: Show that the lowest possible energy for the Ising model is <math>E = -DNJ</math>, where D is the number of dimensions and N is the total number of spins. What is the multiplicity of this state? Calculate its entropy.===

Consider a 1D row of lattice sites of N=3 with spin configuration [+1][+1][+1].

Mathematically the interaction energy is defined asː
<math> -\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} </math> where J is a constant and <math>s_{i}s_{j}</math> is the product between two spins in adjacent lattice sites.

The sum of the interaction energies <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j}</math> can be considered as the sum of the individual interaction energies between spinsː
<math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = \epsilon_{12} + \epsilon_{23} + \epsilon_{13} + \epsilon_{21} + \epsilon_{32} + \epsilon_{31} </math>.

Although lattice sites 1 and 3 are not adjacent they are said to still interact according to the periodic boundary conditions applied.

However, <math>\epsilon_{12} = \epsilon_{21} </math> and <math>\epsilon_{23} = \epsilon_{32}</math> and <math>\epsilon_{13} = \epsilon_{31}</math> which means that all of the interactions within the system are counted twice, hence the total energy needs to be halved, resulting in the following formula being obtainedː <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = 2\epsilon_{12} + 2\epsilon_{13} + 2\epsilon_{23} </math>.

It can be determined that <math>\epsilon_{12} = (+1)(+1) = 1</math> , <math>\epsilon_{13} = (+1)(+1) = 1</math> and <math>\epsilon_{23} = (+1)(+1) = 1</math>.

Thereforeː <math>-\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = -\frac{1}{2} \ J \ (2 + 2 + 2) = -\frac{1}{2} \ J \ 6 = - 3 J = -DNJ</math> for a 1D lattice with <math>D=1</math> and 3 lattice sites <math>N=3</math>

The multiplicity of the system,<math>\Omega = 2S+1</math> where <math>S</math> is the total magnetisation of the system.

In this case, <math>\Omega = 2(3)+1 = 7</math>

Entropy, <math>S</math> is defined as <math>S = k_B ln(\Omega)</math> and so in this case <math>S = k_B ln7 = 1.95 k_B</math>

===TASK: Imagine that the system is in the lowest energy configuration. To move to a different state, one of the spins must spontaneously change direction ("flip"). What is the change in energy if this happens <math>(D=3, N=1000)</math>? How much entropy does the system gain by doing soʔ===

In a 3D lattice system, each lattice site has three unique interactions with its neighbours to its left, top and front. In the lowest energy configuration, all spins are parallel and for a system the minimum energy is <math>E = -DNJ</math>, so for the system with <math>N=1000</math> and <math>D=3</math>, the minimum energy is <math>-3000J</math>.

If a single spin is flipped, the product of its spin with its neighbours spin reverses and becomes negative and this increases the total energy of the system. Since 3 unique spin-spin interactions are reversed in sign, the total energy increases by <math>+3J</math>, meaning the new total energy is <math>-2997J</math>

Initially the multiplicity of the system will be <math>\Omega = 2(1000)+1=2001</math> , and after the flip, the multiplicity becomes <math>\Omega = 2(1000-1)+1=1999</math>.

The associated change in entropy, <math>\Delta S = k_B ln(1999) - k_B ln(2001)= k_B ln(\frac{1999}{2001}) = -0.001 k_B</math>, which is a very small decrease in entropy as the system starts

===TASK: Calculate the magnetisation of the 1D and 2D lattices in Figure 1. What magnetisation would you expect to observe for an Ising lattice with <math>D = 3,\ N=1000</math> at absolute zero?===

[[File:ThirdYearCMPExpt-IsingSketch.png|thumb|left|Figure 1 - Shows 1D (N = 5), 2D (N = 5x5) and 3D (N = 5x5x5) lattices.]]

Magnetisation is defined as <math>M=\sum_{i} s_i</math>. So for the 1D lattice with <math>N = 5</math> in ''Figure 2'', <math>M = +1</math> and for the 2D lattice with <math>N = 25 , M = +1</math> too.

According to the 3rd Law of thermodynamics, entropy is 0 at absolute zero for a perfect crystalline solid, and consequently it is expected that the lattices will have follow suit and have zero entropy at 0K. To have zero entropy all spins must be paired as such that magnetisation, <math>M = 0</math> - which is only possible in the lattices contains an even numbers of lattice sites (N = even). So, for a lattice with <math>N = 1000</math> and <math>D =3</math>, if <math>M = 0</math>, then multiplicity, <math>\Omega = 1</math> and entropy, <math>S =k_B ln(\Omega) = 0</math>.

==Section 2 - Calculating the Energy and Magnetisation==

===TASK: complete the functions energy() and magnetisation(), which should return the energy of the lattice and the total magnetisation, respectively. In the energy() function you may assume that <math>J=1.0</math> at all times (in fact, we are working in reduced units in which <math>J=k_B</math>, but there will be more information about this in later sections). Do not worry about the efficiency of the code at the moment — we will address the speed in a later part of the experiment.===

<pre>def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
lat=self.lattice #creates lattice and stores it
mag=[]
for i in range(0,len(lat)): #loops through all rows of lattice
for j in range(0,len(lat[i])): #loops through elements of each row
mag+=[lat[i][j]] #adds spin value to mag array
return sum(mag) #sums all spins from mag array
</pre>

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

lat=self.lattice #creates lattice and stores it
left=[]
top=[]

for i in range(0,len(lat)):
for j in range(0,len(lat[i])):
left+=[lat[i][j]*lat[i][j-1]] #multiplies spin by spin to left
top+=[lat[i][j]*lat[i-1][j]] #multiplies spin by spin above it
int_en=left+top #sums spin products from left and top
energy=-sum(int_en) #sums all spin products for each spin to give total

return energy
</pre>

===TASK: Run the ILcheck.py script from the IPython Qt console using the command===

''Figure 2'' shows the results when ILcheck.py was ran on my IsingLattice.py file. The ILcheck.py file was ran several times to ensure the code worked for various random lattices.

[[File:Cg1417ILcheck run.png|thumb|left|500px| Figure 2 - Result from running the ILcheck.py file]]

 

==Section 3 - Introduction to Monte Carlo Simulation==

===TASK: How many configurations are available to a system with 100 spins? To evaluate these expressions, we have to calculate the energy and magnetisation for each of these configurations, then perform the sum. Let's be very, very, generous, and say that we can analyse <math>1\times 10^9</math> configurations per second with our computer. How long will it take to evaluate a single value of <math>\left\langle M\right\rangle_T</math>?===

For a system with 100 lattice sites and two possible spins for each site, there are <math>2^{100}</math>possible configurations for the system. <math>2^{100}= 1.27\times 10^{30} </math>, so if the computer can analyse <math>1\times 10^9</math> configurations per second, then it will take <math>\frac{1.27\times 10^{30}}{10^9} = 1.27\times 10^{21} s</math> to analyse the whole system, which is older than the age of the universe and therefore is not a practical approach.

===TASK: Implement a single cycle of the above algorithm in the montecarlocycle(T) function. This function should return the energy of your lattice and the magnetisation at the end of the cycle. You may assume that the energy returned by your energy() function is in units of <math>k_B</math>! Complete the statistics() function. This should return the following quantities whenever it is called: <math><E>, <E^2>, <M>, <M^2></math>, and the number of Monte Carlo steps that have elapsed.===
<pre>
E = []
E2 = []
M = []
M2 = []
n_cycles = 0

def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back if rejected else not changed

self.E+=[self.energy()] #records energy
self.E2+=[self.energy()**2] #records energy squared
self.M+=[self.magnetisation()] #records magnetisation
self.M2+=[self.magnetisation()**2] #records magnetisation squared
self.n_cycles=self.n_cycles+1 #adds 1 to run total

return (self.energy(),self.magnetisation())

def statistics(self):
# complete this function so that it calculates the correct values for the averages of E, E*E (E2), M, M*M (M2), and returns them

e=np.mean(self.E)
e2=np.mean(self.E2)
m=np.mean(self.M)
m2=np.mean(self.M2)

return e,e2,m,m2,self.n_cycles
</pre>

===TASK: If <math>T < T_C</math>, do you expect a spontaneous magnetisation (i.e. do you expect <math>\left\langle M\right\rangle \neq 0</math>)? When the state of the simulation appears to stop changing (when you have reached an equilibrium state), use the controls to export the output to PNG and attach this to your report. You should also include the output from your statistics() function.===

If the temperature of the system is less than the Curie Temperature, <math>T_C</math> then spontaneous magnetisation can occur and the system will tend to its lowest energy state where all of the spins are parallel - this is a property of ferromagnetic materials.

[[File:Cg1417ILanim_run.png|400px|thumb|left|Figure 3 - Results from running the ILanim.py file - shows the energy and magnetisation converging over time]]

''Figure 3'' shows that over time the the system spontaneously converges to the minimum energy state with all of the spins parallel to one another and shows, as I expected, that spontaneous magnetisation occurs and also shows that the temperature of this simulation is below the Curie Temperature, <math>T < T_C</math>.

 

==Section 4 - Accelerating the Code==

===TASK: Use the script ILtimetrial.py to record how long your current version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 5'' show the results of running the ILtimetrial.py file on my code three timesː

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1.png
| width1=500
| image2=cg1417ILtimetrial_run2.png
| width2=500
| image3=cg1417ILtimetrial_run3.png
| width3=500
| footer = Figure 5 - Results of running the ILtimetrial.py file on my code three separate times
}}
 

This gave me an avergage time of <math>24.3 s \pm 0.2s</math>

===TASK: Look at the documentation for the NumPy sum function. You should be able to modify your magnetisation() function so that it uses this to evaluate M. The energy is a little trickier. Familiarise yourself with the NumPy roll and multiply functions, and use these to replace your energy double loop (you will need to call roll and multiply twice!).===

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

left=multiply(roll(self.lattice,1,axis=1),self.lattice) #product of spin with spin left of it
top=multiply(roll(self.lattice,-1,axis=0),self.lattice) #product of spin with spin above it

int_en=sum(left+top) #sum of array containing sum of left and top spin products for each spin

energy = -sum(int_en) #calculates the total energy of system
return energy

def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
return sum(sum(self.lattice)) #adds up all spins in lattice
</pre>

===TASK: Use the script ILtimetrial.py to record how long your new version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 6'' shows the result of running the ILtimetrial.py on my new accelerated code.

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1fast.png
| width1=500
| image2=ILtimetrial_run2fast.png
| width2=500
| image3=ILtimetrial_run3fast.png
| width3=500
| footer = Figure 6 - Results of running the ILtimetrial.py file on my new updated and accelerated code.
}}
 

The accelerated code is much faster upon using the roll, multiply and s with a new average time of <math>0.790 s \pm 0.005 </math>

==Section 5 - The effect of temperature==

===TASK: The script ILfinalframe.py runs for a given number of cycles at a given temperature, then plots a depiction of the final lattice state as well as graphs of the energy and magnetisation as a function of cycle number. This is much quicker than animating every frame! Experiment with different temperature and lattice sizes. How many cycles are typically needed for the system to go from its random starting position to the equilibrium state? Modify your statistics() and montecarlostep() functions so that the first N cycles of the simulation are ignored when calculating the averages. You should state in your report what period you chose to ignore, and include graphs from ILfinalframe.py to illustrate your motivation in choosing this figure.===

''Figure 7'' below shows the results from running the ILfinalframe.py for 2x2 lattice at T=1,2,3,5.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2T1.png
| image2 = cg14172x2T2.png
| image3 =cg14172x2T3.png
| image4 =cg14172x2T5.png
| footer_align = left
| footer = Figure 7 - Results of running the ILfinalframe.py file at T=1,2,3,5 for a 2x2 matrix.
}}

 

For a 2x2 matrix, a suitable cut-off point to exclude from the avergage energies and magnetisations is where the energy and magnetisations per spin are constant, which is 30 steps. For T=3 and T=5 the graphs do not converge because it is possible that these temperatures are higher than the Curie Temperature and as such spontaneous magnetisation will not occur and the system will not diverge to the lowest energy state. At the higher temperatures, there are larger thermal fluctations and the Boltzmann factor is more significant allowing the system to move away from the lowest energy state easier. As a result moving forwards, a suitable cut-off point will only be determined from T=1 and T=2 graphs for the larger matrices.

''Figure 8'' shows the results from running a 4x4 lattice at T=1,2 and 3.

{{multiple image
| width =350
| align = left
| image1 = cg14174x4T1.png
| image2 = cg14174x4T2.png
| image3 =cg14174x4T3.png
| footer_align = left
| footer = Figure 8 - Results of running the ILfinalframe.py file at T=1,2,3 for a 4x4 matrix.
}}

From ''Figure 8'', a suitable cut-off point for the energy and magnetisations is 200 as this is after where the energy and magnetisation has converged for T=1, and is after the initial large drop in energy for T=2, even though there are a few small fluctuations after 200 steps. The result from T=3 has been included to show the large fluctuations for the larger temperatures, and supporting my choice to determine the cut-off from T=1 and T=2 only.

''Figure 9'' shows the results for an 8x8 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg14178x8T1.png
| image2 = cg14178x8T2.png
| footer_align = left
| footer = Figure 9 - Results of running the ILfinalframe.py file at T=1,2 for an 8x8 matrix
}}

From ''Figure 9'' above, a suitable cut-off point is 1000 steps as this is where the energy and magnetisation has easily converged by and is also the point after which the initial large drop in energy has been overcome for T=2 too.

''Figure 10'' shows the result of running the ILfinalframe.py for a 16x16 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg141716x16T1.png
| image2 = cg141716x16T2.png
| footer_align = left
| footer = Figure 10 - Results of running the ILfinalframe.py file at T=1,2 for a 16x16 matrix
}}

From ''Figure 10'', a suitable cut-off point is 15000 steps as for T=1 the energy and magnetisations have converged significantly and will not change much, and likewise this is the same for the T=2 frame.

''Figure 11'' below shows the results from a 32x32 matrix at T=1 and T=2.

{{multiple image
| width =350
| align = left
| image1 = cg141732x32T1.png
| image2 = cg141732x32T2.png
| footer_align = left
| footer = Figure 11 - Results of running the ILfinalframe.py file at T=1,2 for a 32x32 matrix
}}

''Figure 11'' above shows the results of running the ILfinalframe.py file for a 32x32 matrix at T=1 and T=2. As a result a suitable cut-off of 50000 steps was chosen as the energy and magnetisation has significantly converged, but not as much as it could at 100000 steps. I chose a slightly lower value to ensure that the run times of my monte-carlo simulations in future tasks were not extremely time consuming.

The montecarlostep() function was changed by adding a condition that values only above the pre-determined cut-off were included when determining the average value of energy; energy squared; magnetisation and magnetisations squared from the statistics function. The statistics() function did not need to be modified.

The following code is from the 32x32 matrixː

<pre>def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back

if self.n_cycles > 50000: #only adds values to array of E,E2,M and M2 is above specific cut-off
self.E+=[self.energy()]
self.E2+=[self.energy()**2]
self.M+=[self.magnetisation()]
self.M2+=[self.magnetisation()**2]
self.n_cycles=self.n_cycles+1

return (self.energy(),self.magnetisation())
</pre>

===TASK: Use ILtemperaturerange.py to plot the average energy and magnetisation for each temperature, with error bars, for an <math>8\times 8</math> lattice. Use your intuition and results from the script ILfinalframe.py to estimate how many cycles each simulation should be. The temperature range 0.25 to 5.0 is sufficient. Use as many temperature points as you feel necessary to illustrate the trend, but do not use a temperature spacing larger than 0.5. The NumPy function savetxt() stores your array of output data on disk — you will need it later. Save the file as 8x8.dat so that you know which lattice size it came from.===

Using the modified code, the file ILtemperaturerange.py was ran on an 8x8 matrix between T=0.5 and T=5 with a step of T=0.02 for 10000 Montecarlo steps and the first 1000 steps of each temperature were excluded when calculating the averages. Figure 12 shows the result of the simulation and also included error bars of standard deviation.

[[File:Cg14178x8error.png|1000px|thumb|left|Figure 12 - Graph showing average energy and average magnetisation for an 8x8 lattice with error bars between T=0.5 and T=5]]

 

==Section 6 - The effect of system size==

===TASK: Repeat the final task of the previous section for the following lattice sizes: 2x2, 4x4, 8x8, 16x16, 32x32. Make sure that you name each datafile that your produce after the corresponding lattice size! Write a Python script to make a plot showing the energy per spin versus temperature for each of your lattice sizes. Hint: the NumPy loadtxt function is the reverse of the savetxt function, and can be used to read your previously saved files into the script. Repeat this for the magnetisation. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. How big a lattice do you think is big enough to capture the long range fluctuations?===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb.

Each matrix was simulated using the ILtemperaturerange.py file between T=0.5 and T=5 with a step of T=0.02.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2error.png
| caption1 = 2x2 matrix - 5000 steps, cut-off = 30 steps
| image2 = 4x4error.png
| caption2 = 4x4 matrix - 1000 steps, cut-off = 200 steps
| image3 =cg141716x16error.png
| caption3 = 16x16 matrix - 50000 steps, cut-off = 15000 steps
| image4 =cg141732x32error.png
| caption4 = 32x32 matrix - 200000 steps, cut-off = 50000 steps
| footer_align = left
| footer = Figure 13 - Results of running the ILtemperaturerange.py file for 2x2, 4x4, 16x16 and 32x32 matrices.
}}

 

==Section 7 - Determining the Heat Capacity==

===TASK: By definition, <math>C = \frac{\partial \left\langle E\right\rangle}{\partial T}</math>. From this, show that <math>C = \frac{\mathrm{Var}[E]}{k_B T^2}</math> (Where <math>\mathrm{Var}[E]</math> is the variance in <math>E</math>.)===

Recall from statistical thermodynamics that the average energy of a system is the sum across all microstates of the probability of that microstate multiplied by the energy of that microstate, which is defined mathematically asː <math>\langle E \rangle = \sum_i p_{i}\epsilon_{i}</math>.

The partition function <math>q</math> is defined as <math>q = \sum_{i} exp(-\beta \epsilon_{i})</math> where <math>\beta =\frac{1}{k_BT}</math>and the probability, <math>p_{i}</math> can be defined in terms of the partition function as <math>p_{i} = \frac{exp(-\beta \epsilon_{i})}{\sum_{i} exp(-\beta \epsilon_{i})} = \frac{exp(-\beta \epsilon_{i})}{q}</math>.

As a result, <math>\langle E \rangle</math> can be re-written as <math>\langle E \rangle = \sum_{i} \frac{\epsilon_{i} exp(-\beta \epsilon_{i})}{q} = -\frac{1}{q} \frac{\partial}{\partial \beta}\sum_{i}exp(-\beta \epsilon_{i}) = -\frac{1}{q} \frac{\partial q}{\partial \beta}</math>

Likewise, <math>\langle E^2 \rangle = \sum_i p_{i}\epsilon_{i}^{2} = \sum_{i} \frac{\epsilon_{i}^{2}exp(-\beta \epsilon_{i})}{q} = \frac{1}{q} \frac{\partial^{2}}{\partial \beta^{2}}\sum_{i}exp(-\beta \epsilon_{i}) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}}</math>

From definitionː <math>Var[E] = \Delta E^2 = \langle E^2 \rangle - \langle E \rangle^2 </math>

When the definition of <math>\langle E \rangle</math> and <math>\langle E^2 \rangle</math> is written in terms of partition function <math>q</math>ː <math>Var[E] = \langle E^2 \rangle - \langle E \rangle^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \left(\frac{1}{q}\frac{\partial q}{\partial \beta}\right)^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2</math>.

According to the chain ruleː <math>\frac{\partial}{\partial \beta}\left(\frac{1}{q} \frac{\partial q}{\partial \beta}\right) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2 = -\frac{\partial}{\partial \beta}\langle E \rangle = Var[E]</math>

And using the chain rule againː <math>C = \frac{\partial \langle E \rangle}{\partial T}= \left(-\frac{\partial \langle E \rangle}{\partial \beta}\right) \left(-\frac{\partial \beta}{\partial T}\right) = \frac{Var[E]}{k_B T^2}</math>

===TASK: Write a Python script to make a plot showing the heat capacity versus temperature for each of your lattice sizes from the previous section. You may need to do some research to recall the connection between the variance of a variable, <math>\mathrm{Var}[X]</math>, the mean of its square <math>\left\langle X^2\right\rangle</math>, and its squared mean <math>\left\langle X\right\rangle^2</math>. You may find that the data around the peak is very noisy — this is normal, and is a result of being in the critical region. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. ===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb

{{multiple image
| width =300
| align = left
| image1 = cg14172x2heatcap.png
| caption1 = 2x2 Matrix
| image2 = cg14174x4heatcap.png
| caption2 = 4x4 Matrix
| image3 =cg14178x8heatcap.png
| caption3 = 8x8 Matrix
| image4 =cg141716x16heatcap.png
| caption4 = 16x16 Matrix
| image5=cg141732x32heatcap.png
| caption5= 32x32 Matrix
| footer = Figure 14 - Graphs showing Heat Capacity against Temperature for each matrix size
}}

A general trend from the above graphs is that the peak of the graph shifts towards lower temperatures as the size of the matrix used increases.

==Section 8 - Locating the Curie Temperature==
===TASK: A C++ program has been used to run some much longer simulations than would be possible on the college computers in Python. You can view its source code here if you are interested. Each file contains six columns: <math>T, E, E^2, M, M^2, C</math> (the final five quantities are per spin), and you can read them with the NumPy loadtxt function as before. For each lattice size, plot the C++ data against your data. For one lattice size, save a PNG of this comparison and add it to your report — add a legend to the graph to label which is which. To do this, you will need to pass the label="..." keyword to the plot function, then call the legend() function of the axis object (documentation here).===

The python code used to read and plot the C++ data is found in the Jupyter notebook CG1417IsingModelGraphs.ipynb.

''Figure 15'' below shows the C++ plotted against my own data for a 16x16 Matrix.

[[File:Cg141716x16C++.png|400px|thumb|left|Figure 15 - Graph showing my own data against the C++ data for a 16x16 matrix.]]

 

===TASK: write a script to read the data from a particular file, and plot C vs T, as well as a fitted polynomial. Try changing the degree of the polynomial to improve the fit — in general, it might be difficult to get a good fit! Attach a PNG of an example fit to your report.===

The python script to read and plot the fitted polynomial is found in CG1417PolyfitScript.ipynb

Below in ''Figure 16'' is a plot of my Heat Capacity against Temperature data for a 16x16 matrix and features a polynomial of degree 35 plotted against it. Even with a polynomial of such a high degree, it poorly fits the curve and does not fit to the peak of the curve either.

[[File:cg1417FIT_TEST16x16_35.png|thumb|left|400px|Figure 16 - Plot of Heat Capacity against Temperature along with a poorly fitted polynomial of degree 35. ]]

 

===TASK: Modify your script from the previous section. You should still plot the whole temperature range, but fit the polynomial only to the peak of the heat capacity! You should find it easier to get a good fit when restricted to this region===

The script was modified as such that the polynomial was fitted in a set range around the peak of the graph, this is demonstrated in ''Figure 17'' which shows a newly fitted polynomial between a much smaller range of temperatures (T = 2.15-2.55) and a much smaller degree polynomial (3).

[[File:CG1417FIT_16x16C_3.png|thumb|left|400px|Figure 17 - Graph showing Heat Capacity against Temperature for a 16x16 matrix along with a fitted polynomial between a much more restricted range of temperatures and a significantly lower degree of polynomial]]

Upon comparison with ''Figure 16'', the new fitted polynomial is a significantly better fit even for a 3rd degree polynomial and is a much more accurate representation of my data around the peak of the graph and will make it easier to determine the maximum value of Heat Capacity.

 

===TASK: find the temperature at which the maximum in C occurs for each datafile that you were given. Make a text file containing two colums: the lattice side length (2,4,8, etc.), and the temperature at which C is a maximum. This is your estimate of <math>T_C</math> for that side length. Make a plot that uses the scaling relation given above to determine <math>T_{C,\infty}</math>. By doing a little research online, you should be able to find the theoretical exact Curie temperature for the infinite 2D Ising lattice. How does your value compare to this? Are you surprised by how good/bad the agreement is? Attach a PNG of this final graph to your report, and discuss briefly what you think the major sources of error are in your estimate.===

Figure 17 below shows a graph of <math>T_{C,L}</math> against <math>\frac{1}{Lattice Size}</math> to determine the Curie Temperature of an infinite 2D Ising Model Lattice <math>T_{C,\infty}</math>. The black dots represent the raw data obtained from obtaining the temperature at which the Heat Capacity was a maximum for the lattices and the red line in a linear curve fit plotted against the data to allow the y-intercept which is the Curie Temperature for the infinite 2D lattice to be determined.

[[File:cg1417CurieTemp.png|400px|thumb|left|Figure 17 - Plot of 1/Lattice Size against Curie Temperature for that lattice size.]]

The value for <math>T_{C,\inf}</math> obtained from the data is <math>T_{C,\infty} = 2.277 \frac{J}{k_B}</math> with a literature value being <math>T_{C,\infty} = 2.269 \frac{J}{k_B}</math> for an infinite square 2D lattice. This means that my result slightly over-estimates the Curie Temperature for the infinite lattice and as a result for an infinite lattice the temperature at which spontaneous magnetisation stops would actually occur at a slightly lower temperature than expected. However, the difference between my value and the literature value is only 0.008 which is incredibly small and the amount of agreement between the two values is somewhat surprising, which means that the error in my estimates of the Curie Temperature for each lattice size is relatively small. A potential source of error from the values of the Curie Temperature for each lattice size could come from the

Rep:Y3CMPCG1417

2019-11-20T07:51:29Z

Cg1417: /* TASK: Run the ILcheck.py script from the IPython Qt console using the command */

==Section 1 - Introduction to the Ising Model==

===TASK: Show that the lowest possible energy for the Ising model is <math>E = -DNJ</math>, where D is the number of dimensions and N is the total number of spins. What is the multiplicity of this state? Calculate its entropy.===

Consider a 1D row of lattice sites of N=3 with spin configuration [+1][+1][+1].

Mathematically the interaction energy is defined asː
<math> -\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} </math> where J is a constant and <math>s_{i}s_{j}</math> is the product between two spins in adjacent lattice sites.

The sum of the interaction energies <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j}</math> can be considered as the sum of the individual interaction energies between spinsː
<math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = \epsilon_{12} + \epsilon_{23} + \epsilon_{13} + \epsilon_{21} + \epsilon_{32} + \epsilon_{31} </math>.

Although lattice sites 1 and 3 are not adjacent they are said to still interact according to the periodic boundary conditions applied.

However, <math>\epsilon_{12} = \epsilon_{21} </math> and <math>\epsilon_{23} = \epsilon_{32}</math> and <math>\epsilon_{13} = \epsilon_{31}</math> which means that all of the interactions within the system are counted twice, hence the total energy needs to be halved, resulting in the following formula being obtainedː <math> \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = 2\epsilon_{12} + 2\epsilon_{13} + 2\epsilon_{23} </math>.

It can be determined that <math>\epsilon_{12} = (+1)(+1) = 1</math> , <math>\epsilon_{13} = (+1)(+1) = 1</math> and <math>\epsilon_{23} = (+1)(+1) = 1</math>.

Thereforeː <math>-\frac{1}{2} \ J \ \sum^{N}_{i} \sum^{}_{j \ \epsilon \ neighbours (i)} s_{i} s_{j} = -\frac{1}{2} \ J \ (2 + 2 + 2) = -\frac{1}{2} \ J \ 6 = - 3 J = -DNJ</math> for a 1D lattice with <math>D=1</math> and 3 lattice sites <math>N=3</math>

The multiplicity of the system,<math>\Omega = 2S+1</math> where <math>S</math> is the total magnetisation of the system.

In this case, <math>\Omega = 2(3)+1 = 7</math>

Entropy, <math>S</math> is defined as <math>S = k_B ln(\Omega)</math> and so in this case <math>S = k_B ln7 = 1.95 k_B</math>

===TASK: Imagine that the system is in the lowest energy configuration. To move to a different state, one of the spins must spontaneously change direction ("flip"). What is the change in energy if this happens <math>(D=3, N=1000)</math>? How much entropy does the system gain by doing soʔ===

In a 3D lattice system, each lattice site has three unique interactions with its neighbours to its left, top and front. In the lowest energy configuration, all spins are parallel and for a system the minimum energy is <math>E = -DNJ</math>, so for the system with <math>N=1000</math> and <math>D=3</math>, the minimum energy is <math>-3000J</math>.

If a single spin is flipped, the product of its spin with its neighbours spin reverses and becomes negative and this increases the total energy of the system. Since 3 unique spin-spin interactions are reversed in sign, the total energy increases by <math>+3J</math>, meaning the new total energy is <math>-2997J</math>

Initially the multiplicity of the system will be <math>\Omega = 2(1000)+1=2001</math> , and after the flip, the multiplicity becomes <math>\Omega = 2(1000-1)+1=1999</math>.

The associated change in entropy, <math>\Delta S = k_B ln(1999) - k_B ln(2001)= k_B ln(\frac{1999}{2001}) = -0.001 k_B</math>, which is a very small decrease in entropy as the system starts

===TASK: Calculate the magnetisation of the 1D and 2D lattices in Figure 1. What magnetisation would you expect to observe for an Ising lattice with <math>D = 3,\ N=1000</math> at absolute zero?===

[[File:ThirdYearCMPExpt-IsingSketch.png|thumb|left|Figure 1 - Shows 1D (N = 5), 2D (N = 5x5) and 3D (N = 5x5x5) lattices.]]

Magnetisation is defined as <math>M=\sum_{i} s_i</math>. So for the 1D lattice with <math>N = 5</math> in ''Figure 2'', <math>M = +1</math> and for the 2D lattice with <math>N = 25 , M = +1</math> too.

According to the 3rd Law of thermodynamics, entropy is 0 at absolute zero for a perfect crystalline solid, and consequently it is expected that the lattices will have follow suit and have zero entropy at 0K. To have zero entropy all spins must be paired as such that magnetisation, <math>M = 0</math> - which is only possible in the lattices contains an even numbers of lattice sites (N = even). So, for a lattice with <math>N = 1000</math> and <math>D =3</math>, if <math>M = 0</math>, then multiplicity, <math>\Omega = 1</math> and entropy, <math>S =k_B ln(\Omega) = 0</math>.

==Section 2 - Calculating the Energy and Magnetisation==

===TASK: complete the functions energy() and magnetisation(), which should return the energy of the lattice and the total magnetisation, respectively. In the energy() function you may assume that <math>J=1.0</math> at all times (in fact, we are working in reduced units in which <math>J=k_B</math>, but there will be more information about this in later sections). Do not worry about the efficiency of the code at the moment — we will address the speed in a later part of the experiment.===

<pre>def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
lat=self.lattice #creates lattice and stores it
mag=[]
for i in range(0,len(lat)): #loops through all rows of lattice
for j in range(0,len(lat[i])): #loops through elements of each row
mag+=[lat[i][j]] #adds spin value to mag array
return sum(mag) #sums all spins from mag array
</pre>

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

lat=self.lattice #creates lattice and stores it
left=[]
top=[]

for i in range(0,len(lat)):
for j in range(0,len(lat[i])):
left+=[lat[i][j]*lat[i][j-1]] #multiplies spin by spin to left
top+=[lat[i][j]*lat[i-1][j]] #multiplies spin by spin above it
int_en=left+top #sums spin products from left and top
energy=-sum(int_en) #sums all spin products for each spin to give total

return energy
</pre>

===TASK: Run the ILcheck.py script from the IPython Qt console using the command===

''Figure 2'' shows the results when ILcheck.py was ran on my IsingLattice.py file. The ILcheck.py file was ran several times to ensure the code worked for various random lattices.

[[File:Cg1417ILcheck run.png|thumb|left|500px| Figure 2 - Result from running the ILcheck.py file]]

 

==Section 3 - Introduction to Monte Carlo Simulation==

===TASK: How many configurations are available to a system with 100 spins? To evaluate these expressions, we have to calculate the energy and magnetisation for each of these configurations, then perform the sum. Let's be very, very, generous, and say that we can analyse <math>1\times 10^9</math> configurations per second with our computer. How long will it take to evaluate a single value of <math>\left\langle M\right\rangle_T</math>?===

For a system with 100 lattice sites and two possible spins for each site, there are <math>2^{100}</math>possible configurations for the system. <math>2^{100}= 1.27\times 10^{30} </math>, so if the computer can analyse <math>1\times 10^9</math> configurations per second, then it will take <math>\frac{1.27\times 10^{30}}{10^9} = 1.27\times 10^{21} s</math> to analyse the whole system, which is older than the age of the universe and therefore is not a practical approach.

===TASK: Implement a single cycle of the above algorithm in the montecarlocycle(T) function. This function should return the energy of your lattice and the magnetisation at the end of the cycle. You may assume that the energy returned by your energy() function is in units of <math>k_B</math>! Complete the statistics() function. This should return the following quantities whenever it is called: <math><E>, <E^2>, <M>, <M^2></math>, and the number of Monte Carlo steps that have elapsed.===
<pre>
E = []
E2 = []
M = []
M2 = []
n_cycles = 0

def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back if rejected else not changed

self.E+=[self.energy()] #records energy
self.E2+=[self.energy()**2] #records energy squared
self.M+=[self.magnetisation()] #records magnetisation
self.M2+=[self.magnetisation()**2] #records magnetisation squared
self.n_cycles=self.n_cycles+1 #adds 1 to run total

return (self.energy(),self.magnetisation())

def statistics(self):
# complete this function so that it calculates the correct values for the averages of E, E*E (E2), M, M*M (M2), and returns them

e=np.mean(self.E)
e2=np.mean(self.E2)
m=np.mean(self.M)
m2=np.mean(self.M2)

return e,e2,m,m2,self.n_cycles
</pre>

===TASK: If <math>T < T_C</math>, do you expect a spontaneous magnetisation (i.e. do you expect <math>\left\langle M\right\rangle \neq 0</math>)? When the state of the simulation appears to stop changing (when you have reached an equilibrium state), use the controls to export the output to PNG and attach this to your report. You should also include the output from your statistics() function.===

If the temperature of the system is less than the Curie Temperature, <math>T_C</math> then spontaneous magnetisation can occur and the system will tend to its lowest energy state where all of the spins are parallel - this is a property of ferromagnetic materials.

[[File:Cg1417ILanim_run.png|400px|thumb|left|Figure 4 - Results from running the ILanim.py file - shows the energy and magnetisation converging over time]]

''Figure 4'' shows that over time the the system spontaneously converges to the minimum energy state with all of the spins parallel to one another and shows, as I expected, that spontaneous magnetisation occurs and also shows that the temperature of this simulation is below the Curie Temperature, <math>T < T_C</math>.

 

==Section 4 - Accelerating the Code==

===TASK: Use the script ILtimetrial.py to record how long your current version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 5'' show the results of running the ILtimetrial.py file on my code three timesː

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1.png
| width1=500
| image2=cg1417ILtimetrial_run2.png
| width2=500
| image3=cg1417ILtimetrial_run3.png
| width3=500
| footer = Figure 5 - Results of running the ILtimetrial.py file on my code three separate times
}}
 

This gave me an avergage time of <math>24.3 s \pm 0.2s</math>

===TASK: Look at the documentation for the NumPy sum function. You should be able to modify your magnetisation() function so that it uses this to evaluate M. The energy is a little trickier. Familiarise yourself with the NumPy roll and multiply functions, and use these to replace your energy double loop (you will need to call roll and multiply twice!).===

<pre> def energy(self):
"Return the total energy of the current lattice configuration."

left=multiply(roll(self.lattice,1,axis=1),self.lattice) #product of spin with spin left of it
top=multiply(roll(self.lattice,-1,axis=0),self.lattice) #product of spin with spin above it

int_en=sum(left+top) #sum of array containing sum of left and top spin products for each spin

energy = -sum(int_en) #calculates the total energy of system
return energy

def magnetisation(self):
"Return the total magnetisation of the current lattice configuration."
return sum(sum(self.lattice)) #adds up all spins in lattice
</pre>

===TASK: Use the script ILtimetrial.py to record how long your new version of IsingLattice.py takes to perform 2000 Monte Carlo steps. This will vary, depending on what else the computer happens to be doing, so perform repeats and report the error in your average!===

''Figure 6'' shows the result of running the ILtimetrial.py on my new accelerated code.

{{multiple image
| align = left

| image1=cg1417ILtimetrial_run1fast.png
| width1=500
| image2=ILtimetrial_run2fast.png
| width2=500
| image3=ILtimetrial_run3fast.png
| width3=500
| footer = Figure 6 - Results of running the ILtimetrial.py file on my new updated and accelerated code.
}}
 

The accelerated code is much faster upon using the roll, multiply and s with a new average time of <math>0.790 s \pm 0.005 </math>

==Section 5 - The effect of temperature==

===TASK: The script ILfinalframe.py runs for a given number of cycles at a given temperature, then plots a depiction of the final lattice state as well as graphs of the energy and magnetisation as a function of cycle number. This is much quicker than animating every frame! Experiment with different temperature and lattice sizes. How many cycles are typically needed for the system to go from its random starting position to the equilibrium state? Modify your statistics() and montecarlostep() functions so that the first N cycles of the simulation are ignored when calculating the averages. You should state in your report what period you chose to ignore, and include graphs from ILfinalframe.py to illustrate your motivation in choosing this figure.===

''Figure 7'' below shows the results from running the ILfinalframe.py for 2x2 lattice at T=1,2,3,5.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2T1.png
| image2 = cg14172x2T2.png
| image3 =cg14172x2T3.png
| image4 =cg14172x2T5.png
| footer_align = left
| footer = Figure 7 - Results of running the ILfinalframe.py file at T=1,2,3,5 for a 2x2 matrix.
}}

 

For a 2x2 matrix, a suitable cut-off point to exclude from the avergage energies and magnetisations is where the energy and magnetisations per spin are constant, which is 30 steps. For T=3 and T=5 the graphs do not converge because it is possible that these temperatures are higher than the Curie Temperature and as such spontaneous magnetisation will not occur and the system will not diverge to the lowest energy state. At the higher temperatures, there are larger thermal fluctations and the Boltzmann factor is more significant allowing the system to move away from the lowest energy state easier. As a result moving forwards, a suitable cut-off point will only be determined from T=1 and T=2 graphs for the larger matrices.

''Figure 8'' shows the results from running a 4x4 lattice at T=1,2 and 3.

{{multiple image
| width =350
| align = left
| image1 = cg14174x4T1.png
| image2 = cg14174x4T2.png
| image3 =cg14174x4T3.png
| footer_align = left
| footer = Figure 8 - Results of running the ILfinalframe.py file at T=1,2,3 for a 4x4 matrix.
}}

From ''Figure 8'', a suitable cut-off point for the energy and magnetisations is 200 as this is after where the energy and magnetisation has converged for T=1, and is after the initial large drop in energy for T=2, even though there are a few small fluctuations after 200 steps. The result from T=3 has been included to show the large fluctuations for the larger temperatures, and supporting my choice to determine the cut-off from T=1 and T=2 only.

''Figure 9'' shows the results for an 8x8 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg14178x8T1.png
| image2 = cg14178x8T2.png
| footer_align = left
| footer = Figure 9 - Results of running the ILfinalframe.py file at T=1,2 for an 8x8 matrix
}}

From ''Figure 9'' above, a suitable cut-off point is 1000 steps as this is where the energy and magnetisation has easily converged by and is also the point after which the initial large drop in energy has been overcome for T=2 too.

''Figure 10'' shows the result of running the ILfinalframe.py for a 16x16 matrix.

{{multiple image
| width =350
| align = left
| image1 = cg141716x16T1.png
| image2 = cg141716x16T2.png
| footer_align = left
| footer = Figure 10 - Results of running the ILfinalframe.py file at T=1,2 for a 16x16 matrix
}}

From ''Figure 10'', a suitable cut-off point is 15000 steps as for T=1 the energy and magnetisations have converged significantly and will not change much, and likewise this is the same for the T=2 frame.

''Figure 11'' below shows the results from a 32x32 matrix at T=1 and T=2.

{{multiple image
| width =350
| align = left
| image1 = cg141732x32T1.png
| image2 = cg141732x32T2.png
| footer_align = left
| footer = Figure 11 - Results of running the ILfinalframe.py file at T=1,2 for a 32x32 matrix
}}

''Figure 11'' above shows the results of running the ILfinalframe.py file for a 32x32 matrix at T=1 and T=2. As a result a suitable cut-off of 50000 steps was chosen as the energy and magnetisation has significantly converged, but not as much as it could at 100000 steps. I chose a slightly lower value to ensure that the run times of my monte-carlo simulations in future tasks were not extremely time consuming.

The montecarlostep() function was changed by adding a condition that values only above the pre-determined cut-off were included when determining the average value of energy; energy squared; magnetisation and magnetisations squared from the statistics function. The statistics() function did not need to be modified.

The following code is from the 32x32 matrixː

<pre>def montecarlostep(self, T):
# complete this function so that it performs a single Monte Carlo step

energy = self.energy() #defines initial energy

#the following two lines will select the coordinates of the random spin for you
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
#the following line will choose a random number in the range[0,1) for you
random_number = np.random.random()

self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #flips spin and changes lattice
energy2=self.energy() #energy of new flipped lattice
deltaE=energy2-energy #calculates change in energy

#at this point the system has the new spin config and new energy

if deltaE > 0 and random_number > e**(-deltaE/T):
self.lattice[random_i][random_j]=(self.lattice[random_i][random_j])*(-1) #reverts spin back

if self.n_cycles > 50000: #only adds values to array of E,E2,M and M2 is above specific cut-off
self.E+=[self.energy()]
self.E2+=[self.energy()**2]
self.M+=[self.magnetisation()]
self.M2+=[self.magnetisation()**2]
self.n_cycles=self.n_cycles+1

return (self.energy(),self.magnetisation())
</pre>

===TASK: Use ILtemperaturerange.py to plot the average energy and magnetisation for each temperature, with error bars, for an <math>8\times 8</math> lattice. Use your intuition and results from the script ILfinalframe.py to estimate how many cycles each simulation should be. The temperature range 0.25 to 5.0 is sufficient. Use as many temperature points as you feel necessary to illustrate the trend, but do not use a temperature spacing larger than 0.5. The NumPy function savetxt() stores your array of output data on disk — you will need it later. Save the file as 8x8.dat so that you know which lattice size it came from.===

Using the modified code, the file ILtemperaturerange.py was ran on an 8x8 matrix between T=0.5 and T=5 with a step of T=0.02 for 10000 Montecarlo steps and the first 1000 steps of each temperature were excluded when calculating the averages. Figure 12 shows the result of the simulation and also included error bars of standard deviation.

[[File:Cg14178x8error.png|1000px|thumb|left|Figure 12 - Graph showing average energy and average magnetisation for an 8x8 lattice with error bars between T=0.5 and T=5]]

 

==Section 6 - The effect of system size==

===TASK: Repeat the final task of the previous section for the following lattice sizes: 2x2, 4x4, 8x8, 16x16, 32x32. Make sure that you name each datafile that your produce after the corresponding lattice size! Write a Python script to make a plot showing the energy per spin versus temperature for each of your lattice sizes. Hint: the NumPy loadtxt function is the reverse of the savetxt function, and can be used to read your previously saved files into the script. Repeat this for the magnetisation. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. How big a lattice do you think is big enough to capture the long range fluctuations?===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb.

Each matrix was simulated using the ILtemperaturerange.py file between T=0.5 and T=5 with a step of T=0.02.

{{multiple image
| width =350
| align = left
| image1 = cg14172x2error.png
| caption1 = 2x2 matrix - 5000 steps, cut-off = 30 steps
| image2 = 4x4error.png
| caption2 = 4x4 matrix - 1000 steps, cut-off = 200 steps
| image3 =cg141716x16error.png
| caption3 = 16x16 matrix - 50000 steps, cut-off = 15000 steps
| image4 =cg141732x32error.png
| caption4 = 32x32 matrix - 200000 steps, cut-off = 50000 steps
| footer_align = left
| footer = Figure 13 - Results of running the ILtemperaturerange.py file for 2x2, 4x4, 16x16 and 32x32 matrices.
}}

 

==Section 7 - Determining the Heat Capacity==

===TASK: By definition, <math>C = \frac{\partial \left\langle E\right\rangle}{\partial T}</math>. From this, show that <math>C = \frac{\mathrm{Var}[E]}{k_B T^2}</math> (Where <math>\mathrm{Var}[E]</math> is the variance in <math>E</math>.)===

Recall from statistical thermodynamics that the average energy of a system is the sum across all microstates of the probability of that microstate multiplied by the energy of that microstate, which is defined mathematically asː <math>\langle E \rangle = \sum_i p_{i}\epsilon_{i}</math>.

The partition function <math>q</math> is defined as <math>q = \sum_{i} exp(-\beta \epsilon_{i})</math> where <math>\beta =\frac{1}{k_BT}</math>and the probability, <math>p_{i}</math> can be defined in terms of the partition function as <math>p_{i} = \frac{exp(-\beta \epsilon_{i})}{\sum_{i} exp(-\beta \epsilon_{i})} = \frac{exp(-\beta \epsilon_{i})}{q}</math>.

As a result, <math>\langle E \rangle</math> can be re-written as <math>\langle E \rangle = \sum_{i} \frac{\epsilon_{i} exp(-\beta \epsilon_{i})}{q} = -\frac{1}{q} \frac{\partial}{\partial \beta}\sum_{i}exp(-\beta \epsilon_{i}) = -\frac{1}{q} \frac{\partial q}{\partial \beta}</math>

Likewise, <math>\langle E^2 \rangle = \sum_i p_{i}\epsilon_{i}^{2} = \sum_{i} \frac{\epsilon_{i}^{2}exp(-\beta \epsilon_{i})}{q} = \frac{1}{q} \frac{\partial^{2}}{\partial \beta^{2}}\sum_{i}exp(-\beta \epsilon_{i}) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}}</math>

From definitionː <math>Var[E] = \Delta E^2 = \langle E^2 \rangle - \langle E \rangle^2 </math>

When the definition of <math>\langle E \rangle</math> and <math>\langle E^2 \rangle</math> is written in terms of partition function <math>q</math>ː <math>Var[E] = \langle E^2 \rangle - \langle E \rangle^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \left(\frac{1}{q}\frac{\partial q}{\partial \beta}\right)^2 = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2</math>.

According to the chain ruleː <math>\frac{\partial}{\partial \beta}\left(\frac{1}{q} \frac{\partial q}{\partial \beta}\right) = \frac{1}{q} \frac{\partial^{2} q}{\partial \beta^{2}} - \frac{1}{q^2}\left(\frac{\partial q}{\partial \beta}\right)^2 = -\frac{\partial}{\partial \beta}\langle E \rangle = Var[E]</math>

And using the chain rule againː <math>C = \frac{\partial \langle E \rangle}{\partial T}= \left(-\frac{\partial \langle E \rangle}{\partial \beta}\right) \left(-\frac{\partial \beta}{\partial T}\right) = \frac{Var[E]}{k_B T^2}</math>

===TASK: Write a Python script to make a plot showing the heat capacity versus temperature for each of your lattice sizes from the previous section. You may need to do some research to recall the connection between the variance of a variable, <math>\mathrm{Var}[X]</math>, the mean of its square <math>\left\langle X^2\right\rangle</math>, and its squared mean <math>\left\langle X\right\rangle^2</math>. You may find that the data around the peak is very noisy — this is normal, and is a result of being in the critical region. As before, use the plot controls to save your a PNG image of your plot and attach this to the report. ===

The python script for this section can be found in the Jupyter Notebook - CG1417IsingModelGraphs.ipynb

{{multiple image
| width =300
| align = left
| image1 = cg14172x2heatcap.png
| caption1 = 2x2 Matrix
| image2 = cg14174x4heatcap.png
| caption2 = 4x4 Matrix
| image3 =cg14178x8heatcap.png
| caption3 = 8x8 Matrix
| image4 =cg141716x16heatcap.png
| caption4 = 16x16 Matrix
| image5=cg141732x32heatcap.png
| caption5= 32x32 Matrix
| footer = Figure 14 - Graphs showing Heat Capacity against Temperature for each matrix size
}}

A general trend from the above graphs is that the peak of the graph shifts towards lower temperatures as the size of the matrix used increases.

==Section 8 - Locating the Curie Temperature==
===TASK: A C++ program has been used to run some much longer simulations than would be possible on the college computers in Python. You can view its source code here if you are interested. Each file contains six columns: <math>T, E, E^2, M, M^2, C</math> (the final five quantities are per spin), and you can read them with the NumPy loadtxt function as before. For each lattice size, plot the C++ data against your data. For one lattice size, save a PNG of this comparison and add it to your report — add a legend to the graph to label which is which. To do this, you will need to pass the label="..." keyword to the plot function, then call the legend() function of the axis object (documentation here).===

The python code used to read and plot the C++ data is found in the Jupyter notebook CG1417IsingModelGraphs.ipynb.

''Figure 15'' below shows the C++ plotted against my own data for a 16x16 Matrix.

[[File:Cg141716x16C++.png|400px|thumb|left|Figure 15 - Graph showing my own data against the C++ data for a 16x16 matrix.]]

 

===TASK: write a script to read the data from a particular file, and plot C vs T, as well as a fitted polynomial. Try changing the degree of the polynomial to improve the fit — in general, it might be difficult to get a good fit! Attach a PNG of an example fit to your report.===

The python script to read and plot the fitted polynomial is found in CG1417PolyfitScript.ipynb

Below in ''Figure 16'' is a plot of my Heat Capacity against Temperature data for a 16x16 matrix and features a polynomial of degree 35 plotted against it. Even with a polynomial of such a high degree, it poorly fits the curve and does not fit to the peak of the curve either.

[[File:cg1417FIT_TEST16x16_35.png|thumb|left|400px|Figure 16 - Plot of Heat Capacity against Temperature along with a poorly fitted polynomial of degree 35. ]]

 

===TASK: Modify your script from the previous section. You should still plot the whole temperature range, but fit the polynomial only to the peak of the heat capacity! You should find it easier to get a good fit when restricted to this region===

The script was modified as such that the polynomial was fitted in a set range around the peak of the graph, this is demonstrated in ''Figure 17'' which shows a newly fitted polynomial between a much smaller range of temperatures (T = 2.15-2.55) and a much smaller degree polynomial (3).

[[File:CG1417FIT_16x16C_3.png|thumb|left|400px|Figure 17 - Graph showing Heat Capacity against Temperature for a 16x16 matrix along with a fitted polynomial between a much more restricted range of temperatures and a significantly lower degree of polynomial]]

Upon comparison with ''Figure 16'', the new fitted polynomial is a significantly better fit even for a 3rd degree polynomial and is a much more accurate representation of my data around the peak of the graph and will make it easier to determine the maximum value of Heat Capacity.

 

===TASK: find the temperature at which the maximum in C occurs for each datafile that you were given. Make a text file containing two colums: the lattice side length (2,4,8, etc.), and the temperature at which C is a maximum. This is your estimate of <math>T_C</math> for that side length. Make a plot that uses the scaling relation given above to determine <math>T_{C,\infty}</math>. By doing a little research online, you should be able to find the theoretical exact Curie temperature for the infinite 2D Ising lattice. How does your value compare to this? Are you surprised by how good/bad the agreement is? Attach a PNG of this final graph to your report, and discuss briefly what you think the major sources of error are in your estimate.===

Figure 17 below shows a graph of <math>T_{C,L}</math> against <math>\frac{1}{Lattice Size}</math> to determine the Curie Temperature of an infinite 2D Ising Model Lattice <math>T_{C,\infty}</math>. The black dots represent the raw data obtained from obtaining the temperature at which the Heat Capacity was a maximum for the lattices and the red line in a linear curve fit plotted against the data to allow the y-intercept which is the Curie Temperature for the infinite 2D lattice to be determined.

[[File:cg1417CurieTemp.png|400px|thumb|left|Figure 17 - Plot of 1/Lattice Size against Curie Temperature for that lattice size.]]

The value for <math>T_{C,\inf}</math> obtained from the data is <math>T_{C,\infty} = 2.277 \frac{J}{k_B}</math> with a literature value being <math>T_{C,\infty} = 2.269 \frac{J}{k_B}</math> for an infinite square 2D lattice. This means that my result slightly over-estimates the Curie Temperature for the infinite lattice and as a result for an infinite lattice the temperature at which spontaneous magnetisation stops would actually occur at a slightly lower temperature than expected. However, the difference between my value and the literature value is only 0.008 which is incredibly small and the amount of agreement between the two values is somewhat surprising, which means that the error in my estimates of the Curie Temperature for each lattice size is relatively small. A potential source of error from the values of the Curie Temperature for each lattice size could come from the