ChemWiki - User contributions [en]

Rep:Mod:DMS3053

2015-02-27T14:40:59Z

Ds3012: /* Finding the Peak in Heat Capacity */

'''CMP Programming Experiment - Daniel Spencer, 00736964'''
<div style="text-align: justify">
==Introduction to the Ising Model==
===Minimum energy of the Ising Model===
Using the equation 
::<math>E= - \frac{1}{2} J \sum_i^N \sum_{j\ \in\ \mathrm{neighbours}\left(i\right)} s_i s_j</math> (''eq. 1'') 
the minimum energy of an Ising lattice of <math>D</math> dimensions, with <math>N</math> spins (where each
spin had a value of +1 or -1) and an interaction strength of <math>J</math> was considered. This was achieved first through a consideration of a one-dimensional system with five parallel spins (where the spins are parallel as this corresponds to the minimum energy arrangement of the system). Hence, the energy of this linear system was found to be 
::<math>E_\text{min,1D} = -5J </math>. 
For a linear, one-dimensional system, the number of neigbouring spins is two. The number of neighbours can be determined for two- and three- dimensional systems through a geometric consideration of their structure - the values are presented in ''Table 1''.
{| class="wikitable floatright" width=42%
|+ ''Table 1: Dimension numbers and number of neighbours''
! Number of Dimensions, D !! Number of Neighbours
|- style="text-align:center;"
| 1 || 2
|- style="text-align:center;"
| 2 || 4
|- style="text-align:center;"
| 3 || 6
|- style="text-align:center;"
| D || 2D
|}
These data indicate that the number of neighbours is twice the number of dimensions, for the dimensions considered here. This can be extrapolated to give the general number of neighbours as <math>2D</math>.

For the minimum energy of the system, where all spins are parallel, every combination <math>s_i s_j</math> has a value of 1. Notably, for each value of <math>i</math>, there will be <math>2D</math> neighbour interactions. Ergo, using ''eq. 1'', the general minimum energy can be found to be
::<math>E_\text{min,D} = -DNJ </math> (''eq. 2''). 
To check this equation, it can be applied to the two-dimensional Ising lattice with 25 spins - this gives a value of
::<math>E_\text{min,2D} = -50J </math>, 
which matches with the value predicted from first-principles.

For this D-dimensional system, the multiplicity (i.e. the number of ways of achieving the specified configuration of spins) must be equal to two, as either all of the spins could be aligned 'up' (+1) or 'down' (-1). Using this multiplicity, the entropy of the system can be calculated using the equation
::<math>S = k_B \ln\Omega</math>, (''eq. 3'') 
where Ω is the number of microstates (equal to the multiplicity in this case), which gives a value of <math>k_B \ln2 </math>, or 9.57 x 10-24 J K-1.

===Spin 'flipping'===
[[File:ThirdYearCMPExpt-IsingSketch.png|300px|thumb|right|'' '''Figure 1''': Representation of Ising lattices in one (N=5), two (N=25), and three (N=125) dimensions. +1 and -1 spins are denoted by the red and blue cells respectively. Diagram taken from the lab script.'']]
Using the Ising model, it is also possible to consider a change in state, reflected by a 'flipping' of the direction of one of the lattice spins. For this case, the energy (using ''eq. 1'') can be determined to be
::<math>E'= - \frac{1}{2} J (2DN - 4D - 4D) = 4DJ - DNJ</math>, (''eq. 4'') 
where the additional <math>4D</math> terms arise from the loss of 4D stabilising spin-aligned interactions and the gain of 4D destabilising spins anti-aligned interactions following spin 'flipping'. Using ''eq. 2'' and ''eq. 4'', the change in energy derived from this spin 'flip' can be calculated to be
::<math>\Delta E= 4DJ - DNJ + DNJ = 4DJ</math>. (''eq. 5'') 
For a system with three dimensions (D = 3) and 1000 spins (N = 1000), the system, using ''eq. 5'', was determined to increase in energy by <math>12 J</math>. Notably, this change in energy is independent of the number of spins in the system - it depends only on the number of dimensions and J.

A significant consideration with regards to the spin 'flipping' described here is the accompanying increase in entropy - the driving force for this process. For the scenario describing the change in direction of a single spin, the multiplicity of the system will be <math>2N</math> - this is a consequence of the system prior to 'flipping' having a multiplicity of two (all spins aligned 'up' or 'down'), where now, any one of the spins could flip, adding the factor of N to the multiplicity. Hence, the new entropy can be defined to be
::<math>S' = k_B \ln 2N</math>, (''eq. 6'') 
which allows the change in entropy to be calculated according to ''eq. 7''.
::<math>\Delta S = k_B \ln 2N - k_B \ln2 = k_B \ln N</math> (''eq. 7'') 
For the system described above (D = 3, N = 1000), the change in entropy associated with the spin 'flip' process is therefore <math>k_B ln 1000</math>, which is equal to 9.53 x 10-23 J K-1.

===Magnetisation===
{| class="wikitable floatleft" width=42%
|+ ''Table 2: Ising lattices and magnetisations''
! Ising Lattice !! Magnetisation
|- style="text-align:center;"
| 1D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 2D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 3D at 0 K || 1000 or -1000
|}
''Figure 1'' shows three examples of Ising lattices, with one, two and three dimensions respectively. Using the equation for magnetisation (''eq. 8''), the magnetisations of these systems can be calculated to be those presented in ''Table 2''.
::<math>M= \sum_i s_i</math> (''eq. 8'') 
For the three-dimensional system with 1000 spins at a temperature of 0 K, all of the spins must be aligned either 'up' or 'down', as the entropic increase associated with 'flipped' spins does not provide a driving force at absolute zero - the only factor to consider is that of the energy, which is a minimum when all of the spins are aligned. For this case, the magnetisation could be either 1000 or -1000, depending upon the direction of the spin alignment. From a consideration of the magnetisation values calculated here, it is evident that with all of the spins aligned, the (magnitude of the) magnetisation of the system is at a maximum.

==Calculating the energy and magnetisation==
===Modifying the files===
[[File:DMStest_output2.png|300px|thumb|right|'' '''Figure 2''': Output image from testing IsingLattice.py using Ilcheck.py'']]
In order to use Python to compute the energy and magnetisation for a given two-dimensional Ising lattice, the class IsingLattice was used, where energy() and magnetisation() functions were written to calculate their corresponding properties for a random numpy array of spins (generated using np.random.choice). For this aspect of the experiment, the value of J was assumed to be 1.0, working in reduced units. The Python script developed can be viewed [[Mod:DMS3053-1|here]], including annotations.

===Testing the files===
In order to test the script prepared thus far, the Ilcheck.py script was run, generating the image presented in ''Figure 2''. An examination of this output clearly indicates that the script provides accurate energies and magnetisations for the minimum and maximum energy configurations, along with for an intermediate, random arrangement. Hence, it can be concluded that at the current level, the Python script is functioning as required.

==Introduction to the Monte Carlo simulation==
===Average Energy and Magnetisation===
[[File:DMSILanim3.png|300px|thumb|right|'''''Figure 3''': Animation result from ILanim.py, showing the resting of the system in the minimum energy state'']]
In order to consider the generalisability of the prepared script, it is important to analyse how the script will function for large systems, such as those with 100 spins in the spin array. As each of these spins can be either 'up' or 'down', each spin has two choices. Hence, the number of possible configurations for the system can be written as <math>2^{100}</math>, which has a value of 1.2677 x 1030.

If one considers the sampling of a single configuration to take 1 x 10-9 s, then it is clear that sampling all of these configurations would take a total of 1.2677 x 1021 s (also expressed as 4.017 x 1013 years). From this analysis, it is evident that the sampling of configurations was a significant consideration in the writing of a python script for this task.

In order to account for this, the technique of importance sampling was implemented, using the statistical Boltzmann distribution, <math>\exp(- \Delta E / k_B T)</math>. Note that as the energy computed using the energy() function is in units of kB, this factor is not included in the script.

===Modifying IsingLattice.py to Implement a Monte Carlo Cycle===
[[File:DMSILanim_meta.png|300px|thumb|left|'''''Figure 4''': Animation result from ILanim.py, showing the resting of the system in a meta-stable state'']]
The python script developed at this stage is presented [[Mod:DMS3053-2|here]], accompanied by annotations to explain how the script functions.

===Simulating the Monte Carlo Cycles===
{| class="wikitable floatright" width=42%
|+ ''Table 3: statistics() output for animated system at global minimum configuration (Figure 3)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.70542501728
|- style="text-align:center;"
| <E2> || 3.13520970111
|- style="text-align:center;"
| <M> || -0.829971492744
|- style="text-align:center;"
| <M2> || 0.770986982766
|}
For cases where T < Tc, it would be expected that the system would have a spontaneous magnetisation. When T > Tc, the entropy will be the dominating factor, potentially resulting in the system having a magnetisation of zero.
{| class="wikitable floatright" width=42%
|+ ''Table 4: statistics() output for animated system at meta-stable configuration (Figure 4)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.35076450189
|- style="text-align:center;"
| <E2> || 1.89025801939
|- style="text-align:center;"
| <M> || -0.344104665826
|- style="text-align:center;"
| <M2> || 0.138855365306
|}
Using the presented script and the ILanim.py script, the Monte Carlo cycles can be simulated to view the results on the spin array as the process progresses. Here, the system under consideration was an 8 x 8 spin array, at a temperature of 0.5. ''Figure 3'' shows the typical outcome of the animation, with the system having reached the most stable, minimum energy arrangement. For the result presented here, the output of the statistics() function was that shown in ''Table 3''.

It was also observed that the system could locate a meta-stable state, with large regions of spin 'up' and 'down' spins. An example of such a result is presented in ''Figure 4'' (for which the output data from statistics() is presented in ''Table 4'').

==Accelerating the code==

In order to examine the efficiency of the python script developed thus far, the Iltimetrial.py script was utilised to investigate the time taken to perform 2000 Monte Carlo cycles. This script was modified to the version presented [[Mod:DMS3053-3|here]], which repeats the time measurement a defined number of times, then calculates the average time and the standard error in this average. For the Monte Carlo script prepared previously, the average time for 2000 Monte Carlo cycles was measured to be 5.475804 s and a standard error was calculated to be 0.008325 s, with 100 measurements made using the script.

Evidently, the current script is slow at conducting large numbers of Monte Carlo cycles and hence, a more efficient script was developed using the np.roll, np.multiply and np.sum functions - this is presented [[Mod:DMS3053-4|here]].

After this optimisation of the python script, the Iltimetrial.py script was re-run, giving an average time of 0.291467 s, with a standard error of 0.000156 s. Clearly, this optimised script is substantially faster than that developed previously (approximately 19 times faster).

==The effect of temperature==
===Correcting the averaging code===
As the equilibrium state of the system requires a number of Monte Carlo cycles to be reached, it is evident that the average energies and magnetisations are accounting for values for non-equilibrium arrangements - this was accounted for through a consideration of the number of cycles required to reach equilibrium. For this, the ILfinalframe.py script was used, giving the graphs shown in ''Table 5''. Here, each system was run for 150000 Monte Carlo cycles.
{| class="wikitable center" width=70%
|+ ''Table 5: Graphs of energy and magnetisation versus number of Monte Carlo cycles for different temperatures and system sizes''
! Temperature !! System Size !! Resulting Graphs !! Cycles for Equilibrium
|- style="text-align:center;"
| 0.5 || 4x4 || [[File:DMS0544.png|300px]] || 24
|- style="text-align:center;"
| 0.5 || 8x8 || [[File:DMS0588.png|300px]] || 392
|- style="text-align:center;"
| 0.5 || 16x16 || [[File:DMS051616.png|300px]] || 5549
|- style="text-align:center;"
| 1.0 || 2x2 || [[File:DMS1022.png|300px]] || (0)
|- style="text-align:center;"
| 1.0 || 4x4 || [[File:DMS1044.png|300px]] || 49
|- style="text-align:center;"
| 1.0 || 8x8 || [[File:DMS10882.png|300px]] || 590
|- style="text-align:center;"
| 1.0 || 16x16 || [[File:DMS101616.png|300px]] || ~6300
|- style="text-align:center;"
| 1.0 || 32x32 || [[File:DMS103232.png|300px]] || ~110000
|- style="text-align:center;"
| 2.0 || 4x4 || [[File:DMS2044.png|300px]] || -
|- style="text-align:center;"
| 2.0 || 8x8 || [[File:DMS2088.png|300px]] || -
|}
{| class="wikitable floatright" width=42%
|+ ''Table 6: Number of cycles to be ignored for each system size''
! System Size !! Number of cycles before averaging
|- style="text-align:center;"
| 2x2 || 0
|- style="text-align:center;"
| 4x4 || 100
|- style="text-align:center;"
| 8x8 || 1000
|- style="text-align:center;"
| 16x16 || 8000
|- style="text-align:center;"
| 32x32 || 120000
|}
Analysis of these graphs indicates that at higher temperatures, such as 2.0 (also observed at 1.5), large fluctuations in the energy and magnetisation are observed - these fluctuations are the reason that the average values of the properties must be taken. As the temperature is increased for systems of size 4x4, 8x8 and 16x16, it is clear that the number of cycles required in order to reach equilibrium increases. Hence, for the temperature range to be considered later (0.25 to 5.00), the required number of cycles was overestimated in order to ensure that all measurements were taken whilst the system was in equilibrium. The proposed numbers of cycles to be ignored for each system size are presented in ''Table 6''.

The python script developed up to this point was modified to account for these values by inclusion of a skip_region variable, which defines the number of cycles performed before energies and magnetisations contribute to the self.X values (before averaging occurs). The modified script is presented [[Mod:DMS3053-5|here]].

===Running over a range of temperatures===
[[File:DMS88dat.png|300px|thumb|right|'''''Figure 5''': Average energy and average magnetisation vs. temperature for 8x8 lattice, with error bars'']]
Using the python script modified in the previous exercise, the code can now be used to simulate the 8x8 system at a range of temperatures, using the ILtemperaturerange.py file (shown [[Mod:DMS3053-temprange|here]]). Here, the temperature range of 0.25 to 5.00 was used, with a separation of 0.25 between points, whilst the runtime was set to 10000 (neglecting the property values for the first 1000 cycles). Running this simulation produced the graphs in ''Figure 5'', where error bars computed using standard errors have also been included (these are small as a consequence of small standard errors). From the graph of average energy versus temperature, the phase transition can be observed - this occurs in the region with a gradient that is not close to zero. The data used here (temperature, average energies, average squared-energies, average magnetisations and average squared-magnetisations) was then saved as a numpy array in a new file, 8x8.dat.

==The effect of system size==
[[File:DMSLatticeSizeCombinedPlot.png|300px|thumb|left|'''''Figure 6''': Average energy and average magnetisation (per spins) vs. temperature for multiple lattice sizes'']]
The process conducted for the 8x8 lattice in the previous exercise was then repeated for lattices of sizes 2x2, 4x4, 16x16 and 32x32, with the data saved in .dat files. These files were then accessed, and the average energy and magnetisation data were plotted on one graph for all of the lattices sizes - this was achieved using the script presented [[Mod:DMS3053-6|here]]. The graphs produced in this manner are shown in ''Figure 6''.

A consideration of this graph suggests that in order to capture the long range fluctuations, whilst minimising the computational time required, an 8x8 lattice is likely to be the optimum choice. This is because the graph for this system size is comparable to that for a 32x32 lattice, whilst being faster to compute.

==Determining the heat capacity==
[[File:DMSheatcapacity2.png|300px|thumb|right|'''''Figure 7''': Heat capacity (per spin) versus temperature for different lattice sizes'']]
Using the .dat files previously produced, the heat capacity was calculated for each lattice size using the equation
::<math>C = \frac{\partial E}{\partial T} = \frac{\mathrm{Var}[E]}{k_B T^2}</math>, (''eq. 9'') 
where <math>\mathrm{Var}[E] = <E^2> - <E>^2 </math>. When implementing this, the kB term was neglected due to the energy values having units of kB. The script used for this purpose is provided [[DMS3053-7|here]]. The plot of heat capacity per spin versus temperature for all of the lattice sizes considered is presented in ''Figure 7''.

==Locating the Curie temperature==
===Comparison with C++ Data===
The data for the heat capacity generated using the python script prepared in this experiment was compared to that from longer C++ computations - graphs showing this comparison are presented in ''Table 7'' for a range of lattice sizes. The Python code used to produce these graphs is shown [[Mod:DMS3053-8|here]].

Considering these graphs, it is clear that, in general, there is a reasonable correlation between the Python and C++ data; however, some of the data, particularly that for high lattice sizes, shows that the Python computations have not always found the maximum of heat capacity. This correlation would be improved by making computations at the same range of temperatures, but with a smaller gap between the temperatures taken; however, this would substantially increase computation time.
{| class="wikitable center" width=70%
|+ ''Table 7: Graphs of heat capacity (per spin) versus temperature for C++ and Python data''
|- style="text-align:center;"
| [[File:DMS2x2c.png|300px]] || [[File:DMS4x4c.png|300px]] || [[File:DMS8x8c.png|300px]]
|- style="text-align:center;"
| 2x2 || 4x4 || 8x8
|- style="text-align:center;"
| [[File:DMS16x16c.png|300px]] || [[File:DMS32x32c.png|300px]]
|- style="text-align:center;"
| 16x16 || 32x32
|}

===Polynomial Fitting===
[[File:DMS8x8513.png|300px|thumb|right|'''''Figure 8''': Heat capacity (per spin) versus temperature for 8x8 system with two polynomial fits'']]
In order to make use of the C++ data in finding the Curie temperature for the Ising Lattices under consideration, polynomials were fit to the data - the script written for this purpose is shown [[Mod:DMS3053-9|here]]. For this fitting, it was found that a polynomial order of 5 was required to provide a good fit for the 2x2 data - this increased significantly as the lattice size increased. An example fit is shown for the 8x8 system in ''Figure 8'', where the polynomial fit is shown for orders 5 and 13. A consideration of this graph reveals that whilst a polynomial of order 5 may be appropriate for a 2x2 system, it is inadequate for the larger system of 8x8. Whilst an order of 13 substantially improves the polynomial fit, one must, in general, take care with 'overfitting' data.
[[File:Py8x8(13fit).png|300px|thumb|left|'''''Figure 9''': Heat capacity (per spin) versus temperature for Python data for 8x8 system with a 13th order polynomial fit'']]
For comparison, a 13th order polynomial was fitted to the 8x8 Python data previously computed - this is shown in ''Figure 9''. Here, it is evident that for this data, a higher order polynomial is required to obtain a fit comparable to that for the C++ data above.

===Fitting in a Particular Temperature Range===
[[File:DMS8x8peak(3).png|300px|thumb|right|'''''Figure 10''': Heat capacity (per spin) versus temperature for 8x8 system with peak polynomial fit'']]
As was observed in the previous exercise, large polynomial orders are required to fit the C++ data well across the whole temperature range. The python script was modified to that presented [[Mod:DMS3053-10|here]] (this script also contains the python code to compute the maximum heat capacity and temperature at which this occurs for the following exercise), which fits a polynomial only in the region of the maximum heat capacity for the system. An example of such fit is shown in ''Figure 10'' for the 8x8 system. Here, it should be noted that for all of the system sizes studied, a polynomial order of 3 was used - this is a clear improvement compared to the 13th order polynomials used previously.

===Finding the Peak in Heat Capacity===
{| class="wikitable floatright" width=42%
|+ ''Table 8: Lattice sizes and their corresponding Curie temperatures''
! System Size !! Curie Temperature
|- style="text-align:center;"
| 2x2 || 2.53503504
|- style="text-align:center;"
| 4x4 || 2.43843844
|- style="text-align:center;"
| 8x8 || 2.33433433
|- style="text-align:center;"
| 16x16 || 2.30455455
|- style="text-align:center;"
| 32x32 || 2.27752753
|}
[[File:DMSCurieTemperature.png|300px|thumb|left|'''''Figure 11''': Curie temperature vs. 1/(lattice length), with extrapolated linear fit'']]
In order to find the Curie temperature for an infinite Ising Lattice, the Curie temperature for each system size considered was first found (using the script shown in the previous exercise). These temperatures were then saved to a .dat file (whose contents are also showed in ''Table 8'', along with their corresponding lattice sizes. Finally, using the script presented [[Mod:DMS3053-11|here]], a graph of Curie temperature versus the inverse of the lattice length was plotted, according to the equation
::<math>T_{C, L} = \frac{A}{L} + T_{C,\infty}</math>, ''(eq. 10)
where <math>T_{C, L}</math> is the Curie temperature for a lattice with length L and <math>T_{C,\infty}</math> is the Curie temperature for an infinite Ising lattice. Hence, it is clear that the desired Curie temperature must be the y-intercept of the graph shown in ''Figure 11'' (hence the use of extrapolation in the python script). Taking this extrapolated value gives a Curie temperature of 2.271. This value can be compared to the theoretical exact value of 2.27 (J/kB),<ref>D. K. Khudier, N. I. Fawaz, ''Int. Lett. Chem. Phys. Astron.'', 2013, '''10''', 201-212. Available from: http://www.ilcpa.pl/wp-content/uploads/2012/11/ILCPA-102-2013-201-2121.pdf</ref> which indicates a good agreement between the value calculated in this investigation and the theoretical exact value. This is surprising given that it would be expected that the polynomial fitting of the data to locate the maximum would contribute a considerable degree of error to the final value. Alongside this, some error may also have been derived from the decision of the number of Monte Carlo cycles at which to begin averaging. In order to prevent any issues arriving here, a large number of cycles should be used - this was not implemented here due to the computation time that would be required.

==References==
<references/>
</div>

Rep:Mod:DMS3053

2015-02-27T13:12:12Z

Ds3012: /* Introduction to the Monte Carlo simulation */

Rep:Mod:DMS3053

2015-02-26T21:53:23Z

Ds3012: /* Finding the Peak in Heat Capacity */

'''CMP Programming Experiment - Daniel Spencer, 00736964'''
<div style="text-align: justify">
==Introduction to the Ising Model==
===Minimum energy of the Ising Model===
Using the equation 
::<math>E= - \frac{1}{2} J \sum_i^N \sum_{j\ \in\ \mathrm{neighbours}\left(i\right)} s_i s_j</math> (''eq. 1'') 
the minimum energy of an Ising lattice of <math>D</math> dimensions, with <math>N</math> spins (where each
spin had a value of +1 or -1) and an interaction strength of <math>J</math> was considered. This was achieved first through a consideration of a one-dimensional system with five parallel spins (where the spins are parallel as this corresponds to the minimum energy arrangement of the system). Hence, the energy of this linear system was found to be 
::<math>E_\text{min,1D} = -5J </math>. 
For a linear, one-dimensional system, the number of neigbouring spins is two. The number of neighbours can be determined for two- and three- dimensional systems through a geometric consideration of their structure - the values are presented in ''Table 1''.
{| class="wikitable floatright" width=42%
|+ ''Table 1: Dimension numbers and number of neighbours''
! Number of Dimensions, D !! Number of Neighbours
|- style="text-align:center;"
| 1 || 2
|- style="text-align:center;"
| 2 || 4
|- style="text-align:center;"
| 3 || 6
|- style="text-align:center;"
| D || 2D
|}
These data indicate that the number of neighbours is twice the number of dimensions, for the dimensions considered here. This can be extrapolated to give the general number of neighbours as <math>2D</math>.

For the minimum energy of the system, where all spins are parallel, every combination <math>s_i s_j</math> has a value of 1. Notably, for each value of <math>i</math>, there will be <math>2D</math> neighbour interactions. Ergo, using ''eq. 1'', the general minimum energy can be found to be
::<math>E_\text{min,D} = -DNJ </math> (''eq. 2''). 
To check this equation, it can be applied to the two-dimensional Ising lattice with 25 spins - this gives a value of
::<math>E_\text{min,2D} = -50J </math>, 
which matches with the value predicted from first-principles.

For this D-dimensional system, the multiplicity (i.e. the number of ways of achieving the specified configuration of spins) must be equal to two, as either all of the spins could be aligned 'up' (+1) or 'down' (-1). Using this multiplicity, the entropy of the system can be calculated using the equation
::<math>S = k_B \ln\Omega</math>, (''eq. 3'') 
where Ω is the number of microstates (equal to the multiplicity in this case), which gives a value of <math>k_B \ln2 </math>, or 9.57 x 10-24 J K-1.

===Spin 'flipping'===
[[File:ThirdYearCMPExpt-IsingSketch.png|300px|thumb|right|'' '''Figure 1''': Representation of Ising lattices in one (N=5), two (N=25), and three (N=125) dimensions. +1 and -1 spins are denoted by the red and blue cells respectively. Diagram taken from the lab script.'']]
Using the Ising model, it is also possible to consider a change in state, reflected by a 'flipping' of the direction of one of the lattice spins. For this case, the energy (using ''eq. 1'') can be determined to be
::<math>E'= - \frac{1}{2} J (2DN - 4D - 4D) = 4DJ - DNJ</math>, (''eq. 4'') 
where the additional <math>4D</math> terms arise from the loss of 4D stabilising spin-aligned interactions and the gain of 4D destabilising spins anti-aligned interactions following spin 'flipping'. Using ''eq. 2'' and ''eq. 4'', the change in energy derived from this spin 'flip' can be calculated to be
::<math>\Delta E= 4DJ - DNJ + DNJ = 4DJ</math>. (''eq. 5'') 
For a system with three dimensions (D = 3) and 1000 spins (N = 1000), the system, using ''eq. 5'', was determined to increase in energy by <math>12 J</math>. Notably, this change in energy is independent of the number of spins in the system - it depends only on the number of dimensions and J.

A significant consideration with regards to the spin 'flipping' described here is the accompanying increase in entropy - the driving force for this process. For the scenario describing the change in direction of a single spin, the multiplicity of the system will be <math>2N</math> - this is a consequence of the system prior to 'flipping' having a multiplicity of two (all spins aligned 'up' or 'down'), where now, any one of the spins could flip, adding the factor of N to the multiplicity. Hence, the new entropy can be defined to be
::<math>S' = k_B \ln 2N</math>, (''eq. 6'') 
which allows the change in entropy to be calculated according to ''eq. 7''.
::<math>\Delta S = k_B \ln 2N - k_B \ln2 = k_B \ln N</math> (''eq. 7'') 
For the system described above (D = 3, N = 1000), the change in entropy associated with the spin 'flip' process is therefore <math>k_B ln 1000</math>, which is equal to 9.53 x 10-23 J K-1.

===Magnetisation===
{| class="wikitable floatleft" width=42%
|+ ''Table 2: Ising lattices and magnetisations''
! Ising Lattice !! Magnetisation
|- style="text-align:center;"
| 1D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 2D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 3D at 0 K || 1000 or -1000
|}
''Figure 1'' shows three examples of Ising lattices, with one, two and three dimensions respectively. Using the equation for magnetisation (''eq. 8''), the magnetisations of these systems can be calculated to be those presented in ''Table 2''.
::<math>M= \sum_i s_i</math> (''eq. 8'') 
For the three-dimensional system with 1000 spins at a temperature of 0 K, all of the spins must be aligned either 'up' or 'down', as the entropic increase associated with 'flipped' spins does not provide a driving force at absolute zero - the only factor to consider is that of the energy, which is a minimum when all of the spins are aligned. For this case, the magnetisation could be either 1000 or -1000, depending upon the direction of the spin alignment. From a consideration of the magnetisation values calculated here, it is evident that with all of the spins aligned, the (magnitude of the) magnetisation of the system is at a maximum.

==Calculating the energy and magnetisation==
===Modifying the files===
[[File:DMStest_output2.png|300px|thumb|right|'' '''Figure 2''': Output image from testing IsingLattice.py using Ilcheck.py'']]
In order to use Python to compute the energy and magnetisation for a given two-dimensional Ising lattice, the class IsingLattice was used, where energy() and magnetisation() functions were written to calculate their corresponding properties for a random numpy array of spins (generated using np.random.choice). For this aspect of the experiment, the value of J was assumed to be 1.0, working in reduced units. The Python script developed can be viewed [[Mod:DMS3053-1|here]], including annotations.

===Testing the files===
In order to test the script prepared thus far, the Ilcheck.py script was run, generating the image presented in ''Figure 2''. An examination of this output clearly indicates that the script provides accurate energies and magnetisations for the minimum and maximum energy configurations, along with for an intermediate, random arrangement. Hence, it can be concluded that at the current level, the Python script is functioning as required.

==Introduction to the Monte Carlo simulation==
===Average Energy and Magnetisation===
[[File:DMSILanim3.png|300px|thumb|right|'''''Figure 3''': Animation result from ILanim.py, showing the resting of the system in the minimum energy state'']]
In order to consider the generalisability of the prepared script, it is important to analyse how the script will function for large systems, such as those with 100 spins in the spin array. As each of these spins can be either 'up' or 'down', each spin has two choices. Hence, the number of possible configurations for the system can be written as <math>2^{100}</math>, which has a value of 1.2677 x 1030.

If one considers the sampling of a single configuration to take 1 x 10-9 s, then it is clear that sampling all of these considerations would take a total of 1.2677 x 1021 s (also expressed as 4.017 x 1013 years). From this analysis, it is evident that the sampling of configurations was a significant consideration in the writing of a python script for this task.

In order to account for this, the technique of importance sampling was implemented, using the statistical Boltzmann distribution, <math>\exp(- \Delta E / k_B T)</math>. Note that as the energy computed using the energy() function is in units of kB, this factor is not included in the script.

===Modifying IsingLattice.py to Implement a Monte Carlo Cycle===
[[File:DMSILanim_meta.png|300px|thumb|left|'''''Figure 4''': Animation result from ILanim.py, showing the resting of the system in a meta-stable state'']]
The python script developed at this stage is presented [[Mod:DMS3053-2|here]], accompanied by annotations to explain how the script functions.

===Simulating the Monte Carlo Cycles===
{| class="wikitable floatright" width=42%
|+ ''Table 3: statistics() output for animated system at global minimum configuration (Figure 3)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.70542501728
|- style="text-align:center;"
| <E2> || 3.13520970111
|- style="text-align:center;"
| <M> || -0.829971492744
|- style="text-align:center;"
| <M2> || 0.770986982766
|}
For cases where T < Tc, it would be expected that the system would have a spontaneous magnetisation. When T > Tc, the entropy will be the dominating factor, potentially resulting in the system having a magnetisation of zero.
{| class="wikitable floatright" width=42%
|+ ''Table 4: statistics() output for animated system at meta-stable configuration (Figure 4)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.35076450189
|- style="text-align:center;"
| <E2> || 1.89025801939
|- style="text-align:center;"
| <M> || -0.344104665826
|- style="text-align:center;"
| <M2> || 0.138855365306
|}
Using the presented script and the ILanim.py script, the Monte Carlo cycles can be simulated to view the results on the spin array as the process progresses. Here, the system under consideration was an 8 x 8 spin array, at a temperature of 0.5. ''Figure 3'' shows the typical outcome of the animation, with the system having reached the most stable, minimum energy arrangement. For the result presented here, the output of the statistics() function was that shown in ''Table 3''.

It was also observed that the system could locate a meta-stable state, with large regions of spin 'up' and 'down' spins. An example of such a result is presented in ''Figure 4'' (for which the output data from statistics() is presented in ''Table 4'').

==Accelerating the code==

In order to examine the efficiency of the python script developed thus far, the Iltimetrial.py script was utilised to investigate the time taken to perform 2000 Monte Carlo cycles. This script was modified to the version presented [[Mod:DMS3053-3|here]], which repeats the time measurement a defined number of times, then calculates the average time and the standard error in this average. For the Monte Carlo script prepared previously, the average time for 2000 Monte Carlo cycles was measured to be 5.475804 s and a standard error was calculated to be 0.008325 s, with 100 measurements made using the script.

Evidently, the current script is slow at conducting large numbers of Monte Carlo cycles and hence, a more efficient script was developed using the np.roll, np.multiply and np.sum functions - this is presented [[Mod:DMS3053-4|here]].

After this optimisation of the python script, the Iltimetrial.py script was re-run, giving an average time of 0.291467 s, with a standard error of 0.000156 s. Clearly, this optimised script is substantially faster than that developed previously (approximately 19 times faster).

==The effect of temperature==
===Correcting the averaging code===
As the equilibrium state of the system requires a number of Monte Carlo cycles to be reached, it is evident that the average energies and magnetisations are accounting for values for non-equilibrium arrangements - this was accounted for through a consideration of the number of cycles required to reach equilibrium. For this, the ILfinalframe.py script was used, giving the graphs shown in ''Table 5''. Here, each system was run for 150000 Monte Carlo cycles.
{| class="wikitable center" width=70%
|+ ''Table 5: Graphs of energy and magnetisation versus number of Monte Carlo cycles for different temperatures and system sizes''
! Temperature !! System Size !! Resulting Graphs !! Cycles for Equilibrium
|- style="text-align:center;"
| 0.5 || 4x4 || [[File:DMS0544.png|300px]] || 24
|- style="text-align:center;"
| 0.5 || 8x8 || [[File:DMS0588.png|300px]] || 392
|- style="text-align:center;"
| 0.5 || 16x16 || [[File:DMS051616.png|300px]] || 5549
|- style="text-align:center;"
| 1.0 || 2x2 || [[File:DMS1022.png|300px]] || (0)
|- style="text-align:center;"
| 1.0 || 4x4 || [[File:DMS1044.png|300px]] || 49
|- style="text-align:center;"
| 1.0 || 8x8 || [[File:DMS10882.png|300px]] || 590
|- style="text-align:center;"
| 1.0 || 16x16 || [[File:DMS101616.png|300px]] || ~6300
|- style="text-align:center;"
| 1.0 || 32x32 || [[File:DMS103232.png|300px]] || ~110000
|- style="text-align:center;"
| 2.0 || 4x4 || [[File:DMS2044.png|300px]] || -
|- style="text-align:center;"
| 2.0 || 8x8 || [[File:DMS2088.png|300px]] || -
|}
{| class="wikitable floatright" width=42%
|+ ''Table 6: Number of cycles to be ignored for each system size''
! System Size !! Number of cycles before averaging
|- style="text-align:center;"
| 2x2 || 0
|- style="text-align:center;"
| 4x4 || 100
|- style="text-align:center;"
| 8x8 || 1000
|- style="text-align:center;"
| 16x16 || 8000
|- style="text-align:center;"
| 32x32 || 120000
|}
Analysis of these graphs indicates that at higher temperatures, such as 2.0 (also observed at 1.5), large fluctuations in the energy and magnetisation are observed - these fluctuations are the reason that the average values of the properties must be taken. As the temperature is increased for systems of size 4x4, 8x8 and 16x16, it is clear that the number of cycles required in order to reach equilibrium increases. Hence, for the temperature range to be considered later (0.25 to 5.00), the required number of cycles was overestimated in order to ensure that all measurements were taken whilst the system was in equilibrium. The proposed numbers of cycles to be ignored for each system size are presented in ''Table 6''.

The python script developed up to this point was modified to account for these values by inclusion of a skip_region variable, which defines the number of cycles performed before energies and magnetisations contribute to the self.X values (before averaging occurs). The modified script is presented [[Mod:DMS3053-5|here]].

===Running over a range of temperatures===
[[File:DMS88dat.png|300px|thumb|right|'''''Figure 5''': Average energy and average magnetisation vs. temperature for 8x8 lattice, with error bars'']]
Using the python script modified in the previous exercise, the code can now be used to simulate the 8x8 system at a range of temperatures, using the ILtemperaturerange.py file (shown [[Mod:DMS3053-temprange|here]]). Here, the temperature range of 0.25 to 5.00 was used, with a separation of 0.25 between points, whilst the runtime was set to 10000 (neglecting the property values for the first 1000 cycles). Running this simulation produced the graphs in ''Figure 5'', where error bars computed using standard errors have also been included (these are small as a consequence of small standard errors). From the graph of average energy versus temperature, the phase transition can be observed - this occurs in the region with a gradient that is not close to zero. The data used here (temperature, average energies, average squared-energies, average magnetisations and average squared-magnetisations) was then saved as a numpy array in a new file, 8x8.dat.

==The effect of system size==
[[File:DMSLatticeSizeCombinedPlot.png|300px|thumb|left|'''''Figure 6''': Average energy and average magnetisation (per spins) vs. temperature for multiple lattice sizes'']]
The process conducted for the 8x8 lattice in the previous exercise was then repeated for lattices of sizes 2x2, 4x4, 16x16 and 32x32, with the data saved in .dat files. These files were then accessed, and the average energy and magnetisation data were plotted on one graph for all of the lattices sizes - this was achieved using the script presented [[Mod:DMS3053-6|here]]. The graphs produced in this manner are shown in ''Figure 6''.

A consideration of this graph suggests that in order to capture the long range fluctuations, whilst minimising the computational time required, an 8x8 lattice is likely to be the optimum choice. This is because the graph for this system size is comparable to that for a 32x32 lattice, whilst being faster to compute.

==Determining the heat capacity==
[[File:DMSheatcapacity2.png|300px|thumb|right|'''''Figure 7''': Heat capacity (per spin) versus temperature for different lattice sizes'']]
Using the .dat files previously produced, the heat capacity was calculated for each lattice size using the equation
::<math>C = \frac{\partial E}{\partial T} = \frac{\mathrm{Var}[E]}{k_B T^2}</math>, (''eq. 9'') 
where <math>\mathrm{Var}[E] = <E^2> - <E>^2 </math>. When implementing this, the kB term was neglected due to the energy values having units of kB. The script used for this purpose is provided [[DMS3053-7|here]]. The plot of heat capacity per spin versus temperature for all of the lattice sizes considered is presented in ''Figure 7''.

==Locating the Curie temperature==
===Comparison with C++ Data===
The data for the heat capacity generated using the python script prepared in this experiment was compared to that from longer C++ computations - graphs showing this comparison are presented in ''Table 7'' for a range of lattice sizes. The Python code used to produce these graphs is shown [[Mod:DMS3053-8|here]].

Considering these graphs, it is clear that, in general, there is a reasonable correlation between the Python and C++ data; however, some of the data, particularly that for high lattice sizes, shows that the Python computations have not always found the maximum of heat capacity. This correlation would be improved by making computations at the same range of temperatures, but with a smaller gap between the temperatures taken; however, this would substantially increase computation time.
{| class="wikitable center" width=70%
|+ ''Table 7: Graphs of heat capacity (per spin) versus temperature for C++ and Python data''
|- style="text-align:center;"
| [[File:DMS2x2c.png|300px]] || [[File:DMS4x4c.png|300px]] || [[File:DMS8x8c.png|300px]]
|- style="text-align:center;"
| 2x2 || 4x4 || 8x8
|- style="text-align:center;"
| [[File:DMS16x16c.png|300px]] || [[File:DMS32x32c.png|300px]]
|- style="text-align:center;"
| 16x16 || 32x32
|}

===Polynomial Fitting===
[[File:DMS8x8513.png|300px|thumb|right|'''''Figure 8''': Heat capacity (per spin) versus temperature for 8x8 system with two polynomial fits'']]
In order to make use of the C++ data in finding the Curie temperature for the Ising Lattices under consideration, polynomials were fit to the data - the script written for this purpose is shown [[Mod:DMS3053-9|here]]. For this fitting, it was found that a polynomial order of 5 was required to provide a good fit for the 2x2 data - this increased significantly as the lattice size increased. An example fit is shown for the 8x8 system in ''Figure 8'', where the polynomial fit is shown for orders 5 and 13. A consideration of this graph reveals that whilst a polynomial of order 5 may be appropriate for a 2x2 system, it is inadequate for the larger system of 8x8. Whilst an order of 13 substantially improves the polynomial fit, one must, in general, take care with 'overfitting' data.
[[File:Py8x8(13fit).png|300px|thumb|left|'''''Figure 9''': Heat capacity (per spin) versus temperature for Python data for 8x8 system with a 13th order polynomial fit'']]
For comparison, a 13th order polynomial was fitted to the 8x8 Python data previously computed - this is shown in ''Figure 9''. Here, it is evident that for this data, a higher order polynomial is required to obtain a fit comparable to that for the C++ data above.

===Fitting in a Particular Temperature Range===
[[File:DMS8x8peak(3).png|300px|thumb|right|'''''Figure 10''': Heat capacity (per spin) versus temperature for 8x8 system with peak polynomial fit'']]
As was observed in the previous exercise, large polynomial orders are required to fit the C++ data well across the whole temperature range. The python script was modified to that presented [[Mod:DMS3053-10|here]] (this script also contains the python code to compute the maximum heat capacity and temperature at which this occurs for the following exercise), which fits a polynomial only in the region of the maximum heat capacity for the system. An example of such fit is shown in ''Figure 10'' for the 8x8 system. Here, it should be noted that for all of the system sizes studied, a polynomial order of 3 was used - this is a clear improvement compared to the 13th order polynomials used previously.

===Finding the Peak in Heat Capacity===
{| class="wikitable floatright" width=42%
|+ ''Table 8: Lattice sizes and their corresponding Curie temperatures''
! System Size !! Curie Temperature
|- style="text-align:center;"
| 2x2 || 2.53503504
|- style="text-align:center;"
| 4x4 || 2.43843844
|- style="text-align:center;"
| 8x8 || 2.33433433
|- style="text-align:center;"
| 16x16 || 2.30455455
|- style="text-align:center;"
| 32x32 || 2.27752753
|}
[[File:DMSCurieTemperature.png|300px|thumb|left|'''''Figure 11''': Curie temperature vs. 1/(lattice length), with extrapolated linear fit'']]
In order to find the Curie temperature for an infinite Ising Lattice, the Curie temperature for each system size considered was first found (using the script shown in the previous exercise). These temperatures were then saved to a .dat file (whose contents are also showed in ''Table 8'', along with their corresponding lattice sizes. Finally, using the script presented [[Mod:DMS3053-11|here]], a graph of Curie temperature versus the inverse of the lattice length was plotted, according to the equation
::<math>T_{C, L} = \frac{A}{L} + T_{C,\infty}</math>, ''(eq. 10)
where <math>T_{C, L}</math> is the Curie temperature for a lattice with length L and <math>T_{C,\infty}</math> is the Curie temperature for an infinite Ising lattice. Hence, it is clear that the desired Curie temperature must be the y-intercept of the graph shown in ''Figure 11'' (hence the use of extrapolation in the python script). Taking this extrapolated value gives a Curie temperature of 2.271. This value can be compared to the theoretical exact value of 2.27 (J/kB),<ref>D. K. Khudier, N. I. Fawaz, ''Int. Lett. Chem. Phys. Astron.'', 2013, '''10''', 201-212. Available from: http://www.ilcpa.pl/wp-content/uploads/2012/11/ILCPA-102-2013-201-2121.pdf</ref> which indicates a good agreement between the value calculated in this investigation and the theoretical exact value. This is surprising given that it would be expected that the polynomial fitting of the data to locate the maximum would contribute a considerable degree of error to the final value.

==References==
<references/>
</div>

Rep:Mod:DMS3053

2015-02-26T10:31:45Z

Ds3012: /* Finding the Peak in Heat Capacity */

'''CMP Programming Experiment - Daniel Spencer, 00736964'''
<div style="text-align: justify">
==Introduction to the Ising Model==
===Minimum energy of the Ising Model===
Using the equation 
::<math>E= - \frac{1}{2} J \sum_i^N \sum_{j\ \in\ \mathrm{neighbours}\left(i\right)} s_i s_j</math> (''eq. 1'') 
the minimum energy of an Ising lattice of <math>D</math> dimensions, with <math>N</math> spins (where each
spin had a value of +1 or -1) and an interaction strength of <math>J</math> was considered. This was achieved first through a consideration of a one-dimensional system with five parallel spins (where the spins are parallel as this corresponds to the minimum energy arrangement of the system). Hence, the energy of this linear system was found to be 
::<math>E_\text{min,1D} = -5J </math>. 
For a linear, one-dimensional system, the number of neigbouring spins is two. The number of neighbours can be determined for two- and three- dimensional systems through a geometric consideration of their structure - the values are presented in ''Table 1''.
{| class="wikitable floatright" width=42%
|+ ''Table 1: Dimension numbers and number of neighbours''
! Number of Dimensions, D !! Number of Neighbours
|- style="text-align:center;"
| 1 || 2
|- style="text-align:center;"
| 2 || 4
|- style="text-align:center;"
| 3 || 6
|- style="text-align:center;"
| D || 2D
|}
These data indicate that the number of neighbours is twice the number of dimensions, for the dimensions considered here. This can be extrapolated to give the general number of neighbours as <math>2D</math>.

For the minimum energy of the system, where all spins are parallel, every combination <math>s_i s_j</math> has a value of 1. Notably, for each value of <math>i</math>, there will be <math>2D</math> neighbour interactions. Ergo, using ''eq. 1'', the general minimum energy can be found to be
::<math>E_\text{min,D} = -DNJ </math> (''eq. 2''). 
To check this equation, it can be applied to the two-dimensional Ising lattice with 25 spins - this gives a value of
::<math>E_\text{min,2D} = -50J </math>, 
which matches with the value predicted from first-principles.

For this D-dimensional system, the multiplicity (i.e. the number of ways of achieving the specified configuration of spins) must be equal to two, as either all of the spins could be aligned 'up' (+1) or 'down' (-1). Using this multiplicity, the entropy of the system can be calculated using the equation
::<math>S = k_B \ln\Omega</math>, (''eq. 3'') 
where Ω is the number of microstates (equal to the multiplicity in this case), which gives a value of <math>k_B \ln2 </math>, or 9.57 x 10-24 J K-1.

===Spin 'flipping'===
[[File:ThirdYearCMPExpt-IsingSketch.png|300px|thumb|right|'' '''Figure 1''': Representation of Ising lattices in one (N=5), two (N=25), and three (N=125) dimensions. +1 and -1 spins are denoted by the red and blue cells respectively. Diagram taken from the lab script.'']]
Using the Ising model, it is also possible to consider a change in state, reflected by a 'flipping' of the direction of one of the lattice spins. For this case, the energy (using ''eq. 1'') can be determined to be
::<math>E'= - \frac{1}{2} J (2DN - 4D - 4D) = 4DJ - DNJ</math>, (''eq. 4'') 
where the additional <math>4D</math> terms arise from the loss of 4D stabilising spin-aligned interactions and the gain of 4D destabilising spins anti-aligned interactions following spin 'flipping'. Using ''eq. 2'' and ''eq. 4'', the change in energy derived from this spin 'flip' can be calculated to be
::<math>\Delta E= 4DJ - DNJ + DNJ = 4DJ</math>. (''eq. 5'') 
For a system with three dimensions (D = 3) and 1000 spins (N = 1000), the system, using ''eq. 5'', was determined to increase in energy by <math>12 J</math>. Notably, this change in energy is independent of the number of spins in the system - it depends only on the number of dimensions and J.

A significant consideration with regards to the spin 'flipping' described here is the accompanying increase in entropy - the driving force for this process. For the scenario describing the change in direction of a single spin, the multiplicity of the system will be <math>2N</math> - this is a consequence of the system prior to 'flipping' having a multiplicity of two (all spins aligned 'up' or 'down'), where now, any one of the spins could flip, adding the factor of N to the multiplicity. Hence, the new entropy can be defined to be
::<math>S' = k_B \ln 2N</math>, (''eq. 6'') 
which allows the change in entropy to be calculated according to ''eq. 7''.
::<math>\Delta S = k_B \ln 2N - k_B \ln2 = k_B \ln N</math> (''eq. 7'') 
For the system described above (D = 3, N = 1000), the change in entropy associated with the spin 'flip' process is therefore <math>k_B ln 1000</math>, which is equal to 9.53 x 10-23 J K-1.

===Magnetisation===
{| class="wikitable floatleft" width=42%
|+ ''Table 2: Ising lattices and magnetisations''
! Ising Lattice !! Magnetisation
|- style="text-align:center;"
| 1D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 2D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 3D at 0 K || 1000 or -1000
|}
''Figure 1'' shows three examples of Ising lattices, with one, two and three dimensions respectively. Using the equation for magnetisation (''eq. 8''), the magnetisations of these systems can be calculated to be those presented in ''Table 2''.
::<math>M= \sum_i s_i</math> (''eq. 8'') 
For the three-dimensional system with 1000 spins at a temperature of 0 K, all of the spins must be aligned either 'up' or 'down', as the entropic increase associated with 'flipped' spins does not provide a driving force at absolute zero - the only factor to consider is that of the energy, which is a minimum when all of the spins are aligned. For this case, the magnetisation could be either 1000 or -1000, depending upon the direction of the spin alignment. From a consideration of the magnetisation values calculated here, it is evident that with all of the spins aligned, the (magnitude of the) magnetisation of the system is at a maximum.

==Calculating the energy and magnetisation==
===Modifying the files===
[[File:DMStest_output2.png|300px|thumb|right|'' '''Figure 2''': Output image from testing IsingLattice.py using Ilcheck.py'']]
In order to use Python to compute the energy and magnetisation for a given two-dimensional Ising lattice, the class IsingLattice was used, where energy() and magnetisation() functions were written to calculate their corresponding properties for a random numpy array of spins (generated using np.random.choice). For this aspect of the experiment, the value of J was assumed to be 1.0, working in reduced units. The Python script developed can be viewed [[Mod:DMS3053-1|here]], including annotations.

===Testing the files===
In order to test the script prepared thus far, the Ilcheck.py script was run, generating the image presented in ''Figure 2''. An examination of this output clearly indicates that the script provides accurate energies and magnetisations for the minimum and maximum energy configurations, along with for an intermediate, random arrangement. Hence, it can be concluded that at the current level, the Python script is functioning as required.

==Introduction to the Monte Carlo simulation==
===Average Energy and Magnetisation===
[[File:DMSILanim3.png|300px|thumb|right|'''''Figure 3''': Animation result from ILanim.py, showing the resting of the system in the minimum energy state'']]
In order to consider the generalisability of the prepared script, it is important to analyse how the script will function for large systems, such as those with 100 spins in the spin array. As each of these spins can be either 'up' or 'down', each spin has two choices. Hence, the number of possible configurations for the system can be written as <math>2^{100}</math>, which has a value of 1.2677 x 1030.

If one considers the sampling of a single configuration to take 1 x 10-9 s, then it is clear that sampling all of these considerations would take a total of 1.2677 x 1021 s (also expressed as 4.017 x 1013 years). From this analysis, it is evident that the sampling of configurations was a significant consideration in the writing of a python script for this task.

In order to account for this, the technique of importance sampling was implemented, using the statistical Boltzmann distribution, <math>\exp(- \Delta E / k_B T)</math>. Note that as the energy computed using the energy() function is in units of kB, this factor is not included in the script.

===Modifying IsingLattice.py to Implement a Monte Carlo Cycle===
[[File:DMSILanim_meta.png|300px|thumb|left|'''''Figure 4''': Animation result from ILanim.py, showing the resting of the system in a meta-stable state'']]
The python script developed at this stage is presented [[Mod:DMS3053-2|here]], accompanied by annotations to explain how the script functions.

===Simulating the Monte Carlo Cycles===
{| class="wikitable floatright" width=42%
|+ ''Table 3: statistics() output for animated system at global minimum configuration (Figure 3)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.70542501728
|- style="text-align:center;"
| <E2> || 3.13520970111
|- style="text-align:center;"
| <M> || -0.829971492744
|- style="text-align:center;"
| <M2> || 0.770986982766
|}
For cases where T < Tc, it would be expected that the system would have a spontaneous magnetisation. When T > Tc, the entropy will be the dominating factor, potentially resulting in the system having a magnetisation of zero.
{| class="wikitable floatright" width=42%
|+ ''Table 4: statistics() output for animated system at meta-stable configuration (Figure 4)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.35076450189
|- style="text-align:center;"
| <E2> || 1.89025801939
|- style="text-align:center;"
| <M> || -0.344104665826
|- style="text-align:center;"
| <M2> || 0.138855365306
|}
Using the presented script and the ILanim.py script, the Monte Carlo cycles can be simulated to view the results on the spin array as the process progresses. Here, the system under consideration was an 8 x 8 spin array, at a temperature of 0.5. ''Figure 3'' shows the typical outcome of the animation, with the system having reached the most stable, minimum energy arrangement. For the result presented here, the output of the statistics() function was that shown in ''Table 3''.

It was also observed that the system could locate a meta-stable state, with large regions of spin 'up' and 'down' spins. An example of such a result is presented in ''Figure 4'' (for which the output data from statistics() is presented in ''Table 4'').

==Accelerating the code==

In order to examine the efficiency of the python script developed thus far, the Iltimetrial.py script was utilised to investigate the time taken to perform 2000 Monte Carlo cycles. This script was modified to the version presented [[Mod:DMS3053-3|here]], which repeats the time measurement a defined number of times, then calculates the average time and the standard error in this average. For the Monte Carlo script prepared previously, the average time for 2000 Monte Carlo cycles was measured to be 5.475804 s and a standard error was calculated to be 0.008325 s, with 100 measurements made using the script.

Evidently, the current script is slow at conducting large numbers of Monte Carlo cycles and hence, a more efficient script was developed using the np.roll, np.multiply and np.sum functions - this is presented [[Mod:DMS3053-4|here]].

After this optimisation of the python script, the Iltimetrial.py script was re-run, giving an average time of 0.291467 s, with a standard error of 0.000156 s. Clearly, this optimised script is substantially faster than that developed previously (approximately 19 times faster).

==The effect of temperature==
===Correcting the averaging code===
As the equilibrium state of the system requires a number of Monte Carlo cycles to be reached, it is evident that the average energies and magnetisations are accounting for values for non-equilibrium arrangements - this was accounted for through a consideration of the number of cycles required to reach equilibrium. For this, the ILfinalframe.py script was used, giving the graphs shown in ''Table 5''. Here, each system was run for 150000 Monte Carlo cycles.
{| class="wikitable center" width=70%
|+ ''Table 5: Graphs of energy and magnetisation versus number of Monte Carlo cycles for different temperatures and system sizes''
! Temperature !! System Size !! Resulting Graphs !! Cycles for Equilibrium
|- style="text-align:center;"
| 0.5 || 4x4 || [[File:DMS0544.png|300px]] || 24
|- style="text-align:center;"
| 0.5 || 8x8 || [[File:DMS0588.png|300px]] || 392
|- style="text-align:center;"
| 0.5 || 16x16 || [[File:DMS051616.png|300px]] || 5549
|- style="text-align:center;"
| 1.0 || 2x2 || [[File:DMS1022.png|300px]] || (0)
|- style="text-align:center;"
| 1.0 || 4x4 || [[File:DMS1044.png|300px]] || 49
|- style="text-align:center;"
| 1.0 || 8x8 || [[File:DMS10882.png|300px]] || 590
|- style="text-align:center;"
| 1.0 || 16x16 || [[File:DMS101616.png|300px]] || ~6300
|- style="text-align:center;"
| 1.0 || 32x32 || [[File:DMS103232.png|300px]] || ~110000
|- style="text-align:center;"
| 2.0 || 4x4 || [[File:DMS2044.png|300px]] || -
|- style="text-align:center;"
| 2.0 || 8x8 || [[File:DMS2088.png|300px]] || -
|}
{| class="wikitable floatright" width=42%
|+ ''Table 6: Number of cycles to be ignored for each system size''
! System Size !! Number of cycles before averaging
|- style="text-align:center;"
| 2x2 || 0
|- style="text-align:center;"
| 4x4 || 100
|- style="text-align:center;"
| 8x8 || 1000
|- style="text-align:center;"
| 16x16 || 8000
|- style="text-align:center;"
| 32x32 || 120000
|}
Analysis of these graphs indicates that at higher temperatures, such as 2.0 (also observed at 1.5), large fluctuations in the energy and magnetisation are observed - these fluctuations are the reason that the average values of the properties must be taken. As the temperature is increased for systems of size 4x4, 8x8 and 16x16, it is clear that the number of cycles required in order to reach equilibrium increases. Hence, for the temperature range to be considered later (0.25 to 5.00), the required number of cycles was overestimated in order to ensure that all measurements were taken whilst the system was in equilibrium. The proposed numbers of cycles to be ignored for each system size are presented in ''Table 6''.

The python script developed up to this point was modified to account for these values by inclusion of a skip_region variable, which defines the number of cycles performed before energies and magnetisations contribute to the self.X values (before averaging occurs). The modified script is presented [[Mod:DMS3053-5|here]].

===Running over a range of temperatures===
[[File:DMS88dat.png|300px|thumb|right|'''''Figure 5''': Average energy and average magnetisation vs. temperature for 8x8 lattice, with error bars'']]
Using the python script modified in the previous exercise, the code can now be used to simulate the 8x8 system at a range of temperatures, using the ILtemperaturerange.py file (shown [[Mod:DMS3053-temprange|here]]). Here, the temperature range of 0.25 to 5.00 was used, with a separation of 0.25 between points, whilst the runtime was set to 10000 (neglecting the property values for the first 1000 cycles). Running this simulation produced the graphs in ''Figure 5'', where error bars computed using standard errors have also been included (these are small as a consequence of small standard errors). From the graph of average energy versus temperature, the phase transition can be observed - this occurs in the region with a gradient that is not close to zero. The data used here (temperature, average energies, average squared-energies, average magnetisations and average squared-magnetisations) was then saved as a numpy array in a new file, 8x8.dat.

==The effect of system size==
[[File:DMSLatticeSizeCombinedPlot.png|300px|thumb|left|'''''Figure 6''': Average energy and average magnetisation (per spins) vs. temperature for multiple lattice sizes'']]
The process conducted for the 8x8 lattice in the previous exercise was then repeated for lattices of sizes 2x2, 4x4, 16x16 and 32x32, with the data saved in .dat files. These files were then accessed, and the average energy and magnetisation data were plotted on one graph for all of the lattices sizes - this was achieved using the script presented [[Mod:DMS3053-6|here]]. The graphs produced in this manner are shown in ''Figure 6''.

A consideration of this graph suggests that in order to capture the long range fluctuations, whilst minimising the computational time required, an 8x8 lattice is likely to be the optimum choice. This is because the graph for this system size is comparable to that for a 32x32 lattice, whilst being faster to compute.

==Determining the heat capacity==
[[File:DMSheatcapacity2.png|300px|thumb|right|'''''Figure 7''': Heat capacity (per spin) versus temperature for different lattice sizes'']]
Using the .dat files previously produced, the heat capacity was calculated for each lattice size using the equation
::<math>C = \frac{\partial E}{\partial T} = \frac{\mathrm{Var}[E]}{k_B T^2}</math>, (''eq. 9'') 
where <math>\mathrm{Var}[E] = <E^2> - <E>^2 </math>. When implementing this, the kB term was neglected due to the energy values having units of kB. The script used for this purpose is provided [[DMS3053-7|here]]. The plot of heat capacity per spin versus temperature for all of the lattice sizes considered is presented in ''Figure 7''.

==Locating the Curie temperature==
===Comparison with C++ Data===
The data for the heat capacity generated using the python script prepared in this experiment was compared to that from longer C++ computations - graphs showing this comparison are presented in ''Table 7'' for a range of lattice sizes. The Python code used to produce these graphs is shown [[Mod:DMS3053-8|here]].

Considering these graphs, it is clear that, in general, there is a reasonable correlation between the Python and C++ data; however, some of the data, particularly that for high lattice sizes, shows that the Python computations have not always found the maximum of heat capacity. This correlation would be improved by making computations at the same range of temperatures, but with a smaller gap between the temperatures taken; however, this would substantially increase computation time.
{| class="wikitable center" width=70%
|+ ''Table 7: Graphs of heat capacity (per spin) versus temperature for C++ and Python data''
|- style="text-align:center;"
| [[File:DMS2x2c.png|300px]] || [[File:DMS4x4c.png|300px]] || [[File:DMS8x8c.png|300px]]
|- style="text-align:center;"
| 2x2 || 4x4 || 8x8
|- style="text-align:center;"
| [[File:DMS16x16c.png|300px]] || [[File:DMS32x32c.png|300px]]
|- style="text-align:center;"
| 16x16 || 32x32
|}

===Polynomial Fitting===
[[File:DMS8x8513.png|300px|thumb|right|'''''Figure 8''': Heat capacity (per spin) versus temperature for 8x8 system with two polynomial fits'']]
In order to make use of the C++ data in finding the Curie temperature for the Ising Lattices under consideration, polynomials were fit to the data - the script written for this purpose is shown [[Mod:DMS3053-9|here]]. For this fitting, it was found that a polynomial order of 5 was required to provide a good fit for the 2x2 data - this increased significantly as the lattice size increased. An example fit is shown for the 8x8 system in ''Figure 8'', where the polynomial fit is shown for orders 5 and 13. A consideration of this graph reveals that whilst a polynomial of order 5 may be appropriate for a 2x2 system, it is inadequate for the larger system of 8x8. Whilst an order of 13 substantially improves the polynomial fit, one must, in general, take care with 'overfitting' data.
[[File:Py8x8(13fit).png|300px|thumb|left|'''''Figure 9''': Heat capacity (per spin) versus temperature for Python data for 8x8 system with a 13th order polynomial fit'']]
For comparison, a 13th order polynomial was fitted to the 8x8 Python data previously computed - this is shown in ''Figure 9''. Here, it is evident that for this data, a higher order polynomial is required to obtain a fit comparable to that for the C++ data above.

===Fitting in a Particular Temperature Range===
[[File:DMS8x8peak(3).png|300px|thumb|right|'''''Figure 10''': Heat capacity (per spin) versus temperature for 8x8 system with peak polynomial fit'']]
As was observed in the previous exercise, large polynomial orders are required to fit the C++ data well across the whole temperature range. The python script was modified to that presented [[Mod:DMS3053-10|here]] (this script also contains the python code to compute the maximum heat capacity and temperature at which this occurs for the following exercise), which fits a polynomial only in the region of the maximum heat capacity for the system. An example of such fit is shown in ''Figure 10'' for the 8x8 system. Here, it should be noted that for all of the system sizes studied, a polynomial order of 3 was used - this is a clear improvement compared to the 13th order polynomials used previously.

===Finding the Peak in Heat Capacity===
{| class="wikitable floatright" width=42%
|+ ''Table 8: Lattice sizes and their corresponding Curie temperatures''
! System Size !! Curie Temperature
|- style="text-align:center;"
| 2x2 || 2.53503504
|- style="text-align:center;"
| 4x4 || 2.43843844
|- style="text-align:center;"
| 8x8 || 2.33433433
|- style="text-align:center;"
| 16x16 || 2.30455455
|- style="text-align:center;"
| 32x32 || 2.27752753
|}
[[File:DMSCurieTemperature.png|300px|thumb|left|'''''Figure 11''': Curie temperature vs. 1/(lattice length), with extrapolated linear fit'']]
In order to find the Curie temperature for an infinite Ising Lattice, the Curie temperature for each system size considered was first found (using the script shown in the previous exercise). These temperatures were then saved to a .dat file (whose contents are also showed in ''Table 8'', along with their corresponding lattice sizes. Finally, using the script presented [[Mod:DMS3053-11|here]], a graph of Curie temperature versus the inverse of the lattice length was plotted, according to the equation
::<math>T_{C, L} = \frac{A}{L} + T_{C,\infty}</math>, ''(eq. 10)
where <math>T_{C, L}</math> is the Curie temperature for a lattice with length L and <math>T_{C,\infty}</math> is the Curie temperature for an infinite Ising lattice. Hence, it is clear that the desired Curie temperature must be the y-intercept of the graph shown in ''Figure 11'' (hence the use of extrapolation in the python script). Taking this extrapolated value gives a Curie temperature of 2.271. This value can be compared to the theoretical exact value of 2.27 (J/kB),<ref>D. K. Khudier, N. I. Fawaz, ''Int. Lett. Them. Phys. Astron.'', 2013, '''10''', 201-212. Available from: http://www.ilcpa.pl/wp-content/uploads/2012/11/ILCPA-102-2013-201-2121.pdf</ref> which indicates a good agreement between the value calculated in this investigation and the theoretical exact value. This is surprising given that it would be expected that the polynomial fitting of the data to locate the maximum would contribute a considerable degree of error to the final value.

==References==
<references/>
</div>

Rep:Mod:DMS3053

2015-02-26T10:24:11Z

Ds3012: /* The effect of system size */

'''CMP Programming Experiment - Daniel Spencer, 00736964'''
<div style="text-align: justify">
==Introduction to the Ising Model==
===Minimum energy of the Ising Model===
Using the equation 
::<math>E= - \frac{1}{2} J \sum_i^N \sum_{j\ \in\ \mathrm{neighbours}\left(i\right)} s_i s_j</math> (''eq. 1'') 
the minimum energy of an Ising lattice of <math>D</math> dimensions, with <math>N</math> spins (where each
spin had a value of +1 or -1) and an interaction strength of <math>J</math> was considered. This was achieved first through a consideration of a one-dimensional system with five parallel spins (where the spins are parallel as this corresponds to the minimum energy arrangement of the system). Hence, the energy of this linear system was found to be 
::<math>E_\text{min,1D} = -5J </math>. 
For a linear, one-dimensional system, the number of neigbouring spins is two. The number of neighbours can be determined for two- and three- dimensional systems through a geometric consideration of their structure - the values are presented in ''Table 1''.
{| class="wikitable floatright" width=42%
|+ ''Table 1: Dimension numbers and number of neighbours''
! Number of Dimensions, D !! Number of Neighbours
|- style="text-align:center;"
| 1 || 2
|- style="text-align:center;"
| 2 || 4
|- style="text-align:center;"
| 3 || 6
|- style="text-align:center;"
| D || 2D
|}
These data indicate that the number of neighbours is twice the number of dimensions, for the dimensions considered here. This can be extrapolated to give the general number of neighbours as <math>2D</math>.

For the minimum energy of the system, where all spins are parallel, every combination <math>s_i s_j</math> has a value of 1. Notably, for each value of <math>i</math>, there will be <math>2D</math> neighbour interactions. Ergo, using ''eq. 1'', the general minimum energy can be found to be
::<math>E_\text{min,D} = -DNJ </math> (''eq. 2''). 
To check this equation, it can be applied to the two-dimensional Ising lattice with 25 spins - this gives a value of
::<math>E_\text{min,2D} = -50J </math>, 
which matches with the value predicted from first-principles.

For this D-dimensional system, the multiplicity (i.e. the number of ways of achieving the specified configuration of spins) must be equal to two, as either all of the spins could be aligned 'up' (+1) or 'down' (-1). Using this multiplicity, the entropy of the system can be calculated using the equation
::<math>S = k_B \ln\Omega</math>, (''eq. 3'') 
where Ω is the number of microstates (equal to the multiplicity in this case), which gives a value of <math>k_B \ln2 </math>, or 9.57 x 10-24 J K-1.

===Spin 'flipping'===
[[File:ThirdYearCMPExpt-IsingSketch.png|300px|thumb|right|'' '''Figure 1''': Representation of Ising lattices in one (N=5), two (N=25), and three (N=125) dimensions. +1 and -1 spins are denoted by the red and blue cells respectively. Diagram taken from the lab script.'']]
Using the Ising model, it is also possible to consider a change in state, reflected by a 'flipping' of the direction of one of the lattice spins. For this case, the energy (using ''eq. 1'') can be determined to be
::<math>E'= - \frac{1}{2} J (2DN - 4D - 4D) = 4DJ - DNJ</math>, (''eq. 4'') 
where the additional <math>4D</math> terms arise from the loss of 4D stabilising spin-aligned interactions and the gain of 4D destabilising spins anti-aligned interactions following spin 'flipping'. Using ''eq. 2'' and ''eq. 4'', the change in energy derived from this spin 'flip' can be calculated to be
::<math>\Delta E= 4DJ - DNJ + DNJ = 4DJ</math>. (''eq. 5'') 
For a system with three dimensions (D = 3) and 1000 spins (N = 1000), the system, using ''eq. 5'', was determined to increase in energy by <math>12 J</math>. Notably, this change in energy is independent of the number of spins in the system - it depends only on the number of dimensions and J.

A significant consideration with regards to the spin 'flipping' described here is the accompanying increase in entropy - the driving force for this process. For the scenario describing the change in direction of a single spin, the multiplicity of the system will be <math>2N</math> - this is a consequence of the system prior to 'flipping' having a multiplicity of two (all spins aligned 'up' or 'down'), where now, any one of the spins could flip, adding the factor of N to the multiplicity. Hence, the new entropy can be defined to be
::<math>S' = k_B \ln 2N</math>, (''eq. 6'') 
which allows the change in entropy to be calculated according to ''eq. 7''.
::<math>\Delta S = k_B \ln 2N - k_B \ln2 = k_B \ln N</math> (''eq. 7'') 
For the system described above (D = 3, N = 1000), the change in entropy associated with the spin 'flip' process is therefore <math>k_B ln 1000</math>, which is equal to 9.53 x 10-23 J K-1.

===Magnetisation===
{| class="wikitable floatleft" width=42%
|+ ''Table 2: Ising lattices and magnetisations''
! Ising Lattice !! Magnetisation
|- style="text-align:center;"
| 1D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 2D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 3D at 0 K || 1000 or -1000
|}
''Figure 1'' shows three examples of Ising lattices, with one, two and three dimensions respectively. Using the equation for magnetisation (''eq. 8''), the magnetisations of these systems can be calculated to be those presented in ''Table 2''.
::<math>M= \sum_i s_i</math> (''eq. 8'') 
For the three-dimensional system with 1000 spins at a temperature of 0 K, all of the spins must be aligned either 'up' or 'down', as the entropic increase associated with 'flipped' spins does not provide a driving force at absolute zero - the only factor to consider is that of the energy, which is a minimum when all of the spins are aligned. For this case, the magnetisation could be either 1000 or -1000, depending upon the direction of the spin alignment. From a consideration of the magnetisation values calculated here, it is evident that with all of the spins aligned, the (magnitude of the) magnetisation of the system is at a maximum.

==Calculating the energy and magnetisation==
===Modifying the files===
[[File:DMStest_output2.png|300px|thumb|right|'' '''Figure 2''': Output image from testing IsingLattice.py using Ilcheck.py'']]
In order to use Python to compute the energy and magnetisation for a given two-dimensional Ising lattice, the class IsingLattice was used, where energy() and magnetisation() functions were written to calculate their corresponding properties for a random numpy array of spins (generated using np.random.choice). For this aspect of the experiment, the value of J was assumed to be 1.0, working in reduced units. The Python script developed can be viewed [[Mod:DMS3053-1|here]], including annotations.

===Testing the files===
In order to test the script prepared thus far, the Ilcheck.py script was run, generating the image presented in ''Figure 2''. An examination of this output clearly indicates that the script provides accurate energies and magnetisations for the minimum and maximum energy configurations, along with for an intermediate, random arrangement. Hence, it can be concluded that at the current level, the Python script is functioning as required.

==Introduction to the Monte Carlo simulation==
===Average Energy and Magnetisation===
[[File:DMSILanim3.png|300px|thumb|right|'''''Figure 3''': Animation result from ILanim.py, showing the resting of the system in the minimum energy state'']]
In order to consider the generalisability of the prepared script, it is important to analyse how the script will function for large systems, such as those with 100 spins in the spin array. As each of these spins can be either 'up' or 'down', each spin has two choices. Hence, the number of possible configurations for the system can be written as <math>2^{100}</math>, which has a value of 1.2677 x 1030.

If one considers the sampling of a single configuration to take 1 x 10-9 s, then it is clear that sampling all of these considerations would take a total of 1.2677 x 1021 s (also expressed as 4.017 x 1013 years). From this analysis, it is evident that the sampling of configurations was a significant consideration in the writing of a python script for this task.

In order to account for this, the technique of importance sampling was implemented, using the statistical Boltzmann distribution, <math>\exp(- \Delta E / k_B T)</math>. Note that as the energy computed using the energy() function is in units of kB, this factor is not included in the script.

===Modifying IsingLattice.py to Implement a Monte Carlo Cycle===
[[File:DMSILanim_meta.png|300px|thumb|left|'''''Figure 4''': Animation result from ILanim.py, showing the resting of the system in a meta-stable state'']]
The python script developed at this stage is presented [[Mod:DMS3053-2|here]], accompanied by annotations to explain how the script functions.

===Simulating the Monte Carlo Cycles===
{| class="wikitable floatright" width=42%
|+ ''Table 3: statistics() output for animated system at global minimum configuration (Figure 3)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.70542501728
|- style="text-align:center;"
| <E2> || 3.13520970111
|- style="text-align:center;"
| <M> || -0.829971492744
|- style="text-align:center;"
| <M2> || 0.770986982766
|}
For cases where T < Tc, it would be expected that the system would have a spontaneous magnetisation. When T > Tc, the entropy will be the dominating factor, potentially resulting in the system having a magnetisation of zero.
{| class="wikitable floatright" width=42%
|+ ''Table 4: statistics() output for animated system at meta-stable configuration (Figure 4)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.35076450189
|- style="text-align:center;"
| <E2> || 1.89025801939
|- style="text-align:center;"
| <M> || -0.344104665826
|- style="text-align:center;"
| <M2> || 0.138855365306
|}
Using the presented script and the ILanim.py script, the Monte Carlo cycles can be simulated to view the results on the spin array as the process progresses. Here, the system under consideration was an 8 x 8 spin array, at a temperature of 0.5. ''Figure 3'' shows the typical outcome of the animation, with the system having reached the most stable, minimum energy arrangement. For the result presented here, the output of the statistics() function was that shown in ''Table 3''.

It was also observed that the system could locate a meta-stable state, with large regions of spin 'up' and 'down' spins. An example of such a result is presented in ''Figure 4'' (for which the output data from statistics() is presented in ''Table 4'').

==Accelerating the code==

In order to examine the efficiency of the python script developed thus far, the Iltimetrial.py script was utilised to investigate the time taken to perform 2000 Monte Carlo cycles. This script was modified to the version presented [[Mod:DMS3053-3|here]], which repeats the time measurement a defined number of times, then calculates the average time and the standard error in this average. For the Monte Carlo script prepared previously, the average time for 2000 Monte Carlo cycles was measured to be 5.475804 s and a standard error was calculated to be 0.008325 s, with 100 measurements made using the script.

Evidently, the current script is slow at conducting large numbers of Monte Carlo cycles and hence, a more efficient script was developed using the np.roll, np.multiply and np.sum functions - this is presented [[Mod:DMS3053-4|here]].

After this optimisation of the python script, the Iltimetrial.py script was re-run, giving an average time of 0.291467 s, with a standard error of 0.000156 s. Clearly, this optimised script is substantially faster than that developed previously (approximately 19 times faster).

==The effect of temperature==
===Correcting the averaging code===
As the equilibrium state of the system requires a number of Monte Carlo cycles to be reached, it is evident that the average energies and magnetisations are accounting for values for non-equilibrium arrangements - this was accounted for through a consideration of the number of cycles required to reach equilibrium. For this, the ILfinalframe.py script was used, giving the graphs shown in ''Table 5''. Here, each system was run for 150000 Monte Carlo cycles.
{| class="wikitable center" width=70%
|+ ''Table 5: Graphs of energy and magnetisation versus number of Monte Carlo cycles for different temperatures and system sizes''
! Temperature !! System Size !! Resulting Graphs !! Cycles for Equilibrium
|- style="text-align:center;"
| 0.5 || 4x4 || [[File:DMS0544.png|300px]] || 24
|- style="text-align:center;"
| 0.5 || 8x8 || [[File:DMS0588.png|300px]] || 392
|- style="text-align:center;"
| 0.5 || 16x16 || [[File:DMS051616.png|300px]] || 5549
|- style="text-align:center;"
| 1.0 || 2x2 || [[File:DMS1022.png|300px]] || (0)
|- style="text-align:center;"
| 1.0 || 4x4 || [[File:DMS1044.png|300px]] || 49
|- style="text-align:center;"
| 1.0 || 8x8 || [[File:DMS10882.png|300px]] || 590
|- style="text-align:center;"
| 1.0 || 16x16 || [[File:DMS101616.png|300px]] || ~6300
|- style="text-align:center;"
| 1.0 || 32x32 || [[File:DMS103232.png|300px]] || ~110000
|- style="text-align:center;"
| 2.0 || 4x4 || [[File:DMS2044.png|300px]] || -
|- style="text-align:center;"
| 2.0 || 8x8 || [[File:DMS2088.png|300px]] || -
|}
{| class="wikitable floatright" width=42%
|+ ''Table 6: Number of cycles to be ignored for each system size''
! System Size !! Number of cycles before averaging
|- style="text-align:center;"
| 2x2 || 0
|- style="text-align:center;"
| 4x4 || 100
|- style="text-align:center;"
| 8x8 || 1000
|- style="text-align:center;"
| 16x16 || 8000
|- style="text-align:center;"
| 32x32 || 120000
|}
Analysis of these graphs indicates that at higher temperatures, such as 2.0 (also observed at 1.5), large fluctuations in the energy and magnetisation are observed - these fluctuations are the reason that the average values of the properties must be taken. As the temperature is increased for systems of size 4x4, 8x8 and 16x16, it is clear that the number of cycles required in order to reach equilibrium increases. Hence, for the temperature range to be considered later (0.25 to 5.00), the required number of cycles was overestimated in order to ensure that all measurements were taken whilst the system was in equilibrium. The proposed numbers of cycles to be ignored for each system size are presented in ''Table 6''.

The python script developed up to this point was modified to account for these values by inclusion of a skip_region variable, which defines the number of cycles performed before energies and magnetisations contribute to the self.X values (before averaging occurs). The modified script is presented [[Mod:DMS3053-5|here]].

===Running over a range of temperatures===
[[File:DMS88dat.png|300px|thumb|right|'''''Figure 5''': Average energy and average magnetisation vs. temperature for 8x8 lattice, with error bars'']]
Using the python script modified in the previous exercise, the code can now be used to simulate the 8x8 system at a range of temperatures, using the ILtemperaturerange.py file (shown [[Mod:DMS3053-temprange|here]]). Here, the temperature range of 0.25 to 5.00 was used, with a separation of 0.25 between points, whilst the runtime was set to 10000 (neglecting the property values for the first 1000 cycles). Running this simulation produced the graphs in ''Figure 5'', where error bars computed using standard errors have also been included (these are small as a consequence of small standard errors). From the graph of average energy versus temperature, the phase transition can be observed - this occurs in the region with a gradient that is not close to zero. The data used here (temperature, average energies, average squared-energies, average magnetisations and average squared-magnetisations) was then saved as a numpy array in a new file, 8x8.dat.

==The effect of system size==
[[File:DMSLatticeSizeCombinedPlot.png|300px|thumb|left|'''''Figure 6''': Average energy and average magnetisation (per spins) vs. temperature for multiple lattice sizes'']]
The process conducted for the 8x8 lattice in the previous exercise was then repeated for lattices of sizes 2x2, 4x4, 16x16 and 32x32, with the data saved in .dat files. These files were then accessed, and the average energy and magnetisation data were plotted on one graph for all of the lattices sizes - this was achieved using the script presented [[Mod:DMS3053-6|here]]. The graphs produced in this manner are shown in ''Figure 6''.

A consideration of this graph suggests that in order to capture the long range fluctuations, whilst minimising the computational time required, an 8x8 lattice is likely to be the optimum choice. This is because the graph for this system size is comparable to that for a 32x32 lattice, whilst being faster to compute.

==Determining the heat capacity==
[[File:DMSheatcapacity2.png|300px|thumb|right|'''''Figure 7''': Heat capacity (per spin) versus temperature for different lattice sizes'']]
Using the .dat files previously produced, the heat capacity was calculated for each lattice size using the equation
::<math>C = \frac{\partial E}{\partial T} = \frac{\mathrm{Var}[E]}{k_B T^2}</math>, (''eq. 9'') 
where <math>\mathrm{Var}[E] = <E^2> - <E>^2 </math>. When implementing this, the kB term was neglected due to the energy values having units of kB. The script used for this purpose is provided [[DMS3053-7|here]]. The plot of heat capacity per spin versus temperature for all of the lattice sizes considered is presented in ''Figure 7''.

==Locating the Curie temperature==
===Comparison with C++ Data===
The data for the heat capacity generated using the python script prepared in this experiment was compared to that from longer C++ computations - graphs showing this comparison are presented in ''Table 7'' for a range of lattice sizes. The Python code used to produce these graphs is shown [[Mod:DMS3053-8|here]].

Considering these graphs, it is clear that, in general, there is a reasonable correlation between the Python and C++ data; however, some of the data, particularly that for high lattice sizes, shows that the Python computations have not always found the maximum of heat capacity. This correlation would be improved by making computations at the same range of temperatures, but with a smaller gap between the temperatures taken; however, this would substantially increase computation time.
{| class="wikitable center" width=70%
|+ ''Table 7: Graphs of heat capacity (per spin) versus temperature for C++ and Python data''
|- style="text-align:center;"
| [[File:DMS2x2c.png|300px]] || [[File:DMS4x4c.png|300px]] || [[File:DMS8x8c.png|300px]]
|- style="text-align:center;"
| 2x2 || 4x4 || 8x8
|- style="text-align:center;"
| [[File:DMS16x16c.png|300px]] || [[File:DMS32x32c.png|300px]]
|- style="text-align:center;"
| 16x16 || 32x32
|}

===Polynomial Fitting===
[[File:DMS8x8513.png|300px|thumb|right|'''''Figure 8''': Heat capacity (per spin) versus temperature for 8x8 system with two polynomial fits'']]
In order to make use of the C++ data in finding the Curie temperature for the Ising Lattices under consideration, polynomials were fit to the data - the script written for this purpose is shown [[Mod:DMS3053-9|here]]. For this fitting, it was found that a polynomial order of 5 was required to provide a good fit for the 2x2 data - this increased significantly as the lattice size increased. An example fit is shown for the 8x8 system in ''Figure 8'', where the polynomial fit is shown for orders 5 and 13. A consideration of this graph reveals that whilst a polynomial of order 5 may be appropriate for a 2x2 system, it is inadequate for the larger system of 8x8. Whilst an order of 13 substantially improves the polynomial fit, one must, in general, take care with 'overfitting' data.
[[File:Py8x8(13fit).png|300px|thumb|left|'''''Figure 9''': Heat capacity (per spin) versus temperature for Python data for 8x8 system with a 13th order polynomial fit'']]
For comparison, a 13th order polynomial was fitted to the 8x8 Python data previously computed - this is shown in ''Figure 9''. Here, it is evident that for this data, a higher order polynomial is required to obtain a fit comparable to that for the C++ data above.

===Fitting in a Particular Temperature Range===
[[File:DMS8x8peak(3).png|300px|thumb|right|'''''Figure 10''': Heat capacity (per spin) versus temperature for 8x8 system with peak polynomial fit'']]
As was observed in the previous exercise, large polynomial orders are required to fit the C++ data well across the whole temperature range. The python script was modified to that presented [[Mod:DMS3053-10|here]] (this script also contains the python code to compute the maximum heat capacity and temperature at which this occurs for the following exercise), which fits a polynomial only in the region of the maximum heat capacity for the system. An example of such fit is shown in ''Figure 10'' for the 8x8 system. Here, it should be noted that for all of the system sizes studied, a polynomial order of 3 was used - this is a clear improvement compared to the 13th order polynomials used previously.

===Finding the Peak in Heat Capacity===
{| class="wikitable floatright" width=42%
|+ ''Table 8: Lattice sizes and their corresponding Curie temperatures''
! System Size !! Number of cycles before averaging
|- style="text-align:center;"
| 2x2 || 2.53503504
|- style="text-align:center;"
| 4x4 || 2.43843844
|- style="text-align:center;"
| 8x8 || 2.33433433
|- style="text-align:center;"
| 16x16 || 2.30455455
|- style="text-align:center;"
| 32x32 || 2.27752753
|}
[[File:DMSCurieTemperature.png|300px|thumb|left|'''''Figure 11''': Curie temperature vs. 1/(lattice length), with extrapolated linear fit'']]
In order to find the Curie temperature for an infinite Ising Lattice, the Curie temperature for each system size considered was first found (using the script shown in the previous exercise). These temperatures were then saved to a .dat file (whose contents are also showed in ''Table 8'', along with their corresponding lattice sizes. Finally, using the script presented [[Mod:DMS3053-11|here]], a graph of Curie temperature versus the inverse of the lattice length was plotted, according to the equation
::<math>T_{C, L} = \frac{A}{L} + T_{C,\infty}</math>, ''(eq. 10)
where <math>T_{C, L}</math> is the Curie temperature for a lattice with length L and <math>T_{C,\infty}</math> is the Curie temperature for an infinite Ising lattice. Hence, it is clear that the desired Curie temperature must be the y-intercept of the graph shown in ''Figure 11'' (hence the use of extrapolation in the python script). Taking this extrapolated value gives a Curie temperature of 2.271. This value can be compared to the theoretical exact value of 2.27,<ref>D. K. Khudier, N. I. Fawaz, ''Int. Lett. Them. Phys. Astron.'', 2013, '''10''', 201-212. Available from: http://www.ilcpa.pl/wp-content/uploads/2012/11/ILCPA-102-2013-201-2121.pdf</ref> which indicates a good agreement between the value calculated in this investigation and the theoretical exact value. This is surprising given that it would be expected that the polynomial fitting of the data to locate the maximum would contribute a considerable degree of error to the final value.

==References==
<references/>
</div>

Rep:Mod:DMS3053

2015-02-26T10:23:35Z

Ds3012: /* Simulating the Monte Carlo Cycles */

'''CMP Programming Experiment - Daniel Spencer, 00736964'''
<div style="text-align: justify">
==Introduction to the Ising Model==
===Minimum energy of the Ising Model===
Using the equation 
::<math>E= - \frac{1}{2} J \sum_i^N \sum_{j\ \in\ \mathrm{neighbours}\left(i\right)} s_i s_j</math> (''eq. 1'') 
the minimum energy of an Ising lattice of <math>D</math> dimensions, with <math>N</math> spins (where each
spin had a value of +1 or -1) and an interaction strength of <math>J</math> was considered. This was achieved first through a consideration of a one-dimensional system with five parallel spins (where the spins are parallel as this corresponds to the minimum energy arrangement of the system). Hence, the energy of this linear system was found to be 
::<math>E_\text{min,1D} = -5J </math>. 
For a linear, one-dimensional system, the number of neigbouring spins is two. The number of neighbours can be determined for two- and three- dimensional systems through a geometric consideration of their structure - the values are presented in ''Table 1''.
{| class="wikitable floatright" width=42%
|+ ''Table 1: Dimension numbers and number of neighbours''
! Number of Dimensions, D !! Number of Neighbours
|- style="text-align:center;"
| 1 || 2
|- style="text-align:center;"
| 2 || 4
|- style="text-align:center;"
| 3 || 6
|- style="text-align:center;"
| D || 2D
|}
These data indicate that the number of neighbours is twice the number of dimensions, for the dimensions considered here. This can be extrapolated to give the general number of neighbours as <math>2D</math>.

For the minimum energy of the system, where all spins are parallel, every combination <math>s_i s_j</math> has a value of 1. Notably, for each value of <math>i</math>, there will be <math>2D</math> neighbour interactions. Ergo, using ''eq. 1'', the general minimum energy can be found to be
::<math>E_\text{min,D} = -DNJ </math> (''eq. 2''). 
To check this equation, it can be applied to the two-dimensional Ising lattice with 25 spins - this gives a value of
::<math>E_\text{min,2D} = -50J </math>, 
which matches with the value predicted from first-principles.

For this D-dimensional system, the multiplicity (i.e. the number of ways of achieving the specified configuration of spins) must be equal to two, as either all of the spins could be aligned 'up' (+1) or 'down' (-1). Using this multiplicity, the entropy of the system can be calculated using the equation
::<math>S = k_B \ln\Omega</math>, (''eq. 3'') 
where Ω is the number of microstates (equal to the multiplicity in this case), which gives a value of <math>k_B \ln2 </math>, or 9.57 x 10-24 J K-1.

===Spin 'flipping'===
[[File:ThirdYearCMPExpt-IsingSketch.png|300px|thumb|right|'' '''Figure 1''': Representation of Ising lattices in one (N=5), two (N=25), and three (N=125) dimensions. +1 and -1 spins are denoted by the red and blue cells respectively. Diagram taken from the lab script.'']]
Using the Ising model, it is also possible to consider a change in state, reflected by a 'flipping' of the direction of one of the lattice spins. For this case, the energy (using ''eq. 1'') can be determined to be
::<math>E'= - \frac{1}{2} J (2DN - 4D - 4D) = 4DJ - DNJ</math>, (''eq. 4'') 
where the additional <math>4D</math> terms arise from the loss of 4D stabilising spin-aligned interactions and the gain of 4D destabilising spins anti-aligned interactions following spin 'flipping'. Using ''eq. 2'' and ''eq. 4'', the change in energy derived from this spin 'flip' can be calculated to be
::<math>\Delta E= 4DJ - DNJ + DNJ = 4DJ</math>. (''eq. 5'') 
For a system with three dimensions (D = 3) and 1000 spins (N = 1000), the system, using ''eq. 5'', was determined to increase in energy by <math>12 J</math>. Notably, this change in energy is independent of the number of spins in the system - it depends only on the number of dimensions and J.

A significant consideration with regards to the spin 'flipping' described here is the accompanying increase in entropy - the driving force for this process. For the scenario describing the change in direction of a single spin, the multiplicity of the system will be <math>2N</math> - this is a consequence of the system prior to 'flipping' having a multiplicity of two (all spins aligned 'up' or 'down'), where now, any one of the spins could flip, adding the factor of N to the multiplicity. Hence, the new entropy can be defined to be
::<math>S' = k_B \ln 2N</math>, (''eq. 6'') 
which allows the change in entropy to be calculated according to ''eq. 7''.
::<math>\Delta S = k_B \ln 2N - k_B \ln2 = k_B \ln N</math> (''eq. 7'') 
For the system described above (D = 3, N = 1000), the change in entropy associated with the spin 'flip' process is therefore <math>k_B ln 1000</math>, which is equal to 9.53 x 10-23 J K-1.

===Magnetisation===
{| class="wikitable floatleft" width=42%
|+ ''Table 2: Ising lattices and magnetisations''
! Ising Lattice !! Magnetisation
|- style="text-align:center;"
| 1D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 2D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 3D at 0 K || 1000 or -1000
|}
''Figure 1'' shows three examples of Ising lattices, with one, two and three dimensions respectively. Using the equation for magnetisation (''eq. 8''), the magnetisations of these systems can be calculated to be those presented in ''Table 2''.
::<math>M= \sum_i s_i</math> (''eq. 8'') 
For the three-dimensional system with 1000 spins at a temperature of 0 K, all of the spins must be aligned either 'up' or 'down', as the entropic increase associated with 'flipped' spins does not provide a driving force at absolute zero - the only factor to consider is that of the energy, which is a minimum when all of the spins are aligned. For this case, the magnetisation could be either 1000 or -1000, depending upon the direction of the spin alignment. From a consideration of the magnetisation values calculated here, it is evident that with all of the spins aligned, the (magnitude of the) magnetisation of the system is at a maximum.

==Calculating the energy and magnetisation==
===Modifying the files===
[[File:DMStest_output2.png|300px|thumb|right|'' '''Figure 2''': Output image from testing IsingLattice.py using Ilcheck.py'']]
In order to use Python to compute the energy and magnetisation for a given two-dimensional Ising lattice, the class IsingLattice was used, where energy() and magnetisation() functions were written to calculate their corresponding properties for a random numpy array of spins (generated using np.random.choice). For this aspect of the experiment, the value of J was assumed to be 1.0, working in reduced units. The Python script developed can be viewed [[Mod:DMS3053-1|here]], including annotations.

===Testing the files===
In order to test the script prepared thus far, the Ilcheck.py script was run, generating the image presented in ''Figure 2''. An examination of this output clearly indicates that the script provides accurate energies and magnetisations for the minimum and maximum energy configurations, along with for an intermediate, random arrangement. Hence, it can be concluded that at the current level, the Python script is functioning as required.

==Introduction to the Monte Carlo simulation==
===Average Energy and Magnetisation===
[[File:DMSILanim3.png|300px|thumb|right|'''''Figure 3''': Animation result from ILanim.py, showing the resting of the system in the minimum energy state'']]
In order to consider the generalisability of the prepared script, it is important to analyse how the script will function for large systems, such as those with 100 spins in the spin array. As each of these spins can be either 'up' or 'down', each spin has two choices. Hence, the number of possible configurations for the system can be written as <math>2^{100}</math>, which has a value of 1.2677 x 1030.

If one considers the sampling of a single configuration to take 1 x 10-9 s, then it is clear that sampling all of these considerations would take a total of 1.2677 x 1021 s (also expressed as 4.017 x 1013 years). From this analysis, it is evident that the sampling of configurations was a significant consideration in the writing of a python script for this task.

In order to account for this, the technique of importance sampling was implemented, using the statistical Boltzmann distribution, <math>\exp(- \Delta E / k_B T)</math>. Note that as the energy computed using the energy() function is in units of kB, this factor is not included in the script.

===Modifying IsingLattice.py to Implement a Monte Carlo Cycle===
[[File:DMSILanim_meta.png|300px|thumb|left|'''''Figure 4''': Animation result from ILanim.py, showing the resting of the system in a meta-stable state'']]
The python script developed at this stage is presented [[Mod:DMS3053-2|here]], accompanied by annotations to explain how the script functions.

===Simulating the Monte Carlo Cycles===
{| class="wikitable floatright" width=42%
|+ ''Table 3: statistics() output for animated system at global minimum configuration (Figure 3)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.70542501728
|- style="text-align:center;"
| <E2> || 3.13520970111
|- style="text-align:center;"
| <M> || -0.829971492744
|- style="text-align:center;"
| <M2> || 0.770986982766
|}
For cases where T < Tc, it would be expected that the system would have a spontaneous magnetisation. When T > Tc, the entropy will be the dominating factor, potentially resulting in the system having a magnetisation of zero.
{| class="wikitable floatright" width=42%
|+ ''Table 4: statistics() output for animated system at meta-stable configuration (Figure 4)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.35076450189
|- style="text-align:center;"
| <E2> || 1.89025801939
|- style="text-align:center;"
| <M> || -0.344104665826
|- style="text-align:center;"
| <M2> || 0.138855365306
|}
Using the presented script and the ILanim.py script, the Monte Carlo cycles can be simulated to view the results on the spin array as the process progresses. Here, the system under consideration was an 8 x 8 spin array, at a temperature of 0.5. ''Figure 3'' shows the typical outcome of the animation, with the system having reached the most stable, minimum energy arrangement. For the result presented here, the output of the statistics() function was that shown in ''Table 3''.

It was also observed that the system could locate a meta-stable state, with large regions of spin 'up' and 'down' spins. An example of such a result is presented in ''Figure 4'' (for which the output data from statistics() is presented in ''Table 4'').

==Accelerating the code==

In order to examine the efficiency of the python script developed thus far, the Iltimetrial.py script was utilised to investigate the time taken to perform 2000 Monte Carlo cycles. This script was modified to the version presented [[Mod:DMS3053-3|here]], which repeats the time measurement a defined number of times, then calculates the average time and the standard error in this average. For the Monte Carlo script prepared previously, the average time for 2000 Monte Carlo cycles was measured to be 5.475804 s and a standard error was calculated to be 0.008325 s, with 100 measurements made using the script.

Evidently, the current script is slow at conducting large numbers of Monte Carlo cycles and hence, a more efficient script was developed using the np.roll, np.multiply and np.sum functions - this is presented [[Mod:DMS3053-4|here]].

After this optimisation of the python script, the Iltimetrial.py script was re-run, giving an average time of 0.291467 s, with a standard error of 0.000156 s. Clearly, this optimised script is substantially faster than that developed previously (approximately 19 times faster).

==The effect of temperature==
===Correcting the averaging code===
As the equilibrium state of the system requires a number of Monte Carlo cycles to be reached, it is evident that the average energies and magnetisations are accounting for values for non-equilibrium arrangements - this was accounted for through a consideration of the number of cycles required to reach equilibrium. For this, the ILfinalframe.py script was used, giving the graphs shown in ''Table 5''. Here, each system was run for 150000 Monte Carlo cycles.
{| class="wikitable center" width=70%
|+ ''Table 5: Graphs of energy and magnetisation versus number of Monte Carlo cycles for different temperatures and system sizes''
! Temperature !! System Size !! Resulting Graphs !! Cycles for Equilibrium
|- style="text-align:center;"
| 0.5 || 4x4 || [[File:DMS0544.png|300px]] || 24
|- style="text-align:center;"
| 0.5 || 8x8 || [[File:DMS0588.png|300px]] || 392
|- style="text-align:center;"
| 0.5 || 16x16 || [[File:DMS051616.png|300px]] || 5549
|- style="text-align:center;"
| 1.0 || 2x2 || [[File:DMS1022.png|300px]] || (0)
|- style="text-align:center;"
| 1.0 || 4x4 || [[File:DMS1044.png|300px]] || 49
|- style="text-align:center;"
| 1.0 || 8x8 || [[File:DMS10882.png|300px]] || 590
|- style="text-align:center;"
| 1.0 || 16x16 || [[File:DMS101616.png|300px]] || ~6300
|- style="text-align:center;"
| 1.0 || 32x32 || [[File:DMS103232.png|300px]] || ~110000
|- style="text-align:center;"
| 2.0 || 4x4 || [[File:DMS2044.png|300px]] || -
|- style="text-align:center;"
| 2.0 || 8x8 || [[File:DMS2088.png|300px]] || -
|}
{| class="wikitable floatright" width=42%
|+ ''Table 6: Number of cycles to be ignored for each system size''
! System Size !! Number of cycles before averaging
|- style="text-align:center;"
| 2x2 || 0
|- style="text-align:center;"
| 4x4 || 100
|- style="text-align:center;"
| 8x8 || 1000
|- style="text-align:center;"
| 16x16 || 8000
|- style="text-align:center;"
| 32x32 || 120000
|}
Analysis of these graphs indicates that at higher temperatures, such as 2.0 (also observed at 1.5), large fluctuations in the energy and magnetisation are observed - these fluctuations are the reason that the average values of the properties must be taken. As the temperature is increased for systems of size 4x4, 8x8 and 16x16, it is clear that the number of cycles required in order to reach equilibrium increases. Hence, for the temperature range to be considered later (0.25 to 5.00), the required number of cycles was overestimated in order to ensure that all measurements were taken whilst the system was in equilibrium. The proposed numbers of cycles to be ignored for each system size are presented in ''Table 6''.

The python script developed up to this point was modified to account for these values by inclusion of a skip_region variable, which defines the number of cycles performed before energies and magnetisations contribute to the self.X values (before averaging occurs). The modified script is presented [[Mod:DMS3053-5|here]].

===Running over a range of temperatures===
[[File:DMS88dat.png|300px|thumb|right|'''''Figure 5''': Average energy and average magnetisation vs. temperature for 8x8 lattice, with error bars'']]
Using the python script modified in the previous exercise, the code can now be used to simulate the 8x8 system at a range of temperatures, using the ILtemperaturerange.py file (shown [[Mod:DMS3053-temprange|here]]). Here, the temperature range of 0.25 to 5.00 was used, with a separation of 0.25 between points, whilst the runtime was set to 10000 (neglecting the property values for the first 1000 cycles). Running this simulation produced the graphs in ''Figure 5'', where error bars computed using standard errors have also been included (these are small as a consequence of small standard errors). From the graph of average energy versus temperature, the phase transition can be observed - this occurs in the region with a gradient that is not close to zero. The data used here (temperature, average energies, average squared-energies, average magnetisations and average squared-magnetisations) was then saved as a numpy array in a new file, 8x8.dat.

==The effect of system size==
[[File:DMSLatticeSizeCombinedPlot.png|300px|thumb|right|'''''Figure 6''': Average energy and average magnetisation (per spins) vs. temperature for multiple lattice sizes'']]
The process conducted for the 8x8 lattice in the previous exercise was then repeated for lattices of sizes 2x2, 4x4, 16x16 and 32x32, with the data saved in .dat files. These files were then accessed, and the average energy and magnetisation data were plotted on one graph for all of the lattices sizes - this was achieved using the script presented [[Mod:DMS3053-6|here]]. The graphs produced in this manner are shown in ''Figure 6''.

A consideration of this graph suggests that in order to capture the long range fluctuations, whilst minimising the computational time required, an 8x8 lattice is likely to be the optimum choice. This is because the graph for this system size is comparable to that for a 32x32 lattice, whilst being faster to compute.

==Determining the heat capacity==
[[File:DMSheatcapacity2.png|300px|thumb|right|'''''Figure 7''': Heat capacity (per spin) versus temperature for different lattice sizes'']]
Using the .dat files previously produced, the heat capacity was calculated for each lattice size using the equation
::<math>C = \frac{\partial E}{\partial T} = \frac{\mathrm{Var}[E]}{k_B T^2}</math>, (''eq. 9'') 
where <math>\mathrm{Var}[E] = <E^2> - <E>^2 </math>. When implementing this, the kB term was neglected due to the energy values having units of kB. The script used for this purpose is provided [[DMS3053-7|here]]. The plot of heat capacity per spin versus temperature for all of the lattice sizes considered is presented in ''Figure 7''.

==Locating the Curie temperature==
===Comparison with C++ Data===
The data for the heat capacity generated using the python script prepared in this experiment was compared to that from longer C++ computations - graphs showing this comparison are presented in ''Table 7'' for a range of lattice sizes. The Python code used to produce these graphs is shown [[Mod:DMS3053-8|here]].

Considering these graphs, it is clear that, in general, there is a reasonable correlation between the Python and C++ data; however, some of the data, particularly that for high lattice sizes, shows that the Python computations have not always found the maximum of heat capacity. This correlation would be improved by making computations at the same range of temperatures, but with a smaller gap between the temperatures taken; however, this would substantially increase computation time.
{| class="wikitable center" width=70%
|+ ''Table 7: Graphs of heat capacity (per spin) versus temperature for C++ and Python data''
|- style="text-align:center;"
| [[File:DMS2x2c.png|300px]] || [[File:DMS4x4c.png|300px]] || [[File:DMS8x8c.png|300px]]
|- style="text-align:center;"
| 2x2 || 4x4 || 8x8
|- style="text-align:center;"
| [[File:DMS16x16c.png|300px]] || [[File:DMS32x32c.png|300px]]
|- style="text-align:center;"
| 16x16 || 32x32
|}

===Polynomial Fitting===
[[File:DMS8x8513.png|300px|thumb|right|'''''Figure 8''': Heat capacity (per spin) versus temperature for 8x8 system with two polynomial fits'']]
In order to make use of the C++ data in finding the Curie temperature for the Ising Lattices under consideration, polynomials were fit to the data - the script written for this purpose is shown [[Mod:DMS3053-9|here]]. For this fitting, it was found that a polynomial order of 5 was required to provide a good fit for the 2x2 data - this increased significantly as the lattice size increased. An example fit is shown for the 8x8 system in ''Figure 8'', where the polynomial fit is shown for orders 5 and 13. A consideration of this graph reveals that whilst a polynomial of order 5 may be appropriate for a 2x2 system, it is inadequate for the larger system of 8x8. Whilst an order of 13 substantially improves the polynomial fit, one must, in general, take care with 'overfitting' data.
[[File:Py8x8(13fit).png|300px|thumb|left|'''''Figure 9''': Heat capacity (per spin) versus temperature for Python data for 8x8 system with a 13th order polynomial fit'']]
For comparison, a 13th order polynomial was fitted to the 8x8 Python data previously computed - this is shown in ''Figure 9''. Here, it is evident that for this data, a higher order polynomial is required to obtain a fit comparable to that for the C++ data above.

===Fitting in a Particular Temperature Range===
[[File:DMS8x8peak(3).png|300px|thumb|right|'''''Figure 10''': Heat capacity (per spin) versus temperature for 8x8 system with peak polynomial fit'']]
As was observed in the previous exercise, large polynomial orders are required to fit the C++ data well across the whole temperature range. The python script was modified to that presented [[Mod:DMS3053-10|here]] (this script also contains the python code to compute the maximum heat capacity and temperature at which this occurs for the following exercise), which fits a polynomial only in the region of the maximum heat capacity for the system. An example of such fit is shown in ''Figure 10'' for the 8x8 system. Here, it should be noted that for all of the system sizes studied, a polynomial order of 3 was used - this is a clear improvement compared to the 13th order polynomials used previously.

===Finding the Peak in Heat Capacity===
{| class="wikitable floatright" width=42%
|+ ''Table 8: Lattice sizes and their corresponding Curie temperatures''
! System Size !! Number of cycles before averaging
|- style="text-align:center;"
| 2x2 || 2.53503504
|- style="text-align:center;"
| 4x4 || 2.43843844
|- style="text-align:center;"
| 8x8 || 2.33433433
|- style="text-align:center;"
| 16x16 || 2.30455455
|- style="text-align:center;"
| 32x32 || 2.27752753
|}
[[File:DMSCurieTemperature.png|300px|thumb|left|'''''Figure 11''': Curie temperature vs. 1/(lattice length), with extrapolated linear fit'']]
In order to find the Curie temperature for an infinite Ising Lattice, the Curie temperature for each system size considered was first found (using the script shown in the previous exercise). These temperatures were then saved to a .dat file (whose contents are also showed in ''Table 8'', along with their corresponding lattice sizes. Finally, using the script presented [[Mod:DMS3053-11|here]], a graph of Curie temperature versus the inverse of the lattice length was plotted, according to the equation
::<math>T_{C, L} = \frac{A}{L} + T_{C,\infty}</math>, ''(eq. 10)
where <math>T_{C, L}</math> is the Curie temperature for a lattice with length L and <math>T_{C,\infty}</math> is the Curie temperature for an infinite Ising lattice. Hence, it is clear that the desired Curie temperature must be the y-intercept of the graph shown in ''Figure 11'' (hence the use of extrapolation in the python script). Taking this extrapolated value gives a Curie temperature of 2.271. This value can be compared to the theoretical exact value of 2.27,<ref>D. K. Khudier, N. I. Fawaz, ''Int. Lett. Them. Phys. Astron.'', 2013, '''10''', 201-212. Available from: http://www.ilcpa.pl/wp-content/uploads/2012/11/ILCPA-102-2013-201-2121.pdf</ref> which indicates a good agreement between the value calculated in this investigation and the theoretical exact value. This is surprising given that it would be expected that the polynomial fitting of the data to locate the maximum would contribute a considerable degree of error to the final value.

==References==
<references/>
</div>

Rep:Mod:DMS3053

2015-02-26T10:21:35Z

Ds3012: /* Simulating the Monte Carlo Cycles */

'''CMP Programming Experiment - Daniel Spencer, 00736964'''
<div style="text-align: justify">
==Introduction to the Ising Model==
===Minimum energy of the Ising Model===
Using the equation 
::<math>E= - \frac{1}{2} J \sum_i^N \sum_{j\ \in\ \mathrm{neighbours}\left(i\right)} s_i s_j</math> (''eq. 1'') 
the minimum energy of an Ising lattice of <math>D</math> dimensions, with <math>N</math> spins (where each
spin had a value of +1 or -1) and an interaction strength of <math>J</math> was considered. This was achieved first through a consideration of a one-dimensional system with five parallel spins (where the spins are parallel as this corresponds to the minimum energy arrangement of the system). Hence, the energy of this linear system was found to be 
::<math>E_\text{min,1D} = -5J </math>. 
For a linear, one-dimensional system, the number of neigbouring spins is two. The number of neighbours can be determined for two- and three- dimensional systems through a geometric consideration of their structure - the values are presented in ''Table 1''.
{| class="wikitable floatright" width=42%
|+ ''Table 1: Dimension numbers and number of neighbours''
! Number of Dimensions, D !! Number of Neighbours
|- style="text-align:center;"
| 1 || 2
|- style="text-align:center;"
| 2 || 4
|- style="text-align:center;"
| 3 || 6
|- style="text-align:center;"
| D || 2D
|}
These data indicate that the number of neighbours is twice the number of dimensions, for the dimensions considered here. This can be extrapolated to give the general number of neighbours as <math>2D</math>.

For the minimum energy of the system, where all spins are parallel, every combination <math>s_i s_j</math> has a value of 1. Notably, for each value of <math>i</math>, there will be <math>2D</math> neighbour interactions. Ergo, using ''eq. 1'', the general minimum energy can be found to be
::<math>E_\text{min,D} = -DNJ </math> (''eq. 2''). 
To check this equation, it can be applied to the two-dimensional Ising lattice with 25 spins - this gives a value of
::<math>E_\text{min,2D} = -50J </math>, 
which matches with the value predicted from first-principles.

For this D-dimensional system, the multiplicity (i.e. the number of ways of achieving the specified configuration of spins) must be equal to two, as either all of the spins could be aligned 'up' (+1) or 'down' (-1). Using this multiplicity, the entropy of the system can be calculated using the equation
::<math>S = k_B \ln\Omega</math>, (''eq. 3'') 
where Ω is the number of microstates (equal to the multiplicity in this case), which gives a value of <math>k_B \ln2 </math>, or 9.57 x 10-24 J K-1.

===Spin 'flipping'===
[[File:ThirdYearCMPExpt-IsingSketch.png|300px|thumb|right|'' '''Figure 1''': Representation of Ising lattices in one (N=5), two (N=25), and three (N=125) dimensions. +1 and -1 spins are denoted by the red and blue cells respectively. Diagram taken from the lab script.'']]
Using the Ising model, it is also possible to consider a change in state, reflected by a 'flipping' of the direction of one of the lattice spins. For this case, the energy (using ''eq. 1'') can be determined to be
::<math>E'= - \frac{1}{2} J (2DN - 4D - 4D) = 4DJ - DNJ</math>, (''eq. 4'') 
where the additional <math>4D</math> terms arise from the loss of 4D stabilising spin-aligned interactions and the gain of 4D destabilising spins anti-aligned interactions following spin 'flipping'. Using ''eq. 2'' and ''eq. 4'', the change in energy derived from this spin 'flip' can be calculated to be
::<math>\Delta E= 4DJ - DNJ + DNJ = 4DJ</math>. (''eq. 5'') 
For a system with three dimensions (D = 3) and 1000 spins (N = 1000), the system, using ''eq. 5'', was determined to increase in energy by <math>12 J</math>. Notably, this change in energy is independent of the number of spins in the system - it depends only on the number of dimensions and J.

A significant consideration with regards to the spin 'flipping' described here is the accompanying increase in entropy - the driving force for this process. For the scenario describing the change in direction of a single spin, the multiplicity of the system will be <math>2N</math> - this is a consequence of the system prior to 'flipping' having a multiplicity of two (all spins aligned 'up' or 'down'), where now, any one of the spins could flip, adding the factor of N to the multiplicity. Hence, the new entropy can be defined to be
::<math>S' = k_B \ln 2N</math>, (''eq. 6'') 
which allows the change in entropy to be calculated according to ''eq. 7''.
::<math>\Delta S = k_B \ln 2N - k_B \ln2 = k_B \ln N</math> (''eq. 7'') 
For the system described above (D = 3, N = 1000), the change in entropy associated with the spin 'flip' process is therefore <math>k_B ln 1000</math>, which is equal to 9.53 x 10-23 J K-1.

===Magnetisation===
{| class="wikitable floatleft" width=42%
|+ ''Table 2: Ising lattices and magnetisations''
! Ising Lattice !! Magnetisation
|- style="text-align:center;"
| 1D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 2D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 3D at 0 K || 1000 or -1000
|}
''Figure 1'' shows three examples of Ising lattices, with one, two and three dimensions respectively. Using the equation for magnetisation (''eq. 8''), the magnetisations of these systems can be calculated to be those presented in ''Table 2''.
::<math>M= \sum_i s_i</math> (''eq. 8'') 
For the three-dimensional system with 1000 spins at a temperature of 0 K, all of the spins must be aligned either 'up' or 'down', as the entropic increase associated with 'flipped' spins does not provide a driving force at absolute zero - the only factor to consider is that of the energy, which is a minimum when all of the spins are aligned. For this case, the magnetisation could be either 1000 or -1000, depending upon the direction of the spin alignment. From a consideration of the magnetisation values calculated here, it is evident that with all of the spins aligned, the (magnitude of the) magnetisation of the system is at a maximum.

==Calculating the energy and magnetisation==
===Modifying the files===
[[File:DMStest_output2.png|300px|thumb|right|'' '''Figure 2''': Output image from testing IsingLattice.py using Ilcheck.py'']]
In order to use Python to compute the energy and magnetisation for a given two-dimensional Ising lattice, the class IsingLattice was used, where energy() and magnetisation() functions were written to calculate their corresponding properties for a random numpy array of spins (generated using np.random.choice). For this aspect of the experiment, the value of J was assumed to be 1.0, working in reduced units. The Python script developed can be viewed [[Mod:DMS3053-1|here]], including annotations.

===Testing the files===
In order to test the script prepared thus far, the Ilcheck.py script was run, generating the image presented in ''Figure 2''. An examination of this output clearly indicates that the script provides accurate energies and magnetisations for the minimum and maximum energy configurations, along with for an intermediate, random arrangement. Hence, it can be concluded that at the current level, the Python script is functioning as required.

==Introduction to the Monte Carlo simulation==
===Average Energy and Magnetisation===
[[File:DMSILanim3.png|300px|thumb|right|'''''Figure 3''': Animation result from ILanim.py, showing the resting of the system in the minimum energy state'']]
In order to consider the generalisability of the prepared script, it is important to analyse how the script will function for large systems, such as those with 100 spins in the spin array. As each of these spins can be either 'up' or 'down', each spin has two choices. Hence, the number of possible configurations for the system can be written as <math>2^{100}</math>, which has a value of 1.2677 x 1030.

If one considers the sampling of a single configuration to take 1 x 10-9 s, then it is clear that sampling all of these considerations would take a total of 1.2677 x 1021 s (also expressed as 4.017 x 1013 years). From this analysis, it is evident that the sampling of configurations was a significant consideration in the writing of a python script for this task.

In order to account for this, the technique of importance sampling was implemented, using the statistical Boltzmann distribution, <math>\exp(- \Delta E / k_B T)</math>. Note that as the energy computed using the energy() function is in units of kB, this factor is not included in the script.

===Modifying IsingLattice.py to Implement a Monte Carlo Cycle===
[[File:DMSILanim_meta.png|300px|thumb|left|'''''Figure 4''': Animation result from ILanim.py, showing the resting of the system in a meta-stable state'']]
The python script developed at this stage is presented [[Mod:DMS3053-2|here]], accompanied by annotations to explain how the script functions.

===Simulating the Monte Carlo Cycles===
{| class="wikitable floatright" width=42%
|+ ''Table 3: statistics() output for animated system at global minimum configuration (Figure 3)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.70542501728
|- style="text-align:center;"
| <E2> || 3.13520970111
|- style="text-align:center;"
| <M> || -0.829971492744
|- style="text-align:center;"
| <M2> || 0.770986982766
|}
For cases where T < Tc, it would be expected that the system would have a spontaneous magnetisation. When T > Tc, the entropy will be the dominating factor, potentially resulting in the system having a magnetisation of zero.
{| class="wikitable floatleft" width=42%
|+ ''Table 4: statistics() output for animated system at meta-stable configuration (Figure 4)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.35076450189
|- style="text-align:center;"
| <E2> || 1.89025801939
|- style="text-align:center;"
| <M> || -0.344104665826
|- style="text-align:center;"
| <M2> || 0.138855365306
|}
Using the presented script and the ILanim.py script, the Monte Carlo cycles can be simulated to view the results on the spin array as the process progresses. Here, the system under consideration was an 8 x 8 spin array, at a temperature of 0.5. ''Figure 3'' shows the typical outcome of the animation, with the system having reached the most stable, minimum energy arrangement. For the result presented here, the output of the statistics() function was that shown in ''Table 3''.

It was also observed that the system could locate a meta-stable state, with large regions of spin 'up' and 'down' spins. An example of such a result is presented in ''Figure 4'' (for which the output data from statistics() is presented in ''Table 4'').

==Accelerating the code==

In order to examine the efficiency of the python script developed thus far, the Iltimetrial.py script was utilised to investigate the time taken to perform 2000 Monte Carlo cycles. This script was modified to the version presented [[Mod:DMS3053-3|here]], which repeats the time measurement a defined number of times, then calculates the average time and the standard error in this average. For the Monte Carlo script prepared previously, the average time for 2000 Monte Carlo cycles was measured to be 5.475804 s and a standard error was calculated to be 0.008325 s, with 100 measurements made using the script.

Evidently, the current script is slow at conducting large numbers of Monte Carlo cycles and hence, a more efficient script was developed using the np.roll, np.multiply and np.sum functions - this is presented [[Mod:DMS3053-4|here]].

After this optimisation of the python script, the Iltimetrial.py script was re-run, giving an average time of 0.291467 s, with a standard error of 0.000156 s. Clearly, this optimised script is substantially faster than that developed previously (approximately 19 times faster).

==The effect of temperature==
===Correcting the averaging code===
As the equilibrium state of the system requires a number of Monte Carlo cycles to be reached, it is evident that the average energies and magnetisations are accounting for values for non-equilibrium arrangements - this was accounted for through a consideration of the number of cycles required to reach equilibrium. For this, the ILfinalframe.py script was used, giving the graphs shown in ''Table 5''. Here, each system was run for 150000 Monte Carlo cycles.
{| class="wikitable center" width=70%
|+ ''Table 5: Graphs of energy and magnetisation versus number of Monte Carlo cycles for different temperatures and system sizes''
! Temperature !! System Size !! Resulting Graphs !! Cycles for Equilibrium
|- style="text-align:center;"
| 0.5 || 4x4 || [[File:DMS0544.png|300px]] || 24
|- style="text-align:center;"
| 0.5 || 8x8 || [[File:DMS0588.png|300px]] || 392
|- style="text-align:center;"
| 0.5 || 16x16 || [[File:DMS051616.png|300px]] || 5549
|- style="text-align:center;"
| 1.0 || 2x2 || [[File:DMS1022.png|300px]] || (0)
|- style="text-align:center;"
| 1.0 || 4x4 || [[File:DMS1044.png|300px]] || 49
|- style="text-align:center;"
| 1.0 || 8x8 || [[File:DMS10882.png|300px]] || 590
|- style="text-align:center;"
| 1.0 || 16x16 || [[File:DMS101616.png|300px]] || ~6300
|- style="text-align:center;"
| 1.0 || 32x32 || [[File:DMS103232.png|300px]] || ~110000
|- style="text-align:center;"
| 2.0 || 4x4 || [[File:DMS2044.png|300px]] || -
|- style="text-align:center;"
| 2.0 || 8x8 || [[File:DMS2088.png|300px]] || -
|}
{| class="wikitable floatright" width=42%
|+ ''Table 6: Number of cycles to be ignored for each system size''
! System Size !! Number of cycles before averaging
|- style="text-align:center;"
| 2x2 || 0
|- style="text-align:center;"
| 4x4 || 100
|- style="text-align:center;"
| 8x8 || 1000
|- style="text-align:center;"
| 16x16 || 8000
|- style="text-align:center;"
| 32x32 || 120000
|}
Analysis of these graphs indicates that at higher temperatures, such as 2.0 (also observed at 1.5), large fluctuations in the energy and magnetisation are observed - these fluctuations are the reason that the average values of the properties must be taken. As the temperature is increased for systems of size 4x4, 8x8 and 16x16, it is clear that the number of cycles required in order to reach equilibrium increases. Hence, for the temperature range to be considered later (0.25 to 5.00), the required number of cycles was overestimated in order to ensure that all measurements were taken whilst the system was in equilibrium. The proposed numbers of cycles to be ignored for each system size are presented in ''Table 6''.

The python script developed up to this point was modified to account for these values by inclusion of a skip_region variable, which defines the number of cycles performed before energies and magnetisations contribute to the self.X values (before averaging occurs). The modified script is presented [[Mod:DMS3053-5|here]].

===Running over a range of temperatures===
[[File:DMS88dat.png|300px|thumb|right|'''''Figure 5''': Average energy and average magnetisation vs. temperature for 8x8 lattice, with error bars'']]
Using the python script modified in the previous exercise, the code can now be used to simulate the 8x8 system at a range of temperatures, using the ILtemperaturerange.py file (shown [[Mod:DMS3053-temprange|here]]). Here, the temperature range of 0.25 to 5.00 was used, with a separation of 0.25 between points, whilst the runtime was set to 10000 (neglecting the property values for the first 1000 cycles). Running this simulation produced the graphs in ''Figure 5'', where error bars computed using standard errors have also been included (these are small as a consequence of small standard errors). From the graph of average energy versus temperature, the phase transition can be observed - this occurs in the region with a gradient that is not close to zero. The data used here (temperature, average energies, average squared-energies, average magnetisations and average squared-magnetisations) was then saved as a numpy array in a new file, 8x8.dat.

==The effect of system size==
[[File:DMSLatticeSizeCombinedPlot.png|300px|thumb|right|'''''Figure 6''': Average energy and average magnetisation (per spins) vs. temperature for multiple lattice sizes'']]
The process conducted for the 8x8 lattice in the previous exercise was then repeated for lattices of sizes 2x2, 4x4, 16x16 and 32x32, with the data saved in .dat files. These files were then accessed, and the average energy and magnetisation data were plotted on one graph for all of the lattices sizes - this was achieved using the script presented [[Mod:DMS3053-6|here]]. The graphs produced in this manner are shown in ''Figure 6''.

A consideration of this graph suggests that in order to capture the long range fluctuations, whilst minimising the computational time required, an 8x8 lattice is likely to be the optimum choice. This is because the graph for this system size is comparable to that for a 32x32 lattice, whilst being faster to compute.

==Determining the heat capacity==
[[File:DMSheatcapacity2.png|300px|thumb|right|'''''Figure 7''': Heat capacity (per spin) versus temperature for different lattice sizes'']]
Using the .dat files previously produced, the heat capacity was calculated for each lattice size using the equation
::<math>C = \frac{\partial E}{\partial T} = \frac{\mathrm{Var}[E]}{k_B T^2}</math>, (''eq. 9'') 
where <math>\mathrm{Var}[E] = <E^2> - <E>^2 </math>. When implementing this, the kB term was neglected due to the energy values having units of kB. The script used for this purpose is provided [[DMS3053-7|here]]. The plot of heat capacity per spin versus temperature for all of the lattice sizes considered is presented in ''Figure 7''.

==Locating the Curie temperature==
===Comparison with C++ Data===
The data for the heat capacity generated using the python script prepared in this experiment was compared to that from longer C++ computations - graphs showing this comparison are presented in ''Table 7'' for a range of lattice sizes. The Python code used to produce these graphs is shown [[Mod:DMS3053-8|here]].

Considering these graphs, it is clear that, in general, there is a reasonable correlation between the Python and C++ data; however, some of the data, particularly that for high lattice sizes, shows that the Python computations have not always found the maximum of heat capacity. This correlation would be improved by making computations at the same range of temperatures, but with a smaller gap between the temperatures taken; however, this would substantially increase computation time.
{| class="wikitable center" width=70%
|+ ''Table 7: Graphs of heat capacity (per spin) versus temperature for C++ and Python data''
|- style="text-align:center;"
| [[File:DMS2x2c.png|300px]] || [[File:DMS4x4c.png|300px]] || [[File:DMS8x8c.png|300px]]
|- style="text-align:center;"
| 2x2 || 4x4 || 8x8
|- style="text-align:center;"
| [[File:DMS16x16c.png|300px]] || [[File:DMS32x32c.png|300px]]
|- style="text-align:center;"
| 16x16 || 32x32
|}

===Polynomial Fitting===
[[File:DMS8x8513.png|300px|thumb|right|'''''Figure 8''': Heat capacity (per spin) versus temperature for 8x8 system with two polynomial fits'']]
In order to make use of the C++ data in finding the Curie temperature for the Ising Lattices under consideration, polynomials were fit to the data - the script written for this purpose is shown [[Mod:DMS3053-9|here]]. For this fitting, it was found that a polynomial order of 5 was required to provide a good fit for the 2x2 data - this increased significantly as the lattice size increased. An example fit is shown for the 8x8 system in ''Figure 8'', where the polynomial fit is shown for orders 5 and 13. A consideration of this graph reveals that whilst a polynomial of order 5 may be appropriate for a 2x2 system, it is inadequate for the larger system of 8x8. Whilst an order of 13 substantially improves the polynomial fit, one must, in general, take care with 'overfitting' data.
[[File:Py8x8(13fit).png|300px|thumb|left|'''''Figure 9''': Heat capacity (per spin) versus temperature for Python data for 8x8 system with a 13th order polynomial fit'']]
For comparison, a 13th order polynomial was fitted to the 8x8 Python data previously computed - this is shown in ''Figure 9''. Here, it is evident that for this data, a higher order polynomial is required to obtain a fit comparable to that for the C++ data above.

===Fitting in a Particular Temperature Range===
[[File:DMS8x8peak(3).png|300px|thumb|right|'''''Figure 10''': Heat capacity (per spin) versus temperature for 8x8 system with peak polynomial fit'']]
As was observed in the previous exercise, large polynomial orders are required to fit the C++ data well across the whole temperature range. The python script was modified to that presented [[Mod:DMS3053-10|here]] (this script also contains the python code to compute the maximum heat capacity and temperature at which this occurs for the following exercise), which fits a polynomial only in the region of the maximum heat capacity for the system. An example of such fit is shown in ''Figure 10'' for the 8x8 system. Here, it should be noted that for all of the system sizes studied, a polynomial order of 3 was used - this is a clear improvement compared to the 13th order polynomials used previously.

===Finding the Peak in Heat Capacity===
{| class="wikitable floatright" width=42%
|+ ''Table 8: Lattice sizes and their corresponding Curie temperatures''
! System Size !! Number of cycles before averaging
|- style="text-align:center;"
| 2x2 || 2.53503504
|- style="text-align:center;"
| 4x4 || 2.43843844
|- style="text-align:center;"
| 8x8 || 2.33433433
|- style="text-align:center;"
| 16x16 || 2.30455455
|- style="text-align:center;"
| 32x32 || 2.27752753
|}
[[File:DMSCurieTemperature.png|300px|thumb|left|'''''Figure 11''': Curie temperature vs. 1/(lattice length), with extrapolated linear fit'']]
In order to find the Curie temperature for an infinite Ising Lattice, the Curie temperature for each system size considered was first found (using the script shown in the previous exercise). These temperatures were then saved to a .dat file (whose contents are also showed in ''Table 8'', along with their corresponding lattice sizes. Finally, using the script presented [[Mod:DMS3053-11|here]], a graph of Curie temperature versus the inverse of the lattice length was plotted, according to the equation
::<math>T_{C, L} = \frac{A}{L} + T_{C,\infty}</math>, ''(eq. 10)
where <math>T_{C, L}</math> is the Curie temperature for a lattice with length L and <math>T_{C,\infty}</math> is the Curie temperature for an infinite Ising lattice. Hence, it is clear that the desired Curie temperature must be the y-intercept of the graph shown in ''Figure 11'' (hence the use of extrapolation in the python script). Taking this extrapolated value gives a Curie temperature of 2.271. This value can be compared to the theoretical exact value of 2.27,<ref>D. K. Khudier, N. I. Fawaz, ''Int. Lett. Them. Phys. Astron.'', 2013, '''10''', 201-212. Available from: http://www.ilcpa.pl/wp-content/uploads/2012/11/ILCPA-102-2013-201-2121.pdf</ref> which indicates a good agreement between the value calculated in this investigation and the theoretical exact value. This is surprising given that it would be expected that the polynomial fitting of the data to locate the maximum would contribute a considerable degree of error to the final value.

==References==
<references/>
</div>

Rep:Mod:DMS3053

2015-02-26T10:21:20Z

Ds3012: /* Modifying IsingLattice.py to Implement a Monte Carlo Cycle */

'''CMP Programming Experiment - Daniel Spencer, 00736964'''
<div style="text-align: justify">
==Introduction to the Ising Model==
===Minimum energy of the Ising Model===
Using the equation 
::<math>E= - \frac{1}{2} J \sum_i^N \sum_{j\ \in\ \mathrm{neighbours}\left(i\right)} s_i s_j</math> (''eq. 1'') 
the minimum energy of an Ising lattice of <math>D</math> dimensions, with <math>N</math> spins (where each
spin had a value of +1 or -1) and an interaction strength of <math>J</math> was considered. This was achieved first through a consideration of a one-dimensional system with five parallel spins (where the spins are parallel as this corresponds to the minimum energy arrangement of the system). Hence, the energy of this linear system was found to be 
::<math>E_\text{min,1D} = -5J </math>. 
For a linear, one-dimensional system, the number of neigbouring spins is two. The number of neighbours can be determined for two- and three- dimensional systems through a geometric consideration of their structure - the values are presented in ''Table 1''.
{| class="wikitable floatright" width=42%
|+ ''Table 1: Dimension numbers and number of neighbours''
! Number of Dimensions, D !! Number of Neighbours
|- style="text-align:center;"
| 1 || 2
|- style="text-align:center;"
| 2 || 4
|- style="text-align:center;"
| 3 || 6
|- style="text-align:center;"
| D || 2D
|}
These data indicate that the number of neighbours is twice the number of dimensions, for the dimensions considered here. This can be extrapolated to give the general number of neighbours as <math>2D</math>.

For the minimum energy of the system, where all spins are parallel, every combination <math>s_i s_j</math> has a value of 1. Notably, for each value of <math>i</math>, there will be <math>2D</math> neighbour interactions. Ergo, using ''eq. 1'', the general minimum energy can be found to be
::<math>E_\text{min,D} = -DNJ </math> (''eq. 2''). 
To check this equation, it can be applied to the two-dimensional Ising lattice with 25 spins - this gives a value of
::<math>E_\text{min,2D} = -50J </math>, 
which matches with the value predicted from first-principles.

For this D-dimensional system, the multiplicity (i.e. the number of ways of achieving the specified configuration of spins) must be equal to two, as either all of the spins could be aligned 'up' (+1) or 'down' (-1). Using this multiplicity, the entropy of the system can be calculated using the equation
::<math>S = k_B \ln\Omega</math>, (''eq. 3'') 
where Ω is the number of microstates (equal to the multiplicity in this case), which gives a value of <math>k_B \ln2 </math>, or 9.57 x 10-24 J K-1.

===Spin 'flipping'===
[[File:ThirdYearCMPExpt-IsingSketch.png|300px|thumb|right|'' '''Figure 1''': Representation of Ising lattices in one (N=5), two (N=25), and three (N=125) dimensions. +1 and -1 spins are denoted by the red and blue cells respectively. Diagram taken from the lab script.'']]
Using the Ising model, it is also possible to consider a change in state, reflected by a 'flipping' of the direction of one of the lattice spins. For this case, the energy (using ''eq. 1'') can be determined to be
::<math>E'= - \frac{1}{2} J (2DN - 4D - 4D) = 4DJ - DNJ</math>, (''eq. 4'') 
where the additional <math>4D</math> terms arise from the loss of 4D stabilising spin-aligned interactions and the gain of 4D destabilising spins anti-aligned interactions following spin 'flipping'. Using ''eq. 2'' and ''eq. 4'', the change in energy derived from this spin 'flip' can be calculated to be
::<math>\Delta E= 4DJ - DNJ + DNJ = 4DJ</math>. (''eq. 5'') 
For a system with three dimensions (D = 3) and 1000 spins (N = 1000), the system, using ''eq. 5'', was determined to increase in energy by <math>12 J</math>. Notably, this change in energy is independent of the number of spins in the system - it depends only on the number of dimensions and J.

A significant consideration with regards to the spin 'flipping' described here is the accompanying increase in entropy - the driving force for this process. For the scenario describing the change in direction of a single spin, the multiplicity of the system will be <math>2N</math> - this is a consequence of the system prior to 'flipping' having a multiplicity of two (all spins aligned 'up' or 'down'), where now, any one of the spins could flip, adding the factor of N to the multiplicity. Hence, the new entropy can be defined to be
::<math>S' = k_B \ln 2N</math>, (''eq. 6'') 
which allows the change in entropy to be calculated according to ''eq. 7''.
::<math>\Delta S = k_B \ln 2N - k_B \ln2 = k_B \ln N</math> (''eq. 7'') 
For the system described above (D = 3, N = 1000), the change in entropy associated with the spin 'flip' process is therefore <math>k_B ln 1000</math>, which is equal to 9.53 x 10-23 J K-1.

===Magnetisation===
{| class="wikitable floatleft" width=42%
|+ ''Table 2: Ising lattices and magnetisations''
! Ising Lattice !! Magnetisation
|- style="text-align:center;"
| 1D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 2D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 3D at 0 K || 1000 or -1000
|}
''Figure 1'' shows three examples of Ising lattices, with one, two and three dimensions respectively. Using the equation for magnetisation (''eq. 8''), the magnetisations of these systems can be calculated to be those presented in ''Table 2''.
::<math>M= \sum_i s_i</math> (''eq. 8'') 
For the three-dimensional system with 1000 spins at a temperature of 0 K, all of the spins must be aligned either 'up' or 'down', as the entropic increase associated with 'flipped' spins does not provide a driving force at absolute zero - the only factor to consider is that of the energy, which is a minimum when all of the spins are aligned. For this case, the magnetisation could be either 1000 or -1000, depending upon the direction of the spin alignment. From a consideration of the magnetisation values calculated here, it is evident that with all of the spins aligned, the (magnitude of the) magnetisation of the system is at a maximum.

==Calculating the energy and magnetisation==
===Modifying the files===
[[File:DMStest_output2.png|300px|thumb|right|'' '''Figure 2''': Output image from testing IsingLattice.py using Ilcheck.py'']]
In order to use Python to compute the energy and magnetisation for a given two-dimensional Ising lattice, the class IsingLattice was used, where energy() and magnetisation() functions were written to calculate their corresponding properties for a random numpy array of spins (generated using np.random.choice). For this aspect of the experiment, the value of J was assumed to be 1.0, working in reduced units. The Python script developed can be viewed [[Mod:DMS3053-1|here]], including annotations.

===Testing the files===
In order to test the script prepared thus far, the Ilcheck.py script was run, generating the image presented in ''Figure 2''. An examination of this output clearly indicates that the script provides accurate energies and magnetisations for the minimum and maximum energy configurations, along with for an intermediate, random arrangement. Hence, it can be concluded that at the current level, the Python script is functioning as required.

==Introduction to the Monte Carlo simulation==
===Average Energy and Magnetisation===
[[File:DMSILanim3.png|300px|thumb|right|'''''Figure 3''': Animation result from ILanim.py, showing the resting of the system in the minimum energy state'']]
In order to consider the generalisability of the prepared script, it is important to analyse how the script will function for large systems, such as those with 100 spins in the spin array. As each of these spins can be either 'up' or 'down', each spin has two choices. Hence, the number of possible configurations for the system can be written as <math>2^{100}</math>, which has a value of 1.2677 x 1030.

If one considers the sampling of a single configuration to take 1 x 10-9 s, then it is clear that sampling all of these considerations would take a total of 1.2677 x 1021 s (also expressed as 4.017 x 1013 years). From this analysis, it is evident that the sampling of configurations was a significant consideration in the writing of a python script for this task.

In order to account for this, the technique of importance sampling was implemented, using the statistical Boltzmann distribution, <math>\exp(- \Delta E / k_B T)</math>. Note that as the energy computed using the energy() function is in units of kB, this factor is not included in the script.

===Modifying IsingLattice.py to Implement a Monte Carlo Cycle===
[[File:DMSILanim_meta.png|300px|thumb|left|'''''Figure 4''': Animation result from ILanim.py, showing the resting of the system in a meta-stable state'']]
The python script developed at this stage is presented [[Mod:DMS3053-2|here]], accompanied by annotations to explain how the script functions.

===Simulating the Monte Carlo Cycles===

{| class="wikitable floatright" width=42%
|+ ''Table 3: statistics() output for animated system at global minimum configuration (Figure 3)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.70542501728
|- style="text-align:center;"
| <E2> || 3.13520970111
|- style="text-align:center;"
| <M> || -0.829971492744
|- style="text-align:center;"
| <M2> || 0.770986982766
|}
For cases where T < Tc, it would be expected that the system would have a spontaneous magnetisation. When T > Tc, the entropy will be the dominating factor, potentially resulting in the system having a magnetisation of zero.
{| class="wikitable floatright" width=42%
|+ ''Table 4: statistics() output for animated system at meta-stable configuration (Figure 4)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.35076450189
|- style="text-align:center;"
| <E2> || 1.89025801939
|- style="text-align:center;"
| <M> || -0.344104665826
|- style="text-align:center;"
| <M2> || 0.138855365306
|}
Using the presented script and the ILanim.py script, the Monte Carlo cycles can be simulated to view the results on the spin array as the process progresses. Here, the system under consideration was an 8 x 8 spin array, at a temperature of 0.5. ''Figure 3'' shows the typical outcome of the animation, with the system having reached the most stable, minimum energy arrangement. For the result presented here, the output of the statistics() function was that shown in ''Table 3''.

It was also observed that the system could locate a meta-stable state, with large regions of spin 'up' and 'down' spins. An example of such a result is presented in ''Figure 4'' (for which the output data from statistics() is presented in ''Table 4'').

==Accelerating the code==

In order to examine the efficiency of the python script developed thus far, the Iltimetrial.py script was utilised to investigate the time taken to perform 2000 Monte Carlo cycles. This script was modified to the version presented [[Mod:DMS3053-3|here]], which repeats the time measurement a defined number of times, then calculates the average time and the standard error in this average. For the Monte Carlo script prepared previously, the average time for 2000 Monte Carlo cycles was measured to be 5.475804 s and a standard error was calculated to be 0.008325 s, with 100 measurements made using the script.

Evidently, the current script is slow at conducting large numbers of Monte Carlo cycles and hence, a more efficient script was developed using the np.roll, np.multiply and np.sum functions - this is presented [[Mod:DMS3053-4|here]].

After this optimisation of the python script, the Iltimetrial.py script was re-run, giving an average time of 0.291467 s, with a standard error of 0.000156 s. Clearly, this optimised script is substantially faster than that developed previously (approximately 19 times faster).

==The effect of temperature==
===Correcting the averaging code===
As the equilibrium state of the system requires a number of Monte Carlo cycles to be reached, it is evident that the average energies and magnetisations are accounting for values for non-equilibrium arrangements - this was accounted for through a consideration of the number of cycles required to reach equilibrium. For this, the ILfinalframe.py script was used, giving the graphs shown in ''Table 5''. Here, each system was run for 150000 Monte Carlo cycles.
{| class="wikitable center" width=70%
|+ ''Table 5: Graphs of energy and magnetisation versus number of Monte Carlo cycles for different temperatures and system sizes''
! Temperature !! System Size !! Resulting Graphs !! Cycles for Equilibrium
|- style="text-align:center;"
| 0.5 || 4x4 || [[File:DMS0544.png|300px]] || 24
|- style="text-align:center;"
| 0.5 || 8x8 || [[File:DMS0588.png|300px]] || 392
|- style="text-align:center;"
| 0.5 || 16x16 || [[File:DMS051616.png|300px]] || 5549
|- style="text-align:center;"
| 1.0 || 2x2 || [[File:DMS1022.png|300px]] || (0)
|- style="text-align:center;"
| 1.0 || 4x4 || [[File:DMS1044.png|300px]] || 49
|- style="text-align:center;"
| 1.0 || 8x8 || [[File:DMS10882.png|300px]] || 590
|- style="text-align:center;"
| 1.0 || 16x16 || [[File:DMS101616.png|300px]] || ~6300
|- style="text-align:center;"
| 1.0 || 32x32 || [[File:DMS103232.png|300px]] || ~110000
|- style="text-align:center;"
| 2.0 || 4x4 || [[File:DMS2044.png|300px]] || -
|- style="text-align:center;"
| 2.0 || 8x8 || [[File:DMS2088.png|300px]] || -
|}
{| class="wikitable floatright" width=42%
|+ ''Table 6: Number of cycles to be ignored for each system size''
! System Size !! Number of cycles before averaging
|- style="text-align:center;"
| 2x2 || 0
|- style="text-align:center;"
| 4x4 || 100
|- style="text-align:center;"
| 8x8 || 1000
|- style="text-align:center;"
| 16x16 || 8000
|- style="text-align:center;"
| 32x32 || 120000
|}
Analysis of these graphs indicates that at higher temperatures, such as 2.0 (also observed at 1.5), large fluctuations in the energy and magnetisation are observed - these fluctuations are the reason that the average values of the properties must be taken. As the temperature is increased for systems of size 4x4, 8x8 and 16x16, it is clear that the number of cycles required in order to reach equilibrium increases. Hence, for the temperature range to be considered later (0.25 to 5.00), the required number of cycles was overestimated in order to ensure that all measurements were taken whilst the system was in equilibrium. The proposed numbers of cycles to be ignored for each system size are presented in ''Table 6''.

The python script developed up to this point was modified to account for these values by inclusion of a skip_region variable, which defines the number of cycles performed before energies and magnetisations contribute to the self.X values (before averaging occurs). The modified script is presented [[Mod:DMS3053-5|here]].

===Running over a range of temperatures===
[[File:DMS88dat.png|300px|thumb|right|'''''Figure 5''': Average energy and average magnetisation vs. temperature for 8x8 lattice, with error bars'']]
Using the python script modified in the previous exercise, the code can now be used to simulate the 8x8 system at a range of temperatures, using the ILtemperaturerange.py file (shown [[Mod:DMS3053-temprange|here]]). Here, the temperature range of 0.25 to 5.00 was used, with a separation of 0.25 between points, whilst the runtime was set to 10000 (neglecting the property values for the first 1000 cycles). Running this simulation produced the graphs in ''Figure 5'', where error bars computed using standard errors have also been included (these are small as a consequence of small standard errors). From the graph of average energy versus temperature, the phase transition can be observed - this occurs in the region with a gradient that is not close to zero. The data used here (temperature, average energies, average squared-energies, average magnetisations and average squared-magnetisations) was then saved as a numpy array in a new file, 8x8.dat.

==The effect of system size==
[[File:DMSLatticeSizeCombinedPlot.png|300px|thumb|right|'''''Figure 6''': Average energy and average magnetisation (per spins) vs. temperature for multiple lattice sizes'']]
The process conducted for the 8x8 lattice in the previous exercise was then repeated for lattices of sizes 2x2, 4x4, 16x16 and 32x32, with the data saved in .dat files. These files were then accessed, and the average energy and magnetisation data were plotted on one graph for all of the lattices sizes - this was achieved using the script presented [[Mod:DMS3053-6|here]]. The graphs produced in this manner are shown in ''Figure 6''.

A consideration of this graph suggests that in order to capture the long range fluctuations, whilst minimising the computational time required, an 8x8 lattice is likely to be the optimum choice. This is because the graph for this system size is comparable to that for a 32x32 lattice, whilst being faster to compute.

==Determining the heat capacity==
[[File:DMSheatcapacity2.png|300px|thumb|right|'''''Figure 7''': Heat capacity (per spin) versus temperature for different lattice sizes'']]
Using the .dat files previously produced, the heat capacity was calculated for each lattice size using the equation
::<math>C = \frac{\partial E}{\partial T} = \frac{\mathrm{Var}[E]}{k_B T^2}</math>, (''eq. 9'') 
where <math>\mathrm{Var}[E] = <E^2> - <E>^2 </math>. When implementing this, the kB term was neglected due to the energy values having units of kB. The script used for this purpose is provided [[DMS3053-7|here]]. The plot of heat capacity per spin versus temperature for all of the lattice sizes considered is presented in ''Figure 7''.

==Locating the Curie temperature==
===Comparison with C++ Data===
The data for the heat capacity generated using the python script prepared in this experiment was compared to that from longer C++ computations - graphs showing this comparison are presented in ''Table 7'' for a range of lattice sizes. The Python code used to produce these graphs is shown [[Mod:DMS3053-8|here]].

Considering these graphs, it is clear that, in general, there is a reasonable correlation between the Python and C++ data; however, some of the data, particularly that for high lattice sizes, shows that the Python computations have not always found the maximum of heat capacity. This correlation would be improved by making computations at the same range of temperatures, but with a smaller gap between the temperatures taken; however, this would substantially increase computation time.
{| class="wikitable center" width=70%
|+ ''Table 7: Graphs of heat capacity (per spin) versus temperature for C++ and Python data''
|- style="text-align:center;"
| [[File:DMS2x2c.png|300px]] || [[File:DMS4x4c.png|300px]] || [[File:DMS8x8c.png|300px]]
|- style="text-align:center;"
| 2x2 || 4x4 || 8x8
|- style="text-align:center;"
| [[File:DMS16x16c.png|300px]] || [[File:DMS32x32c.png|300px]]
|- style="text-align:center;"
| 16x16 || 32x32
|}

===Polynomial Fitting===
[[File:DMS8x8513.png|300px|thumb|right|'''''Figure 8''': Heat capacity (per spin) versus temperature for 8x8 system with two polynomial fits'']]
In order to make use of the C++ data in finding the Curie temperature for the Ising Lattices under consideration, polynomials were fit to the data - the script written for this purpose is shown [[Mod:DMS3053-9|here]]. For this fitting, it was found that a polynomial order of 5 was required to provide a good fit for the 2x2 data - this increased significantly as the lattice size increased. An example fit is shown for the 8x8 system in ''Figure 8'', where the polynomial fit is shown for orders 5 and 13. A consideration of this graph reveals that whilst a polynomial of order 5 may be appropriate for a 2x2 system, it is inadequate for the larger system of 8x8. Whilst an order of 13 substantially improves the polynomial fit, one must, in general, take care with 'overfitting' data.
[[File:Py8x8(13fit).png|300px|thumb|left|'''''Figure 9''': Heat capacity (per spin) versus temperature for Python data for 8x8 system with a 13th order polynomial fit'']]
For comparison, a 13th order polynomial was fitted to the 8x8 Python data previously computed - this is shown in ''Figure 9''. Here, it is evident that for this data, a higher order polynomial is required to obtain a fit comparable to that for the C++ data above.

===Fitting in a Particular Temperature Range===
[[File:DMS8x8peak(3).png|300px|thumb|right|'''''Figure 10''': Heat capacity (per spin) versus temperature for 8x8 system with peak polynomial fit'']]
As was observed in the previous exercise, large polynomial orders are required to fit the C++ data well across the whole temperature range. The python script was modified to that presented [[Mod:DMS3053-10|here]] (this script also contains the python code to compute the maximum heat capacity and temperature at which this occurs for the following exercise), which fits a polynomial only in the region of the maximum heat capacity for the system. An example of such fit is shown in ''Figure 10'' for the 8x8 system. Here, it should be noted that for all of the system sizes studied, a polynomial order of 3 was used - this is a clear improvement compared to the 13th order polynomials used previously.

===Finding the Peak in Heat Capacity===
{| class="wikitable floatright" width=42%
|+ ''Table 8: Lattice sizes and their corresponding Curie temperatures''
! System Size !! Number of cycles before averaging
|- style="text-align:center;"
| 2x2 || 2.53503504
|- style="text-align:center;"
| 4x4 || 2.43843844
|- style="text-align:center;"
| 8x8 || 2.33433433
|- style="text-align:center;"
| 16x16 || 2.30455455
|- style="text-align:center;"
| 32x32 || 2.27752753
|}
[[File:DMSCurieTemperature.png|300px|thumb|left|'''''Figure 11''': Curie temperature vs. 1/(lattice length), with extrapolated linear fit'']]
In order to find the Curie temperature for an infinite Ising Lattice, the Curie temperature for each system size considered was first found (using the script shown in the previous exercise). These temperatures were then saved to a .dat file (whose contents are also showed in ''Table 8'', along with their corresponding lattice sizes. Finally, using the script presented [[Mod:DMS3053-11|here]], a graph of Curie temperature versus the inverse of the lattice length was plotted, according to the equation
::<math>T_{C, L} = \frac{A}{L} + T_{C,\infty}</math>, ''(eq. 10)
where <math>T_{C, L}</math> is the Curie temperature for a lattice with length L and <math>T_{C,\infty}</math> is the Curie temperature for an infinite Ising lattice. Hence, it is clear that the desired Curie temperature must be the y-intercept of the graph shown in ''Figure 11'' (hence the use of extrapolation in the python script). Taking this extrapolated value gives a Curie temperature of 2.271. This value can be compared to the theoretical exact value of 2.27,<ref>D. K. Khudier, N. I. Fawaz, ''Int. Lett. Them. Phys. Astron.'', 2013, '''10''', 201-212. Available from: http://www.ilcpa.pl/wp-content/uploads/2012/11/ILCPA-102-2013-201-2121.pdf</ref> which indicates a good agreement between the value calculated in this investigation and the theoretical exact value. This is surprising given that it would be expected that the polynomial fitting of the data to locate the maximum would contribute a considerable degree of error to the final value.

==References==
<references/>
</div>

Rep:Mod:DMS3053

2015-02-26T10:21:09Z

Ds3012: /* Simulating the Monte Carlo Cycles */

'''CMP Programming Experiment - Daniel Spencer, 00736964'''
<div style="text-align: justify">
==Introduction to the Ising Model==
===Minimum energy of the Ising Model===
Using the equation 
::<math>E= - \frac{1}{2} J \sum_i^N \sum_{j\ \in\ \mathrm{neighbours}\left(i\right)} s_i s_j</math> (''eq. 1'') 
the minimum energy of an Ising lattice of <math>D</math> dimensions, with <math>N</math> spins (where each
spin had a value of +1 or -1) and an interaction strength of <math>J</math> was considered. This was achieved first through a consideration of a one-dimensional system with five parallel spins (where the spins are parallel as this corresponds to the minimum energy arrangement of the system). Hence, the energy of this linear system was found to be 
::<math>E_\text{min,1D} = -5J </math>. 
For a linear, one-dimensional system, the number of neigbouring spins is two. The number of neighbours can be determined for two- and three- dimensional systems through a geometric consideration of their structure - the values are presented in ''Table 1''.
{| class="wikitable floatright" width=42%
|+ ''Table 1: Dimension numbers and number of neighbours''
! Number of Dimensions, D !! Number of Neighbours
|- style="text-align:center;"
| 1 || 2
|- style="text-align:center;"
| 2 || 4
|- style="text-align:center;"
| 3 || 6
|- style="text-align:center;"
| D || 2D
|}
These data indicate that the number of neighbours is twice the number of dimensions, for the dimensions considered here. This can be extrapolated to give the general number of neighbours as <math>2D</math>.

For the minimum energy of the system, where all spins are parallel, every combination <math>s_i s_j</math> has a value of 1. Notably, for each value of <math>i</math>, there will be <math>2D</math> neighbour interactions. Ergo, using ''eq. 1'', the general minimum energy can be found to be
::<math>E_\text{min,D} = -DNJ </math> (''eq. 2''). 
To check this equation, it can be applied to the two-dimensional Ising lattice with 25 spins - this gives a value of
::<math>E_\text{min,2D} = -50J </math>, 
which matches with the value predicted from first-principles.

For this D-dimensional system, the multiplicity (i.e. the number of ways of achieving the specified configuration of spins) must be equal to two, as either all of the spins could be aligned 'up' (+1) or 'down' (-1). Using this multiplicity, the entropy of the system can be calculated using the equation
::<math>S = k_B \ln\Omega</math>, (''eq. 3'') 
where Ω is the number of microstates (equal to the multiplicity in this case), which gives a value of <math>k_B \ln2 </math>, or 9.57 x 10-24 J K-1.

===Spin 'flipping'===
[[File:ThirdYearCMPExpt-IsingSketch.png|300px|thumb|right|'' '''Figure 1''': Representation of Ising lattices in one (N=5), two (N=25), and three (N=125) dimensions. +1 and -1 spins are denoted by the red and blue cells respectively. Diagram taken from the lab script.'']]
Using the Ising model, it is also possible to consider a change in state, reflected by a 'flipping' of the direction of one of the lattice spins. For this case, the energy (using ''eq. 1'') can be determined to be
::<math>E'= - \frac{1}{2} J (2DN - 4D - 4D) = 4DJ - DNJ</math>, (''eq. 4'') 
where the additional <math>4D</math> terms arise from the loss of 4D stabilising spin-aligned interactions and the gain of 4D destabilising spins anti-aligned interactions following spin 'flipping'. Using ''eq. 2'' and ''eq. 4'', the change in energy derived from this spin 'flip' can be calculated to be
::<math>\Delta E= 4DJ - DNJ + DNJ = 4DJ</math>. (''eq. 5'') 
For a system with three dimensions (D = 3) and 1000 spins (N = 1000), the system, using ''eq. 5'', was determined to increase in energy by <math>12 J</math>. Notably, this change in energy is independent of the number of spins in the system - it depends only on the number of dimensions and J.

A significant consideration with regards to the spin 'flipping' described here is the accompanying increase in entropy - the driving force for this process. For the scenario describing the change in direction of a single spin, the multiplicity of the system will be <math>2N</math> - this is a consequence of the system prior to 'flipping' having a multiplicity of two (all spins aligned 'up' or 'down'), where now, any one of the spins could flip, adding the factor of N to the multiplicity. Hence, the new entropy can be defined to be
::<math>S' = k_B \ln 2N</math>, (''eq. 6'') 
which allows the change in entropy to be calculated according to ''eq. 7''.
::<math>\Delta S = k_B \ln 2N - k_B \ln2 = k_B \ln N</math> (''eq. 7'') 
For the system described above (D = 3, N = 1000), the change in entropy associated with the spin 'flip' process is therefore <math>k_B ln 1000</math>, which is equal to 9.53 x 10-23 J K-1.

===Magnetisation===
{| class="wikitable floatleft" width=42%
|+ ''Table 2: Ising lattices and magnetisations''
! Ising Lattice !! Magnetisation
|- style="text-align:center;"
| 1D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 2D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 3D at 0 K || 1000 or -1000
|}
''Figure 1'' shows three examples of Ising lattices, with one, two and three dimensions respectively. Using the equation for magnetisation (''eq. 8''), the magnetisations of these systems can be calculated to be those presented in ''Table 2''.
::<math>M= \sum_i s_i</math> (''eq. 8'') 
For the three-dimensional system with 1000 spins at a temperature of 0 K, all of the spins must be aligned either 'up' or 'down', as the entropic increase associated with 'flipped' spins does not provide a driving force at absolute zero - the only factor to consider is that of the energy, which is a minimum when all of the spins are aligned. For this case, the magnetisation could be either 1000 or -1000, depending upon the direction of the spin alignment. From a consideration of the magnetisation values calculated here, it is evident that with all of the spins aligned, the (magnitude of the) magnetisation of the system is at a maximum.

==Calculating the energy and magnetisation==
===Modifying the files===
[[File:DMStest_output2.png|300px|thumb|right|'' '''Figure 2''': Output image from testing IsingLattice.py using Ilcheck.py'']]
In order to use Python to compute the energy and magnetisation for a given two-dimensional Ising lattice, the class IsingLattice was used, where energy() and magnetisation() functions were written to calculate their corresponding properties for a random numpy array of spins (generated using np.random.choice). For this aspect of the experiment, the value of J was assumed to be 1.0, working in reduced units. The Python script developed can be viewed [[Mod:DMS3053-1|here]], including annotations.

===Testing the files===
In order to test the script prepared thus far, the Ilcheck.py script was run, generating the image presented in ''Figure 2''. An examination of this output clearly indicates that the script provides accurate energies and magnetisations for the minimum and maximum energy configurations, along with for an intermediate, random arrangement. Hence, it can be concluded that at the current level, the Python script is functioning as required.

==Introduction to the Monte Carlo simulation==
===Average Energy and Magnetisation===
[[File:DMSILanim3.png|300px|thumb|right|'''''Figure 3''': Animation result from ILanim.py, showing the resting of the system in the minimum energy state'']]
In order to consider the generalisability of the prepared script, it is important to analyse how the script will function for large systems, such as those with 100 spins in the spin array. As each of these spins can be either 'up' or 'down', each spin has two choices. Hence, the number of possible configurations for the system can be written as <math>2^{100}</math>, which has a value of 1.2677 x 1030.

If one considers the sampling of a single configuration to take 1 x 10-9 s, then it is clear that sampling all of these considerations would take a total of 1.2677 x 1021 s (also expressed as 4.017 x 1013 years). From this analysis, it is evident that the sampling of configurations was a significant consideration in the writing of a python script for this task.

In order to account for this, the technique of importance sampling was implemented, using the statistical Boltzmann distribution, <math>\exp(- \Delta E / k_B T)</math>. Note that as the energy computed using the energy() function is in units of kB, this factor is not included in the script.

===Modifying IsingLattice.py to Implement a Monte Carlo Cycle===
The python script developed at this stage is presented [[Mod:DMS3053-2|here]], accompanied by annotations to explain how the script functions.

===Simulating the Monte Carlo Cycles===

{| class="wikitable floatright" width=42%
|+ ''Table 3: statistics() output for animated system at global minimum configuration (Figure 3)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.70542501728
|- style="text-align:center;"
| <E2> || 3.13520970111
|- style="text-align:center;"
| <M> || -0.829971492744
|- style="text-align:center;"
| <M2> || 0.770986982766
|}
For cases where T < Tc, it would be expected that the system would have a spontaneous magnetisation. When T > Tc, the entropy will be the dominating factor, potentially resulting in the system having a magnetisation of zero.
{| class="wikitable floatright" width=42%
|+ ''Table 4: statistics() output for animated system at meta-stable configuration (Figure 4)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.35076450189
|- style="text-align:center;"
| <E2> || 1.89025801939
|- style="text-align:center;"
| <M> || -0.344104665826
|- style="text-align:center;"
| <M2> || 0.138855365306
|}
Using the presented script and the ILanim.py script, the Monte Carlo cycles can be simulated to view the results on the spin array as the process progresses. Here, the system under consideration was an 8 x 8 spin array, at a temperature of 0.5. ''Figure 3'' shows the typical outcome of the animation, with the system having reached the most stable, minimum energy arrangement. For the result presented here, the output of the statistics() function was that shown in ''Table 3''.

It was also observed that the system could locate a meta-stable state, with large regions of spin 'up' and 'down' spins. An example of such a result is presented in ''Figure 4'' (for which the output data from statistics() is presented in ''Table 4'').

==Accelerating the code==

In order to examine the efficiency of the python script developed thus far, the Iltimetrial.py script was utilised to investigate the time taken to perform 2000 Monte Carlo cycles. This script was modified to the version presented [[Mod:DMS3053-3|here]], which repeats the time measurement a defined number of times, then calculates the average time and the standard error in this average. For the Monte Carlo script prepared previously, the average time for 2000 Monte Carlo cycles was measured to be 5.475804 s and a standard error was calculated to be 0.008325 s, with 100 measurements made using the script.

Evidently, the current script is slow at conducting large numbers of Monte Carlo cycles and hence, a more efficient script was developed using the np.roll, np.multiply and np.sum functions - this is presented [[Mod:DMS3053-4|here]].

After this optimisation of the python script, the Iltimetrial.py script was re-run, giving an average time of 0.291467 s, with a standard error of 0.000156 s. Clearly, this optimised script is substantially faster than that developed previously (approximately 19 times faster).

==The effect of temperature==
===Correcting the averaging code===
As the equilibrium state of the system requires a number of Monte Carlo cycles to be reached, it is evident that the average energies and magnetisations are accounting for values for non-equilibrium arrangements - this was accounted for through a consideration of the number of cycles required to reach equilibrium. For this, the ILfinalframe.py script was used, giving the graphs shown in ''Table 5''. Here, each system was run for 150000 Monte Carlo cycles.
{| class="wikitable center" width=70%
|+ ''Table 5: Graphs of energy and magnetisation versus number of Monte Carlo cycles for different temperatures and system sizes''
! Temperature !! System Size !! Resulting Graphs !! Cycles for Equilibrium
|- style="text-align:center;"
| 0.5 || 4x4 || [[File:DMS0544.png|300px]] || 24
|- style="text-align:center;"
| 0.5 || 8x8 || [[File:DMS0588.png|300px]] || 392
|- style="text-align:center;"
| 0.5 || 16x16 || [[File:DMS051616.png|300px]] || 5549
|- style="text-align:center;"
| 1.0 || 2x2 || [[File:DMS1022.png|300px]] || (0)
|- style="text-align:center;"
| 1.0 || 4x4 || [[File:DMS1044.png|300px]] || 49
|- style="text-align:center;"
| 1.0 || 8x8 || [[File:DMS10882.png|300px]] || 590
|- style="text-align:center;"
| 1.0 || 16x16 || [[File:DMS101616.png|300px]] || ~6300
|- style="text-align:center;"
| 1.0 || 32x32 || [[File:DMS103232.png|300px]] || ~110000
|- style="text-align:center;"
| 2.0 || 4x4 || [[File:DMS2044.png|300px]] || -
|- style="text-align:center;"
| 2.0 || 8x8 || [[File:DMS2088.png|300px]] || -
|}
{| class="wikitable floatright" width=42%
|+ ''Table 6: Number of cycles to be ignored for each system size''
! System Size !! Number of cycles before averaging
|- style="text-align:center;"
| 2x2 || 0
|- style="text-align:center;"
| 4x4 || 100
|- style="text-align:center;"
| 8x8 || 1000
|- style="text-align:center;"
| 16x16 || 8000
|- style="text-align:center;"
| 32x32 || 120000
|}
Analysis of these graphs indicates that at higher temperatures, such as 2.0 (also observed at 1.5), large fluctuations in the energy and magnetisation are observed - these fluctuations are the reason that the average values of the properties must be taken. As the temperature is increased for systems of size 4x4, 8x8 and 16x16, it is clear that the number of cycles required in order to reach equilibrium increases. Hence, for the temperature range to be considered later (0.25 to 5.00), the required number of cycles was overestimated in order to ensure that all measurements were taken whilst the system was in equilibrium. The proposed numbers of cycles to be ignored for each system size are presented in ''Table 6''.

The python script developed up to this point was modified to account for these values by inclusion of a skip_region variable, which defines the number of cycles performed before energies and magnetisations contribute to the self.X values (before averaging occurs). The modified script is presented [[Mod:DMS3053-5|here]].

===Running over a range of temperatures===
[[File:DMS88dat.png|300px|thumb|right|'''''Figure 5''': Average energy and average magnetisation vs. temperature for 8x8 lattice, with error bars'']]
Using the python script modified in the previous exercise, the code can now be used to simulate the 8x8 system at a range of temperatures, using the ILtemperaturerange.py file (shown [[Mod:DMS3053-temprange|here]]). Here, the temperature range of 0.25 to 5.00 was used, with a separation of 0.25 between points, whilst the runtime was set to 10000 (neglecting the property values for the first 1000 cycles). Running this simulation produced the graphs in ''Figure 5'', where error bars computed using standard errors have also been included (these are small as a consequence of small standard errors). From the graph of average energy versus temperature, the phase transition can be observed - this occurs in the region with a gradient that is not close to zero. The data used here (temperature, average energies, average squared-energies, average magnetisations and average squared-magnetisations) was then saved as a numpy array in a new file, 8x8.dat.

==The effect of system size==
[[File:DMSLatticeSizeCombinedPlot.png|300px|thumb|right|'''''Figure 6''': Average energy and average magnetisation (per spins) vs. temperature for multiple lattice sizes'']]
The process conducted for the 8x8 lattice in the previous exercise was then repeated for lattices of sizes 2x2, 4x4, 16x16 and 32x32, with the data saved in .dat files. These files were then accessed, and the average energy and magnetisation data were plotted on one graph for all of the lattices sizes - this was achieved using the script presented [[Mod:DMS3053-6|here]]. The graphs produced in this manner are shown in ''Figure 6''.

A consideration of this graph suggests that in order to capture the long range fluctuations, whilst minimising the computational time required, an 8x8 lattice is likely to be the optimum choice. This is because the graph for this system size is comparable to that for a 32x32 lattice, whilst being faster to compute.

==Determining the heat capacity==
[[File:DMSheatcapacity2.png|300px|thumb|right|'''''Figure 7''': Heat capacity (per spin) versus temperature for different lattice sizes'']]
Using the .dat files previously produced, the heat capacity was calculated for each lattice size using the equation
::<math>C = \frac{\partial E}{\partial T} = \frac{\mathrm{Var}[E]}{k_B T^2}</math>, (''eq. 9'') 
where <math>\mathrm{Var}[E] = <E^2> - <E>^2 </math>. When implementing this, the kB term was neglected due to the energy values having units of kB. The script used for this purpose is provided [[DMS3053-7|here]]. The plot of heat capacity per spin versus temperature for all of the lattice sizes considered is presented in ''Figure 7''.

==Locating the Curie temperature==
===Comparison with C++ Data===
The data for the heat capacity generated using the python script prepared in this experiment was compared to that from longer C++ computations - graphs showing this comparison are presented in ''Table 7'' for a range of lattice sizes. The Python code used to produce these graphs is shown [[Mod:DMS3053-8|here]].

Considering these graphs, it is clear that, in general, there is a reasonable correlation between the Python and C++ data; however, some of the data, particularly that for high lattice sizes, shows that the Python computations have not always found the maximum of heat capacity. This correlation would be improved by making computations at the same range of temperatures, but with a smaller gap between the temperatures taken; however, this would substantially increase computation time.
{| class="wikitable center" width=70%
|+ ''Table 7: Graphs of heat capacity (per spin) versus temperature for C++ and Python data''
|- style="text-align:center;"
| [[File:DMS2x2c.png|300px]] || [[File:DMS4x4c.png|300px]] || [[File:DMS8x8c.png|300px]]
|- style="text-align:center;"
| 2x2 || 4x4 || 8x8
|- style="text-align:center;"
| [[File:DMS16x16c.png|300px]] || [[File:DMS32x32c.png|300px]]
|- style="text-align:center;"
| 16x16 || 32x32
|}

===Polynomial Fitting===
[[File:DMS8x8513.png|300px|thumb|right|'''''Figure 8''': Heat capacity (per spin) versus temperature for 8x8 system with two polynomial fits'']]
In order to make use of the C++ data in finding the Curie temperature for the Ising Lattices under consideration, polynomials were fit to the data - the script written for this purpose is shown [[Mod:DMS3053-9|here]]. For this fitting, it was found that a polynomial order of 5 was required to provide a good fit for the 2x2 data - this increased significantly as the lattice size increased. An example fit is shown for the 8x8 system in ''Figure 8'', where the polynomial fit is shown for orders 5 and 13. A consideration of this graph reveals that whilst a polynomial of order 5 may be appropriate for a 2x2 system, it is inadequate for the larger system of 8x8. Whilst an order of 13 substantially improves the polynomial fit, one must, in general, take care with 'overfitting' data.
[[File:Py8x8(13fit).png|300px|thumb|left|'''''Figure 9''': Heat capacity (per spin) versus temperature for Python data for 8x8 system with a 13th order polynomial fit'']]
For comparison, a 13th order polynomial was fitted to the 8x8 Python data previously computed - this is shown in ''Figure 9''. Here, it is evident that for this data, a higher order polynomial is required to obtain a fit comparable to that for the C++ data above.

===Fitting in a Particular Temperature Range===
[[File:DMS8x8peak(3).png|300px|thumb|right|'''''Figure 10''': Heat capacity (per spin) versus temperature for 8x8 system with peak polynomial fit'']]
As was observed in the previous exercise, large polynomial orders are required to fit the C++ data well across the whole temperature range. The python script was modified to that presented [[Mod:DMS3053-10|here]] (this script also contains the python code to compute the maximum heat capacity and temperature at which this occurs for the following exercise), which fits a polynomial only in the region of the maximum heat capacity for the system. An example of such fit is shown in ''Figure 10'' for the 8x8 system. Here, it should be noted that for all of the system sizes studied, a polynomial order of 3 was used - this is a clear improvement compared to the 13th order polynomials used previously.

===Finding the Peak in Heat Capacity===
{| class="wikitable floatright" width=42%
|+ ''Table 8: Lattice sizes and their corresponding Curie temperatures''
! System Size !! Number of cycles before averaging
|- style="text-align:center;"
| 2x2 || 2.53503504
|- style="text-align:center;"
| 4x4 || 2.43843844
|- style="text-align:center;"
| 8x8 || 2.33433433
|- style="text-align:center;"
| 16x16 || 2.30455455
|- style="text-align:center;"
| 32x32 || 2.27752753
|}
[[File:DMSCurieTemperature.png|300px|thumb|left|'''''Figure 11''': Curie temperature vs. 1/(lattice length), with extrapolated linear fit'']]
In order to find the Curie temperature for an infinite Ising Lattice, the Curie temperature for each system size considered was first found (using the script shown in the previous exercise). These temperatures were then saved to a .dat file (whose contents are also showed in ''Table 8'', along with their corresponding lattice sizes. Finally, using the script presented [[Mod:DMS3053-11|here]], a graph of Curie temperature versus the inverse of the lattice length was plotted, according to the equation
::<math>T_{C, L} = \frac{A}{L} + T_{C,\infty}</math>, ''(eq. 10)
where <math>T_{C, L}</math> is the Curie temperature for a lattice with length L and <math>T_{C,\infty}</math> is the Curie temperature for an infinite Ising lattice. Hence, it is clear that the desired Curie temperature must be the y-intercept of the graph shown in ''Figure 11'' (hence the use of extrapolation in the python script). Taking this extrapolated value gives a Curie temperature of 2.271. This value can be compared to the theoretical exact value of 2.27,<ref>D. K. Khudier, N. I. Fawaz, ''Int. Lett. Them. Phys. Astron.'', 2013, '''10''', 201-212. Available from: http://www.ilcpa.pl/wp-content/uploads/2012/11/ILCPA-102-2013-201-2121.pdf</ref> which indicates a good agreement between the value calculated in this investigation and the theoretical exact value. This is surprising given that it would be expected that the polynomial fitting of the data to locate the maximum would contribute a considerable degree of error to the final value.

==References==
<references/>
</div>

Rep:Mod:DMS3053

2015-02-26T10:20:52Z

Ds3012: /* Simulating the Monte Carlo Cycles */

'''CMP Programming Experiment - Daniel Spencer, 00736964'''
<div style="text-align: justify">
==Introduction to the Ising Model==
===Minimum energy of the Ising Model===
Using the equation 
::<math>E= - \frac{1}{2} J \sum_i^N \sum_{j\ \in\ \mathrm{neighbours}\left(i\right)} s_i s_j</math> (''eq. 1'') 
the minimum energy of an Ising lattice of <math>D</math> dimensions, with <math>N</math> spins (where each
spin had a value of +1 or -1) and an interaction strength of <math>J</math> was considered. This was achieved first through a consideration of a one-dimensional system with five parallel spins (where the spins are parallel as this corresponds to the minimum energy arrangement of the system). Hence, the energy of this linear system was found to be 
::<math>E_\text{min,1D} = -5J </math>. 
For a linear, one-dimensional system, the number of neigbouring spins is two. The number of neighbours can be determined for two- and three- dimensional systems through a geometric consideration of their structure - the values are presented in ''Table 1''.
{| class="wikitable floatright" width=42%
|+ ''Table 1: Dimension numbers and number of neighbours''
! Number of Dimensions, D !! Number of Neighbours
|- style="text-align:center;"
| 1 || 2
|- style="text-align:center;"
| 2 || 4
|- style="text-align:center;"
| 3 || 6
|- style="text-align:center;"
| D || 2D
|}
These data indicate that the number of neighbours is twice the number of dimensions, for the dimensions considered here. This can be extrapolated to give the general number of neighbours as <math>2D</math>.

For the minimum energy of the system, where all spins are parallel, every combination <math>s_i s_j</math> has a value of 1. Notably, for each value of <math>i</math>, there will be <math>2D</math> neighbour interactions. Ergo, using ''eq. 1'', the general minimum energy can be found to be
::<math>E_\text{min,D} = -DNJ </math> (''eq. 2''). 
To check this equation, it can be applied to the two-dimensional Ising lattice with 25 spins - this gives a value of
::<math>E_\text{min,2D} = -50J </math>, 
which matches with the value predicted from first-principles.

For this D-dimensional system, the multiplicity (i.e. the number of ways of achieving the specified configuration of spins) must be equal to two, as either all of the spins could be aligned 'up' (+1) or 'down' (-1). Using this multiplicity, the entropy of the system can be calculated using the equation
::<math>S = k_B \ln\Omega</math>, (''eq. 3'') 
where Ω is the number of microstates (equal to the multiplicity in this case), which gives a value of <math>k_B \ln2 </math>, or 9.57 x 10-24 J K-1.

===Spin 'flipping'===
[[File:ThirdYearCMPExpt-IsingSketch.png|300px|thumb|right|'' '''Figure 1''': Representation of Ising lattices in one (N=5), two (N=25), and three (N=125) dimensions. +1 and -1 spins are denoted by the red and blue cells respectively. Diagram taken from the lab script.'']]
Using the Ising model, it is also possible to consider a change in state, reflected by a 'flipping' of the direction of one of the lattice spins. For this case, the energy (using ''eq. 1'') can be determined to be
::<math>E'= - \frac{1}{2} J (2DN - 4D - 4D) = 4DJ - DNJ</math>, (''eq. 4'') 
where the additional <math>4D</math> terms arise from the loss of 4D stabilising spin-aligned interactions and the gain of 4D destabilising spins anti-aligned interactions following spin 'flipping'. Using ''eq. 2'' and ''eq. 4'', the change in energy derived from this spin 'flip' can be calculated to be
::<math>\Delta E= 4DJ - DNJ + DNJ = 4DJ</math>. (''eq. 5'') 
For a system with three dimensions (D = 3) and 1000 spins (N = 1000), the system, using ''eq. 5'', was determined to increase in energy by <math>12 J</math>. Notably, this change in energy is independent of the number of spins in the system - it depends only on the number of dimensions and J.

A significant consideration with regards to the spin 'flipping' described here is the accompanying increase in entropy - the driving force for this process. For the scenario describing the change in direction of a single spin, the multiplicity of the system will be <math>2N</math> - this is a consequence of the system prior to 'flipping' having a multiplicity of two (all spins aligned 'up' or 'down'), where now, any one of the spins could flip, adding the factor of N to the multiplicity. Hence, the new entropy can be defined to be
::<math>S' = k_B \ln 2N</math>, (''eq. 6'') 
which allows the change in entropy to be calculated according to ''eq. 7''.
::<math>\Delta S = k_B \ln 2N - k_B \ln2 = k_B \ln N</math> (''eq. 7'') 
For the system described above (D = 3, N = 1000), the change in entropy associated with the spin 'flip' process is therefore <math>k_B ln 1000</math>, which is equal to 9.53 x 10-23 J K-1.

===Magnetisation===
{| class="wikitable floatleft" width=42%
|+ ''Table 2: Ising lattices and magnetisations''
! Ising Lattice !! Magnetisation
|- style="text-align:center;"
| 1D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 2D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 3D at 0 K || 1000 or -1000
|}
''Figure 1'' shows three examples of Ising lattices, with one, two and three dimensions respectively. Using the equation for magnetisation (''eq. 8''), the magnetisations of these systems can be calculated to be those presented in ''Table 2''.
::<math>M= \sum_i s_i</math> (''eq. 8'') 
For the three-dimensional system with 1000 spins at a temperature of 0 K, all of the spins must be aligned either 'up' or 'down', as the entropic increase associated with 'flipped' spins does not provide a driving force at absolute zero - the only factor to consider is that of the energy, which is a minimum when all of the spins are aligned. For this case, the magnetisation could be either 1000 or -1000, depending upon the direction of the spin alignment. From a consideration of the magnetisation values calculated here, it is evident that with all of the spins aligned, the (magnitude of the) magnetisation of the system is at a maximum.

==Calculating the energy and magnetisation==
===Modifying the files===
[[File:DMStest_output2.png|300px|thumb|right|'' '''Figure 2''': Output image from testing IsingLattice.py using Ilcheck.py'']]
In order to use Python to compute the energy and magnetisation for a given two-dimensional Ising lattice, the class IsingLattice was used, where energy() and magnetisation() functions were written to calculate their corresponding properties for a random numpy array of spins (generated using np.random.choice). For this aspect of the experiment, the value of J was assumed to be 1.0, working in reduced units. The Python script developed can be viewed [[Mod:DMS3053-1|here]], including annotations.

===Testing the files===
In order to test the script prepared thus far, the Ilcheck.py script was run, generating the image presented in ''Figure 2''. An examination of this output clearly indicates that the script provides accurate energies and magnetisations for the minimum and maximum energy configurations, along with for an intermediate, random arrangement. Hence, it can be concluded that at the current level, the Python script is functioning as required.

==Introduction to the Monte Carlo simulation==
===Average Energy and Magnetisation===
[[File:DMSILanim3.png|300px|thumb|right|'''''Figure 3''': Animation result from ILanim.py, showing the resting of the system in the minimum energy state'']]
In order to consider the generalisability of the prepared script, it is important to analyse how the script will function for large systems, such as those with 100 spins in the spin array. As each of these spins can be either 'up' or 'down', each spin has two choices. Hence, the number of possible configurations for the system can be written as <math>2^{100}</math>, which has a value of 1.2677 x 1030.

If one considers the sampling of a single configuration to take 1 x 10-9 s, then it is clear that sampling all of these considerations would take a total of 1.2677 x 1021 s (also expressed as 4.017 x 1013 years). From this analysis, it is evident that the sampling of configurations was a significant consideration in the writing of a python script for this task.

In order to account for this, the technique of importance sampling was implemented, using the statistical Boltzmann distribution, <math>\exp(- \Delta E / k_B T)</math>. Note that as the energy computed using the energy() function is in units of kB, this factor is not included in the script.

===Modifying IsingLattice.py to Implement a Monte Carlo Cycle===
The python script developed at this stage is presented [[Mod:DMS3053-2|here]], accompanied by annotations to explain how the script functions.

===Simulating the Monte Carlo Cycles===
[[File:DMSILanim_meta.png|300px|thumb|left|'''''Figure 4''': Animation result from ILanim.py, showing the resting of the system in a meta-stable state'']]
{| class="wikitable floatright" width=42%
|+ ''Table 3: statistics() output for animated system at global minimum configuration (Figure 3)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.70542501728
|- style="text-align:center;"
| <E2> || 3.13520970111
|- style="text-align:center;"
| <M> || -0.829971492744
|- style="text-align:center;"
| <M2> || 0.770986982766
|}
For cases where T < Tc, it would be expected that the system would have a spontaneous magnetisation. When T > Tc, the entropy will be the dominating factor, potentially resulting in the system having a magnetisation of zero.
{| class="wikitable floatright" width=42%
|+ ''Table 4: statistics() output for animated system at meta-stable configuration (Figure 4)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.35076450189
|- style="text-align:center;"
| <E2> || 1.89025801939
|- style="text-align:center;"
| <M> || -0.344104665826
|- style="text-align:center;"
| <M2> || 0.138855365306
|}
Using the presented script and the ILanim.py script, the Monte Carlo cycles can be simulated to view the results on the spin array as the process progresses. Here, the system under consideration was an 8 x 8 spin array, at a temperature of 0.5. ''Figure 3'' shows the typical outcome of the animation, with the system having reached the most stable, minimum energy arrangement. For the result presented here, the output of the statistics() function was that shown in ''Table 3''.

It was also observed that the system could locate a meta-stable state, with large regions of spin 'up' and 'down' spins. An example of such a result is presented in ''Figure 4'' (for which the output data from statistics() is presented in ''Table 4'').

==Accelerating the code==

In order to examine the efficiency of the python script developed thus far, the Iltimetrial.py script was utilised to investigate the time taken to perform 2000 Monte Carlo cycles. This script was modified to the version presented [[Mod:DMS3053-3|here]], which repeats the time measurement a defined number of times, then calculates the average time and the standard error in this average. For the Monte Carlo script prepared previously, the average time for 2000 Monte Carlo cycles was measured to be 5.475804 s and a standard error was calculated to be 0.008325 s, with 100 measurements made using the script.

Evidently, the current script is slow at conducting large numbers of Monte Carlo cycles and hence, a more efficient script was developed using the np.roll, np.multiply and np.sum functions - this is presented [[Mod:DMS3053-4|here]].

After this optimisation of the python script, the Iltimetrial.py script was re-run, giving an average time of 0.291467 s, with a standard error of 0.000156 s. Clearly, this optimised script is substantially faster than that developed previously (approximately 19 times faster).

==The effect of temperature==
===Correcting the averaging code===
As the equilibrium state of the system requires a number of Monte Carlo cycles to be reached, it is evident that the average energies and magnetisations are accounting for values for non-equilibrium arrangements - this was accounted for through a consideration of the number of cycles required to reach equilibrium. For this, the ILfinalframe.py script was used, giving the graphs shown in ''Table 5''. Here, each system was run for 150000 Monte Carlo cycles.
{| class="wikitable center" width=70%
|+ ''Table 5: Graphs of energy and magnetisation versus number of Monte Carlo cycles for different temperatures and system sizes''
! Temperature !! System Size !! Resulting Graphs !! Cycles for Equilibrium
|- style="text-align:center;"
| 0.5 || 4x4 || [[File:DMS0544.png|300px]] || 24
|- style="text-align:center;"
| 0.5 || 8x8 || [[File:DMS0588.png|300px]] || 392
|- style="text-align:center;"
| 0.5 || 16x16 || [[File:DMS051616.png|300px]] || 5549
|- style="text-align:center;"
| 1.0 || 2x2 || [[File:DMS1022.png|300px]] || (0)
|- style="text-align:center;"
| 1.0 || 4x4 || [[File:DMS1044.png|300px]] || 49
|- style="text-align:center;"
| 1.0 || 8x8 || [[File:DMS10882.png|300px]] || 590
|- style="text-align:center;"
| 1.0 || 16x16 || [[File:DMS101616.png|300px]] || ~6300
|- style="text-align:center;"
| 1.0 || 32x32 || [[File:DMS103232.png|300px]] || ~110000
|- style="text-align:center;"
| 2.0 || 4x4 || [[File:DMS2044.png|300px]] || -
|- style="text-align:center;"
| 2.0 || 8x8 || [[File:DMS2088.png|300px]] || -
|}
{| class="wikitable floatright" width=42%
|+ ''Table 6: Number of cycles to be ignored for each system size''
! System Size !! Number of cycles before averaging
|- style="text-align:center;"
| 2x2 || 0
|- style="text-align:center;"
| 4x4 || 100
|- style="text-align:center;"
| 8x8 || 1000
|- style="text-align:center;"
| 16x16 || 8000
|- style="text-align:center;"
| 32x32 || 120000
|}
Analysis of these graphs indicates that at higher temperatures, such as 2.0 (also observed at 1.5), large fluctuations in the energy and magnetisation are observed - these fluctuations are the reason that the average values of the properties must be taken. As the temperature is increased for systems of size 4x4, 8x8 and 16x16, it is clear that the number of cycles required in order to reach equilibrium increases. Hence, for the temperature range to be considered later (0.25 to 5.00), the required number of cycles was overestimated in order to ensure that all measurements were taken whilst the system was in equilibrium. The proposed numbers of cycles to be ignored for each system size are presented in ''Table 6''.

The python script developed up to this point was modified to account for these values by inclusion of a skip_region variable, which defines the number of cycles performed before energies and magnetisations contribute to the self.X values (before averaging occurs). The modified script is presented [[Mod:DMS3053-5|here]].

===Running over a range of temperatures===
[[File:DMS88dat.png|300px|thumb|right|'''''Figure 5''': Average energy and average magnetisation vs. temperature for 8x8 lattice, with error bars'']]
Using the python script modified in the previous exercise, the code can now be used to simulate the 8x8 system at a range of temperatures, using the ILtemperaturerange.py file (shown [[Mod:DMS3053-temprange|here]]). Here, the temperature range of 0.25 to 5.00 was used, with a separation of 0.25 between points, whilst the runtime was set to 10000 (neglecting the property values for the first 1000 cycles). Running this simulation produced the graphs in ''Figure 5'', where error bars computed using standard errors have also been included (these are small as a consequence of small standard errors). From the graph of average energy versus temperature, the phase transition can be observed - this occurs in the region with a gradient that is not close to zero. The data used here (temperature, average energies, average squared-energies, average magnetisations and average squared-magnetisations) was then saved as a numpy array in a new file, 8x8.dat.

==The effect of system size==
[[File:DMSLatticeSizeCombinedPlot.png|300px|thumb|right|'''''Figure 6''': Average energy and average magnetisation (per spins) vs. temperature for multiple lattice sizes'']]
The process conducted for the 8x8 lattice in the previous exercise was then repeated for lattices of sizes 2x2, 4x4, 16x16 and 32x32, with the data saved in .dat files. These files were then accessed, and the average energy and magnetisation data were plotted on one graph for all of the lattices sizes - this was achieved using the script presented [[Mod:DMS3053-6|here]]. The graphs produced in this manner are shown in ''Figure 6''.

A consideration of this graph suggests that in order to capture the long range fluctuations, whilst minimising the computational time required, an 8x8 lattice is likely to be the optimum choice. This is because the graph for this system size is comparable to that for a 32x32 lattice, whilst being faster to compute.

==Determining the heat capacity==
[[File:DMSheatcapacity2.png|300px|thumb|right|'''''Figure 7''': Heat capacity (per spin) versus temperature for different lattice sizes'']]
Using the .dat files previously produced, the heat capacity was calculated for each lattice size using the equation
::<math>C = \frac{\partial E}{\partial T} = \frac{\mathrm{Var}[E]}{k_B T^2}</math>, (''eq. 9'') 
where <math>\mathrm{Var}[E] = <E^2> - <E>^2 </math>. When implementing this, the kB term was neglected due to the energy values having units of kB. The script used for this purpose is provided [[DMS3053-7|here]]. The plot of heat capacity per spin versus temperature for all of the lattice sizes considered is presented in ''Figure 7''.

==Locating the Curie temperature==
===Comparison with C++ Data===
The data for the heat capacity generated using the python script prepared in this experiment was compared to that from longer C++ computations - graphs showing this comparison are presented in ''Table 7'' for a range of lattice sizes. The Python code used to produce these graphs is shown [[Mod:DMS3053-8|here]].

Considering these graphs, it is clear that, in general, there is a reasonable correlation between the Python and C++ data; however, some of the data, particularly that for high lattice sizes, shows that the Python computations have not always found the maximum of heat capacity. This correlation would be improved by making computations at the same range of temperatures, but with a smaller gap between the temperatures taken; however, this would substantially increase computation time.
{| class="wikitable center" width=70%
|+ ''Table 7: Graphs of heat capacity (per spin) versus temperature for C++ and Python data''
|- style="text-align:center;"
| [[File:DMS2x2c.png|300px]] || [[File:DMS4x4c.png|300px]] || [[File:DMS8x8c.png|300px]]
|- style="text-align:center;"
| 2x2 || 4x4 || 8x8
|- style="text-align:center;"
| [[File:DMS16x16c.png|300px]] || [[File:DMS32x32c.png|300px]]
|- style="text-align:center;"
| 16x16 || 32x32
|}

===Polynomial Fitting===
[[File:DMS8x8513.png|300px|thumb|right|'''''Figure 8''': Heat capacity (per spin) versus temperature for 8x8 system with two polynomial fits'']]
In order to make use of the C++ data in finding the Curie temperature for the Ising Lattices under consideration, polynomials were fit to the data - the script written for this purpose is shown [[Mod:DMS3053-9|here]]. For this fitting, it was found that a polynomial order of 5 was required to provide a good fit for the 2x2 data - this increased significantly as the lattice size increased. An example fit is shown for the 8x8 system in ''Figure 8'', where the polynomial fit is shown for orders 5 and 13. A consideration of this graph reveals that whilst a polynomial of order 5 may be appropriate for a 2x2 system, it is inadequate for the larger system of 8x8. Whilst an order of 13 substantially improves the polynomial fit, one must, in general, take care with 'overfitting' data.
[[File:Py8x8(13fit).png|300px|thumb|left|'''''Figure 9''': Heat capacity (per spin) versus temperature for Python data for 8x8 system with a 13th order polynomial fit'']]
For comparison, a 13th order polynomial was fitted to the 8x8 Python data previously computed - this is shown in ''Figure 9''. Here, it is evident that for this data, a higher order polynomial is required to obtain a fit comparable to that for the C++ data above.

===Fitting in a Particular Temperature Range===
[[File:DMS8x8peak(3).png|300px|thumb|right|'''''Figure 10''': Heat capacity (per spin) versus temperature for 8x8 system with peak polynomial fit'']]
As was observed in the previous exercise, large polynomial orders are required to fit the C++ data well across the whole temperature range. The python script was modified to that presented [[Mod:DMS3053-10|here]] (this script also contains the python code to compute the maximum heat capacity and temperature at which this occurs for the following exercise), which fits a polynomial only in the region of the maximum heat capacity for the system. An example of such fit is shown in ''Figure 10'' for the 8x8 system. Here, it should be noted that for all of the system sizes studied, a polynomial order of 3 was used - this is a clear improvement compared to the 13th order polynomials used previously.

===Finding the Peak in Heat Capacity===
{| class="wikitable floatright" width=42%
|+ ''Table 8: Lattice sizes and their corresponding Curie temperatures''
! System Size !! Number of cycles before averaging
|- style="text-align:center;"
| 2x2 || 2.53503504
|- style="text-align:center;"
| 4x4 || 2.43843844
|- style="text-align:center;"
| 8x8 || 2.33433433
|- style="text-align:center;"
| 16x16 || 2.30455455
|- style="text-align:center;"
| 32x32 || 2.27752753
|}
[[File:DMSCurieTemperature.png|300px|thumb|left|'''''Figure 11''': Curie temperature vs. 1/(lattice length), with extrapolated linear fit'']]
In order to find the Curie temperature for an infinite Ising Lattice, the Curie temperature for each system size considered was first found (using the script shown in the previous exercise). These temperatures were then saved to a .dat file (whose contents are also showed in ''Table 8'', along with their corresponding lattice sizes. Finally, using the script presented [[Mod:DMS3053-11|here]], a graph of Curie temperature versus the inverse of the lattice length was plotted, according to the equation
::<math>T_{C, L} = \frac{A}{L} + T_{C,\infty}</math>, ''(eq. 10)
where <math>T_{C, L}</math> is the Curie temperature for a lattice with length L and <math>T_{C,\infty}</math> is the Curie temperature for an infinite Ising lattice. Hence, it is clear that the desired Curie temperature must be the y-intercept of the graph shown in ''Figure 11'' (hence the use of extrapolation in the python script). Taking this extrapolated value gives a Curie temperature of 2.271. This value can be compared to the theoretical exact value of 2.27,<ref>D. K. Khudier, N. I. Fawaz, ''Int. Lett. Them. Phys. Astron.'', 2013, '''10''', 201-212. Available from: http://www.ilcpa.pl/wp-content/uploads/2012/11/ILCPA-102-2013-201-2121.pdf</ref> which indicates a good agreement between the value calculated in this investigation and the theoretical exact value. This is surprising given that it would be expected that the polynomial fitting of the data to locate the maximum would contribute a considerable degree of error to the final value.

==References==
<references/>
</div>

Rep:Mod:DMS3053

2015-02-26T10:20:40Z

Ds3012: /* Average Energy and Magnetisation */

'''CMP Programming Experiment - Daniel Spencer, 00736964'''
<div style="text-align: justify">
==Introduction to the Ising Model==
===Minimum energy of the Ising Model===
Using the equation 
::<math>E= - \frac{1}{2} J \sum_i^N \sum_{j\ \in\ \mathrm{neighbours}\left(i\right)} s_i s_j</math> (''eq. 1'') 
the minimum energy of an Ising lattice of <math>D</math> dimensions, with <math>N</math> spins (where each
spin had a value of +1 or -1) and an interaction strength of <math>J</math> was considered. This was achieved first through a consideration of a one-dimensional system with five parallel spins (where the spins are parallel as this corresponds to the minimum energy arrangement of the system). Hence, the energy of this linear system was found to be 
::<math>E_\text{min,1D} = -5J </math>. 
For a linear, one-dimensional system, the number of neigbouring spins is two. The number of neighbours can be determined for two- and three- dimensional systems through a geometric consideration of their structure - the values are presented in ''Table 1''.
{| class="wikitable floatright" width=42%
|+ ''Table 1: Dimension numbers and number of neighbours''
! Number of Dimensions, D !! Number of Neighbours
|- style="text-align:center;"
| 1 || 2
|- style="text-align:center;"
| 2 || 4
|- style="text-align:center;"
| 3 || 6
|- style="text-align:center;"
| D || 2D
|}
These data indicate that the number of neighbours is twice the number of dimensions, for the dimensions considered here. This can be extrapolated to give the general number of neighbours as <math>2D</math>.

For the minimum energy of the system, where all spins are parallel, every combination <math>s_i s_j</math> has a value of 1. Notably, for each value of <math>i</math>, there will be <math>2D</math> neighbour interactions. Ergo, using ''eq. 1'', the general minimum energy can be found to be
::<math>E_\text{min,D} = -DNJ </math> (''eq. 2''). 
To check this equation, it can be applied to the two-dimensional Ising lattice with 25 spins - this gives a value of
::<math>E_\text{min,2D} = -50J </math>, 
which matches with the value predicted from first-principles.

For this D-dimensional system, the multiplicity (i.e. the number of ways of achieving the specified configuration of spins) must be equal to two, as either all of the spins could be aligned 'up' (+1) or 'down' (-1). Using this multiplicity, the entropy of the system can be calculated using the equation
::<math>S = k_B \ln\Omega</math>, (''eq. 3'') 
where Ω is the number of microstates (equal to the multiplicity in this case), which gives a value of <math>k_B \ln2 </math>, or 9.57 x 10-24 J K-1.

===Spin 'flipping'===
[[File:ThirdYearCMPExpt-IsingSketch.png|300px|thumb|right|'' '''Figure 1''': Representation of Ising lattices in one (N=5), two (N=25), and three (N=125) dimensions. +1 and -1 spins are denoted by the red and blue cells respectively. Diagram taken from the lab script.'']]
Using the Ising model, it is also possible to consider a change in state, reflected by a 'flipping' of the direction of one of the lattice spins. For this case, the energy (using ''eq. 1'') can be determined to be
::<math>E'= - \frac{1}{2} J (2DN - 4D - 4D) = 4DJ - DNJ</math>, (''eq. 4'') 
where the additional <math>4D</math> terms arise from the loss of 4D stabilising spin-aligned interactions and the gain of 4D destabilising spins anti-aligned interactions following spin 'flipping'. Using ''eq. 2'' and ''eq. 4'', the change in energy derived from this spin 'flip' can be calculated to be
::<math>\Delta E= 4DJ - DNJ + DNJ = 4DJ</math>. (''eq. 5'') 
For a system with three dimensions (D = 3) and 1000 spins (N = 1000), the system, using ''eq. 5'', was determined to increase in energy by <math>12 J</math>. Notably, this change in energy is independent of the number of spins in the system - it depends only on the number of dimensions and J.

A significant consideration with regards to the spin 'flipping' described here is the accompanying increase in entropy - the driving force for this process. For the scenario describing the change in direction of a single spin, the multiplicity of the system will be <math>2N</math> - this is a consequence of the system prior to 'flipping' having a multiplicity of two (all spins aligned 'up' or 'down'), where now, any one of the spins could flip, adding the factor of N to the multiplicity. Hence, the new entropy can be defined to be
::<math>S' = k_B \ln 2N</math>, (''eq. 6'') 
which allows the change in entropy to be calculated according to ''eq. 7''.
::<math>\Delta S = k_B \ln 2N - k_B \ln2 = k_B \ln N</math> (''eq. 7'') 
For the system described above (D = 3, N = 1000), the change in entropy associated with the spin 'flip' process is therefore <math>k_B ln 1000</math>, which is equal to 9.53 x 10-23 J K-1.

===Magnetisation===
{| class="wikitable floatleft" width=42%
|+ ''Table 2: Ising lattices and magnetisations''
! Ising Lattice !! Magnetisation
|- style="text-align:center;"
| 1D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 2D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 3D at 0 K || 1000 or -1000
|}
''Figure 1'' shows three examples of Ising lattices, with one, two and three dimensions respectively. Using the equation for magnetisation (''eq. 8''), the magnetisations of these systems can be calculated to be those presented in ''Table 2''.
::<math>M= \sum_i s_i</math> (''eq. 8'') 
For the three-dimensional system with 1000 spins at a temperature of 0 K, all of the spins must be aligned either 'up' or 'down', as the entropic increase associated with 'flipped' spins does not provide a driving force at absolute zero - the only factor to consider is that of the energy, which is a minimum when all of the spins are aligned. For this case, the magnetisation could be either 1000 or -1000, depending upon the direction of the spin alignment. From a consideration of the magnetisation values calculated here, it is evident that with all of the spins aligned, the (magnitude of the) magnetisation of the system is at a maximum.

==Calculating the energy and magnetisation==
===Modifying the files===
[[File:DMStest_output2.png|300px|thumb|right|'' '''Figure 2''': Output image from testing IsingLattice.py using Ilcheck.py'']]
In order to use Python to compute the energy and magnetisation for a given two-dimensional Ising lattice, the class IsingLattice was used, where energy() and magnetisation() functions were written to calculate their corresponding properties for a random numpy array of spins (generated using np.random.choice). For this aspect of the experiment, the value of J was assumed to be 1.0, working in reduced units. The Python script developed can be viewed [[Mod:DMS3053-1|here]], including annotations.

===Testing the files===
In order to test the script prepared thus far, the Ilcheck.py script was run, generating the image presented in ''Figure 2''. An examination of this output clearly indicates that the script provides accurate energies and magnetisations for the minimum and maximum energy configurations, along with for an intermediate, random arrangement. Hence, it can be concluded that at the current level, the Python script is functioning as required.

==Introduction to the Monte Carlo simulation==
===Average Energy and Magnetisation===
[[File:DMSILanim3.png|300px|thumb|right|'''''Figure 3''': Animation result from ILanim.py, showing the resting of the system in the minimum energy state'']]
In order to consider the generalisability of the prepared script, it is important to analyse how the script will function for large systems, such as those with 100 spins in the spin array. As each of these spins can be either 'up' or 'down', each spin has two choices. Hence, the number of possible configurations for the system can be written as <math>2^{100}</math>, which has a value of 1.2677 x 1030.

If one considers the sampling of a single configuration to take 1 x 10-9 s, then it is clear that sampling all of these considerations would take a total of 1.2677 x 1021 s (also expressed as 4.017 x 1013 years). From this analysis, it is evident that the sampling of configurations was a significant consideration in the writing of a python script for this task.

In order to account for this, the technique of importance sampling was implemented, using the statistical Boltzmann distribution, <math>\exp(- \Delta E / k_B T)</math>. Note that as the energy computed using the energy() function is in units of kB, this factor is not included in the script.

===Modifying IsingLattice.py to Implement a Monte Carlo Cycle===
The python script developed at this stage is presented [[Mod:DMS3053-2|here]], accompanied by annotations to explain how the script functions.

===Simulating the Monte Carlo Cycles===
{| class="wikitable floatright" width=42%
|+ ''Table 3: statistics() output for animated system at global minimum configuration (Figure 3)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.70542501728
|- style="text-align:center;"
| <E2> || 3.13520970111
|- style="text-align:center;"
| <M> || -0.829971492744
|- style="text-align:center;"
| <M2> || 0.770986982766
|}
For cases where T < Tc, it would be expected that the system would have a spontaneous magnetisation. When T > Tc, the entropy will be the dominating factor, potentially resulting in the system having a magnetisation of zero.
{| class="wikitable floatright" width=42%
|+ ''Table 4: statistics() output for animated system at meta-stable configuration (Figure 4)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.35076450189
|- style="text-align:center;"
| <E2> || 1.89025801939
|- style="text-align:center;"
| <M> || -0.344104665826
|- style="text-align:center;"
| <M2> || 0.138855365306
|}
Using the presented script and the ILanim.py script, the Monte Carlo cycles can be simulated to view the results on the spin array as the process progresses. Here, the system under consideration was an 8 x 8 spin array, at a temperature of 0.5. ''Figure 3'' shows the typical outcome of the animation, with the system having reached the most stable, minimum energy arrangement. For the result presented here, the output of the statistics() function was that shown in ''Table 3''.

It was also observed that the system could locate a meta-stable state, with large regions of spin 'up' and 'down' spins. An example of such a result is presented in ''Figure 4'' (for which the output data from statistics() is presented in ''Table 4'').

==Accelerating the code==

In order to examine the efficiency of the python script developed thus far, the Iltimetrial.py script was utilised to investigate the time taken to perform 2000 Monte Carlo cycles. This script was modified to the version presented [[Mod:DMS3053-3|here]], which repeats the time measurement a defined number of times, then calculates the average time and the standard error in this average. For the Monte Carlo script prepared previously, the average time for 2000 Monte Carlo cycles was measured to be 5.475804 s and a standard error was calculated to be 0.008325 s, with 100 measurements made using the script.

Evidently, the current script is slow at conducting large numbers of Monte Carlo cycles and hence, a more efficient script was developed using the np.roll, np.multiply and np.sum functions - this is presented [[Mod:DMS3053-4|here]].

After this optimisation of the python script, the Iltimetrial.py script was re-run, giving an average time of 0.291467 s, with a standard error of 0.000156 s. Clearly, this optimised script is substantially faster than that developed previously (approximately 19 times faster).

==The effect of temperature==
===Correcting the averaging code===
As the equilibrium state of the system requires a number of Monte Carlo cycles to be reached, it is evident that the average energies and magnetisations are accounting for values for non-equilibrium arrangements - this was accounted for through a consideration of the number of cycles required to reach equilibrium. For this, the ILfinalframe.py script was used, giving the graphs shown in ''Table 5''. Here, each system was run for 150000 Monte Carlo cycles.
{| class="wikitable center" width=70%
|+ ''Table 5: Graphs of energy and magnetisation versus number of Monte Carlo cycles for different temperatures and system sizes''
! Temperature !! System Size !! Resulting Graphs !! Cycles for Equilibrium
|- style="text-align:center;"
| 0.5 || 4x4 || [[File:DMS0544.png|300px]] || 24
|- style="text-align:center;"
| 0.5 || 8x8 || [[File:DMS0588.png|300px]] || 392
|- style="text-align:center;"
| 0.5 || 16x16 || [[File:DMS051616.png|300px]] || 5549
|- style="text-align:center;"
| 1.0 || 2x2 || [[File:DMS1022.png|300px]] || (0)
|- style="text-align:center;"
| 1.0 || 4x4 || [[File:DMS1044.png|300px]] || 49
|- style="text-align:center;"
| 1.0 || 8x8 || [[File:DMS10882.png|300px]] || 590
|- style="text-align:center;"
| 1.0 || 16x16 || [[File:DMS101616.png|300px]] || ~6300
|- style="text-align:center;"
| 1.0 || 32x32 || [[File:DMS103232.png|300px]] || ~110000
|- style="text-align:center;"
| 2.0 || 4x4 || [[File:DMS2044.png|300px]] || -
|- style="text-align:center;"
| 2.0 || 8x8 || [[File:DMS2088.png|300px]] || -
|}
{| class="wikitable floatright" width=42%
|+ ''Table 6: Number of cycles to be ignored for each system size''
! System Size !! Number of cycles before averaging
|- style="text-align:center;"
| 2x2 || 0
|- style="text-align:center;"
| 4x4 || 100
|- style="text-align:center;"
| 8x8 || 1000
|- style="text-align:center;"
| 16x16 || 8000
|- style="text-align:center;"
| 32x32 || 120000
|}
Analysis of these graphs indicates that at higher temperatures, such as 2.0 (also observed at 1.5), large fluctuations in the energy and magnetisation are observed - these fluctuations are the reason that the average values of the properties must be taken. As the temperature is increased for systems of size 4x4, 8x8 and 16x16, it is clear that the number of cycles required in order to reach equilibrium increases. Hence, for the temperature range to be considered later (0.25 to 5.00), the required number of cycles was overestimated in order to ensure that all measurements were taken whilst the system was in equilibrium. The proposed numbers of cycles to be ignored for each system size are presented in ''Table 6''.

The python script developed up to this point was modified to account for these values by inclusion of a skip_region variable, which defines the number of cycles performed before energies and magnetisations contribute to the self.X values (before averaging occurs). The modified script is presented [[Mod:DMS3053-5|here]].

===Running over a range of temperatures===
[[File:DMS88dat.png|300px|thumb|right|'''''Figure 5''': Average energy and average magnetisation vs. temperature for 8x8 lattice, with error bars'']]
Using the python script modified in the previous exercise, the code can now be used to simulate the 8x8 system at a range of temperatures, using the ILtemperaturerange.py file (shown [[Mod:DMS3053-temprange|here]]). Here, the temperature range of 0.25 to 5.00 was used, with a separation of 0.25 between points, whilst the runtime was set to 10000 (neglecting the property values for the first 1000 cycles). Running this simulation produced the graphs in ''Figure 5'', where error bars computed using standard errors have also been included (these are small as a consequence of small standard errors). From the graph of average energy versus temperature, the phase transition can be observed - this occurs in the region with a gradient that is not close to zero. The data used here (temperature, average energies, average squared-energies, average magnetisations and average squared-magnetisations) was then saved as a numpy array in a new file, 8x8.dat.

==The effect of system size==
[[File:DMSLatticeSizeCombinedPlot.png|300px|thumb|right|'''''Figure 6''': Average energy and average magnetisation (per spins) vs. temperature for multiple lattice sizes'']]
The process conducted for the 8x8 lattice in the previous exercise was then repeated for lattices of sizes 2x2, 4x4, 16x16 and 32x32, with the data saved in .dat files. These files were then accessed, and the average energy and magnetisation data were plotted on one graph for all of the lattices sizes - this was achieved using the script presented [[Mod:DMS3053-6|here]]. The graphs produced in this manner are shown in ''Figure 6''.

A consideration of this graph suggests that in order to capture the long range fluctuations, whilst minimising the computational time required, an 8x8 lattice is likely to be the optimum choice. This is because the graph for this system size is comparable to that for a 32x32 lattice, whilst being faster to compute.

==Determining the heat capacity==
[[File:DMSheatcapacity2.png|300px|thumb|right|'''''Figure 7''': Heat capacity (per spin) versus temperature for different lattice sizes'']]
Using the .dat files previously produced, the heat capacity was calculated for each lattice size using the equation
::<math>C = \frac{\partial E}{\partial T} = \frac{\mathrm{Var}[E]}{k_B T^2}</math>, (''eq. 9'') 
where <math>\mathrm{Var}[E] = <E^2> - <E>^2 </math>. When implementing this, the kB term was neglected due to the energy values having units of kB. The script used for this purpose is provided [[DMS3053-7|here]]. The plot of heat capacity per spin versus temperature for all of the lattice sizes considered is presented in ''Figure 7''.

==Locating the Curie temperature==
===Comparison with C++ Data===
The data for the heat capacity generated using the python script prepared in this experiment was compared to that from longer C++ computations - graphs showing this comparison are presented in ''Table 7'' for a range of lattice sizes. The Python code used to produce these graphs is shown [[Mod:DMS3053-8|here]].

Considering these graphs, it is clear that, in general, there is a reasonable correlation between the Python and C++ data; however, some of the data, particularly that for high lattice sizes, shows that the Python computations have not always found the maximum of heat capacity. This correlation would be improved by making computations at the same range of temperatures, but with a smaller gap between the temperatures taken; however, this would substantially increase computation time.
{| class="wikitable center" width=70%
|+ ''Table 7: Graphs of heat capacity (per spin) versus temperature for C++ and Python data''
|- style="text-align:center;"
| [[File:DMS2x2c.png|300px]] || [[File:DMS4x4c.png|300px]] || [[File:DMS8x8c.png|300px]]
|- style="text-align:center;"
| 2x2 || 4x4 || 8x8
|- style="text-align:center;"
| [[File:DMS16x16c.png|300px]] || [[File:DMS32x32c.png|300px]]
|- style="text-align:center;"
| 16x16 || 32x32
|}

===Polynomial Fitting===
[[File:DMS8x8513.png|300px|thumb|right|'''''Figure 8''': Heat capacity (per spin) versus temperature for 8x8 system with two polynomial fits'']]
In order to make use of the C++ data in finding the Curie temperature for the Ising Lattices under consideration, polynomials were fit to the data - the script written for this purpose is shown [[Mod:DMS3053-9|here]]. For this fitting, it was found that a polynomial order of 5 was required to provide a good fit for the 2x2 data - this increased significantly as the lattice size increased. An example fit is shown for the 8x8 system in ''Figure 8'', where the polynomial fit is shown for orders 5 and 13. A consideration of this graph reveals that whilst a polynomial of order 5 may be appropriate for a 2x2 system, it is inadequate for the larger system of 8x8. Whilst an order of 13 substantially improves the polynomial fit, one must, in general, take care with 'overfitting' data.
[[File:Py8x8(13fit).png|300px|thumb|left|'''''Figure 9''': Heat capacity (per spin) versus temperature for Python data for 8x8 system with a 13th order polynomial fit'']]
For comparison, a 13th order polynomial was fitted to the 8x8 Python data previously computed - this is shown in ''Figure 9''. Here, it is evident that for this data, a higher order polynomial is required to obtain a fit comparable to that for the C++ data above.

===Fitting in a Particular Temperature Range===
[[File:DMS8x8peak(3).png|300px|thumb|right|'''''Figure 10''': Heat capacity (per spin) versus temperature for 8x8 system with peak polynomial fit'']]
As was observed in the previous exercise, large polynomial orders are required to fit the C++ data well across the whole temperature range. The python script was modified to that presented [[Mod:DMS3053-10|here]] (this script also contains the python code to compute the maximum heat capacity and temperature at which this occurs for the following exercise), which fits a polynomial only in the region of the maximum heat capacity for the system. An example of such fit is shown in ''Figure 10'' for the 8x8 system. Here, it should be noted that for all of the system sizes studied, a polynomial order of 3 was used - this is a clear improvement compared to the 13th order polynomials used previously.

===Finding the Peak in Heat Capacity===
{| class="wikitable floatright" width=42%
|+ ''Table 8: Lattice sizes and their corresponding Curie temperatures''
! System Size !! Number of cycles before averaging
|- style="text-align:center;"
| 2x2 || 2.53503504
|- style="text-align:center;"
| 4x4 || 2.43843844
|- style="text-align:center;"
| 8x8 || 2.33433433
|- style="text-align:center;"
| 16x16 || 2.30455455
|- style="text-align:center;"
| 32x32 || 2.27752753
|}
[[File:DMSCurieTemperature.png|300px|thumb|left|'''''Figure 11''': Curie temperature vs. 1/(lattice length), with extrapolated linear fit'']]
In order to find the Curie temperature for an infinite Ising Lattice, the Curie temperature for each system size considered was first found (using the script shown in the previous exercise). These temperatures were then saved to a .dat file (whose contents are also showed in ''Table 8'', along with their corresponding lattice sizes. Finally, using the script presented [[Mod:DMS3053-11|here]], a graph of Curie temperature versus the inverse of the lattice length was plotted, according to the equation
::<math>T_{C, L} = \frac{A}{L} + T_{C,\infty}</math>, ''(eq. 10)
where <math>T_{C, L}</math> is the Curie temperature for a lattice with length L and <math>T_{C,\infty}</math> is the Curie temperature for an infinite Ising lattice. Hence, it is clear that the desired Curie temperature must be the y-intercept of the graph shown in ''Figure 11'' (hence the use of extrapolation in the python script). Taking this extrapolated value gives a Curie temperature of 2.271. This value can be compared to the theoretical exact value of 2.27,<ref>D. K. Khudier, N. I. Fawaz, ''Int. Lett. Them. Phys. Astron.'', 2013, '''10''', 201-212. Available from: http://www.ilcpa.pl/wp-content/uploads/2012/11/ILCPA-102-2013-201-2121.pdf</ref> which indicates a good agreement between the value calculated in this investigation and the theoretical exact value. This is surprising given that it would be expected that the polynomial fitting of the data to locate the maximum would contribute a considerable degree of error to the final value.

==References==
<references/>
</div>

Rep:Mod:DMS3053

2015-02-26T10:20:21Z

Ds3012: /* Introduction to the Monte Carlo simulation */

'''CMP Programming Experiment - Daniel Spencer, 00736964'''
<div style="text-align: justify">
==Introduction to the Ising Model==
===Minimum energy of the Ising Model===
Using the equation 
::<math>E= - \frac{1}{2} J \sum_i^N \sum_{j\ \in\ \mathrm{neighbours}\left(i\right)} s_i s_j</math> (''eq. 1'') 
the minimum energy of an Ising lattice of <math>D</math> dimensions, with <math>N</math> spins (where each
spin had a value of +1 or -1) and an interaction strength of <math>J</math> was considered. This was achieved first through a consideration of a one-dimensional system with five parallel spins (where the spins are parallel as this corresponds to the minimum energy arrangement of the system). Hence, the energy of this linear system was found to be 
::<math>E_\text{min,1D} = -5J </math>. 
For a linear, one-dimensional system, the number of neigbouring spins is two. The number of neighbours can be determined for two- and three- dimensional systems through a geometric consideration of their structure - the values are presented in ''Table 1''.
{| class="wikitable floatright" width=42%
|+ ''Table 1: Dimension numbers and number of neighbours''
! Number of Dimensions, D !! Number of Neighbours
|- style="text-align:center;"
| 1 || 2
|- style="text-align:center;"
| 2 || 4
|- style="text-align:center;"
| 3 || 6
|- style="text-align:center;"
| D || 2D
|}
These data indicate that the number of neighbours is twice the number of dimensions, for the dimensions considered here. This can be extrapolated to give the general number of neighbours as <math>2D</math>.

For the minimum energy of the system, where all spins are parallel, every combination <math>s_i s_j</math> has a value of 1. Notably, for each value of <math>i</math>, there will be <math>2D</math> neighbour interactions. Ergo, using ''eq. 1'', the general minimum energy can be found to be
::<math>E_\text{min,D} = -DNJ </math> (''eq. 2''). 
To check this equation, it can be applied to the two-dimensional Ising lattice with 25 spins - this gives a value of
::<math>E_\text{min,2D} = -50J </math>, 
which matches with the value predicted from first-principles.

For this D-dimensional system, the multiplicity (i.e. the number of ways of achieving the specified configuration of spins) must be equal to two, as either all of the spins could be aligned 'up' (+1) or 'down' (-1). Using this multiplicity, the entropy of the system can be calculated using the equation
::<math>S = k_B \ln\Omega</math>, (''eq. 3'') 
where Ω is the number of microstates (equal to the multiplicity in this case), which gives a value of <math>k_B \ln2 </math>, or 9.57 x 10-24 J K-1.

===Spin 'flipping'===
[[File:ThirdYearCMPExpt-IsingSketch.png|300px|thumb|right|'' '''Figure 1''': Representation of Ising lattices in one (N=5), two (N=25), and three (N=125) dimensions. +1 and -1 spins are denoted by the red and blue cells respectively. Diagram taken from the lab script.'']]
Using the Ising model, it is also possible to consider a change in state, reflected by a 'flipping' of the direction of one of the lattice spins. For this case, the energy (using ''eq. 1'') can be determined to be
::<math>E'= - \frac{1}{2} J (2DN - 4D - 4D) = 4DJ - DNJ</math>, (''eq. 4'') 
where the additional <math>4D</math> terms arise from the loss of 4D stabilising spin-aligned interactions and the gain of 4D destabilising spins anti-aligned interactions following spin 'flipping'. Using ''eq. 2'' and ''eq. 4'', the change in energy derived from this spin 'flip' can be calculated to be
::<math>\Delta E= 4DJ - DNJ + DNJ = 4DJ</math>. (''eq. 5'') 
For a system with three dimensions (D = 3) and 1000 spins (N = 1000), the system, using ''eq. 5'', was determined to increase in energy by <math>12 J</math>. Notably, this change in energy is independent of the number of spins in the system - it depends only on the number of dimensions and J.

A significant consideration with regards to the spin 'flipping' described here is the accompanying increase in entropy - the driving force for this process. For the scenario describing the change in direction of a single spin, the multiplicity of the system will be <math>2N</math> - this is a consequence of the system prior to 'flipping' having a multiplicity of two (all spins aligned 'up' or 'down'), where now, any one of the spins could flip, adding the factor of N to the multiplicity. Hence, the new entropy can be defined to be
::<math>S' = k_B \ln 2N</math>, (''eq. 6'') 
which allows the change in entropy to be calculated according to ''eq. 7''.
::<math>\Delta S = k_B \ln 2N - k_B \ln2 = k_B \ln N</math> (''eq. 7'') 
For the system described above (D = 3, N = 1000), the change in entropy associated with the spin 'flip' process is therefore <math>k_B ln 1000</math>, which is equal to 9.53 x 10-23 J K-1.

===Magnetisation===
{| class="wikitable floatleft" width=42%
|+ ''Table 2: Ising lattices and magnetisations''
! Ising Lattice !! Magnetisation
|- style="text-align:center;"
| 1D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 2D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 3D at 0 K || 1000 or -1000
|}
''Figure 1'' shows three examples of Ising lattices, with one, two and three dimensions respectively. Using the equation for magnetisation (''eq. 8''), the magnetisations of these systems can be calculated to be those presented in ''Table 2''.
::<math>M= \sum_i s_i</math> (''eq. 8'') 
For the three-dimensional system with 1000 spins at a temperature of 0 K, all of the spins must be aligned either 'up' or 'down', as the entropic increase associated with 'flipped' spins does not provide a driving force at absolute zero - the only factor to consider is that of the energy, which is a minimum when all of the spins are aligned. For this case, the magnetisation could be either 1000 or -1000, depending upon the direction of the spin alignment. From a consideration of the magnetisation values calculated here, it is evident that with all of the spins aligned, the (magnitude of the) magnetisation of the system is at a maximum.

==Calculating the energy and magnetisation==
===Modifying the files===
[[File:DMStest_output2.png|300px|thumb|right|'' '''Figure 2''': Output image from testing IsingLattice.py using Ilcheck.py'']]
In order to use Python to compute the energy and magnetisation for a given two-dimensional Ising lattice, the class IsingLattice was used, where energy() and magnetisation() functions were written to calculate their corresponding properties for a random numpy array of spins (generated using np.random.choice). For this aspect of the experiment, the value of J was assumed to be 1.0, working in reduced units. The Python script developed can be viewed [[Mod:DMS3053-1|here]], including annotations.

===Testing the files===
In order to test the script prepared thus far, the Ilcheck.py script was run, generating the image presented in ''Figure 2''. An examination of this output clearly indicates that the script provides accurate energies and magnetisations for the minimum and maximum energy configurations, along with for an intermediate, random arrangement. Hence, it can be concluded that at the current level, the Python script is functioning as required.

==Introduction to the Monte Carlo simulation==
===Average Energy and Magnetisation===
[[File:DMSILanim3.png|300px|thumb|right|'''''Figure 3''': Animation result from ILanim.py, showing the resting of the system in the minimum energy state'']]
[[File:DMSILanim_meta.png|300px|thumb|left|'''''Figure 4''': Animation result from ILanim.py, showing the resting of the system in a meta-stable state'']]

In order to consider the generalisability of the prepared script, it is important to analyse how the script will function for large systems, such as those with 100 spins in the spin array. As each of these spins can be either 'up' or 'down', each spin has two choices. Hence, the number of possible configurations for the system can be written as <math>2^{100}</math>, which has a value of 1.2677 x 1030.

If one considers the sampling of a single configuration to take 1 x 10-9 s, then it is clear that sampling all of these considerations would take a total of 1.2677 x 1021 s (also expressed as 4.017 x 1013 years). From this analysis, it is evident that the sampling of configurations was a significant consideration in the writing of a python script for this task.

In order to account for this, the technique of importance sampling was implemented, using the statistical Boltzmann distribution, <math>\exp(- \Delta E / k_B T)</math>. Note that as the energy computed using the energy() function is in units of kB, this factor is not included in the script.

===Modifying IsingLattice.py to Implement a Monte Carlo Cycle===
The python script developed at this stage is presented [[Mod:DMS3053-2|here]], accompanied by annotations to explain how the script functions.

===Simulating the Monte Carlo Cycles===
{| class="wikitable floatright" width=42%
|+ ''Table 3: statistics() output for animated system at global minimum configuration (Figure 3)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.70542501728
|- style="text-align:center;"
| <E2> || 3.13520970111
|- style="text-align:center;"
| <M> || -0.829971492744
|- style="text-align:center;"
| <M2> || 0.770986982766
|}
For cases where T < Tc, it would be expected that the system would have a spontaneous magnetisation. When T > Tc, the entropy will be the dominating factor, potentially resulting in the system having a magnetisation of zero.
{| class="wikitable floatright" width=42%
|+ ''Table 4: statistics() output for animated system at meta-stable configuration (Figure 4)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.35076450189
|- style="text-align:center;"
| <E2> || 1.89025801939
|- style="text-align:center;"
| <M> || -0.344104665826
|- style="text-align:center;"
| <M2> || 0.138855365306
|}
Using the presented script and the ILanim.py script, the Monte Carlo cycles can be simulated to view the results on the spin array as the process progresses. Here, the system under consideration was an 8 x 8 spin array, at a temperature of 0.5. ''Figure 3'' shows the typical outcome of the animation, with the system having reached the most stable, minimum energy arrangement. For the result presented here, the output of the statistics() function was that shown in ''Table 3''.

It was also observed that the system could locate a meta-stable state, with large regions of spin 'up' and 'down' spins. An example of such a result is presented in ''Figure 4'' (for which the output data from statistics() is presented in ''Table 4'').

==Accelerating the code==

In order to examine the efficiency of the python script developed thus far, the Iltimetrial.py script was utilised to investigate the time taken to perform 2000 Monte Carlo cycles. This script was modified to the version presented [[Mod:DMS3053-3|here]], which repeats the time measurement a defined number of times, then calculates the average time and the standard error in this average. For the Monte Carlo script prepared previously, the average time for 2000 Monte Carlo cycles was measured to be 5.475804 s and a standard error was calculated to be 0.008325 s, with 100 measurements made using the script.

Evidently, the current script is slow at conducting large numbers of Monte Carlo cycles and hence, a more efficient script was developed using the np.roll, np.multiply and np.sum functions - this is presented [[Mod:DMS3053-4|here]].

After this optimisation of the python script, the Iltimetrial.py script was re-run, giving an average time of 0.291467 s, with a standard error of 0.000156 s. Clearly, this optimised script is substantially faster than that developed previously (approximately 19 times faster).

==The effect of temperature==
===Correcting the averaging code===
As the equilibrium state of the system requires a number of Monte Carlo cycles to be reached, it is evident that the average energies and magnetisations are accounting for values for non-equilibrium arrangements - this was accounted for through a consideration of the number of cycles required to reach equilibrium. For this, the ILfinalframe.py script was used, giving the graphs shown in ''Table 5''. Here, each system was run for 150000 Monte Carlo cycles.
{| class="wikitable center" width=70%
|+ ''Table 5: Graphs of energy and magnetisation versus number of Monte Carlo cycles for different temperatures and system sizes''
! Temperature !! System Size !! Resulting Graphs !! Cycles for Equilibrium
|- style="text-align:center;"
| 0.5 || 4x4 || [[File:DMS0544.png|300px]] || 24
|- style="text-align:center;"
| 0.5 || 8x8 || [[File:DMS0588.png|300px]] || 392
|- style="text-align:center;"
| 0.5 || 16x16 || [[File:DMS051616.png|300px]] || 5549
|- style="text-align:center;"
| 1.0 || 2x2 || [[File:DMS1022.png|300px]] || (0)
|- style="text-align:center;"
| 1.0 || 4x4 || [[File:DMS1044.png|300px]] || 49
|- style="text-align:center;"
| 1.0 || 8x8 || [[File:DMS10882.png|300px]] || 590
|- style="text-align:center;"
| 1.0 || 16x16 || [[File:DMS101616.png|300px]] || ~6300
|- style="text-align:center;"
| 1.0 || 32x32 || [[File:DMS103232.png|300px]] || ~110000
|- style="text-align:center;"
| 2.0 || 4x4 || [[File:DMS2044.png|300px]] || -
|- style="text-align:center;"
| 2.0 || 8x8 || [[File:DMS2088.png|300px]] || -
|}
{| class="wikitable floatright" width=42%
|+ ''Table 6: Number of cycles to be ignored for each system size''
! System Size !! Number of cycles before averaging
|- style="text-align:center;"
| 2x2 || 0
|- style="text-align:center;"
| 4x4 || 100
|- style="text-align:center;"
| 8x8 || 1000
|- style="text-align:center;"
| 16x16 || 8000
|- style="text-align:center;"
| 32x32 || 120000
|}
Analysis of these graphs indicates that at higher temperatures, such as 2.0 (also observed at 1.5), large fluctuations in the energy and magnetisation are observed - these fluctuations are the reason that the average values of the properties must be taken. As the temperature is increased for systems of size 4x4, 8x8 and 16x16, it is clear that the number of cycles required in order to reach equilibrium increases. Hence, for the temperature range to be considered later (0.25 to 5.00), the required number of cycles was overestimated in order to ensure that all measurements were taken whilst the system was in equilibrium. The proposed numbers of cycles to be ignored for each system size are presented in ''Table 6''.

The python script developed up to this point was modified to account for these values by inclusion of a skip_region variable, which defines the number of cycles performed before energies and magnetisations contribute to the self.X values (before averaging occurs). The modified script is presented [[Mod:DMS3053-5|here]].

===Running over a range of temperatures===
[[File:DMS88dat.png|300px|thumb|right|'''''Figure 5''': Average energy and average magnetisation vs. temperature for 8x8 lattice, with error bars'']]
Using the python script modified in the previous exercise, the code can now be used to simulate the 8x8 system at a range of temperatures, using the ILtemperaturerange.py file (shown [[Mod:DMS3053-temprange|here]]). Here, the temperature range of 0.25 to 5.00 was used, with a separation of 0.25 between points, whilst the runtime was set to 10000 (neglecting the property values for the first 1000 cycles). Running this simulation produced the graphs in ''Figure 5'', where error bars computed using standard errors have also been included (these are small as a consequence of small standard errors). From the graph of average energy versus temperature, the phase transition can be observed - this occurs in the region with a gradient that is not close to zero. The data used here (temperature, average energies, average squared-energies, average magnetisations and average squared-magnetisations) was then saved as a numpy array in a new file, 8x8.dat.

==The effect of system size==
[[File:DMSLatticeSizeCombinedPlot.png|300px|thumb|right|'''''Figure 6''': Average energy and average magnetisation (per spins) vs. temperature for multiple lattice sizes'']]
The process conducted for the 8x8 lattice in the previous exercise was then repeated for lattices of sizes 2x2, 4x4, 16x16 and 32x32, with the data saved in .dat files. These files were then accessed, and the average energy and magnetisation data were plotted on one graph for all of the lattices sizes - this was achieved using the script presented [[Mod:DMS3053-6|here]]. The graphs produced in this manner are shown in ''Figure 6''.

A consideration of this graph suggests that in order to capture the long range fluctuations, whilst minimising the computational time required, an 8x8 lattice is likely to be the optimum choice. This is because the graph for this system size is comparable to that for a 32x32 lattice, whilst being faster to compute.

==Determining the heat capacity==
[[File:DMSheatcapacity2.png|300px|thumb|right|'''''Figure 7''': Heat capacity (per spin) versus temperature for different lattice sizes'']]
Using the .dat files previously produced, the heat capacity was calculated for each lattice size using the equation
::<math>C = \frac{\partial E}{\partial T} = \frac{\mathrm{Var}[E]}{k_B T^2}</math>, (''eq. 9'') 
where <math>\mathrm{Var}[E] = <E^2> - <E>^2 </math>. When implementing this, the kB term was neglected due to the energy values having units of kB. The script used for this purpose is provided [[DMS3053-7|here]]. The plot of heat capacity per spin versus temperature for all of the lattice sizes considered is presented in ''Figure 7''.

==Locating the Curie temperature==
===Comparison with C++ Data===
The data for the heat capacity generated using the python script prepared in this experiment was compared to that from longer C++ computations - graphs showing this comparison are presented in ''Table 7'' for a range of lattice sizes. The Python code used to produce these graphs is shown [[Mod:DMS3053-8|here]].

Considering these graphs, it is clear that, in general, there is a reasonable correlation between the Python and C++ data; however, some of the data, particularly that for high lattice sizes, shows that the Python computations have not always found the maximum of heat capacity. This correlation would be improved by making computations at the same range of temperatures, but with a smaller gap between the temperatures taken; however, this would substantially increase computation time.
{| class="wikitable center" width=70%
|+ ''Table 7: Graphs of heat capacity (per spin) versus temperature for C++ and Python data''
|- style="text-align:center;"
| [[File:DMS2x2c.png|300px]] || [[File:DMS4x4c.png|300px]] || [[File:DMS8x8c.png|300px]]
|- style="text-align:center;"
| 2x2 || 4x4 || 8x8
|- style="text-align:center;"
| [[File:DMS16x16c.png|300px]] || [[File:DMS32x32c.png|300px]]
|- style="text-align:center;"
| 16x16 || 32x32
|}

===Polynomial Fitting===
[[File:DMS8x8513.png|300px|thumb|right|'''''Figure 8''': Heat capacity (per spin) versus temperature for 8x8 system with two polynomial fits'']]
In order to make use of the C++ data in finding the Curie temperature for the Ising Lattices under consideration, polynomials were fit to the data - the script written for this purpose is shown [[Mod:DMS3053-9|here]]. For this fitting, it was found that a polynomial order of 5 was required to provide a good fit for the 2x2 data - this increased significantly as the lattice size increased. An example fit is shown for the 8x8 system in ''Figure 8'', where the polynomial fit is shown for orders 5 and 13. A consideration of this graph reveals that whilst a polynomial of order 5 may be appropriate for a 2x2 system, it is inadequate for the larger system of 8x8. Whilst an order of 13 substantially improves the polynomial fit, one must, in general, take care with 'overfitting' data.
[[File:Py8x8(13fit).png|300px|thumb|left|'''''Figure 9''': Heat capacity (per spin) versus temperature for Python data for 8x8 system with a 13th order polynomial fit'']]
For comparison, a 13th order polynomial was fitted to the 8x8 Python data previously computed - this is shown in ''Figure 9''. Here, it is evident that for this data, a higher order polynomial is required to obtain a fit comparable to that for the C++ data above.

===Fitting in a Particular Temperature Range===
[[File:DMS8x8peak(3).png|300px|thumb|right|'''''Figure 10''': Heat capacity (per spin) versus temperature for 8x8 system with peak polynomial fit'']]
As was observed in the previous exercise, large polynomial orders are required to fit the C++ data well across the whole temperature range. The python script was modified to that presented [[Mod:DMS3053-10|here]] (this script also contains the python code to compute the maximum heat capacity and temperature at which this occurs for the following exercise), which fits a polynomial only in the region of the maximum heat capacity for the system. An example of such fit is shown in ''Figure 10'' for the 8x8 system. Here, it should be noted that for all of the system sizes studied, a polynomial order of 3 was used - this is a clear improvement compared to the 13th order polynomials used previously.

===Finding the Peak in Heat Capacity===
{| class="wikitable floatright" width=42%
|+ ''Table 8: Lattice sizes and their corresponding Curie temperatures''
! System Size !! Number of cycles before averaging
|- style="text-align:center;"
| 2x2 || 2.53503504
|- style="text-align:center;"
| 4x4 || 2.43843844
|- style="text-align:center;"
| 8x8 || 2.33433433
|- style="text-align:center;"
| 16x16 || 2.30455455
|- style="text-align:center;"
| 32x32 || 2.27752753
|}
[[File:DMSCurieTemperature.png|300px|thumb|left|'''''Figure 11''': Curie temperature vs. 1/(lattice length), with extrapolated linear fit'']]
In order to find the Curie temperature for an infinite Ising Lattice, the Curie temperature for each system size considered was first found (using the script shown in the previous exercise). These temperatures were then saved to a .dat file (whose contents are also showed in ''Table 8'', along with their corresponding lattice sizes. Finally, using the script presented [[Mod:DMS3053-11|here]], a graph of Curie temperature versus the inverse of the lattice length was plotted, according to the equation
::<math>T_{C, L} = \frac{A}{L} + T_{C,\infty}</math>, ''(eq. 10)
where <math>T_{C, L}</math> is the Curie temperature for a lattice with length L and <math>T_{C,\infty}</math> is the Curie temperature for an infinite Ising lattice. Hence, it is clear that the desired Curie temperature must be the y-intercept of the graph shown in ''Figure 11'' (hence the use of extrapolation in the python script). Taking this extrapolated value gives a Curie temperature of 2.271. This value can be compared to the theoretical exact value of 2.27,<ref>D. K. Khudier, N. I. Fawaz, ''Int. Lett. Them. Phys. Astron.'', 2013, '''10''', 201-212. Available from: http://www.ilcpa.pl/wp-content/uploads/2012/11/ILCPA-102-2013-201-2121.pdf</ref> which indicates a good agreement between the value calculated in this investigation and the theoretical exact value. This is surprising given that it would be expected that the polynomial fitting of the data to locate the maximum would contribute a considerable degree of error to the final value.

==References==
<references/>
</div>

Rep:Mod:DMS3053

2015-02-26T10:19:36Z

Ds3012: /* Spin 'flipping' */

'''CMP Programming Experiment - Daniel Spencer, 00736964'''
<div style="text-align: justify">
==Introduction to the Ising Model==
===Minimum energy of the Ising Model===
Using the equation 
::<math>E= - \frac{1}{2} J \sum_i^N \sum_{j\ \in\ \mathrm{neighbours}\left(i\right)} s_i s_j</math> (''eq. 1'') 
the minimum energy of an Ising lattice of <math>D</math> dimensions, with <math>N</math> spins (where each
spin had a value of +1 or -1) and an interaction strength of <math>J</math> was considered. This was achieved first through a consideration of a one-dimensional system with five parallel spins (where the spins are parallel as this corresponds to the minimum energy arrangement of the system). Hence, the energy of this linear system was found to be 
::<math>E_\text{min,1D} = -5J </math>. 
For a linear, one-dimensional system, the number of neigbouring spins is two. The number of neighbours can be determined for two- and three- dimensional systems through a geometric consideration of their structure - the values are presented in ''Table 1''.
{| class="wikitable floatright" width=42%
|+ ''Table 1: Dimension numbers and number of neighbours''
! Number of Dimensions, D !! Number of Neighbours
|- style="text-align:center;"
| 1 || 2
|- style="text-align:center;"
| 2 || 4
|- style="text-align:center;"
| 3 || 6
|- style="text-align:center;"
| D || 2D
|}
These data indicate that the number of neighbours is twice the number of dimensions, for the dimensions considered here. This can be extrapolated to give the general number of neighbours as <math>2D</math>.

For the minimum energy of the system, where all spins are parallel, every combination <math>s_i s_j</math> has a value of 1. Notably, for each value of <math>i</math>, there will be <math>2D</math> neighbour interactions. Ergo, using ''eq. 1'', the general minimum energy can be found to be
::<math>E_\text{min,D} = -DNJ </math> (''eq. 2''). 
To check this equation, it can be applied to the two-dimensional Ising lattice with 25 spins - this gives a value of
::<math>E_\text{min,2D} = -50J </math>, 
which matches with the value predicted from first-principles.

For this D-dimensional system, the multiplicity (i.e. the number of ways of achieving the specified configuration of spins) must be equal to two, as either all of the spins could be aligned 'up' (+1) or 'down' (-1). Using this multiplicity, the entropy of the system can be calculated using the equation
::<math>S = k_B \ln\Omega</math>, (''eq. 3'') 
where Ω is the number of microstates (equal to the multiplicity in this case), which gives a value of <math>k_B \ln2 </math>, or 9.57 x 10-24 J K-1.

===Spin 'flipping'===
[[File:ThirdYearCMPExpt-IsingSketch.png|300px|thumb|right|'' '''Figure 1''': Representation of Ising lattices in one (N=5), two (N=25), and three (N=125) dimensions. +1 and -1 spins are denoted by the red and blue cells respectively. Diagram taken from the lab script.'']]
Using the Ising model, it is also possible to consider a change in state, reflected by a 'flipping' of the direction of one of the lattice spins. For this case, the energy (using ''eq. 1'') can be determined to be
::<math>E'= - \frac{1}{2} J (2DN - 4D - 4D) = 4DJ - DNJ</math>, (''eq. 4'') 
where the additional <math>4D</math> terms arise from the loss of 4D stabilising spin-aligned interactions and the gain of 4D destabilising spins anti-aligned interactions following spin 'flipping'. Using ''eq. 2'' and ''eq. 4'', the change in energy derived from this spin 'flip' can be calculated to be
::<math>\Delta E= 4DJ - DNJ + DNJ = 4DJ</math>. (''eq. 5'') 
For a system with three dimensions (D = 3) and 1000 spins (N = 1000), the system, using ''eq. 5'', was determined to increase in energy by <math>12 J</math>. Notably, this change in energy is independent of the number of spins in the system - it depends only on the number of dimensions and J.

A significant consideration with regards to the spin 'flipping' described here is the accompanying increase in entropy - the driving force for this process. For the scenario describing the change in direction of a single spin, the multiplicity of the system will be <math>2N</math> - this is a consequence of the system prior to 'flipping' having a multiplicity of two (all spins aligned 'up' or 'down'), where now, any one of the spins could flip, adding the factor of N to the multiplicity. Hence, the new entropy can be defined to be
::<math>S' = k_B \ln 2N</math>, (''eq. 6'') 
which allows the change in entropy to be calculated according to ''eq. 7''.
::<math>\Delta S = k_B \ln 2N - k_B \ln2 = k_B \ln N</math> (''eq. 7'') 
For the system described above (D = 3, N = 1000), the change in entropy associated with the spin 'flip' process is therefore <math>k_B ln 1000</math>, which is equal to 9.53 x 10-23 J K-1.

===Magnetisation===
{| class="wikitable floatleft" width=42%
|+ ''Table 2: Ising lattices and magnetisations''
! Ising Lattice !! Magnetisation
|- style="text-align:center;"
| 1D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 2D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 3D at 0 K || 1000 or -1000
|}
''Figure 1'' shows three examples of Ising lattices, with one, two and three dimensions respectively. Using the equation for magnetisation (''eq. 8''), the magnetisations of these systems can be calculated to be those presented in ''Table 2''.
::<math>M= \sum_i s_i</math> (''eq. 8'') 
For the three-dimensional system with 1000 spins at a temperature of 0 K, all of the spins must be aligned either 'up' or 'down', as the entropic increase associated with 'flipped' spins does not provide a driving force at absolute zero - the only factor to consider is that of the energy, which is a minimum when all of the spins are aligned. For this case, the magnetisation could be either 1000 or -1000, depending upon the direction of the spin alignment. From a consideration of the magnetisation values calculated here, it is evident that with all of the spins aligned, the (magnitude of the) magnetisation of the system is at a maximum.

==Calculating the energy and magnetisation==
===Modifying the files===
[[File:DMStest_output2.png|300px|thumb|right|'' '''Figure 2''': Output image from testing IsingLattice.py using Ilcheck.py'']]
In order to use Python to compute the energy and magnetisation for a given two-dimensional Ising lattice, the class IsingLattice was used, where energy() and magnetisation() functions were written to calculate their corresponding properties for a random numpy array of spins (generated using np.random.choice). For this aspect of the experiment, the value of J was assumed to be 1.0, working in reduced units. The Python script developed can be viewed [[Mod:DMS3053-1|here]], including annotations.

===Testing the files===
In order to test the script prepared thus far, the Ilcheck.py script was run, generating the image presented in ''Figure 2''. An examination of this output clearly indicates that the script provides accurate energies and magnetisations for the minimum and maximum energy configurations, along with for an intermediate, random arrangement. Hence, it can be concluded that at the current level, the Python script is functioning as required.

==Introduction to the Monte Carlo simulation==
===Average Energy and Magnetisation===
[[File:DMSILanim3.png|300px|thumb|right|'''''Figure 3''': Animation result from ILanim.py, showing the resting of the system in the minimum energy state'']]
[[File:DMSILanim_meta.png|300px|thumb|right|'''''Figure 4''': Animation result from ILanim.py, showing the resting of the system in a meta-stable state'']]

In order to consider the generalisability of the prepared script, it is important to analyse how the script will function for large systems, such as those with 100 spins in the spin array. As each of these spins can be either 'up' or 'down', each spin has two choices. Hence, the number of possible configurations for the system can be written as <math>2^{100}</math>, which has a value of 1.2677 x 1030.

If one considers the sampling of a single configuration to take 1 x 10-9 s, then it is clear that sampling all of these considerations would take a total of 1.2677 x 1021 s (also expressed as 4.017 x 1013 years). From this analysis, it is evident that the sampling of configurations was a significant consideration in the writing of a python script for this task.

In order to account for this, the technique of importance sampling was implemented, using the statistical Boltzmann distribution, <math>\exp(- \Delta E / k_B T)</math>. Note that as the energy computed using the energy() function is in units of kB, this factor is not included in the script.

===Modifying IsingLattice.py to Implement a Monte Carlo Cycle===
The python script developed at this stage is presented [[Mod:DMS3053-2|here]], accompanied by annotations to explain how the script functions.

===Simulating the Monte Carlo Cycles===
{| class="wikitable floatright" width=42%
|+ ''Table 3: statistics() output for animated system at global minimum configuration (Figure 3)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.70542501728
|- style="text-align:center;"
| <E2> || 3.13520970111
|- style="text-align:center;"
| <M> || -0.829971492744
|- style="text-align:center;"
| <M2> || 0.770986982766
|}
For cases where T < Tc, it would be expected that the system would have a spontaneous magnetisation. When T > Tc, the entropy will be the dominating factor, potentially resulting in the system having a magnetisation of zero.
{| class="wikitable floatright" width=42%
|+ ''Table 4: statistics() output for animated system at meta-stable configuration (Figure 4)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.35076450189
|- style="text-align:center;"
| <E2> || 1.89025801939
|- style="text-align:center;"
| <M> || -0.344104665826
|- style="text-align:center;"
| <M2> || 0.138855365306
|}
Using the presented script and the ILanim.py script, the Monte Carlo cycles can be simulated to view the results on the spin array as the process progresses. Here, the system under consideration was an 8 x 8 spin array, at a temperature of 0.5. ''Figure 3'' shows the typical outcome of the animation, with the system having reached the most stable, minimum energy arrangement. For the result presented here, the output of the statistics() function was that shown in ''Table 3''.

It was also observed that the system could locate a meta-stable state, with large regions of spin 'up' and 'down' spins. An example of such a result is presented in ''Figure 4'' (for which the output data from statistics() is presented in ''Table 4'').

==Accelerating the code==

In order to examine the efficiency of the python script developed thus far, the Iltimetrial.py script was utilised to investigate the time taken to perform 2000 Monte Carlo cycles. This script was modified to the version presented [[Mod:DMS3053-3|here]], which repeats the time measurement a defined number of times, then calculates the average time and the standard error in this average. For the Monte Carlo script prepared previously, the average time for 2000 Monte Carlo cycles was measured to be 5.475804 s and a standard error was calculated to be 0.008325 s, with 100 measurements made using the script.

Evidently, the current script is slow at conducting large numbers of Monte Carlo cycles and hence, a more efficient script was developed using the np.roll, np.multiply and np.sum functions - this is presented [[Mod:DMS3053-4|here]].

After this optimisation of the python script, the Iltimetrial.py script was re-run, giving an average time of 0.291467 s, with a standard error of 0.000156 s. Clearly, this optimised script is substantially faster than that developed previously (approximately 19 times faster).

==The effect of temperature==
===Correcting the averaging code===
As the equilibrium state of the system requires a number of Monte Carlo cycles to be reached, it is evident that the average energies and magnetisations are accounting for values for non-equilibrium arrangements - this was accounted for through a consideration of the number of cycles required to reach equilibrium. For this, the ILfinalframe.py script was used, giving the graphs shown in ''Table 5''. Here, each system was run for 150000 Monte Carlo cycles.
{| class="wikitable center" width=70%
|+ ''Table 5: Graphs of energy and magnetisation versus number of Monte Carlo cycles for different temperatures and system sizes''
! Temperature !! System Size !! Resulting Graphs !! Cycles for Equilibrium
|- style="text-align:center;"
| 0.5 || 4x4 || [[File:DMS0544.png|300px]] || 24
|- style="text-align:center;"
| 0.5 || 8x8 || [[File:DMS0588.png|300px]] || 392
|- style="text-align:center;"
| 0.5 || 16x16 || [[File:DMS051616.png|300px]] || 5549
|- style="text-align:center;"
| 1.0 || 2x2 || [[File:DMS1022.png|300px]] || (0)
|- style="text-align:center;"
| 1.0 || 4x4 || [[File:DMS1044.png|300px]] || 49
|- style="text-align:center;"
| 1.0 || 8x8 || [[File:DMS10882.png|300px]] || 590
|- style="text-align:center;"
| 1.0 || 16x16 || [[File:DMS101616.png|300px]] || ~6300
|- style="text-align:center;"
| 1.0 || 32x32 || [[File:DMS103232.png|300px]] || ~110000
|- style="text-align:center;"
| 2.0 || 4x4 || [[File:DMS2044.png|300px]] || -
|- style="text-align:center;"
| 2.0 || 8x8 || [[File:DMS2088.png|300px]] || -
|}
{| class="wikitable floatright" width=42%
|+ ''Table 6: Number of cycles to be ignored for each system size''
! System Size !! Number of cycles before averaging
|- style="text-align:center;"
| 2x2 || 0
|- style="text-align:center;"
| 4x4 || 100
|- style="text-align:center;"
| 8x8 || 1000
|- style="text-align:center;"
| 16x16 || 8000
|- style="text-align:center;"
| 32x32 || 120000
|}
Analysis of these graphs indicates that at higher temperatures, such as 2.0 (also observed at 1.5), large fluctuations in the energy and magnetisation are observed - these fluctuations are the reason that the average values of the properties must be taken. As the temperature is increased for systems of size 4x4, 8x8 and 16x16, it is clear that the number of cycles required in order to reach equilibrium increases. Hence, for the temperature range to be considered later (0.25 to 5.00), the required number of cycles was overestimated in order to ensure that all measurements were taken whilst the system was in equilibrium. The proposed numbers of cycles to be ignored for each system size are presented in ''Table 6''.

The python script developed up to this point was modified to account for these values by inclusion of a skip_region variable, which defines the number of cycles performed before energies and magnetisations contribute to the self.X values (before averaging occurs). The modified script is presented [[Mod:DMS3053-5|here]].

===Running over a range of temperatures===
[[File:DMS88dat.png|300px|thumb|right|'''''Figure 5''': Average energy and average magnetisation vs. temperature for 8x8 lattice, with error bars'']]
Using the python script modified in the previous exercise, the code can now be used to simulate the 8x8 system at a range of temperatures, using the ILtemperaturerange.py file (shown [[Mod:DMS3053-temprange|here]]). Here, the temperature range of 0.25 to 5.00 was used, with a separation of 0.25 between points, whilst the runtime was set to 10000 (neglecting the property values for the first 1000 cycles). Running this simulation produced the graphs in ''Figure 5'', where error bars computed using standard errors have also been included (these are small as a consequence of small standard errors). From the graph of average energy versus temperature, the phase transition can be observed - this occurs in the region with a gradient that is not close to zero. The data used here (temperature, average energies, average squared-energies, average magnetisations and average squared-magnetisations) was then saved as a numpy array in a new file, 8x8.dat.

==The effect of system size==
[[File:DMSLatticeSizeCombinedPlot.png|300px|thumb|right|'''''Figure 6''': Average energy and average magnetisation (per spins) vs. temperature for multiple lattice sizes'']]
The process conducted for the 8x8 lattice in the previous exercise was then repeated for lattices of sizes 2x2, 4x4, 16x16 and 32x32, with the data saved in .dat files. These files were then accessed, and the average energy and magnetisation data were plotted on one graph for all of the lattices sizes - this was achieved using the script presented [[Mod:DMS3053-6|here]]. The graphs produced in this manner are shown in ''Figure 6''.

A consideration of this graph suggests that in order to capture the long range fluctuations, whilst minimising the computational time required, an 8x8 lattice is likely to be the optimum choice. This is because the graph for this system size is comparable to that for a 32x32 lattice, whilst being faster to compute.

==Determining the heat capacity==
[[File:DMSheatcapacity2.png|300px|thumb|right|'''''Figure 7''': Heat capacity (per spin) versus temperature for different lattice sizes'']]
Using the .dat files previously produced, the heat capacity was calculated for each lattice size using the equation
::<math>C = \frac{\partial E}{\partial T} = \frac{\mathrm{Var}[E]}{k_B T^2}</math>, (''eq. 9'') 
where <math>\mathrm{Var}[E] = <E^2> - <E>^2 </math>. When implementing this, the kB term was neglected due to the energy values having units of kB. The script used for this purpose is provided [[DMS3053-7|here]]. The plot of heat capacity per spin versus temperature for all of the lattice sizes considered is presented in ''Figure 7''.

==Locating the Curie temperature==
===Comparison with C++ Data===
The data for the heat capacity generated using the python script prepared in this experiment was compared to that from longer C++ computations - graphs showing this comparison are presented in ''Table 7'' for a range of lattice sizes. The Python code used to produce these graphs is shown [[Mod:DMS3053-8|here]].

Considering these graphs, it is clear that, in general, there is a reasonable correlation between the Python and C++ data; however, some of the data, particularly that for high lattice sizes, shows that the Python computations have not always found the maximum of heat capacity. This correlation would be improved by making computations at the same range of temperatures, but with a smaller gap between the temperatures taken; however, this would substantially increase computation time.
{| class="wikitable center" width=70%
|+ ''Table 7: Graphs of heat capacity (per spin) versus temperature for C++ and Python data''
|- style="text-align:center;"
| [[File:DMS2x2c.png|300px]] || [[File:DMS4x4c.png|300px]] || [[File:DMS8x8c.png|300px]]
|- style="text-align:center;"
| 2x2 || 4x4 || 8x8
|- style="text-align:center;"
| [[File:DMS16x16c.png|300px]] || [[File:DMS32x32c.png|300px]]
|- style="text-align:center;"
| 16x16 || 32x32
|}

===Polynomial Fitting===
[[File:DMS8x8513.png|300px|thumb|right|'''''Figure 8''': Heat capacity (per spin) versus temperature for 8x8 system with two polynomial fits'']]
In order to make use of the C++ data in finding the Curie temperature for the Ising Lattices under consideration, polynomials were fit to the data - the script written for this purpose is shown [[Mod:DMS3053-9|here]]. For this fitting, it was found that a polynomial order of 5 was required to provide a good fit for the 2x2 data - this increased significantly as the lattice size increased. An example fit is shown for the 8x8 system in ''Figure 8'', where the polynomial fit is shown for orders 5 and 13. A consideration of this graph reveals that whilst a polynomial of order 5 may be appropriate for a 2x2 system, it is inadequate for the larger system of 8x8. Whilst an order of 13 substantially improves the polynomial fit, one must, in general, take care with 'overfitting' data.
[[File:Py8x8(13fit).png|300px|thumb|left|'''''Figure 9''': Heat capacity (per spin) versus temperature for Python data for 8x8 system with a 13th order polynomial fit'']]
For comparison, a 13th order polynomial was fitted to the 8x8 Python data previously computed - this is shown in ''Figure 9''. Here, it is evident that for this data, a higher order polynomial is required to obtain a fit comparable to that for the C++ data above.

===Fitting in a Particular Temperature Range===
[[File:DMS8x8peak(3).png|300px|thumb|right|'''''Figure 10''': Heat capacity (per spin) versus temperature for 8x8 system with peak polynomial fit'']]
As was observed in the previous exercise, large polynomial orders are required to fit the C++ data well across the whole temperature range. The python script was modified to that presented [[Mod:DMS3053-10|here]] (this script also contains the python code to compute the maximum heat capacity and temperature at which this occurs for the following exercise), which fits a polynomial only in the region of the maximum heat capacity for the system. An example of such fit is shown in ''Figure 10'' for the 8x8 system. Here, it should be noted that for all of the system sizes studied, a polynomial order of 3 was used - this is a clear improvement compared to the 13th order polynomials used previously.

===Finding the Peak in Heat Capacity===
{| class="wikitable floatright" width=42%
|+ ''Table 8: Lattice sizes and their corresponding Curie temperatures''
! System Size !! Number of cycles before averaging
|- style="text-align:center;"
| 2x2 || 2.53503504
|- style="text-align:center;"
| 4x4 || 2.43843844
|- style="text-align:center;"
| 8x8 || 2.33433433
|- style="text-align:center;"
| 16x16 || 2.30455455
|- style="text-align:center;"
| 32x32 || 2.27752753
|}
[[File:DMSCurieTemperature.png|300px|thumb|left|'''''Figure 11''': Curie temperature vs. 1/(lattice length), with extrapolated linear fit'']]
In order to find the Curie temperature for an infinite Ising Lattice, the Curie temperature for each system size considered was first found (using the script shown in the previous exercise). These temperatures were then saved to a .dat file (whose contents are also showed in ''Table 8'', along with their corresponding lattice sizes. Finally, using the script presented [[Mod:DMS3053-11|here]], a graph of Curie temperature versus the inverse of the lattice length was plotted, according to the equation
::<math>T_{C, L} = \frac{A}{L} + T_{C,\infty}</math>, ''(eq. 10)
where <math>T_{C, L}</math> is the Curie temperature for a lattice with length L and <math>T_{C,\infty}</math> is the Curie temperature for an infinite Ising lattice. Hence, it is clear that the desired Curie temperature must be the y-intercept of the graph shown in ''Figure 11'' (hence the use of extrapolation in the python script). Taking this extrapolated value gives a Curie temperature of 2.271. This value can be compared to the theoretical exact value of 2.27,<ref>D. K. Khudier, N. I. Fawaz, ''Int. Lett. Them. Phys. Astron.'', 2013, '''10''', 201-212. Available from: http://www.ilcpa.pl/wp-content/uploads/2012/11/ILCPA-102-2013-201-2121.pdf</ref> which indicates a good agreement between the value calculated in this investigation and the theoretical exact value. This is surprising given that it would be expected that the polynomial fitting of the data to locate the maximum would contribute a considerable degree of error to the final value.

==References==
<references/>
</div>

Rep:Mod:DMS3053

2015-02-26T10:18:27Z

Ds3012: /* Magnetisation */

'''CMP Programming Experiment - Daniel Spencer, 00736964'''
<div style="text-align: justify">
==Introduction to the Ising Model==
===Minimum energy of the Ising Model===
Using the equation 
::<math>E= - \frac{1}{2} J \sum_i^N \sum_{j\ \in\ \mathrm{neighbours}\left(i\right)} s_i s_j</math> (''eq. 1'') 
the minimum energy of an Ising lattice of <math>D</math> dimensions, with <math>N</math> spins (where each
spin had a value of +1 or -1) and an interaction strength of <math>J</math> was considered. This was achieved first through a consideration of a one-dimensional system with five parallel spins (where the spins are parallel as this corresponds to the minimum energy arrangement of the system). Hence, the energy of this linear system was found to be 
::<math>E_\text{min,1D} = -5J </math>. 
For a linear, one-dimensional system, the number of neigbouring spins is two. The number of neighbours can be determined for two- and three- dimensional systems through a geometric consideration of their structure - the values are presented in ''Table 1''.
{| class="wikitable floatright" width=42%
|+ ''Table 1: Dimension numbers and number of neighbours''
! Number of Dimensions, D !! Number of Neighbours
|- style="text-align:center;"
| 1 || 2
|- style="text-align:center;"
| 2 || 4
|- style="text-align:center;"
| 3 || 6
|- style="text-align:center;"
| D || 2D
|}
These data indicate that the number of neighbours is twice the number of dimensions, for the dimensions considered here. This can be extrapolated to give the general number of neighbours as <math>2D</math>.

For the minimum energy of the system, where all spins are parallel, every combination <math>s_i s_j</math> has a value of 1. Notably, for each value of <math>i</math>, there will be <math>2D</math> neighbour interactions. Ergo, using ''eq. 1'', the general minimum energy can be found to be
::<math>E_\text{min,D} = -DNJ </math> (''eq. 2''). 
To check this equation, it can be applied to the two-dimensional Ising lattice with 25 spins - this gives a value of
::<math>E_\text{min,2D} = -50J </math>, 
which matches with the value predicted from first-principles.

For this D-dimensional system, the multiplicity (i.e. the number of ways of achieving the specified configuration of spins) must be equal to two, as either all of the spins could be aligned 'up' (+1) or 'down' (-1). Using this multiplicity, the entropy of the system can be calculated using the equation
::<math>S = k_B \ln\Omega</math>, (''eq. 3'') 
where Ω is the number of microstates (equal to the multiplicity in this case), which gives a value of <math>k_B \ln2 </math>, or 9.57 x 10-24 J K-1.

===Spin 'flipping'===

Using the Ising model, it is also possible to consider a change in state, reflected by a 'flipping' of the direction of one of the lattice spins. For this case, the energy (using ''eq. 1'') can be determined to be
::<math>E'= - \frac{1}{2} J (2DN - 4D - 4D) = 4DJ - DNJ</math>, (''eq. 4'') 
where the additional <math>4D</math> terms arise from the loss of 4D stabilising spin-aligned interactions and the gain of 4D destabilising spins anti-aligned interactions following spin 'flipping'. Using ''eq. 2'' and ''eq. 4'', the change in energy derived from this spin 'flip' can be calculated to be
::<math>\Delta E= 4DJ - DNJ + DNJ = 4DJ</math>. (''eq. 5'') 
For a system with three dimensions (D = 3) and 1000 spins (N = 1000), the system, using ''eq. 5'', was determined to increase in energy by <math>12 J</math>. Notably, this change in energy is independent of the number of spins in the system - it depends only on the number of dimensions and J.
[[File:ThirdYearCMPExpt-IsingSketch.png|300px|thumb|right|'' '''Figure 1''': Representation of Ising lattices in one (N=5), two (N=25), and three (N=125) dimensions. +1 and -1 spins are denoted by the red and blue cells respectively. Diagram taken from the lab script.'']]
A significant consideration with regards to the spin 'flipping' described here is the accompanying increase in entropy - the driving force for this process. For the scenario describing the change in direction of a single spin, the multiplicity of the system will be <math>2N</math> - this is a consequence of the system prior to 'flipping' having a multiplicity of two (all spins aligned 'up' or 'down'), where now, any one of the spins could flip, adding the factor of N to the multiplicity. Hence, the new entropy can be defined to be
::<math>S' = k_B \ln 2N</math>, (''eq. 6'') 
which allows the change in entropy to be calculated according to ''eq. 7''.
::<math>\Delta S = k_B \ln 2N - k_B \ln2 = k_B \ln N</math> (''eq. 7'') 
For the system described above (D = 3, N = 1000), the change in entropy associated with the spin 'flip' process is therefore <math>k_B ln 1000</math>, which is equal to 9.53 x 10-23 J K-1.

===Magnetisation===
{| class="wikitable floatleft" width=42%
|+ ''Table 2: Ising lattices and magnetisations''
! Ising Lattice !! Magnetisation
|- style="text-align:center;"
| 1D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 2D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 3D at 0 K || 1000 or -1000
|}
''Figure 1'' shows three examples of Ising lattices, with one, two and three dimensions respectively. Using the equation for magnetisation (''eq. 8''), the magnetisations of these systems can be calculated to be those presented in ''Table 2''.
::<math>M= \sum_i s_i</math> (''eq. 8'') 
For the three-dimensional system with 1000 spins at a temperature of 0 K, all of the spins must be aligned either 'up' or 'down', as the entropic increase associated with 'flipped' spins does not provide a driving force at absolute zero - the only factor to consider is that of the energy, which is a minimum when all of the spins are aligned. For this case, the magnetisation could be either 1000 or -1000, depending upon the direction of the spin alignment. From a consideration of the magnetisation values calculated here, it is evident that with all of the spins aligned, the (magnitude of the) magnetisation of the system is at a maximum.

==Calculating the energy and magnetisation==
===Modifying the files===
[[File:DMStest_output2.png|300px|thumb|right|'' '''Figure 2''': Output image from testing IsingLattice.py using Ilcheck.py'']]
In order to use Python to compute the energy and magnetisation for a given two-dimensional Ising lattice, the class IsingLattice was used, where energy() and magnetisation() functions were written to calculate their corresponding properties for a random numpy array of spins (generated using np.random.choice). For this aspect of the experiment, the value of J was assumed to be 1.0, working in reduced units. The Python script developed can be viewed [[Mod:DMS3053-1|here]], including annotations.

===Testing the files===
In order to test the script prepared thus far, the Ilcheck.py script was run, generating the image presented in ''Figure 2''. An examination of this output clearly indicates that the script provides accurate energies and magnetisations for the minimum and maximum energy configurations, along with for an intermediate, random arrangement. Hence, it can be concluded that at the current level, the Python script is functioning as required.

==Introduction to the Monte Carlo simulation==
===Average Energy and Magnetisation===
[[File:DMSILanim3.png|300px|thumb|right|'''''Figure 3''': Animation result from ILanim.py, showing the resting of the system in the minimum energy state'']]
[[File:DMSILanim_meta.png|300px|thumb|right|'''''Figure 4''': Animation result from ILanim.py, showing the resting of the system in a meta-stable state'']]

In order to consider the generalisability of the prepared script, it is important to analyse how the script will function for large systems, such as those with 100 spins in the spin array. As each of these spins can be either 'up' or 'down', each spin has two choices. Hence, the number of possible configurations for the system can be written as <math>2^{100}</math>, which has a value of 1.2677 x 1030.

If one considers the sampling of a single configuration to take 1 x 10-9 s, then it is clear that sampling all of these considerations would take a total of 1.2677 x 1021 s (also expressed as 4.017 x 1013 years). From this analysis, it is evident that the sampling of configurations was a significant consideration in the writing of a python script for this task.

In order to account for this, the technique of importance sampling was implemented, using the statistical Boltzmann distribution, <math>\exp(- \Delta E / k_B T)</math>. Note that as the energy computed using the energy() function is in units of kB, this factor is not included in the script.

===Modifying IsingLattice.py to Implement a Monte Carlo Cycle===
The python script developed at this stage is presented [[Mod:DMS3053-2|here]], accompanied by annotations to explain how the script functions.

===Simulating the Monte Carlo Cycles===
{| class="wikitable floatright" width=42%
|+ ''Table 3: statistics() output for animated system at global minimum configuration (Figure 3)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.70542501728
|- style="text-align:center;"
| <E2> || 3.13520970111
|- style="text-align:center;"
| <M> || -0.829971492744
|- style="text-align:center;"
| <M2> || 0.770986982766
|}
For cases where T < Tc, it would be expected that the system would have a spontaneous magnetisation. When T > Tc, the entropy will be the dominating factor, potentially resulting in the system having a magnetisation of zero.
{| class="wikitable floatright" width=42%
|+ ''Table 4: statistics() output for animated system at meta-stable configuration (Figure 4)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.35076450189
|- style="text-align:center;"
| <E2> || 1.89025801939
|- style="text-align:center;"
| <M> || -0.344104665826
|- style="text-align:center;"
| <M2> || 0.138855365306
|}
Using the presented script and the ILanim.py script, the Monte Carlo cycles can be simulated to view the results on the spin array as the process progresses. Here, the system under consideration was an 8 x 8 spin array, at a temperature of 0.5. ''Figure 3'' shows the typical outcome of the animation, with the system having reached the most stable, minimum energy arrangement. For the result presented here, the output of the statistics() function was that shown in ''Table 3''.

It was also observed that the system could locate a meta-stable state, with large regions of spin 'up' and 'down' spins. An example of such a result is presented in ''Figure 4'' (for which the output data from statistics() is presented in ''Table 4'').

==Accelerating the code==

In order to examine the efficiency of the python script developed thus far, the Iltimetrial.py script was utilised to investigate the time taken to perform 2000 Monte Carlo cycles. This script was modified to the version presented [[Mod:DMS3053-3|here]], which repeats the time measurement a defined number of times, then calculates the average time and the standard error in this average. For the Monte Carlo script prepared previously, the average time for 2000 Monte Carlo cycles was measured to be 5.475804 s and a standard error was calculated to be 0.008325 s, with 100 measurements made using the script.

Evidently, the current script is slow at conducting large numbers of Monte Carlo cycles and hence, a more efficient script was developed using the np.roll, np.multiply and np.sum functions - this is presented [[Mod:DMS3053-4|here]].

After this optimisation of the python script, the Iltimetrial.py script was re-run, giving an average time of 0.291467 s, with a standard error of 0.000156 s. Clearly, this optimised script is substantially faster than that developed previously (approximately 19 times faster).

==The effect of temperature==
===Correcting the averaging code===
As the equilibrium state of the system requires a number of Monte Carlo cycles to be reached, it is evident that the average energies and magnetisations are accounting for values for non-equilibrium arrangements - this was accounted for through a consideration of the number of cycles required to reach equilibrium. For this, the ILfinalframe.py script was used, giving the graphs shown in ''Table 5''. Here, each system was run for 150000 Monte Carlo cycles.
{| class="wikitable center" width=70%
|+ ''Table 5: Graphs of energy and magnetisation versus number of Monte Carlo cycles for different temperatures and system sizes''
! Temperature !! System Size !! Resulting Graphs !! Cycles for Equilibrium
|- style="text-align:center;"
| 0.5 || 4x4 || [[File:DMS0544.png|300px]] || 24
|- style="text-align:center;"
| 0.5 || 8x8 || [[File:DMS0588.png|300px]] || 392
|- style="text-align:center;"
| 0.5 || 16x16 || [[File:DMS051616.png|300px]] || 5549
|- style="text-align:center;"
| 1.0 || 2x2 || [[File:DMS1022.png|300px]] || (0)
|- style="text-align:center;"
| 1.0 || 4x4 || [[File:DMS1044.png|300px]] || 49
|- style="text-align:center;"
| 1.0 || 8x8 || [[File:DMS10882.png|300px]] || 590
|- style="text-align:center;"
| 1.0 || 16x16 || [[File:DMS101616.png|300px]] || ~6300
|- style="text-align:center;"
| 1.0 || 32x32 || [[File:DMS103232.png|300px]] || ~110000
|- style="text-align:center;"
| 2.0 || 4x4 || [[File:DMS2044.png|300px]] || -
|- style="text-align:center;"
| 2.0 || 8x8 || [[File:DMS2088.png|300px]] || -
|}
{| class="wikitable floatright" width=42%
|+ ''Table 6: Number of cycles to be ignored for each system size''
! System Size !! Number of cycles before averaging
|- style="text-align:center;"
| 2x2 || 0
|- style="text-align:center;"
| 4x4 || 100
|- style="text-align:center;"
| 8x8 || 1000
|- style="text-align:center;"
| 16x16 || 8000
|- style="text-align:center;"
| 32x32 || 120000
|}
Analysis of these graphs indicates that at higher temperatures, such as 2.0 (also observed at 1.5), large fluctuations in the energy and magnetisation are observed - these fluctuations are the reason that the average values of the properties must be taken. As the temperature is increased for systems of size 4x4, 8x8 and 16x16, it is clear that the number of cycles required in order to reach equilibrium increases. Hence, for the temperature range to be considered later (0.25 to 5.00), the required number of cycles was overestimated in order to ensure that all measurements were taken whilst the system was in equilibrium. The proposed numbers of cycles to be ignored for each system size are presented in ''Table 6''.

The python script developed up to this point was modified to account for these values by inclusion of a skip_region variable, which defines the number of cycles performed before energies and magnetisations contribute to the self.X values (before averaging occurs). The modified script is presented [[Mod:DMS3053-5|here]].

===Running over a range of temperatures===
[[File:DMS88dat.png|300px|thumb|right|'''''Figure 5''': Average energy and average magnetisation vs. temperature for 8x8 lattice, with error bars'']]
Using the python script modified in the previous exercise, the code can now be used to simulate the 8x8 system at a range of temperatures, using the ILtemperaturerange.py file (shown [[Mod:DMS3053-temprange|here]]). Here, the temperature range of 0.25 to 5.00 was used, with a separation of 0.25 between points, whilst the runtime was set to 10000 (neglecting the property values for the first 1000 cycles). Running this simulation produced the graphs in ''Figure 5'', where error bars computed using standard errors have also been included (these are small as a consequence of small standard errors). From the graph of average energy versus temperature, the phase transition can be observed - this occurs in the region with a gradient that is not close to zero. The data used here (temperature, average energies, average squared-energies, average magnetisations and average squared-magnetisations) was then saved as a numpy array in a new file, 8x8.dat.

==The effect of system size==
[[File:DMSLatticeSizeCombinedPlot.png|300px|thumb|right|'''''Figure 6''': Average energy and average magnetisation (per spins) vs. temperature for multiple lattice sizes'']]
The process conducted for the 8x8 lattice in the previous exercise was then repeated for lattices of sizes 2x2, 4x4, 16x16 and 32x32, with the data saved in .dat files. These files were then accessed, and the average energy and magnetisation data were plotted on one graph for all of the lattices sizes - this was achieved using the script presented [[Mod:DMS3053-6|here]]. The graphs produced in this manner are shown in ''Figure 6''.

A consideration of this graph suggests that in order to capture the long range fluctuations, whilst minimising the computational time required, an 8x8 lattice is likely to be the optimum choice. This is because the graph for this system size is comparable to that for a 32x32 lattice, whilst being faster to compute.

==Determining the heat capacity==
[[File:DMSheatcapacity2.png|300px|thumb|right|'''''Figure 7''': Heat capacity (per spin) versus temperature for different lattice sizes'']]
Using the .dat files previously produced, the heat capacity was calculated for each lattice size using the equation
::<math>C = \frac{\partial E}{\partial T} = \frac{\mathrm{Var}[E]}{k_B T^2}</math>, (''eq. 9'') 
where <math>\mathrm{Var}[E] = <E^2> - <E>^2 </math>. When implementing this, the kB term was neglected due to the energy values having units of kB. The script used for this purpose is provided [[DMS3053-7|here]]. The plot of heat capacity per spin versus temperature for all of the lattice sizes considered is presented in ''Figure 7''.

==Locating the Curie temperature==
===Comparison with C++ Data===
The data for the heat capacity generated using the python script prepared in this experiment was compared to that from longer C++ computations - graphs showing this comparison are presented in ''Table 7'' for a range of lattice sizes. The Python code used to produce these graphs is shown [[Mod:DMS3053-8|here]].

Considering these graphs, it is clear that, in general, there is a reasonable correlation between the Python and C++ data; however, some of the data, particularly that for high lattice sizes, shows that the Python computations have not always found the maximum of heat capacity. This correlation would be improved by making computations at the same range of temperatures, but with a smaller gap between the temperatures taken; however, this would substantially increase computation time.
{| class="wikitable center" width=70%
|+ ''Table 7: Graphs of heat capacity (per spin) versus temperature for C++ and Python data''
|- style="text-align:center;"
| [[File:DMS2x2c.png|300px]] || [[File:DMS4x4c.png|300px]] || [[File:DMS8x8c.png|300px]]
|- style="text-align:center;"
| 2x2 || 4x4 || 8x8
|- style="text-align:center;"
| [[File:DMS16x16c.png|300px]] || [[File:DMS32x32c.png|300px]]
|- style="text-align:center;"
| 16x16 || 32x32
|}

===Polynomial Fitting===
[[File:DMS8x8513.png|300px|thumb|right|'''''Figure 8''': Heat capacity (per spin) versus temperature for 8x8 system with two polynomial fits'']]
In order to make use of the C++ data in finding the Curie temperature for the Ising Lattices under consideration, polynomials were fit to the data - the script written for this purpose is shown [[Mod:DMS3053-9|here]]. For this fitting, it was found that a polynomial order of 5 was required to provide a good fit for the 2x2 data - this increased significantly as the lattice size increased. An example fit is shown for the 8x8 system in ''Figure 8'', where the polynomial fit is shown for orders 5 and 13. A consideration of this graph reveals that whilst a polynomial of order 5 may be appropriate for a 2x2 system, it is inadequate for the larger system of 8x8. Whilst an order of 13 substantially improves the polynomial fit, one must, in general, take care with 'overfitting' data.
[[File:Py8x8(13fit).png|300px|thumb|left|'''''Figure 9''': Heat capacity (per spin) versus temperature for Python data for 8x8 system with a 13th order polynomial fit'']]
For comparison, a 13th order polynomial was fitted to the 8x8 Python data previously computed - this is shown in ''Figure 9''. Here, it is evident that for this data, a higher order polynomial is required to obtain a fit comparable to that for the C++ data above.

===Fitting in a Particular Temperature Range===
[[File:DMS8x8peak(3).png|300px|thumb|right|'''''Figure 10''': Heat capacity (per spin) versus temperature for 8x8 system with peak polynomial fit'']]
As was observed in the previous exercise, large polynomial orders are required to fit the C++ data well across the whole temperature range. The python script was modified to that presented [[Mod:DMS3053-10|here]] (this script also contains the python code to compute the maximum heat capacity and temperature at which this occurs for the following exercise), which fits a polynomial only in the region of the maximum heat capacity for the system. An example of such fit is shown in ''Figure 10'' for the 8x8 system. Here, it should be noted that for all of the system sizes studied, a polynomial order of 3 was used - this is a clear improvement compared to the 13th order polynomials used previously.

===Finding the Peak in Heat Capacity===
{| class="wikitable floatright" width=42%
|+ ''Table 8: Lattice sizes and their corresponding Curie temperatures''
! System Size !! Number of cycles before averaging
|- style="text-align:center;"
| 2x2 || 2.53503504
|- style="text-align:center;"
| 4x4 || 2.43843844
|- style="text-align:center;"
| 8x8 || 2.33433433
|- style="text-align:center;"
| 16x16 || 2.30455455
|- style="text-align:center;"
| 32x32 || 2.27752753
|}
[[File:DMSCurieTemperature.png|300px|thumb|left|'''''Figure 11''': Curie temperature vs. 1/(lattice length), with extrapolated linear fit'']]
In order to find the Curie temperature for an infinite Ising Lattice, the Curie temperature for each system size considered was first found (using the script shown in the previous exercise). These temperatures were then saved to a .dat file (whose contents are also showed in ''Table 8'', along with their corresponding lattice sizes. Finally, using the script presented [[Mod:DMS3053-11|here]], a graph of Curie temperature versus the inverse of the lattice length was plotted, according to the equation
::<math>T_{C, L} = \frac{A}{L} + T_{C,\infty}</math>, ''(eq. 10)
where <math>T_{C, L}</math> is the Curie temperature for a lattice with length L and <math>T_{C,\infty}</math> is the Curie temperature for an infinite Ising lattice. Hence, it is clear that the desired Curie temperature must be the y-intercept of the graph shown in ''Figure 11'' (hence the use of extrapolation in the python script). Taking this extrapolated value gives a Curie temperature of 2.271. This value can be compared to the theoretical exact value of 2.27,<ref>D. K. Khudier, N. I. Fawaz, ''Int. Lett. Them. Phys. Astron.'', 2013, '''10''', 201-212. Available from: http://www.ilcpa.pl/wp-content/uploads/2012/11/ILCPA-102-2013-201-2121.pdf</ref> which indicates a good agreement between the value calculated in this investigation and the theoretical exact value. This is surprising given that it would be expected that the polynomial fitting of the data to locate the maximum would contribute a considerable degree of error to the final value.

==References==
<references/>
</div>

Rep:Mod:DMS3053

2015-02-26T10:16:48Z

Ds3012: /* Magnetisation */

'''CMP Programming Experiment - Daniel Spencer, 00736964'''
<div style="text-align: justify">
==Introduction to the Ising Model==
===Minimum energy of the Ising Model===
Using the equation 
::<math>E= - \frac{1}{2} J \sum_i^N \sum_{j\ \in\ \mathrm{neighbours}\left(i\right)} s_i s_j</math> (''eq. 1'') 
the minimum energy of an Ising lattice of <math>D</math> dimensions, with <math>N</math> spins (where each
spin had a value of +1 or -1) and an interaction strength of <math>J</math> was considered. This was achieved first through a consideration of a one-dimensional system with five parallel spins (where the spins are parallel as this corresponds to the minimum energy arrangement of the system). Hence, the energy of this linear system was found to be 
::<math>E_\text{min,1D} = -5J </math>. 
For a linear, one-dimensional system, the number of neigbouring spins is two. The number of neighbours can be determined for two- and three- dimensional systems through a geometric consideration of their structure - the values are presented in ''Table 1''.
{| class="wikitable floatright" width=42%
|+ ''Table 1: Dimension numbers and number of neighbours''
! Number of Dimensions, D !! Number of Neighbours
|- style="text-align:center;"
| 1 || 2
|- style="text-align:center;"
| 2 || 4
|- style="text-align:center;"
| 3 || 6
|- style="text-align:center;"
| D || 2D
|}
These data indicate that the number of neighbours is twice the number of dimensions, for the dimensions considered here. This can be extrapolated to give the general number of neighbours as <math>2D</math>.

For the minimum energy of the system, where all spins are parallel, every combination <math>s_i s_j</math> has a value of 1. Notably, for each value of <math>i</math>, there will be <math>2D</math> neighbour interactions. Ergo, using ''eq. 1'', the general minimum energy can be found to be
::<math>E_\text{min,D} = -DNJ </math> (''eq. 2''). 
To check this equation, it can be applied to the two-dimensional Ising lattice with 25 spins - this gives a value of
::<math>E_\text{min,2D} = -50J </math>, 
which matches with the value predicted from first-principles.

For this D-dimensional system, the multiplicity (i.e. the number of ways of achieving the specified configuration of spins) must be equal to two, as either all of the spins could be aligned 'up' (+1) or 'down' (-1). Using this multiplicity, the entropy of the system can be calculated using the equation
::<math>S = k_B \ln\Omega</math>, (''eq. 3'') 
where Ω is the number of microstates (equal to the multiplicity in this case), which gives a value of <math>k_B \ln2 </math>, or 9.57 x 10-24 J K-1.

===Spin 'flipping'===

Using the Ising model, it is also possible to consider a change in state, reflected by a 'flipping' of the direction of one of the lattice spins. For this case, the energy (using ''eq. 1'') can be determined to be
::<math>E'= - \frac{1}{2} J (2DN - 4D - 4D) = 4DJ - DNJ</math>, (''eq. 4'') 
where the additional <math>4D</math> terms arise from the loss of 4D stabilising spin-aligned interactions and the gain of 4D destabilising spins anti-aligned interactions following spin 'flipping'. Using ''eq. 2'' and ''eq. 4'', the change in energy derived from this spin 'flip' can be calculated to be
::<math>\Delta E= 4DJ - DNJ + DNJ = 4DJ</math>. (''eq. 5'') 
For a system with three dimensions (D = 3) and 1000 spins (N = 1000), the system, using ''eq. 5'', was determined to increase in energy by <math>12 J</math>. Notably, this change in energy is independent of the number of spins in the system - it depends only on the number of dimensions and J.
[[File:ThirdYearCMPExpt-IsingSketch.png|300px|thumb|right|'' '''Figure 1''': Representation of Ising lattices in one (N=5), two (N=25), and three (N=125) dimensions. +1 and -1 spins are denoted by the red and blue cells respectively. Diagram taken from the lab script.'']]
A significant consideration with regards to the spin 'flipping' described here is the accompanying increase in entropy - the driving force for this process. For the scenario describing the change in direction of a single spin, the multiplicity of the system will be <math>2N</math> - this is a consequence of the system prior to 'flipping' having a multiplicity of two (all spins aligned 'up' or 'down'), where now, any one of the spins could flip, adding the factor of N to the multiplicity. Hence, the new entropy can be defined to be
::<math>S' = k_B \ln 2N</math>, (''eq. 6'') 
which allows the change in entropy to be calculated according to ''eq. 7''.
::<math>\Delta S = k_B \ln 2N - k_B \ln2 = k_B \ln N</math> (''eq. 7'') 
For the system described above (D = 3, N = 1000), the change in entropy associated with the spin 'flip' process is therefore <math>k_B ln 1000</math>, which is equal to 9.53 x 10-23 J K-1.

===Magnetisation===
{| class="wikitable floatleft" width=42%
|+ ''Table 2: Ising lattices and magnetisations''
! Ising Lattice !! Magnetisation
|- style="text-align:center;"
| 1D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 2D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 3D at 0 K || 1000 or -1000
|}
''Figure 1'' shows three examples of Ising lattices, with one, two and three dimensions respectively. Using the equation for magnetisation (''eq. 8''), the magnetisations of these systems can be calculated to be those presented in ''Table 2''.
::<math>M= \sum_i s_i</math> (''eq. 8'') 
For the three-dimensional system at a temperature of 0 K, all of the spins must be aligned either 'up' or 'down', as the entropic increase associated with 'flipped' spins does not provide a driving force at absolute zero - the only factor to consider is that of the energy, which is a minimum when all of the spins are aligned. For this case, the magnetisation could be either 1000 or -1000, depending upon the direction of the spin alignment. From a consideration of the magnetisation values calculated here, it is evident that with all of the spins aligned, the (magnitude of the) magnetisation of the system is at a maximum.

==Calculating the energy and magnetisation==
===Modifying the files===
[[File:DMStest_output2.png|300px|thumb|right|'' '''Figure 2''': Output image from testing IsingLattice.py using Ilcheck.py'']]
In order to use Python to compute the energy and magnetisation for a given two-dimensional Ising lattice, the class IsingLattice was used, where energy() and magnetisation() functions were written to calculate their corresponding properties for a random numpy array of spins (generated using np.random.choice). For this aspect of the experiment, the value of J was assumed to be 1.0, working in reduced units. The Python script developed can be viewed [[Mod:DMS3053-1|here]], including annotations.

===Testing the files===
In order to test the script prepared thus far, the Ilcheck.py script was run, generating the image presented in ''Figure 2''. An examination of this output clearly indicates that the script provides accurate energies and magnetisations for the minimum and maximum energy configurations, along with for an intermediate, random arrangement. Hence, it can be concluded that at the current level, the Python script is functioning as required.

==Introduction to the Monte Carlo simulation==
===Average Energy and Magnetisation===
[[File:DMSILanim3.png|300px|thumb|right|'''''Figure 3''': Animation result from ILanim.py, showing the resting of the system in the minimum energy state'']]
[[File:DMSILanim_meta.png|300px|thumb|right|'''''Figure 4''': Animation result from ILanim.py, showing the resting of the system in a meta-stable state'']]

In order to consider the generalisability of the prepared script, it is important to analyse how the script will function for large systems, such as those with 100 spins in the spin array. As each of these spins can be either 'up' or 'down', each spin has two choices. Hence, the number of possible configurations for the system can be written as <math>2^{100}</math>, which has a value of 1.2677 x 1030.

If one considers the sampling of a single configuration to take 1 x 10-9 s, then it is clear that sampling all of these considerations would take a total of 1.2677 x 1021 s (also expressed as 4.017 x 1013 years). From this analysis, it is evident that the sampling of configurations was a significant consideration in the writing of a python script for this task.

In order to account for this, the technique of importance sampling was implemented, using the statistical Boltzmann distribution, <math>\exp(- \Delta E / k_B T)</math>. Note that as the energy computed using the energy() function is in units of kB, this factor is not included in the script.

===Modifying IsingLattice.py to Implement a Monte Carlo Cycle===
The python script developed at this stage is presented [[Mod:DMS3053-2|here]], accompanied by annotations to explain how the script functions.

===Simulating the Monte Carlo Cycles===
{| class="wikitable floatright" width=42%
|+ ''Table 3: statistics() output for animated system at global minimum configuration (Figure 3)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.70542501728
|- style="text-align:center;"
| <E2> || 3.13520970111
|- style="text-align:center;"
| <M> || -0.829971492744
|- style="text-align:center;"
| <M2> || 0.770986982766
|}
For cases where T < Tc, it would be expected that the system would have a spontaneous magnetisation. When T > Tc, the entropy will be the dominating factor, potentially resulting in the system having a magnetisation of zero.
{| class="wikitable floatright" width=42%
|+ ''Table 4: statistics() output for animated system at meta-stable configuration (Figure 4)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.35076450189
|- style="text-align:center;"
| <E2> || 1.89025801939
|- style="text-align:center;"
| <M> || -0.344104665826
|- style="text-align:center;"
| <M2> || 0.138855365306
|}
Using the presented script and the ILanim.py script, the Monte Carlo cycles can be simulated to view the results on the spin array as the process progresses. Here, the system under consideration was an 8 x 8 spin array, at a temperature of 0.5. ''Figure 3'' shows the typical outcome of the animation, with the system having reached the most stable, minimum energy arrangement. For the result presented here, the output of the statistics() function was that shown in ''Table 3''.

It was also observed that the system could locate a meta-stable state, with large regions of spin 'up' and 'down' spins. An example of such a result is presented in ''Figure 4'' (for which the output data from statistics() is presented in ''Table 4'').

==Accelerating the code==

In order to examine the efficiency of the python script developed thus far, the Iltimetrial.py script was utilised to investigate the time taken to perform 2000 Monte Carlo cycles. This script was modified to the version presented [[Mod:DMS3053-3|here]], which repeats the time measurement a defined number of times, then calculates the average time and the standard error in this average. For the Monte Carlo script prepared previously, the average time for 2000 Monte Carlo cycles was measured to be 5.475804 s and a standard error was calculated to be 0.008325 s, with 100 measurements made using the script.

Evidently, the current script is slow at conducting large numbers of Monte Carlo cycles and hence, a more efficient script was developed using the np.roll, np.multiply and np.sum functions - this is presented [[Mod:DMS3053-4|here]].

After this optimisation of the python script, the Iltimetrial.py script was re-run, giving an average time of 0.291467 s, with a standard error of 0.000156 s. Clearly, this optimised script is substantially faster than that developed previously (approximately 19 times faster).

==The effect of temperature==
===Correcting the averaging code===
As the equilibrium state of the system requires a number of Monte Carlo cycles to be reached, it is evident that the average energies and magnetisations are accounting for values for non-equilibrium arrangements - this was accounted for through a consideration of the number of cycles required to reach equilibrium. For this, the ILfinalframe.py script was used, giving the graphs shown in ''Table 5''. Here, each system was run for 150000 Monte Carlo cycles.
{| class="wikitable center" width=70%
|+ ''Table 5: Graphs of energy and magnetisation versus number of Monte Carlo cycles for different temperatures and system sizes''
! Temperature !! System Size !! Resulting Graphs !! Cycles for Equilibrium
|- style="text-align:center;"
| 0.5 || 4x4 || [[File:DMS0544.png|300px]] || 24
|- style="text-align:center;"
| 0.5 || 8x8 || [[File:DMS0588.png|300px]] || 392
|- style="text-align:center;"
| 0.5 || 16x16 || [[File:DMS051616.png|300px]] || 5549
|- style="text-align:center;"
| 1.0 || 2x2 || [[File:DMS1022.png|300px]] || (0)
|- style="text-align:center;"
| 1.0 || 4x4 || [[File:DMS1044.png|300px]] || 49
|- style="text-align:center;"
| 1.0 || 8x8 || [[File:DMS10882.png|300px]] || 590
|- style="text-align:center;"
| 1.0 || 16x16 || [[File:DMS101616.png|300px]] || ~6300
|- style="text-align:center;"
| 1.0 || 32x32 || [[File:DMS103232.png|300px]] || ~110000
|- style="text-align:center;"
| 2.0 || 4x4 || [[File:DMS2044.png|300px]] || -
|- style="text-align:center;"
| 2.0 || 8x8 || [[File:DMS2088.png|300px]] || -
|}
{| class="wikitable floatright" width=42%
|+ ''Table 6: Number of cycles to be ignored for each system size''
! System Size !! Number of cycles before averaging
|- style="text-align:center;"
| 2x2 || 0
|- style="text-align:center;"
| 4x4 || 100
|- style="text-align:center;"
| 8x8 || 1000
|- style="text-align:center;"
| 16x16 || 8000
|- style="text-align:center;"
| 32x32 || 120000
|}
Analysis of these graphs indicates that at higher temperatures, such as 2.0 (also observed at 1.5), large fluctuations in the energy and magnetisation are observed - these fluctuations are the reason that the average values of the properties must be taken. As the temperature is increased for systems of size 4x4, 8x8 and 16x16, it is clear that the number of cycles required in order to reach equilibrium increases. Hence, for the temperature range to be considered later (0.25 to 5.00), the required number of cycles was overestimated in order to ensure that all measurements were taken whilst the system was in equilibrium. The proposed numbers of cycles to be ignored for each system size are presented in ''Table 6''.

The python script developed up to this point was modified to account for these values by inclusion of a skip_region variable, which defines the number of cycles performed before energies and magnetisations contribute to the self.X values (before averaging occurs). The modified script is presented [[Mod:DMS3053-5|here]].

===Running over a range of temperatures===
[[File:DMS88dat.png|300px|thumb|right|'''''Figure 5''': Average energy and average magnetisation vs. temperature for 8x8 lattice, with error bars'']]
Using the python script modified in the previous exercise, the code can now be used to simulate the 8x8 system at a range of temperatures, using the ILtemperaturerange.py file (shown [[Mod:DMS3053-temprange|here]]). Here, the temperature range of 0.25 to 5.00 was used, with a separation of 0.25 between points, whilst the runtime was set to 10000 (neglecting the property values for the first 1000 cycles). Running this simulation produced the graphs in ''Figure 5'', where error bars computed using standard errors have also been included (these are small as a consequence of small standard errors). From the graph of average energy versus temperature, the phase transition can be observed - this occurs in the region with a gradient that is not close to zero. The data used here (temperature, average energies, average squared-energies, average magnetisations and average squared-magnetisations) was then saved as a numpy array in a new file, 8x8.dat.

==The effect of system size==
[[File:DMSLatticeSizeCombinedPlot.png|300px|thumb|right|'''''Figure 6''': Average energy and average magnetisation (per spins) vs. temperature for multiple lattice sizes'']]
The process conducted for the 8x8 lattice in the previous exercise was then repeated for lattices of sizes 2x2, 4x4, 16x16 and 32x32, with the data saved in .dat files. These files were then accessed, and the average energy and magnetisation data were plotted on one graph for all of the lattices sizes - this was achieved using the script presented [[Mod:DMS3053-6|here]]. The graphs produced in this manner are shown in ''Figure 6''.

A consideration of this graph suggests that in order to capture the long range fluctuations, whilst minimising the computational time required, an 8x8 lattice is likely to be the optimum choice. This is because the graph for this system size is comparable to that for a 32x32 lattice, whilst being faster to compute.

==Determining the heat capacity==
[[File:DMSheatcapacity2.png|300px|thumb|right|'''''Figure 7''': Heat capacity (per spin) versus temperature for different lattice sizes'']]
Using the .dat files previously produced, the heat capacity was calculated for each lattice size using the equation
::<math>C = \frac{\partial E}{\partial T} = \frac{\mathrm{Var}[E]}{k_B T^2}</math>, (''eq. 9'') 
where <math>\mathrm{Var}[E] = <E^2> - <E>^2 </math>. When implementing this, the kB term was neglected due to the energy values having units of kB. The script used for this purpose is provided [[DMS3053-7|here]]. The plot of heat capacity per spin versus temperature for all of the lattice sizes considered is presented in ''Figure 7''.

==Locating the Curie temperature==
===Comparison with C++ Data===
The data for the heat capacity generated using the python script prepared in this experiment was compared to that from longer C++ computations - graphs showing this comparison are presented in ''Table 7'' for a range of lattice sizes. The Python code used to produce these graphs is shown [[Mod:DMS3053-8|here]].

Considering these graphs, it is clear that, in general, there is a reasonable correlation between the Python and C++ data; however, some of the data, particularly that for high lattice sizes, shows that the Python computations have not always found the maximum of heat capacity. This correlation would be improved by making computations at the same range of temperatures, but with a smaller gap between the temperatures taken; however, this would substantially increase computation time.
{| class="wikitable center" width=70%
|+ ''Table 7: Graphs of heat capacity (per spin) versus temperature for C++ and Python data''
|- style="text-align:center;"
| [[File:DMS2x2c.png|300px]] || [[File:DMS4x4c.png|300px]] || [[File:DMS8x8c.png|300px]]
|- style="text-align:center;"
| 2x2 || 4x4 || 8x8
|- style="text-align:center;"
| [[File:DMS16x16c.png|300px]] || [[File:DMS32x32c.png|300px]]
|- style="text-align:center;"
| 16x16 || 32x32
|}

===Polynomial Fitting===
[[File:DMS8x8513.png|300px|thumb|right|'''''Figure 8''': Heat capacity (per spin) versus temperature for 8x8 system with two polynomial fits'']]
In order to make use of the C++ data in finding the Curie temperature for the Ising Lattices under consideration, polynomials were fit to the data - the script written for this purpose is shown [[Mod:DMS3053-9|here]]. For this fitting, it was found that a polynomial order of 5 was required to provide a good fit for the 2x2 data - this increased significantly as the lattice size increased. An example fit is shown for the 8x8 system in ''Figure 8'', where the polynomial fit is shown for orders 5 and 13. A consideration of this graph reveals that whilst a polynomial of order 5 may be appropriate for a 2x2 system, it is inadequate for the larger system of 8x8. Whilst an order of 13 substantially improves the polynomial fit, one must, in general, take care with 'overfitting' data.
[[File:Py8x8(13fit).png|300px|thumb|left|'''''Figure 9''': Heat capacity (per spin) versus temperature for Python data for 8x8 system with a 13th order polynomial fit'']]
For comparison, a 13th order polynomial was fitted to the 8x8 Python data previously computed - this is shown in ''Figure 9''. Here, it is evident that for this data, a higher order polynomial is required to obtain a fit comparable to that for the C++ data above.

===Fitting in a Particular Temperature Range===
[[File:DMS8x8peak(3).png|300px|thumb|right|'''''Figure 10''': Heat capacity (per spin) versus temperature for 8x8 system with peak polynomial fit'']]
As was observed in the previous exercise, large polynomial orders are required to fit the C++ data well across the whole temperature range. The python script was modified to that presented [[Mod:DMS3053-10|here]] (this script also contains the python code to compute the maximum heat capacity and temperature at which this occurs for the following exercise), which fits a polynomial only in the region of the maximum heat capacity for the system. An example of such fit is shown in ''Figure 10'' for the 8x8 system. Here, it should be noted that for all of the system sizes studied, a polynomial order of 3 was used - this is a clear improvement compared to the 13th order polynomials used previously.

===Finding the Peak in Heat Capacity===
{| class="wikitable floatright" width=42%
|+ ''Table 8: Lattice sizes and their corresponding Curie temperatures''
! System Size !! Number of cycles before averaging
|- style="text-align:center;"
| 2x2 || 2.53503504
|- style="text-align:center;"
| 4x4 || 2.43843844
|- style="text-align:center;"
| 8x8 || 2.33433433
|- style="text-align:center;"
| 16x16 || 2.30455455
|- style="text-align:center;"
| 32x32 || 2.27752753
|}
[[File:DMSCurieTemperature.png|300px|thumb|left|'''''Figure 11''': Curie temperature vs. 1/(lattice length), with extrapolated linear fit'']]
In order to find the Curie temperature for an infinite Ising Lattice, the Curie temperature for each system size considered was first found (using the script shown in the previous exercise). These temperatures were then saved to a .dat file (whose contents are also showed in ''Table 8'', along with their corresponding lattice sizes. Finally, using the script presented [[Mod:DMS3053-11|here]], a graph of Curie temperature versus the inverse of the lattice length was plotted, according to the equation
::<math>T_{C, L} = \frac{A}{L} + T_{C,\infty}</math>, ''(eq. 10)
where <math>T_{C, L}</math> is the Curie temperature for a lattice with length L and <math>T_{C,\infty}</math> is the Curie temperature for an infinite Ising lattice. Hence, it is clear that the desired Curie temperature must be the y-intercept of the graph shown in ''Figure 11'' (hence the use of extrapolation in the python script). Taking this extrapolated value gives a Curie temperature of 2.271. This value can be compared to the theoretical exact value of 2.27,<ref>D. K. Khudier, N. I. Fawaz, ''Int. Lett. Them. Phys. Astron.'', 2013, '''10''', 201-212. Available from: http://www.ilcpa.pl/wp-content/uploads/2012/11/ILCPA-102-2013-201-2121.pdf</ref> which indicates a good agreement between the value calculated in this investigation and the theoretical exact value. This is surprising given that it would be expected that the polynomial fitting of the data to locate the maximum would contribute a considerable degree of error to the final value.

==References==
<references/>
</div>

Rep:Mod:DMS3053

2015-02-26T10:16:09Z

Ds3012: /* The effect of system size */

'''CMP Programming Experiment - Daniel Spencer, 00736964'''
<div style="text-align: justify">
==Introduction to the Ising Model==
===Minimum energy of the Ising Model===
Using the equation 
::<math>E= - \frac{1}{2} J \sum_i^N \sum_{j\ \in\ \mathrm{neighbours}\left(i\right)} s_i s_j</math> (''eq. 1'') 
the minimum energy of an Ising lattice of <math>D</math> dimensions, with <math>N</math> spins (where each
spin had a value of +1 or -1) and an interaction strength of <math>J</math> was considered. This was achieved first through a consideration of a one-dimensional system with five parallel spins (where the spins are parallel as this corresponds to the minimum energy arrangement of the system). Hence, the energy of this linear system was found to be 
::<math>E_\text{min,1D} = -5J </math>. 
For a linear, one-dimensional system, the number of neigbouring spins is two. The number of neighbours can be determined for two- and three- dimensional systems through a geometric consideration of their structure - the values are presented in ''Table 1''.
{| class="wikitable floatright" width=42%
|+ ''Table 1: Dimension numbers and number of neighbours''
! Number of Dimensions, D !! Number of Neighbours
|- style="text-align:center;"
| 1 || 2
|- style="text-align:center;"
| 2 || 4
|- style="text-align:center;"
| 3 || 6
|- style="text-align:center;"
| D || 2D
|}
These data indicate that the number of neighbours is twice the number of dimensions, for the dimensions considered here. This can be extrapolated to give the general number of neighbours as <math>2D</math>.

For the minimum energy of the system, where all spins are parallel, every combination <math>s_i s_j</math> has a value of 1. Notably, for each value of <math>i</math>, there will be <math>2D</math> neighbour interactions. Ergo, using ''eq. 1'', the general minimum energy can be found to be
::<math>E_\text{min,D} = -DNJ </math> (''eq. 2''). 
To check this equation, it can be applied to the two-dimensional Ising lattice with 25 spins - this gives a value of
::<math>E_\text{min,2D} = -50J </math>, 
which matches with the value predicted from first-principles.

For this D-dimensional system, the multiplicity (i.e. the number of ways of achieving the specified configuration of spins) must be equal to two, as either all of the spins could be aligned 'up' (+1) or 'down' (-1). Using this multiplicity, the entropy of the system can be calculated using the equation
::<math>S = k_B \ln\Omega</math>, (''eq. 3'') 
where Ω is the number of microstates (equal to the multiplicity in this case), which gives a value of <math>k_B \ln2 </math>, or 9.57 x 10-24 J K-1.

===Spin 'flipping'===

Using the Ising model, it is also possible to consider a change in state, reflected by a 'flipping' of the direction of one of the lattice spins. For this case, the energy (using ''eq. 1'') can be determined to be
::<math>E'= - \frac{1}{2} J (2DN - 4D - 4D) = 4DJ - DNJ</math>, (''eq. 4'') 
where the additional <math>4D</math> terms arise from the loss of 4D stabilising spin-aligned interactions and the gain of 4D destabilising spins anti-aligned interactions following spin 'flipping'. Using ''eq. 2'' and ''eq. 4'', the change in energy derived from this spin 'flip' can be calculated to be
::<math>\Delta E= 4DJ - DNJ + DNJ = 4DJ</math>. (''eq. 5'') 
For a system with three dimensions (D = 3) and 1000 spins (N = 1000), the system, using ''eq. 5'', was determined to increase in energy by <math>12 J</math>. Notably, this change in energy is independent of the number of spins in the system - it depends only on the number of dimensions and J.
[[File:ThirdYearCMPExpt-IsingSketch.png|300px|thumb|right|'' '''Figure 1''': Representation of Ising lattices in one (N=5), two (N=25), and three (N=125) dimensions. +1 and -1 spins are denoted by the red and blue cells respectively. Diagram taken from the lab script.'']]
A significant consideration with regards to the spin 'flipping' described here is the accompanying increase in entropy - the driving force for this process. For the scenario describing the change in direction of a single spin, the multiplicity of the system will be <math>2N</math> - this is a consequence of the system prior to 'flipping' having a multiplicity of two (all spins aligned 'up' or 'down'), where now, any one of the spins could flip, adding the factor of N to the multiplicity. Hence, the new entropy can be defined to be
::<math>S' = k_B \ln 2N</math>, (''eq. 6'') 
which allows the change in entropy to be calculated according to ''eq. 7''.
::<math>\Delta S = k_B \ln 2N - k_B \ln2 = k_B \ln N</math> (''eq. 7'') 
For the system described above (D = 3, N = 1000), the change in entropy associated with the spin 'flip' process is therefore <math>k_B ln 1000</math>, which is equal to 9.53 x 10-23 J K-1.

===Magnetisation===
{| class="wikitable floatright" width=42%
|+ ''Table 2: Ising lattices and magnetisations''
! Ising Lattice !! Magnetisation
|- style="text-align:center;"
| 1D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 2D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 3D at 0 K || 1000 or -1000
|}
''Figure 1'' shows three examples of Ising lattices, with one, two and three dimensions respectively. Using the equation for magnetisation (''eq. 8''), the magnetisations of these systems can be calculated to be those presented in ''Table 2''.
::<math>M= \sum_i s_i</math> (''eq. 8'') 
For the three-dimensional system at a temperature of 0 K, all of the spins must be aligned either 'up' or 'down', as the entropic increase associated with 'flipped' spins does not provide a driving force at absolute zero - the only factor to consider is that of the energy, which is a minimum when all of the spins are aligned. For this case, the magnetisation could be either 1000 or -1000, depending upon the direction of the spin alignment. From a consideration of the magnetisation values calculated here, it is evident that with all of the spins aligned, the (magnitude of the) magnetisation of the system is at a maximum.

==Calculating the energy and magnetisation==
===Modifying the files===
[[File:DMStest_output2.png|300px|thumb|right|'' '''Figure 2''': Output image from testing IsingLattice.py using Ilcheck.py'']]
In order to use Python to compute the energy and magnetisation for a given two-dimensional Ising lattice, the class IsingLattice was used, where energy() and magnetisation() functions were written to calculate their corresponding properties for a random numpy array of spins (generated using np.random.choice). For this aspect of the experiment, the value of J was assumed to be 1.0, working in reduced units. The Python script developed can be viewed [[Mod:DMS3053-1|here]], including annotations.

===Testing the files===
In order to test the script prepared thus far, the Ilcheck.py script was run, generating the image presented in ''Figure 2''. An examination of this output clearly indicates that the script provides accurate energies and magnetisations for the minimum and maximum energy configurations, along with for an intermediate, random arrangement. Hence, it can be concluded that at the current level, the Python script is functioning as required.

==Introduction to the Monte Carlo simulation==
===Average Energy and Magnetisation===
[[File:DMSILanim3.png|300px|thumb|right|'''''Figure 3''': Animation result from ILanim.py, showing the resting of the system in the minimum energy state'']]
[[File:DMSILanim_meta.png|300px|thumb|right|'''''Figure 4''': Animation result from ILanim.py, showing the resting of the system in a meta-stable state'']]

In order to consider the generalisability of the prepared script, it is important to analyse how the script will function for large systems, such as those with 100 spins in the spin array. As each of these spins can be either 'up' or 'down', each spin has two choices. Hence, the number of possible configurations for the system can be written as <math>2^{100}</math>, which has a value of 1.2677 x 1030.

If one considers the sampling of a single configuration to take 1 x 10-9 s, then it is clear that sampling all of these considerations would take a total of 1.2677 x 1021 s (also expressed as 4.017 x 1013 years). From this analysis, it is evident that the sampling of configurations was a significant consideration in the writing of a python script for this task.

In order to account for this, the technique of importance sampling was implemented, using the statistical Boltzmann distribution, <math>\exp(- \Delta E / k_B T)</math>. Note that as the energy computed using the energy() function is in units of kB, this factor is not included in the script.

===Modifying IsingLattice.py to Implement a Monte Carlo Cycle===
The python script developed at this stage is presented [[Mod:DMS3053-2|here]], accompanied by annotations to explain how the script functions.

===Simulating the Monte Carlo Cycles===
{| class="wikitable floatright" width=42%
|+ ''Table 3: statistics() output for animated system at global minimum configuration (Figure 3)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.70542501728
|- style="text-align:center;"
| <E2> || 3.13520970111
|- style="text-align:center;"
| <M> || -0.829971492744
|- style="text-align:center;"
| <M2> || 0.770986982766
|}
For cases where T < Tc, it would be expected that the system would have a spontaneous magnetisation. When T > Tc, the entropy will be the dominating factor, potentially resulting in the system having a magnetisation of zero.
{| class="wikitable floatright" width=42%
|+ ''Table 4: statistics() output for animated system at meta-stable configuration (Figure 4)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.35076450189
|- style="text-align:center;"
| <E2> || 1.89025801939
|- style="text-align:center;"
| <M> || -0.344104665826
|- style="text-align:center;"
| <M2> || 0.138855365306
|}
Using the presented script and the ILanim.py script, the Monte Carlo cycles can be simulated to view the results on the spin array as the process progresses. Here, the system under consideration was an 8 x 8 spin array, at a temperature of 0.5. ''Figure 3'' shows the typical outcome of the animation, with the system having reached the most stable, minimum energy arrangement. For the result presented here, the output of the statistics() function was that shown in ''Table 3''.

It was also observed that the system could locate a meta-stable state, with large regions of spin 'up' and 'down' spins. An example of such a result is presented in ''Figure 4'' (for which the output data from statistics() is presented in ''Table 4'').

==Accelerating the code==

In order to examine the efficiency of the python script developed thus far, the Iltimetrial.py script was utilised to investigate the time taken to perform 2000 Monte Carlo cycles. This script was modified to the version presented [[Mod:DMS3053-3|here]], which repeats the time measurement a defined number of times, then calculates the average time and the standard error in this average. For the Monte Carlo script prepared previously, the average time for 2000 Monte Carlo cycles was measured to be 5.475804 s and a standard error was calculated to be 0.008325 s, with 100 measurements made using the script.

Evidently, the current script is slow at conducting large numbers of Monte Carlo cycles and hence, a more efficient script was developed using the np.roll, np.multiply and np.sum functions - this is presented [[Mod:DMS3053-4|here]].

After this optimisation of the python script, the Iltimetrial.py script was re-run, giving an average time of 0.291467 s, with a standard error of 0.000156 s. Clearly, this optimised script is substantially faster than that developed previously (approximately 19 times faster).

==The effect of temperature==
===Correcting the averaging code===
As the equilibrium state of the system requires a number of Monte Carlo cycles to be reached, it is evident that the average energies and magnetisations are accounting for values for non-equilibrium arrangements - this was accounted for through a consideration of the number of cycles required to reach equilibrium. For this, the ILfinalframe.py script was used, giving the graphs shown in ''Table 5''. Here, each system was run for 150000 Monte Carlo cycles.
{| class="wikitable center" width=70%
|+ ''Table 5: Graphs of energy and magnetisation versus number of Monte Carlo cycles for different temperatures and system sizes''
! Temperature !! System Size !! Resulting Graphs !! Cycles for Equilibrium
|- style="text-align:center;"
| 0.5 || 4x4 || [[File:DMS0544.png|300px]] || 24
|- style="text-align:center;"
| 0.5 || 8x8 || [[File:DMS0588.png|300px]] || 392
|- style="text-align:center;"
| 0.5 || 16x16 || [[File:DMS051616.png|300px]] || 5549
|- style="text-align:center;"
| 1.0 || 2x2 || [[File:DMS1022.png|300px]] || (0)
|- style="text-align:center;"
| 1.0 || 4x4 || [[File:DMS1044.png|300px]] || 49
|- style="text-align:center;"
| 1.0 || 8x8 || [[File:DMS10882.png|300px]] || 590
|- style="text-align:center;"
| 1.0 || 16x16 || [[File:DMS101616.png|300px]] || ~6300
|- style="text-align:center;"
| 1.0 || 32x32 || [[File:DMS103232.png|300px]] || ~110000
|- style="text-align:center;"
| 2.0 || 4x4 || [[File:DMS2044.png|300px]] || -
|- style="text-align:center;"
| 2.0 || 8x8 || [[File:DMS2088.png|300px]] || -
|}
{| class="wikitable floatright" width=42%
|+ ''Table 6: Number of cycles to be ignored for each system size''
! System Size !! Number of cycles before averaging
|- style="text-align:center;"
| 2x2 || 0
|- style="text-align:center;"
| 4x4 || 100
|- style="text-align:center;"
| 8x8 || 1000
|- style="text-align:center;"
| 16x16 || 8000
|- style="text-align:center;"
| 32x32 || 120000
|}
Analysis of these graphs indicates that at higher temperatures, such as 2.0 (also observed at 1.5), large fluctuations in the energy and magnetisation are observed - these fluctuations are the reason that the average values of the properties must be taken. As the temperature is increased for systems of size 4x4, 8x8 and 16x16, it is clear that the number of cycles required in order to reach equilibrium increases. Hence, for the temperature range to be considered later (0.25 to 5.00), the required number of cycles was overestimated in order to ensure that all measurements were taken whilst the system was in equilibrium. The proposed numbers of cycles to be ignored for each system size are presented in ''Table 6''.

The python script developed up to this point was modified to account for these values by inclusion of a skip_region variable, which defines the number of cycles performed before energies and magnetisations contribute to the self.X values (before averaging occurs). The modified script is presented [[Mod:DMS3053-5|here]].

===Running over a range of temperatures===
[[File:DMS88dat.png|300px|thumb|right|'''''Figure 5''': Average energy and average magnetisation vs. temperature for 8x8 lattice, with error bars'']]
Using the python script modified in the previous exercise, the code can now be used to simulate the 8x8 system at a range of temperatures, using the ILtemperaturerange.py file (shown [[Mod:DMS3053-temprange|here]]). Here, the temperature range of 0.25 to 5.00 was used, with a separation of 0.25 between points, whilst the runtime was set to 10000 (neglecting the property values for the first 1000 cycles). Running this simulation produced the graphs in ''Figure 5'', where error bars computed using standard errors have also been included (these are small as a consequence of small standard errors). From the graph of average energy versus temperature, the phase transition can be observed - this occurs in the region with a gradient that is not close to zero. The data used here (temperature, average energies, average squared-energies, average magnetisations and average squared-magnetisations) was then saved as a numpy array in a new file, 8x8.dat.

==The effect of system size==
[[File:DMSLatticeSizeCombinedPlot.png|300px|thumb|right|'''''Figure 6''': Average energy and average magnetisation (per spins) vs. temperature for multiple lattice sizes'']]
The process conducted for the 8x8 lattice in the previous exercise was then repeated for lattices of sizes 2x2, 4x4, 16x16 and 32x32, with the data saved in .dat files. These files were then accessed, and the average energy and magnetisation data were plotted on one graph for all of the lattices sizes - this was achieved using the script presented [[Mod:DMS3053-6|here]]. The graphs produced in this manner are shown in ''Figure 6''.

A consideration of this graph suggests that in order to capture the long range fluctuations, whilst minimising the computational time required, an 8x8 lattice is likely to be the optimum choice. This is because the graph for this system size is comparable to that for a 32x32 lattice, whilst being faster to compute.

==Determining the heat capacity==
[[File:DMSheatcapacity2.png|300px|thumb|right|'''''Figure 7''': Heat capacity (per spin) versus temperature for different lattice sizes'']]
Using the .dat files previously produced, the heat capacity was calculated for each lattice size using the equation
::<math>C = \frac{\partial E}{\partial T} = \frac{\mathrm{Var}[E]}{k_B T^2}</math>, (''eq. 9'') 
where <math>\mathrm{Var}[E] = <E^2> - <E>^2 </math>. When implementing this, the kB term was neglected due to the energy values having units of kB. The script used for this purpose is provided [[DMS3053-7|here]]. The plot of heat capacity per spin versus temperature for all of the lattice sizes considered is presented in ''Figure 7''.

==Locating the Curie temperature==
===Comparison with C++ Data===
The data for the heat capacity generated using the python script prepared in this experiment was compared to that from longer C++ computations - graphs showing this comparison are presented in ''Table 7'' for a range of lattice sizes. The Python code used to produce these graphs is shown [[Mod:DMS3053-8|here]].

Considering these graphs, it is clear that, in general, there is a reasonable correlation between the Python and C++ data; however, some of the data, particularly that for high lattice sizes, shows that the Python computations have not always found the maximum of heat capacity. This correlation would be improved by making computations at the same range of temperatures, but with a smaller gap between the temperatures taken; however, this would substantially increase computation time.
{| class="wikitable center" width=70%
|+ ''Table 7: Graphs of heat capacity (per spin) versus temperature for C++ and Python data''
|- style="text-align:center;"
| [[File:DMS2x2c.png|300px]] || [[File:DMS4x4c.png|300px]] || [[File:DMS8x8c.png|300px]]
|- style="text-align:center;"
| 2x2 || 4x4 || 8x8
|- style="text-align:center;"
| [[File:DMS16x16c.png|300px]] || [[File:DMS32x32c.png|300px]]
|- style="text-align:center;"
| 16x16 || 32x32
|}

===Polynomial Fitting===
[[File:DMS8x8513.png|300px|thumb|right|'''''Figure 8''': Heat capacity (per spin) versus temperature for 8x8 system with two polynomial fits'']]
In order to make use of the C++ data in finding the Curie temperature for the Ising Lattices under consideration, polynomials were fit to the data - the script written for this purpose is shown [[Mod:DMS3053-9|here]]. For this fitting, it was found that a polynomial order of 5 was required to provide a good fit for the 2x2 data - this increased significantly as the lattice size increased. An example fit is shown for the 8x8 system in ''Figure 8'', where the polynomial fit is shown for orders 5 and 13. A consideration of this graph reveals that whilst a polynomial of order 5 may be appropriate for a 2x2 system, it is inadequate for the larger system of 8x8. Whilst an order of 13 substantially improves the polynomial fit, one must, in general, take care with 'overfitting' data.
[[File:Py8x8(13fit).png|300px|thumb|left|'''''Figure 9''': Heat capacity (per spin) versus temperature for Python data for 8x8 system with a 13th order polynomial fit'']]
For comparison, a 13th order polynomial was fitted to the 8x8 Python data previously computed - this is shown in ''Figure 9''. Here, it is evident that for this data, a higher order polynomial is required to obtain a fit comparable to that for the C++ data above.

===Fitting in a Particular Temperature Range===
[[File:DMS8x8peak(3).png|300px|thumb|right|'''''Figure 10''': Heat capacity (per spin) versus temperature for 8x8 system with peak polynomial fit'']]
As was observed in the previous exercise, large polynomial orders are required to fit the C++ data well across the whole temperature range. The python script was modified to that presented [[Mod:DMS3053-10|here]] (this script also contains the python code to compute the maximum heat capacity and temperature at which this occurs for the following exercise), which fits a polynomial only in the region of the maximum heat capacity for the system. An example of such fit is shown in ''Figure 10'' for the 8x8 system. Here, it should be noted that for all of the system sizes studied, a polynomial order of 3 was used - this is a clear improvement compared to the 13th order polynomials used previously.

===Finding the Peak in Heat Capacity===
{| class="wikitable floatright" width=42%
|+ ''Table 8: Lattice sizes and their corresponding Curie temperatures''
! System Size !! Number of cycles before averaging
|- style="text-align:center;"
| 2x2 || 2.53503504
|- style="text-align:center;"
| 4x4 || 2.43843844
|- style="text-align:center;"
| 8x8 || 2.33433433
|- style="text-align:center;"
| 16x16 || 2.30455455
|- style="text-align:center;"
| 32x32 || 2.27752753
|}
[[File:DMSCurieTemperature.png|300px|thumb|left|'''''Figure 11''': Curie temperature vs. 1/(lattice length), with extrapolated linear fit'']]
In order to find the Curie temperature for an infinite Ising Lattice, the Curie temperature for each system size considered was first found (using the script shown in the previous exercise). These temperatures were then saved to a .dat file (whose contents are also showed in ''Table 8'', along with their corresponding lattice sizes. Finally, using the script presented [[Mod:DMS3053-11|here]], a graph of Curie temperature versus the inverse of the lattice length was plotted, according to the equation
::<math>T_{C, L} = \frac{A}{L} + T_{C,\infty}</math>, ''(eq. 10)
where <math>T_{C, L}</math> is the Curie temperature for a lattice with length L and <math>T_{C,\infty}</math> is the Curie temperature for an infinite Ising lattice. Hence, it is clear that the desired Curie temperature must be the y-intercept of the graph shown in ''Figure 11'' (hence the use of extrapolation in the python script). Taking this extrapolated value gives a Curie temperature of 2.271. This value can be compared to the theoretical exact value of 2.27,<ref>D. K. Khudier, N. I. Fawaz, ''Int. Lett. Them. Phys. Astron.'', 2013, '''10''', 201-212. Available from: http://www.ilcpa.pl/wp-content/uploads/2012/11/ILCPA-102-2013-201-2121.pdf</ref> which indicates a good agreement between the value calculated in this investigation and the theoretical exact value. This is surprising given that it would be expected that the polynomial fitting of the data to locate the maximum would contribute a considerable degree of error to the final value.

==References==
<references/>
</div>

Rep:Mod:DMS3053

2015-02-26T10:04:39Z

Ds3012: /* Finding the Peak in Heat Capacity */

'''CMP Programming Experiment - Daniel Spencer, 00736964'''
<div style="text-align: justify">
==Introduction to the Ising Model==
===Minimum energy of the Ising Model===
Using the equation 
::<math>E= - \frac{1}{2} J \sum_i^N \sum_{j\ \in\ \mathrm{neighbours}\left(i\right)} s_i s_j</math> (''eq. 1'') 
the minimum energy of an Ising lattice of <math>D</math> dimensions, with <math>N</math> spins (where each
spin had a value of +1 or -1) and an interaction strength of <math>J</math> was considered. This was achieved first through a consideration of a one-dimensional system with five parallel spins (where the spins are parallel as this corresponds to the minimum energy arrangement of the system). Hence, the energy of this linear system was found to be 
::<math>E_\text{min,1D} = -5J </math>. 
For a linear, one-dimensional system, the number of neigbouring spins is two. The number of neighbours can be determined for two- and three- dimensional systems through a geometric consideration of their structure - the values are presented in ''Table 1''.
{| class="wikitable floatright" width=42%
|+ ''Table 1: Dimension numbers and number of neighbours''
! Number of Dimensions, D !! Number of Neighbours
|- style="text-align:center;"
| 1 || 2
|- style="text-align:center;"
| 2 || 4
|- style="text-align:center;"
| 3 || 6
|- style="text-align:center;"
| D || 2D
|}
These data indicate that the number of neighbours is twice the number of dimensions, for the dimensions considered here. This can be extrapolated to give the general number of neighbours as <math>2D</math>.

For the minimum energy of the system, where all spins are parallel, every combination <math>s_i s_j</math> has a value of 1. Notably, for each value of <math>i</math>, there will be <math>2D</math> neighbour interactions. Ergo, using ''eq. 1'', the general minimum energy can be found to be
::<math>E_\text{min,D} = -DNJ </math> (''eq. 2''). 
To check this equation, it can be applied to the two-dimensional Ising lattice with 25 spins - this gives a value of
::<math>E_\text{min,2D} = -50J </math>, 
which matches with the value predicted from first-principles.

For this D-dimensional system, the multiplicity (i.e. the number of ways of achieving the specified configuration of spins) must be equal to two, as either all of the spins could be aligned 'up' (+1) or 'down' (-1). Using this multiplicity, the entropy of the system can be calculated using the equation
::<math>S = k_B \ln\Omega</math>, (''eq. 3'') 
where Ω is the number of microstates (equal to the multiplicity in this case), which gives a value of <math>k_B \ln2 </math>, or 9.57 x 10-24 J K-1.

===Spin 'flipping'===

Using the Ising model, it is also possible to consider a change in state, reflected by a 'flipping' of the direction of one of the lattice spins. For this case, the energy (using ''eq. 1'') can be determined to be
::<math>E'= - \frac{1}{2} J (2DN - 4D - 4D) = 4DJ - DNJ</math>, (''eq. 4'') 
where the additional <math>4D</math> terms arise from the loss of 4D stabilising spin-aligned interactions and the gain of 4D destabilising spins anti-aligned interactions following spin 'flipping'. Using ''eq. 2'' and ''eq. 4'', the change in energy derived from this spin 'flip' can be calculated to be
::<math>\Delta E= 4DJ - DNJ + DNJ = 4DJ</math>. (''eq. 5'') 
For a system with three dimensions (D = 3) and 1000 spins (N = 1000), the system, using ''eq. 5'', was determined to increase in energy by <math>12 J</math>. Notably, this change in energy is independent of the number of spins in the system - it depends only on the number of dimensions and J.
[[File:ThirdYearCMPExpt-IsingSketch.png|300px|thumb|right|'' '''Figure 1''': Representation of Ising lattices in one (N=5), two (N=25), and three (N=125) dimensions. +1 and -1 spins are denoted by the red and blue cells respectively. Diagram taken from the lab script.'']]
A significant consideration with regards to the spin 'flipping' described here is the accompanying increase in entropy - the driving force for this process. For the scenario describing the change in direction of a single spin, the multiplicity of the system will be <math>2N</math> - this is a consequence of the system prior to 'flipping' having a multiplicity of two (all spins aligned 'up' or 'down'), where now, any one of the spins could flip, adding the factor of N to the multiplicity. Hence, the new entropy can be defined to be
::<math>S' = k_B \ln 2N</math>, (''eq. 6'') 
which allows the change in entropy to be calculated according to ''eq. 7''.
::<math>\Delta S = k_B \ln 2N - k_B \ln2 = k_B \ln N</math> (''eq. 7'') 
For the system described above (D = 3, N = 1000), the change in entropy associated with the spin 'flip' process is therefore <math>k_B ln 1000</math>, which is equal to 9.53 x 10-23 J K-1.

===Magnetisation===
{| class="wikitable floatright" width=42%
|+ ''Table 2: Ising lattices and magnetisations''
! Ising Lattice !! Magnetisation
|- style="text-align:center;"
| 1D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 2D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 3D at 0 K || 1000 or -1000
|}
''Figure 1'' shows three examples of Ising lattices, with one, two and three dimensions respectively. Using the equation for magnetisation (''eq. 8''), the magnetisations of these systems can be calculated to be those presented in ''Table 2''.
::<math>M= \sum_i s_i</math> (''eq. 8'') 
For the three-dimensional system at a temperature of 0 K, all of the spins must be aligned either 'up' or 'down', as the entropic increase associated with 'flipped' spins does not provide a driving force at absolute zero - the only factor to consider is that of the energy, which is a minimum when all of the spins are aligned. For this case, the magnetisation could be either 1000 or -1000, depending upon the direction of the spin alignment. From a consideration of the magnetisation values calculated here, it is evident that with all of the spins aligned, the (magnitude of the) magnetisation of the system is at a maximum.

==Calculating the energy and magnetisation==
===Modifying the files===
[[File:DMStest_output2.png|300px|thumb|right|'' '''Figure 2''': Output image from testing IsingLattice.py using Ilcheck.py'']]
In order to use Python to compute the energy and magnetisation for a given two-dimensional Ising lattice, the class IsingLattice was used, where energy() and magnetisation() functions were written to calculate their corresponding properties for a random numpy array of spins (generated using np.random.choice). For this aspect of the experiment, the value of J was assumed to be 1.0, working in reduced units. The Python script developed can be viewed [[Mod:DMS3053-1|here]], including annotations.

===Testing the files===
In order to test the script prepared thus far, the Ilcheck.py script was run, generating the image presented in ''Figure 2''. An examination of this output clearly indicates that the script provides accurate energies and magnetisations for the minimum and maximum energy configurations, along with for an intermediate, random arrangement. Hence, it can be concluded that at the current level, the Python script is functioning as required.

==Introduction to the Monte Carlo simulation==
===Average Energy and Magnetisation===
[[File:DMSILanim3.png|300px|thumb|right|'''''Figure 3''': Animation result from ILanim.py, showing the resting of the system in the minimum energy state'']]
[[File:DMSILanim_meta.png|300px|thumb|right|'''''Figure 4''': Animation result from ILanim.py, showing the resting of the system in a meta-stable state'']]

In order to consider the generalisability of the prepared script, it is important to analyse how the script will function for large systems, such as those with 100 spins in the spin array. As each of these spins can be either 'up' or 'down', each spin has two choices. Hence, the number of possible configurations for the system can be written as <math>2^{100}</math>, which has a value of 1.2677 x 1030.

If one considers the sampling of a single configuration to take 1 x 10-9 s, then it is clear that sampling all of these considerations would take a total of 1.2677 x 1021 s (also expressed as 4.017 x 1013 years). From this analysis, it is evident that the sampling of configurations was a significant consideration in the writing of a python script for this task.

In order to account for this, the technique of importance sampling was implemented, using the statistical Boltzmann distribution, <math>\exp(- \Delta E / k_B T)</math>. Note that as the energy computed using the energy() function is in units of kB, this factor is not included in the script.

===Modifying IsingLattice.py to Implement a Monte Carlo Cycle===
The python script developed at this stage is presented [[Mod:DMS3053-2|here]], accompanied by annotations to explain how the script functions.

===Simulating the Monte Carlo Cycles===
{| class="wikitable floatright" width=42%
|+ ''Table 3: statistics() output for animated system at global minimum configuration (Figure 3)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.70542501728
|- style="text-align:center;"
| <E2> || 3.13520970111
|- style="text-align:center;"
| <M> || -0.829971492744
|- style="text-align:center;"
| <M2> || 0.770986982766
|}
For cases where T < Tc, it would be expected that the system would have a spontaneous magnetisation. When T > Tc, the entropy will be the dominating factor, potentially resulting in the system having a magnetisation of zero.
{| class="wikitable floatright" width=42%
|+ ''Table 4: statistics() output for animated system at meta-stable configuration (Figure 4)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.35076450189
|- style="text-align:center;"
| <E2> || 1.89025801939
|- style="text-align:center;"
| <M> || -0.344104665826
|- style="text-align:center;"
| <M2> || 0.138855365306
|}
Using the presented script and the ILanim.py script, the Monte Carlo cycles can be simulated to view the results on the spin array as the process progresses. Here, the system under consideration was an 8 x 8 spin array, at a temperature of 0.5. ''Figure 3'' shows the typical outcome of the animation, with the system having reached the most stable, minimum energy arrangement. For the result presented here, the output of the statistics() function was that shown in ''Table 3''.

It was also observed that the system could locate a meta-stable state, with large regions of spin 'up' and 'down' spins. An example of such a result is presented in ''Figure 4'' (for which the output data from statistics() is presented in ''Table 4'').

==Accelerating the code==

In order to examine the efficiency of the python script developed thus far, the Iltimetrial.py script was utilised to investigate the time taken to perform 2000 Monte Carlo cycles. This script was modified to the version presented [[Mod:DMS3053-3|here]], which repeats the time measurement a defined number of times, then calculates the average time and the standard error in this average. For the Monte Carlo script prepared previously, the average time for 2000 Monte Carlo cycles was measured to be 5.475804 s and a standard error was calculated to be 0.008325 s, with 100 measurements made using the script.

Evidently, the current script is slow at conducting large numbers of Monte Carlo cycles and hence, a more efficient script was developed using the np.roll, np.multiply and np.sum functions - this is presented [[Mod:DMS3053-4|here]].

After this optimisation of the python script, the Iltimetrial.py script was re-run, giving an average time of 0.291467 s, with a standard error of 0.000156 s. Clearly, this optimised script is substantially faster than that developed previously (approximately 19 times faster).

==The effect of temperature==
===Correcting the averaging code===
As the equilibrium state of the system requires a number of Monte Carlo cycles to be reached, it is evident that the average energies and magnetisations are accounting for values for non-equilibrium arrangements - this was accounted for through a consideration of the number of cycles required to reach equilibrium. For this, the ILfinalframe.py script was used, giving the graphs shown in ''Table 5''. Here, each system was run for 150000 Monte Carlo cycles.
{| class="wikitable center" width=70%
|+ ''Table 5: Graphs of energy and magnetisation versus number of Monte Carlo cycles for different temperatures and system sizes''
! Temperature !! System Size !! Resulting Graphs !! Cycles for Equilibrium
|- style="text-align:center;"
| 0.5 || 4x4 || [[File:DMS0544.png|300px]] || 24
|- style="text-align:center;"
| 0.5 || 8x8 || [[File:DMS0588.png|300px]] || 392
|- style="text-align:center;"
| 0.5 || 16x16 || [[File:DMS051616.png|300px]] || 5549
|- style="text-align:center;"
| 1.0 || 2x2 || [[File:DMS1022.png|300px]] || (0)
|- style="text-align:center;"
| 1.0 || 4x4 || [[File:DMS1044.png|300px]] || 49
|- style="text-align:center;"
| 1.0 || 8x8 || [[File:DMS10882.png|300px]] || 590
|- style="text-align:center;"
| 1.0 || 16x16 || [[File:DMS101616.png|300px]] || ~6300
|- style="text-align:center;"
| 1.0 || 32x32 || [[File:DMS103232.png|300px]] || ~110000
|- style="text-align:center;"
| 2.0 || 4x4 || [[File:DMS2044.png|300px]] || -
|- style="text-align:center;"
| 2.0 || 8x8 || [[File:DMS2088.png|300px]] || -
|}
{| class="wikitable floatright" width=42%
|+ ''Table 6: Number of cycles to be ignored for each system size''
! System Size !! Number of cycles before averaging
|- style="text-align:center;"
| 2x2 || 0
|- style="text-align:center;"
| 4x4 || 100
|- style="text-align:center;"
| 8x8 || 1000
|- style="text-align:center;"
| 16x16 || 8000
|- style="text-align:center;"
| 32x32 || 120000
|}
Analysis of these graphs indicates that at higher temperatures, such as 2.0 (also observed at 1.5), large fluctuations in the energy and magnetisation are observed - these fluctuations are the reason that the average values of the properties must be taken. As the temperature is increased for systems of size 4x4, 8x8 and 16x16, it is clear that the number of cycles required in order to reach equilibrium increases. Hence, for the temperature range to be considered later (0.25 to 5.00), the required number of cycles was overestimated in order to ensure that all measurements were taken whilst the system was in equilibrium. The proposed numbers of cycles to be ignored for each system size are presented in ''Table 6''.

The python script developed up to this point was modified to account for these values by inclusion of a skip_region variable, which defines the number of cycles performed before energies and magnetisations contribute to the self.X values (before averaging occurs). The modified script is presented [[Mod:DMS3053-5|here]].

===Running over a range of temperatures===
[[File:DMS88dat.png|300px|thumb|right|'''''Figure 5''': Average energy and average magnetisation vs. temperature for 8x8 lattice, with error bars'']]
Using the python script modified in the previous exercise, the code can now be used to simulate the 8x8 system at a range of temperatures, using the ILtemperaturerange.py file (shown [[Mod:DMS3053-temprange|here]]). Here, the temperature range of 0.25 to 5.00 was used, with a separation of 0.25 between points, whilst the runtime was set to 10000 (neglecting the property values for the first 1000 cycles). Running this simulation produced the graphs in ''Figure 5'', where error bars computed using standard errors have also been included (these are small as a consequence of small standard errors). From the graph of average energy versus temperature, the phase transition can be observed - this occurs in the region with a gradient that is not close to zero. The data used here (temperature, average energies, average squared-energies, average magnetisations and average squared-magnetisations) was then saved as a numpy array in a new file, 8x8.dat.

==The effect of system size==
[[File:DMSLatticeSizeCombinedPlot.png|300px|thumb|right|'''''Figure 6''': Average energy and average magnetisation (per spins) vs. temperature for multiple lattice sizes'']]
The process conducted for the 8x8 lattice in the previous exercise was then repeated for lattices of sizes 2x2, 4x4, 16x16 and 32x32, with the data saved in .dat files. These files were then accessed, and the average energy and magnetisation data were plotted on one graph for all of the lattices sizes - this was achieved using the script presented [[Mod:DMS3053-6|here]]. The graphs produced in this manner are shown in ''Figure 6''.

A consideration of this graph suggests that in order to capture the long range fluctuations, a 16x16 lattice is necessary.

==Determining the heat capacity==
[[File:DMSheatcapacity2.png|300px|thumb|right|'''''Figure 7''': Heat capacity (per spin) versus temperature for different lattice sizes'']]
Using the .dat files previously produced, the heat capacity was calculated for each lattice size using the equation
::<math>C = \frac{\partial E}{\partial T} = \frac{\mathrm{Var}[E]}{k_B T^2}</math>, (''eq. 9'') 
where <math>\mathrm{Var}[E] = <E^2> - <E>^2 </math>. When implementing this, the kB term was neglected due to the energy values having units of kB. The script used for this purpose is provided [[DMS3053-7|here]]. The plot of heat capacity per spin versus temperature for all of the lattice sizes considered is presented in ''Figure 7''.

==Locating the Curie temperature==
===Comparison with C++ Data===
The data for the heat capacity generated using the python script prepared in this experiment was compared to that from longer C++ computations - graphs showing this comparison are presented in ''Table 7'' for a range of lattice sizes. The Python code used to produce these graphs is shown [[Mod:DMS3053-8|here]].

Considering these graphs, it is clear that, in general, there is a reasonable correlation between the Python and C++ data; however, some of the data, particularly that for high lattice sizes, shows that the Python computations have not always found the maximum of heat capacity. This correlation would be improved by making computations at the same range of temperatures, but with a smaller gap between the temperatures taken; however, this would substantially increase computation time.
{| class="wikitable center" width=70%
|+ ''Table 7: Graphs of heat capacity (per spin) versus temperature for C++ and Python data''
|- style="text-align:center;"
| [[File:DMS2x2c.png|300px]] || [[File:DMS4x4c.png|300px]] || [[File:DMS8x8c.png|300px]]
|- style="text-align:center;"
| 2x2 || 4x4 || 8x8
|- style="text-align:center;"
| [[File:DMS16x16c.png|300px]] || [[File:DMS32x32c.png|300px]]
|- style="text-align:center;"
| 16x16 || 32x32
|}

===Polynomial Fitting===
[[File:DMS8x8513.png|300px|thumb|right|'''''Figure 8''': Heat capacity (per spin) versus temperature for 8x8 system with two polynomial fits'']]
In order to make use of the C++ data in finding the Curie temperature for the Ising Lattices under consideration, polynomials were fit to the data - the script written for this purpose is shown [[Mod:DMS3053-9|here]]. For this fitting, it was found that a polynomial order of 5 was required to provide a good fit for the 2x2 data - this increased significantly as the lattice size increased. An example fit is shown for the 8x8 system in ''Figure 8'', where the polynomial fit is shown for orders 5 and 13. A consideration of this graph reveals that whilst a polynomial of order 5 may be appropriate for a 2x2 system, it is inadequate for the larger system of 8x8. Whilst an order of 13 substantially improves the polynomial fit, one must, in general, take care with 'overfitting' data.
[[File:Py8x8(13fit).png|300px|thumb|left|'''''Figure 9''': Heat capacity (per spin) versus temperature for Python data for 8x8 system with a 13th order polynomial fit'']]
For comparison, a 13th order polynomial was fitted to the 8x8 Python data previously computed - this is shown in ''Figure 9''. Here, it is evident that for this data, a higher order polynomial is required to obtain a fit comparable to that for the C++ data above.

===Fitting in a Particular Temperature Range===
[[File:DMS8x8peak(3).png|300px|thumb|right|'''''Figure 10''': Heat capacity (per spin) versus temperature for 8x8 system with peak polynomial fit'']]
As was observed in the previous exercise, large polynomial orders are required to fit the C++ data well across the whole temperature range. The python script was modified to that presented [[Mod:DMS3053-10|here]] (this script also contains the python code to compute the maximum heat capacity and temperature at which this occurs for the following exercise), which fits a polynomial only in the region of the maximum heat capacity for the system. An example of such fit is shown in ''Figure 10'' for the 8x8 system. Here, it should be noted that for all of the system sizes studied, a polynomial order of 3 was used - this is a clear improvement compared to the 13th order polynomials used previously.

===Finding the Peak in Heat Capacity===
{| class="wikitable floatright" width=42%
|+ ''Table 8: Lattice sizes and their corresponding Curie temperatures''
! System Size !! Number of cycles before averaging
|- style="text-align:center;"
| 2x2 || 2.53503504
|- style="text-align:center;"
| 4x4 || 2.43843844
|- style="text-align:center;"
| 8x8 || 2.33433433
|- style="text-align:center;"
| 16x16 || 2.30455455
|- style="text-align:center;"
| 32x32 || 2.27752753
|}
[[File:DMSCurieTemperature.png|300px|thumb|left|'''''Figure 11''': Curie temperature vs. 1/(lattice length), with extrapolated linear fit'']]
In order to find the Curie temperature for an infinite Ising Lattice, the Curie temperature for each system size considered was first found (using the script shown in the previous exercise). These temperatures were then saved to a .dat file (whose contents are also showed in ''Table 8'', along with their corresponding lattice sizes. Finally, using the script presented [[Mod:DMS3053-11|here]], a graph of Curie temperature versus the inverse of the lattice length was plotted, according to the equation
::<math>T_{C, L} = \frac{A}{L} + T_{C,\infty}</math>, ''(eq. 10)
where <math>T_{C, L}</math> is the Curie temperature for a lattice with length L and <math>T_{C,\infty}</math> is the Curie temperature for an infinite Ising lattice. Hence, it is clear that the desired Curie temperature must be the y-intercept of the graph shown in ''Figure 11'' (hence the use of extrapolation in the python script). Taking this extrapolated value gives a Curie temperature of 2.271. This value can be compared to the theoretical exact value of 2.27,<ref>D. K. Khudier, N. I. Fawaz, ''Int. Lett. Them. Phys. Astron.'', 2013, '''10''', 201-212. Available from: http://www.ilcpa.pl/wp-content/uploads/2012/11/ILCPA-102-2013-201-2121.pdf</ref> which indicates a good agreement between the value calculated in this investigation and the theoretical exact value. This is surprising given that it would be expected that the polynomial fitting of the data to locate the maximum would contribute a considerable degree of error to the final value.

==References==
<references/>
</div>

Rep:Mod:DMS3053

2015-02-25T16:13:20Z

Ds3012: /* Finding the Peak in Heat Capacity */

'''CMP Programming Experiment - Daniel Spencer, 00736964'''
<div style="text-align: justify">
==Introduction to the Ising Model==
===Minimum energy of the Ising Model===
Using the equation 
::<math>E= - \frac{1}{2} J \sum_i^N \sum_{j\ \in\ \mathrm{neighbours}\left(i\right)} s_i s_j</math> (''eq. 1'') 
the minimum energy of an Ising lattice of <math>D</math> dimensions, with <math>N</math> spins (where each
spin had a value of +1 or -1) and an interaction strength of <math>J</math> was considered. This was achieved first through a consideration of a one-dimensional system with five parallel spins (where the spins are parallel as this corresponds to the minimum energy arrangement of the system). Hence, the energy of this linear system was found to be 
::<math>E_\text{min,1D} = -5J </math>. 
For a linear, one-dimensional system, the number of neigbouring spins is two. The number of neighbours can be determined for two- and three- dimensional systems through a geometric consideration of their structure - the values are presented in ''Table 1''.
{| class="wikitable floatright" width=42%
|+ ''Table 1: Dimension numbers and number of neighbours''
! Number of Dimensions, D !! Number of Neighbours
|- style="text-align:center;"
| 1 || 2
|- style="text-align:center;"
| 2 || 4
|- style="text-align:center;"
| 3 || 6
|- style="text-align:center;"
| D || 2D
|}
These data indicate that the number of neighbours is twice the number of dimensions, for the dimensions considered here. This can be extrapolated to give the general number of neighbours as <math>2D</math>.

For the minimum energy of the system, where all spins are parallel, every combination <math>s_i s_j</math> has a value of 1. Notably, for each value of <math>i</math>, there will be <math>2D</math> neighbour interactions. Ergo, using ''eq. 1'', the general minimum energy can be found to be
::<math>E_\text{min,D} = -DNJ </math> (''eq. 2''). 
To check this equation, it can be applied to the two-dimensional Ising lattice with 25 spins - this gives a value of
::<math>E_\text{min,2D} = -50J </math>, 
which matches with the value predicted from first-principles.

For this D-dimensional system, the multiplicity (i.e. the number of ways of achieving the specified configuration of spins) must be equal to two, as either all of the spins could be aligned 'up' (+1) or 'down' (-1). Using this multiplicity, the entropy of the system can be calculated using the equation
::<math>S = k_B \ln\Omega</math>, (''eq. 3'') 
where Ω is the number of microstates (equal to the multiplicity in this case), which gives a value of <math>k_B \ln2 </math>, or 9.57 x 10-24 J K-1.

===Spin 'flipping'===

Using the Ising model, it is also possible to consider a change in state, reflected by a 'flipping' of the direction of one of the lattice spins. For this case, the energy (using ''eq. 1'') can be determined to be
::<math>E'= - \frac{1}{2} J (2DN - 4D - 4D) = 4DJ - DNJ</math>, (''eq. 4'') 
where the additional <math>4D</math> terms arise from the loss of 4D stabilising spin-aligned interactions and the gain of 4D destabilising spins anti-aligned interactions following spin 'flipping'. Using ''eq. 2'' and ''eq. 4'', the change in energy derived from this spin 'flip' can be calculated to be
::<math>\Delta E= 4DJ - DNJ + DNJ = 4DJ</math>. (''eq. 5'') 
For a system with three dimensions (D = 3) and 1000 spins (N = 1000), the system, using ''eq. 5'', was determined to increase in energy by <math>12 J</math>. Notably, this change in energy is independent of the number of spins in the system - it depends only on the number of dimensions and J.
[[File:ThirdYearCMPExpt-IsingSketch.png|300px|thumb|right|'' '''Figure 1''': Representation of Ising lattices in one (N=5), two (N=25), and three (N=125) dimensions. +1 and -1 spins are denoted by the red and blue cells respectively. Diagram taken from the lab script.'']]
A significant consideration with regards to the spin 'flipping' described here is the accompanying increase in entropy - the driving force for this process. For the scenario describing the change in direction of a single spin, the multiplicity of the system will be <math>2N</math> - this is a consequence of the system prior to 'flipping' having a multiplicity of two (all spins aligned 'up' or 'down'), where now, any one of the spins could flip, adding the factor of N to the multiplicity. Hence, the new entropy can be defined to be
::<math>S' = k_B \ln 2N</math>, (''eq. 6'') 
which allows the change in entropy to be calculated according to ''eq. 7''.
::<math>\Delta S = k_B \ln 2N - k_B \ln2 = k_B \ln N</math> (''eq. 7'') 
For the system described above (D = 3, N = 1000), the change in entropy associated with the spin 'flip' process is therefore <math>k_B ln 1000</math>, which is equal to 9.53 x 10-23 J K-1.

===Magnetisation===
{| class="wikitable floatright" width=42%
|+ ''Table 2: Ising lattices and magnetisations''
! Ising Lattice !! Magnetisation
|- style="text-align:center;"
| 1D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 2D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 3D at 0 K || 1000 or -1000
|}
''Figure 1'' shows three examples of Ising lattices, with one, two and three dimensions respectively. Using the equation for magnetisation (''eq. 8''), the magnetisations of these systems can be calculated to be those presented in ''Table 2''.
::<math>M= \sum_i s_i</math> (''eq. 8'') 
For the three-dimensional system at a temperature of 0 K, all of the spins must be aligned either 'up' or 'down', as the entropic increase associated with 'flipped' spins does not provide a driving force at absolute zero - the only factor to consider is that of the energy, which is a minimum when all of the spins are aligned. For this case, the magnetisation could be either 1000 or -1000, depending upon the direction of the spin alignment. From a consideration of the magnetisation values calculated here, it is evident that with all of the spins aligned, the (magnitude of the) magnetisation of the system is at a maximum.

==Calculating the energy and magnetisation==
===Modifying the files===
[[File:DMStest_output2.png|300px|thumb|right|'' '''Figure 2''': Output image from testing IsingLattice.py using Ilcheck.py'']]
In order to use Python to compute the energy and magnetisation for a given two-dimensional Ising lattice, the class IsingLattice was used, where energy() and magnetisation() functions were written to calculate their corresponding properties for a random numpy array of spins (generated using np.random.choice). For this aspect of the experiment, the value of J was assumed to be 1.0, working in reduced units. The Python script developed can be viewed [[Mod:DMS3053-1|here]], including annotations.

===Testing the files===
In order to test the script prepared thus far, the Ilcheck.py script was run, generating the image presented in ''Figure 2''. An examination of this output clearly indicates that the script provides accurate energies and magnetisations for the minimum and maximum energy configurations, along with for an intermediate, random arrangement. Hence, it can be concluded that at the current level, the Python script is functioning as required.

==Introduction to the Monte Carlo simulation==
===Average Energy and Magnetisation===
[[File:DMSILanim3.png|300px|thumb|right|'''''Figure 3''': Animation result from ILanim.py, showing the resting of the system in the minimum energy state'']]
[[File:DMSILanim_meta.png|300px|thumb|right|'''''Figure 4''': Animation result from ILanim.py, showing the resting of the system in a meta-stable state'']]

In order to consider the generalisability of the prepared script, it is important to analyse how the script will function for large systems, such as those with 100 spins in the spin array. As each of these spins can be either 'up' or 'down', each spin has two choices. Hence, the number of possible configurations for the system can be written as <math>2^{100}</math>, which has a value of 1.2677 x 1030.

If one considers the sampling of a single configuration to take 1 x 10-9 s, then it is clear that sampling all of these considerations would take a total of 1.2677 x 1021 s (also expressed as 4.017 x 1013 years). From this analysis, it is evident that the sampling of configurations was a significant consideration in the writing of a python script for this task.

In order to account for this, the technique of importance sampling was implemented, using the statistical Boltzmann distribution, <math>\exp(- \Delta E / k_B T)</math>. Note that as the energy computed using the energy() function is in units of kB, this factor is not included in the script.

===Modifying IsingLattice.py to Implement a Monte Carlo Cycle===
The python script developed at this stage is presented [[Mod:DMS3053-2|here]], accompanied by annotations to explain how the script functions.

===Simulating the Monte Carlo Cycles===
{| class="wikitable floatright" width=42%
|+ ''Table 3: statistics() output for animated system at global minimum configuration (Figure 3)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.70542501728
|- style="text-align:center;"
| <E2> || 3.13520970111
|- style="text-align:center;"
| <M> || -0.829971492744
|- style="text-align:center;"
| <M2> || 0.770986982766
|}
For cases where T < Tc, it would be expected that the system would have a spontaneous magnetisation. When T > Tc, the entropy will be the dominating factor, potentially resulting in the system having a magnetisation of zero.
{| class="wikitable floatright" width=42%
|+ ''Table 4: statistics() output for animated system at meta-stable configuration (Figure 4)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.35076450189
|- style="text-align:center;"
| <E2> || 1.89025801939
|- style="text-align:center;"
| <M> || -0.344104665826
|- style="text-align:center;"
| <M2> || 0.138855365306
|}
Using the presented script and the ILanim.py script, the Monte Carlo cycles can be simulated to view the results on the spin array as the process progresses. Here, the system under consideration was an 8 x 8 spin array, at a temperature of 0.5. ''Figure 3'' shows the typical outcome of the animation, with the system having reached the most stable, minimum energy arrangement. For the result presented here, the output of the statistics() function was that shown in ''Table 3''.

It was also observed that the system could locate a meta-stable state, with large regions of spin 'up' and 'down' spins. An example of such a result is presented in ''Figure 4'' (for which the output data from statistics() is presented in ''Table 4'').

==Accelerating the code==

In order to examine the efficiency of the python script developed thus far, the Iltimetrial.py script was utilised to investigate the time taken to perform 2000 Monte Carlo cycles. This script was modified to the version presented [[Mod:DMS3053-3|here]], which repeats the time measurement a defined number of times, then calculates the average time and the standard error in this average. For the Monte Carlo script prepared previously, the average time for 2000 Monte Carlo cycles was measured to be 5.475804 s and a standard error was calculated to be 0.008325 s, with 100 measurements made using the script.

Evidently, the current script is slow at conducting large numbers of Monte Carlo cycles and hence, a more efficient script was developed using the np.roll, np.multiply and np.sum functions - this is presented [[Mod:DMS3053-4|here]].

After this optimisation of the python script, the Iltimetrial.py script was re-run, giving an average time of 0.291467 s, with a standard error of 0.000156 s. Clearly, this optimised script is substantially faster than that developed previously (approximately 19 times faster).

==The effect of temperature==
===Correcting the averaging code===
As the equilibrium state of the system requires a number of Monte Carlo cycles to be reached, it is evident that the average energies and magnetisations are accounting for values for non-equilibrium arrangements - this was accounted for through a consideration of the number of cycles required to reach equilibrium. For this, the ILfinalframe.py script was used, giving the graphs shown in ''Table 5''. Here, each system was run for 150000 Monte Carlo cycles.
{| class="wikitable center" width=70%
|+ ''Table 5: Graphs of energy and magnetisation versus number of Monte Carlo cycles for different temperatures and system sizes''
! Temperature !! System Size !! Resulting Graphs !! Cycles for Equilibrium
|- style="text-align:center;"
| 0.5 || 4x4 || [[File:DMS0544.png|300px]] || 24
|- style="text-align:center;"
| 0.5 || 8x8 || [[File:DMS0588.png|300px]] || 392
|- style="text-align:center;"
| 0.5 || 16x16 || [[File:DMS051616.png|300px]] || 5549
|- style="text-align:center;"
| 1.0 || 2x2 || [[File:DMS1022.png|300px]] || (0)
|- style="text-align:center;"
| 1.0 || 4x4 || [[File:DMS1044.png|300px]] || 49
|- style="text-align:center;"
| 1.0 || 8x8 || [[File:DMS10882.png|300px]] || 590
|- style="text-align:center;"
| 1.0 || 16x16 || [[File:DMS101616.png|300px]] || ~6300
|- style="text-align:center;"
| 1.0 || 32x32 || [[File:DMS103232.png|300px]] || ~110000
|- style="text-align:center;"
| 2.0 || 4x4 || [[File:DMS2044.png|300px]] || -
|- style="text-align:center;"
| 2.0 || 8x8 || [[File:DMS2088.png|300px]] || -
|}
{| class="wikitable floatright" width=42%
|+ ''Table 6: Number of cycles to be ignored for each system size''
! System Size !! Number of cycles before averaging
|- style="text-align:center;"
| 2x2 || 0
|- style="text-align:center;"
| 4x4 || 100
|- style="text-align:center;"
| 8x8 || 1000
|- style="text-align:center;"
| 16x16 || 8000
|- style="text-align:center;"
| 32x32 || 120000
|}
Analysis of these graphs indicates that at higher temperatures, such as 2.0 (also observed at 1.5), large fluctuations in the energy and magnetisation are observed - these fluctuations are the reason that the average values of the properties must be taken. As the temperature is increased for systems of size 4x4, 8x8 and 16x16, it is clear that the number of cycles required in order to reach equilibrium increases. Hence, for the temperature range to be considered later (0.25 to 5.00), the required number of cycles was overestimated in order to ensure that all measurements were taken whilst the system was in equilibrium. The proposed numbers of cycles to be ignored for each system size are presented in ''Table 6''.

The python script developed up to this point was modified to account for these values by inclusion of a skip_region variable, which defines the number of cycles performed before energies and magnetisations contribute to the self.X values (before averaging occurs). The modified script is presented [[Mod:DMS3053-5|here]].

===Running over a range of temperatures===
[[File:DMS88dat.png|300px|thumb|right|'''''Figure 5''': Average energy and average magnetisation vs. temperature for 8x8 lattice, with error bars'']]
Using the python script modified in the previous exercise, the code can now be used to simulate the 8x8 system at a range of temperatures, using the ILtemperaturerange.py file (shown [[Mod:DMS3053-temprange|here]]). Here, the temperature range of 0.25 to 5.00 was used, with a separation of 0.25 between points, whilst the runtime was set to 10000 (neglecting the property values for the first 1000 cycles). Running this simulation produced the graphs in ''Figure 5'', where error bars computed using standard errors have also been included (these are small as a consequence of small standard errors). From the graph of average energy versus temperature, the phase transition can be observed - this occurs in the region with a gradient that is not close to zero. The data used here (temperature, average energies, average squared-energies, average magnetisations and average squared-magnetisations) was then saved as a numpy array in a new file, 8x8.dat.

==The effect of system size==
[[File:DMSLatticeSizeCombinedPlot.png|300px|thumb|right|'''''Figure 6''': Average energy and average magnetisation (per spins) vs. temperature for multiple lattice sizes'']]
The process conducted for the 8x8 lattice in the previous exercise was then repeated for lattices of sizes 2x2, 4x4, 16x16 and 32x32, with the data saved in .dat files. These files were then accessed, and the average energy and magnetisation data were plotted on one graph for all of the lattices sizes - this was achieved using the script presented [[Mod:DMS3053-6|here]]. The graphs produced in this manner are shown in ''Figure 6''.

A consideration of this graph suggests that in order to capture the long range fluctuations, a 16x16 lattice is necessary.

==Determining the heat capacity==
[[File:DMSheatcapacity2.png|300px|thumb|right|'''''Figure 7''': Heat capacity (per spin) versus temperature for different lattice sizes'']]
Using the .dat files previously produced, the heat capacity was calculated for each lattice size using the equation
::<math>C = \frac{\partial E}{\partial T} = \frac{\mathrm{Var}[E]}{k_B T^2}</math>, (''eq. 9'') 
where <math>\mathrm{Var}[E] = <E^2> - <E>^2 </math>. When implementing this, the kB term was neglected due to the energy values having units of kB. The script used for this purpose is provided [[DMS3053-7|here]]. The plot of heat capacity per spin versus temperature for all of the lattice sizes considered is presented in ''Figure 7''.

==Locating the Curie temperature==
===Comparison with C++ Data===
The data for the heat capacity generated using the python script prepared in this experiment was compared to that from longer C++ computations - graphs showing this comparison are presented in ''Table 7'' for a range of lattice sizes. The Python code used to produce these graphs is shown [[Mod:DMS3053-8|here]].

Considering these graphs, it is clear that, in general, there is a reasonable correlation between the Python and C++ data; however, some of the data, particularly that for high lattice sizes, shows that the Python computations have not always found the maximum of heat capacity. This correlation would be improved by making computations at the same range of temperatures, but with a smaller gap between the temperatures taken; however, this would substantially increase computation time.
{| class="wikitable center" width=70%
|+ ''Table 7: Graphs of heat capacity (per spin) versus temperature for C++ and Python data''
|- style="text-align:center;"
| [[File:DMS2x2c.png|300px]] || [[File:DMS4x4c.png|300px]] || [[File:DMS8x8c.png|300px]]
|- style="text-align:center;"
| 2x2 || 4x4 || 8x8
|- style="text-align:center;"
| [[File:DMS16x16c.png|300px]] || [[File:DMS32x32c.png|300px]]
|- style="text-align:center;"
| 16x16 || 32x32
|}

===Polynomial Fitting===
[[File:DMS8x8513.png|300px|thumb|right|'''''Figure 8''': Heat capacity (per spin) versus temperature for 8x8 system with two polynomial fits'']]
In order to make use of the C++ data in finding the Curie temperature for the Ising Lattices under consideration, polynomials were fit to the data - the script written for this purpose is shown [[Mod:DMS3053-9|here]]. For this fitting, it was found that a polynomial order of 5 was required to provide a good fit for the 2x2 data - this increased significantly as the lattice size increased. An example fit is shown for the 8x8 system in ''Figure 8'', where the polynomial fit is shown for orders 5 and 13. A consideration of this graph reveals that whilst a polynomial of order 5 may be appropriate for a 2x2 system, it is inadequate for the larger system of 8x8. Whilst an order of 13 substantially improves the polynomial fit, one must, in general, take care with 'overfitting' data.
[[File:Py8x8(13fit).png|300px|thumb|left|'''''Figure 9''': Heat capacity (per spin) versus temperature for Python data for 8x8 system with a 13th order polynomial fit'']]
For comparison, a 13th order polynomial was fitted to the 8x8 Python data previously computed - this is shown in ''Figure 9''. Here, it is evident that for this data, a higher order polynomial is required to obtain a fit comparable to that for the C++ data above.

===Fitting in a Particular Temperature Range===
[[File:DMS8x8peak(3).png|300px|thumb|right|'''''Figure 10''': Heat capacity (per spin) versus temperature for 8x8 system with peak polynomial fit'']]
As was observed in the previous exercise, large polynomial orders are required to fit the C++ data well across the whole temperature range. The python script was modified to that presented [[Mod:DMS3053-10|here]] (this script also contains the python code to compute the maximum heat capacity and temperature at which this occurs for the following exercise), which fits a polynomial only in the region of the maximum heat capacity for the system. An example of such fit is shown in ''Figure 10'' for the 8x8 system. Here, it should be noted that for all of the system sizes studied, a polynomial order of 3 was used - this is a clear improvement compared to the 13th order polynomials used previously.

===Finding the Peak in Heat Capacity===
{| class="wikitable floatright" width=42%
|+ ''Table 8: Lattice sizes and their corresponding Curie temperatures''
! System Size !! Number of cycles before averaging
|- style="text-align:center;"
| 2x2 || 2.53503504
|- style="text-align:center;"
| 4x4 || 2.43843844
|- style="text-align:center;"
| 8x8 || 2.33433433
|- style="text-align:center;"
| 16x16 || 2.30455455
|- style="text-align:center;"
| 32x32 || 2.27752753
|}
[[File:DMSCurieTemperature.png|300px|thumb|left|'''''Figure 11''': Curie temperature vs. 1/(lattice length), with extrapolated linear fit'']]
In order to find the Curie temperature for an infinite Ising Lattice, the Curie temperature for each system size considered was first found (using the script shown in the previous exercise). These temperatures were then saved to a .dat file (whose contents are also showed in ''Table 8'', along with their corresponding lattice sizes. Finally, using the script presented [[Mod:DMS3053-11|here]], a graph of Curie temperature versus the inverse of the lattice length was plotted, according to the equation
::<math>T_{C, L} = \frac{A}{L} + T_{C,\infty}</math>, ''(eq. 10)
where <math>T_{C, L}</math> is the Curie temperature for a lattice with length L and <math>T_{C,\infty}</math> is the Curie temperature for an infinite Ising lattice. Hence, it is clear that the desired Curie temperature must be the y-intercept of the graph shown in ''Figure 11'' (hence the use of extrapolation in the python script). Taking this extrapolated value gives a Curie temperature of 2.271. This value can be compared to the theoretical exact value of 2.27,<ref>D. K. Khudier, N. I. Fawaz, ''Int. Lett. Them. Whys. Astron.'', 2013, '''10''', 201-212. Available from: http://www.ilcpa.pl/wp-content/uploads/2012/11/ILCPA-102-2013-201-2121.pdf</ref> which indicates a good agreement between the value calculated in this investigation and the theoretical exact value. This is surprising given that it would be expected that the polynomial fitting of the data to locate the maximum would contribute a considerable degree of error to the final value.

==References==
<references/>
</div>

Rep:Mod:DMS3053

2015-02-25T16:10:25Z

Ds3012:

'''CMP Programming Experiment - Daniel Spencer, 00736964'''
<div style="text-align: justify">
==Introduction to the Ising Model==
===Minimum energy of the Ising Model===
Using the equation 
::<math>E= - \frac{1}{2} J \sum_i^N \sum_{j\ \in\ \mathrm{neighbours}\left(i\right)} s_i s_j</math> (''eq. 1'') 
the minimum energy of an Ising lattice of <math>D</math> dimensions, with <math>N</math> spins (where each
spin had a value of +1 or -1) and an interaction strength of <math>J</math> was considered. This was achieved first through a consideration of a one-dimensional system with five parallel spins (where the spins are parallel as this corresponds to the minimum energy arrangement of the system). Hence, the energy of this linear system was found to be 
::<math>E_\text{min,1D} = -5J </math>. 
For a linear, one-dimensional system, the number of neigbouring spins is two. The number of neighbours can be determined for two- and three- dimensional systems through a geometric consideration of their structure - the values are presented in ''Table 1''.
{| class="wikitable floatright" width=42%
|+ ''Table 1: Dimension numbers and number of neighbours''
! Number of Dimensions, D !! Number of Neighbours
|- style="text-align:center;"
| 1 || 2
|- style="text-align:center;"
| 2 || 4
|- style="text-align:center;"
| 3 || 6
|- style="text-align:center;"
| D || 2D
|}
These data indicate that the number of neighbours is twice the number of dimensions, for the dimensions considered here. This can be extrapolated to give the general number of neighbours as <math>2D</math>.

For the minimum energy of the system, where all spins are parallel, every combination <math>s_i s_j</math> has a value of 1. Notably, for each value of <math>i</math>, there will be <math>2D</math> neighbour interactions. Ergo, using ''eq. 1'', the general minimum energy can be found to be
::<math>E_\text{min,D} = -DNJ </math> (''eq. 2''). 
To check this equation, it can be applied to the two-dimensional Ising lattice with 25 spins - this gives a value of
::<math>E_\text{min,2D} = -50J </math>, 
which matches with the value predicted from first-principles.

For this D-dimensional system, the multiplicity (i.e. the number of ways of achieving the specified configuration of spins) must be equal to two, as either all of the spins could be aligned 'up' (+1) or 'down' (-1). Using this multiplicity, the entropy of the system can be calculated using the equation
::<math>S = k_B \ln\Omega</math>, (''eq. 3'') 
where Ω is the number of microstates (equal to the multiplicity in this case), which gives a value of <math>k_B \ln2 </math>, or 9.57 x 10-24 J K-1.

===Spin 'flipping'===

Using the Ising model, it is also possible to consider a change in state, reflected by a 'flipping' of the direction of one of the lattice spins. For this case, the energy (using ''eq. 1'') can be determined to be
::<math>E'= - \frac{1}{2} J (2DN - 4D - 4D) = 4DJ - DNJ</math>, (''eq. 4'') 
where the additional <math>4D</math> terms arise from the loss of 4D stabilising spin-aligned interactions and the gain of 4D destabilising spins anti-aligned interactions following spin 'flipping'. Using ''eq. 2'' and ''eq. 4'', the change in energy derived from this spin 'flip' can be calculated to be
::<math>\Delta E= 4DJ - DNJ + DNJ = 4DJ</math>. (''eq. 5'') 
For a system with three dimensions (D = 3) and 1000 spins (N = 1000), the system, using ''eq. 5'', was determined to increase in energy by <math>12 J</math>. Notably, this change in energy is independent of the number of spins in the system - it depends only on the number of dimensions and J.
[[File:ThirdYearCMPExpt-IsingSketch.png|300px|thumb|right|'' '''Figure 1''': Representation of Ising lattices in one (N=5), two (N=25), and three (N=125) dimensions. +1 and -1 spins are denoted by the red and blue cells respectively. Diagram taken from the lab script.'']]
A significant consideration with regards to the spin 'flipping' described here is the accompanying increase in entropy - the driving force for this process. For the scenario describing the change in direction of a single spin, the multiplicity of the system will be <math>2N</math> - this is a consequence of the system prior to 'flipping' having a multiplicity of two (all spins aligned 'up' or 'down'), where now, any one of the spins could flip, adding the factor of N to the multiplicity. Hence, the new entropy can be defined to be
::<math>S' = k_B \ln 2N</math>, (''eq. 6'') 
which allows the change in entropy to be calculated according to ''eq. 7''.
::<math>\Delta S = k_B \ln 2N - k_B \ln2 = k_B \ln N</math> (''eq. 7'') 
For the system described above (D = 3, N = 1000), the change in entropy associated with the spin 'flip' process is therefore <math>k_B ln 1000</math>, which is equal to 9.53 x 10-23 J K-1.

===Magnetisation===
{| class="wikitable floatright" width=42%
|+ ''Table 2: Ising lattices and magnetisations''
! Ising Lattice !! Magnetisation
|- style="text-align:center;"
| 1D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 2D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 3D at 0 K || 1000 or -1000
|}
''Figure 1'' shows three examples of Ising lattices, with one, two and three dimensions respectively. Using the equation for magnetisation (''eq. 8''), the magnetisations of these systems can be calculated to be those presented in ''Table 2''.
::<math>M= \sum_i s_i</math> (''eq. 8'') 
For the three-dimensional system at a temperature of 0 K, all of the spins must be aligned either 'up' or 'down', as the entropic increase associated with 'flipped' spins does not provide a driving force at absolute zero - the only factor to consider is that of the energy, which is a minimum when all of the spins are aligned. For this case, the magnetisation could be either 1000 or -1000, depending upon the direction of the spin alignment. From a consideration of the magnetisation values calculated here, it is evident that with all of the spins aligned, the (magnitude of the) magnetisation of the system is at a maximum.

==Calculating the energy and magnetisation==
===Modifying the files===
[[File:DMStest_output2.png|300px|thumb|right|'' '''Figure 2''': Output image from testing IsingLattice.py using Ilcheck.py'']]
In order to use Python to compute the energy and magnetisation for a given two-dimensional Ising lattice, the class IsingLattice was used, where energy() and magnetisation() functions were written to calculate their corresponding properties for a random numpy array of spins (generated using np.random.choice). For this aspect of the experiment, the value of J was assumed to be 1.0, working in reduced units. The Python script developed can be viewed [[Mod:DMS3053-1|here]], including annotations.

===Testing the files===
In order to test the script prepared thus far, the Ilcheck.py script was run, generating the image presented in ''Figure 2''. An examination of this output clearly indicates that the script provides accurate energies and magnetisations for the minimum and maximum energy configurations, along with for an intermediate, random arrangement. Hence, it can be concluded that at the current level, the Python script is functioning as required.

==Introduction to the Monte Carlo simulation==
===Average Energy and Magnetisation===
[[File:DMSILanim3.png|300px|thumb|right|'''''Figure 3''': Animation result from ILanim.py, showing the resting of the system in the minimum energy state'']]
[[File:DMSILanim_meta.png|300px|thumb|right|'''''Figure 4''': Animation result from ILanim.py, showing the resting of the system in a meta-stable state'']]

In order to consider the generalisability of the prepared script, it is important to analyse how the script will function for large systems, such as those with 100 spins in the spin array. As each of these spins can be either 'up' or 'down', each spin has two choices. Hence, the number of possible configurations for the system can be written as <math>2^{100}</math>, which has a value of 1.2677 x 1030.

If one considers the sampling of a single configuration to take 1 x 10-9 s, then it is clear that sampling all of these considerations would take a total of 1.2677 x 1021 s (also expressed as 4.017 x 1013 years). From this analysis, it is evident that the sampling of configurations was a significant consideration in the writing of a python script for this task.

In order to account for this, the technique of importance sampling was implemented, using the statistical Boltzmann distribution, <math>\exp(- \Delta E / k_B T)</math>. Note that as the energy computed using the energy() function is in units of kB, this factor is not included in the script.

===Modifying IsingLattice.py to Implement a Monte Carlo Cycle===
The python script developed at this stage is presented [[Mod:DMS3053-2|here]], accompanied by annotations to explain how the script functions.

===Simulating the Monte Carlo Cycles===
{| class="wikitable floatright" width=42%
|+ ''Table 3: statistics() output for animated system at global minimum configuration (Figure 3)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.70542501728
|- style="text-align:center;"
| <E2> || 3.13520970111
|- style="text-align:center;"
| <M> || -0.829971492744
|- style="text-align:center;"
| <M2> || 0.770986982766
|}
For cases where T < Tc, it would be expected that the system would have a spontaneous magnetisation. When T > Tc, the entropy will be the dominating factor, potentially resulting in the system having a magnetisation of zero.
{| class="wikitable floatright" width=42%
|+ ''Table 4: statistics() output for animated system at meta-stable configuration (Figure 4)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.35076450189
|- style="text-align:center;"
| <E2> || 1.89025801939
|- style="text-align:center;"
| <M> || -0.344104665826
|- style="text-align:center;"
| <M2> || 0.138855365306
|}
Using the presented script and the ILanim.py script, the Monte Carlo cycles can be simulated to view the results on the spin array as the process progresses. Here, the system under consideration was an 8 x 8 spin array, at a temperature of 0.5. ''Figure 3'' shows the typical outcome of the animation, with the system having reached the most stable, minimum energy arrangement. For the result presented here, the output of the statistics() function was that shown in ''Table 3''.

It was also observed that the system could locate a meta-stable state, with large regions of spin 'up' and 'down' spins. An example of such a result is presented in ''Figure 4'' (for which the output data from statistics() is presented in ''Table 4'').

==Accelerating the code==

In order to examine the efficiency of the python script developed thus far, the Iltimetrial.py script was utilised to investigate the time taken to perform 2000 Monte Carlo cycles. This script was modified to the version presented [[Mod:DMS3053-3|here]], which repeats the time measurement a defined number of times, then calculates the average time and the standard error in this average. For the Monte Carlo script prepared previously, the average time for 2000 Monte Carlo cycles was measured to be 5.475804 s and a standard error was calculated to be 0.008325 s, with 100 measurements made using the script.

Evidently, the current script is slow at conducting large numbers of Monte Carlo cycles and hence, a more efficient script was developed using the np.roll, np.multiply and np.sum functions - this is presented [[Mod:DMS3053-4|here]].

After this optimisation of the python script, the Iltimetrial.py script was re-run, giving an average time of 0.291467 s, with a standard error of 0.000156 s. Clearly, this optimised script is substantially faster than that developed previously (approximately 19 times faster).

==The effect of temperature==
===Correcting the averaging code===
As the equilibrium state of the system requires a number of Monte Carlo cycles to be reached, it is evident that the average energies and magnetisations are accounting for values for non-equilibrium arrangements - this was accounted for through a consideration of the number of cycles required to reach equilibrium. For this, the ILfinalframe.py script was used, giving the graphs shown in ''Table 5''. Here, each system was run for 150000 Monte Carlo cycles.
{| class="wikitable center" width=70%
|+ ''Table 5: Graphs of energy and magnetisation versus number of Monte Carlo cycles for different temperatures and system sizes''
! Temperature !! System Size !! Resulting Graphs !! Cycles for Equilibrium
|- style="text-align:center;"
| 0.5 || 4x4 || [[File:DMS0544.png|300px]] || 24
|- style="text-align:center;"
| 0.5 || 8x8 || [[File:DMS0588.png|300px]] || 392
|- style="text-align:center;"
| 0.5 || 16x16 || [[File:DMS051616.png|300px]] || 5549
|- style="text-align:center;"
| 1.0 || 2x2 || [[File:DMS1022.png|300px]] || (0)
|- style="text-align:center;"
| 1.0 || 4x4 || [[File:DMS1044.png|300px]] || 49
|- style="text-align:center;"
| 1.0 || 8x8 || [[File:DMS10882.png|300px]] || 590
|- style="text-align:center;"
| 1.0 || 16x16 || [[File:DMS101616.png|300px]] || ~6300
|- style="text-align:center;"
| 1.0 || 32x32 || [[File:DMS103232.png|300px]] || ~110000
|- style="text-align:center;"
| 2.0 || 4x4 || [[File:DMS2044.png|300px]] || -
|- style="text-align:center;"
| 2.0 || 8x8 || [[File:DMS2088.png|300px]] || -
|}
{| class="wikitable floatright" width=42%
|+ ''Table 6: Number of cycles to be ignored for each system size''
! System Size !! Number of cycles before averaging
|- style="text-align:center;"
| 2x2 || 0
|- style="text-align:center;"
| 4x4 || 100
|- style="text-align:center;"
| 8x8 || 1000
|- style="text-align:center;"
| 16x16 || 8000
|- style="text-align:center;"
| 32x32 || 120000
|}
Analysis of these graphs indicates that at higher temperatures, such as 2.0 (also observed at 1.5), large fluctuations in the energy and magnetisation are observed - these fluctuations are the reason that the average values of the properties must be taken. As the temperature is increased for systems of size 4x4, 8x8 and 16x16, it is clear that the number of cycles required in order to reach equilibrium increases. Hence, for the temperature range to be considered later (0.25 to 5.00), the required number of cycles was overestimated in order to ensure that all measurements were taken whilst the system was in equilibrium. The proposed numbers of cycles to be ignored for each system size are presented in ''Table 6''.

The python script developed up to this point was modified to account for these values by inclusion of a skip_region variable, which defines the number of cycles performed before energies and magnetisations contribute to the self.X values (before averaging occurs). The modified script is presented [[Mod:DMS3053-5|here]].

===Running over a range of temperatures===
[[File:DMS88dat.png|300px|thumb|right|'''''Figure 5''': Average energy and average magnetisation vs. temperature for 8x8 lattice, with error bars'']]
Using the python script modified in the previous exercise, the code can now be used to simulate the 8x8 system at a range of temperatures, using the ILtemperaturerange.py file (shown [[Mod:DMS3053-temprange|here]]). Here, the temperature range of 0.25 to 5.00 was used, with a separation of 0.25 between points, whilst the runtime was set to 10000 (neglecting the property values for the first 1000 cycles). Running this simulation produced the graphs in ''Figure 5'', where error bars computed using standard errors have also been included (these are small as a consequence of small standard errors). From the graph of average energy versus temperature, the phase transition can be observed - this occurs in the region with a gradient that is not close to zero. The data used here (temperature, average energies, average squared-energies, average magnetisations and average squared-magnetisations) was then saved as a numpy array in a new file, 8x8.dat.

==The effect of system size==
[[File:DMSLatticeSizeCombinedPlot.png|300px|thumb|right|'''''Figure 6''': Average energy and average magnetisation (per spins) vs. temperature for multiple lattice sizes'']]
The process conducted for the 8x8 lattice in the previous exercise was then repeated for lattices of sizes 2x2, 4x4, 16x16 and 32x32, with the data saved in .dat files. These files were then accessed, and the average energy and magnetisation data were plotted on one graph for all of the lattices sizes - this was achieved using the script presented [[Mod:DMS3053-6|here]]. The graphs produced in this manner are shown in ''Figure 6''.

A consideration of this graph suggests that in order to capture the long range fluctuations, a 16x16 lattice is necessary.

==Determining the heat capacity==
[[File:DMSheatcapacity2.png|300px|thumb|right|'''''Figure 7''': Heat capacity (per spin) versus temperature for different lattice sizes'']]
Using the .dat files previously produced, the heat capacity was calculated for each lattice size using the equation
::<math>C = \frac{\partial E}{\partial T} = \frac{\mathrm{Var}[E]}{k_B T^2}</math>, (''eq. 9'') 
where <math>\mathrm{Var}[E] = <E^2> - <E>^2 </math>. When implementing this, the kB term was neglected due to the energy values having units of kB. The script used for this purpose is provided [[DMS3053-7|here]]. The plot of heat capacity per spin versus temperature for all of the lattice sizes considered is presented in ''Figure 7''.

==Locating the Curie temperature==
===Comparison with C++ Data===
The data for the heat capacity generated using the python script prepared in this experiment was compared to that from longer C++ computations - graphs showing this comparison are presented in ''Table 7'' for a range of lattice sizes. The Python code used to produce these graphs is shown [[Mod:DMS3053-8|here]].

Considering these graphs, it is clear that, in general, there is a reasonable correlation between the Python and C++ data; however, some of the data, particularly that for high lattice sizes, shows that the Python computations have not always found the maximum of heat capacity. This correlation would be improved by making computations at the same range of temperatures, but with a smaller gap between the temperatures taken; however, this would substantially increase computation time.
{| class="wikitable center" width=70%
|+ ''Table 7: Graphs of heat capacity (per spin) versus temperature for C++ and Python data''
|- style="text-align:center;"
| [[File:DMS2x2c.png|300px]] || [[File:DMS4x4c.png|300px]] || [[File:DMS8x8c.png|300px]]
|- style="text-align:center;"
| 2x2 || 4x4 || 8x8
|- style="text-align:center;"
| [[File:DMS16x16c.png|300px]] || [[File:DMS32x32c.png|300px]]
|- style="text-align:center;"
| 16x16 || 32x32
|}

===Polynomial Fitting===
[[File:DMS8x8513.png|300px|thumb|right|'''''Figure 8''': Heat capacity (per spin) versus temperature for 8x8 system with two polynomial fits'']]
In order to make use of the C++ data in finding the Curie temperature for the Ising Lattices under consideration, polynomials were fit to the data - the script written for this purpose is shown [[Mod:DMS3053-9|here]]. For this fitting, it was found that a polynomial order of 5 was required to provide a good fit for the 2x2 data - this increased significantly as the lattice size increased. An example fit is shown for the 8x8 system in ''Figure 8'', where the polynomial fit is shown for orders 5 and 13. A consideration of this graph reveals that whilst a polynomial of order 5 may be appropriate for a 2x2 system, it is inadequate for the larger system of 8x8. Whilst an order of 13 substantially improves the polynomial fit, one must, in general, take care with 'overfitting' data.
[[File:Py8x8(13fit).png|300px|thumb|left|'''''Figure 9''': Heat capacity (per spin) versus temperature for Python data for 8x8 system with a 13th order polynomial fit'']]
For comparison, a 13th order polynomial was fitted to the 8x8 Python data previously computed - this is shown in ''Figure 9''. Here, it is evident that for this data, a higher order polynomial is required to obtain a fit comparable to that for the C++ data above.

===Fitting in a Particular Temperature Range===
[[File:DMS8x8peak(3).png|300px|thumb|right|'''''Figure 10''': Heat capacity (per spin) versus temperature for 8x8 system with peak polynomial fit'']]
As was observed in the previous exercise, large polynomial orders are required to fit the C++ data well across the whole temperature range. The python script was modified to that presented [[Mod:DMS3053-10|here]] (this script also contains the python code to compute the maximum heat capacity and temperature at which this occurs for the following exercise), which fits a polynomial only in the region of the maximum heat capacity for the system. An example of such fit is shown in ''Figure 10'' for the 8x8 system. Here, it should be noted that for all of the system sizes studied, a polynomial order of 3 was used - this is a clear improvement compared to the 13th order polynomials used previously.

===Finding the Peak in Heat Capacity===
{| class="wikitable floatright" width=42%
|+ ''Table 8: Lattice sizes and their corresponding Curie temperatures''
! System Size !! Number of cycles before averaging
|- style="text-align:center;"
| 2x2 || 2.53503504
|- style="text-align:center;"
| 4x4 || 2.43843844
|- style="text-align:center;"
| 8x8 || 2.33433433
|- style="text-align:center;"
| 16x16 || 2.30455455
|- style="text-align:center;"
| 32x32 || 2.27752753
|}
[[File:DMSCurieTemperature.png|300px|thumb|left|'''''Figure 11''': Curie temperature vs. 1/(lattice length), with extrapolated linear fit'']]
In order to find the Curie temperature for an infinite Ising Lattice, the Curie temperature for each system size considered was first found (using the script shown in the previous exercise). These temperatures were then saved to a .dat file (whose contents are also showed in ''Table 8'', along with their corresponding lattice sizes. Finally, using the script presented [[Mod:DMS3053-11|here]], a graph of Curie temperature versus the inverse of the lattice length was plotted, according to the equation
::<math>T_{C, L} = \frac{A}{L} + T_{C,\infty}</math>, ''(eq. 10)
where <math>T_{C, L}</math> is the Curie temperature for a lattice with length L and <math>T_{C,\infty}</math> is the Curie temperature for an infinite Ising lattice. Hence, it is clear that the desired Curie temperature must be the y-intercept of the graph shown in ''Figure 11'' (hence the use of extrapolation in the python script). Taking this extrapolated value gives a Curie temperature of 2.271. This value can be compared to the theoretical exact value of 2.27 <ref>D. K. Khudier, N. I. Fawaz, ''Int. Lett. Them. Whys. Astron.'', 2013, '''10''', 201-212. Available from: http://www.ilcpa.pl/wp-content/uploads/2012/11/ILCPA-102-2013-201-2121.pdf</ref>

==References==
<references/>
</div>

Rep:Mod:DMS3053

2015-02-25T16:09:40Z

Ds3012: /* Finding the Peak in Heat Capacity */

'''CMP Programming Experiment - Daniel Spencer, 00736964'''
<div style="text-align: justify">
==Introduction to the Ising Model==
===Minimum energy of the Ising Model===
Using the equation 
::<math>E= - \frac{1}{2} J \sum_i^N \sum_{j\ \in\ \mathrm{neighbours}\left(i\right)} s_i s_j</math> (''eq. 1'') 
the minimum energy of an Ising lattice of <math>D</math> dimensions, with <math>N</math> spins (where each
spin had a value of +1 or -1) and an interaction strength of <math>J</math> was considered. This was achieved first through a consideration of a one-dimensional system with five parallel spins (where the spins are parallel as this corresponds to the minimum energy arrangement of the system). Hence, the energy of this linear system was found to be 
::<math>E_\text{min,1D} = -5J </math>. 
For a linear, one-dimensional system, the number of neigbouring spins is two. The number of neighbours can be determined for two- and three- dimensional systems through a geometric consideration of their structure - the values are presented in ''Table 1''.
{| class="wikitable floatright" width=42%
|+ ''Table 1: Dimension numbers and number of neighbours''
! Number of Dimensions, D !! Number of Neighbours
|- style="text-align:center;"
| 1 || 2
|- style="text-align:center;"
| 2 || 4
|- style="text-align:center;"
| 3 || 6
|- style="text-align:center;"
| D || 2D
|}
These data indicate that the number of neighbours is twice the number of dimensions, for the dimensions considered here. This can be extrapolated to give the general number of neighbours as <math>2D</math>.

For the minimum energy of the system, where all spins are parallel, every combination <math>s_i s_j</math> has a value of 1. Notably, for each value of <math>i</math>, there will be <math>2D</math> neighbour interactions. Ergo, using ''eq. 1'', the general minimum energy can be found to be
::<math>E_\text{min,D} = -DNJ </math> (''eq. 2''). 
To check this equation, it can be applied to the two-dimensional Ising lattice with 25 spins - this gives a value of
::<math>E_\text{min,2D} = -50J </math>, 
which matches with the value predicted from first-principles.

For this D-dimensional system, the multiplicity (i.e. the number of ways of achieving the specified configuration of spins) must be equal to two, as either all of the spins could be aligned 'up' (+1) or 'down' (-1). Using this multiplicity, the entropy of the system can be calculated using the equation
::<math>S = k_B \ln\Omega</math>, (''eq. 3'') 
where Ω is the number of microstates (equal to the multiplicity in this case), which gives a value of <math>k_B \ln2 </math>, or 9.57 x 10-24 J K-1.

===Spin 'flipping'===

Using the Ising model, it is also possible to consider a change in state, reflected by a 'flipping' of the direction of one of the lattice spins. For this case, the energy (using ''eq. 1'') can be determined to be
::<math>E'= - \frac{1}{2} J (2DN - 4D - 4D) = 4DJ - DNJ</math>, (''eq. 4'') 
where the additional <math>4D</math> terms arise from the loss of 4D stabilising spin-aligned interactions and the gain of 4D destabilising spins anti-aligned interactions following spin 'flipping'. Using ''eq. 2'' and ''eq. 4'', the change in energy derived from this spin 'flip' can be calculated to be
::<math>\Delta E= 4DJ - DNJ + DNJ = 4DJ</math>. (''eq. 5'') 
For a system with three dimensions (D = 3) and 1000 spins (N = 1000), the system, using ''eq. 5'', was determined to increase in energy by <math>12 J</math>. Notably, this change in energy is independent of the number of spins in the system - it depends only on the number of dimensions and J.
[[File:ThirdYearCMPExpt-IsingSketch.png|300px|thumb|right|'' '''Figure 1''': Representation of Ising lattices in one (N=5), two (N=25), and three (N=125) dimensions. +1 and -1 spins are denoted by the red and blue cells respectively. Diagram taken from the lab script.'']]
A significant consideration with regards to the spin 'flipping' described here is the accompanying increase in entropy - the driving force for this process. For the scenario describing the change in direction of a single spin, the multiplicity of the system will be <math>2N</math> - this is a consequence of the system prior to 'flipping' having a multiplicity of two (all spins aligned 'up' or 'down'), where now, any one of the spins could flip, adding the factor of N to the multiplicity. Hence, the new entropy can be defined to be
::<math>S' = k_B \ln 2N</math>, (''eq. 6'') 
which allows the change in entropy to be calculated according to ''eq. 7''.
::<math>\Delta S = k_B \ln 2N - k_B \ln2 = k_B \ln N</math> (''eq. 7'') 
For the system described above (D = 3, N = 1000), the change in entropy associated with the spin 'flip' process is therefore <math>k_B ln 1000</math>, which is equal to 9.53 x 10-23 J K-1.

===Magnetisation===
{| class="wikitable floatright" width=42%
|+ ''Table 2: Ising lattices and magnetisations''
! Ising Lattice !! Magnetisation
|- style="text-align:center;"
| 1D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 2D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 3D at 0 K || 1000 or -1000
|}
''Figure 1'' shows three examples of Ising lattices, with one, two and three dimensions respectively. Using the equation for magnetisation (''eq. 8''), the magnetisations of these systems can be calculated to be those presented in ''Table 2''.
::<math>M= \sum_i s_i</math> (''eq. 8'') 
For the three-dimensional system at a temperature of 0 K, all of the spins must be aligned either 'up' or 'down', as the entropic increase associated with 'flipped' spins does not provide a driving force at absolute zero - the only factor to consider is that of the energy, which is a minimum when all of the spins are aligned. For this case, the magnetisation could be either 1000 or -1000, depending upon the direction of the spin alignment. From a consideration of the magnetisation values calculated here, it is evident that with all of the spins aligned, the (magnitude of the) magnetisation of the system is at a maximum.

==Calculating the energy and magnetisation==
===Modifying the files===
[[File:DMStest_output2.png|300px|thumb|right|'' '''Figure 2''': Output image from testing IsingLattice.py using Ilcheck.py'']]
In order to use Python to compute the energy and magnetisation for a given two-dimensional Ising lattice, the class IsingLattice was used, where energy() and magnetisation() functions were written to calculate their corresponding properties for a random numpy array of spins (generated using np.random.choice). For this aspect of the experiment, the value of J was assumed to be 1.0, working in reduced units. The Python script developed can be viewed [[Mod:DMS3053-1|here]], including annotations.

===Testing the files===
In order to test the script prepared thus far, the Ilcheck.py script was run, generating the image presented in ''Figure 2''. An examination of this output clearly indicates that the script provides accurate energies and magnetisations for the minimum and maximum energy configurations, along with for an intermediate, random arrangement. Hence, it can be concluded that at the current level, the Python script is functioning as required.

==Introduction to the Monte Carlo simulation==
===Average Energy and Magnetisation===
[[File:DMSILanim3.png|300px|thumb|right|'''''Figure 3''': Animation result from ILanim.py, showing the resting of the system in the minimum energy state'']]
[[File:DMSILanim_meta.png|300px|thumb|right|'''''Figure 4''': Animation result from ILanim.py, showing the resting of the system in a meta-stable state'']]

In order to consider the generalisability of the prepared script, it is important to analyse how the script will function for large systems, such as those with 100 spins in the spin array. As each of these spins can be either 'up' or 'down', each spin has two choices. Hence, the number of possible configurations for the system can be written as <math>2^{100}</math>, which has a value of 1.2677 x 1030.

If one considers the sampling of a single configuration to take 1 x 10-9 s, then it is clear that sampling all of these considerations would take a total of 1.2677 x 1021 s (also expressed as 4.017 x 1013 years). From this analysis, it is evident that the sampling of configurations was a significant consideration in the writing of a python script for this task.

In order to account for this, the technique of importance sampling was implemented, using the statistical Boltzmann distribution, <math>\exp(- \Delta E / k_B T)</math>. Note that as the energy computed using the energy() function is in units of kB, this factor is not included in the script.

===Modifying IsingLattice.py to Implement a Monte Carlo Cycle===
The python script developed at this stage is presented [[Mod:DMS3053-2|here]], accompanied by annotations to explain how the script functions.

===Simulating the Monte Carlo Cycles===
{| class="wikitable floatright" width=42%
|+ ''Table 3: statistics() output for animated system at global minimum configuration (Figure 3)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.70542501728
|- style="text-align:center;"
| <E2> || 3.13520970111
|- style="text-align:center;"
| <M> || -0.829971492744
|- style="text-align:center;"
| <M2> || 0.770986982766
|}
For cases where T < Tc, it would be expected that the system would have a spontaneous magnetisation. When T > Tc, the entropy will be the dominating factor, potentially resulting in the system having a magnetisation of zero.
{| class="wikitable floatright" width=42%
|+ ''Table 4: statistics() output for animated system at meta-stable configuration (Figure 4)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.35076450189
|- style="text-align:center;"
| <E2> || 1.89025801939
|- style="text-align:center;"
| <M> || -0.344104665826
|- style="text-align:center;"
| <M2> || 0.138855365306
|}
Using the presented script and the ILanim.py script, the Monte Carlo cycles can be simulated to view the results on the spin array as the process progresses. Here, the system under consideration was an 8 x 8 spin array, at a temperature of 0.5. ''Figure 3'' shows the typical outcome of the animation, with the system having reached the most stable, minimum energy arrangement. For the result presented here, the output of the statistics() function was that shown in ''Table 3''.

It was also observed that the system could locate a meta-stable state, with large regions of spin 'up' and 'down' spins. An example of such a result is presented in ''Figure 4'' (for which the output data from statistics() is presented in ''Table 4'').

==Accelerating the code==

In order to examine the efficiency of the python script developed thus far, the Iltimetrial.py script was utilised to investigate the time taken to perform 2000 Monte Carlo cycles. This script was modified to the version presented [[Mod:DMS3053-3|here]], which repeats the time measurement a defined number of times, then calculates the average time and the standard error in this average. For the Monte Carlo script prepared previously, the average time for 2000 Monte Carlo cycles was measured to be 5.475804 s and a standard error was calculated to be 0.008325 s, with 100 measurements made using the script.

Evidently, the current script is slow at conducting large numbers of Monte Carlo cycles and hence, a more efficient script was developed using the np.roll, np.multiply and np.sum functions - this is presented [[Mod:DMS3053-4|here]].

After this optimisation of the python script, the Iltimetrial.py script was re-run, giving an average time of 0.291467 s, with a standard error of 0.000156 s. Clearly, this optimised script is substantially faster than that developed previously (approximately 19 times faster).

==The effect of temperature==
===Correcting the averaging code===
As the equilibrium state of the system requires a number of Monte Carlo cycles to be reached, it is evident that the average energies and magnetisations are accounting for values for non-equilibrium arrangements - this was accounted for through a consideration of the number of cycles required to reach equilibrium. For this, the ILfinalframe.py script was used, giving the graphs shown in ''Table 5''. Here, each system was run for 150000 Monte Carlo cycles.
{| class="wikitable center" width=70%
|+ ''Table 5: Graphs of energy and magnetisation versus number of Monte Carlo cycles for different temperatures and system sizes''
! Temperature !! System Size !! Resulting Graphs !! Cycles for Equilibrium
|- style="text-align:center;"
| 0.5 || 4x4 || [[File:DMS0544.png|300px]] || 24
|- style="text-align:center;"
| 0.5 || 8x8 || [[File:DMS0588.png|300px]] || 392
|- style="text-align:center;"
| 0.5 || 16x16 || [[File:DMS051616.png|300px]] || 5549
|- style="text-align:center;"
| 1.0 || 2x2 || [[File:DMS1022.png|300px]] || (0)
|- style="text-align:center;"
| 1.0 || 4x4 || [[File:DMS1044.png|300px]] || 49
|- style="text-align:center;"
| 1.0 || 8x8 || [[File:DMS10882.png|300px]] || 590
|- style="text-align:center;"
| 1.0 || 16x16 || [[File:DMS101616.png|300px]] || ~6300
|- style="text-align:center;"
| 1.0 || 32x32 || [[File:DMS103232.png|300px]] || ~110000
|- style="text-align:center;"
| 2.0 || 4x4 || [[File:DMS2044.png|300px]] || -
|- style="text-align:center;"
| 2.0 || 8x8 || [[File:DMS2088.png|300px]] || -
|}
{| class="wikitable floatright" width=42%
|+ ''Table 6: Number of cycles to be ignored for each system size''
! System Size !! Number of cycles before averaging
|- style="text-align:center;"
| 2x2 || 0
|- style="text-align:center;"
| 4x4 || 100
|- style="text-align:center;"
| 8x8 || 1000
|- style="text-align:center;"
| 16x16 || 8000
|- style="text-align:center;"
| 32x32 || 120000
|}
Analysis of these graphs indicates that at higher temperatures, such as 2.0 (also observed at 1.5), large fluctuations in the energy and magnetisation are observed - these fluctuations are the reason that the average values of the properties must be taken. As the temperature is increased for systems of size 4x4, 8x8 and 16x16, it is clear that the number of cycles required in order to reach equilibrium increases. Hence, for the temperature range to be considered later (0.25 to 5.00), the required number of cycles was overestimated in order to ensure that all measurements were taken whilst the system was in equilibrium. The proposed numbers of cycles to be ignored for each system size are presented in ''Table 6''.

The python script developed up to this point was modified to account for these values by inclusion of a skip_region variable, which defines the number of cycles performed before energies and magnetisations contribute to the self.X values (before averaging occurs). The modified script is presented [[Mod:DMS3053-5|here]].

===Running over a range of temperatures===
[[File:DMS88dat.png|300px|thumb|right|'''''Figure 5''': Average energy and average magnetisation vs. temperature for 8x8 lattice, with error bars'']]
Using the python script modified in the previous exercise, the code can now be used to simulate the 8x8 system at a range of temperatures, using the ILtemperaturerange.py file (shown [[Mod:DMS3053-temprange|here]]). Here, the temperature range of 0.25 to 5.00 was used, with a separation of 0.25 between points, whilst the runtime was set to 10000 (neglecting the property values for the first 1000 cycles). Running this simulation produced the graphs in ''Figure 5'', where error bars computed using standard errors have also been included (these are small as a consequence of small standard errors). From the graph of average energy versus temperature, the phase transition can be observed - this occurs in the region with a gradient that is not close to zero. The data used here (temperature, average energies, average squared-energies, average magnetisations and average squared-magnetisations) was then saved as a numpy array in a new file, 8x8.dat.

==The effect of system size==
[[File:DMSLatticeSizeCombinedPlot.png|300px|thumb|right|'''''Figure 6''': Average energy and average magnetisation (per spins) vs. temperature for multiple lattice sizes'']]
The process conducted for the 8x8 lattice in the previous exercise was then repeated for lattices of sizes 2x2, 4x4, 16x16 and 32x32, with the data saved in .dat files. These files were then accessed, and the average energy and magnetisation data were plotted on one graph for all of the lattices sizes - this was achieved using the script presented [[Mod:DMS3053-6|here]]. The graphs produced in this manner are shown in ''Figure 6''.

A consideration of this graph suggests that in order to capture the long range fluctuations, a 16x16 lattice is necessary.

==Determining the heat capacity==
[[File:DMSheatcapacity2.png|300px|thumb|right|'''''Figure 7''': Heat capacity (per spin) versus temperature for different lattice sizes'']]
Using the .dat files previously produced, the heat capacity was calculated for each lattice size using the equation
::<math>C = \frac{\partial E}{\partial T} = \frac{\mathrm{Var}[E]}{k_B T^2}</math>, (''eq. 9'') 
where <math>\mathrm{Var}[E] = <E^2> - <E>^2 </math>. When implementing this, the kB term was neglected due to the energy values having units of kB. The script used for this purpose is provided [[DMS3053-7|here]]. The plot of heat capacity per spin versus temperature for all of the lattice sizes considered is presented in ''Figure 7''.

==Locating the Curie temperature==
===Comparison with C++ Data===
The data for the heat capacity generated using the python script prepared in this experiment was compared to that from longer C++ computations - graphs showing this comparison are presented in ''Table 7'' for a range of lattice sizes. The Python code used to produce these graphs is shown [[Mod:DMS3053-8|here]].

Considering these graphs, it is clear that, in general, there is a reasonable correlation between the Python and C++ data; however, some of the data, particularly that for high lattice sizes, shows that the Python computations have not always found the maximum of heat capacity. This correlation would be improved by making computations at the same range of temperatures, but with a smaller gap between the temperatures taken; however, this would substantially increase computation time.
{| class="wikitable center" width=70%
|+ ''Table 7: Graphs of heat capacity (per spin) versus temperature for C++ and Python data''
|- style="text-align:center;"
| [[File:DMS2x2c.png|300px]] || [[File:DMS4x4c.png|300px]] || [[File:DMS8x8c.png|300px]]
|- style="text-align:center;"
| 2x2 || 4x4 || 8x8
|- style="text-align:center;"
| [[File:DMS16x16c.png|300px]] || [[File:DMS32x32c.png|300px]]
|- style="text-align:center;"
| 16x16 || 32x32
|}

===Polynomial Fitting===
[[File:DMS8x8513.png|300px|thumb|right|'''''Figure 8''': Heat capacity (per spin) versus temperature for 8x8 system with two polynomial fits'']]
In order to make use of the C++ data in finding the Curie temperature for the Ising Lattices under consideration, polynomials were fit to the data - the script written for this purpose is shown [[Mod:DMS3053-9|here]]. For this fitting, it was found that a polynomial order of 5 was required to provide a good fit for the 2x2 data - this increased significantly as the lattice size increased. An example fit is shown for the 8x8 system in ''Figure 8'', where the polynomial fit is shown for orders 5 and 13. A consideration of this graph reveals that whilst a polynomial of order 5 may be appropriate for a 2x2 system, it is inadequate for the larger system of 8x8. Whilst an order of 13 substantially improves the polynomial fit, one must, in general, take care with 'overfitting' data.
[[File:Py8x8(13fit).png|300px|thumb|left|'''''Figure 9''': Heat capacity (per spin) versus temperature for Python data for 8x8 system with a 13th order polynomial fit'']]
For comparison, a 13th order polynomial was fitted to the 8x8 Python data previously computed - this is shown in ''Figure 9''. Here, it is evident that for this data, a higher order polynomial is required to obtain a fit comparable to that for the C++ data above.

===Fitting in a Particular Temperature Range===
[[File:DMS8x8peak(3).png|300px|thumb|right|'''''Figure 10''': Heat capacity (per spin) versus temperature for 8x8 system with peak polynomial fit'']]
As was observed in the previous exercise, large polynomial orders are required to fit the C++ data well across the whole temperature range. The python script was modified to that presented [[Mod:DMS3053-10|here]] (this script also contains the python code to compute the maximum heat capacity and temperature at which this occurs for the following exercise), which fits a polynomial only in the region of the maximum heat capacity for the system. An example of such fit is shown in ''Figure 10'' for the 8x8 system. Here, it should be noted that for all of the system sizes studied, a polynomial order of 3 was used - this is a clear improvement compared to the 13th order polynomials used previously.

===Finding the Peak in Heat Capacity===
{| class="wikitable floatright" width=42%
|+ ''Table 8: Lattice sizes and their corresponding Curie temperatures''
! System Size !! Number of cycles before averaging
|- style="text-align:center;"
| 2x2 || 2.53503504
|- style="text-align:center;"
| 4x4 || 2.43843844
|- style="text-align:center;"
| 8x8 || 2.33433433
|- style="text-align:center;"
| 16x16 || 2.30455455
|- style="text-align:center;"
| 32x32 || 2.27752753
|}
[[File:DMSCurieTemperature.png|300px|thumb|left|'''''Figure 11''': Curie temperature vs. 1/(lattice length), with extrapolated linear fit'']]
In order to find the Curie temperature for an infinite Ising Lattice, the Curie temperature for each system size considered was first found (using the script shown in the previous exercise). These temperatures were then saved to a .dat file (whose contents are also showed in ''Table 8'', along with their corresponding lattice sizes. Finally, using the script presented [[Mod:DMS3053-11|here]], a graph of Curie temperature versus the inverse of the lattice length was plotted, according to the equation
::<math>T_{C, L} = \frac{A}{L} + T_{C,\infty}</math>, ''(eq. 10)
where <math>T_{C, L}</math> is the Curie temperature for a lattice with length L and <math>T_{C,\infty}</math> is the Curie temperature for an infinite Ising lattice. Hence, it is clear that the desired Curie temperature must be the y-intercept of the graph shown in ''Figure 11'' (hence the use of extrapolation in the python script). Taking this extrapolated value gives a Curie temperature of 2.271. This value can be compared to the theoretical exact value of 2.27 <ref>D. K. Khudier, N. I. Fawaz, ''Int. Lett. Them. Whys. Astron.'', 2013, '''10''', 201-212. Available from: http://www.ilcpa.pl/wp-content/uploads/2012/11/ILCPA-102-2013-201-2121.pdf</ref>

</div>

Rep:Mod:DMS3053

2015-02-25T16:03:19Z

Ds3012: /* Finding the Peak in Heat Capacity */

'''CMP Programming Experiment - Daniel Spencer, 00736964'''
<div style="text-align: justify">
==Introduction to the Ising Model==
===Minimum energy of the Ising Model===
Using the equation 
::<math>E= - \frac{1}{2} J \sum_i^N \sum_{j\ \in\ \mathrm{neighbours}\left(i\right)} s_i s_j</math> (''eq. 1'') 
the minimum energy of an Ising lattice of <math>D</math> dimensions, with <math>N</math> spins (where each
spin had a value of +1 or -1) and an interaction strength of <math>J</math> was considered. This was achieved first through a consideration of a one-dimensional system with five parallel spins (where the spins are parallel as this corresponds to the minimum energy arrangement of the system). Hence, the energy of this linear system was found to be 
::<math>E_\text{min,1D} = -5J </math>. 
For a linear, one-dimensional system, the number of neigbouring spins is two. The number of neighbours can be determined for two- and three- dimensional systems through a geometric consideration of their structure - the values are presented in ''Table 1''.
{| class="wikitable floatright" width=42%
|+ ''Table 1: Dimension numbers and number of neighbours''
! Number of Dimensions, D !! Number of Neighbours
|- style="text-align:center;"
| 1 || 2
|- style="text-align:center;"
| 2 || 4
|- style="text-align:center;"
| 3 || 6
|- style="text-align:center;"
| D || 2D
|}
These data indicate that the number of neighbours is twice the number of dimensions, for the dimensions considered here. This can be extrapolated to give the general number of neighbours as <math>2D</math>.

For the minimum energy of the system, where all spins are parallel, every combination <math>s_i s_j</math> has a value of 1. Notably, for each value of <math>i</math>, there will be <math>2D</math> neighbour interactions. Ergo, using ''eq. 1'', the general minimum energy can be found to be
::<math>E_\text{min,D} = -DNJ </math> (''eq. 2''). 
To check this equation, it can be applied to the two-dimensional Ising lattice with 25 spins - this gives a value of
::<math>E_\text{min,2D} = -50J </math>, 
which matches with the value predicted from first-principles.

For this D-dimensional system, the multiplicity (i.e. the number of ways of achieving the specified configuration of spins) must be equal to two, as either all of the spins could be aligned 'up' (+1) or 'down' (-1). Using this multiplicity, the entropy of the system can be calculated using the equation
::<math>S = k_B \ln\Omega</math>, (''eq. 3'') 
where Ω is the number of microstates (equal to the multiplicity in this case), which gives a value of <math>k_B \ln2 </math>, or 9.57 x 10-24 J K-1.

===Spin 'flipping'===

Using the Ising model, it is also possible to consider a change in state, reflected by a 'flipping' of the direction of one of the lattice spins. For this case, the energy (using ''eq. 1'') can be determined to be
::<math>E'= - \frac{1}{2} J (2DN - 4D - 4D) = 4DJ - DNJ</math>, (''eq. 4'') 
where the additional <math>4D</math> terms arise from the loss of 4D stabilising spin-aligned interactions and the gain of 4D destabilising spins anti-aligned interactions following spin 'flipping'. Using ''eq. 2'' and ''eq. 4'', the change in energy derived from this spin 'flip' can be calculated to be
::<math>\Delta E= 4DJ - DNJ + DNJ = 4DJ</math>. (''eq. 5'') 
For a system with three dimensions (D = 3) and 1000 spins (N = 1000), the system, using ''eq. 5'', was determined to increase in energy by <math>12 J</math>. Notably, this change in energy is independent of the number of spins in the system - it depends only on the number of dimensions and J.
[[File:ThirdYearCMPExpt-IsingSketch.png|300px|thumb|right|'' '''Figure 1''': Representation of Ising lattices in one (N=5), two (N=25), and three (N=125) dimensions. +1 and -1 spins are denoted by the red and blue cells respectively. Diagram taken from the lab script.'']]
A significant consideration with regards to the spin 'flipping' described here is the accompanying increase in entropy - the driving force for this process. For the scenario describing the change in direction of a single spin, the multiplicity of the system will be <math>2N</math> - this is a consequence of the system prior to 'flipping' having a multiplicity of two (all spins aligned 'up' or 'down'), where now, any one of the spins could flip, adding the factor of N to the multiplicity. Hence, the new entropy can be defined to be
::<math>S' = k_B \ln 2N</math>, (''eq. 6'') 
which allows the change in entropy to be calculated according to ''eq. 7''.
::<math>\Delta S = k_B \ln 2N - k_B \ln2 = k_B \ln N</math> (''eq. 7'') 
For the system described above (D = 3, N = 1000), the change in entropy associated with the spin 'flip' process is therefore <math>k_B ln 1000</math>, which is equal to 9.53 x 10-23 J K-1.

===Magnetisation===
{| class="wikitable floatright" width=42%
|+ ''Table 2: Ising lattices and magnetisations''
! Ising Lattice !! Magnetisation
|- style="text-align:center;"
| 1D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 2D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 3D at 0 K || 1000 or -1000
|}
''Figure 1'' shows three examples of Ising lattices, with one, two and three dimensions respectively. Using the equation for magnetisation (''eq. 8''), the magnetisations of these systems can be calculated to be those presented in ''Table 2''.
::<math>M= \sum_i s_i</math> (''eq. 8'') 
For the three-dimensional system at a temperature of 0 K, all of the spins must be aligned either 'up' or 'down', as the entropic increase associated with 'flipped' spins does not provide a driving force at absolute zero - the only factor to consider is that of the energy, which is a minimum when all of the spins are aligned. For this case, the magnetisation could be either 1000 or -1000, depending upon the direction of the spin alignment. From a consideration of the magnetisation values calculated here, it is evident that with all of the spins aligned, the (magnitude of the) magnetisation of the system is at a maximum.

==Calculating the energy and magnetisation==
===Modifying the files===
[[File:DMStest_output2.png|300px|thumb|right|'' '''Figure 2''': Output image from testing IsingLattice.py using Ilcheck.py'']]
In order to use Python to compute the energy and magnetisation for a given two-dimensional Ising lattice, the class IsingLattice was used, where energy() and magnetisation() functions were written to calculate their corresponding properties for a random numpy array of spins (generated using np.random.choice). For this aspect of the experiment, the value of J was assumed to be 1.0, working in reduced units. The Python script developed can be viewed [[Mod:DMS3053-1|here]], including annotations.

===Testing the files===
In order to test the script prepared thus far, the Ilcheck.py script was run, generating the image presented in ''Figure 2''. An examination of this output clearly indicates that the script provides accurate energies and magnetisations for the minimum and maximum energy configurations, along with for an intermediate, random arrangement. Hence, it can be concluded that at the current level, the Python script is functioning as required.

==Introduction to the Monte Carlo simulation==
===Average Energy and Magnetisation===
[[File:DMSILanim3.png|300px|thumb|right|'''''Figure 3''': Animation result from ILanim.py, showing the resting of the system in the minimum energy state'']]
[[File:DMSILanim_meta.png|300px|thumb|right|'''''Figure 4''': Animation result from ILanim.py, showing the resting of the system in a meta-stable state'']]

In order to consider the generalisability of the prepared script, it is important to analyse how the script will function for large systems, such as those with 100 spins in the spin array. As each of these spins can be either 'up' or 'down', each spin has two choices. Hence, the number of possible configurations for the system can be written as <math>2^{100}</math>, which has a value of 1.2677 x 1030.

If one considers the sampling of a single configuration to take 1 x 10-9 s, then it is clear that sampling all of these considerations would take a total of 1.2677 x 1021 s (also expressed as 4.017 x 1013 years). From this analysis, it is evident that the sampling of configurations was a significant consideration in the writing of a python script for this task.

In order to account for this, the technique of importance sampling was implemented, using the statistical Boltzmann distribution, <math>\exp(- \Delta E / k_B T)</math>. Note that as the energy computed using the energy() function is in units of kB, this factor is not included in the script.

===Modifying IsingLattice.py to Implement a Monte Carlo Cycle===
The python script developed at this stage is presented [[Mod:DMS3053-2|here]], accompanied by annotations to explain how the script functions.

===Simulating the Monte Carlo Cycles===
{| class="wikitable floatright" width=42%
|+ ''Table 3: statistics() output for animated system at global minimum configuration (Figure 3)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.70542501728
|- style="text-align:center;"
| <E2> || 3.13520970111
|- style="text-align:center;"
| <M> || -0.829971492744
|- style="text-align:center;"
| <M2> || 0.770986982766
|}
For cases where T < Tc, it would be expected that the system would have a spontaneous magnetisation. When T > Tc, the entropy will be the dominating factor, potentially resulting in the system having a magnetisation of zero.
{| class="wikitable floatright" width=42%
|+ ''Table 4: statistics() output for animated system at meta-stable configuration (Figure 4)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.35076450189
|- style="text-align:center;"
| <E2> || 1.89025801939
|- style="text-align:center;"
| <M> || -0.344104665826
|- style="text-align:center;"
| <M2> || 0.138855365306
|}
Using the presented script and the ILanim.py script, the Monte Carlo cycles can be simulated to view the results on the spin array as the process progresses. Here, the system under consideration was an 8 x 8 spin array, at a temperature of 0.5. ''Figure 3'' shows the typical outcome of the animation, with the system having reached the most stable, minimum energy arrangement. For the result presented here, the output of the statistics() function was that shown in ''Table 3''.

It was also observed that the system could locate a meta-stable state, with large regions of spin 'up' and 'down' spins. An example of such a result is presented in ''Figure 4'' (for which the output data from statistics() is presented in ''Table 4'').

==Accelerating the code==

In order to examine the efficiency of the python script developed thus far, the Iltimetrial.py script was utilised to investigate the time taken to perform 2000 Monte Carlo cycles. This script was modified to the version presented [[Mod:DMS3053-3|here]], which repeats the time measurement a defined number of times, then calculates the average time and the standard error in this average. For the Monte Carlo script prepared previously, the average time for 2000 Monte Carlo cycles was measured to be 5.475804 s and a standard error was calculated to be 0.008325 s, with 100 measurements made using the script.

Evidently, the current script is slow at conducting large numbers of Monte Carlo cycles and hence, a more efficient script was developed using the np.roll, np.multiply and np.sum functions - this is presented [[Mod:DMS3053-4|here]].

After this optimisation of the python script, the Iltimetrial.py script was re-run, giving an average time of 0.291467 s, with a standard error of 0.000156 s. Clearly, this optimised script is substantially faster than that developed previously (approximately 19 times faster).

==The effect of temperature==
===Correcting the averaging code===
As the equilibrium state of the system requires a number of Monte Carlo cycles to be reached, it is evident that the average energies and magnetisations are accounting for values for non-equilibrium arrangements - this was accounted for through a consideration of the number of cycles required to reach equilibrium. For this, the ILfinalframe.py script was used, giving the graphs shown in ''Table 5''. Here, each system was run for 150000 Monte Carlo cycles.
{| class="wikitable center" width=70%
|+ ''Table 5: Graphs of energy and magnetisation versus number of Monte Carlo cycles for different temperatures and system sizes''
! Temperature !! System Size !! Resulting Graphs !! Cycles for Equilibrium
|- style="text-align:center;"
| 0.5 || 4x4 || [[File:DMS0544.png|300px]] || 24
|- style="text-align:center;"
| 0.5 || 8x8 || [[File:DMS0588.png|300px]] || 392
|- style="text-align:center;"
| 0.5 || 16x16 || [[File:DMS051616.png|300px]] || 5549
|- style="text-align:center;"
| 1.0 || 2x2 || [[File:DMS1022.png|300px]] || (0)
|- style="text-align:center;"
| 1.0 || 4x4 || [[File:DMS1044.png|300px]] || 49
|- style="text-align:center;"
| 1.0 || 8x8 || [[File:DMS10882.png|300px]] || 590
|- style="text-align:center;"
| 1.0 || 16x16 || [[File:DMS101616.png|300px]] || ~6300
|- style="text-align:center;"
| 1.0 || 32x32 || [[File:DMS103232.png|300px]] || ~110000
|- style="text-align:center;"
| 2.0 || 4x4 || [[File:DMS2044.png|300px]] || -
|- style="text-align:center;"
| 2.0 || 8x8 || [[File:DMS2088.png|300px]] || -
|}
{| class="wikitable floatright" width=42%
|+ ''Table 6: Number of cycles to be ignored for each system size''
! System Size !! Number of cycles before averaging
|- style="text-align:center;"
| 2x2 || 0
|- style="text-align:center;"
| 4x4 || 100
|- style="text-align:center;"
| 8x8 || 1000
|- style="text-align:center;"
| 16x16 || 8000
|- style="text-align:center;"
| 32x32 || 120000
|}
Analysis of these graphs indicates that at higher temperatures, such as 2.0 (also observed at 1.5), large fluctuations in the energy and magnetisation are observed - these fluctuations are the reason that the average values of the properties must be taken. As the temperature is increased for systems of size 4x4, 8x8 and 16x16, it is clear that the number of cycles required in order to reach equilibrium increases. Hence, for the temperature range to be considered later (0.25 to 5.00), the required number of cycles was overestimated in order to ensure that all measurements were taken whilst the system was in equilibrium. The proposed numbers of cycles to be ignored for each system size are presented in ''Table 6''.

The python script developed up to this point was modified to account for these values by inclusion of a skip_region variable, which defines the number of cycles performed before energies and magnetisations contribute to the self.X values (before averaging occurs). The modified script is presented [[Mod:DMS3053-5|here]].

===Running over a range of temperatures===
[[File:DMS88dat.png|300px|thumb|right|'''''Figure 5''': Average energy and average magnetisation vs. temperature for 8x8 lattice, with error bars'']]
Using the python script modified in the previous exercise, the code can now be used to simulate the 8x8 system at a range of temperatures, using the ILtemperaturerange.py file (shown [[Mod:DMS3053-temprange|here]]). Here, the temperature range of 0.25 to 5.00 was used, with a separation of 0.25 between points, whilst the runtime was set to 10000 (neglecting the property values for the first 1000 cycles). Running this simulation produced the graphs in ''Figure 5'', where error bars computed using standard errors have also been included (these are small as a consequence of small standard errors). From the graph of average energy versus temperature, the phase transition can be observed - this occurs in the region with a gradient that is not close to zero. The data used here (temperature, average energies, average squared-energies, average magnetisations and average squared-magnetisations) was then saved as a numpy array in a new file, 8x8.dat.

==The effect of system size==
[[File:DMSLatticeSizeCombinedPlot.png|300px|thumb|right|'''''Figure 6''': Average energy and average magnetisation (per spins) vs. temperature for multiple lattice sizes'']]
The process conducted for the 8x8 lattice in the previous exercise was then repeated for lattices of sizes 2x2, 4x4, 16x16 and 32x32, with the data saved in .dat files. These files were then accessed, and the average energy and magnetisation data were plotted on one graph for all of the lattices sizes - this was achieved using the script presented [[Mod:DMS3053-6|here]]. The graphs produced in this manner are shown in ''Figure 6''.

A consideration of this graph suggests that in order to capture the long range fluctuations, a 16x16 lattice is necessary.

==Determining the heat capacity==
[[File:DMSheatcapacity2.png|300px|thumb|right|'''''Figure 7''': Heat capacity (per spin) versus temperature for different lattice sizes'']]
Using the .dat files previously produced, the heat capacity was calculated for each lattice size using the equation
::<math>C = \frac{\partial E}{\partial T} = \frac{\mathrm{Var}[E]}{k_B T^2}</math>, (''eq. 9'') 
where <math>\mathrm{Var}[E] = <E^2> - <E>^2 </math>. When implementing this, the kB term was neglected due to the energy values having units of kB. The script used for this purpose is provided [[DMS3053-7|here]]. The plot of heat capacity per spin versus temperature for all of the lattice sizes considered is presented in ''Figure 7''.

==Locating the Curie temperature==
===Comparison with C++ Data===
The data for the heat capacity generated using the python script prepared in this experiment was compared to that from longer C++ computations - graphs showing this comparison are presented in ''Table 7'' for a range of lattice sizes. The Python code used to produce these graphs is shown [[Mod:DMS3053-8|here]].

Considering these graphs, it is clear that, in general, there is a reasonable correlation between the Python and C++ data; however, some of the data, particularly that for high lattice sizes, shows that the Python computations have not always found the maximum of heat capacity. This correlation would be improved by making computations at the same range of temperatures, but with a smaller gap between the temperatures taken; however, this would substantially increase computation time.
{| class="wikitable center" width=70%
|+ ''Table 7: Graphs of heat capacity (per spin) versus temperature for C++ and Python data''
|- style="text-align:center;"
| [[File:DMS2x2c.png|300px]] || [[File:DMS4x4c.png|300px]] || [[File:DMS8x8c.png|300px]]
|- style="text-align:center;"
| 2x2 || 4x4 || 8x8
|- style="text-align:center;"
| [[File:DMS16x16c.png|300px]] || [[File:DMS32x32c.png|300px]]
|- style="text-align:center;"
| 16x16 || 32x32
|}

===Polynomial Fitting===
[[File:DMS8x8513.png|300px|thumb|right|'''''Figure 8''': Heat capacity (per spin) versus temperature for 8x8 system with two polynomial fits'']]
In order to make use of the C++ data in finding the Curie temperature for the Ising Lattices under consideration, polynomials were fit to the data - the script written for this purpose is shown [[Mod:DMS3053-9|here]]. For this fitting, it was found that a polynomial order of 5 was required to provide a good fit for the 2x2 data - this increased significantly as the lattice size increased. An example fit is shown for the 8x8 system in ''Figure 8'', where the polynomial fit is shown for orders 5 and 13. A consideration of this graph reveals that whilst a polynomial of order 5 may be appropriate for a 2x2 system, it is inadequate for the larger system of 8x8. Whilst an order of 13 substantially improves the polynomial fit, one must, in general, take care with 'overfitting' data.
[[File:Py8x8(13fit).png|300px|thumb|left|'''''Figure 9''': Heat capacity (per spin) versus temperature for Python data for 8x8 system with a 13th order polynomial fit'']]
For comparison, a 13th order polynomial was fitted to the 8x8 Python data previously computed - this is shown in ''Figure 9''. Here, it is evident that for this data, a higher order polynomial is required to obtain a fit comparable to that for the C++ data above.

===Fitting in a Particular Temperature Range===
[[File:DMS8x8peak(3).png|300px|thumb|right|'''''Figure 10''': Heat capacity (per spin) versus temperature for 8x8 system with peak polynomial fit'']]
As was observed in the previous exercise, large polynomial orders are required to fit the C++ data well across the whole temperature range. The python script was modified to that presented [[Mod:DMS3053-10|here]] (this script also contains the python code to compute the maximum heat capacity and temperature at which this occurs for the following exercise), which fits a polynomial only in the region of the maximum heat capacity for the system. An example of such fit is shown in ''Figure 10'' for the 8x8 system. Here, it should be noted that for all of the system sizes studied, a polynomial order of 3 was used - this is a clear improvement compared to the 13th order polynomials used previously.

===Finding the Peak in Heat Capacity===
{| class="wikitable floatright" width=42%
|+ ''Table 8: Lattice sizes and their corresponding Curie temperatures''
! System Size !! Number of cycles before averaging
|- style="text-align:center;"
| 2x2 || 2.53503504
|- style="text-align:center;"
| 4x4 || 2.43843844
|- style="text-align:center;"
| 8x8 || 2.33433433
|- style="text-align:center;"
| 16x16 || 2.30455455
|- style="text-align:center;"
| 32x32 || 2.27752753
|}
[[File:DMSCurieTemperature.png|300px|thumb|left|'''''Figure 11''': Curie temperature vs. 1/(lattice length), with extrapolated linear fit'']]
In order to find the Curie temperature for an infinite Ising Lattice, the Curie temperature for each system size considered was first found (using the script shown in the previous exercise). These temperatures were then saved to a .dat file (whose contents are also showed in ''Table 8'', along with their corresponding lattice sizes. Finally, using the script presented [[Mod:DMS3053-11|here]], a graph of Curie temperature versus the inverse of the lattice length was plotted, according to the equation
::<math>T_{C, L} = \frac{A}{L} + T_{C,\infty}</math>, ''(eq. 10)
where <math>T_{C, L}</math> is the Curie temperature for a lattice with length L and <math>T_{C,\infty}</math> is the Curie temperature for an infinite Ising lattice. Hence, it is clear that the desired Curie temperature must be the y-intercept of the graph shown in ''Figure 11'' (hence the use of extrapolation in the python script). Taking this extrapolated value gives a Curie temperature of 2.271. This value can be compared
</div>

File:DMSCurieTemperature.png

2015-02-25T15:57:05Z

Ds3012:

Rep:Mod:DMS3053-11

2015-02-25T15:55:29Z

Ds3012: Created page with " from matplotlib import pylab as pl import numpy as np from scipy.interpolate import InterpolatedUnivariateSpline def extract_data(file): data_array =..."

from matplotlib import pylab as pl
import numpy as np
from scipy.interpolate import InterpolatedUnivariateSpline

def extract_data(file):
data_array = np.loadtxt(file)
lattice_lengths = data_array[:,0]
inverse_lengths = 1 / lattice_lengths
curie_temps = data_array[:,1]
return inverse_lengths, curie_temps

def plotdata(file):
file_data = extract_data(file)
L_min = np.min(file_data[0])
L_max = np.max(file_data[0])
L_range = np.linspace(L_min, L_max, 1000) # Generates 1000 evenly spaced points between T_min and T_max
L_range1 = np.linspace(0, L_max, 1000) # Range for extrapolation to y-axis
fit = np.polyfit(file_data[0], file_data[1], 1)
fitted_T_values = np.polyval(fit, L_range)
extrapolation = InterpolatedUnivariateSpline(L_range, fitted_T_values, k=1) # Allows for extrapolation of the fit to find intercept accurately
T_values = extrapolation(L_range1) # Calculates the extrapolated temperatures
pl.ylabel("Temperature")
pl.xlabel("1/(Lattice Length)")
pl.ylim([2.2, 2.6])
pl.plot(file_data[0], file_data[1], L_range1, T_values)
pl.legend(['Data', 'Extrapolated linear fit'], loc='upper center', bbox_to_anchor=(0.5, 1.10),
ncol=2)
pl.show()
print(T_values[L_range1 == 0]) # Prints the y-intercept of the graph

Rep:Mod:DMS3053

2015-02-25T15:54:18Z

Ds3012: /* Finding the Peak in Heat Capacity */

'''CMP Programming Experiment - Daniel Spencer, 00736964'''
<div style="text-align: justify">
==Introduction to the Ising Model==
===Minimum energy of the Ising Model===
Using the equation 
::<math>E= - \frac{1}{2} J \sum_i^N \sum_{j\ \in\ \mathrm{neighbours}\left(i\right)} s_i s_j</math> (''eq. 1'') 
the minimum energy of an Ising lattice of <math>D</math> dimensions, with <math>N</math> spins (where each
spin had a value of +1 or -1) and an interaction strength of <math>J</math> was considered. This was achieved first through a consideration of a one-dimensional system with five parallel spins (where the spins are parallel as this corresponds to the minimum energy arrangement of the system). Hence, the energy of this linear system was found to be 
::<math>E_\text{min,1D} = -5J </math>. 
For a linear, one-dimensional system, the number of neigbouring spins is two. The number of neighbours can be determined for two- and three- dimensional systems through a geometric consideration of their structure - the values are presented in ''Table 1''.
{| class="wikitable floatright" width=42%
|+ ''Table 1: Dimension numbers and number of neighbours''
! Number of Dimensions, D !! Number of Neighbours
|- style="text-align:center;"
| 1 || 2
|- style="text-align:center;"
| 2 || 4
|- style="text-align:center;"
| 3 || 6
|- style="text-align:center;"
| D || 2D
|}
These data indicate that the number of neighbours is twice the number of dimensions, for the dimensions considered here. This can be extrapolated to give the general number of neighbours as <math>2D</math>.

For the minimum energy of the system, where all spins are parallel, every combination <math>s_i s_j</math> has a value of 1. Notably, for each value of <math>i</math>, there will be <math>2D</math> neighbour interactions. Ergo, using ''eq. 1'', the general minimum energy can be found to be
::<math>E_\text{min,D} = -DNJ </math> (''eq. 2''). 
To check this equation, it can be applied to the two-dimensional Ising lattice with 25 spins - this gives a value of
::<math>E_\text{min,2D} = -50J </math>, 
which matches with the value predicted from first-principles.

For this D-dimensional system, the multiplicity (i.e. the number of ways of achieving the specified configuration of spins) must be equal to two, as either all of the spins could be aligned 'up' (+1) or 'down' (-1). Using this multiplicity, the entropy of the system can be calculated using the equation
::<math>S = k_B \ln\Omega</math>, (''eq. 3'') 
where Ω is the number of microstates (equal to the multiplicity in this case), which gives a value of <math>k_B \ln2 </math>, or 9.57 x 10-24 J K-1.

===Spin 'flipping'===

Using the Ising model, it is also possible to consider a change in state, reflected by a 'flipping' of the direction of one of the lattice spins. For this case, the energy (using ''eq. 1'') can be determined to be
::<math>E'= - \frac{1}{2} J (2DN - 4D - 4D) = 4DJ - DNJ</math>, (''eq. 4'') 
where the additional <math>4D</math> terms arise from the loss of 4D stabilising spin-aligned interactions and the gain of 4D destabilising spins anti-aligned interactions following spin 'flipping'. Using ''eq. 2'' and ''eq. 4'', the change in energy derived from this spin 'flip' can be calculated to be
::<math>\Delta E= 4DJ - DNJ + DNJ = 4DJ</math>. (''eq. 5'') 
For a system with three dimensions (D = 3) and 1000 spins (N = 1000), the system, using ''eq. 5'', was determined to increase in energy by <math>12 J</math>. Notably, this change in energy is independent of the number of spins in the system - it depends only on the number of dimensions and J.
[[File:ThirdYearCMPExpt-IsingSketch.png|300px|thumb|right|'' '''Figure 1''': Representation of Ising lattices in one (N=5), two (N=25), and three (N=125) dimensions. +1 and -1 spins are denoted by the red and blue cells respectively. Diagram taken from the lab script.'']]
A significant consideration with regards to the spin 'flipping' described here is the accompanying increase in entropy - the driving force for this process. For the scenario describing the change in direction of a single spin, the multiplicity of the system will be <math>2N</math> - this is a consequence of the system prior to 'flipping' having a multiplicity of two (all spins aligned 'up' or 'down'), where now, any one of the spins could flip, adding the factor of N to the multiplicity. Hence, the new entropy can be defined to be
::<math>S' = k_B \ln 2N</math>, (''eq. 6'') 
which allows the change in entropy to be calculated according to ''eq. 7''.
::<math>\Delta S = k_B \ln 2N - k_B \ln2 = k_B \ln N</math> (''eq. 7'') 
For the system described above (D = 3, N = 1000), the change in entropy associated with the spin 'flip' process is therefore <math>k_B ln 1000</math>, which is equal to 9.53 x 10-23 J K-1.

===Magnetisation===
{| class="wikitable floatright" width=42%
|+ ''Table 2: Ising lattices and magnetisations''
! Ising Lattice !! Magnetisation
|- style="text-align:center;"
| 1D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 2D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 3D at 0 K || 1000 or -1000
|}
''Figure 1'' shows three examples of Ising lattices, with one, two and three dimensions respectively. Using the equation for magnetisation (''eq. 8''), the magnetisations of these systems can be calculated to be those presented in ''Table 2''.
::<math>M= \sum_i s_i</math> (''eq. 8'') 
For the three-dimensional system at a temperature of 0 K, all of the spins must be aligned either 'up' or 'down', as the entropic increase associated with 'flipped' spins does not provide a driving force at absolute zero - the only factor to consider is that of the energy, which is a minimum when all of the spins are aligned. For this case, the magnetisation could be either 1000 or -1000, depending upon the direction of the spin alignment. From a consideration of the magnetisation values calculated here, it is evident that with all of the spins aligned, the (magnitude of the) magnetisation of the system is at a maximum.

==Calculating the energy and magnetisation==
===Modifying the files===
[[File:DMStest_output2.png|300px|thumb|right|'' '''Figure 2''': Output image from testing IsingLattice.py using Ilcheck.py'']]
In order to use Python to compute the energy and magnetisation for a given two-dimensional Ising lattice, the class IsingLattice was used, where energy() and magnetisation() functions were written to calculate their corresponding properties for a random numpy array of spins (generated using np.random.choice). For this aspect of the experiment, the value of J was assumed to be 1.0, working in reduced units. The Python script developed can be viewed [[Mod:DMS3053-1|here]], including annotations.

===Testing the files===
In order to test the script prepared thus far, the Ilcheck.py script was run, generating the image presented in ''Figure 2''. An examination of this output clearly indicates that the script provides accurate energies and magnetisations for the minimum and maximum energy configurations, along with for an intermediate, random arrangement. Hence, it can be concluded that at the current level, the Python script is functioning as required.

==Introduction to the Monte Carlo simulation==
===Average Energy and Magnetisation===
[[File:DMSILanim3.png|300px|thumb|right|'''''Figure 3''': Animation result from ILanim.py, showing the resting of the system in the minimum energy state'']]
[[File:DMSILanim_meta.png|300px|thumb|right|'''''Figure 4''': Animation result from ILanim.py, showing the resting of the system in a meta-stable state'']]

In order to consider the generalisability of the prepared script, it is important to analyse how the script will function for large systems, such as those with 100 spins in the spin array. As each of these spins can be either 'up' or 'down', each spin has two choices. Hence, the number of possible configurations for the system can be written as <math>2^{100}</math>, which has a value of 1.2677 x 1030.

If one considers the sampling of a single configuration to take 1 x 10-9 s, then it is clear that sampling all of these considerations would take a total of 1.2677 x 1021 s (also expressed as 4.017 x 1013 years). From this analysis, it is evident that the sampling of configurations was a significant consideration in the writing of a python script for this task.

In order to account for this, the technique of importance sampling was implemented, using the statistical Boltzmann distribution, <math>\exp(- \Delta E / k_B T)</math>. Note that as the energy computed using the energy() function is in units of kB, this factor is not included in the script.

===Modifying IsingLattice.py to Implement a Monte Carlo Cycle===
The python script developed at this stage is presented [[Mod:DMS3053-2|here]], accompanied by annotations to explain how the script functions.

===Simulating the Monte Carlo Cycles===
{| class="wikitable floatright" width=42%
|+ ''Table 3: statistics() output for animated system at global minimum configuration (Figure 3)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.70542501728
|- style="text-align:center;"
| <E2> || 3.13520970111
|- style="text-align:center;"
| <M> || -0.829971492744
|- style="text-align:center;"
| <M2> || 0.770986982766
|}
For cases where T < Tc, it would be expected that the system would have a spontaneous magnetisation. When T > Tc, the entropy will be the dominating factor, potentially resulting in the system having a magnetisation of zero.
{| class="wikitable floatright" width=42%
|+ ''Table 4: statistics() output for animated system at meta-stable configuration (Figure 4)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.35076450189
|- style="text-align:center;"
| <E2> || 1.89025801939
|- style="text-align:center;"
| <M> || -0.344104665826
|- style="text-align:center;"
| <M2> || 0.138855365306
|}
Using the presented script and the ILanim.py script, the Monte Carlo cycles can be simulated to view the results on the spin array as the process progresses. Here, the system under consideration was an 8 x 8 spin array, at a temperature of 0.5. ''Figure 3'' shows the typical outcome of the animation, with the system having reached the most stable, minimum energy arrangement. For the result presented here, the output of the statistics() function was that shown in ''Table 3''.

It was also observed that the system could locate a meta-stable state, with large regions of spin 'up' and 'down' spins. An example of such a result is presented in ''Figure 4'' (for which the output data from statistics() is presented in ''Table 4'').

==Accelerating the code==

In order to examine the efficiency of the python script developed thus far, the Iltimetrial.py script was utilised to investigate the time taken to perform 2000 Monte Carlo cycles. This script was modified to the version presented [[Mod:DMS3053-3|here]], which repeats the time measurement a defined number of times, then calculates the average time and the standard error in this average. For the Monte Carlo script prepared previously, the average time for 2000 Monte Carlo cycles was measured to be 5.475804 s and a standard error was calculated to be 0.008325 s, with 100 measurements made using the script.

Evidently, the current script is slow at conducting large numbers of Monte Carlo cycles and hence, a more efficient script was developed using the np.roll, np.multiply and np.sum functions - this is presented [[Mod:DMS3053-4|here]].

After this optimisation of the python script, the Iltimetrial.py script was re-run, giving an average time of 0.291467 s, with a standard error of 0.000156 s. Clearly, this optimised script is substantially faster than that developed previously (approximately 19 times faster).

==The effect of temperature==
===Correcting the averaging code===
As the equilibrium state of the system requires a number of Monte Carlo cycles to be reached, it is evident that the average energies and magnetisations are accounting for values for non-equilibrium arrangements - this was accounted for through a consideration of the number of cycles required to reach equilibrium. For this, the ILfinalframe.py script was used, giving the graphs shown in ''Table 5''. Here, each system was run for 150000 Monte Carlo cycles.
{| class="wikitable center" width=70%
|+ ''Table 5: Graphs of energy and magnetisation versus number of Monte Carlo cycles for different temperatures and system sizes''
! Temperature !! System Size !! Resulting Graphs !! Cycles for Equilibrium
|- style="text-align:center;"
| 0.5 || 4x4 || [[File:DMS0544.png|300px]] || 24
|- style="text-align:center;"
| 0.5 || 8x8 || [[File:DMS0588.png|300px]] || 392
|- style="text-align:center;"
| 0.5 || 16x16 || [[File:DMS051616.png|300px]] || 5549
|- style="text-align:center;"
| 1.0 || 2x2 || [[File:DMS1022.png|300px]] || (0)
|- style="text-align:center;"
| 1.0 || 4x4 || [[File:DMS1044.png|300px]] || 49
|- style="text-align:center;"
| 1.0 || 8x8 || [[File:DMS10882.png|300px]] || 590
|- style="text-align:center;"
| 1.0 || 16x16 || [[File:DMS101616.png|300px]] || ~6300
|- style="text-align:center;"
| 1.0 || 32x32 || [[File:DMS103232.png|300px]] || ~110000
|- style="text-align:center;"
| 2.0 || 4x4 || [[File:DMS2044.png|300px]] || -
|- style="text-align:center;"
| 2.0 || 8x8 || [[File:DMS2088.png|300px]] || -
|}
{| class="wikitable floatright" width=42%
|+ ''Table 6: Number of cycles to be ignored for each system size''
! System Size !! Number of cycles before averaging
|- style="text-align:center;"
| 2x2 || 0
|- style="text-align:center;"
| 4x4 || 100
|- style="text-align:center;"
| 8x8 || 1000
|- style="text-align:center;"
| 16x16 || 8000
|- style="text-align:center;"
| 32x32 || 120000
|}
Analysis of these graphs indicates that at higher temperatures, such as 2.0 (also observed at 1.5), large fluctuations in the energy and magnetisation are observed - these fluctuations are the reason that the average values of the properties must be taken. As the temperature is increased for systems of size 4x4, 8x8 and 16x16, it is clear that the number of cycles required in order to reach equilibrium increases. Hence, for the temperature range to be considered later (0.25 to 5.00), the required number of cycles was overestimated in order to ensure that all measurements were taken whilst the system was in equilibrium. The proposed numbers of cycles to be ignored for each system size are presented in ''Table 6''.

The python script developed up to this point was modified to account for these values by inclusion of a skip_region variable, which defines the number of cycles performed before energies and magnetisations contribute to the self.X values (before averaging occurs). The modified script is presented [[Mod:DMS3053-5|here]].

===Running over a range of temperatures===
[[File:DMS88dat.png|300px|thumb|right|'''''Figure 5''': Average energy and average magnetisation vs. temperature for 8x8 lattice, with error bars'']]
Using the python script modified in the previous exercise, the code can now be used to simulate the 8x8 system at a range of temperatures, using the ILtemperaturerange.py file (shown [[Mod:DMS3053-temprange|here]]). Here, the temperature range of 0.25 to 5.00 was used, with a separation of 0.25 between points, whilst the runtime was set to 10000 (neglecting the property values for the first 1000 cycles). Running this simulation produced the graphs in ''Figure 5'', where error bars computed using standard errors have also been included (these are small as a consequence of small standard errors). From the graph of average energy versus temperature, the phase transition can be observed - this occurs in the region with a gradient that is not close to zero. The data used here (temperature, average energies, average squared-energies, average magnetisations and average squared-magnetisations) was then saved as a numpy array in a new file, 8x8.dat.

==The effect of system size==
[[File:DMSLatticeSizeCombinedPlot.png|300px|thumb|right|'''''Figure 6''': Average energy and average magnetisation (per spins) vs. temperature for multiple lattice sizes'']]
The process conducted for the 8x8 lattice in the previous exercise was then repeated for lattices of sizes 2x2, 4x4, 16x16 and 32x32, with the data saved in .dat files. These files were then accessed, and the average energy and magnetisation data were plotted on one graph for all of the lattices sizes - this was achieved using the script presented [[Mod:DMS3053-6|here]]. The graphs produced in this manner are shown in ''Figure 6''.

A consideration of this graph suggests that in order to capture the long range fluctuations, a 16x16 lattice is necessary.

==Determining the heat capacity==
[[File:DMSheatcapacity2.png|300px|thumb|right|'''''Figure 7''': Heat capacity (per spin) versus temperature for different lattice sizes'']]
Using the .dat files previously produced, the heat capacity was calculated for each lattice size using the equation
::<math>C = \frac{\partial E}{\partial T} = \frac{\mathrm{Var}[E]}{k_B T^2}</math>, (''eq. 9'') 
where <math>\mathrm{Var}[E] = <E^2> - <E>^2 </math>. When implementing this, the kB term was neglected due to the energy values having units of kB. The script used for this purpose is provided [[DMS3053-7|here]]. The plot of heat capacity per spin versus temperature for all of the lattice sizes considered is presented in ''Figure 7''.

==Locating the Curie temperature==
===Comparison with C++ Data===
The data for the heat capacity generated using the python script prepared in this experiment was compared to that from longer C++ computations - graphs showing this comparison are presented in ''Table 7'' for a range of lattice sizes. The Python code used to produce these graphs is shown [[Mod:DMS3053-8|here]].

Considering these graphs, it is clear that, in general, there is a reasonable correlation between the Python and C++ data; however, some of the data, particularly that for high lattice sizes, shows that the Python computations have not always found the maximum of heat capacity. This correlation would be improved by making computations at the same range of temperatures, but with a smaller gap between the temperatures taken; however, this would substantially increase computation time.
{| class="wikitable center" width=70%
|+ ''Table 7: Graphs of heat capacity (per spin) versus temperature for C++ and Python data''
|- style="text-align:center;"
| [[File:DMS2x2c.png|300px]] || [[File:DMS4x4c.png|300px]] || [[File:DMS8x8c.png|300px]]
|- style="text-align:center;"
| 2x2 || 4x4 || 8x8
|- style="text-align:center;"
| [[File:DMS16x16c.png|300px]] || [[File:DMS32x32c.png|300px]]
|- style="text-align:center;"
| 16x16 || 32x32
|}

===Polynomial Fitting===
[[File:DMS8x8513.png|300px|thumb|right|'''''Figure 8''': Heat capacity (per spin) versus temperature for 8x8 system with two polynomial fits'']]
In order to make use of the C++ data in finding the Curie temperature for the Ising Lattices under consideration, polynomials were fit to the data - the script written for this purpose is shown [[Mod:DMS3053-9|here]]. For this fitting, it was found that a polynomial order of 5 was required to provide a good fit for the 2x2 data - this increased significantly as the lattice size increased. An example fit is shown for the 8x8 system in ''Figure 8'', where the polynomial fit is shown for orders 5 and 13. A consideration of this graph reveals that whilst a polynomial of order 5 may be appropriate for a 2x2 system, it is inadequate for the larger system of 8x8. Whilst an order of 13 substantially improves the polynomial fit, one must, in general, take care with 'overfitting' data.
[[File:Py8x8(13fit).png|300px|thumb|left|'''''Figure 9''': Heat capacity (per spin) versus temperature for Python data for 8x8 system with a 13th order polynomial fit'']]
For comparison, a 13th order polynomial was fitted to the 8x8 Python data previously computed - this is shown in ''Figure 9''. Here, it is evident that for this data, a higher order polynomial is required to obtain a fit comparable to that for the C++ data above.

===Fitting in a Particular Temperature Range===
[[File:DMS8x8peak(3).png|300px|thumb|right|'''''Figure 10''': Heat capacity (per spin) versus temperature for 8x8 system with peak polynomial fit'']]
As was observed in the previous exercise, large polynomial orders are required to fit the C++ data well across the whole temperature range. The python script was modified to that presented [[Mod:DMS3053-10|here]] (this script also contains the python code to compute the maximum heat capacity and temperature at which this occurs for the following exercise), which fits a polynomial only in the region of the maximum heat capacity for the system. An example of such fit is shown in ''Figure 10'' for the 8x8 system. Here, it should be noted that for all of the system sizes studied, a polynomial order of 3 was used - this is a clear improvement compared to the 13th order polynomials used previously.

===Finding the Peak in Heat Capacity===
{| class="wikitable floatright" width=42%
|+ ''Table 8: Lattice sizes and their corresponding Curie temperatures''
! System Size !! Number of cycles before averaging
|- style="text-align:center;"
| 2x2 || 2.53503504
|- style="text-align:center;"
| 4x4 || 2.43843844
|- style="text-align:center;"
| 8x8 || 2.33433433
|- style="text-align:center;"
| 16x16 || 2.30455455
|- style="text-align:center;"
| 32x32 || 2.27752753
|}
In order to find the Curie temperature for an infinite Ising Lattice, the Curie temperature for each system size considered was first found (using the script shown in the previous exercise). These temperatures were then saved to a .dat file (whose contents are also showed in ''Table 8'', along with their corresponding lattice sizes. Finally, using the script presented [[Mod:DMS3053-11|here]], a graph of Curie temperature versus the inverse of the lattice length was plotted, according to the equation
::<math>T_{C, L} = \frac{A}{L} + T_{C,\infty}</math>, ''(eq. 10)
where <math>T_{C, L}</math> is the Curie temperature for a lattice with length L and <math>T_{C,\infty}</math> is the Curie temperature for an infinite Ising lattice. Hence, it is clear that the desired Curie temperature must be the y-intercept of the graph shown in ''Figure 11'' (hence the use of extrapolation in the python script). Taking this extrapolated value gives a Curie temperature of 2.271.
</div>

Rep:Mod:DMS3053

2015-02-25T15:52:39Z

Ds3012: /* Finding the Peak in Heat Capacity */

'''CMP Programming Experiment - Daniel Spencer, 00736964'''
<div style="text-align: justify">
==Introduction to the Ising Model==
===Minimum energy of the Ising Model===
Using the equation 
::<math>E= - \frac{1}{2} J \sum_i^N \sum_{j\ \in\ \mathrm{neighbours}\left(i\right)} s_i s_j</math> (''eq. 1'') 
the minimum energy of an Ising lattice of <math>D</math> dimensions, with <math>N</math> spins (where each
spin had a value of +1 or -1) and an interaction strength of <math>J</math> was considered. This was achieved first through a consideration of a one-dimensional system with five parallel spins (where the spins are parallel as this corresponds to the minimum energy arrangement of the system). Hence, the energy of this linear system was found to be 
::<math>E_\text{min,1D} = -5J </math>. 
For a linear, one-dimensional system, the number of neigbouring spins is two. The number of neighbours can be determined for two- and three- dimensional systems through a geometric consideration of their structure - the values are presented in ''Table 1''.
{| class="wikitable floatright" width=42%
|+ ''Table 1: Dimension numbers and number of neighbours''
! Number of Dimensions, D !! Number of Neighbours
|- style="text-align:center;"
| 1 || 2
|- style="text-align:center;"
| 2 || 4
|- style="text-align:center;"
| 3 || 6
|- style="text-align:center;"
| D || 2D
|}
These data indicate that the number of neighbours is twice the number of dimensions, for the dimensions considered here. This can be extrapolated to give the general number of neighbours as <math>2D</math>.

For the minimum energy of the system, where all spins are parallel, every combination <math>s_i s_j</math> has a value of 1. Notably, for each value of <math>i</math>, there will be <math>2D</math> neighbour interactions. Ergo, using ''eq. 1'', the general minimum energy can be found to be
::<math>E_\text{min,D} = -DNJ </math> (''eq. 2''). 
To check this equation, it can be applied to the two-dimensional Ising lattice with 25 spins - this gives a value of
::<math>E_\text{min,2D} = -50J </math>, 
which matches with the value predicted from first-principles.

For this D-dimensional system, the multiplicity (i.e. the number of ways of achieving the specified configuration of spins) must be equal to two, as either all of the spins could be aligned 'up' (+1) or 'down' (-1). Using this multiplicity, the entropy of the system can be calculated using the equation
::<math>S = k_B \ln\Omega</math>, (''eq. 3'') 
where Ω is the number of microstates (equal to the multiplicity in this case), which gives a value of <math>k_B \ln2 </math>, or 9.57 x 10-24 J K-1.

===Spin 'flipping'===

Using the Ising model, it is also possible to consider a change in state, reflected by a 'flipping' of the direction of one of the lattice spins. For this case, the energy (using ''eq. 1'') can be determined to be
::<math>E'= - \frac{1}{2} J (2DN - 4D - 4D) = 4DJ - DNJ</math>, (''eq. 4'') 
where the additional <math>4D</math> terms arise from the loss of 4D stabilising spin-aligned interactions and the gain of 4D destabilising spins anti-aligned interactions following spin 'flipping'. Using ''eq. 2'' and ''eq. 4'', the change in energy derived from this spin 'flip' can be calculated to be
::<math>\Delta E= 4DJ - DNJ + DNJ = 4DJ</math>. (''eq. 5'') 
For a system with three dimensions (D = 3) and 1000 spins (N = 1000), the system, using ''eq. 5'', was determined to increase in energy by <math>12 J</math>. Notably, this change in energy is independent of the number of spins in the system - it depends only on the number of dimensions and J.
[[File:ThirdYearCMPExpt-IsingSketch.png|300px|thumb|right|'' '''Figure 1''': Representation of Ising lattices in one (N=5), two (N=25), and three (N=125) dimensions. +1 and -1 spins are denoted by the red and blue cells respectively. Diagram taken from the lab script.'']]
A significant consideration with regards to the spin 'flipping' described here is the accompanying increase in entropy - the driving force for this process. For the scenario describing the change in direction of a single spin, the multiplicity of the system will be <math>2N</math> - this is a consequence of the system prior to 'flipping' having a multiplicity of two (all spins aligned 'up' or 'down'), where now, any one of the spins could flip, adding the factor of N to the multiplicity. Hence, the new entropy can be defined to be
::<math>S' = k_B \ln 2N</math>, (''eq. 6'') 
which allows the change in entropy to be calculated according to ''eq. 7''.
::<math>\Delta S = k_B \ln 2N - k_B \ln2 = k_B \ln N</math> (''eq. 7'') 
For the system described above (D = 3, N = 1000), the change in entropy associated with the spin 'flip' process is therefore <math>k_B ln 1000</math>, which is equal to 9.53 x 10-23 J K-1.

===Magnetisation===
{| class="wikitable floatright" width=42%
|+ ''Table 2: Ising lattices and magnetisations''
! Ising Lattice !! Magnetisation
|- style="text-align:center;"
| 1D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 2D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 3D at 0 K || 1000 or -1000
|}
''Figure 1'' shows three examples of Ising lattices, with one, two and three dimensions respectively. Using the equation for magnetisation (''eq. 8''), the magnetisations of these systems can be calculated to be those presented in ''Table 2''.
::<math>M= \sum_i s_i</math> (''eq. 8'') 
For the three-dimensional system at a temperature of 0 K, all of the spins must be aligned either 'up' or 'down', as the entropic increase associated with 'flipped' spins does not provide a driving force at absolute zero - the only factor to consider is that of the energy, which is a minimum when all of the spins are aligned. For this case, the magnetisation could be either 1000 or -1000, depending upon the direction of the spin alignment. From a consideration of the magnetisation values calculated here, it is evident that with all of the spins aligned, the (magnitude of the) magnetisation of the system is at a maximum.

==Calculating the energy and magnetisation==
===Modifying the files===
[[File:DMStest_output2.png|300px|thumb|right|'' '''Figure 2''': Output image from testing IsingLattice.py using Ilcheck.py'']]
In order to use Python to compute the energy and magnetisation for a given two-dimensional Ising lattice, the class IsingLattice was used, where energy() and magnetisation() functions were written to calculate their corresponding properties for a random numpy array of spins (generated using np.random.choice). For this aspect of the experiment, the value of J was assumed to be 1.0, working in reduced units. The Python script developed can be viewed [[Mod:DMS3053-1|here]], including annotations.

===Testing the files===
In order to test the script prepared thus far, the Ilcheck.py script was run, generating the image presented in ''Figure 2''. An examination of this output clearly indicates that the script provides accurate energies and magnetisations for the minimum and maximum energy configurations, along with for an intermediate, random arrangement. Hence, it can be concluded that at the current level, the Python script is functioning as required.

==Introduction to the Monte Carlo simulation==
===Average Energy and Magnetisation===
[[File:DMSILanim3.png|300px|thumb|right|'''''Figure 3''': Animation result from ILanim.py, showing the resting of the system in the minimum energy state'']]
[[File:DMSILanim_meta.png|300px|thumb|right|'''''Figure 4''': Animation result from ILanim.py, showing the resting of the system in a meta-stable state'']]

In order to consider the generalisability of the prepared script, it is important to analyse how the script will function for large systems, such as those with 100 spins in the spin array. As each of these spins can be either 'up' or 'down', each spin has two choices. Hence, the number of possible configurations for the system can be written as <math>2^{100}</math>, which has a value of 1.2677 x 1030.

If one considers the sampling of a single configuration to take 1 x 10-9 s, then it is clear that sampling all of these considerations would take a total of 1.2677 x 1021 s (also expressed as 4.017 x 1013 years). From this analysis, it is evident that the sampling of configurations was a significant consideration in the writing of a python script for this task.

In order to account for this, the technique of importance sampling was implemented, using the statistical Boltzmann distribution, <math>\exp(- \Delta E / k_B T)</math>. Note that as the energy computed using the energy() function is in units of kB, this factor is not included in the script.

===Modifying IsingLattice.py to Implement a Monte Carlo Cycle===
The python script developed at this stage is presented [[Mod:DMS3053-2|here]], accompanied by annotations to explain how the script functions.

===Simulating the Monte Carlo Cycles===
{| class="wikitable floatright" width=42%
|+ ''Table 3: statistics() output for animated system at global minimum configuration (Figure 3)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.70542501728
|- style="text-align:center;"
| <E2> || 3.13520970111
|- style="text-align:center;"
| <M> || -0.829971492744
|- style="text-align:center;"
| <M2> || 0.770986982766
|}
For cases where T < Tc, it would be expected that the system would have a spontaneous magnetisation. When T > Tc, the entropy will be the dominating factor, potentially resulting in the system having a magnetisation of zero.
{| class="wikitable floatright" width=42%
|+ ''Table 4: statistics() output for animated system at meta-stable configuration (Figure 4)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.35076450189
|- style="text-align:center;"
| <E2> || 1.89025801939
|- style="text-align:center;"
| <M> || -0.344104665826
|- style="text-align:center;"
| <M2> || 0.138855365306
|}
Using the presented script and the ILanim.py script, the Monte Carlo cycles can be simulated to view the results on the spin array as the process progresses. Here, the system under consideration was an 8 x 8 spin array, at a temperature of 0.5. ''Figure 3'' shows the typical outcome of the animation, with the system having reached the most stable, minimum energy arrangement. For the result presented here, the output of the statistics() function was that shown in ''Table 3''.

It was also observed that the system could locate a meta-stable state, with large regions of spin 'up' and 'down' spins. An example of such a result is presented in ''Figure 4'' (for which the output data from statistics() is presented in ''Table 4'').

==Accelerating the code==

In order to examine the efficiency of the python script developed thus far, the Iltimetrial.py script was utilised to investigate the time taken to perform 2000 Monte Carlo cycles. This script was modified to the version presented [[Mod:DMS3053-3|here]], which repeats the time measurement a defined number of times, then calculates the average time and the standard error in this average. For the Monte Carlo script prepared previously, the average time for 2000 Monte Carlo cycles was measured to be 5.475804 s and a standard error was calculated to be 0.008325 s, with 100 measurements made using the script.

Evidently, the current script is slow at conducting large numbers of Monte Carlo cycles and hence, a more efficient script was developed using the np.roll, np.multiply and np.sum functions - this is presented [[Mod:DMS3053-4|here]].

After this optimisation of the python script, the Iltimetrial.py script was re-run, giving an average time of 0.291467 s, with a standard error of 0.000156 s. Clearly, this optimised script is substantially faster than that developed previously (approximately 19 times faster).

==The effect of temperature==
===Correcting the averaging code===
As the equilibrium state of the system requires a number of Monte Carlo cycles to be reached, it is evident that the average energies and magnetisations are accounting for values for non-equilibrium arrangements - this was accounted for through a consideration of the number of cycles required to reach equilibrium. For this, the ILfinalframe.py script was used, giving the graphs shown in ''Table 5''. Here, each system was run for 150000 Monte Carlo cycles.
{| class="wikitable center" width=70%
|+ ''Table 5: Graphs of energy and magnetisation versus number of Monte Carlo cycles for different temperatures and system sizes''
! Temperature !! System Size !! Resulting Graphs !! Cycles for Equilibrium
|- style="text-align:center;"
| 0.5 || 4x4 || [[File:DMS0544.png|300px]] || 24
|- style="text-align:center;"
| 0.5 || 8x8 || [[File:DMS0588.png|300px]] || 392
|- style="text-align:center;"
| 0.5 || 16x16 || [[File:DMS051616.png|300px]] || 5549
|- style="text-align:center;"
| 1.0 || 2x2 || [[File:DMS1022.png|300px]] || (0)
|- style="text-align:center;"
| 1.0 || 4x4 || [[File:DMS1044.png|300px]] || 49
|- style="text-align:center;"
| 1.0 || 8x8 || [[File:DMS10882.png|300px]] || 590
|- style="text-align:center;"
| 1.0 || 16x16 || [[File:DMS101616.png|300px]] || ~6300
|- style="text-align:center;"
| 1.0 || 32x32 || [[File:DMS103232.png|300px]] || ~110000
|- style="text-align:center;"
| 2.0 || 4x4 || [[File:DMS2044.png|300px]] || -
|- style="text-align:center;"
| 2.0 || 8x8 || [[File:DMS2088.png|300px]] || -
|}
{| class="wikitable floatright" width=42%
|+ ''Table 6: Number of cycles to be ignored for each system size''
! System Size !! Number of cycles before averaging
|- style="text-align:center;"
| 2x2 || 0
|- style="text-align:center;"
| 4x4 || 100
|- style="text-align:center;"
| 8x8 || 1000
|- style="text-align:center;"
| 16x16 || 8000
|- style="text-align:center;"
| 32x32 || 120000
|}
Analysis of these graphs indicates that at higher temperatures, such as 2.0 (also observed at 1.5), large fluctuations in the energy and magnetisation are observed - these fluctuations are the reason that the average values of the properties must be taken. As the temperature is increased for systems of size 4x4, 8x8 and 16x16, it is clear that the number of cycles required in order to reach equilibrium increases. Hence, for the temperature range to be considered later (0.25 to 5.00), the required number of cycles was overestimated in order to ensure that all measurements were taken whilst the system was in equilibrium. The proposed numbers of cycles to be ignored for each system size are presented in ''Table 6''.

The python script developed up to this point was modified to account for these values by inclusion of a skip_region variable, which defines the number of cycles performed before energies and magnetisations contribute to the self.X values (before averaging occurs). The modified script is presented [[Mod:DMS3053-5|here]].

===Running over a range of temperatures===
[[File:DMS88dat.png|300px|thumb|right|'''''Figure 5''': Average energy and average magnetisation vs. temperature for 8x8 lattice, with error bars'']]
Using the python script modified in the previous exercise, the code can now be used to simulate the 8x8 system at a range of temperatures, using the ILtemperaturerange.py file (shown [[Mod:DMS3053-temprange|here]]). Here, the temperature range of 0.25 to 5.00 was used, with a separation of 0.25 between points, whilst the runtime was set to 10000 (neglecting the property values for the first 1000 cycles). Running this simulation produced the graphs in ''Figure 5'', where error bars computed using standard errors have also been included (these are small as a consequence of small standard errors). From the graph of average energy versus temperature, the phase transition can be observed - this occurs in the region with a gradient that is not close to zero. The data used here (temperature, average energies, average squared-energies, average magnetisations and average squared-magnetisations) was then saved as a numpy array in a new file, 8x8.dat.

==The effect of system size==
[[File:DMSLatticeSizeCombinedPlot.png|300px|thumb|right|'''''Figure 6''': Average energy and average magnetisation (per spins) vs. temperature for multiple lattice sizes'']]
The process conducted for the 8x8 lattice in the previous exercise was then repeated for lattices of sizes 2x2, 4x4, 16x16 and 32x32, with the data saved in .dat files. These files were then accessed, and the average energy and magnetisation data were plotted on one graph for all of the lattices sizes - this was achieved using the script presented [[Mod:DMS3053-6|here]]. The graphs produced in this manner are shown in ''Figure 6''.

A consideration of this graph suggests that in order to capture the long range fluctuations, a 16x16 lattice is necessary.

==Determining the heat capacity==
[[File:DMSheatcapacity2.png|300px|thumb|right|'''''Figure 7''': Heat capacity (per spin) versus temperature for different lattice sizes'']]
Using the .dat files previously produced, the heat capacity was calculated for each lattice size using the equation
::<math>C = \frac{\partial E}{\partial T} = \frac{\mathrm{Var}[E]}{k_B T^2}</math>, (''eq. 9'') 
where <math>\mathrm{Var}[E] = <E^2> - <E>^2 </math>. When implementing this, the kB term was neglected due to the energy values having units of kB. The script used for this purpose is provided [[DMS3053-7|here]]. The plot of heat capacity per spin versus temperature for all of the lattice sizes considered is presented in ''Figure 7''.

==Locating the Curie temperature==
===Comparison with C++ Data===
The data for the heat capacity generated using the python script prepared in this experiment was compared to that from longer C++ computations - graphs showing this comparison are presented in ''Table 7'' for a range of lattice sizes. The Python code used to produce these graphs is shown [[Mod:DMS3053-8|here]].

Considering these graphs, it is clear that, in general, there is a reasonable correlation between the Python and C++ data; however, some of the data, particularly that for high lattice sizes, shows that the Python computations have not always found the maximum of heat capacity. This correlation would be improved by making computations at the same range of temperatures, but with a smaller gap between the temperatures taken; however, this would substantially increase computation time.
{| class="wikitable center" width=70%
|+ ''Table 7: Graphs of heat capacity (per spin) versus temperature for C++ and Python data''
|- style="text-align:center;"
| [[File:DMS2x2c.png|300px]] || [[File:DMS4x4c.png|300px]] || [[File:DMS8x8c.png|300px]]
|- style="text-align:center;"
| 2x2 || 4x4 || 8x8
|- style="text-align:center;"
| [[File:DMS16x16c.png|300px]] || [[File:DMS32x32c.png|300px]]
|- style="text-align:center;"
| 16x16 || 32x32
|}

===Polynomial Fitting===
[[File:DMS8x8513.png|300px|thumb|right|'''''Figure 8''': Heat capacity (per spin) versus temperature for 8x8 system with two polynomial fits'']]
In order to make use of the C++ data in finding the Curie temperature for the Ising Lattices under consideration, polynomials were fit to the data - the script written for this purpose is shown [[Mod:DMS3053-9|here]]. For this fitting, it was found that a polynomial order of 5 was required to provide a good fit for the 2x2 data - this increased significantly as the lattice size increased. An example fit is shown for the 8x8 system in ''Figure 8'', where the polynomial fit is shown for orders 5 and 13. A consideration of this graph reveals that whilst a polynomial of order 5 may be appropriate for a 2x2 system, it is inadequate for the larger system of 8x8. Whilst an order of 13 substantially improves the polynomial fit, one must, in general, take care with 'overfitting' data.
[[File:Py8x8(13fit).png|300px|thumb|left|'''''Figure 9''': Heat capacity (per spin) versus temperature for Python data for 8x8 system with a 13th order polynomial fit'']]
For comparison, a 13th order polynomial was fitted to the 8x8 Python data previously computed - this is shown in ''Figure 9''. Here, it is evident that for this data, a higher order polynomial is required to obtain a fit comparable to that for the C++ data above.

===Fitting in a Particular Temperature Range===
[[File:DMS8x8peak(3).png|300px|thumb|right|'''''Figure 10''': Heat capacity (per spin) versus temperature for 8x8 system with peak polynomial fit'']]
As was observed in the previous exercise, large polynomial orders are required to fit the C++ data well across the whole temperature range. The python script was modified to that presented [[Mod:DMS3053-10|here]] (this script also contains the python code to compute the maximum heat capacity and temperature at which this occurs for the following exercise), which fits a polynomial only in the region of the maximum heat capacity for the system. An example of such fit is shown in ''Figure 10'' for the 8x8 system. Here, it should be noted that for all of the system sizes studied, a polynomial order of 3 was used - this is a clear improvement compared to the 13th order polynomials used previously.

===Finding the Peak in Heat Capacity===
In order to find the Curie temperature for an infinite Ising Lattice, the Curie temperature for each system size considered was first found (using the script shown in the previous exercise). These temperatures were then saved to a .dat file (whose contents are also showed in ''Table 8'', along with their corresponding lattice sizes. Finally, using the script presented [[Mod:DMS3053-11|here]], a graph of Curie temperature versus the inverse of the lattice length was plotted, according to the equation
::<math>T_{C, L} = \frac{A}{L} + T_{C,\infty}</math>, ''(eq. 10)
where <math>T_{C, L}</math> is the Curie temperature for a lattice with length L and <math>T_{C,\infty}</math> is the Curie temperature for an infinite Ising lattice. Hence, it is clear that the desired Curie temperature must be the y-intercept of the graph shown in ''Figure 11'' (hence the use of extrapolation in the python script). Taking this extrapolated value gives a Curie temperature of 2.271.
</div>

Rep:Mod:DMS3053

2015-02-25T15:51:46Z

Ds3012: /* Locating the Curie temperature */

'''CMP Programming Experiment - Daniel Spencer, 00736964'''
<div style="text-align: justify">
==Introduction to the Ising Model==
===Minimum energy of the Ising Model===
Using the equation 
::<math>E= - \frac{1}{2} J \sum_i^N \sum_{j\ \in\ \mathrm{neighbours}\left(i\right)} s_i s_j</math> (''eq. 1'') 
the minimum energy of an Ising lattice of <math>D</math> dimensions, with <math>N</math> spins (where each
spin had a value of +1 or -1) and an interaction strength of <math>J</math> was considered. This was achieved first through a consideration of a one-dimensional system with five parallel spins (where the spins are parallel as this corresponds to the minimum energy arrangement of the system). Hence, the energy of this linear system was found to be 
::<math>E_\text{min,1D} = -5J </math>. 
For a linear, one-dimensional system, the number of neigbouring spins is two. The number of neighbours can be determined for two- and three- dimensional systems through a geometric consideration of their structure - the values are presented in ''Table 1''.
{| class="wikitable floatright" width=42%
|+ ''Table 1: Dimension numbers and number of neighbours''
! Number of Dimensions, D !! Number of Neighbours
|- style="text-align:center;"
| 1 || 2
|- style="text-align:center;"
| 2 || 4
|- style="text-align:center;"
| 3 || 6
|- style="text-align:center;"
| D || 2D
|}
These data indicate that the number of neighbours is twice the number of dimensions, for the dimensions considered here. This can be extrapolated to give the general number of neighbours as <math>2D</math>.

For the minimum energy of the system, where all spins are parallel, every combination <math>s_i s_j</math> has a value of 1. Notably, for each value of <math>i</math>, there will be <math>2D</math> neighbour interactions. Ergo, using ''eq. 1'', the general minimum energy can be found to be
::<math>E_\text{min,D} = -DNJ </math> (''eq. 2''). 
To check this equation, it can be applied to the two-dimensional Ising lattice with 25 spins - this gives a value of
::<math>E_\text{min,2D} = -50J </math>, 
which matches with the value predicted from first-principles.

For this D-dimensional system, the multiplicity (i.e. the number of ways of achieving the specified configuration of spins) must be equal to two, as either all of the spins could be aligned 'up' (+1) or 'down' (-1). Using this multiplicity, the entropy of the system can be calculated using the equation
::<math>S = k_B \ln\Omega</math>, (''eq. 3'') 
where Ω is the number of microstates (equal to the multiplicity in this case), which gives a value of <math>k_B \ln2 </math>, or 9.57 x 10-24 J K-1.

===Spin 'flipping'===

Using the Ising model, it is also possible to consider a change in state, reflected by a 'flipping' of the direction of one of the lattice spins. For this case, the energy (using ''eq. 1'') can be determined to be
::<math>E'= - \frac{1}{2} J (2DN - 4D - 4D) = 4DJ - DNJ</math>, (''eq. 4'') 
where the additional <math>4D</math> terms arise from the loss of 4D stabilising spin-aligned interactions and the gain of 4D destabilising spins anti-aligned interactions following spin 'flipping'. Using ''eq. 2'' and ''eq. 4'', the change in energy derived from this spin 'flip' can be calculated to be
::<math>\Delta E= 4DJ - DNJ + DNJ = 4DJ</math>. (''eq. 5'') 
For a system with three dimensions (D = 3) and 1000 spins (N = 1000), the system, using ''eq. 5'', was determined to increase in energy by <math>12 J</math>. Notably, this change in energy is independent of the number of spins in the system - it depends only on the number of dimensions and J.
[[File:ThirdYearCMPExpt-IsingSketch.png|300px|thumb|right|'' '''Figure 1''': Representation of Ising lattices in one (N=5), two (N=25), and three (N=125) dimensions. +1 and -1 spins are denoted by the red and blue cells respectively. Diagram taken from the lab script.'']]
A significant consideration with regards to the spin 'flipping' described here is the accompanying increase in entropy - the driving force for this process. For the scenario describing the change in direction of a single spin, the multiplicity of the system will be <math>2N</math> - this is a consequence of the system prior to 'flipping' having a multiplicity of two (all spins aligned 'up' or 'down'), where now, any one of the spins could flip, adding the factor of N to the multiplicity. Hence, the new entropy can be defined to be
::<math>S' = k_B \ln 2N</math>, (''eq. 6'') 
which allows the change in entropy to be calculated according to ''eq. 7''.
::<math>\Delta S = k_B \ln 2N - k_B \ln2 = k_B \ln N</math> (''eq. 7'') 
For the system described above (D = 3, N = 1000), the change in entropy associated with the spin 'flip' process is therefore <math>k_B ln 1000</math>, which is equal to 9.53 x 10-23 J K-1.

===Magnetisation===
{| class="wikitable floatright" width=42%
|+ ''Table 2: Ising lattices and magnetisations''
! Ising Lattice !! Magnetisation
|- style="text-align:center;"
| 1D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 2D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 3D at 0 K || 1000 or -1000
|}
''Figure 1'' shows three examples of Ising lattices, with one, two and three dimensions respectively. Using the equation for magnetisation (''eq. 8''), the magnetisations of these systems can be calculated to be those presented in ''Table 2''.
::<math>M= \sum_i s_i</math> (''eq. 8'') 
For the three-dimensional system at a temperature of 0 K, all of the spins must be aligned either 'up' or 'down', as the entropic increase associated with 'flipped' spins does not provide a driving force at absolute zero - the only factor to consider is that of the energy, which is a minimum when all of the spins are aligned. For this case, the magnetisation could be either 1000 or -1000, depending upon the direction of the spin alignment. From a consideration of the magnetisation values calculated here, it is evident that with all of the spins aligned, the (magnitude of the) magnetisation of the system is at a maximum.

==Calculating the energy and magnetisation==
===Modifying the files===
[[File:DMStest_output2.png|300px|thumb|right|'' '''Figure 2''': Output image from testing IsingLattice.py using Ilcheck.py'']]
In order to use Python to compute the energy and magnetisation for a given two-dimensional Ising lattice, the class IsingLattice was used, where energy() and magnetisation() functions were written to calculate their corresponding properties for a random numpy array of spins (generated using np.random.choice). For this aspect of the experiment, the value of J was assumed to be 1.0, working in reduced units. The Python script developed can be viewed [[Mod:DMS3053-1|here]], including annotations.

===Testing the files===
In order to test the script prepared thus far, the Ilcheck.py script was run, generating the image presented in ''Figure 2''. An examination of this output clearly indicates that the script provides accurate energies and magnetisations for the minimum and maximum energy configurations, along with for an intermediate, random arrangement. Hence, it can be concluded that at the current level, the Python script is functioning as required.

==Introduction to the Monte Carlo simulation==
===Average Energy and Magnetisation===
[[File:DMSILanim3.png|300px|thumb|right|'''''Figure 3''': Animation result from ILanim.py, showing the resting of the system in the minimum energy state'']]
[[File:DMSILanim_meta.png|300px|thumb|right|'''''Figure 4''': Animation result from ILanim.py, showing the resting of the system in a meta-stable state'']]

In order to consider the generalisability of the prepared script, it is important to analyse how the script will function for large systems, such as those with 100 spins in the spin array. As each of these spins can be either 'up' or 'down', each spin has two choices. Hence, the number of possible configurations for the system can be written as <math>2^{100}</math>, which has a value of 1.2677 x 1030.

If one considers the sampling of a single configuration to take 1 x 10-9 s, then it is clear that sampling all of these considerations would take a total of 1.2677 x 1021 s (also expressed as 4.017 x 1013 years). From this analysis, it is evident that the sampling of configurations was a significant consideration in the writing of a python script for this task.

In order to account for this, the technique of importance sampling was implemented, using the statistical Boltzmann distribution, <math>\exp(- \Delta E / k_B T)</math>. Note that as the energy computed using the energy() function is in units of kB, this factor is not included in the script.

===Modifying IsingLattice.py to Implement a Monte Carlo Cycle===
The python script developed at this stage is presented [[Mod:DMS3053-2|here]], accompanied by annotations to explain how the script functions.

===Simulating the Monte Carlo Cycles===
{| class="wikitable floatright" width=42%
|+ ''Table 3: statistics() output for animated system at global minimum configuration (Figure 3)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.70542501728
|- style="text-align:center;"
| <E2> || 3.13520970111
|- style="text-align:center;"
| <M> || -0.829971492744
|- style="text-align:center;"
| <M2> || 0.770986982766
|}
For cases where T < Tc, it would be expected that the system would have a spontaneous magnetisation. When T > Tc, the entropy will be the dominating factor, potentially resulting in the system having a magnetisation of zero.
{| class="wikitable floatright" width=42%
|+ ''Table 4: statistics() output for animated system at meta-stable configuration (Figure 4)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.35076450189
|- style="text-align:center;"
| <E2> || 1.89025801939
|- style="text-align:center;"
| <M> || -0.344104665826
|- style="text-align:center;"
| <M2> || 0.138855365306
|}
Using the presented script and the ILanim.py script, the Monte Carlo cycles can be simulated to view the results on the spin array as the process progresses. Here, the system under consideration was an 8 x 8 spin array, at a temperature of 0.5. ''Figure 3'' shows the typical outcome of the animation, with the system having reached the most stable, minimum energy arrangement. For the result presented here, the output of the statistics() function was that shown in ''Table 3''.

It was also observed that the system could locate a meta-stable state, with large regions of spin 'up' and 'down' spins. An example of such a result is presented in ''Figure 4'' (for which the output data from statistics() is presented in ''Table 4'').

==Accelerating the code==

In order to examine the efficiency of the python script developed thus far, the Iltimetrial.py script was utilised to investigate the time taken to perform 2000 Monte Carlo cycles. This script was modified to the version presented [[Mod:DMS3053-3|here]], which repeats the time measurement a defined number of times, then calculates the average time and the standard error in this average. For the Monte Carlo script prepared previously, the average time for 2000 Monte Carlo cycles was measured to be 5.475804 s and a standard error was calculated to be 0.008325 s, with 100 measurements made using the script.

Evidently, the current script is slow at conducting large numbers of Monte Carlo cycles and hence, a more efficient script was developed using the np.roll, np.multiply and np.sum functions - this is presented [[Mod:DMS3053-4|here]].

After this optimisation of the python script, the Iltimetrial.py script was re-run, giving an average time of 0.291467 s, with a standard error of 0.000156 s. Clearly, this optimised script is substantially faster than that developed previously (approximately 19 times faster).

==The effect of temperature==
===Correcting the averaging code===
As the equilibrium state of the system requires a number of Monte Carlo cycles to be reached, it is evident that the average energies and magnetisations are accounting for values for non-equilibrium arrangements - this was accounted for through a consideration of the number of cycles required to reach equilibrium. For this, the ILfinalframe.py script was used, giving the graphs shown in ''Table 5''. Here, each system was run for 150000 Monte Carlo cycles.
{| class="wikitable center" width=70%
|+ ''Table 5: Graphs of energy and magnetisation versus number of Monte Carlo cycles for different temperatures and system sizes''
! Temperature !! System Size !! Resulting Graphs !! Cycles for Equilibrium
|- style="text-align:center;"
| 0.5 || 4x4 || [[File:DMS0544.png|300px]] || 24
|- style="text-align:center;"
| 0.5 || 8x8 || [[File:DMS0588.png|300px]] || 392
|- style="text-align:center;"
| 0.5 || 16x16 || [[File:DMS051616.png|300px]] || 5549
|- style="text-align:center;"
| 1.0 || 2x2 || [[File:DMS1022.png|300px]] || (0)
|- style="text-align:center;"
| 1.0 || 4x4 || [[File:DMS1044.png|300px]] || 49
|- style="text-align:center;"
| 1.0 || 8x8 || [[File:DMS10882.png|300px]] || 590
|- style="text-align:center;"
| 1.0 || 16x16 || [[File:DMS101616.png|300px]] || ~6300
|- style="text-align:center;"
| 1.0 || 32x32 || [[File:DMS103232.png|300px]] || ~110000
|- style="text-align:center;"
| 2.0 || 4x4 || [[File:DMS2044.png|300px]] || -
|- style="text-align:center;"
| 2.0 || 8x8 || [[File:DMS2088.png|300px]] || -
|}
{| class="wikitable floatright" width=42%
|+ ''Table 6: Number of cycles to be ignored for each system size''
! System Size !! Number of cycles before averaging
|- style="text-align:center;"
| 2x2 || 0
|- style="text-align:center;"
| 4x4 || 100
|- style="text-align:center;"
| 8x8 || 1000
|- style="text-align:center;"
| 16x16 || 8000
|- style="text-align:center;"
| 32x32 || 120000
|}
Analysis of these graphs indicates that at higher temperatures, such as 2.0 (also observed at 1.5), large fluctuations in the energy and magnetisation are observed - these fluctuations are the reason that the average values of the properties must be taken. As the temperature is increased for systems of size 4x4, 8x8 and 16x16, it is clear that the number of cycles required in order to reach equilibrium increases. Hence, for the temperature range to be considered later (0.25 to 5.00), the required number of cycles was overestimated in order to ensure that all measurements were taken whilst the system was in equilibrium. The proposed numbers of cycles to be ignored for each system size are presented in ''Table 6''.

The python script developed up to this point was modified to account for these values by inclusion of a skip_region variable, which defines the number of cycles performed before energies and magnetisations contribute to the self.X values (before averaging occurs). The modified script is presented [[Mod:DMS3053-5|here]].

===Running over a range of temperatures===
[[File:DMS88dat.png|300px|thumb|right|'''''Figure 5''': Average energy and average magnetisation vs. temperature for 8x8 lattice, with error bars'']]
Using the python script modified in the previous exercise, the code can now be used to simulate the 8x8 system at a range of temperatures, using the ILtemperaturerange.py file (shown [[Mod:DMS3053-temprange|here]]). Here, the temperature range of 0.25 to 5.00 was used, with a separation of 0.25 between points, whilst the runtime was set to 10000 (neglecting the property values for the first 1000 cycles). Running this simulation produced the graphs in ''Figure 5'', where error bars computed using standard errors have also been included (these are small as a consequence of small standard errors). From the graph of average energy versus temperature, the phase transition can be observed - this occurs in the region with a gradient that is not close to zero. The data used here (temperature, average energies, average squared-energies, average magnetisations and average squared-magnetisations) was then saved as a numpy array in a new file, 8x8.dat.

==The effect of system size==
[[File:DMSLatticeSizeCombinedPlot.png|300px|thumb|right|'''''Figure 6''': Average energy and average magnetisation (per spins) vs. temperature for multiple lattice sizes'']]
The process conducted for the 8x8 lattice in the previous exercise was then repeated for lattices of sizes 2x2, 4x4, 16x16 and 32x32, with the data saved in .dat files. These files were then accessed, and the average energy and magnetisation data were plotted on one graph for all of the lattices sizes - this was achieved using the script presented [[Mod:DMS3053-6|here]]. The graphs produced in this manner are shown in ''Figure 6''.

A consideration of this graph suggests that in order to capture the long range fluctuations, a 16x16 lattice is necessary.

==Determining the heat capacity==
[[File:DMSheatcapacity2.png|300px|thumb|right|'''''Figure 7''': Heat capacity (per spin) versus temperature for different lattice sizes'']]
Using the .dat files previously produced, the heat capacity was calculated for each lattice size using the equation
::<math>C = \frac{\partial E}{\partial T} = \frac{\mathrm{Var}[E]}{k_B T^2}</math>, (''eq. 9'') 
where <math>\mathrm{Var}[E] = <E^2> - <E>^2 </math>. When implementing this, the kB term was neglected due to the energy values having units of kB. The script used for this purpose is provided [[DMS3053-7|here]]. The plot of heat capacity per spin versus temperature for all of the lattice sizes considered is presented in ''Figure 7''.

==Locating the Curie temperature==
===Comparison with C++ Data===
The data for the heat capacity generated using the python script prepared in this experiment was compared to that from longer C++ computations - graphs showing this comparison are presented in ''Table 7'' for a range of lattice sizes. The Python code used to produce these graphs is shown [[Mod:DMS3053-8|here]].

Considering these graphs, it is clear that, in general, there is a reasonable correlation between the Python and C++ data; however, some of the data, particularly that for high lattice sizes, shows that the Python computations have not always found the maximum of heat capacity. This correlation would be improved by making computations at the same range of temperatures, but with a smaller gap between the temperatures taken; however, this would substantially increase computation time.
{| class="wikitable center" width=70%
|+ ''Table 7: Graphs of heat capacity (per spin) versus temperature for C++ and Python data''
|- style="text-align:center;"
| [[File:DMS2x2c.png|300px]] || [[File:DMS4x4c.png|300px]] || [[File:DMS8x8c.png|300px]]
|- style="text-align:center;"
| 2x2 || 4x4 || 8x8
|- style="text-align:center;"
| [[File:DMS16x16c.png|300px]] || [[File:DMS32x32c.png|300px]]
|- style="text-align:center;"
| 16x16 || 32x32
|}

===Polynomial Fitting===
[[File:DMS8x8513.png|300px|thumb|right|'''''Figure 8''': Heat capacity (per spin) versus temperature for 8x8 system with two polynomial fits'']]
In order to make use of the C++ data in finding the Curie temperature for the Ising Lattices under consideration, polynomials were fit to the data - the script written for this purpose is shown [[Mod:DMS3053-9|here]]. For this fitting, it was found that a polynomial order of 5 was required to provide a good fit for the 2x2 data - this increased significantly as the lattice size increased. An example fit is shown for the 8x8 system in ''Figure 8'', where the polynomial fit is shown for orders 5 and 13. A consideration of this graph reveals that whilst a polynomial of order 5 may be appropriate for a 2x2 system, it is inadequate for the larger system of 8x8. Whilst an order of 13 substantially improves the polynomial fit, one must, in general, take care with 'overfitting' data.
[[File:Py8x8(13fit).png|300px|thumb|left|'''''Figure 9''': Heat capacity (per spin) versus temperature for Python data for 8x8 system with a 13th order polynomial fit'']]
For comparison, a 13th order polynomial was fitted to the 8x8 Python data previously computed - this is shown in ''Figure 9''. Here, it is evident that for this data, a higher order polynomial is required to obtain a fit comparable to that for the C++ data above.

===Fitting in a Particular Temperature Range===
[[File:DMS8x8peak(3).png|300px|thumb|right|'''''Figure 10''': Heat capacity (per spin) versus temperature for 8x8 system with peak polynomial fit'']]
As was observed in the previous exercise, large polynomial orders are required to fit the C++ data well across the whole temperature range. The python script was modified to that presented [[Mod:DMS3053-10|here]] (this script also contains the python code to compute the maximum heat capacity and temperature at which this occurs for the following exercise), which fits a polynomial only in the region of the maximum heat capacity for the system. An example of such fit is shown in ''Figure 10'' for the 8x8 system. Here, it should be noted that for all of the system sizes studied, a polynomial order of 3 was used - this is a clear improvement compared to the 13th order polynomials used previously.

===Finding the Peak in Heat Capacity===
In order to find the Curie temperature for an infinite Ising Lattice, the Curie temperature for each system size considered was first found (using the script shown in the previous exercise). These temperatures were then saved to a .dat file (whose contents are also showed in ''Table 8'', along with their corresponding lattice sizes. Finally, using the script presented [[Mod:DMS3053-11|here]], a graph of Curie temperature versus the inverse of the lattice length was plotted, according to the equation
::<math>T_{C, L} = \frac{A}{L} + T_{C,\infty}</math>, ''(eq. X)
where <math>T_{C, L}</math> is the Curie temperature for a lattice with length L and <math>T_{C,\infty}</math> is the Curie temperature for an infinite Ising lattice. Hence, it is clear that the desired Curie temperature must be the y-intercept of the graph shown in ''Figure 11'' (hence the use of extrapolation in the python script). Taking this extrapolated value gives a Curie temperature of 2.271.
</div>

Rep:Mod:DMS3053-10

2015-02-25T15:38:42Z

Ds3012: Created page with " from matplotlib import pylab as pl import numpy as np def extract_data_c(file): data_array = np.loadtxt(file) temps = data_array[:,0] heat..."

from matplotlib import pylab as pl
import numpy as np

def extract_data_c(file):
data_array = np.loadtxt(file)
temps = data_array[:,0]
heat_cap_per_spin = data_array[:,5]
return temps, heat_cap_per_spin

def plotdata(file):
file_data = extract_data_c(file)
T_min = 2.15
T_max = 2.55 # Min and Max altered to get good peak fit
T_range = np.linspace(T_min, T_max, 1000) #g= Generates 1000 evenly spaced points between T_min and T_max
selection = np.logical_and(file_data[0] > T_min, file_data[0] < T_max) # Selects rows of data for which both conditions are met
peak_T_values = file_data[0][selection] # Selects the appropriate temperature values
peak_C_values = file_data[1][selection] # Selects the appropriate heat capacity values
fit = np.polyfit(peak_T_values, peak_C_values, 3) # Fits a third order polynomial
fitted_C_values = np.polyval(fit, T_range) # Uses the fit object to generate the corresponding values of C
Cmax = np.max(fitted_C_values) # Locates the maximum in heat capacity
Tmax = T_range[fitted_C_values == Cmax] # Locates the corresponding value of temperature
pl.ylabel("Heat Capacity")
pl.xlabel("Temperature")
pl.ylim([0.0, 2.0])
pl.plot(file_data[0], file_data[1], T_range, fitted_C_values)
pl.legend(['Data', 'Polynomial fit'], loc='upper center', bbox_to_anchor=(0.5, 1.10),
ncol=5)
pl.show()
print(Cmax)
print(Tmax)

Rep:Mod:DMS3053

2015-02-25T15:35:21Z

Ds3012: /* Polynomial Fitting */

'''CMP Programming Experiment - Daniel Spencer, 00736964'''
<div style="text-align: justify">
==Introduction to the Ising Model==
===Minimum energy of the Ising Model===
Using the equation 
::<math>E= - \frac{1}{2} J \sum_i^N \sum_{j\ \in\ \mathrm{neighbours}\left(i\right)} s_i s_j</math> (''eq. 1'') 
the minimum energy of an Ising lattice of <math>D</math> dimensions, with <math>N</math> spins (where each
spin had a value of +1 or -1) and an interaction strength of <math>J</math> was considered. This was achieved first through a consideration of a one-dimensional system with five parallel spins (where the spins are parallel as this corresponds to the minimum energy arrangement of the system). Hence, the energy of this linear system was found to be 
::<math>E_\text{min,1D} = -5J </math>. 
For a linear, one-dimensional system, the number of neigbouring spins is two. The number of neighbours can be determined for two- and three- dimensional systems through a geometric consideration of their structure - the values are presented in ''Table 1''.
{| class="wikitable floatright" width=42%
|+ ''Table 1: Dimension numbers and number of neighbours''
! Number of Dimensions, D !! Number of Neighbours
|- style="text-align:center;"
| 1 || 2
|- style="text-align:center;"
| 2 || 4
|- style="text-align:center;"
| 3 || 6
|- style="text-align:center;"
| D || 2D
|}
These data indicate that the number of neighbours is twice the number of dimensions, for the dimensions considered here. This can be extrapolated to give the general number of neighbours as <math>2D</math>.

For the minimum energy of the system, where all spins are parallel, every combination <math>s_i s_j</math> has a value of 1. Notably, for each value of <math>i</math>, there will be <math>2D</math> neighbour interactions. Ergo, using ''eq. 1'', the general minimum energy can be found to be
::<math>E_\text{min,D} = -DNJ </math> (''eq. 2''). 
To check this equation, it can be applied to the two-dimensional Ising lattice with 25 spins - this gives a value of
::<math>E_\text{min,2D} = -50J </math>, 
which matches with the value predicted from first-principles.

For this D-dimensional system, the multiplicity (i.e. the number of ways of achieving the specified configuration of spins) must be equal to two, as either all of the spins could be aligned 'up' (+1) or 'down' (-1). Using this multiplicity, the entropy of the system can be calculated using the equation
::<math>S = k_B \ln\Omega</math>, (''eq. 3'') 
where Ω is the number of microstates (equal to the multiplicity in this case), which gives a value of <math>k_B \ln2 </math>, or 9.57 x 10-24 J K-1.

===Spin 'flipping'===

Using the Ising model, it is also possible to consider a change in state, reflected by a 'flipping' of the direction of one of the lattice spins. For this case, the energy (using ''eq. 1'') can be determined to be
::<math>E'= - \frac{1}{2} J (2DN - 4D - 4D) = 4DJ - DNJ</math>, (''eq. 4'') 
where the additional <math>4D</math> terms arise from the loss of 4D stabilising spin-aligned interactions and the gain of 4D destabilising spins anti-aligned interactions following spin 'flipping'. Using ''eq. 2'' and ''eq. 4'', the change in energy derived from this spin 'flip' can be calculated to be
::<math>\Delta E= 4DJ - DNJ + DNJ = 4DJ</math>. (''eq. 5'') 
For a system with three dimensions (D = 3) and 1000 spins (N = 1000), the system, using ''eq. 5'', was determined to increase in energy by <math>12 J</math>. Notably, this change in energy is independent of the number of spins in the system - it depends only on the number of dimensions and J.
[[File:ThirdYearCMPExpt-IsingSketch.png|300px|thumb|right|'' '''Figure 1''': Representation of Ising lattices in one (N=5), two (N=25), and three (N=125) dimensions. +1 and -1 spins are denoted by the red and blue cells respectively. Diagram taken from the lab script.'']]
A significant consideration with regards to the spin 'flipping' described here is the accompanying increase in entropy - the driving force for this process. For the scenario describing the change in direction of a single spin, the multiplicity of the system will be <math>2N</math> - this is a consequence of the system prior to 'flipping' having a multiplicity of two (all spins aligned 'up' or 'down'), where now, any one of the spins could flip, adding the factor of N to the multiplicity. Hence, the new entropy can be defined to be
::<math>S' = k_B \ln 2N</math>, (''eq. 6'') 
which allows the change in entropy to be calculated according to ''eq. 7''.
::<math>\Delta S = k_B \ln 2N - k_B \ln2 = k_B \ln N</math> (''eq. 7'') 
For the system described above (D = 3, N = 1000), the change in entropy associated with the spin 'flip' process is therefore <math>k_B ln 1000</math>, which is equal to 9.53 x 10-23 J K-1.

===Magnetisation===
{| class="wikitable floatright" width=42%
|+ ''Table 2: Ising lattices and magnetisations''
! Ising Lattice !! Magnetisation
|- style="text-align:center;"
| 1D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 2D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 3D at 0 K || 1000 or -1000
|}
''Figure 1'' shows three examples of Ising lattices, with one, two and three dimensions respectively. Using the equation for magnetisation (''eq. 8''), the magnetisations of these systems can be calculated to be those presented in ''Table 2''.
::<math>M= \sum_i s_i</math> (''eq. 8'') 
For the three-dimensional system at a temperature of 0 K, all of the spins must be aligned either 'up' or 'down', as the entropic increase associated with 'flipped' spins does not provide a driving force at absolute zero - the only factor to consider is that of the energy, which is a minimum when all of the spins are aligned. For this case, the magnetisation could be either 1000 or -1000, depending upon the direction of the spin alignment. From a consideration of the magnetisation values calculated here, it is evident that with all of the spins aligned, the (magnitude of the) magnetisation of the system is at a maximum.

==Calculating the energy and magnetisation==
===Modifying the files===
[[File:DMStest_output2.png|300px|thumb|right|'' '''Figure 2''': Output image from testing IsingLattice.py using Ilcheck.py'']]
In order to use Python to compute the energy and magnetisation for a given two-dimensional Ising lattice, the class IsingLattice was used, where energy() and magnetisation() functions were written to calculate their corresponding properties for a random numpy array of spins (generated using np.random.choice). For this aspect of the experiment, the value of J was assumed to be 1.0, working in reduced units. The Python script developed can be viewed [[Mod:DMS3053-1|here]], including annotations.

===Testing the files===
In order to test the script prepared thus far, the Ilcheck.py script was run, generating the image presented in ''Figure 2''. An examination of this output clearly indicates that the script provides accurate energies and magnetisations for the minimum and maximum energy configurations, along with for an intermediate, random arrangement. Hence, it can be concluded that at the current level, the Python script is functioning as required.

==Introduction to the Monte Carlo simulation==
===Average Energy and Magnetisation===
[[File:DMSILanim3.png|300px|thumb|right|'''''Figure 3''': Animation result from ILanim.py, showing the resting of the system in the minimum energy state'']]
[[File:DMSILanim_meta.png|300px|thumb|right|'''''Figure 4''': Animation result from ILanim.py, showing the resting of the system in a meta-stable state'']]

In order to consider the generalisability of the prepared script, it is important to analyse how the script will function for large systems, such as those with 100 spins in the spin array. As each of these spins can be either 'up' or 'down', each spin has two choices. Hence, the number of possible configurations for the system can be written as <math>2^{100}</math>, which has a value of 1.2677 x 1030.

If one considers the sampling of a single configuration to take 1 x 10-9 s, then it is clear that sampling all of these considerations would take a total of 1.2677 x 1021 s (also expressed as 4.017 x 1013 years). From this analysis, it is evident that the sampling of configurations was a significant consideration in the writing of a python script for this task.

In order to account for this, the technique of importance sampling was implemented, using the statistical Boltzmann distribution, <math>\exp(- \Delta E / k_B T)</math>. Note that as the energy computed using the energy() function is in units of kB, this factor is not included in the script.

===Modifying IsingLattice.py to Implement a Monte Carlo Cycle===
The python script developed at this stage is presented [[Mod:DMS3053-2|here]], accompanied by annotations to explain how the script functions.

===Simulating the Monte Carlo Cycles===
{| class="wikitable floatright" width=42%
|+ ''Table 3: statistics() output for animated system at global minimum configuration (Figure 3)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.70542501728
|- style="text-align:center;"
| <E2> || 3.13520970111
|- style="text-align:center;"
| <M> || -0.829971492744
|- style="text-align:center;"
| <M2> || 0.770986982766
|}
For cases where T < Tc, it would be expected that the system would have a spontaneous magnetisation. When T > Tc, the entropy will be the dominating factor, potentially resulting in the system having a magnetisation of zero.
{| class="wikitable floatright" width=42%
|+ ''Table 4: statistics() output for animated system at meta-stable configuration (Figure 4)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.35076450189
|- style="text-align:center;"
| <E2> || 1.89025801939
|- style="text-align:center;"
| <M> || -0.344104665826
|- style="text-align:center;"
| <M2> || 0.138855365306
|}
Using the presented script and the ILanim.py script, the Monte Carlo cycles can be simulated to view the results on the spin array as the process progresses. Here, the system under consideration was an 8 x 8 spin array, at a temperature of 0.5. ''Figure 3'' shows the typical outcome of the animation, with the system having reached the most stable, minimum energy arrangement. For the result presented here, the output of the statistics() function was that shown in ''Table 3''.

It was also observed that the system could locate a meta-stable state, with large regions of spin 'up' and 'down' spins. An example of such a result is presented in ''Figure 4'' (for which the output data from statistics() is presented in ''Table 4'').

==Accelerating the code==

In order to examine the efficiency of the python script developed thus far, the Iltimetrial.py script was utilised to investigate the time taken to perform 2000 Monte Carlo cycles. This script was modified to the version presented [[Mod:DMS3053-3|here]], which repeats the time measurement a defined number of times, then calculates the average time and the standard error in this average. For the Monte Carlo script prepared previously, the average time for 2000 Monte Carlo cycles was measured to be 5.475804 s and a standard error was calculated to be 0.008325 s, with 100 measurements made using the script.

Evidently, the current script is slow at conducting large numbers of Monte Carlo cycles and hence, a more efficient script was developed using the np.roll, np.multiply and np.sum functions - this is presented [[Mod:DMS3053-4|here]].

After this optimisation of the python script, the Iltimetrial.py script was re-run, giving an average time of 0.291467 s, with a standard error of 0.000156 s. Clearly, this optimised script is substantially faster than that developed previously (approximately 19 times faster).

==The effect of temperature==
===Correcting the averaging code===
As the equilibrium state of the system requires a number of Monte Carlo cycles to be reached, it is evident that the average energies and magnetisations are accounting for values for non-equilibrium arrangements - this was accounted for through a consideration of the number of cycles required to reach equilibrium. For this, the ILfinalframe.py script was used, giving the graphs shown in ''Table 5''. Here, each system was run for 150000 Monte Carlo cycles.
{| class="wikitable center" width=70%
|+ ''Table 5: Graphs of energy and magnetisation versus number of Monte Carlo cycles for different temperatures and system sizes''
! Temperature !! System Size !! Resulting Graphs !! Cycles for Equilibrium
|- style="text-align:center;"
| 0.5 || 4x4 || [[File:DMS0544.png|300px]] || 24
|- style="text-align:center;"
| 0.5 || 8x8 || [[File:DMS0588.png|300px]] || 392
|- style="text-align:center;"
| 0.5 || 16x16 || [[File:DMS051616.png|300px]] || 5549
|- style="text-align:center;"
| 1.0 || 2x2 || [[File:DMS1022.png|300px]] || (0)
|- style="text-align:center;"
| 1.0 || 4x4 || [[File:DMS1044.png|300px]] || 49
|- style="text-align:center;"
| 1.0 || 8x8 || [[File:DMS10882.png|300px]] || 590
|- style="text-align:center;"
| 1.0 || 16x16 || [[File:DMS101616.png|300px]] || ~6300
|- style="text-align:center;"
| 1.0 || 32x32 || [[File:DMS103232.png|300px]] || ~110000
|- style="text-align:center;"
| 2.0 || 4x4 || [[File:DMS2044.png|300px]] || -
|- style="text-align:center;"
| 2.0 || 8x8 || [[File:DMS2088.png|300px]] || -
|}
{| class="wikitable floatright" width=42%
|+ ''Table 6: Number of cycles to be ignored for each system size''
! System Size !! Number of cycles before averaging
|- style="text-align:center;"
| 2x2 || 0
|- style="text-align:center;"
| 4x4 || 100
|- style="text-align:center;"
| 8x8 || 1000
|- style="text-align:center;"
| 16x16 || 8000
|- style="text-align:center;"
| 32x32 || 120000
|}
Analysis of these graphs indicates that at higher temperatures, such as 2.0 (also observed at 1.5), large fluctuations in the energy and magnetisation are observed - these fluctuations are the reason that the average values of the properties must be taken. As the temperature is increased for systems of size 4x4, 8x8 and 16x16, it is clear that the number of cycles required in order to reach equilibrium increases. Hence, for the temperature range to be considered later (0.25 to 5.00), the required number of cycles was overestimated in order to ensure that all measurements were taken whilst the system was in equilibrium. The proposed numbers of cycles to be ignored for each system size are presented in ''Table 6''.

The python script developed up to this point was modified to account for these values by inclusion of a skip_region variable, which defines the number of cycles performed before energies and magnetisations contribute to the self.X values (before averaging occurs). The modified script is presented [[Mod:DMS3053-5|here]].

===Running over a range of temperatures===
[[File:DMS88dat.png|300px|thumb|right|'''''Figure 5''': Average energy and average magnetisation vs. temperature for 8x8 lattice, with error bars'']]
Using the python script modified in the previous exercise, the code can now be used to simulate the 8x8 system at a range of temperatures, using the ILtemperaturerange.py file (shown [[Mod:DMS3053-temprange|here]]). Here, the temperature range of 0.25 to 5.00 was used, with a separation of 0.25 between points, whilst the runtime was set to 10000 (neglecting the property values for the first 1000 cycles). Running this simulation produced the graphs in ''Figure 5'', where error bars computed using standard errors have also been included (these are small as a consequence of small standard errors). From the graph of average energy versus temperature, the phase transition can be observed - this occurs in the region with a gradient that is not close to zero. The data used here (temperature, average energies, average squared-energies, average magnetisations and average squared-magnetisations) was then saved as a numpy array in a new file, 8x8.dat.

==The effect of system size==
[[File:DMSLatticeSizeCombinedPlot.png|300px|thumb|right|'''''Figure 6''': Average energy and average magnetisation (per spins) vs. temperature for multiple lattice sizes'']]
The process conducted for the 8x8 lattice in the previous exercise was then repeated for lattices of sizes 2x2, 4x4, 16x16 and 32x32, with the data saved in .dat files. These files were then accessed, and the average energy and magnetisation data were plotted on one graph for all of the lattices sizes - this was achieved using the script presented [[Mod:DMS3053-6|here]]. The graphs produced in this manner are shown in ''Figure 6''.

A consideration of this graph suggests that in order to capture the long range fluctuations, a 16x16 lattice is necessary.

==Determining the heat capacity==
[[File:DMSheatcapacity2.png|300px|thumb|right|'''''Figure 7''': Heat capacity (per spin) versus temperature for different lattice sizes'']]
Using the .dat files previously produced, the heat capacity was calculated for each lattice size using the equation
::<math>C = \frac{\partial E}{\partial T} = \frac{\mathrm{Var}[E]}{k_B T^2}</math>, (''eq. 9'') 
where <math>\mathrm{Var}[E] = <E^2> - <E>^2 </math>. When implementing this, the kB term was neglected due to the energy values having units of kB. The script used for this purpose is provided [[DMS3053-7|here]]. The plot of heat capacity per spin versus temperature for all of the lattice sizes considered is presented in ''Figure 7''.

==Locating the Curie temperature==
===Comparison with C++ Data===
The data for the heat capacity generated using the python script prepared in this experiment was compared to that from longer C++ computations - graphs showing this comparison are presented in ''Table 7'' for a range of lattice sizes. The Python code used to produce these graphs is shown [[Mod:DMS3053-8|here]].

Considering these graphs, it is clear that, in general, there is a reasonable correlation between the Python and C++ data; however, some of the data, particularly that for high lattice sizes, shows that the Python computations have not always found the maximum of heat capacity. This correlation would be improved by making computations at the same range of temperatures, but with a smaller gap between the temperatures taken; however, this would substantially increase computation time.
{| class="wikitable center" width=70%
|+ ''Table 7: Graphs of heat capacity (per spin) versus temperature for C++ and Python data''
|- style="text-align:center;"
| [[File:DMS2x2c.png|300px]] || [[File:DMS4x4c.png|300px]] || [[File:DMS8x8c.png|300px]]
|- style="text-align:center;"
| 2x2 || 4x4 || 8x8
|- style="text-align:center;"
| [[File:DMS16x16c.png|300px]] || [[File:DMS32x32c.png|300px]]
|- style="text-align:center;"
| 16x16 || 32x32
|}

===Polynomial Fitting===
[[File:DMS8x8513.png|300px|thumb|right|'''''Figure 8''': Heat capacity (per spin) versus temperature for 8x8 system with two polynomial fits'']]
In order to make use of the C++ data in finding the Curie temperature for the Ising Lattices under consideration, polynomials were fit to the data - the script written for this purpose is shown [[Mod:DMS3053-9|here]]. For this fitting, it was found that a polynomial order of 5 was required to provide a good fit for the 2x2 data - this increased significantly as the lattice size increased. An example fit is shown for the 8x8 system in ''Figure 8'', where the polynomial fit is shown for orders 5 and 13. A consideration of this graph reveals that whilst a polynomial of order 5 may be appropriate for a 2x2 system, it is inadequate for the larger system of 8x8. Whilst an order of 13 substantially improves the polynomial fit, one must, in general, take care with 'overfitting' data.
[[File:Py8x8(13fit).png|300px|thumb|left|'''''Figure 9''': Heat capacity (per spin) versus temperature for Python data for 8x8 system with a 13th order polynomial fit'']]
For comparison, a 13th order polynomial was fitted to the 8x8 Python data previously computed - this is shown in ''Figure 9''. Here, it is evident that for this data, a higher order polynomial is required to obtain a fit comparable to that for the C++ data above.

===Fitting in a Particular Temperature Range===
[[File:DMS8x8peak(3).png|300px|thumb|right|'''''Figure 10''': Heat capacity (per spin) versus temperature for 8x8 system with peak polynomial fit'']]
As was observed in the previous exercise, large polynomial orders are required to fit the C++ data well across the whole temperature range. The python script was modified to that presented [[Mod:DMS3053-10|here]] (this script also contains the python code to compute the maximum heat capacity and temperature at which this occurs for the following exercise), which fits a polynomial only in the region of the maximum heat capacity for the system. An example of such fit is shown in ''Figure 10'' for the 8x8 system. Here, it should be noted that for all of the system sizes studied, a polynomial order of 3 was used - this is a clear improvement compared to the 13th order polynomials used previously.
</div>

Rep:Mod:DMS3053

2015-02-25T15:34:47Z

Ds3012: /* Locating the Curie temperature */

'''CMP Programming Experiment - Daniel Spencer, 00736964'''
<div style="text-align: justify">
==Introduction to the Ising Model==
===Minimum energy of the Ising Model===
Using the equation 
::<math>E= - \frac{1}{2} J \sum_i^N \sum_{j\ \in\ \mathrm{neighbours}\left(i\right)} s_i s_j</math> (''eq. 1'') 
the minimum energy of an Ising lattice of <math>D</math> dimensions, with <math>N</math> spins (where each
spin had a value of +1 or -1) and an interaction strength of <math>J</math> was considered. This was achieved first through a consideration of a one-dimensional system with five parallel spins (where the spins are parallel as this corresponds to the minimum energy arrangement of the system). Hence, the energy of this linear system was found to be 
::<math>E_\text{min,1D} = -5J </math>. 
For a linear, one-dimensional system, the number of neigbouring spins is two. The number of neighbours can be determined for two- and three- dimensional systems through a geometric consideration of their structure - the values are presented in ''Table 1''.
{| class="wikitable floatright" width=42%
|+ ''Table 1: Dimension numbers and number of neighbours''
! Number of Dimensions, D !! Number of Neighbours
|- style="text-align:center;"
| 1 || 2
|- style="text-align:center;"
| 2 || 4
|- style="text-align:center;"
| 3 || 6
|- style="text-align:center;"
| D || 2D
|}
These data indicate that the number of neighbours is twice the number of dimensions, for the dimensions considered here. This can be extrapolated to give the general number of neighbours as <math>2D</math>.

For the minimum energy of the system, where all spins are parallel, every combination <math>s_i s_j</math> has a value of 1. Notably, for each value of <math>i</math>, there will be <math>2D</math> neighbour interactions. Ergo, using ''eq. 1'', the general minimum energy can be found to be
::<math>E_\text{min,D} = -DNJ </math> (''eq. 2''). 
To check this equation, it can be applied to the two-dimensional Ising lattice with 25 spins - this gives a value of
::<math>E_\text{min,2D} = -50J </math>, 
which matches with the value predicted from first-principles.

For this D-dimensional system, the multiplicity (i.e. the number of ways of achieving the specified configuration of spins) must be equal to two, as either all of the spins could be aligned 'up' (+1) or 'down' (-1). Using this multiplicity, the entropy of the system can be calculated using the equation
::<math>S = k_B \ln\Omega</math>, (''eq. 3'') 
where Ω is the number of microstates (equal to the multiplicity in this case), which gives a value of <math>k_B \ln2 </math>, or 9.57 x 10-24 J K-1.

===Spin 'flipping'===

Using the Ising model, it is also possible to consider a change in state, reflected by a 'flipping' of the direction of one of the lattice spins. For this case, the energy (using ''eq. 1'') can be determined to be
::<math>E'= - \frac{1}{2} J (2DN - 4D - 4D) = 4DJ - DNJ</math>, (''eq. 4'') 
where the additional <math>4D</math> terms arise from the loss of 4D stabilising spin-aligned interactions and the gain of 4D destabilising spins anti-aligned interactions following spin 'flipping'. Using ''eq. 2'' and ''eq. 4'', the change in energy derived from this spin 'flip' can be calculated to be
::<math>\Delta E= 4DJ - DNJ + DNJ = 4DJ</math>. (''eq. 5'') 
For a system with three dimensions (D = 3) and 1000 spins (N = 1000), the system, using ''eq. 5'', was determined to increase in energy by <math>12 J</math>. Notably, this change in energy is independent of the number of spins in the system - it depends only on the number of dimensions and J.
[[File:ThirdYearCMPExpt-IsingSketch.png|300px|thumb|right|'' '''Figure 1''': Representation of Ising lattices in one (N=5), two (N=25), and three (N=125) dimensions. +1 and -1 spins are denoted by the red and blue cells respectively. Diagram taken from the lab script.'']]
A significant consideration with regards to the spin 'flipping' described here is the accompanying increase in entropy - the driving force for this process. For the scenario describing the change in direction of a single spin, the multiplicity of the system will be <math>2N</math> - this is a consequence of the system prior to 'flipping' having a multiplicity of two (all spins aligned 'up' or 'down'), where now, any one of the spins could flip, adding the factor of N to the multiplicity. Hence, the new entropy can be defined to be
::<math>S' = k_B \ln 2N</math>, (''eq. 6'') 
which allows the change in entropy to be calculated according to ''eq. 7''.
::<math>\Delta S = k_B \ln 2N - k_B \ln2 = k_B \ln N</math> (''eq. 7'') 
For the system described above (D = 3, N = 1000), the change in entropy associated with the spin 'flip' process is therefore <math>k_B ln 1000</math>, which is equal to 9.53 x 10-23 J K-1.

===Magnetisation===
{| class="wikitable floatright" width=42%
|+ ''Table 2: Ising lattices and magnetisations''
! Ising Lattice !! Magnetisation
|- style="text-align:center;"
| 1D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 2D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 3D at 0 K || 1000 or -1000
|}
''Figure 1'' shows three examples of Ising lattices, with one, two and three dimensions respectively. Using the equation for magnetisation (''eq. 8''), the magnetisations of these systems can be calculated to be those presented in ''Table 2''.
::<math>M= \sum_i s_i</math> (''eq. 8'') 
For the three-dimensional system at a temperature of 0 K, all of the spins must be aligned either 'up' or 'down', as the entropic increase associated with 'flipped' spins does not provide a driving force at absolute zero - the only factor to consider is that of the energy, which is a minimum when all of the spins are aligned. For this case, the magnetisation could be either 1000 or -1000, depending upon the direction of the spin alignment. From a consideration of the magnetisation values calculated here, it is evident that with all of the spins aligned, the (magnitude of the) magnetisation of the system is at a maximum.

==Calculating the energy and magnetisation==
===Modifying the files===
[[File:DMStest_output2.png|300px|thumb|right|'' '''Figure 2''': Output image from testing IsingLattice.py using Ilcheck.py'']]
In order to use Python to compute the energy and magnetisation for a given two-dimensional Ising lattice, the class IsingLattice was used, where energy() and magnetisation() functions were written to calculate their corresponding properties for a random numpy array of spins (generated using np.random.choice). For this aspect of the experiment, the value of J was assumed to be 1.0, working in reduced units. The Python script developed can be viewed [[Mod:DMS3053-1|here]], including annotations.

===Testing the files===
In order to test the script prepared thus far, the Ilcheck.py script was run, generating the image presented in ''Figure 2''. An examination of this output clearly indicates that the script provides accurate energies and magnetisations for the minimum and maximum energy configurations, along with for an intermediate, random arrangement. Hence, it can be concluded that at the current level, the Python script is functioning as required.

==Introduction to the Monte Carlo simulation==
===Average Energy and Magnetisation===
[[File:DMSILanim3.png|300px|thumb|right|'''''Figure 3''': Animation result from ILanim.py, showing the resting of the system in the minimum energy state'']]
[[File:DMSILanim_meta.png|300px|thumb|right|'''''Figure 4''': Animation result from ILanim.py, showing the resting of the system in a meta-stable state'']]

In order to consider the generalisability of the prepared script, it is important to analyse how the script will function for large systems, such as those with 100 spins in the spin array. As each of these spins can be either 'up' or 'down', each spin has two choices. Hence, the number of possible configurations for the system can be written as <math>2^{100}</math>, which has a value of 1.2677 x 1030.

If one considers the sampling of a single configuration to take 1 x 10-9 s, then it is clear that sampling all of these considerations would take a total of 1.2677 x 1021 s (also expressed as 4.017 x 1013 years). From this analysis, it is evident that the sampling of configurations was a significant consideration in the writing of a python script for this task.

In order to account for this, the technique of importance sampling was implemented, using the statistical Boltzmann distribution, <math>\exp(- \Delta E / k_B T)</math>. Note that as the energy computed using the energy() function is in units of kB, this factor is not included in the script.

===Modifying IsingLattice.py to Implement a Monte Carlo Cycle===
The python script developed at this stage is presented [[Mod:DMS3053-2|here]], accompanied by annotations to explain how the script functions.

===Simulating the Monte Carlo Cycles===
{| class="wikitable floatright" width=42%
|+ ''Table 3: statistics() output for animated system at global minimum configuration (Figure 3)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.70542501728
|- style="text-align:center;"
| <E2> || 3.13520970111
|- style="text-align:center;"
| <M> || -0.829971492744
|- style="text-align:center;"
| <M2> || 0.770986982766
|}
For cases where T < Tc, it would be expected that the system would have a spontaneous magnetisation. When T > Tc, the entropy will be the dominating factor, potentially resulting in the system having a magnetisation of zero.
{| class="wikitable floatright" width=42%
|+ ''Table 4: statistics() output for animated system at meta-stable configuration (Figure 4)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.35076450189
|- style="text-align:center;"
| <E2> || 1.89025801939
|- style="text-align:center;"
| <M> || -0.344104665826
|- style="text-align:center;"
| <M2> || 0.138855365306
|}
Using the presented script and the ILanim.py script, the Monte Carlo cycles can be simulated to view the results on the spin array as the process progresses. Here, the system under consideration was an 8 x 8 spin array, at a temperature of 0.5. ''Figure 3'' shows the typical outcome of the animation, with the system having reached the most stable, minimum energy arrangement. For the result presented here, the output of the statistics() function was that shown in ''Table 3''.

It was also observed that the system could locate a meta-stable state, with large regions of spin 'up' and 'down' spins. An example of such a result is presented in ''Figure 4'' (for which the output data from statistics() is presented in ''Table 4'').

==Accelerating the code==

In order to examine the efficiency of the python script developed thus far, the Iltimetrial.py script was utilised to investigate the time taken to perform 2000 Monte Carlo cycles. This script was modified to the version presented [[Mod:DMS3053-3|here]], which repeats the time measurement a defined number of times, then calculates the average time and the standard error in this average. For the Monte Carlo script prepared previously, the average time for 2000 Monte Carlo cycles was measured to be 5.475804 s and a standard error was calculated to be 0.008325 s, with 100 measurements made using the script.

Evidently, the current script is slow at conducting large numbers of Monte Carlo cycles and hence, a more efficient script was developed using the np.roll, np.multiply and np.sum functions - this is presented [[Mod:DMS3053-4|here]].

After this optimisation of the python script, the Iltimetrial.py script was re-run, giving an average time of 0.291467 s, with a standard error of 0.000156 s. Clearly, this optimised script is substantially faster than that developed previously (approximately 19 times faster).

==The effect of temperature==
===Correcting the averaging code===
As the equilibrium state of the system requires a number of Monte Carlo cycles to be reached, it is evident that the average energies and magnetisations are accounting for values for non-equilibrium arrangements - this was accounted for through a consideration of the number of cycles required to reach equilibrium. For this, the ILfinalframe.py script was used, giving the graphs shown in ''Table 5''. Here, each system was run for 150000 Monte Carlo cycles.
{| class="wikitable center" width=70%
|+ ''Table 5: Graphs of energy and magnetisation versus number of Monte Carlo cycles for different temperatures and system sizes''
! Temperature !! System Size !! Resulting Graphs !! Cycles for Equilibrium
|- style="text-align:center;"
| 0.5 || 4x4 || [[File:DMS0544.png|300px]] || 24
|- style="text-align:center;"
| 0.5 || 8x8 || [[File:DMS0588.png|300px]] || 392
|- style="text-align:center;"
| 0.5 || 16x16 || [[File:DMS051616.png|300px]] || 5549
|- style="text-align:center;"
| 1.0 || 2x2 || [[File:DMS1022.png|300px]] || (0)
|- style="text-align:center;"
| 1.0 || 4x4 || [[File:DMS1044.png|300px]] || 49
|- style="text-align:center;"
| 1.0 || 8x8 || [[File:DMS10882.png|300px]] || 590
|- style="text-align:center;"
| 1.0 || 16x16 || [[File:DMS101616.png|300px]] || ~6300
|- style="text-align:center;"
| 1.0 || 32x32 || [[File:DMS103232.png|300px]] || ~110000
|- style="text-align:center;"
| 2.0 || 4x4 || [[File:DMS2044.png|300px]] || -
|- style="text-align:center;"
| 2.0 || 8x8 || [[File:DMS2088.png|300px]] || -
|}
{| class="wikitable floatright" width=42%
|+ ''Table 6: Number of cycles to be ignored for each system size''
! System Size !! Number of cycles before averaging
|- style="text-align:center;"
| 2x2 || 0
|- style="text-align:center;"
| 4x4 || 100
|- style="text-align:center;"
| 8x8 || 1000
|- style="text-align:center;"
| 16x16 || 8000
|- style="text-align:center;"
| 32x32 || 120000
|}
Analysis of these graphs indicates that at higher temperatures, such as 2.0 (also observed at 1.5), large fluctuations in the energy and magnetisation are observed - these fluctuations are the reason that the average values of the properties must be taken. As the temperature is increased for systems of size 4x4, 8x8 and 16x16, it is clear that the number of cycles required in order to reach equilibrium increases. Hence, for the temperature range to be considered later (0.25 to 5.00), the required number of cycles was overestimated in order to ensure that all measurements were taken whilst the system was in equilibrium. The proposed numbers of cycles to be ignored for each system size are presented in ''Table 6''.

The python script developed up to this point was modified to account for these values by inclusion of a skip_region variable, which defines the number of cycles performed before energies and magnetisations contribute to the self.X values (before averaging occurs). The modified script is presented [[Mod:DMS3053-5|here]].

===Running over a range of temperatures===
[[File:DMS88dat.png|300px|thumb|right|'''''Figure 5''': Average energy and average magnetisation vs. temperature for 8x8 lattice, with error bars'']]
Using the python script modified in the previous exercise, the code can now be used to simulate the 8x8 system at a range of temperatures, using the ILtemperaturerange.py file (shown [[Mod:DMS3053-temprange|here]]). Here, the temperature range of 0.25 to 5.00 was used, with a separation of 0.25 between points, whilst the runtime was set to 10000 (neglecting the property values for the first 1000 cycles). Running this simulation produced the graphs in ''Figure 5'', where error bars computed using standard errors have also been included (these are small as a consequence of small standard errors). From the graph of average energy versus temperature, the phase transition can be observed - this occurs in the region with a gradient that is not close to zero. The data used here (temperature, average energies, average squared-energies, average magnetisations and average squared-magnetisations) was then saved as a numpy array in a new file, 8x8.dat.

==The effect of system size==
[[File:DMSLatticeSizeCombinedPlot.png|300px|thumb|right|'''''Figure 6''': Average energy and average magnetisation (per spins) vs. temperature for multiple lattice sizes'']]
The process conducted for the 8x8 lattice in the previous exercise was then repeated for lattices of sizes 2x2, 4x4, 16x16 and 32x32, with the data saved in .dat files. These files were then accessed, and the average energy and magnetisation data were plotted on one graph for all of the lattices sizes - this was achieved using the script presented [[Mod:DMS3053-6|here]]. The graphs produced in this manner are shown in ''Figure 6''.

A consideration of this graph suggests that in order to capture the long range fluctuations, a 16x16 lattice is necessary.

==Determining the heat capacity==
[[File:DMSheatcapacity2.png|300px|thumb|right|'''''Figure 7''': Heat capacity (per spin) versus temperature for different lattice sizes'']]
Using the .dat files previously produced, the heat capacity was calculated for each lattice size using the equation
::<math>C = \frac{\partial E}{\partial T} = \frac{\mathrm{Var}[E]}{k_B T^2}</math>, (''eq. 9'') 
where <math>\mathrm{Var}[E] = <E^2> - <E>^2 </math>. When implementing this, the kB term was neglected due to the energy values having units of kB. The script used for this purpose is provided [[DMS3053-7|here]]. The plot of heat capacity per spin versus temperature for all of the lattice sizes considered is presented in ''Figure 7''.

==Locating the Curie temperature==
===Comparison with C++ Data===
The data for the heat capacity generated using the python script prepared in this experiment was compared to that from longer C++ computations - graphs showing this comparison are presented in ''Table 7'' for a range of lattice sizes. The Python code used to produce these graphs is shown [[Mod:DMS3053-8|here]].

Considering these graphs, it is clear that, in general, there is a reasonable correlation between the Python and C++ data; however, some of the data, particularly that for high lattice sizes, shows that the Python computations have not always found the maximum of heat capacity. This correlation would be improved by making computations at the same range of temperatures, but with a smaller gap between the temperatures taken; however, this would substantially increase computation time.
{| class="wikitable center" width=70%
|+ ''Table 7: Graphs of heat capacity (per spin) versus temperature for C++ and Python data''
|- style="text-align:center;"
| [[File:DMS2x2c.png|300px]] || [[File:DMS4x4c.png|300px]] || [[File:DMS8x8c.png|300px]]
|- style="text-align:center;"
| 2x2 || 4x4 || 8x8
|- style="text-align:center;"
| [[File:DMS16x16c.png|300px]] || [[File:DMS32x32c.png|300px]]
|- style="text-align:center;"
| 16x16 || 32x32
|}

===Polynomial Fitting===
[[File:DMS8x8513.png|300px|thumb|right|'''''Figure 8''': Heat capacity (per spin) versus temperature for 8x8 system with two polynomial fits'']]
In order to make use of the C++ data in finding the Curie temperature for the Ising Lattices under consideration, polynomials were fit to the data - the script written for this purpose is shown [[Mod:DMS3053-9|here]]. For this fitting, it was found that a polynomial order of 5 was required to provide a good fit for the 2x2 data - this increased significantly as the lattice size increased. An example fit is shown for the 8x8 system in ''Figure 8'', where the polynomial fit is shown for orders 5 and 13. A consideration of this graph reveals that whilst a polynomial of order 5 may be appropriate for a 2x2 system, it is inadequate for the larger system of 8x8. Whilst an order of 13 substantially improves the polynomial fit, one must, in general, take care with 'overfitting' data.
[[File:Py8x8(13fit).png|300px|thumb|right|'''''Figure 9''': Heat capacity (per spin) versus temperature for Python data for 8x8 system with a 13th order polynomial fit'']]
For comparison, a 13th order polynomial was fitted to the 8x8 Python data previously computed - this is shown in ''Figure 9''. Here, it is evident that for this data, a higher order polynomial is required to obtain a fit comparable to that for the C++ data above.

===Fitting in a Particular Temperature Range===
[[File:DMS8x8peak(3).png|300px|thumb|right|'''''Figure 10''': Heat capacity (per spin) versus temperature for 8x8 system with peak polynomial fit'']]
As was observed in the previous exercise, large polynomial orders are required to fit the C++ data well across the whole temperature range. The python script was modified to that presented [[Mod:DMS3053-10|here]] (this script also contains the python code to compute the maximum heat capacity and temperature at which this occurs for the following exercise), which fits a polynomial only in the region of the maximum heat capacity for the system. An example of such fit is shown in ''Figure 10'' for the 8x8 system. Here, it should be noted that for all of the system sizes studied, a polynomial order of 3 was used - this is a clear improvement compared to the 13th order polynomials used previously.
</div>

File:DMS8x8peak(3).png

2015-02-25T15:34:17Z

Ds3012:

Rep:Mod:DMS3053-8

2015-02-25T13:42:55Z

Ds3012: Created page with " from matplotlib import pylab as pl import numpy as np def extract_data_c(file): data_array = np.loadtxt(file) temps = data_array[:,0] heat..."

from matplotlib import pylab as pl
import numpy as np

def extract_data_c(file):
data_array = np.loadtxt(file)
temps = data_array[:,0]
heat_cap_per_spin = data_array[:,5]
return temps, heat_cap_per_spin

def extract_data(file):
data_array = np.loadtxt(file)
list = file.split("x") # Splits the file name to find the lattice size
spin = int(list[0])
spins = spin*spin # Provided that the lattice in use is square
temps = data_array[:,0]
energies = data_array[:,1]
squared_energies = data_array[:,2]
variance = squared_energies - (energies*energies)
heat_capacity = variance / (temps*temps)
heat_cap_per_spin = heat_capacity / spins
return temps, heat_cap_per_spin

def plotdata(fileC, filePY):
fileC_data = extract_data_c(fileC)
filePY_data = extract_data(filePY)
pl.ylabel("Heat Capacity")
pl.xlabel("Temperature")
pl.ylim([0.0, 2.0])
pl.plot(fileC_data[0], fileC_data[1], filePY_data[0], filePY_data[1])
pl.legend(['C++', 'Python'], loc='upper center', bbox_to_anchor=(0.5, 1.10),
ncol=5)
pl.show()

Rep:Mod:DMS3053

2015-02-25T13:40:52Z

Ds3012: /* Comparison with C++ Data */

'''CMP Programming Experiment - Daniel Spencer, 00736964'''
<div style="text-align: justify">
==Introduction to the Ising Model==
===Minimum energy of the Ising Model===
Using the equation 
::<math>E= - \frac{1}{2} J \sum_i^N \sum_{j\ \in\ \mathrm{neighbours}\left(i\right)} s_i s_j</math> (''eq. 1'') 
the minimum energy of an Ising lattice of <math>D</math> dimensions, with <math>N</math> spins (where each
spin had a value of +1 or -1) and an interaction strength of <math>J</math> was considered. This was achieved first through a consideration of a one-dimensional system with five parallel spins (where the spins are parallel as this corresponds to the minimum energy arrangement of the system). Hence, the energy of this linear system was found to be 
::<math>E_\text{min,1D} = -5J </math>. 
For a linear, one-dimensional system, the number of neigbouring spins is two. The number of neighbours can be determined for two- and three- dimensional systems through a geometric consideration of their structure - the values are presented in ''Table 1''.
{| class="wikitable floatright" width=42%
|+ ''Table 1: Dimension numbers and number of neighbours''
! Number of Dimensions, D !! Number of Neighbours
|- style="text-align:center;"
| 1 || 2
|- style="text-align:center;"
| 2 || 4
|- style="text-align:center;"
| 3 || 6
|- style="text-align:center;"
| D || 2D
|}
These data indicate that the number of neighbours is twice the number of dimensions, for the dimensions considered here. This can be extrapolated to give the general number of neighbours as <math>2D</math>.

For the minimum energy of the system, where all spins are parallel, every combination <math>s_i s_j</math> has a value of 1. Notably, for each value of <math>i</math>, there will be <math>2D</math> neighbour interactions. Ergo, using ''eq. 1'', the general minimum energy can be found to be
::<math>E_\text{min,D} = -DNJ </math> (''eq. 2''). 
To check this equation, it can be applied to the two-dimensional Ising lattice with 25 spins - this gives a value of
::<math>E_\text{min,2D} = -50J </math>, 
which matches with the value predicted from first-principles.

For this D-dimensional system, the multiplicity (i.e. the number of ways of achieving the specified configuration of spins) must be equal to two, as either all of the spins could be aligned 'up' (+1) or 'down' (-1). Using this multiplicity, the entropy of the system can be calculated using the equation
::<math>S = k_B \ln\Omega</math>, (''eq. 3'') 
where Ω is the number of microstates (equal to the multiplicity in this case), which gives a value of <math>k_B \ln2 </math>, or 9.57 x 10-24 J K-1.

===Spin 'flipping'===

Using the Ising model, it is also possible to consider a change in state, reflected by a 'flipping' of the direction of one of the lattice spins. For this case, the energy (using ''eq. 1'') can be determined to be
::<math>E'= - \frac{1}{2} J (2DN - 4D - 4D) = 4DJ - DNJ</math>, (''eq. 4'') 
where the additional <math>4D</math> terms arise from the loss of 4D stabilising spin-aligned interactions and the gain of 4D destabilising spins anti-aligned interactions following spin 'flipping'. Using ''eq. 2'' and ''eq. 4'', the change in energy derived from this spin 'flip' can be calculated to be
::<math>\Delta E= 4DJ - DNJ + DNJ = 4DJ</math>. (''eq. 5'') 
For a system with three dimensions (D = 3) and 1000 spins (N = 1000), the system, using ''eq. 5'', was determined to increase in energy by <math>12 J</math>. Notably, this change in energy is independent of the number of spins in the system - it depends only on the number of dimensions and J.
[[File:ThirdYearCMPExpt-IsingSketch.png|300px|thumb|right|'' '''Figure 1''': Representation of Ising lattices in one (N=5), two (N=25), and three (N=125) dimensions. +1 and -1 spins are denoted by the red and blue cells respectively. Diagram taken from the lab script.'']]
A significant consideration with regards to the spin 'flipping' described here is the accompanying increase in entropy - the driving force for this process. For the scenario describing the change in direction of a single spin, the multiplicity of the system will be <math>2N</math> - this is a consequence of the system prior to 'flipping' having a multiplicity of two (all spins aligned 'up' or 'down'), where now, any one of the spins could flip, adding the factor of N to the multiplicity. Hence, the new entropy can be defined to be
::<math>S' = k_B \ln 2N</math>, (''eq. 6'') 
which allows the change in entropy to be calculated according to ''eq. 7''.
::<math>\Delta S = k_B \ln 2N - k_B \ln2 = k_B \ln N</math> (''eq. 7'') 
For the system described above (D = 3, N = 1000), the change in entropy associated with the spin 'flip' process is therefore <math>k_B ln 1000</math>, which is equal to 9.53 x 10-23 J K-1.

===Magnetisation===
{| class="wikitable floatright" width=42%
|+ ''Table 2: Ising lattices and magnetisations''
! Ising Lattice !! Magnetisation
|- style="text-align:center;"
| 1D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 2D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 3D at 0 K || 1000 or -1000
|}
''Figure 1'' shows three examples of Ising lattices, with one, two and three dimensions respectively. Using the equation for magnetisation (''eq. 8''), the magnetisations of these systems can be calculated to be those presented in ''Table 2''.
::<math>M= \sum_i s_i</math> (''eq. 8'') 
For the three-dimensional system at a temperature of 0 K, all of the spins must be aligned either 'up' or 'down', as the entropic increase associated with 'flipped' spins does not provide a driving force at absolute zero - the only factor to consider is that of the energy, which is a minimum when all of the spins are aligned. For this case, the magnetisation could be either 1000 or -1000, depending upon the direction of the spin alignment. From a consideration of the magnetisation values calculated here, it is evident that with all of the spins aligned, the (magnitude of the) magnetisation of the system is at a maximum.

==Calculating the energy and magnetisation==
===Modifying the files===
[[File:DMStest_output2.png|300px|thumb|right|'' '''Figure 2''': Output image from testing IsingLattice.py using Ilcheck.py'']]
In order to use Python to compute the energy and magnetisation for a given two-dimensional Ising lattice, the class IsingLattice was used, where energy() and magnetisation() functions were written to calculate their corresponding properties for a random numpy array of spins (generated using np.random.choice). For this aspect of the experiment, the value of J was assumed to be 1.0, working in reduced units. The Python script developed can be viewed [[Mod:DMS3053-1|here]], including annotations.

===Testing the files===
In order to test the script prepared thus far, the Ilcheck.py script was run, generating the image presented in ''Figure 2''. An examination of this output clearly indicates that the script provides accurate energies and magnetisations for the minimum and maximum energy configurations, along with for an intermediate, random arrangement. Hence, it can be concluded that at the current level, the Python script is functioning as required.

==Introduction to the Monte Carlo simulation==
===Average Energy and Magnetisation===
[[File:DMSILanim3.png|300px|thumb|right|'''''Figure 3''': Animation result from ILanim.py, showing the resting of the system in the minimum energy state'']]
[[File:DMSILanim_meta.png|300px|thumb|right|'''''Figure 4''': Animation result from ILanim.py, showing the resting of the system in a meta-stable state'']]

In order to consider the generalisability of the prepared script, it is important to analyse how the script will function for large systems, such as those with 100 spins in the spin array. As each of these spins can be either 'up' or 'down', each spin has two choices. Hence, the number of possible configurations for the system can be written as <math>2^{100}</math>, which has a value of 1.2677 x 1030.

If one considers the sampling of a single configuration to take 1 x 10-9 s, then it is clear that sampling all of these considerations would take a total of 1.2677 x 1021 s (also expressed as 4.017 x 1013 years). From this analysis, it is evident that the sampling of configurations was a significant consideration in the writing of a python script for this task.

In order to account for this, the technique of importance sampling was implemented, using the statistical Boltzmann distribution, <math>\exp(- \Delta E / k_B T)</math>. Note that as the energy computed using the energy() function is in units of kB, this factor is not included in the script.

===Modifying IsingLattice.py to Implement a Monte Carlo Cycle===
The python script developed at this stage is presented [[Mod:DMS3053-2|here]], accompanied by annotations to explain how the script functions.

===Simulating the Monte Carlo Cycles===
{| class="wikitable floatright" width=42%
|+ ''Table 3: statistics() output for animated system at global minimum configuration (Figure 3)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.70542501728
|- style="text-align:center;"
| <E2> || 3.13520970111
|- style="text-align:center;"
| <M> || -0.829971492744
|- style="text-align:center;"
| <M2> || 0.770986982766
|}
For cases where T < Tc, it would be expected that the system would have a spontaneous magnetisation. When T > Tc, the entropy will be the dominating factor, potentially resulting in the system having a magnetisation of zero.
{| class="wikitable floatright" width=42%
|+ ''Table 4: statistics() output for animated system at meta-stable configuration (Figure 4)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.35076450189
|- style="text-align:center;"
| <E2> || 1.89025801939
|- style="text-align:center;"
| <M> || -0.344104665826
|- style="text-align:center;"
| <M2> || 0.138855365306
|}
Using the presented script and the ILanim.py script, the Monte Carlo cycles can be simulated to view the results on the spin array as the process progresses. Here, the system under consideration was an 8 x 8 spin array, at a temperature of 0.5. ''Figure 3'' shows the typical outcome of the animation, with the system having reached the most stable, minimum energy arrangement. For the result presented here, the output of the statistics() function was that shown in ''Table 3''.

It was also observed that the system could locate a meta-stable state, with large regions of spin 'up' and 'down' spins. An example of such a result is presented in ''Figure 4'' (for which the output data from statistics() is presented in ''Table 4'').

==Accelerating the code==

In order to examine the efficiency of the python script developed thus far, the Iltimetrial.py script was utilised to investigate the time taken to perform 2000 Monte Carlo cycles. This script was modified to the version presented [[Mod:DMS3053-3|here]], which repeats the time measurement a defined number of times, then calculates the average time and the standard error in this average. For the Monte Carlo script prepared previously, the average time for 2000 Monte Carlo cycles was measured to be 5.475804 s and a standard error was calculated to be 0.008325 s, with 100 measurements made using the script.

Evidently, the current script is slow at conducting large numbers of Monte Carlo cycles and hence, a more efficient script was developed using the np.roll, np.multiply and np.sum functions - this is presented [[Mod:DMS3053-4|here]].

After this optimisation of the python script, the Iltimetrial.py script was re-run, giving an average time of 0.291467 s, with a standard error of 0.000156 s. Clearly, this optimised script is substantially faster than that developed previously (approximately 19 times faster).

==The effect of temperature==
===Correcting the averaging code===
As the equilibrium state of the system requires a number of Monte Carlo cycles to be reached, it is evident that the average energies and magnetisations are accounting for values for non-equilibrium arrangements - this was accounted for through a consideration of the number of cycles required to reach equilibrium. For this, the ILfinalframe.py script was used, giving the graphs shown in ''Table 5''. Here, each system was run for 150000 Monte Carlo cycles.
{| class="wikitable center" width=70%
|+ ''Table 5: Graphs of energy and magnetisation versus number of Monte Carlo cycles for different temperatures and system sizes''
! Temperature !! System Size !! Resulting Graphs !! Cycles for Equilibrium
|- style="text-align:center;"
| 0.5 || 4x4 || [[File:DMS0544.png|300px]] || 24
|- style="text-align:center;"
| 0.5 || 8x8 || [[File:DMS0588.png|300px]] || 392
|- style="text-align:center;"
| 0.5 || 16x16 || [[File:DMS051616.png|300px]] || 5549
|- style="text-align:center;"
| 1.0 || 2x2 || [[File:DMS1022.png|300px]] || (0)
|- style="text-align:center;"
| 1.0 || 4x4 || [[File:DMS1044.png|300px]] || 49
|- style="text-align:center;"
| 1.0 || 8x8 || [[File:DMS10882.png|300px]] || 590
|- style="text-align:center;"
| 1.0 || 16x16 || [[File:DMS101616.png|300px]] || ~6300
|- style="text-align:center;"
| 1.0 || 32x32 || [[File:DMS103232.png|300px]] || ~110000
|- style="text-align:center;"
| 2.0 || 4x4 || [[File:DMS2044.png|300px]] || -
|- style="text-align:center;"
| 2.0 || 8x8 || [[File:DMS2088.png|300px]] || -
|}
{| class="wikitable floatright" width=42%
|+ ''Table 6: Number of cycles to be ignored for each system size''
! System Size !! Number of cycles before averaging
|- style="text-align:center;"
| 2x2 || 0
|- style="text-align:center;"
| 4x4 || 100
|- style="text-align:center;"
| 8x8 || 1000
|- style="text-align:center;"
| 16x16 || 8000
|- style="text-align:center;"
| 32x32 || 120000
|}
Analysis of these graphs indicates that at higher temperatures, such as 2.0 (also observed at 1.5), large fluctuations in the energy and magnetisation are observed - these fluctuations are the reason that the average values of the properties must be taken. As the temperature is increased for systems of size 4x4, 8x8 and 16x16, it is clear that the number of cycles required in order to reach equilibrium increases. Hence, for the temperature range to be considered later (0.25 to 5.00), the required number of cycles was overestimated in order to ensure that all measurements were taken whilst the system was in equilibrium. The proposed numbers of cycles to be ignored for each system size are presented in ''Table 6''.

The python script developed up to this point was modified to account for these values by inclusion of a skip_region variable, which defines the number of cycles performed before energies and magnetisations contribute to the self.X values (before averaging occurs). The modified script is presented [[Mod:DMS3053-5|here]].

===Running over a range of temperatures===
[[File:DMS88dat.png|300px|thumb|right|'''''Figure 5''': Average energy and average magnetisation vs. temperature for 8x8 lattice, with error bars'']]
Using the python script modified in the previous exercise, the code can now be used to simulate the 8x8 system at a range of temperatures, using the ILtemperaturerange.py file (shown [[Mod:DMS3053-temprange|here]]). Here, the temperature range of 0.25 to 5.00 was used, with a separation of 0.25 between points, whilst the runtime was set to 10000 (neglecting the property values for the first 1000 cycles). Running this simulation produced the graphs in ''Figure 5'', where error bars computed using standard errors have also been included (these are small as a consequence of small standard errors). From the graph of average energy versus temperature, the phase transition can be observed - this occurs in the region with a gradient that is not close to zero. The data used here (temperature, average energies, average squared-energies, average magnetisations and average squared-magnetisations) was then saved as a numpy array in a new file, 8x8.dat.

==The effect of system size==
[[File:DMSLatticeSizeCombinedPlot.png|300px|thumb|right|'''''Figure 6''': Average energy and average magnetisation (per spins) vs. temperature for multiple lattice sizes'']]
The process conducted for the 8x8 lattice in the previous exercise was then repeated for lattices of sizes 2x2, 4x4, 16x16 and 32x32, with the data saved in .dat files. These files were then accessed, and the average energy and magnetisation data were plotted on one graph for all of the lattices sizes - this was achieved using the script presented [[Mod:DMS3053-6|here]]. The graphs produced in this manner are shown in ''Figure 6''.

A consideration of this graph suggests that in order to capture the long range fluctuations, a 16x16 lattice is necessary.

==Determining the heat capacity==
[[File:DMSheatcapacity2.png|300px|thumb|right|'''''Figure 7''': Heat capacity (per spin) versus temperature for different lattice sizes'']]
Using the .dat files previously produced, the heat capacity was calculated for each lattice size using the equation
::<math>C = \frac{\partial E}{\partial T} = \frac{\mathrm{Var}[E]}{k_B T^2}</math>, (''eq. 9'') 
where <math>\mathrm{Var}[E] = <E^2> - <E>^2 </math>. When implementing this, the kB term was neglected due to the energy values having units of kB. The script used for this purpose is provided [[DMS3053-7|here]]. The plot of heat capacity per spin versus temperature for all of the lattice sizes considered is presented in ''Figure 7''.

==Locating the Curie temperature==
===Comparison with C++ Data===
The data for the heat capacity generated using the python script prepared in this experiment was compared to that from longer C++ computations - graphs showing this comparison are presented in ''Table 7'' for a range of lattice sizes. The Python code used to produce these graphs is shown [[Mod:DMS3053-8|here]].

Considering these graphs, it is clear that, in general, there is a reasonable correlation between the Python and C++ data; however, some of the data, particularly that for high lattice sizes, shows that the Python computations have not always found the maximum of heat capacity. This correlation would be improved by making computations at the same range of temperatures, but with a smaller gap between the temperatures taken; however, this would substantially increase computation time.
{| class="wikitable center" width=70%
|+ ''Table 7: Graphs of heat capacity (per spin) versus temperature for C++ and Python data''
|- style="text-align:center;"
| [[File:DMS2x2c.png|300px]] || [[File:DMS4x4c.png|300px]] || [[File:DMS8x8c.png|300px]]
|- style="text-align:center;"
| 2x2 || 4x4 || 8x8
|- style="text-align:center;"
| [[File:DMS16x16c.png|300px]] || [[File:DMS32x32c.png|300px]]
|- style="text-align:center;"
| 16x16 || 32x32
|}

===Polynomial Fitting===
[[File:DMS8x8513.png|300px|thumb|right|'''''Figure 8''': Heat capacity (per spin) versus temperature for 8x8 system with two polynomial fits'']]
In order to make use of the C++ data in finding the Curie temperature for the Ising Lattices under consideration, polynomials were fit to the data - the script written for this purpose is shown [[Mod:DMS3053-9|here]]. For this fitting, it was found that a polynomial order of 5 was required to provide a good fit for the 2x2 data - this increased significantly as the lattice size increased. An example fit is shown for the 8x8 system in ''Figure 8'', where the polynomial fit is shown for orders 5 and 13. A consideration of this graph reveals that whilst a polynomial of order 5 may be appropriate for a 2x2 system, it is inadequate for the larger system of 8x8. Whilst an order of 13 substantially improves the polynomial fit, one must, in general, take care with 'overfitting' data.
[[File:Py8x8(13fit).png|300px|thumb|right|'''''Figure 9''': Heat capacity (per spin) versus temperature for Python data for 8x8 system with a 13th order polynomial fit'']]
For comparison, a 13th order polynomial was fitted to the 8x8 Python data previously computed - this is shown in ''Figure 9''. Here, it is evident that for this data, a higher order polynomial is required to obtain a fit comparable to that for the C++ data above.

</div>

Rep:Mod:DMS3053

2015-02-24T16:06:50Z

Ds3012: /* Polynomial Fitting */

'''CMP Programming Experiment - Daniel Spencer, 00736964'''
<div style="text-align: justify">
==Introduction to the Ising Model==
===Minimum energy of the Ising Model===
Using the equation 
::<math>E= - \frac{1}{2} J \sum_i^N \sum_{j\ \in\ \mathrm{neighbours}\left(i\right)} s_i s_j</math> (''eq. 1'') 
the minimum energy of an Ising lattice of <math>D</math> dimensions, with <math>N</math> spins (where each
spin had a value of +1 or -1) and an interaction strength of <math>J</math> was considered. This was achieved first through a consideration of a one-dimensional system with five parallel spins (where the spins are parallel as this corresponds to the minimum energy arrangement of the system). Hence, the energy of this linear system was found to be 
::<math>E_\text{min,1D} = -5J </math>. 
For a linear, one-dimensional system, the number of neigbouring spins is two. The number of neighbours can be determined for two- and three- dimensional systems through a geometric consideration of their structure - the values are presented in ''Table 1''.
{| class="wikitable floatright" width=42%
|+ ''Table 1: Dimension numbers and number of neighbours''
! Number of Dimensions, D !! Number of Neighbours
|- style="text-align:center;"
| 1 || 2
|- style="text-align:center;"
| 2 || 4
|- style="text-align:center;"
| 3 || 6
|- style="text-align:center;"
| D || 2D
|}
These data indicate that the number of neighbours is twice the number of dimensions, for the dimensions considered here. This can be extrapolated to give the general number of neighbours as <math>2D</math>.

For the minimum energy of the system, where all spins are parallel, every combination <math>s_i s_j</math> has a value of 1. Notably, for each value of <math>i</math>, there will be <math>2D</math> neighbour interactions. Ergo, using ''eq. 1'', the general minimum energy can be found to be
::<math>E_\text{min,D} = -DNJ </math> (''eq. 2''). 
To check this equation, it can be applied to the two-dimensional Ising lattice with 25 spins - this gives a value of
::<math>E_\text{min,2D} = -50J </math>, 
which matches with the value predicted from first-principles.

For this D-dimensional system, the multiplicity (i.e. the number of ways of achieving the specified configuration of spins) must be equal to two, as either all of the spins could be aligned 'up' (+1) or 'down' (-1). Using this multiplicity, the entropy of the system can be calculated using the equation
::<math>S = k_B \ln\Omega</math>, (''eq. 3'') 
where Ω is the number of microstates (equal to the multiplicity in this case), which gives a value of <math>k_B \ln2 </math>, or 9.57 x 10-24 J K-1.

===Spin 'flipping'===

Using the Ising model, it is also possible to consider a change in state, reflected by a 'flipping' of the direction of one of the lattice spins. For this case, the energy (using ''eq. 1'') can be determined to be
::<math>E'= - \frac{1}{2} J (2DN - 4D - 4D) = 4DJ - DNJ</math>, (''eq. 4'') 
where the additional <math>4D</math> terms arise from the loss of 4D stabilising spin-aligned interactions and the gain of 4D destabilising spins anti-aligned interactions following spin 'flipping'. Using ''eq. 2'' and ''eq. 4'', the change in energy derived from this spin 'flip' can be calculated to be
::<math>\Delta E= 4DJ - DNJ + DNJ = 4DJ</math>. (''eq. 5'') 
For a system with three dimensions (D = 3) and 1000 spins (N = 1000), the system, using ''eq. 5'', was determined to increase in energy by <math>12 J</math>. Notably, this change in energy is independent of the number of spins in the system - it depends only on the number of dimensions and J.
[[File:ThirdYearCMPExpt-IsingSketch.png|300px|thumb|right|'' '''Figure 1''': Representation of Ising lattices in one (N=5), two (N=25), and three (N=125) dimensions. +1 and -1 spins are denoted by the red and blue cells respectively. Diagram taken from the lab script.'']]
A significant consideration with regards to the spin 'flipping' described here is the accompanying increase in entropy - the driving force for this process. For the scenario describing the change in direction of a single spin, the multiplicity of the system will be <math>2N</math> - this is a consequence of the system prior to 'flipping' having a multiplicity of two (all spins aligned 'up' or 'down'), where now, any one of the spins could flip, adding the factor of N to the multiplicity. Hence, the new entropy can be defined to be
::<math>S' = k_B \ln 2N</math>, (''eq. 6'') 
which allows the change in entropy to be calculated according to ''eq. 7''.
::<math>\Delta S = k_B \ln 2N - k_B \ln2 = k_B \ln N</math> (''eq. 7'') 
For the system described above (D = 3, N = 1000), the change in entropy associated with the spin 'flip' process is therefore <math>k_B ln 1000</math>, which is equal to 9.53 x 10-23 J K-1.

===Magnetisation===
{| class="wikitable floatright" width=42%
|+ ''Table 2: Ising lattices and magnetisations''
! Ising Lattice !! Magnetisation
|- style="text-align:center;"
| 1D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 2D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 3D at 0 K || 1000 or -1000
|}
''Figure 1'' shows three examples of Ising lattices, with one, two and three dimensions respectively. Using the equation for magnetisation (''eq. 8''), the magnetisations of these systems can be calculated to be those presented in ''Table 2''.
::<math>M= \sum_i s_i</math> (''eq. 8'') 
For the three-dimensional system at a temperature of 0 K, all of the spins must be aligned either 'up' or 'down', as the entropic increase associated with 'flipped' spins does not provide a driving force at absolute zero - the only factor to consider is that of the energy, which is a minimum when all of the spins are aligned. For this case, the magnetisation could be either 1000 or -1000, depending upon the direction of the spin alignment. From a consideration of the magnetisation values calculated here, it is evident that with all of the spins aligned, the (magnitude of the) magnetisation of the system is at a maximum.

==Calculating the energy and magnetisation==
===Modifying the files===
[[File:DMStest_output2.png|300px|thumb|right|'' '''Figure 2''': Output image from testing IsingLattice.py using Ilcheck.py'']]
In order to use Python to compute the energy and magnetisation for a given two-dimensional Ising lattice, the class IsingLattice was used, where energy() and magnetisation() functions were written to calculate their corresponding properties for a random numpy array of spins (generated using np.random.choice). For this aspect of the experiment, the value of J was assumed to be 1.0, working in reduced units. The Python script developed can be viewed [[Mod:DMS3053-1|here]], including annotations.

===Testing the files===
In order to test the script prepared thus far, the Ilcheck.py script was run, generating the image presented in ''Figure 2''. An examination of this output clearly indicates that the script provides accurate energies and magnetisations for the minimum and maximum energy configurations, along with for an intermediate, random arrangement. Hence, it can be concluded that at the current level, the Python script is functioning as required.

==Introduction to the Monte Carlo simulation==
===Average Energy and Magnetisation===
[[File:DMSILanim3.png|300px|thumb|right|'''''Figure 3''': Animation result from ILanim.py, showing the resting of the system in the minimum energy state'']]
[[File:DMSILanim_meta.png|300px|thumb|right|'''''Figure 4''': Animation result from ILanim.py, showing the resting of the system in a meta-stable state'']]

In order to consider the generalisability of the prepared script, it is important to analyse how the script will function for large systems, such as those with 100 spins in the spin array. As each of these spins can be either 'up' or 'down', each spin has two choices. Hence, the number of possible configurations for the system can be written as <math>2^{100}</math>, which has a value of 1.2677 x 1030.

If one considers the sampling of a single configuration to take 1 x 10-9 s, then it is clear that sampling all of these considerations would take a total of 1.2677 x 1021 s (also expressed as 4.017 x 1013 years). From this analysis, it is evident that the sampling of configurations was a significant consideration in the writing of a python script for this task.

In order to account for this, the technique of importance sampling was implemented, using the statistical Boltzmann distribution, <math>\exp(- \Delta E / k_B T)</math>. Note that as the energy computed using the energy() function is in units of kB, this factor is not included in the script.

===Modifying IsingLattice.py to Implement a Monte Carlo Cycle===
The python script developed at this stage is presented [[Mod:DMS3053-2|here]], accompanied by annotations to explain how the script functions.

===Simulating the Monte Carlo Cycles===
{| class="wikitable floatright" width=42%
|+ ''Table 3: statistics() output for animated system at global minimum configuration (Figure 3)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.70542501728
|- style="text-align:center;"
| <E2> || 3.13520970111
|- style="text-align:center;"
| <M> || -0.829971492744
|- style="text-align:center;"
| <M2> || 0.770986982766
|}
For cases where T < Tc, it would be expected that the system would have a spontaneous magnetisation. When T > Tc, the entropy will be the dominating factor, potentially resulting in the system having a magnetisation of zero.
{| class="wikitable floatright" width=42%
|+ ''Table 4: statistics() output for animated system at meta-stable configuration (Figure 4)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.35076450189
|- style="text-align:center;"
| <E2> || 1.89025801939
|- style="text-align:center;"
| <M> || -0.344104665826
|- style="text-align:center;"
| <M2> || 0.138855365306
|}
Using the presented script and the ILanim.py script, the Monte Carlo cycles can be simulated to view the results on the spin array as the process progresses. Here, the system under consideration was an 8 x 8 spin array, at a temperature of 0.5. ''Figure 3'' shows the typical outcome of the animation, with the system having reached the most stable, minimum energy arrangement. For the result presented here, the output of the statistics() function was that shown in ''Table 3''.

It was also observed that the system could locate a meta-stable state, with large regions of spin 'up' and 'down' spins. An example of such a result is presented in ''Figure 4'' (for which the output data from statistics() is presented in ''Table 4'').

==Accelerating the code==

In order to examine the efficiency of the python script developed thus far, the Iltimetrial.py script was utilised to investigate the time taken to perform 2000 Monte Carlo cycles. This script was modified to the version presented [[Mod:DMS3053-3|here]], which repeats the time measurement a defined number of times, then calculates the average time and the standard error in this average. For the Monte Carlo script prepared previously, the average time for 2000 Monte Carlo cycles was measured to be 5.475804 s and a standard error was calculated to be 0.008325 s, with 100 measurements made using the script.

Evidently, the current script is slow at conducting large numbers of Monte Carlo cycles and hence, a more efficient script was developed using the np.roll, np.multiply and np.sum functions - this is presented [[Mod:DMS3053-4|here]].

After this optimisation of the python script, the Iltimetrial.py script was re-run, giving an average time of 0.291467 s, with a standard error of 0.000156 s. Clearly, this optimised script is substantially faster than that developed previously (approximately 19 times faster).

==The effect of temperature==
===Correcting the averaging code===
As the equilibrium state of the system requires a number of Monte Carlo cycles to be reached, it is evident that the average energies and magnetisations are accounting for values for non-equilibrium arrangements - this was accounted for through a consideration of the number of cycles required to reach equilibrium. For this, the ILfinalframe.py script was used, giving the graphs shown in ''Table 5''. Here, each system was run for 150000 Monte Carlo cycles.
{| class="wikitable center" width=70%
|+ ''Table 5: Graphs of energy and magnetisation versus number of Monte Carlo cycles for different temperatures and system sizes''
! Temperature !! System Size !! Resulting Graphs !! Cycles for Equilibrium
|- style="text-align:center;"
| 0.5 || 4x4 || [[File:DMS0544.png|300px]] || 24
|- style="text-align:center;"
| 0.5 || 8x8 || [[File:DMS0588.png|300px]] || 392
|- style="text-align:center;"
| 0.5 || 16x16 || [[File:DMS051616.png|300px]] || 5549
|- style="text-align:center;"
| 1.0 || 2x2 || [[File:DMS1022.png|300px]] || (0)
|- style="text-align:center;"
| 1.0 || 4x4 || [[File:DMS1044.png|300px]] || 49
|- style="text-align:center;"
| 1.0 || 8x8 || [[File:DMS10882.png|300px]] || 590
|- style="text-align:center;"
| 1.0 || 16x16 || [[File:DMS101616.png|300px]] || ~6300
|- style="text-align:center;"
| 1.0 || 32x32 || [[File:DMS103232.png|300px]] || ~110000
|- style="text-align:center;"
| 2.0 || 4x4 || [[File:DMS2044.png|300px]] || -
|- style="text-align:center;"
| 2.0 || 8x8 || [[File:DMS2088.png|300px]] || -
|}
{| class="wikitable floatright" width=42%
|+ ''Table 6: Number of cycles to be ignored for each system size''
! System Size !! Number of cycles before averaging
|- style="text-align:center;"
| 2x2 || 0
|- style="text-align:center;"
| 4x4 || 100
|- style="text-align:center;"
| 8x8 || 1000
|- style="text-align:center;"
| 16x16 || 8000
|- style="text-align:center;"
| 32x32 || 120000
|}
Analysis of these graphs indicates that at higher temperatures, such as 2.0 (also observed at 1.5), large fluctuations in the energy and magnetisation are observed - these fluctuations are the reason that the average values of the properties must be taken. As the temperature is increased for systems of size 4x4, 8x8 and 16x16, it is clear that the number of cycles required in order to reach equilibrium increases. Hence, for the temperature range to be considered later (0.25 to 5.00), the required number of cycles was overestimated in order to ensure that all measurements were taken whilst the system was in equilibrium. The proposed numbers of cycles to be ignored for each system size are presented in ''Table 6''.

The python script developed up to this point was modified to account for these values by inclusion of a skip_region variable, which defines the number of cycles performed before energies and magnetisations contribute to the self.X values (before averaging occurs). The modified script is presented [[Mod:DMS3053-5|here]].

===Running over a range of temperatures===
[[File:DMS88dat.png|300px|thumb|right|'''''Figure 5''': Average energy and average magnetisation vs. temperature for 8x8 lattice, with error bars'']]
Using the python script modified in the previous exercise, the code can now be used to simulate the 8x8 system at a range of temperatures, using the ILtemperaturerange.py file (shown [[Mod:DMS3053-temprange|here]]). Here, the temperature range of 0.25 to 5.00 was used, with a separation of 0.25 between points, whilst the runtime was set to 10000 (neglecting the property values for the first 1000 cycles). Running this simulation produced the graphs in ''Figure 5'', where error bars computed using standard errors have also been included (these are small as a consequence of small standard errors). From the graph of average energy versus temperature, the phase transition can be observed - this occurs in the region with a gradient that is not close to zero. The data used here (temperature, average energies, average squared-energies, average magnetisations and average squared-magnetisations) was then saved as a numpy array in a new file, 8x8.dat.

==The effect of system size==
[[File:DMSLatticeSizeCombinedPlot.png|300px|thumb|right|'''''Figure 6''': Average energy and average magnetisation (per spins) vs. temperature for multiple lattice sizes'']]
The process conducted for the 8x8 lattice in the previous exercise was then repeated for lattices of sizes 2x2, 4x4, 16x16 and 32x32, with the data saved in .dat files. These files were then accessed, and the average energy and magnetisation data were plotted on one graph for all of the lattices sizes - this was achieved using the script presented [[Mod:DMS3053-6|here]]. The graphs produced in this manner are shown in ''Figure 6''.

A consideration of this graph suggests that in order to capture the long range fluctuations, a 16x16 lattice is necessary.

==Determining the heat capacity==
[[File:DMSheatcapacity2.png|300px|thumb|right|'''''Figure 7''': Heat capacity (per spin) versus temperature for different lattice sizes'']]
Using the .dat files previously produced, the heat capacity was calculated for each lattice size using the equation
::<math>C = \frac{\partial E}{\partial T} = \frac{\mathrm{Var}[E]}{k_B T^2}</math>, (''eq. 9'') 
where <math>\mathrm{Var}[E] = <E^2> - <E>^2 </math>. When implementing this, the kB term was neglected due to the energy values having units of kB. The script used for this purpose is provided [[DMS3053-7|here]]. The plot of heat capacity per spin versus temperature for all of the lattice sizes considered is presented in ''Figure 7''.

==Locating the Curie temperature==
===Comparison with C++ Data===
The data for the heat capacity generated using the python script prepared in this experiment was compared to that from longer C++ computations - graphs showing this comparison are presented in ''Table 7'' for a range of lattice sizes. The Python code used to produce these graphs is shown [[Mod:DMS3053-8|here]].

Considering these graphs, it is clear that, in general, there is a reasonable correlation between the Python and C++ data; however, some of the data, particularly that for high lattice sizes, shows that the Python computations have not always found the maximum of heat capacity. This correlation would be improved by making computations at the same range of temperatures, but with a smaller gap between the temperatures taken; however, this would substantially increase computation time.
{| class="wikitable center" width=70%
|+ ''Table 7: Graphs of heat capacity (per spin) versus temperature for C++ and Python data''
|- style="text-align:center;"
| [[File:DMS2x2c.png|300px]] || [[File:DMS4x4c.png|300px]] || [[File:DMS8x8c.png|300px]]
|- style="text-align:center;"
| [[File:DMS16x16c.png|300px]] || [[File:DMS32x32c.png|300px]]
|}

===Polynomial Fitting===
[[File:DMS8x8513.png|300px|thumb|right|'''''Figure 8''': Heat capacity (per spin) versus temperature for 8x8 system with two polynomial fits'']]
In order to make use of the C++ data in finding the Curie temperature for the Ising Lattices under consideration, polynomials were fit to the data - the script written for this purpose is shown [[Mod:DMS3053-9|here]]. For this fitting, it was found that a polynomial order of 5 was required to provide a good fit for the 2x2 data - this increased significantly as the lattice size increased. An example fit is shown for the 8x8 system in ''Figure 8'', where the polynomial fit is shown for orders 5 and 13. A consideration of this graph reveals that whilst a polynomial of order 5 may be appropriate for a 2x2 system, it is inadequate for the larger system of 8x8. Whilst an order of 13 substantially improves the polynomial fit, one must, in general, take care with 'overfitting' data.
[[File:Py8x8(13fit).png|300px|thumb|right|'''''Figure 9''': Heat capacity (per spin) versus temperature for Python data for 8x8 system with a 13th order polynomial fit'']]
For comparison, a 13th order polynomial was fitted to the 8x8 Python data previously computed - this is shown in ''Figure 9''. Here, it is evident that for this data, a higher order polynomial is required to obtain a fit comparable to that for the C++ data above.

</div>

File:Py8x8(13fit).png

2015-02-24T16:05:56Z

Ds3012:

Rep:Mod:DMS3053

2015-02-24T16:03:10Z

Ds3012: /* Polynomial Fitting */

'''CMP Programming Experiment - Daniel Spencer, 00736964'''
<div style="text-align: justify">
==Introduction to the Ising Model==
===Minimum energy of the Ising Model===
Using the equation 
::<math>E= - \frac{1}{2} J \sum_i^N \sum_{j\ \in\ \mathrm{neighbours}\left(i\right)} s_i s_j</math> (''eq. 1'') 
the minimum energy of an Ising lattice of <math>D</math> dimensions, with <math>N</math> spins (where each
spin had a value of +1 or -1) and an interaction strength of <math>J</math> was considered. This was achieved first through a consideration of a one-dimensional system with five parallel spins (where the spins are parallel as this corresponds to the minimum energy arrangement of the system). Hence, the energy of this linear system was found to be 
::<math>E_\text{min,1D} = -5J </math>. 
For a linear, one-dimensional system, the number of neigbouring spins is two. The number of neighbours can be determined for two- and three- dimensional systems through a geometric consideration of their structure - the values are presented in ''Table 1''.
{| class="wikitable floatright" width=42%
|+ ''Table 1: Dimension numbers and number of neighbours''
! Number of Dimensions, D !! Number of Neighbours
|- style="text-align:center;"
| 1 || 2
|- style="text-align:center;"
| 2 || 4
|- style="text-align:center;"
| 3 || 6
|- style="text-align:center;"
| D || 2D
|}
These data indicate that the number of neighbours is twice the number of dimensions, for the dimensions considered here. This can be extrapolated to give the general number of neighbours as <math>2D</math>.

For the minimum energy of the system, where all spins are parallel, every combination <math>s_i s_j</math> has a value of 1. Notably, for each value of <math>i</math>, there will be <math>2D</math> neighbour interactions. Ergo, using ''eq. 1'', the general minimum energy can be found to be
::<math>E_\text{min,D} = -DNJ </math> (''eq. 2''). 
To check this equation, it can be applied to the two-dimensional Ising lattice with 25 spins - this gives a value of
::<math>E_\text{min,2D} = -50J </math>, 
which matches with the value predicted from first-principles.

For this D-dimensional system, the multiplicity (i.e. the number of ways of achieving the specified configuration of spins) must be equal to two, as either all of the spins could be aligned 'up' (+1) or 'down' (-1). Using this multiplicity, the entropy of the system can be calculated using the equation
::<math>S = k_B \ln\Omega</math>, (''eq. 3'') 
where Ω is the number of microstates (equal to the multiplicity in this case), which gives a value of <math>k_B \ln2 </math>, or 9.57 x 10-24 J K-1.

===Spin 'flipping'===

Using the Ising model, it is also possible to consider a change in state, reflected by a 'flipping' of the direction of one of the lattice spins. For this case, the energy (using ''eq. 1'') can be determined to be
::<math>E'= - \frac{1}{2} J (2DN - 4D - 4D) = 4DJ - DNJ</math>, (''eq. 4'') 
where the additional <math>4D</math> terms arise from the loss of 4D stabilising spin-aligned interactions and the gain of 4D destabilising spins anti-aligned interactions following spin 'flipping'. Using ''eq. 2'' and ''eq. 4'', the change in energy derived from this spin 'flip' can be calculated to be
::<math>\Delta E= 4DJ - DNJ + DNJ = 4DJ</math>. (''eq. 5'') 
For a system with three dimensions (D = 3) and 1000 spins (N = 1000), the system, using ''eq. 5'', was determined to increase in energy by <math>12 J</math>. Notably, this change in energy is independent of the number of spins in the system - it depends only on the number of dimensions and J.
[[File:ThirdYearCMPExpt-IsingSketch.png|300px|thumb|right|'' '''Figure 1''': Representation of Ising lattices in one (N=5), two (N=25), and three (N=125) dimensions. +1 and -1 spins are denoted by the red and blue cells respectively. Diagram taken from the lab script.'']]
A significant consideration with regards to the spin 'flipping' described here is the accompanying increase in entropy - the driving force for this process. For the scenario describing the change in direction of a single spin, the multiplicity of the system will be <math>2N</math> - this is a consequence of the system prior to 'flipping' having a multiplicity of two (all spins aligned 'up' or 'down'), where now, any one of the spins could flip, adding the factor of N to the multiplicity. Hence, the new entropy can be defined to be
::<math>S' = k_B \ln 2N</math>, (''eq. 6'') 
which allows the change in entropy to be calculated according to ''eq. 7''.
::<math>\Delta S = k_B \ln 2N - k_B \ln2 = k_B \ln N</math> (''eq. 7'') 
For the system described above (D = 3, N = 1000), the change in entropy associated with the spin 'flip' process is therefore <math>k_B ln 1000</math>, which is equal to 9.53 x 10-23 J K-1.

===Magnetisation===
{| class="wikitable floatright" width=42%
|+ ''Table 2: Ising lattices and magnetisations''
! Ising Lattice !! Magnetisation
|- style="text-align:center;"
| 1D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 2D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 3D at 0 K || 1000 or -1000
|}
''Figure 1'' shows three examples of Ising lattices, with one, two and three dimensions respectively. Using the equation for magnetisation (''eq. 8''), the magnetisations of these systems can be calculated to be those presented in ''Table 2''.
::<math>M= \sum_i s_i</math> (''eq. 8'') 
For the three-dimensional system at a temperature of 0 K, all of the spins must be aligned either 'up' or 'down', as the entropic increase associated with 'flipped' spins does not provide a driving force at absolute zero - the only factor to consider is that of the energy, which is a minimum when all of the spins are aligned. For this case, the magnetisation could be either 1000 or -1000, depending upon the direction of the spin alignment. From a consideration of the magnetisation values calculated here, it is evident that with all of the spins aligned, the (magnitude of the) magnetisation of the system is at a maximum.

==Calculating the energy and magnetisation==
===Modifying the files===
[[File:DMStest_output2.png|300px|thumb|right|'' '''Figure 2''': Output image from testing IsingLattice.py using Ilcheck.py'']]
In order to use Python to compute the energy and magnetisation for a given two-dimensional Ising lattice, the class IsingLattice was used, where energy() and magnetisation() functions were written to calculate their corresponding properties for a random numpy array of spins (generated using np.random.choice). For this aspect of the experiment, the value of J was assumed to be 1.0, working in reduced units. The Python script developed can be viewed [[Mod:DMS3053-1|here]], including annotations.

===Testing the files===
In order to test the script prepared thus far, the Ilcheck.py script was run, generating the image presented in ''Figure 2''. An examination of this output clearly indicates that the script provides accurate energies and magnetisations for the minimum and maximum energy configurations, along with for an intermediate, random arrangement. Hence, it can be concluded that at the current level, the Python script is functioning as required.

==Introduction to the Monte Carlo simulation==
===Average Energy and Magnetisation===
[[File:DMSILanim3.png|300px|thumb|right|'''''Figure 3''': Animation result from ILanim.py, showing the resting of the system in the minimum energy state'']]
[[File:DMSILanim_meta.png|300px|thumb|right|'''''Figure 4''': Animation result from ILanim.py, showing the resting of the system in a meta-stable state'']]

In order to consider the generalisability of the prepared script, it is important to analyse how the script will function for large systems, such as those with 100 spins in the spin array. As each of these spins can be either 'up' or 'down', each spin has two choices. Hence, the number of possible configurations for the system can be written as <math>2^{100}</math>, which has a value of 1.2677 x 1030.

If one considers the sampling of a single configuration to take 1 x 10-9 s, then it is clear that sampling all of these considerations would take a total of 1.2677 x 1021 s (also expressed as 4.017 x 1013 years). From this analysis, it is evident that the sampling of configurations was a significant consideration in the writing of a python script for this task.

In order to account for this, the technique of importance sampling was implemented, using the statistical Boltzmann distribution, <math>\exp(- \Delta E / k_B T)</math>. Note that as the energy computed using the energy() function is in units of kB, this factor is not included in the script.

===Modifying IsingLattice.py to Implement a Monte Carlo Cycle===
The python script developed at this stage is presented [[Mod:DMS3053-2|here]], accompanied by annotations to explain how the script functions.

===Simulating the Monte Carlo Cycles===
{| class="wikitable floatright" width=42%
|+ ''Table 3: statistics() output for animated system at global minimum configuration (Figure 3)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.70542501728
|- style="text-align:center;"
| <E2> || 3.13520970111
|- style="text-align:center;"
| <M> || -0.829971492744
|- style="text-align:center;"
| <M2> || 0.770986982766
|}
For cases where T < Tc, it would be expected that the system would have a spontaneous magnetisation. When T > Tc, the entropy will be the dominating factor, potentially resulting in the system having a magnetisation of zero.
{| class="wikitable floatright" width=42%
|+ ''Table 4: statistics() output for animated system at meta-stable configuration (Figure 4)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.35076450189
|- style="text-align:center;"
| <E2> || 1.89025801939
|- style="text-align:center;"
| <M> || -0.344104665826
|- style="text-align:center;"
| <M2> || 0.138855365306
|}
Using the presented script and the ILanim.py script, the Monte Carlo cycles can be simulated to view the results on the spin array as the process progresses. Here, the system under consideration was an 8 x 8 spin array, at a temperature of 0.5. ''Figure 3'' shows the typical outcome of the animation, with the system having reached the most stable, minimum energy arrangement. For the result presented here, the output of the statistics() function was that shown in ''Table 3''.

It was also observed that the system could locate a meta-stable state, with large regions of spin 'up' and 'down' spins. An example of such a result is presented in ''Figure 4'' (for which the output data from statistics() is presented in ''Table 4'').

==Accelerating the code==

In order to examine the efficiency of the python script developed thus far, the Iltimetrial.py script was utilised to investigate the time taken to perform 2000 Monte Carlo cycles. This script was modified to the version presented [[Mod:DMS3053-3|here]], which repeats the time measurement a defined number of times, then calculates the average time and the standard error in this average. For the Monte Carlo script prepared previously, the average time for 2000 Monte Carlo cycles was measured to be 5.475804 s and a standard error was calculated to be 0.008325 s, with 100 measurements made using the script.

Evidently, the current script is slow at conducting large numbers of Monte Carlo cycles and hence, a more efficient script was developed using the np.roll, np.multiply and np.sum functions - this is presented [[Mod:DMS3053-4|here]].

After this optimisation of the python script, the Iltimetrial.py script was re-run, giving an average time of 0.291467 s, with a standard error of 0.000156 s. Clearly, this optimised script is substantially faster than that developed previously (approximately 19 times faster).

==The effect of temperature==
===Correcting the averaging code===
As the equilibrium state of the system requires a number of Monte Carlo cycles to be reached, it is evident that the average energies and magnetisations are accounting for values for non-equilibrium arrangements - this was accounted for through a consideration of the number of cycles required to reach equilibrium. For this, the ILfinalframe.py script was used, giving the graphs shown in ''Table 5''. Here, each system was run for 150000 Monte Carlo cycles.
{| class="wikitable center" width=70%
|+ ''Table 5: Graphs of energy and magnetisation versus number of Monte Carlo cycles for different temperatures and system sizes''
! Temperature !! System Size !! Resulting Graphs !! Cycles for Equilibrium
|- style="text-align:center;"
| 0.5 || 4x4 || [[File:DMS0544.png|300px]] || 24
|- style="text-align:center;"
| 0.5 || 8x8 || [[File:DMS0588.png|300px]] || 392
|- style="text-align:center;"
| 0.5 || 16x16 || [[File:DMS051616.png|300px]] || 5549
|- style="text-align:center;"
| 1.0 || 2x2 || [[File:DMS1022.png|300px]] || (0)
|- style="text-align:center;"
| 1.0 || 4x4 || [[File:DMS1044.png|300px]] || 49
|- style="text-align:center;"
| 1.0 || 8x8 || [[File:DMS10882.png|300px]] || 590
|- style="text-align:center;"
| 1.0 || 16x16 || [[File:DMS101616.png|300px]] || ~6300
|- style="text-align:center;"
| 1.0 || 32x32 || [[File:DMS103232.png|300px]] || ~110000
|- style="text-align:center;"
| 2.0 || 4x4 || [[File:DMS2044.png|300px]] || -
|- style="text-align:center;"
| 2.0 || 8x8 || [[File:DMS2088.png|300px]] || -
|}
{| class="wikitable floatright" width=42%
|+ ''Table 6: Number of cycles to be ignored for each system size''
! System Size !! Number of cycles before averaging
|- style="text-align:center;"
| 2x2 || 0
|- style="text-align:center;"
| 4x4 || 100
|- style="text-align:center;"
| 8x8 || 1000
|- style="text-align:center;"
| 16x16 || 8000
|- style="text-align:center;"
| 32x32 || 120000
|}
Analysis of these graphs indicates that at higher temperatures, such as 2.0 (also observed at 1.5), large fluctuations in the energy and magnetisation are observed - these fluctuations are the reason that the average values of the properties must be taken. As the temperature is increased for systems of size 4x4, 8x8 and 16x16, it is clear that the number of cycles required in order to reach equilibrium increases. Hence, for the temperature range to be considered later (0.25 to 5.00), the required number of cycles was overestimated in order to ensure that all measurements were taken whilst the system was in equilibrium. The proposed numbers of cycles to be ignored for each system size are presented in ''Table 6''.

The python script developed up to this point was modified to account for these values by inclusion of a skip_region variable, which defines the number of cycles performed before energies and magnetisations contribute to the self.X values (before averaging occurs). The modified script is presented [[Mod:DMS3053-5|here]].

===Running over a range of temperatures===
[[File:DMS88dat.png|300px|thumb|right|'''''Figure 5''': Average energy and average magnetisation vs. temperature for 8x8 lattice, with error bars'']]
Using the python script modified in the previous exercise, the code can now be used to simulate the 8x8 system at a range of temperatures, using the ILtemperaturerange.py file (shown [[Mod:DMS3053-temprange|here]]). Here, the temperature range of 0.25 to 5.00 was used, with a separation of 0.25 between points, whilst the runtime was set to 10000 (neglecting the property values for the first 1000 cycles). Running this simulation produced the graphs in ''Figure 5'', where error bars computed using standard errors have also been included (these are small as a consequence of small standard errors). From the graph of average energy versus temperature, the phase transition can be observed - this occurs in the region with a gradient that is not close to zero. The data used here (temperature, average energies, average squared-energies, average magnetisations and average squared-magnetisations) was then saved as a numpy array in a new file, 8x8.dat.

==The effect of system size==
[[File:DMSLatticeSizeCombinedPlot.png|300px|thumb|right|'''''Figure 6''': Average energy and average magnetisation (per spins) vs. temperature for multiple lattice sizes'']]
The process conducted for the 8x8 lattice in the previous exercise was then repeated for lattices of sizes 2x2, 4x4, 16x16 and 32x32, with the data saved in .dat files. These files were then accessed, and the average energy and magnetisation data were plotted on one graph for all of the lattices sizes - this was achieved using the script presented [[Mod:DMS3053-6|here]]. The graphs produced in this manner are shown in ''Figure 6''.

A consideration of this graph suggests that in order to capture the long range fluctuations, a 16x16 lattice is necessary.

==Determining the heat capacity==
[[File:DMSheatcapacity2.png|300px|thumb|right|'''''Figure 7''': Heat capacity (per spin) versus temperature for different lattice sizes'']]
Using the .dat files previously produced, the heat capacity was calculated for each lattice size using the equation
::<math>C = \frac{\partial E}{\partial T} = \frac{\mathrm{Var}[E]}{k_B T^2}</math>, (''eq. 9'') 
where <math>\mathrm{Var}[E] = <E^2> - <E>^2 </math>. When implementing this, the kB term was neglected due to the energy values having units of kB. The script used for this purpose is provided [[DMS3053-7|here]]. The plot of heat capacity per spin versus temperature for all of the lattice sizes considered is presented in ''Figure 7''.

==Locating the Curie temperature==
===Comparison with C++ Data===
The data for the heat capacity generated using the python script prepared in this experiment was compared to that from longer C++ computations - graphs showing this comparison are presented in ''Table 7'' for a range of lattice sizes. The Python code used to produce these graphs is shown [[Mod:DMS3053-8|here]].

Considering these graphs, it is clear that, in general, there is a reasonable correlation between the Python and C++ data; however, some of the data, particularly that for high lattice sizes, shows that the Python computations have not always found the maximum of heat capacity. This correlation would be improved by making computations at the same range of temperatures, but with a smaller gap between the temperatures taken; however, this would substantially increase computation time.
{| class="wikitable center" width=70%
|+ ''Table 7: Graphs of heat capacity (per spin) versus temperature for C++ and Python data''
|- style="text-align:center;"
| [[File:DMS2x2c.png|300px]] || [[File:DMS4x4c.png|300px]] || [[File:DMS8x8c.png|300px]]
|- style="text-align:center;"
| [[File:DMS16x16c.png|300px]] || [[File:DMS32x32c.png|300px]]
|}

===Polynomial Fitting===
[[File:DMS8x8513.png|300px|thumb|right|'''''Figure 8''': Heat capacity (per spin) versus temperature for 8x8 system with two polynomial fits'']]
In order to make use of the C++ data in finding the Curie temperature for the Ising Lattices under consideration, polynomials were fit to the data - the script written for this purpose is shown [[Mod:DMS3053-9|here]]. For this fitting, it was found that a polynomial order of 5 was required to provide a good fit for the 2x2 data - this increased significantly as the lattice size increased. An example fit is shown for the 8x8 system in ''Figure 8'', where the polynomial fit is shown for orders 5 and 13. A consideration of this graph reveals that whilst a polynomial of order 5 may be appropriate for a 2x2 system, it is inadequate for the larger system of 8x8. Whilst an order of 13 substantially improves the polynomial fit, one must, in general, take care with 'overfitting' data.

For comparison, a polynomial was fitted to the 8x8 Python data previously computed - this is shown in ''Figure 9''.

</div>

File:DMS8x8513.png

2015-02-24T16:00:28Z

Ds3012:

Rep:Mod:DMS3053

2015-02-24T15:59:38Z

Ds3012: /* Polynomial Fitting */

'''CMP Programming Experiment - Daniel Spencer, 00736964'''
<div style="text-align: justify">
==Introduction to the Ising Model==
===Minimum energy of the Ising Model===
Using the equation 
::<math>E= - \frac{1}{2} J \sum_i^N \sum_{j\ \in\ \mathrm{neighbours}\left(i\right)} s_i s_j</math> (''eq. 1'') 
the minimum energy of an Ising lattice of <math>D</math> dimensions, with <math>N</math> spins (where each
spin had a value of +1 or -1) and an interaction strength of <math>J</math> was considered. This was achieved first through a consideration of a one-dimensional system with five parallel spins (where the spins are parallel as this corresponds to the minimum energy arrangement of the system). Hence, the energy of this linear system was found to be 
::<math>E_\text{min,1D} = -5J </math>. 
For a linear, one-dimensional system, the number of neigbouring spins is two. The number of neighbours can be determined for two- and three- dimensional systems through a geometric consideration of their structure - the values are presented in ''Table 1''.
{| class="wikitable floatright" width=42%
|+ ''Table 1: Dimension numbers and number of neighbours''
! Number of Dimensions, D !! Number of Neighbours
|- style="text-align:center;"
| 1 || 2
|- style="text-align:center;"
| 2 || 4
|- style="text-align:center;"
| 3 || 6
|- style="text-align:center;"
| D || 2D
|}
These data indicate that the number of neighbours is twice the number of dimensions, for the dimensions considered here. This can be extrapolated to give the general number of neighbours as <math>2D</math>.

For the minimum energy of the system, where all spins are parallel, every combination <math>s_i s_j</math> has a value of 1. Notably, for each value of <math>i</math>, there will be <math>2D</math> neighbour interactions. Ergo, using ''eq. 1'', the general minimum energy can be found to be
::<math>E_\text{min,D} = -DNJ </math> (''eq. 2''). 
To check this equation, it can be applied to the two-dimensional Ising lattice with 25 spins - this gives a value of
::<math>E_\text{min,2D} = -50J </math>, 
which matches with the value predicted from first-principles.

For this D-dimensional system, the multiplicity (i.e. the number of ways of achieving the specified configuration of spins) must be equal to two, as either all of the spins could be aligned 'up' (+1) or 'down' (-1). Using this multiplicity, the entropy of the system can be calculated using the equation
::<math>S = k_B \ln\Omega</math>, (''eq. 3'') 
where Ω is the number of microstates (equal to the multiplicity in this case), which gives a value of <math>k_B \ln2 </math>, or 9.57 x 10-24 J K-1.

===Spin 'flipping'===

Using the Ising model, it is also possible to consider a change in state, reflected by a 'flipping' of the direction of one of the lattice spins. For this case, the energy (using ''eq. 1'') can be determined to be
::<math>E'= - \frac{1}{2} J (2DN - 4D - 4D) = 4DJ - DNJ</math>, (''eq. 4'') 
where the additional <math>4D</math> terms arise from the loss of 4D stabilising spin-aligned interactions and the gain of 4D destabilising spins anti-aligned interactions following spin 'flipping'. Using ''eq. 2'' and ''eq. 4'', the change in energy derived from this spin 'flip' can be calculated to be
::<math>\Delta E= 4DJ - DNJ + DNJ = 4DJ</math>. (''eq. 5'') 
For a system with three dimensions (D = 3) and 1000 spins (N = 1000), the system, using ''eq. 5'', was determined to increase in energy by <math>12 J</math>. Notably, this change in energy is independent of the number of spins in the system - it depends only on the number of dimensions and J.
[[File:ThirdYearCMPExpt-IsingSketch.png|300px|thumb|right|'' '''Figure 1''': Representation of Ising lattices in one (N=5), two (N=25), and three (N=125) dimensions. +1 and -1 spins are denoted by the red and blue cells respectively. Diagram taken from the lab script.'']]
A significant consideration with regards to the spin 'flipping' described here is the accompanying increase in entropy - the driving force for this process. For the scenario describing the change in direction of a single spin, the multiplicity of the system will be <math>2N</math> - this is a consequence of the system prior to 'flipping' having a multiplicity of two (all spins aligned 'up' or 'down'), where now, any one of the spins could flip, adding the factor of N to the multiplicity. Hence, the new entropy can be defined to be
::<math>S' = k_B \ln 2N</math>, (''eq. 6'') 
which allows the change in entropy to be calculated according to ''eq. 7''.
::<math>\Delta S = k_B \ln 2N - k_B \ln2 = k_B \ln N</math> (''eq. 7'') 
For the system described above (D = 3, N = 1000), the change in entropy associated with the spin 'flip' process is therefore <math>k_B ln 1000</math>, which is equal to 9.53 x 10-23 J K-1.

===Magnetisation===
{| class="wikitable floatright" width=42%
|+ ''Table 2: Ising lattices and magnetisations''
! Ising Lattice !! Magnetisation
|- style="text-align:center;"
| 1D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 2D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 3D at 0 K || 1000 or -1000
|}
''Figure 1'' shows three examples of Ising lattices, with one, two and three dimensions respectively. Using the equation for magnetisation (''eq. 8''), the magnetisations of these systems can be calculated to be those presented in ''Table 2''.
::<math>M= \sum_i s_i</math> (''eq. 8'') 
For the three-dimensional system at a temperature of 0 K, all of the spins must be aligned either 'up' or 'down', as the entropic increase associated with 'flipped' spins does not provide a driving force at absolute zero - the only factor to consider is that of the energy, which is a minimum when all of the spins are aligned. For this case, the magnetisation could be either 1000 or -1000, depending upon the direction of the spin alignment. From a consideration of the magnetisation values calculated here, it is evident that with all of the spins aligned, the (magnitude of the) magnetisation of the system is at a maximum.

==Calculating the energy and magnetisation==
===Modifying the files===
[[File:DMStest_output2.png|300px|thumb|right|'' '''Figure 2''': Output image from testing IsingLattice.py using Ilcheck.py'']]
In order to use Python to compute the energy and magnetisation for a given two-dimensional Ising lattice, the class IsingLattice was used, where energy() and magnetisation() functions were written to calculate their corresponding properties for a random numpy array of spins (generated using np.random.choice). For this aspect of the experiment, the value of J was assumed to be 1.0, working in reduced units. The Python script developed can be viewed [[Mod:DMS3053-1|here]], including annotations.

===Testing the files===
In order to test the script prepared thus far, the Ilcheck.py script was run, generating the image presented in ''Figure 2''. An examination of this output clearly indicates that the script provides accurate energies and magnetisations for the minimum and maximum energy configurations, along with for an intermediate, random arrangement. Hence, it can be concluded that at the current level, the Python script is functioning as required.

==Introduction to the Monte Carlo simulation==
===Average Energy and Magnetisation===
[[File:DMSILanim3.png|300px|thumb|right|'''''Figure 3''': Animation result from ILanim.py, showing the resting of the system in the minimum energy state'']]
[[File:DMSILanim_meta.png|300px|thumb|right|'''''Figure 4''': Animation result from ILanim.py, showing the resting of the system in a meta-stable state'']]

In order to consider the generalisability of the prepared script, it is important to analyse how the script will function for large systems, such as those with 100 spins in the spin array. As each of these spins can be either 'up' or 'down', each spin has two choices. Hence, the number of possible configurations for the system can be written as <math>2^{100}</math>, which has a value of 1.2677 x 1030.

If one considers the sampling of a single configuration to take 1 x 10-9 s, then it is clear that sampling all of these considerations would take a total of 1.2677 x 1021 s (also expressed as 4.017 x 1013 years). From this analysis, it is evident that the sampling of configurations was a significant consideration in the writing of a python script for this task.

In order to account for this, the technique of importance sampling was implemented, using the statistical Boltzmann distribution, <math>\exp(- \Delta E / k_B T)</math>. Note that as the energy computed using the energy() function is in units of kB, this factor is not included in the script.

===Modifying IsingLattice.py to Implement a Monte Carlo Cycle===
The python script developed at this stage is presented [[Mod:DMS3053-2|here]], accompanied by annotations to explain how the script functions.

===Simulating the Monte Carlo Cycles===
{| class="wikitable floatright" width=42%
|+ ''Table 3: statistics() output for animated system at global minimum configuration (Figure 3)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.70542501728
|- style="text-align:center;"
| <E2> || 3.13520970111
|- style="text-align:center;"
| <M> || -0.829971492744
|- style="text-align:center;"
| <M2> || 0.770986982766
|}
For cases where T < Tc, it would be expected that the system would have a spontaneous magnetisation. When T > Tc, the entropy will be the dominating factor, potentially resulting in the system having a magnetisation of zero.
{| class="wikitable floatright" width=42%
|+ ''Table 4: statistics() output for animated system at meta-stable configuration (Figure 4)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.35076450189
|- style="text-align:center;"
| <E2> || 1.89025801939
|- style="text-align:center;"
| <M> || -0.344104665826
|- style="text-align:center;"
| <M2> || 0.138855365306
|}
Using the presented script and the ILanim.py script, the Monte Carlo cycles can be simulated to view the results on the spin array as the process progresses. Here, the system under consideration was an 8 x 8 spin array, at a temperature of 0.5. ''Figure 3'' shows the typical outcome of the animation, with the system having reached the most stable, minimum energy arrangement. For the result presented here, the output of the statistics() function was that shown in ''Table 3''.

It was also observed that the system could locate a meta-stable state, with large regions of spin 'up' and 'down' spins. An example of such a result is presented in ''Figure 4'' (for which the output data from statistics() is presented in ''Table 4'').

==Accelerating the code==

In order to examine the efficiency of the python script developed thus far, the Iltimetrial.py script was utilised to investigate the time taken to perform 2000 Monte Carlo cycles. This script was modified to the version presented [[Mod:DMS3053-3|here]], which repeats the time measurement a defined number of times, then calculates the average time and the standard error in this average. For the Monte Carlo script prepared previously, the average time for 2000 Monte Carlo cycles was measured to be 5.475804 s and a standard error was calculated to be 0.008325 s, with 100 measurements made using the script.

Evidently, the current script is slow at conducting large numbers of Monte Carlo cycles and hence, a more efficient script was developed using the np.roll, np.multiply and np.sum functions - this is presented [[Mod:DMS3053-4|here]].

After this optimisation of the python script, the Iltimetrial.py script was re-run, giving an average time of 0.291467 s, with a standard error of 0.000156 s. Clearly, this optimised script is substantially faster than that developed previously (approximately 19 times faster).

==The effect of temperature==
===Correcting the averaging code===
As the equilibrium state of the system requires a number of Monte Carlo cycles to be reached, it is evident that the average energies and magnetisations are accounting for values for non-equilibrium arrangements - this was accounted for through a consideration of the number of cycles required to reach equilibrium. For this, the ILfinalframe.py script was used, giving the graphs shown in ''Table 5''. Here, each system was run for 150000 Monte Carlo cycles.
{| class="wikitable center" width=70%
|+ ''Table 5: Graphs of energy and magnetisation versus number of Monte Carlo cycles for different temperatures and system sizes''
! Temperature !! System Size !! Resulting Graphs !! Cycles for Equilibrium
|- style="text-align:center;"
| 0.5 || 4x4 || [[File:DMS0544.png|300px]] || 24
|- style="text-align:center;"
| 0.5 || 8x8 || [[File:DMS0588.png|300px]] || 392
|- style="text-align:center;"
| 0.5 || 16x16 || [[File:DMS051616.png|300px]] || 5549
|- style="text-align:center;"
| 1.0 || 2x2 || [[File:DMS1022.png|300px]] || (0)
|- style="text-align:center;"
| 1.0 || 4x4 || [[File:DMS1044.png|300px]] || 49
|- style="text-align:center;"
| 1.0 || 8x8 || [[File:DMS10882.png|300px]] || 590
|- style="text-align:center;"
| 1.0 || 16x16 || [[File:DMS101616.png|300px]] || ~6300
|- style="text-align:center;"
| 1.0 || 32x32 || [[File:DMS103232.png|300px]] || ~110000
|- style="text-align:center;"
| 2.0 || 4x4 || [[File:DMS2044.png|300px]] || -
|- style="text-align:center;"
| 2.0 || 8x8 || [[File:DMS2088.png|300px]] || -
|}
{| class="wikitable floatright" width=42%
|+ ''Table 6: Number of cycles to be ignored for each system size''
! System Size !! Number of cycles before averaging
|- style="text-align:center;"
| 2x2 || 0
|- style="text-align:center;"
| 4x4 || 100
|- style="text-align:center;"
| 8x8 || 1000
|- style="text-align:center;"
| 16x16 || 8000
|- style="text-align:center;"
| 32x32 || 120000
|}
Analysis of these graphs indicates that at higher temperatures, such as 2.0 (also observed at 1.5), large fluctuations in the energy and magnetisation are observed - these fluctuations are the reason that the average values of the properties must be taken. As the temperature is increased for systems of size 4x4, 8x8 and 16x16, it is clear that the number of cycles required in order to reach equilibrium increases. Hence, for the temperature range to be considered later (0.25 to 5.00), the required number of cycles was overestimated in order to ensure that all measurements were taken whilst the system was in equilibrium. The proposed numbers of cycles to be ignored for each system size are presented in ''Table 6''.

The python script developed up to this point was modified to account for these values by inclusion of a skip_region variable, which defines the number of cycles performed before energies and magnetisations contribute to the self.X values (before averaging occurs). The modified script is presented [[Mod:DMS3053-5|here]].

===Running over a range of temperatures===
[[File:DMS88dat.png|300px|thumb|right|'''''Figure 5''': Average energy and average magnetisation vs. temperature for 8x8 lattice, with error bars'']]
Using the python script modified in the previous exercise, the code can now be used to simulate the 8x8 system at a range of temperatures, using the ILtemperaturerange.py file (shown [[Mod:DMS3053-temprange|here]]). Here, the temperature range of 0.25 to 5.00 was used, with a separation of 0.25 between points, whilst the runtime was set to 10000 (neglecting the property values for the first 1000 cycles). Running this simulation produced the graphs in ''Figure 5'', where error bars computed using standard errors have also been included (these are small as a consequence of small standard errors). From the graph of average energy versus temperature, the phase transition can be observed - this occurs in the region with a gradient that is not close to zero. The data used here (temperature, average energies, average squared-energies, average magnetisations and average squared-magnetisations) was then saved as a numpy array in a new file, 8x8.dat.

==The effect of system size==
[[File:DMSLatticeSizeCombinedPlot.png|300px|thumb|right|'''''Figure 6''': Average energy and average magnetisation (per spins) vs. temperature for multiple lattice sizes'']]
The process conducted for the 8x8 lattice in the previous exercise was then repeated for lattices of sizes 2x2, 4x4, 16x16 and 32x32, with the data saved in .dat files. These files were then accessed, and the average energy and magnetisation data were plotted on one graph for all of the lattices sizes - this was achieved using the script presented [[Mod:DMS3053-6|here]]. The graphs produced in this manner are shown in ''Figure 6''.

A consideration of this graph suggests that in order to capture the long range fluctuations, a 16x16 lattice is necessary.

==Determining the heat capacity==
[[File:DMSheatcapacity2.png|300px|thumb|right|'''''Figure 7''': Heat capacity (per spin) versus temperature for different lattice sizes'']]
Using the .dat files previously produced, the heat capacity was calculated for each lattice size using the equation
::<math>C = \frac{\partial E}{\partial T} = \frac{\mathrm{Var}[E]}{k_B T^2}</math>, (''eq. 9'') 
where <math>\mathrm{Var}[E] = <E^2> - <E>^2 </math>. When implementing this, the kB term was neglected due to the energy values having units of kB. The script used for this purpose is provided [[DMS3053-7|here]]. The plot of heat capacity per spin versus temperature for all of the lattice sizes considered is presented in ''Figure 7''.

==Locating the Curie temperature==
===Comparison with C++ Data===
The data for the heat capacity generated using the python script prepared in this experiment was compared to that from longer C++ computations - graphs showing this comparison are presented in ''Table 7'' for a range of lattice sizes. The Python code used to produce these graphs is shown [[Mod:DMS3053-8|here]].

Considering these graphs, it is clear that, in general, there is a reasonable correlation between the Python and C++ data; however, some of the data, particularly that for high lattice sizes, shows that the Python computations have not always found the maximum of heat capacity. This correlation would be improved by making computations at the same range of temperatures, but with a smaller gap between the temperatures taken; however, this would substantially increase computation time.
{| class="wikitable center" width=70%
|+ ''Table 7: Graphs of heat capacity (per spin) versus temperature for C++ and Python data''
|- style="text-align:center;"
| [[File:DMS2x2c.png|300px]] || [[File:DMS4x4c.png|300px]] || [[File:DMS8x8c.png|300px]]
|- style="text-align:center;"
| [[File:DMS16x16c.png|300px]] || [[File:DMS32x32c.png|300px]]
|}

===Polynomial Fitting===
In order to make use of the C++ data in finding the Curie temperature for the Ising Lattices under consideration, polynomials were fit to the data - the script written for this purpose is shown [[Mod:DMS3053-9|here]]. For this fitting, it was found that a polynomial order of 5 was required to provide a good fit for the 2x2 data - this increased significantly as the lattice size increased. An example fit is shown for the 8x8 system in ''Figure X'', where the polynomial fit is shown for orders 5 and 13.

</div>

Rep:Mod:DMS3053-9

2015-02-24T15:48:59Z

Ds3012: Created page with " from matplotlib import pylab as pl import numpy as np def extract_data(file): data_array = np.loadtxt(file) temps = data_array[:,0] heat_c..."

from matplotlib import pylab as pl
import numpy as np

def extract_data(file):
data_array = np.loadtxt(file)
temps = data_array[:,0]
heat_cap_per_spin = data_array[:,5]
return temps, heat_cap_per_spin

def plotdata(file):
file_data = extract_data(file)
fit = np.polyfit(file_data[0], file_data[1], 11) # fit a third order polynomial
T_min = np.min(file_data[0])
T_max = np.max(file_data[0])
T_range = np.linspace(T_min, T_max, 1000) #generate 1000 evenly spaced points between T_min and T_max
fitted_C_values = np.polyval(fit, T_range) # use the fit object to generate the corresponding values of C
pl.ylabel("Heat Capacity")
pl.xlabel("Temperature")
pl.ylim([0.0, 1.5])
pl.plot(file_data[0], file_data[1], T_range, fitted_C_values)
pl.legend(['Data', 'Polynomial fit'], loc='upper center', bbox_to_anchor=(0.5, 1.10),
ncol=5)
pl.show()

Rep:Mod:DMS3053

2015-02-24T15:48:11Z

Ds3012: /* Polynomial Fitting */

'''CMP Programming Experiment - Daniel Spencer, 00736964'''
<div style="text-align: justify">
==Introduction to the Ising Model==
===Minimum energy of the Ising Model===
Using the equation 
::<math>E= - \frac{1}{2} J \sum_i^N \sum_{j\ \in\ \mathrm{neighbours}\left(i\right)} s_i s_j</math> (''eq. 1'') 
the minimum energy of an Ising lattice of <math>D</math> dimensions, with <math>N</math> spins (where each
spin had a value of +1 or -1) and an interaction strength of <math>J</math> was considered. This was achieved first through a consideration of a one-dimensional system with five parallel spins (where the spins are parallel as this corresponds to the minimum energy arrangement of the system). Hence, the energy of this linear system was found to be 
::<math>E_\text{min,1D} = -5J </math>. 
For a linear, one-dimensional system, the number of neigbouring spins is two. The number of neighbours can be determined for two- and three- dimensional systems through a geometric consideration of their structure - the values are presented in ''Table 1''.
{| class="wikitable floatright" width=42%
|+ ''Table 1: Dimension numbers and number of neighbours''
! Number of Dimensions, D !! Number of Neighbours
|- style="text-align:center;"
| 1 || 2
|- style="text-align:center;"
| 2 || 4
|- style="text-align:center;"
| 3 || 6
|- style="text-align:center;"
| D || 2D
|}
These data indicate that the number of neighbours is twice the number of dimensions, for the dimensions considered here. This can be extrapolated to give the general number of neighbours as <math>2D</math>.

For the minimum energy of the system, where all spins are parallel, every combination <math>s_i s_j</math> has a value of 1. Notably, for each value of <math>i</math>, there will be <math>2D</math> neighbour interactions. Ergo, using ''eq. 1'', the general minimum energy can be found to be
::<math>E_\text{min,D} = -DNJ </math> (''eq. 2''). 
To check this equation, it can be applied to the two-dimensional Ising lattice with 25 spins - this gives a value of
::<math>E_\text{min,2D} = -50J </math>, 
which matches with the value predicted from first-principles.

For this D-dimensional system, the multiplicity (i.e. the number of ways of achieving the specified configuration of spins) must be equal to two, as either all of the spins could be aligned 'up' (+1) or 'down' (-1). Using this multiplicity, the entropy of the system can be calculated using the equation
::<math>S = k_B \ln\Omega</math>, (''eq. 3'') 
where Ω is the number of microstates (equal to the multiplicity in this case), which gives a value of <math>k_B \ln2 </math>, or 9.57 x 10-24 J K-1.

===Spin 'flipping'===

Using the Ising model, it is also possible to consider a change in state, reflected by a 'flipping' of the direction of one of the lattice spins. For this case, the energy (using ''eq. 1'') can be determined to be
::<math>E'= - \frac{1}{2} J (2DN - 4D - 4D) = 4DJ - DNJ</math>, (''eq. 4'') 
where the additional <math>4D</math> terms arise from the loss of 4D stabilising spin-aligned interactions and the gain of 4D destabilising spins anti-aligned interactions following spin 'flipping'. Using ''eq. 2'' and ''eq. 4'', the change in energy derived from this spin 'flip' can be calculated to be
::<math>\Delta E= 4DJ - DNJ + DNJ = 4DJ</math>. (''eq. 5'') 
For a system with three dimensions (D = 3) and 1000 spins (N = 1000), the system, using ''eq. 5'', was determined to increase in energy by <math>12 J</math>. Notably, this change in energy is independent of the number of spins in the system - it depends only on the number of dimensions and J.
[[File:ThirdYearCMPExpt-IsingSketch.png|300px|thumb|right|'' '''Figure 1''': Representation of Ising lattices in one (N=5), two (N=25), and three (N=125) dimensions. +1 and -1 spins are denoted by the red and blue cells respectively. Diagram taken from the lab script.'']]
A significant consideration with regards to the spin 'flipping' described here is the accompanying increase in entropy - the driving force for this process. For the scenario describing the change in direction of a single spin, the multiplicity of the system will be <math>2N</math> - this is a consequence of the system prior to 'flipping' having a multiplicity of two (all spins aligned 'up' or 'down'), where now, any one of the spins could flip, adding the factor of N to the multiplicity. Hence, the new entropy can be defined to be
::<math>S' = k_B \ln 2N</math>, (''eq. 6'') 
which allows the change in entropy to be calculated according to ''eq. 7''.
::<math>\Delta S = k_B \ln 2N - k_B \ln2 = k_B \ln N</math> (''eq. 7'') 
For the system described above (D = 3, N = 1000), the change in entropy associated with the spin 'flip' process is therefore <math>k_B ln 1000</math>, which is equal to 9.53 x 10-23 J K-1.

===Magnetisation===
{| class="wikitable floatright" width=42%
|+ ''Table 2: Ising lattices and magnetisations''
! Ising Lattice !! Magnetisation
|- style="text-align:center;"
| 1D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 2D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 3D at 0 K || 1000 or -1000
|}
''Figure 1'' shows three examples of Ising lattices, with one, two and three dimensions respectively. Using the equation for magnetisation (''eq. 8''), the magnetisations of these systems can be calculated to be those presented in ''Table 2''.
::<math>M= \sum_i s_i</math> (''eq. 8'') 
For the three-dimensional system at a temperature of 0 K, all of the spins must be aligned either 'up' or 'down', as the entropic increase associated with 'flipped' spins does not provide a driving force at absolute zero - the only factor to consider is that of the energy, which is a minimum when all of the spins are aligned. For this case, the magnetisation could be either 1000 or -1000, depending upon the direction of the spin alignment. From a consideration of the magnetisation values calculated here, it is evident that with all of the spins aligned, the (magnitude of the) magnetisation of the system is at a maximum.

==Calculating the energy and magnetisation==
===Modifying the files===
[[File:DMStest_output2.png|300px|thumb|right|'' '''Figure 2''': Output image from testing IsingLattice.py using Ilcheck.py'']]
In order to use Python to compute the energy and magnetisation for a given two-dimensional Ising lattice, the class IsingLattice was used, where energy() and magnetisation() functions were written to calculate their corresponding properties for a random numpy array of spins (generated using np.random.choice). For this aspect of the experiment, the value of J was assumed to be 1.0, working in reduced units. The Python script developed can be viewed [[Mod:DMS3053-1|here]], including annotations.

===Testing the files===
In order to test the script prepared thus far, the Ilcheck.py script was run, generating the image presented in ''Figure 2''. An examination of this output clearly indicates that the script provides accurate energies and magnetisations for the minimum and maximum energy configurations, along with for an intermediate, random arrangement. Hence, it can be concluded that at the current level, the Python script is functioning as required.

==Introduction to the Monte Carlo simulation==
===Average Energy and Magnetisation===
[[File:DMSILanim3.png|300px|thumb|right|'''''Figure 3''': Animation result from ILanim.py, showing the resting of the system in the minimum energy state'']]
[[File:DMSILanim_meta.png|300px|thumb|right|'''''Figure 4''': Animation result from ILanim.py, showing the resting of the system in a meta-stable state'']]

In order to consider the generalisability of the prepared script, it is important to analyse how the script will function for large systems, such as those with 100 spins in the spin array. As each of these spins can be either 'up' or 'down', each spin has two choices. Hence, the number of possible configurations for the system can be written as <math>2^{100}</math>, which has a value of 1.2677 x 1030.

If one considers the sampling of a single configuration to take 1 x 10-9 s, then it is clear that sampling all of these considerations would take a total of 1.2677 x 1021 s (also expressed as 4.017 x 1013 years). From this analysis, it is evident that the sampling of configurations was a significant consideration in the writing of a python script for this task.

In order to account for this, the technique of importance sampling was implemented, using the statistical Boltzmann distribution, <math>\exp(- \Delta E / k_B T)</math>. Note that as the energy computed using the energy() function is in units of kB, this factor is not included in the script.

===Modifying IsingLattice.py to Implement a Monte Carlo Cycle===
The python script developed at this stage is presented [[Mod:DMS3053-2|here]], accompanied by annotations to explain how the script functions.

===Simulating the Monte Carlo Cycles===
{| class="wikitable floatright" width=42%
|+ ''Table 3: statistics() output for animated system at global minimum configuration (Figure 3)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.70542501728
|- style="text-align:center;"
| <E2> || 3.13520970111
|- style="text-align:center;"
| <M> || -0.829971492744
|- style="text-align:center;"
| <M2> || 0.770986982766
|}
For cases where T < Tc, it would be expected that the system would have a spontaneous magnetisation. When T > Tc, the entropy will be the dominating factor, potentially resulting in the system having a magnetisation of zero.
{| class="wikitable floatright" width=42%
|+ ''Table 4: statistics() output for animated system at meta-stable configuration (Figure 4)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.35076450189
|- style="text-align:center;"
| <E2> || 1.89025801939
|- style="text-align:center;"
| <M> || -0.344104665826
|- style="text-align:center;"
| <M2> || 0.138855365306
|}
Using the presented script and the ILanim.py script, the Monte Carlo cycles can be simulated to view the results on the spin array as the process progresses. Here, the system under consideration was an 8 x 8 spin array, at a temperature of 0.5. ''Figure 3'' shows the typical outcome of the animation, with the system having reached the most stable, minimum energy arrangement. For the result presented here, the output of the statistics() function was that shown in ''Table 3''.

It was also observed that the system could locate a meta-stable state, with large regions of spin 'up' and 'down' spins. An example of such a result is presented in ''Figure 4'' (for which the output data from statistics() is presented in ''Table 4'').

==Accelerating the code==

In order to examine the efficiency of the python script developed thus far, the Iltimetrial.py script was utilised to investigate the time taken to perform 2000 Monte Carlo cycles. This script was modified to the version presented [[Mod:DMS3053-3|here]], which repeats the time measurement a defined number of times, then calculates the average time and the standard error in this average. For the Monte Carlo script prepared previously, the average time for 2000 Monte Carlo cycles was measured to be 5.475804 s and a standard error was calculated to be 0.008325 s, with 100 measurements made using the script.

Evidently, the current script is slow at conducting large numbers of Monte Carlo cycles and hence, a more efficient script was developed using the np.roll, np.multiply and np.sum functions - this is presented [[Mod:DMS3053-4|here]].

After this optimisation of the python script, the Iltimetrial.py script was re-run, giving an average time of 0.291467 s, with a standard error of 0.000156 s. Clearly, this optimised script is substantially faster than that developed previously (approximately 19 times faster).

==The effect of temperature==
===Correcting the averaging code===
As the equilibrium state of the system requires a number of Monte Carlo cycles to be reached, it is evident that the average energies and magnetisations are accounting for values for non-equilibrium arrangements - this was accounted for through a consideration of the number of cycles required to reach equilibrium. For this, the ILfinalframe.py script was used, giving the graphs shown in ''Table 5''. Here, each system was run for 150000 Monte Carlo cycles.
{| class="wikitable center" width=70%
|+ ''Table 5: Graphs of energy and magnetisation versus number of Monte Carlo cycles for different temperatures and system sizes''
! Temperature !! System Size !! Resulting Graphs !! Cycles for Equilibrium
|- style="text-align:center;"
| 0.5 || 4x4 || [[File:DMS0544.png|300px]] || 24
|- style="text-align:center;"
| 0.5 || 8x8 || [[File:DMS0588.png|300px]] || 392
|- style="text-align:center;"
| 0.5 || 16x16 || [[File:DMS051616.png|300px]] || 5549
|- style="text-align:center;"
| 1.0 || 2x2 || [[File:DMS1022.png|300px]] || (0)
|- style="text-align:center;"
| 1.0 || 4x4 || [[File:DMS1044.png|300px]] || 49
|- style="text-align:center;"
| 1.0 || 8x8 || [[File:DMS10882.png|300px]] || 590
|- style="text-align:center;"
| 1.0 || 16x16 || [[File:DMS101616.png|300px]] || ~6300
|- style="text-align:center;"
| 1.0 || 32x32 || [[File:DMS103232.png|300px]] || ~110000
|- style="text-align:center;"
| 2.0 || 4x4 || [[File:DMS2044.png|300px]] || -
|- style="text-align:center;"
| 2.0 || 8x8 || [[File:DMS2088.png|300px]] || -
|}
{| class="wikitable floatright" width=42%
|+ ''Table 6: Number of cycles to be ignored for each system size''
! System Size !! Number of cycles before averaging
|- style="text-align:center;"
| 2x2 || 0
|- style="text-align:center;"
| 4x4 || 100
|- style="text-align:center;"
| 8x8 || 1000
|- style="text-align:center;"
| 16x16 || 8000
|- style="text-align:center;"
| 32x32 || 120000
|}
Analysis of these graphs indicates that at higher temperatures, such as 2.0 (also observed at 1.5), large fluctuations in the energy and magnetisation are observed - these fluctuations are the reason that the average values of the properties must be taken. As the temperature is increased for systems of size 4x4, 8x8 and 16x16, it is clear that the number of cycles required in order to reach equilibrium increases. Hence, for the temperature range to be considered later (0.25 to 5.00), the required number of cycles was overestimated in order to ensure that all measurements were taken whilst the system was in equilibrium. The proposed numbers of cycles to be ignored for each system size are presented in ''Table 6''.

The python script developed up to this point was modified to account for these values by inclusion of a skip_region variable, which defines the number of cycles performed before energies and magnetisations contribute to the self.X values (before averaging occurs). The modified script is presented [[Mod:DMS3053-5|here]].

===Running over a range of temperatures===
[[File:DMS88dat.png|300px|thumb|right|'''''Figure 5''': Average energy and average magnetisation vs. temperature for 8x8 lattice, with error bars'']]
Using the python script modified in the previous exercise, the code can now be used to simulate the 8x8 system at a range of temperatures, using the ILtemperaturerange.py file (shown [[Mod:DMS3053-temprange|here]]). Here, the temperature range of 0.25 to 5.00 was used, with a separation of 0.25 between points, whilst the runtime was set to 10000 (neglecting the property values for the first 1000 cycles). Running this simulation produced the graphs in ''Figure 5'', where error bars computed using standard errors have also been included (these are small as a consequence of small standard errors). From the graph of average energy versus temperature, the phase transition can be observed - this occurs in the region with a gradient that is not close to zero. The data used here (temperature, average energies, average squared-energies, average magnetisations and average squared-magnetisations) was then saved as a numpy array in a new file, 8x8.dat.

==The effect of system size==
[[File:DMSLatticeSizeCombinedPlot.png|300px|thumb|right|'''''Figure 6''': Average energy and average magnetisation (per spins) vs. temperature for multiple lattice sizes'']]
The process conducted for the 8x8 lattice in the previous exercise was then repeated for lattices of sizes 2x2, 4x4, 16x16 and 32x32, with the data saved in .dat files. These files were then accessed, and the average energy and magnetisation data were plotted on one graph for all of the lattices sizes - this was achieved using the script presented [[Mod:DMS3053-6|here]]. The graphs produced in this manner are shown in ''Figure 6''.

A consideration of this graph suggests that in order to capture the long range fluctuations, a 16x16 lattice is necessary.

==Determining the heat capacity==
[[File:DMSheatcapacity2.png|300px|thumb|right|'''''Figure 7''': Heat capacity (per spin) versus temperature for different lattice sizes'']]
Using the .dat files previously produced, the heat capacity was calculated for each lattice size using the equation
::<math>C = \frac{\partial E}{\partial T} = \frac{\mathrm{Var}[E]}{k_B T^2}</math>, (''eq. 9'') 
where <math>\mathrm{Var}[E] = <E^2> - <E>^2 </math>. When implementing this, the kB term was neglected due to the energy values having units of kB. The script used for this purpose is provided [[DMS3053-7|here]]. The plot of heat capacity per spin versus temperature for all of the lattice sizes considered is presented in ''Figure 7''.

==Locating the Curie temperature==
===Comparison with C++ Data===
The data for the heat capacity generated using the python script prepared in this experiment was compared to that from longer C++ computations - graphs showing this comparison are presented in ''Table 7'' for a range of lattice sizes. The Python code used to produce these graphs is shown [[Mod:DMS3053-8|here]].

Considering these graphs, it is clear that, in general, there is a reasonable correlation between the Python and C++ data; however, some of the data, particularly that for high lattice sizes, shows that the Python computations have not always found the maximum of heat capacity. This correlation would be improved by making computations at the same range of temperatures, but with a smaller gap between the temperatures taken; however, this would substantially increase computation time.
{| class="wikitable center" width=70%
|+ ''Table 7: Graphs of heat capacity (per spin) versus temperature for C++ and Python data''
|- style="text-align:center;"
| [[File:DMS2x2c.png|300px]] || [[File:DMS4x4c.png|300px]] || [[File:DMS8x8c.png|300px]]
|- style="text-align:center;"
| [[File:DMS16x16c.png|300px]] || [[File:DMS32x32c.png|300px]]
|}

===Polynomial Fitting===
In order to make use of the C++ data in finding the Curie temperature for the Ising Lattices under consideration, polynomials were fit to the data - the script written for this purpose is shown [[Mod:DMS3053-9|here]].

</div>

Rep:Mod:DMS3053-temprange

2015-02-24T15:39:09Z

Ds3012: Created page with " from IsingLattice import * from matplotlib import pylab as pl import numpy as np n_rows = 32 n_cols = 32 il = IsingLattice(n_rows, n_cols) il.latt..."

from IsingLattice import *
from matplotlib import pylab as pl
import numpy as np

n_rows = 32
n_cols = 32
il = IsingLattice(n_rows, n_cols)
il.lattice = np.ones((n_rows, n_cols))
spins = n_rows*n_cols
runtime = 1000
times = range(runtime)
temps = np.arange(0.25, 5.25, 0.25)
energies = []
magnetisations = []
energysq = []
magnetisationsq = []
E_errors = []
M_errors = []
for t in temps:
for i in times:
if i % 100 == 0:
print(t, i)
energy, magnetisation = il.montecarlostep(t)
aveE, aveE2, aveM, aveM2, n_cycles, std_errorE, std_errorM = il.statistics()
energies.append(aveE)
energysq.append(aveE2)
magnetisations.append(aveM)
magnetisationsq.append(aveM2)
E_errors.append(std_errorE)
M_errors.append(std_errorM)
#reset the IL object for the next cycle
il.E = 0.0
il.E2 = 0.0
il.M = 0.0
il.M2 = 0.0
il.n_cycles = 0
fig = pl.figure()
enerax = fig.add_subplot(2,1,1)
enerax.set_ylabel("Energy per spin")
enerax.set_xlabel("Temperature")
enerax.set_ylim([-2.1, 2.1])
magax = fig.add_subplot(2,1,2)
magax.set_ylabel("Magnetisation per spin")
magax.set_xlabel("Temperature")
magax.set_ylim([-1.1, 1.1])
enerax.plot(temps, np.array(energies)/spins)
enerax.errorbar(temps, np.array(energies)/spins, xerr = 0, yerr = np.array(E_errors)/spins)
magax.plot(temps, np.array(magnetisations)/spins)
magax.errorbar(temps, np.array(magnetisations)/spins, xerr = 0, yerr = np.array(M_errors)/spins)
pl.show()

final_data = np.column_stack((temps, energies, energysq, magnetisations, magnetisationsq))
np.savetxt("32x32.dat", final_data)

Rep:Mod:DMS3053

2015-02-24T15:37:07Z

Ds3012: /* Running over a range of temperatures */

'''CMP Programming Experiment - Daniel Spencer, 00736964'''
<div style="text-align: justify">
==Introduction to the Ising Model==
===Minimum energy of the Ising Model===
Using the equation 
::<math>E= - \frac{1}{2} J \sum_i^N \sum_{j\ \in\ \mathrm{neighbours}\left(i\right)} s_i s_j</math> (''eq. 1'') 
the minimum energy of an Ising lattice of <math>D</math> dimensions, with <math>N</math> spins (where each
spin had a value of +1 or -1) and an interaction strength of <math>J</math> was considered. This was achieved first through a consideration of a one-dimensional system with five parallel spins (where the spins are parallel as this corresponds to the minimum energy arrangement of the system). Hence, the energy of this linear system was found to be 
::<math>E_\text{min,1D} = -5J </math>. 
For a linear, one-dimensional system, the number of neigbouring spins is two. The number of neighbours can be determined for two- and three- dimensional systems through a geometric consideration of their structure - the values are presented in ''Table 1''.
{| class="wikitable floatright" width=42%
|+ ''Table 1: Dimension numbers and number of neighbours''
! Number of Dimensions, D !! Number of Neighbours
|- style="text-align:center;"
| 1 || 2
|- style="text-align:center;"
| 2 || 4
|- style="text-align:center;"
| 3 || 6
|- style="text-align:center;"
| D || 2D
|}
These data indicate that the number of neighbours is twice the number of dimensions, for the dimensions considered here. This can be extrapolated to give the general number of neighbours as <math>2D</math>.

For the minimum energy of the system, where all spins are parallel, every combination <math>s_i s_j</math> has a value of 1. Notably, for each value of <math>i</math>, there will be <math>2D</math> neighbour interactions. Ergo, using ''eq. 1'', the general minimum energy can be found to be
::<math>E_\text{min,D} = -DNJ </math> (''eq. 2''). 
To check this equation, it can be applied to the two-dimensional Ising lattice with 25 spins - this gives a value of
::<math>E_\text{min,2D} = -50J </math>, 
which matches with the value predicted from first-principles.

For this D-dimensional system, the multiplicity (i.e. the number of ways of achieving the specified configuration of spins) must be equal to two, as either all of the spins could be aligned 'up' (+1) or 'down' (-1). Using this multiplicity, the entropy of the system can be calculated using the equation
::<math>S = k_B \ln\Omega</math>, (''eq. 3'') 
where Ω is the number of microstates (equal to the multiplicity in this case), which gives a value of <math>k_B \ln2 </math>, or 9.57 x 10-24 J K-1.

===Spin 'flipping'===

Using the Ising model, it is also possible to consider a change in state, reflected by a 'flipping' of the direction of one of the lattice spins. For this case, the energy (using ''eq. 1'') can be determined to be
::<math>E'= - \frac{1}{2} J (2DN - 4D - 4D) = 4DJ - DNJ</math>, (''eq. 4'') 
where the additional <math>4D</math> terms arise from the loss of 4D stabilising spin-aligned interactions and the gain of 4D destabilising spins anti-aligned interactions following spin 'flipping'. Using ''eq. 2'' and ''eq. 4'', the change in energy derived from this spin 'flip' can be calculated to be
::<math>\Delta E= 4DJ - DNJ + DNJ = 4DJ</math>. (''eq. 5'') 
For a system with three dimensions (D = 3) and 1000 spins (N = 1000), the system, using ''eq. 5'', was determined to increase in energy by <math>12 J</math>. Notably, this change in energy is independent of the number of spins in the system - it depends only on the number of dimensions and J.
[[File:ThirdYearCMPExpt-IsingSketch.png|300px|thumb|right|'' '''Figure 1''': Representation of Ising lattices in one (N=5), two (N=25), and three (N=125) dimensions. +1 and -1 spins are denoted by the red and blue cells respectively. Diagram taken from the lab script.'']]
A significant consideration with regards to the spin 'flipping' described here is the accompanying increase in entropy - the driving force for this process. For the scenario describing the change in direction of a single spin, the multiplicity of the system will be <math>2N</math> - this is a consequence of the system prior to 'flipping' having a multiplicity of two (all spins aligned 'up' or 'down'), where now, any one of the spins could flip, adding the factor of N to the multiplicity. Hence, the new entropy can be defined to be
::<math>S' = k_B \ln 2N</math>, (''eq. 6'') 
which allows the change in entropy to be calculated according to ''eq. 7''.
::<math>\Delta S = k_B \ln 2N - k_B \ln2 = k_B \ln N</math> (''eq. 7'') 
For the system described above (D = 3, N = 1000), the change in entropy associated with the spin 'flip' process is therefore <math>k_B ln 1000</math>, which is equal to 9.53 x 10-23 J K-1.

===Magnetisation===
{| class="wikitable floatright" width=42%
|+ ''Table 2: Ising lattices and magnetisations''
! Ising Lattice !! Magnetisation
|- style="text-align:center;"
| 1D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 2D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 3D at 0 K || 1000 or -1000
|}
''Figure 1'' shows three examples of Ising lattices, with one, two and three dimensions respectively. Using the equation for magnetisation (''eq. 8''), the magnetisations of these systems can be calculated to be those presented in ''Table 2''.
::<math>M= \sum_i s_i</math> (''eq. 8'') 
For the three-dimensional system at a temperature of 0 K, all of the spins must be aligned either 'up' or 'down', as the entropic increase associated with 'flipped' spins does not provide a driving force at absolute zero - the only factor to consider is that of the energy, which is a minimum when all of the spins are aligned. For this case, the magnetisation could be either 1000 or -1000, depending upon the direction of the spin alignment. From a consideration of the magnetisation values calculated here, it is evident that with all of the spins aligned, the (magnitude of the) magnetisation of the system is at a maximum.

==Calculating the energy and magnetisation==
===Modifying the files===
[[File:DMStest_output2.png|300px|thumb|right|'' '''Figure 2''': Output image from testing IsingLattice.py using Ilcheck.py'']]
In order to use Python to compute the energy and magnetisation for a given two-dimensional Ising lattice, the class IsingLattice was used, where energy() and magnetisation() functions were written to calculate their corresponding properties for a random numpy array of spins (generated using np.random.choice). For this aspect of the experiment, the value of J was assumed to be 1.0, working in reduced units. The Python script developed can be viewed [[Mod:DMS3053-1|here]], including annotations.

===Testing the files===
In order to test the script prepared thus far, the Ilcheck.py script was run, generating the image presented in ''Figure 2''. An examination of this output clearly indicates that the script provides accurate energies and magnetisations for the minimum and maximum energy configurations, along with for an intermediate, random arrangement. Hence, it can be concluded that at the current level, the Python script is functioning as required.

==Introduction to the Monte Carlo simulation==
===Average Energy and Magnetisation===
[[File:DMSILanim3.png|300px|thumb|right|'''''Figure 3''': Animation result from ILanim.py, showing the resting of the system in the minimum energy state'']]
[[File:DMSILanim_meta.png|300px|thumb|right|'''''Figure 4''': Animation result from ILanim.py, showing the resting of the system in a meta-stable state'']]

In order to consider the generalisability of the prepared script, it is important to analyse how the script will function for large systems, such as those with 100 spins in the spin array. As each of these spins can be either 'up' or 'down', each spin has two choices. Hence, the number of possible configurations for the system can be written as <math>2^{100}</math>, which has a value of 1.2677 x 1030.

If one considers the sampling of a single configuration to take 1 x 10-9 s, then it is clear that sampling all of these considerations would take a total of 1.2677 x 1021 s (also expressed as 4.017 x 1013 years). From this analysis, it is evident that the sampling of configurations was a significant consideration in the writing of a python script for this task.

In order to account for this, the technique of importance sampling was implemented, using the statistical Boltzmann distribution, <math>\exp(- \Delta E / k_B T)</math>. Note that as the energy computed using the energy() function is in units of kB, this factor is not included in the script.

===Modifying IsingLattice.py to Implement a Monte Carlo Cycle===
The python script developed at this stage is presented [[Mod:DMS3053-2|here]], accompanied by annotations to explain how the script functions.

===Simulating the Monte Carlo Cycles===
{| class="wikitable floatright" width=42%
|+ ''Table 3: statistics() output for animated system at global minimum configuration (Figure 3)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.70542501728
|- style="text-align:center;"
| <E2> || 3.13520970111
|- style="text-align:center;"
| <M> || -0.829971492744
|- style="text-align:center;"
| <M2> || 0.770986982766
|}
For cases where T < Tc, it would be expected that the system would have a spontaneous magnetisation. When T > Tc, the entropy will be the dominating factor, potentially resulting in the system having a magnetisation of zero.
{| class="wikitable floatright" width=42%
|+ ''Table 4: statistics() output for animated system at meta-stable configuration (Figure 4)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.35076450189
|- style="text-align:center;"
| <E2> || 1.89025801939
|- style="text-align:center;"
| <M> || -0.344104665826
|- style="text-align:center;"
| <M2> || 0.138855365306
|}
Using the presented script and the ILanim.py script, the Monte Carlo cycles can be simulated to view the results on the spin array as the process progresses. Here, the system under consideration was an 8 x 8 spin array, at a temperature of 0.5. ''Figure 3'' shows the typical outcome of the animation, with the system having reached the most stable, minimum energy arrangement. For the result presented here, the output of the statistics() function was that shown in ''Table 3''.

It was also observed that the system could locate a meta-stable state, with large regions of spin 'up' and 'down' spins. An example of such a result is presented in ''Figure 4'' (for which the output data from statistics() is presented in ''Table 4'').

==Accelerating the code==

In order to examine the efficiency of the python script developed thus far, the Iltimetrial.py script was utilised to investigate the time taken to perform 2000 Monte Carlo cycles. This script was modified to the version presented [[Mod:DMS3053-3|here]], which repeats the time measurement a defined number of times, then calculates the average time and the standard error in this average. For the Monte Carlo script prepared previously, the average time for 2000 Monte Carlo cycles was measured to be 5.475804 s and a standard error was calculated to be 0.008325 s, with 100 measurements made using the script.

Evidently, the current script is slow at conducting large numbers of Monte Carlo cycles and hence, a more efficient script was developed using the np.roll, np.multiply and np.sum functions - this is presented [[Mod:DMS3053-4|here]].

After this optimisation of the python script, the Iltimetrial.py script was re-run, giving an average time of 0.291467 s, with a standard error of 0.000156 s. Clearly, this optimised script is substantially faster than that developed previously (approximately 19 times faster).

==The effect of temperature==
===Correcting the averaging code===
As the equilibrium state of the system requires a number of Monte Carlo cycles to be reached, it is evident that the average energies and magnetisations are accounting for values for non-equilibrium arrangements - this was accounted for through a consideration of the number of cycles required to reach equilibrium. For this, the ILfinalframe.py script was used, giving the graphs shown in ''Table 5''. Here, each system was run for 150000 Monte Carlo cycles.
{| class="wikitable center" width=70%
|+ ''Table 5: Graphs of energy and magnetisation versus number of Monte Carlo cycles for different temperatures and system sizes''
! Temperature !! System Size !! Resulting Graphs !! Cycles for Equilibrium
|- style="text-align:center;"
| 0.5 || 4x4 || [[File:DMS0544.png|300px]] || 24
|- style="text-align:center;"
| 0.5 || 8x8 || [[File:DMS0588.png|300px]] || 392
|- style="text-align:center;"
| 0.5 || 16x16 || [[File:DMS051616.png|300px]] || 5549
|- style="text-align:center;"
| 1.0 || 2x2 || [[File:DMS1022.png|300px]] || (0)
|- style="text-align:center;"
| 1.0 || 4x4 || [[File:DMS1044.png|300px]] || 49
|- style="text-align:center;"
| 1.0 || 8x8 || [[File:DMS10882.png|300px]] || 590
|- style="text-align:center;"
| 1.0 || 16x16 || [[File:DMS101616.png|300px]] || ~6300
|- style="text-align:center;"
| 1.0 || 32x32 || [[File:DMS103232.png|300px]] || ~110000
|- style="text-align:center;"
| 2.0 || 4x4 || [[File:DMS2044.png|300px]] || -
|- style="text-align:center;"
| 2.0 || 8x8 || [[File:DMS2088.png|300px]] || -
|}
{| class="wikitable floatright" width=42%
|+ ''Table 6: Number of cycles to be ignored for each system size''
! System Size !! Number of cycles before averaging
|- style="text-align:center;"
| 2x2 || 0
|- style="text-align:center;"
| 4x4 || 100
|- style="text-align:center;"
| 8x8 || 1000
|- style="text-align:center;"
| 16x16 || 8000
|- style="text-align:center;"
| 32x32 || 120000
|}
Analysis of these graphs indicates that at higher temperatures, such as 2.0 (also observed at 1.5), large fluctuations in the energy and magnetisation are observed - these fluctuations are the reason that the average values of the properties must be taken. As the temperature is increased for systems of size 4x4, 8x8 and 16x16, it is clear that the number of cycles required in order to reach equilibrium increases. Hence, for the temperature range to be considered later (0.25 to 5.00), the required number of cycles was overestimated in order to ensure that all measurements were taken whilst the system was in equilibrium. The proposed numbers of cycles to be ignored for each system size are presented in ''Table 6''.

The python script developed up to this point was modified to account for these values by inclusion of a skip_region variable, which defines the number of cycles performed before energies and magnetisations contribute to the self.X values (before averaging occurs). The modified script is presented [[Mod:DMS3053-5|here]].

===Running over a range of temperatures===
[[File:DMS88dat.png|300px|thumb|right|'''''Figure 5''': Average energy and average magnetisation vs. temperature for 8x8 lattice, with error bars'']]
Using the python script modified in the previous exercise, the code can now be used to simulate the 8x8 system at a range of temperatures, using the ILtemperaturerange.py file (shown [[Mod:DMS3053-temprange|here]]). Here, the temperature range of 0.25 to 5.00 was used, with a separation of 0.25 between points, whilst the runtime was set to 10000 (neglecting the property values for the first 1000 cycles). Running this simulation produced the graphs in ''Figure 5'', where error bars computed using standard errors have also been included (these are small as a consequence of small standard errors). From the graph of average energy versus temperature, the phase transition can be observed - this occurs in the region with a gradient that is not close to zero. The data used here (temperature, average energies, average squared-energies, average magnetisations and average squared-magnetisations) was then saved as a numpy array in a new file, 8x8.dat.

==The effect of system size==
[[File:DMSLatticeSizeCombinedPlot.png|300px|thumb|right|'''''Figure 6''': Average energy and average magnetisation (per spins) vs. temperature for multiple lattice sizes'']]
The process conducted for the 8x8 lattice in the previous exercise was then repeated for lattices of sizes 2x2, 4x4, 16x16 and 32x32, with the data saved in .dat files. These files were then accessed, and the average energy and magnetisation data were plotted on one graph for all of the lattices sizes - this was achieved using the script presented [[Mod:DMS3053-6|here]]. The graphs produced in this manner are shown in ''Figure 6''.

A consideration of this graph suggests that in order to capture the long range fluctuations, a 16x16 lattice is necessary.

==Determining the heat capacity==
[[File:DMSheatcapacity2.png|300px|thumb|right|'''''Figure 7''': Heat capacity (per spin) versus temperature for different lattice sizes'']]
Using the .dat files previously produced, the heat capacity was calculated for each lattice size using the equation
::<math>C = \frac{\partial E}{\partial T} = \frac{\mathrm{Var}[E]}{k_B T^2}</math>, (''eq. 9'') 
where <math>\mathrm{Var}[E] = <E^2> - <E>^2 </math>. When implementing this, the kB term was neglected due to the energy values having units of kB. The script used for this purpose is provided [[DMS3053-7|here]]. The plot of heat capacity per spin versus temperature for all of the lattice sizes considered is presented in ''Figure 7''.

==Locating the Curie temperature==
===Comparison with C++ Data===
The data for the heat capacity generated using the python script prepared in this experiment was compared to that from longer C++ computations - graphs showing this comparison are presented in ''Table 7'' for a range of lattice sizes. The Python code used to produce these graphs is shown [[Mod:DMS3053-8|here]].

Considering these graphs, it is clear that, in general, there is a reasonable correlation between the Python and C++ data; however, some of the data, particularly that for high lattice sizes, shows that the Python computations have not always found the maximum of heat capacity. This correlation would be improved by making computations at the same range of temperatures, but with a smaller gap between the temperatures taken; however, this would substantially increase computation time.
{| class="wikitable center" width=70%
|+ ''Table 7: Graphs of heat capacity (per spin) versus temperature for C++ and Python data''
|- style="text-align:center;"
| [[File:DMS2x2c.png|300px]] || [[File:DMS4x4c.png|300px]] || [[File:DMS8x8c.png|300px]]
|- style="text-align:center;"
| [[File:DMS16x16c.png|300px]] || [[File:DMS32x32c.png|300px]]
|}

===Polynomial Fitting===

</div>

Rep:Mod:DMS3053-5

2015-02-24T15:36:07Z

Ds3012:

import numpy as np
from math import exp, sqrt

class IsingLattice:

E = 0.0
E2 = 0.0
M = 0.0
M2 = 0.0
E_list = []
M_list = []

n_cycles = 0
skip_region = 0 # Defines the number of initial cycles not to be averaged for above quantities

def __init__(self, n_rows, n_cols):
self.n_rows = n_rows
self.n_cols = n_cols
self.lattice = np.random.choice([-1,1], size=(n_rows, n_cols))

def energy(self):
# Returns the total energy of the current lattice configuration.
J = 1.0 # Including this factor allows for later modifications
summed_spins = np.sum(np.multiply(self.lattice, np.roll(self.lattice, 1, axis = 0)))
# Multiplies a spin with its vertical neighbour, via rolling the array, then sums these results
summed_spins += np.sum(np.multiply(self.lattice, np.roll(self.lattice, 1, axis = 1)))
# Multiplies a spin with its horizontal neighbour, then sums these results
energy = - 1.0 * J * summed_spins
return energy

def magnetisation(self):
# Returns the total magnetisation of the current lattice configuration.
magnetisation = np.sum(self.lattice) # Sums all of the elements of the generated lattice
return magnetisation

def montecarlostep(self, T):
# This function performs a single Monte Carlo step
energy = self.energy() # Energies calculated using this function are in units of the Boltzmann constant
magnetisation = self.magnetisation()
# This section randomly selects the coordinate of the spin to be flipped, then flips it
#- generates new configuration
random_i = np.random.choice(range(0, self.n_rows))
random_j = np.random.choice(range(0, self.n_cols))
self.lattice[random_i, random_j] = - self.lattice[random_i, random_j]
energy1 = self.energy() # Calculates the energy of the new configuration
magnetisation1 = self.magnetisation() # Calculates the magnetisation of the new configuration
# The following line selects a random number in the range [0,1) for step 4 below
random_number = np.random.random()
# This section performs step 4 of the Monte Carlo cycle
deltaE = energy1 - energy # Calculates energy difference between
#new and original spin arrays
if deltaE < 0:# Accepts the new configuration and sets energy and magnetisation equal to the properties for the new arrangement
energy = energy1
magnetisation = magnetisation1
elif random_number <= exp(- deltaE / T): # Allows for statistical inclusion of arrangements with deltaE > 0, with a 'large' Boltzmann factor
energy = energy1
magnetisation = magnetisation1
else: # Rejects the new arrangement - flips the spin back to that in the original self.lattice
self.lattice[random_i, random_j] = - self.lattice[random_i, random_j]
if self.n_cycles >= self.skip_region: # Begins adding values to running sums after self.skip_region cycles
self.E += energy
self.E2 += energy**2
self.M += magnetisation
self.M2 += magnetisation**2 # self.X updates the running total for property X
self.E_list.append(energy)
self.M_list.append(magnetisation) # Appends values to list for standard error calculation
else:
pass
self.n_cycles += 1 # Updates the running total for number of Monte Carlo cycles
return energy, magnetisation

def statistics(self):
# This function calculates the values for the averages of E, E*E (E2), M, M*M (M2), and returns them
averaging_cycles = self.n_cycles - self.skip_region
avgE = self.E / averaging_cycles
avgE2 = self.E2 / averaging_cycles
avgM = self.M / averaging_cycles
avgM2 = self.M2 / averaging_cycles
std_errorE = np.std(self.E_list) / sqrt(averaging_cycles)
std_errorM = np.std(self.M_list) / sqrt(averaging_cycles)
return avgE, avgE2, avgM, avgM2, self.n_cycles, std_errorE, std_errorM

Rep:Mod:DMS3053

2015-02-24T14:59:29Z

Ds3012: /* Locating the Curie temperature */

'''CMP Programming Experiment - Daniel Spencer, 00736964'''
<div style="text-align: justify">
==Introduction to the Ising Model==
===Minimum energy of the Ising Model===
Using the equation 
::<math>E= - \frac{1}{2} J \sum_i^N \sum_{j\ \in\ \mathrm{neighbours}\left(i\right)} s_i s_j</math> (''eq. 1'') 
the minimum energy of an Ising lattice of <math>D</math> dimensions, with <math>N</math> spins (where each
spin had a value of +1 or -1) and an interaction strength of <math>J</math> was considered. This was achieved first through a consideration of a one-dimensional system with five parallel spins (where the spins are parallel as this corresponds to the minimum energy arrangement of the system). Hence, the energy of this linear system was found to be 
::<math>E_\text{min,1D} = -5J </math>. 
For a linear, one-dimensional system, the number of neigbouring spins is two. The number of neighbours can be determined for two- and three- dimensional systems through a geometric consideration of their structure - the values are presented in ''Table 1''.
{| class="wikitable floatright" width=42%
|+ ''Table 1: Dimension numbers and number of neighbours''
! Number of Dimensions, D !! Number of Neighbours
|- style="text-align:center;"
| 1 || 2
|- style="text-align:center;"
| 2 || 4
|- style="text-align:center;"
| 3 || 6
|- style="text-align:center;"
| D || 2D
|}
These data indicate that the number of neighbours is twice the number of dimensions, for the dimensions considered here. This can be extrapolated to give the general number of neighbours as <math>2D</math>.

For the minimum energy of the system, where all spins are parallel, every combination <math>s_i s_j</math> has a value of 1. Notably, for each value of <math>i</math>, there will be <math>2D</math> neighbour interactions. Ergo, using ''eq. 1'', the general minimum energy can be found to be
::<math>E_\text{min,D} = -DNJ </math> (''eq. 2''). 
To check this equation, it can be applied to the two-dimensional Ising lattice with 25 spins - this gives a value of
::<math>E_\text{min,2D} = -50J </math>, 
which matches with the value predicted from first-principles.

For this D-dimensional system, the multiplicity (i.e. the number of ways of achieving the specified configuration of spins) must be equal to two, as either all of the spins could be aligned 'up' (+1) or 'down' (-1). Using this multiplicity, the entropy of the system can be calculated using the equation
::<math>S = k_B \ln\Omega</math>, (''eq. 3'') 
where Ω is the number of microstates (equal to the multiplicity in this case), which gives a value of <math>k_B \ln2 </math>, or 9.57 x 10-24 J K-1.

===Spin 'flipping'===

Using the Ising model, it is also possible to consider a change in state, reflected by a 'flipping' of the direction of one of the lattice spins. For this case, the energy (using ''eq. 1'') can be determined to be
::<math>E'= - \frac{1}{2} J (2DN - 4D - 4D) = 4DJ - DNJ</math>, (''eq. 4'') 
where the additional <math>4D</math> terms arise from the loss of 4D stabilising spin-aligned interactions and the gain of 4D destabilising spins anti-aligned interactions following spin 'flipping'. Using ''eq. 2'' and ''eq. 4'', the change in energy derived from this spin 'flip' can be calculated to be
::<math>\Delta E= 4DJ - DNJ + DNJ = 4DJ</math>. (''eq. 5'') 
For a system with three dimensions (D = 3) and 1000 spins (N = 1000), the system, using ''eq. 5'', was determined to increase in energy by <math>12 J</math>. Notably, this change in energy is independent of the number of spins in the system - it depends only on the number of dimensions and J.
[[File:ThirdYearCMPExpt-IsingSketch.png|300px|thumb|right|'' '''Figure 1''': Representation of Ising lattices in one (N=5), two (N=25), and three (N=125) dimensions. +1 and -1 spins are denoted by the red and blue cells respectively. Diagram taken from the lab script.'']]
A significant consideration with regards to the spin 'flipping' described here is the accompanying increase in entropy - the driving force for this process. For the scenario describing the change in direction of a single spin, the multiplicity of the system will be <math>2N</math> - this is a consequence of the system prior to 'flipping' having a multiplicity of two (all spins aligned 'up' or 'down'), where now, any one of the spins could flip, adding the factor of N to the multiplicity. Hence, the new entropy can be defined to be
::<math>S' = k_B \ln 2N</math>, (''eq. 6'') 
which allows the change in entropy to be calculated according to ''eq. 7''.
::<math>\Delta S = k_B \ln 2N - k_B \ln2 = k_B \ln N</math> (''eq. 7'') 
For the system described above (D = 3, N = 1000), the change in entropy associated with the spin 'flip' process is therefore <math>k_B ln 1000</math>, which is equal to 9.53 x 10-23 J K-1.

===Magnetisation===
{| class="wikitable floatright" width=42%
|+ ''Table 2: Ising lattices and magnetisations''
! Ising Lattice !! Magnetisation
|- style="text-align:center;"
| 1D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 2D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 3D at 0 K || 1000 or -1000
|}
''Figure 1'' shows three examples of Ising lattices, with one, two and three dimensions respectively. Using the equation for magnetisation (''eq. 8''), the magnetisations of these systems can be calculated to be those presented in ''Table 2''.
::<math>M= \sum_i s_i</math> (''eq. 8'') 
For the three-dimensional system at a temperature of 0 K, all of the spins must be aligned either 'up' or 'down', as the entropic increase associated with 'flipped' spins does not provide a driving force at absolute zero - the only factor to consider is that of the energy, which is a minimum when all of the spins are aligned. For this case, the magnetisation could be either 1000 or -1000, depending upon the direction of the spin alignment. From a consideration of the magnetisation values calculated here, it is evident that with all of the spins aligned, the (magnitude of the) magnetisation of the system is at a maximum.

==Calculating the energy and magnetisation==
===Modifying the files===
[[File:DMStest_output2.png|300px|thumb|right|'' '''Figure 2''': Output image from testing IsingLattice.py using Ilcheck.py'']]
In order to use Python to compute the energy and magnetisation for a given two-dimensional Ising lattice, the class IsingLattice was used, where energy() and magnetisation() functions were written to calculate their corresponding properties for a random numpy array of spins (generated using np.random.choice). For this aspect of the experiment, the value of J was assumed to be 1.0, working in reduced units. The Python script developed can be viewed [[Mod:DMS3053-1|here]], including annotations.

===Testing the files===
In order to test the script prepared thus far, the Ilcheck.py script was run, generating the image presented in ''Figure 2''. An examination of this output clearly indicates that the script provides accurate energies and magnetisations for the minimum and maximum energy configurations, along with for an intermediate, random arrangement. Hence, it can be concluded that at the current level, the Python script is functioning as required.

==Introduction to the Monte Carlo simulation==
===Average Energy and Magnetisation===
[[File:DMSILanim3.png|300px|thumb|right|'''''Figure 3''': Animation result from ILanim.py, showing the resting of the system in the minimum energy state'']]
[[File:DMSILanim_meta.png|300px|thumb|right|'''''Figure 4''': Animation result from ILanim.py, showing the resting of the system in a meta-stable state'']]

In order to consider the generalisability of the prepared script, it is important to analyse how the script will function for large systems, such as those with 100 spins in the spin array. As each of these spins can be either 'up' or 'down', each spin has two choices. Hence, the number of possible configurations for the system can be written as <math>2^{100}</math>, which has a value of 1.2677 x 1030.

If one considers the sampling of a single configuration to take 1 x 10-9 s, then it is clear that sampling all of these considerations would take a total of 1.2677 x 1021 s (also expressed as 4.017 x 1013 years). From this analysis, it is evident that the sampling of configurations was a significant consideration in the writing of a python script for this task.

In order to account for this, the technique of importance sampling was implemented, using the statistical Boltzmann distribution, <math>\exp(- \Delta E / k_B T)</math>. Note that as the energy computed using the energy() function is in units of kB, this factor is not included in the script.

===Modifying IsingLattice.py to Implement a Monte Carlo Cycle===
The python script developed at this stage is presented [[Mod:DMS3053-2|here]], accompanied by annotations to explain how the script functions.

===Simulating the Monte Carlo Cycles===
{| class="wikitable floatright" width=42%
|+ ''Table 3: statistics() output for animated system at global minimum configuration (Figure 3)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.70542501728
|- style="text-align:center;"
| <E2> || 3.13520970111
|- style="text-align:center;"
| <M> || -0.829971492744
|- style="text-align:center;"
| <M2> || 0.770986982766
|}
For cases where T < Tc, it would be expected that the system would have a spontaneous magnetisation. When T > Tc, the entropy will be the dominating factor, potentially resulting in the system having a magnetisation of zero.
{| class="wikitable floatright" width=42%
|+ ''Table 4: statistics() output for animated system at meta-stable configuration (Figure 4)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.35076450189
|- style="text-align:center;"
| <E2> || 1.89025801939
|- style="text-align:center;"
| <M> || -0.344104665826
|- style="text-align:center;"
| <M2> || 0.138855365306
|}
Using the presented script and the ILanim.py script, the Monte Carlo cycles can be simulated to view the results on the spin array as the process progresses. Here, the system under consideration was an 8 x 8 spin array, at a temperature of 0.5. ''Figure 3'' shows the typical outcome of the animation, with the system having reached the most stable, minimum energy arrangement. For the result presented here, the output of the statistics() function was that shown in ''Table 3''.

It was also observed that the system could locate a meta-stable state, with large regions of spin 'up' and 'down' spins. An example of such a result is presented in ''Figure 4'' (for which the output data from statistics() is presented in ''Table 4'').

==Accelerating the code==

In order to examine the efficiency of the python script developed thus far, the Iltimetrial.py script was utilised to investigate the time taken to perform 2000 Monte Carlo cycles. This script was modified to the version presented [[Mod:DMS3053-3|here]], which repeats the time measurement a defined number of times, then calculates the average time and the standard error in this average. For the Monte Carlo script prepared previously, the average time for 2000 Monte Carlo cycles was measured to be 5.475804 s and a standard error was calculated to be 0.008325 s, with 100 measurements made using the script.

Evidently, the current script is slow at conducting large numbers of Monte Carlo cycles and hence, a more efficient script was developed using the np.roll, np.multiply and np.sum functions - this is presented [[Mod:DMS3053-4|here]].

After this optimisation of the python script, the Iltimetrial.py script was re-run, giving an average time of 0.291467 s, with a standard error of 0.000156 s. Clearly, this optimised script is substantially faster than that developed previously (approximately 19 times faster).

==The effect of temperature==
===Correcting the averaging code===
As the equilibrium state of the system requires a number of Monte Carlo cycles to be reached, it is evident that the average energies and magnetisations are accounting for values for non-equilibrium arrangements - this was accounted for through a consideration of the number of cycles required to reach equilibrium. For this, the ILfinalframe.py script was used, giving the graphs shown in ''Table 5''. Here, each system was run for 150000 Monte Carlo cycles.
{| class="wikitable center" width=70%
|+ ''Table 5: Graphs of energy and magnetisation versus number of Monte Carlo cycles for different temperatures and system sizes''
! Temperature !! System Size !! Resulting Graphs !! Cycles for Equilibrium
|- style="text-align:center;"
| 0.5 || 4x4 || [[File:DMS0544.png|300px]] || 24
|- style="text-align:center;"
| 0.5 || 8x8 || [[File:DMS0588.png|300px]] || 392
|- style="text-align:center;"
| 0.5 || 16x16 || [[File:DMS051616.png|300px]] || 5549
|- style="text-align:center;"
| 1.0 || 2x2 || [[File:DMS1022.png|300px]] || (0)
|- style="text-align:center;"
| 1.0 || 4x4 || [[File:DMS1044.png|300px]] || 49
|- style="text-align:center;"
| 1.0 || 8x8 || [[File:DMS10882.png|300px]] || 590
|- style="text-align:center;"
| 1.0 || 16x16 || [[File:DMS101616.png|300px]] || ~6300
|- style="text-align:center;"
| 1.0 || 32x32 || [[File:DMS103232.png|300px]] || ~110000
|- style="text-align:center;"
| 2.0 || 4x4 || [[File:DMS2044.png|300px]] || -
|- style="text-align:center;"
| 2.0 || 8x8 || [[File:DMS2088.png|300px]] || -
|}
{| class="wikitable floatright" width=42%
|+ ''Table 6: Number of cycles to be ignored for each system size''
! System Size !! Number of cycles before averaging
|- style="text-align:center;"
| 2x2 || 0
|- style="text-align:center;"
| 4x4 || 100
|- style="text-align:center;"
| 8x8 || 1000
|- style="text-align:center;"
| 16x16 || 8000
|- style="text-align:center;"
| 32x32 || 120000
|}
Analysis of these graphs indicates that at higher temperatures, such as 2.0 (also observed at 1.5), large fluctuations in the energy and magnetisation are observed - these fluctuations are the reason that the average values of the properties must be taken. As the temperature is increased for systems of size 4x4, 8x8 and 16x16, it is clear that the number of cycles required in order to reach equilibrium increases. Hence, for the temperature range to be considered later (0.25 to 5.00), the required number of cycles was overestimated in order to ensure that all measurements were taken whilst the system was in equilibrium. The proposed numbers of cycles to be ignored for each system size are presented in ''Table 6''.

The python script developed up to this point was modified to account for these values by inclusion of a skip_region variable, which defines the number of cycles performed before energies and magnetisations contribute to the self.X values (before averaging occurs). The modified script is presented [[Mod:DMS3053-5|here]].

===Running over a range of temperatures===
[[File:DMS88dat.png|300px|thumb|right|'''''Figure 5''': Average energy and average magnetisation vs. temperature for 8x8 lattice, with error bars'']]
Using the python script modified in the previous exercise, the code can now be used to simulate the 8x8 system at a range of temperatures, using the ILtemperaturerange.py file. Here, the temperature range of 0.25 to 5.00 was used, with a separation of 0.25 between points, whilst the runtime was set to 10000 (neglecting the property values for the first 1000 cycles). Running this simulation produced the graphs in ''Figure 5'', where error bars computed using standard errors have also been included (these are small as a consequence of small standard errors). From the graph of average energy versus temperature, the phase transition can be observed - this occurs in the region with a gradient that is not close to zero. The data used here (temperature, average energies, average squared-energies, average magnetisations and average squared-magnetisations) was then saved as a numpy array in a new file, 8x8.dat.

==The effect of system size==
[[File:DMSLatticeSizeCombinedPlot.png|300px|thumb|right|'''''Figure 6''': Average energy and average magnetisation (per spins) vs. temperature for multiple lattice sizes'']]
The process conducted for the 8x8 lattice in the previous exercise was then repeated for lattices of sizes 2x2, 4x4, 16x16 and 32x32, with the data saved in .dat files. These files were then accessed, and the average energy and magnetisation data were plotted on one graph for all of the lattices sizes - this was achieved using the script presented [[Mod:DMS3053-6|here]]. The graphs produced in this manner are shown in ''Figure 6''.

A consideration of this graph suggests that in order to capture the long range fluctuations, a 16x16 lattice is necessary.

==Determining the heat capacity==
[[File:DMSheatcapacity2.png|300px|thumb|right|'''''Figure 7''': Heat capacity (per spin) versus temperature for different lattice sizes'']]
Using the .dat files previously produced, the heat capacity was calculated for each lattice size using the equation
::<math>C = \frac{\partial E}{\partial T} = \frac{\mathrm{Var}[E]}{k_B T^2}</math>, (''eq. 9'') 
where <math>\mathrm{Var}[E] = <E^2> - <E>^2 </math>. When implementing this, the kB term was neglected due to the energy values having units of kB. The script used for this purpose is provided [[DMS3053-7|here]]. The plot of heat capacity per spin versus temperature for all of the lattice sizes considered is presented in ''Figure 7''.

==Locating the Curie temperature==
===Comparison with C++ Data===
The data for the heat capacity generated using the python script prepared in this experiment was compared to that from longer C++ computations - graphs showing this comparison are presented in ''Table 7'' for a range of lattice sizes. The Python code used to produce these graphs is shown [[Mod:DMS3053-8|here]].

Considering these graphs, it is clear that, in general, there is a reasonable correlation between the Python and C++ data; however, some of the data, particularly that for high lattice sizes, shows that the Python computations have not always found the maximum of heat capacity. This correlation would be improved by making computations at the same range of temperatures, but with a smaller gap between the temperatures taken; however, this would substantially increase computation time.
{| class="wikitable center" width=70%
|+ ''Table 7: Graphs of heat capacity (per spin) versus temperature for C++ and Python data''
|- style="text-align:center;"
| [[File:DMS2x2c.png|300px]] || [[File:DMS4x4c.png|300px]] || [[File:DMS8x8c.png|300px]]
|- style="text-align:center;"
| [[File:DMS16x16c.png|300px]] || [[File:DMS32x32c.png|300px]]
|}

===Polynomial Fitting===

</div>

Rep:Mod:DMS3053

2015-02-24T14:52:19Z

Ds3012: /* Locating the Curie temperature */

'''CMP Programming Experiment - Daniel Spencer, 00736964'''
<div style="text-align: justify">
==Introduction to the Ising Model==
===Minimum energy of the Ising Model===
Using the equation 
::<math>E= - \frac{1}{2} J \sum_i^N \sum_{j\ \in\ \mathrm{neighbours}\left(i\right)} s_i s_j</math> (''eq. 1'') 
the minimum energy of an Ising lattice of <math>D</math> dimensions, with <math>N</math> spins (where each
spin had a value of +1 or -1) and an interaction strength of <math>J</math> was considered. This was achieved first through a consideration of a one-dimensional system with five parallel spins (where the spins are parallel as this corresponds to the minimum energy arrangement of the system). Hence, the energy of this linear system was found to be 
::<math>E_\text{min,1D} = -5J </math>. 
For a linear, one-dimensional system, the number of neigbouring spins is two. The number of neighbours can be determined for two- and three- dimensional systems through a geometric consideration of their structure - the values are presented in ''Table 1''.
{| class="wikitable floatright" width=42%
|+ ''Table 1: Dimension numbers and number of neighbours''
! Number of Dimensions, D !! Number of Neighbours
|- style="text-align:center;"
| 1 || 2
|- style="text-align:center;"
| 2 || 4
|- style="text-align:center;"
| 3 || 6
|- style="text-align:center;"
| D || 2D
|}
These data indicate that the number of neighbours is twice the number of dimensions, for the dimensions considered here. This can be extrapolated to give the general number of neighbours as <math>2D</math>.

For the minimum energy of the system, where all spins are parallel, every combination <math>s_i s_j</math> has a value of 1. Notably, for each value of <math>i</math>, there will be <math>2D</math> neighbour interactions. Ergo, using ''eq. 1'', the general minimum energy can be found to be
::<math>E_\text{min,D} = -DNJ </math> (''eq. 2''). 
To check this equation, it can be applied to the two-dimensional Ising lattice with 25 spins - this gives a value of
::<math>E_\text{min,2D} = -50J </math>, 
which matches with the value predicted from first-principles.

For this D-dimensional system, the multiplicity (i.e. the number of ways of achieving the specified configuration of spins) must be equal to two, as either all of the spins could be aligned 'up' (+1) or 'down' (-1). Using this multiplicity, the entropy of the system can be calculated using the equation
::<math>S = k_B \ln\Omega</math>, (''eq. 3'') 
where Ω is the number of microstates (equal to the multiplicity in this case), which gives a value of <math>k_B \ln2 </math>, or 9.57 x 10-24 J K-1.

===Spin 'flipping'===

Using the Ising model, it is also possible to consider a change in state, reflected by a 'flipping' of the direction of one of the lattice spins. For this case, the energy (using ''eq. 1'') can be determined to be
::<math>E'= - \frac{1}{2} J (2DN - 4D - 4D) = 4DJ - DNJ</math>, (''eq. 4'') 
where the additional <math>4D</math> terms arise from the loss of 4D stabilising spin-aligned interactions and the gain of 4D destabilising spins anti-aligned interactions following spin 'flipping'. Using ''eq. 2'' and ''eq. 4'', the change in energy derived from this spin 'flip' can be calculated to be
::<math>\Delta E= 4DJ - DNJ + DNJ = 4DJ</math>. (''eq. 5'') 
For a system with three dimensions (D = 3) and 1000 spins (N = 1000), the system, using ''eq. 5'', was determined to increase in energy by <math>12 J</math>. Notably, this change in energy is independent of the number of spins in the system - it depends only on the number of dimensions and J.
[[File:ThirdYearCMPExpt-IsingSketch.png|300px|thumb|right|'' '''Figure 1''': Representation of Ising lattices in one (N=5), two (N=25), and three (N=125) dimensions. +1 and -1 spins are denoted by the red and blue cells respectively. Diagram taken from the lab script.'']]
A significant consideration with regards to the spin 'flipping' described here is the accompanying increase in entropy - the driving force for this process. For the scenario describing the change in direction of a single spin, the multiplicity of the system will be <math>2N</math> - this is a consequence of the system prior to 'flipping' having a multiplicity of two (all spins aligned 'up' or 'down'), where now, any one of the spins could flip, adding the factor of N to the multiplicity. Hence, the new entropy can be defined to be
::<math>S' = k_B \ln 2N</math>, (''eq. 6'') 
which allows the change in entropy to be calculated according to ''eq. 7''.
::<math>\Delta S = k_B \ln 2N - k_B \ln2 = k_B \ln N</math> (''eq. 7'') 
For the system described above (D = 3, N = 1000), the change in entropy associated with the spin 'flip' process is therefore <math>k_B ln 1000</math>, which is equal to 9.53 x 10-23 J K-1.

===Magnetisation===
{| class="wikitable floatright" width=42%
|+ ''Table 2: Ising lattices and magnetisations''
! Ising Lattice !! Magnetisation
|- style="text-align:center;"
| 1D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 2D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 3D at 0 K || 1000 or -1000
|}
''Figure 1'' shows three examples of Ising lattices, with one, two and three dimensions respectively. Using the equation for magnetisation (''eq. 8''), the magnetisations of these systems can be calculated to be those presented in ''Table 2''.
::<math>M= \sum_i s_i</math> (''eq. 8'') 
For the three-dimensional system at a temperature of 0 K, all of the spins must be aligned either 'up' or 'down', as the entropic increase associated with 'flipped' spins does not provide a driving force at absolute zero - the only factor to consider is that of the energy, which is a minimum when all of the spins are aligned. For this case, the magnetisation could be either 1000 or -1000, depending upon the direction of the spin alignment. From a consideration of the magnetisation values calculated here, it is evident that with all of the spins aligned, the (magnitude of the) magnetisation of the system is at a maximum.

==Calculating the energy and magnetisation==
===Modifying the files===
[[File:DMStest_output2.png|300px|thumb|right|'' '''Figure 2''': Output image from testing IsingLattice.py using Ilcheck.py'']]
In order to use Python to compute the energy and magnetisation for a given two-dimensional Ising lattice, the class IsingLattice was used, where energy() and magnetisation() functions were written to calculate their corresponding properties for a random numpy array of spins (generated using np.random.choice). For this aspect of the experiment, the value of J was assumed to be 1.0, working in reduced units. The Python script developed can be viewed [[Mod:DMS3053-1|here]], including annotations.

===Testing the files===
In order to test the script prepared thus far, the Ilcheck.py script was run, generating the image presented in ''Figure 2''. An examination of this output clearly indicates that the script provides accurate energies and magnetisations for the minimum and maximum energy configurations, along with for an intermediate, random arrangement. Hence, it can be concluded that at the current level, the Python script is functioning as required.

==Introduction to the Monte Carlo simulation==
===Average Energy and Magnetisation===
[[File:DMSILanim3.png|300px|thumb|right|'''''Figure 3''': Animation result from ILanim.py, showing the resting of the system in the minimum energy state'']]
[[File:DMSILanim_meta.png|300px|thumb|right|'''''Figure 4''': Animation result from ILanim.py, showing the resting of the system in a meta-stable state'']]

In order to consider the generalisability of the prepared script, it is important to analyse how the script will function for large systems, such as those with 100 spins in the spin array. As each of these spins can be either 'up' or 'down', each spin has two choices. Hence, the number of possible configurations for the system can be written as <math>2^{100}</math>, which has a value of 1.2677 x 1030.

If one considers the sampling of a single configuration to take 1 x 10-9 s, then it is clear that sampling all of these considerations would take a total of 1.2677 x 1021 s (also expressed as 4.017 x 1013 years). From this analysis, it is evident that the sampling of configurations was a significant consideration in the writing of a python script for this task.

In order to account for this, the technique of importance sampling was implemented, using the statistical Boltzmann distribution, <math>\exp(- \Delta E / k_B T)</math>. Note that as the energy computed using the energy() function is in units of kB, this factor is not included in the script.

===Modifying IsingLattice.py to Implement a Monte Carlo Cycle===
The python script developed at this stage is presented [[Mod:DMS3053-2|here]], accompanied by annotations to explain how the script functions.

===Simulating the Monte Carlo Cycles===
{| class="wikitable floatright" width=42%
|+ ''Table 3: statistics() output for animated system at global minimum configuration (Figure 3)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.70542501728
|- style="text-align:center;"
| <E2> || 3.13520970111
|- style="text-align:center;"
| <M> || -0.829971492744
|- style="text-align:center;"
| <M2> || 0.770986982766
|}
For cases where T < Tc, it would be expected that the system would have a spontaneous magnetisation. When T > Tc, the entropy will be the dominating factor, potentially resulting in the system having a magnetisation of zero.
{| class="wikitable floatright" width=42%
|+ ''Table 4: statistics() output for animated system at meta-stable configuration (Figure 4)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.35076450189
|- style="text-align:center;"
| <E2> || 1.89025801939
|- style="text-align:center;"
| <M> || -0.344104665826
|- style="text-align:center;"
| <M2> || 0.138855365306
|}
Using the presented script and the ILanim.py script, the Monte Carlo cycles can be simulated to view the results on the spin array as the process progresses. Here, the system under consideration was an 8 x 8 spin array, at a temperature of 0.5. ''Figure 3'' shows the typical outcome of the animation, with the system having reached the most stable, minimum energy arrangement. For the result presented here, the output of the statistics() function was that shown in ''Table 3''.

It was also observed that the system could locate a meta-stable state, with large regions of spin 'up' and 'down' spins. An example of such a result is presented in ''Figure 4'' (for which the output data from statistics() is presented in ''Table 4'').

==Accelerating the code==

In order to examine the efficiency of the python script developed thus far, the Iltimetrial.py script was utilised to investigate the time taken to perform 2000 Monte Carlo cycles. This script was modified to the version presented [[Mod:DMS3053-3|here]], which repeats the time measurement a defined number of times, then calculates the average time and the standard error in this average. For the Monte Carlo script prepared previously, the average time for 2000 Monte Carlo cycles was measured to be 5.475804 s and a standard error was calculated to be 0.008325 s, with 100 measurements made using the script.

Evidently, the current script is slow at conducting large numbers of Monte Carlo cycles and hence, a more efficient script was developed using the np.roll, np.multiply and np.sum functions - this is presented [[Mod:DMS3053-4|here]].

After this optimisation of the python script, the Iltimetrial.py script was re-run, giving an average time of 0.291467 s, with a standard error of 0.000156 s. Clearly, this optimised script is substantially faster than that developed previously (approximately 19 times faster).

==The effect of temperature==
===Correcting the averaging code===
As the equilibrium state of the system requires a number of Monte Carlo cycles to be reached, it is evident that the average energies and magnetisations are accounting for values for non-equilibrium arrangements - this was accounted for through a consideration of the number of cycles required to reach equilibrium. For this, the ILfinalframe.py script was used, giving the graphs shown in ''Table 5''. Here, each system was run for 150000 Monte Carlo cycles.
{| class="wikitable center" width=70%
|+ ''Table 5: Graphs of energy and magnetisation versus number of Monte Carlo cycles for different temperatures and system sizes''
! Temperature !! System Size !! Resulting Graphs !! Cycles for Equilibrium
|- style="text-align:center;"
| 0.5 || 4x4 || [[File:DMS0544.png|300px]] || 24
|- style="text-align:center;"
| 0.5 || 8x8 || [[File:DMS0588.png|300px]] || 392
|- style="text-align:center;"
| 0.5 || 16x16 || [[File:DMS051616.png|300px]] || 5549
|- style="text-align:center;"
| 1.0 || 2x2 || [[File:DMS1022.png|300px]] || (0)
|- style="text-align:center;"
| 1.0 || 4x4 || [[File:DMS1044.png|300px]] || 49
|- style="text-align:center;"
| 1.0 || 8x8 || [[File:DMS10882.png|300px]] || 590
|- style="text-align:center;"
| 1.0 || 16x16 || [[File:DMS101616.png|300px]] || ~6300
|- style="text-align:center;"
| 1.0 || 32x32 || [[File:DMS103232.png|300px]] || ~110000
|- style="text-align:center;"
| 2.0 || 4x4 || [[File:DMS2044.png|300px]] || -
|- style="text-align:center;"
| 2.0 || 8x8 || [[File:DMS2088.png|300px]] || -
|}
{| class="wikitable floatright" width=42%
|+ ''Table 6: Number of cycles to be ignored for each system size''
! System Size !! Number of cycles before averaging
|- style="text-align:center;"
| 2x2 || 0
|- style="text-align:center;"
| 4x4 || 100
|- style="text-align:center;"
| 8x8 || 1000
|- style="text-align:center;"
| 16x16 || 8000
|- style="text-align:center;"
| 32x32 || 120000
|}
Analysis of these graphs indicates that at higher temperatures, such as 2.0 (also observed at 1.5), large fluctuations in the energy and magnetisation are observed - these fluctuations are the reason that the average values of the properties must be taken. As the temperature is increased for systems of size 4x4, 8x8 and 16x16, it is clear that the number of cycles required in order to reach equilibrium increases. Hence, for the temperature range to be considered later (0.25 to 5.00), the required number of cycles was overestimated in order to ensure that all measurements were taken whilst the system was in equilibrium. The proposed numbers of cycles to be ignored for each system size are presented in ''Table 6''.

The python script developed up to this point was modified to account for these values by inclusion of a skip_region variable, which defines the number of cycles performed before energies and magnetisations contribute to the self.X values (before averaging occurs). The modified script is presented [[Mod:DMS3053-5|here]].

===Running over a range of temperatures===
[[File:DMS88dat.png|300px|thumb|right|'''''Figure 5''': Average energy and average magnetisation vs. temperature for 8x8 lattice, with error bars'']]
Using the python script modified in the previous exercise, the code can now be used to simulate the 8x8 system at a range of temperatures, using the ILtemperaturerange.py file. Here, the temperature range of 0.25 to 5.00 was used, with a separation of 0.25 between points, whilst the runtime was set to 10000 (neglecting the property values for the first 1000 cycles). Running this simulation produced the graphs in ''Figure 5'', where error bars computed using standard errors have also been included (these are small as a consequence of small standard errors). From the graph of average energy versus temperature, the phase transition can be observed - this occurs in the region with a gradient that is not close to zero. The data used here (temperature, average energies, average squared-energies, average magnetisations and average squared-magnetisations) was then saved as a numpy array in a new file, 8x8.dat.

==The effect of system size==
[[File:DMSLatticeSizeCombinedPlot.png|300px|thumb|right|'''''Figure 6''': Average energy and average magnetisation (per spins) vs. temperature for multiple lattice sizes'']]
The process conducted for the 8x8 lattice in the previous exercise was then repeated for lattices of sizes 2x2, 4x4, 16x16 and 32x32, with the data saved in .dat files. These files were then accessed, and the average energy and magnetisation data were plotted on one graph for all of the lattices sizes - this was achieved using the script presented [[Mod:DMS3053-6|here]]. The graphs produced in this manner are shown in ''Figure 6''.

A consideration of this graph suggests that in order to capture the long range fluctuations, a 16x16 lattice is necessary.

==Determining the heat capacity==
[[File:DMSheatcapacity2.png|300px|thumb|right|'''''Figure 7''': Heat capacity (per spin) versus temperature for different lattice sizes'']]
Using the .dat files previously produced, the heat capacity was calculated for each lattice size using the equation
::<math>C = \frac{\partial E}{\partial T} = \frac{\mathrm{Var}[E]}{k_B T^2}</math>, (''eq. 9'') 
where <math>\mathrm{Var}[E] = <E^2> - <E>^2 </math>. When implementing this, the kB term was neglected due to the energy values having units of kB. The script used for this purpose is provided [[DMS3053-7|here]]. The plot of heat capacity per spin versus temperature for all of the lattice sizes considered is presented in ''Figure 7''.

==Locating the Curie temperature==
===Comparison with C++ Data===
The data for the heat capacity generated using the python script prepared in this experiment was compared to that from longer C++ computations - graphs showing this comparison are presented in ''Table 7'' for a range of lattice sizes.

Considering these graphs, it is clear that, in general, there is a reasonable correlation between the Python and C++ data; however, some of the data, particularly that for high lattice sizes, shows that the Python computations have not always found the maximum of heat capacity. This correlation would be improved by making computations at the same range of temperatures, but with a smaller gap between the temperatures taken; however, this would substantially increase computation time.
{| class="wikitable center" width=70%
|+ ''Table 7: Graphs of heat capacity (per spin) versus temperature for C++ and Python data''
|- style="text-align:center;"
| [[File:DMS2x2c.png|300px]] || [[File:DMS4x4c.png|300px]] || [[File:DMS8x8c.png|300px]]
|- style="text-align:center;"
| [[File:DMS16x16c.png|300px]] || [[File:DMS32x32c.png|300px]]
|}

===Polynomial Fitting===

</div>

Rep:Mod:DMS3053

2015-02-24T14:49:10Z

Ds3012: /* Locating the Curie temperature */

'''CMP Programming Experiment - Daniel Spencer, 00736964'''
<div style="text-align: justify">
==Introduction to the Ising Model==
===Minimum energy of the Ising Model===
Using the equation 
::<math>E= - \frac{1}{2} J \sum_i^N \sum_{j\ \in\ \mathrm{neighbours}\left(i\right)} s_i s_j</math> (''eq. 1'') 
the minimum energy of an Ising lattice of <math>D</math> dimensions, with <math>N</math> spins (where each
spin had a value of +1 or -1) and an interaction strength of <math>J</math> was considered. This was achieved first through a consideration of a one-dimensional system with five parallel spins (where the spins are parallel as this corresponds to the minimum energy arrangement of the system). Hence, the energy of this linear system was found to be 
::<math>E_\text{min,1D} = -5J </math>. 
For a linear, one-dimensional system, the number of neigbouring spins is two. The number of neighbours can be determined for two- and three- dimensional systems through a geometric consideration of their structure - the values are presented in ''Table 1''.
{| class="wikitable floatright" width=42%
|+ ''Table 1: Dimension numbers and number of neighbours''
! Number of Dimensions, D !! Number of Neighbours
|- style="text-align:center;"
| 1 || 2
|- style="text-align:center;"
| 2 || 4
|- style="text-align:center;"
| 3 || 6
|- style="text-align:center;"
| D || 2D
|}
These data indicate that the number of neighbours is twice the number of dimensions, for the dimensions considered here. This can be extrapolated to give the general number of neighbours as <math>2D</math>.

For the minimum energy of the system, where all spins are parallel, every combination <math>s_i s_j</math> has a value of 1. Notably, for each value of <math>i</math>, there will be <math>2D</math> neighbour interactions. Ergo, using ''eq. 1'', the general minimum energy can be found to be
::<math>E_\text{min,D} = -DNJ </math> (''eq. 2''). 
To check this equation, it can be applied to the two-dimensional Ising lattice with 25 spins - this gives a value of
::<math>E_\text{min,2D} = -50J </math>, 
which matches with the value predicted from first-principles.

For this D-dimensional system, the multiplicity (i.e. the number of ways of achieving the specified configuration of spins) must be equal to two, as either all of the spins could be aligned 'up' (+1) or 'down' (-1). Using this multiplicity, the entropy of the system can be calculated using the equation
::<math>S = k_B \ln\Omega</math>, (''eq. 3'') 
where Ω is the number of microstates (equal to the multiplicity in this case), which gives a value of <math>k_B \ln2 </math>, or 9.57 x 10-24 J K-1.

===Spin 'flipping'===

Using the Ising model, it is also possible to consider a change in state, reflected by a 'flipping' of the direction of one of the lattice spins. For this case, the energy (using ''eq. 1'') can be determined to be
::<math>E'= - \frac{1}{2} J (2DN - 4D - 4D) = 4DJ - DNJ</math>, (''eq. 4'') 
where the additional <math>4D</math> terms arise from the loss of 4D stabilising spin-aligned interactions and the gain of 4D destabilising spins anti-aligned interactions following spin 'flipping'. Using ''eq. 2'' and ''eq. 4'', the change in energy derived from this spin 'flip' can be calculated to be
::<math>\Delta E= 4DJ - DNJ + DNJ = 4DJ</math>. (''eq. 5'') 
For a system with three dimensions (D = 3) and 1000 spins (N = 1000), the system, using ''eq. 5'', was determined to increase in energy by <math>12 J</math>. Notably, this change in energy is independent of the number of spins in the system - it depends only on the number of dimensions and J.
[[File:ThirdYearCMPExpt-IsingSketch.png|300px|thumb|right|'' '''Figure 1''': Representation of Ising lattices in one (N=5), two (N=25), and three (N=125) dimensions. +1 and -1 spins are denoted by the red and blue cells respectively. Diagram taken from the lab script.'']]
A significant consideration with regards to the spin 'flipping' described here is the accompanying increase in entropy - the driving force for this process. For the scenario describing the change in direction of a single spin, the multiplicity of the system will be <math>2N</math> - this is a consequence of the system prior to 'flipping' having a multiplicity of two (all spins aligned 'up' or 'down'), where now, any one of the spins could flip, adding the factor of N to the multiplicity. Hence, the new entropy can be defined to be
::<math>S' = k_B \ln 2N</math>, (''eq. 6'') 
which allows the change in entropy to be calculated according to ''eq. 7''.
::<math>\Delta S = k_B \ln 2N - k_B \ln2 = k_B \ln N</math> (''eq. 7'') 
For the system described above (D = 3, N = 1000), the change in entropy associated with the spin 'flip' process is therefore <math>k_B ln 1000</math>, which is equal to 9.53 x 10-23 J K-1.

===Magnetisation===
{| class="wikitable floatright" width=42%
|+ ''Table 2: Ising lattices and magnetisations''
! Ising Lattice !! Magnetisation
|- style="text-align:center;"
| 1D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 2D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 3D at 0 K || 1000 or -1000
|}
''Figure 1'' shows three examples of Ising lattices, with one, two and three dimensions respectively. Using the equation for magnetisation (''eq. 8''), the magnetisations of these systems can be calculated to be those presented in ''Table 2''.
::<math>M= \sum_i s_i</math> (''eq. 8'') 
For the three-dimensional system at a temperature of 0 K, all of the spins must be aligned either 'up' or 'down', as the entropic increase associated with 'flipped' spins does not provide a driving force at absolute zero - the only factor to consider is that of the energy, which is a minimum when all of the spins are aligned. For this case, the magnetisation could be either 1000 or -1000, depending upon the direction of the spin alignment. From a consideration of the magnetisation values calculated here, it is evident that with all of the spins aligned, the (magnitude of the) magnetisation of the system is at a maximum.

==Calculating the energy and magnetisation==
===Modifying the files===
[[File:DMStest_output2.png|300px|thumb|right|'' '''Figure 2''': Output image from testing IsingLattice.py using Ilcheck.py'']]
In order to use Python to compute the energy and magnetisation for a given two-dimensional Ising lattice, the class IsingLattice was used, where energy() and magnetisation() functions were written to calculate their corresponding properties for a random numpy array of spins (generated using np.random.choice). For this aspect of the experiment, the value of J was assumed to be 1.0, working in reduced units. The Python script developed can be viewed [[Mod:DMS3053-1|here]], including annotations.

===Testing the files===
In order to test the script prepared thus far, the Ilcheck.py script was run, generating the image presented in ''Figure 2''. An examination of this output clearly indicates that the script provides accurate energies and magnetisations for the minimum and maximum energy configurations, along with for an intermediate, random arrangement. Hence, it can be concluded that at the current level, the Python script is functioning as required.

==Introduction to the Monte Carlo simulation==
===Average Energy and Magnetisation===
[[File:DMSILanim3.png|300px|thumb|right|'''''Figure 3''': Animation result from ILanim.py, showing the resting of the system in the minimum energy state'']]
[[File:DMSILanim_meta.png|300px|thumb|right|'''''Figure 4''': Animation result from ILanim.py, showing the resting of the system in a meta-stable state'']]

In order to consider the generalisability of the prepared script, it is important to analyse how the script will function for large systems, such as those with 100 spins in the spin array. As each of these spins can be either 'up' or 'down', each spin has two choices. Hence, the number of possible configurations for the system can be written as <math>2^{100}</math>, which has a value of 1.2677 x 1030.

If one considers the sampling of a single configuration to take 1 x 10-9 s, then it is clear that sampling all of these considerations would take a total of 1.2677 x 1021 s (also expressed as 4.017 x 1013 years). From this analysis, it is evident that the sampling of configurations was a significant consideration in the writing of a python script for this task.

In order to account for this, the technique of importance sampling was implemented, using the statistical Boltzmann distribution, <math>\exp(- \Delta E / k_B T)</math>. Note that as the energy computed using the energy() function is in units of kB, this factor is not included in the script.

===Modifying IsingLattice.py to Implement a Monte Carlo Cycle===
The python script developed at this stage is presented [[Mod:DMS3053-2|here]], accompanied by annotations to explain how the script functions.

===Simulating the Monte Carlo Cycles===
{| class="wikitable floatright" width=42%
|+ ''Table 3: statistics() output for animated system at global minimum configuration (Figure 3)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.70542501728
|- style="text-align:center;"
| <E2> || 3.13520970111
|- style="text-align:center;"
| <M> || -0.829971492744
|- style="text-align:center;"
| <M2> || 0.770986982766
|}
For cases where T < Tc, it would be expected that the system would have a spontaneous magnetisation. When T > Tc, the entropy will be the dominating factor, potentially resulting in the system having a magnetisation of zero.
{| class="wikitable floatright" width=42%
|+ ''Table 4: statistics() output for animated system at meta-stable configuration (Figure 4)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.35076450189
|- style="text-align:center;"
| <E2> || 1.89025801939
|- style="text-align:center;"
| <M> || -0.344104665826
|- style="text-align:center;"
| <M2> || 0.138855365306
|}
Using the presented script and the ILanim.py script, the Monte Carlo cycles can be simulated to view the results on the spin array as the process progresses. Here, the system under consideration was an 8 x 8 spin array, at a temperature of 0.5. ''Figure 3'' shows the typical outcome of the animation, with the system having reached the most stable, minimum energy arrangement. For the result presented here, the output of the statistics() function was that shown in ''Table 3''.

It was also observed that the system could locate a meta-stable state, with large regions of spin 'up' and 'down' spins. An example of such a result is presented in ''Figure 4'' (for which the output data from statistics() is presented in ''Table 4'').

==Accelerating the code==

In order to examine the efficiency of the python script developed thus far, the Iltimetrial.py script was utilised to investigate the time taken to perform 2000 Monte Carlo cycles. This script was modified to the version presented [[Mod:DMS3053-3|here]], which repeats the time measurement a defined number of times, then calculates the average time and the standard error in this average. For the Monte Carlo script prepared previously, the average time for 2000 Monte Carlo cycles was measured to be 5.475804 s and a standard error was calculated to be 0.008325 s, with 100 measurements made using the script.

Evidently, the current script is slow at conducting large numbers of Monte Carlo cycles and hence, a more efficient script was developed using the np.roll, np.multiply and np.sum functions - this is presented [[Mod:DMS3053-4|here]].

After this optimisation of the python script, the Iltimetrial.py script was re-run, giving an average time of 0.291467 s, with a standard error of 0.000156 s. Clearly, this optimised script is substantially faster than that developed previously (approximately 19 times faster).

==The effect of temperature==
===Correcting the averaging code===
As the equilibrium state of the system requires a number of Monte Carlo cycles to be reached, it is evident that the average energies and magnetisations are accounting for values for non-equilibrium arrangements - this was accounted for through a consideration of the number of cycles required to reach equilibrium. For this, the ILfinalframe.py script was used, giving the graphs shown in ''Table 5''. Here, each system was run for 150000 Monte Carlo cycles.
{| class="wikitable center" width=70%
|+ ''Table 5: Graphs of energy and magnetisation versus number of Monte Carlo cycles for different temperatures and system sizes''
! Temperature !! System Size !! Resulting Graphs !! Cycles for Equilibrium
|- style="text-align:center;"
| 0.5 || 4x4 || [[File:DMS0544.png|300px]] || 24
|- style="text-align:center;"
| 0.5 || 8x8 || [[File:DMS0588.png|300px]] || 392
|- style="text-align:center;"
| 0.5 || 16x16 || [[File:DMS051616.png|300px]] || 5549
|- style="text-align:center;"
| 1.0 || 2x2 || [[File:DMS1022.png|300px]] || (0)
|- style="text-align:center;"
| 1.0 || 4x4 || [[File:DMS1044.png|300px]] || 49
|- style="text-align:center;"
| 1.0 || 8x8 || [[File:DMS10882.png|300px]] || 590
|- style="text-align:center;"
| 1.0 || 16x16 || [[File:DMS101616.png|300px]] || ~6300
|- style="text-align:center;"
| 1.0 || 32x32 || [[File:DMS103232.png|300px]] || ~110000
|- style="text-align:center;"
| 2.0 || 4x4 || [[File:DMS2044.png|300px]] || -
|- style="text-align:center;"
| 2.0 || 8x8 || [[File:DMS2088.png|300px]] || -
|}
{| class="wikitable floatright" width=42%
|+ ''Table 6: Number of cycles to be ignored for each system size''
! System Size !! Number of cycles before averaging
|- style="text-align:center;"
| 2x2 || 0
|- style="text-align:center;"
| 4x4 || 100
|- style="text-align:center;"
| 8x8 || 1000
|- style="text-align:center;"
| 16x16 || 8000
|- style="text-align:center;"
| 32x32 || 120000
|}
Analysis of these graphs indicates that at higher temperatures, such as 2.0 (also observed at 1.5), large fluctuations in the energy and magnetisation are observed - these fluctuations are the reason that the average values of the properties must be taken. As the temperature is increased for systems of size 4x4, 8x8 and 16x16, it is clear that the number of cycles required in order to reach equilibrium increases. Hence, for the temperature range to be considered later (0.25 to 5.00), the required number of cycles was overestimated in order to ensure that all measurements were taken whilst the system was in equilibrium. The proposed numbers of cycles to be ignored for each system size are presented in ''Table 6''.

The python script developed up to this point was modified to account for these values by inclusion of a skip_region variable, which defines the number of cycles performed before energies and magnetisations contribute to the self.X values (before averaging occurs). The modified script is presented [[Mod:DMS3053-5|here]].

===Running over a range of temperatures===
[[File:DMS88dat.png|300px|thumb|right|'''''Figure 5''': Average energy and average magnetisation vs. temperature for 8x8 lattice, with error bars'']]
Using the python script modified in the previous exercise, the code can now be used to simulate the 8x8 system at a range of temperatures, using the ILtemperaturerange.py file. Here, the temperature range of 0.25 to 5.00 was used, with a separation of 0.25 between points, whilst the runtime was set to 10000 (neglecting the property values for the first 1000 cycles). Running this simulation produced the graphs in ''Figure 5'', where error bars computed using standard errors have also been included (these are small as a consequence of small standard errors). From the graph of average energy versus temperature, the phase transition can be observed - this occurs in the region with a gradient that is not close to zero. The data used here (temperature, average energies, average squared-energies, average magnetisations and average squared-magnetisations) was then saved as a numpy array in a new file, 8x8.dat.

==The effect of system size==
[[File:DMSLatticeSizeCombinedPlot.png|300px|thumb|right|'''''Figure 6''': Average energy and average magnetisation (per spins) vs. temperature for multiple lattice sizes'']]
The process conducted for the 8x8 lattice in the previous exercise was then repeated for lattices of sizes 2x2, 4x4, 16x16 and 32x32, with the data saved in .dat files. These files were then accessed, and the average energy and magnetisation data were plotted on one graph for all of the lattices sizes - this was achieved using the script presented [[Mod:DMS3053-6|here]]. The graphs produced in this manner are shown in ''Figure 6''.

A consideration of this graph suggests that in order to capture the long range fluctuations, a 16x16 lattice is necessary.

==Determining the heat capacity==
[[File:DMSheatcapacity2.png|300px|thumb|right|'''''Figure 7''': Heat capacity (per spin) versus temperature for different lattice sizes'']]
Using the .dat files previously produced, the heat capacity was calculated for each lattice size using the equation
::<math>C = \frac{\partial E}{\partial T} = \frac{\mathrm{Var}[E]}{k_B T^2}</math>, (''eq. 9'') 
where <math>\mathrm{Var}[E] = <E^2> - <E>^2 </math>. When implementing this, the kB term was neglected due to the energy values having units of kB. The script used for this purpose is provided [[DMS3053-7|here]]. The plot of heat capacity per spin versus temperature for all of the lattice sizes considered is presented in ''Figure 7''.

==Locating the Curie temperature==
The data for the heat capacity generated using the python script prepared in this experiment was compared to that from longer C++ computations - graphs showing this comparison are presented in ''Table 7'' for a range of lattice sizes.

Considering these graphs, it is clear that, in general, there is a reasonable correlation between the Python and C++ data; however, some of the data, particularly that for high lattice sizes, shows that the Python computations have not always found the maximum of heat capacity. This correlation would be improved by making computations at the same range of temperatures, but with a smaller gap between the temperatures taken; however, this would substantially increase computation time.
{| class="wikitable center" width=70%
|+ ''Table 7: Graphs of heat capacity (per spin) versus temperature for C++ and Python data''
|- style="text-align:center;"
| [[File:DMS2x2c.png|300px]] || [[File:DMS4x4c.png|300px]] || [[File:DMS8x8c.png|300px]]
|- style="text-align:center;"
| [[File:DMS16x16c.png|300px]] || [[File:DMS32x32c.png|300px]]
|}
</div>

Rep:Mod:DMS3053

2015-02-24T14:46:12Z

Ds3012: /* Locating the Curie temperature */

'''CMP Programming Experiment - Daniel Spencer, 00736964'''
<div style="text-align: justify">
==Introduction to the Ising Model==
===Minimum energy of the Ising Model===
Using the equation 
::<math>E= - \frac{1}{2} J \sum_i^N \sum_{j\ \in\ \mathrm{neighbours}\left(i\right)} s_i s_j</math> (''eq. 1'') 
the minimum energy of an Ising lattice of <math>D</math> dimensions, with <math>N</math> spins (where each
spin had a value of +1 or -1) and an interaction strength of <math>J</math> was considered. This was achieved first through a consideration of a one-dimensional system with five parallel spins (where the spins are parallel as this corresponds to the minimum energy arrangement of the system). Hence, the energy of this linear system was found to be 
::<math>E_\text{min,1D} = -5J </math>. 
For a linear, one-dimensional system, the number of neigbouring spins is two. The number of neighbours can be determined for two- and three- dimensional systems through a geometric consideration of their structure - the values are presented in ''Table 1''.
{| class="wikitable floatright" width=42%
|+ ''Table 1: Dimension numbers and number of neighbours''
! Number of Dimensions, D !! Number of Neighbours
|- style="text-align:center;"
| 1 || 2
|- style="text-align:center;"
| 2 || 4
|- style="text-align:center;"
| 3 || 6
|- style="text-align:center;"
| D || 2D
|}
These data indicate that the number of neighbours is twice the number of dimensions, for the dimensions considered here. This can be extrapolated to give the general number of neighbours as <math>2D</math>.

For the minimum energy of the system, where all spins are parallel, every combination <math>s_i s_j</math> has a value of 1. Notably, for each value of <math>i</math>, there will be <math>2D</math> neighbour interactions. Ergo, using ''eq. 1'', the general minimum energy can be found to be
::<math>E_\text{min,D} = -DNJ </math> (''eq. 2''). 
To check this equation, it can be applied to the two-dimensional Ising lattice with 25 spins - this gives a value of
::<math>E_\text{min,2D} = -50J </math>, 
which matches with the value predicted from first-principles.

For this D-dimensional system, the multiplicity (i.e. the number of ways of achieving the specified configuration of spins) must be equal to two, as either all of the spins could be aligned 'up' (+1) or 'down' (-1). Using this multiplicity, the entropy of the system can be calculated using the equation
::<math>S = k_B \ln\Omega</math>, (''eq. 3'') 
where Ω is the number of microstates (equal to the multiplicity in this case), which gives a value of <math>k_B \ln2 </math>, or 9.57 x 10-24 J K-1.

===Spin 'flipping'===

Using the Ising model, it is also possible to consider a change in state, reflected by a 'flipping' of the direction of one of the lattice spins. For this case, the energy (using ''eq. 1'') can be determined to be
::<math>E'= - \frac{1}{2} J (2DN - 4D - 4D) = 4DJ - DNJ</math>, (''eq. 4'') 
where the additional <math>4D</math> terms arise from the loss of 4D stabilising spin-aligned interactions and the gain of 4D destabilising spins anti-aligned interactions following spin 'flipping'. Using ''eq. 2'' and ''eq. 4'', the change in energy derived from this spin 'flip' can be calculated to be
::<math>\Delta E= 4DJ - DNJ + DNJ = 4DJ</math>. (''eq. 5'') 
For a system with three dimensions (D = 3) and 1000 spins (N = 1000), the system, using ''eq. 5'', was determined to increase in energy by <math>12 J</math>. Notably, this change in energy is independent of the number of spins in the system - it depends only on the number of dimensions and J.
[[File:ThirdYearCMPExpt-IsingSketch.png|300px|thumb|right|'' '''Figure 1''': Representation of Ising lattices in one (N=5), two (N=25), and three (N=125) dimensions. +1 and -1 spins are denoted by the red and blue cells respectively. Diagram taken from the lab script.'']]
A significant consideration with regards to the spin 'flipping' described here is the accompanying increase in entropy - the driving force for this process. For the scenario describing the change in direction of a single spin, the multiplicity of the system will be <math>2N</math> - this is a consequence of the system prior to 'flipping' having a multiplicity of two (all spins aligned 'up' or 'down'), where now, any one of the spins could flip, adding the factor of N to the multiplicity. Hence, the new entropy can be defined to be
::<math>S' = k_B \ln 2N</math>, (''eq. 6'') 
which allows the change in entropy to be calculated according to ''eq. 7''.
::<math>\Delta S = k_B \ln 2N - k_B \ln2 = k_B \ln N</math> (''eq. 7'') 
For the system described above (D = 3, N = 1000), the change in entropy associated with the spin 'flip' process is therefore <math>k_B ln 1000</math>, which is equal to 9.53 x 10-23 J K-1.

===Magnetisation===
{| class="wikitable floatright" width=42%
|+ ''Table 2: Ising lattices and magnetisations''
! Ising Lattice !! Magnetisation
|- style="text-align:center;"
| 1D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 2D - spins as in ''Figure 1'' || 1
|- style="text-align:center;"
| 3D at 0 K || 1000 or -1000
|}
''Figure 1'' shows three examples of Ising lattices, with one, two and three dimensions respectively. Using the equation for magnetisation (''eq. 8''), the magnetisations of these systems can be calculated to be those presented in ''Table 2''.
::<math>M= \sum_i s_i</math> (''eq. 8'') 
For the three-dimensional system at a temperature of 0 K, all of the spins must be aligned either 'up' or 'down', as the entropic increase associated with 'flipped' spins does not provide a driving force at absolute zero - the only factor to consider is that of the energy, which is a minimum when all of the spins are aligned. For this case, the magnetisation could be either 1000 or -1000, depending upon the direction of the spin alignment. From a consideration of the magnetisation values calculated here, it is evident that with all of the spins aligned, the (magnitude of the) magnetisation of the system is at a maximum.

==Calculating the energy and magnetisation==
===Modifying the files===
[[File:DMStest_output2.png|300px|thumb|right|'' '''Figure 2''': Output image from testing IsingLattice.py using Ilcheck.py'']]
In order to use Python to compute the energy and magnetisation for a given two-dimensional Ising lattice, the class IsingLattice was used, where energy() and magnetisation() functions were written to calculate their corresponding properties for a random numpy array of spins (generated using np.random.choice). For this aspect of the experiment, the value of J was assumed to be 1.0, working in reduced units. The Python script developed can be viewed [[Mod:DMS3053-1|here]], including annotations.

===Testing the files===
In order to test the script prepared thus far, the Ilcheck.py script was run, generating the image presented in ''Figure 2''. An examination of this output clearly indicates that the script provides accurate energies and magnetisations for the minimum and maximum energy configurations, along with for an intermediate, random arrangement. Hence, it can be concluded that at the current level, the Python script is functioning as required.

==Introduction to the Monte Carlo simulation==
===Average Energy and Magnetisation===
[[File:DMSILanim3.png|300px|thumb|right|'''''Figure 3''': Animation result from ILanim.py, showing the resting of the system in the minimum energy state'']]
[[File:DMSILanim_meta.png|300px|thumb|right|'''''Figure 4''': Animation result from ILanim.py, showing the resting of the system in a meta-stable state'']]

In order to consider the generalisability of the prepared script, it is important to analyse how the script will function for large systems, such as those with 100 spins in the spin array. As each of these spins can be either 'up' or 'down', each spin has two choices. Hence, the number of possible configurations for the system can be written as <math>2^{100}</math>, which has a value of 1.2677 x 1030.

If one considers the sampling of a single configuration to take 1 x 10-9 s, then it is clear that sampling all of these considerations would take a total of 1.2677 x 1021 s (also expressed as 4.017 x 1013 years). From this analysis, it is evident that the sampling of configurations was a significant consideration in the writing of a python script for this task.

In order to account for this, the technique of importance sampling was implemented, using the statistical Boltzmann distribution, <math>\exp(- \Delta E / k_B T)</math>. Note that as the energy computed using the energy() function is in units of kB, this factor is not included in the script.

===Modifying IsingLattice.py to Implement a Monte Carlo Cycle===
The python script developed at this stage is presented [[Mod:DMS3053-2|here]], accompanied by annotations to explain how the script functions.

===Simulating the Monte Carlo Cycles===
{| class="wikitable floatright" width=42%
|+ ''Table 3: statistics() output for animated system at global minimum configuration (Figure 3)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.70542501728
|- style="text-align:center;"
| <E2> || 3.13520970111
|- style="text-align:center;"
| <M> || -0.829971492744
|- style="text-align:center;"
| <M2> || 0.770986982766
|}
For cases where T < Tc, it would be expected that the system would have a spontaneous magnetisation. When T > Tc, the entropy will be the dominating factor, potentially resulting in the system having a magnetisation of zero.
{| class="wikitable floatright" width=42%
|+ ''Table 4: statistics() output for animated system at meta-stable configuration (Figure 4)''
! Property !! Value
|- style="text-align:center;"
| <E> || -1.35076450189
|- style="text-align:center;"
| <E2> || 1.89025801939
|- style="text-align:center;"
| <M> || -0.344104665826
|- style="text-align:center;"
| <M2> || 0.138855365306
|}
Using the presented script and the ILanim.py script, the Monte Carlo cycles can be simulated to view the results on the spin array as the process progresses. Here, the system under consideration was an 8 x 8 spin array, at a temperature of 0.5. ''Figure 3'' shows the typical outcome of the animation, with the system having reached the most stable, minimum energy arrangement. For the result presented here, the output of the statistics() function was that shown in ''Table 3''.

It was also observed that the system could locate a meta-stable state, with large regions of spin 'up' and 'down' spins. An example of such a result is presented in ''Figure 4'' (for which the output data from statistics() is presented in ''Table 4'').

==Accelerating the code==

In order to examine the efficiency of the python script developed thus far, the Iltimetrial.py script was utilised to investigate the time taken to perform 2000 Monte Carlo cycles. This script was modified to the version presented [[Mod:DMS3053-3|here]], which repeats the time measurement a defined number of times, then calculates the average time and the standard error in this average. For the Monte Carlo script prepared previously, the average time for 2000 Monte Carlo cycles was measured to be 5.475804 s and a standard error was calculated to be 0.008325 s, with 100 measurements made using the script.

Evidently, the current script is slow at conducting large numbers of Monte Carlo cycles and hence, a more efficient script was developed using the np.roll, np.multiply and np.sum functions - this is presented [[Mod:DMS3053-4|here]].

After this optimisation of the python script, the Iltimetrial.py script was re-run, giving an average time of 0.291467 s, with a standard error of 0.000156 s. Clearly, this optimised script is substantially faster than that developed previously (approximately 19 times faster).

==The effect of temperature==
===Correcting the averaging code===
As the equilibrium state of the system requires a number of Monte Carlo cycles to be reached, it is evident that the average energies and magnetisations are accounting for values for non-equilibrium arrangements - this was accounted for through a consideration of the number of cycles required to reach equilibrium. For this, the ILfinalframe.py script was used, giving the graphs shown in ''Table 5''. Here, each system was run for 150000 Monte Carlo cycles.
{| class="wikitable center" width=70%
|+ ''Table 5: Graphs of energy and magnetisation versus number of Monte Carlo cycles for different temperatures and system sizes''
! Temperature !! System Size !! Resulting Graphs !! Cycles for Equilibrium
|- style="text-align:center;"
| 0.5 || 4x4 || [[File:DMS0544.png|300px]] || 24
|- style="text-align:center;"
| 0.5 || 8x8 || [[File:DMS0588.png|300px]] || 392
|- style="text-align:center;"
| 0.5 || 16x16 || [[File:DMS051616.png|300px]] || 5549
|- style="text-align:center;"
| 1.0 || 2x2 || [[File:DMS1022.png|300px]] || (0)
|- style="text-align:center;"
| 1.0 || 4x4 || [[File:DMS1044.png|300px]] || 49
|- style="text-align:center;"
| 1.0 || 8x8 || [[File:DMS10882.png|300px]] || 590
|- style="text-align:center;"
| 1.0 || 16x16 || [[File:DMS101616.png|300px]] || ~6300
|- style="text-align:center;"
| 1.0 || 32x32 || [[File:DMS103232.png|300px]] || ~110000
|- style="text-align:center;"
| 2.0 || 4x4 || [[File:DMS2044.png|300px]] || -
|- style="text-align:center;"
| 2.0 || 8x8 || [[File:DMS2088.png|300px]] || -
|}
{| class="wikitable floatright" width=42%
|+ ''Table 6: Number of cycles to be ignored for each system size''
! System Size !! Number of cycles before averaging
|- style="text-align:center;"
| 2x2 || 0
|- style="text-align:center;"
| 4x4 || 100
|- style="text-align:center;"
| 8x8 || 1000
|- style="text-align:center;"
| 16x16 || 8000
|- style="text-align:center;"
| 32x32 || 120000
|}
Analysis of these graphs indicates that at higher temperatures, such as 2.0 (also observed at 1.5), large fluctuations in the energy and magnetisation are observed - these fluctuations are the reason that the average values of the properties must be taken. As the temperature is increased for systems of size 4x4, 8x8 and 16x16, it is clear that the number of cycles required in order to reach equilibrium increases. Hence, for the temperature range to be considered later (0.25 to 5.00), the required number of cycles was overestimated in order to ensure that all measurements were taken whilst the system was in equilibrium. The proposed numbers of cycles to be ignored for each system size are presented in ''Table 6''.

The python script developed up to this point was modified to account for these values by inclusion of a skip_region variable, which defines the number of cycles performed before energies and magnetisations contribute to the self.X values (before averaging occurs). The modified script is presented [[Mod:DMS3053-5|here]].

===Running over a range of temperatures===
[[File:DMS88dat.png|300px|thumb|right|'''''Figure 5''': Average energy and average magnetisation vs. temperature for 8x8 lattice, with error bars'']]
Using the python script modified in the previous exercise, the code can now be used to simulate the 8x8 system at a range of temperatures, using the ILtemperaturerange.py file. Here, the temperature range of 0.25 to 5.00 was used, with a separation of 0.25 between points, whilst the runtime was set to 10000 (neglecting the property values for the first 1000 cycles). Running this simulation produced the graphs in ''Figure 5'', where error bars computed using standard errors have also been included (these are small as a consequence of small standard errors). From the graph of average energy versus temperature, the phase transition can be observed - this occurs in the region with a gradient that is not close to zero. The data used here (temperature, average energies, average squared-energies, average magnetisations and average squared-magnetisations) was then saved as a numpy array in a new file, 8x8.dat.

==The effect of system size==
[[File:DMSLatticeSizeCombinedPlot.png|300px|thumb|right|'''''Figure 6''': Average energy and average magnetisation (per spins) vs. temperature for multiple lattice sizes'']]
The process conducted for the 8x8 lattice in the previous exercise was then repeated for lattices of sizes 2x2, 4x4, 16x16 and 32x32, with the data saved in .dat files. These files were then accessed, and the average energy and magnetisation data were plotted on one graph for all of the lattices sizes - this was achieved using the script presented [[Mod:DMS3053-6|here]]. The graphs produced in this manner are shown in ''Figure 6''.

A consideration of this graph suggests that in order to capture the long range fluctuations, a 16x16 lattice is necessary.

==Determining the heat capacity==
[[File:DMSheatcapacity2.png|300px|thumb|right|'''''Figure 7''': Heat capacity (per spin) versus temperature for different lattice sizes'']]
Using the .dat files previously produced, the heat capacity was calculated for each lattice size using the equation
::<math>C = \frac{\partial E}{\partial T} = \frac{\mathrm{Var}[E]}{k_B T^2}</math>, (''eq. 9'') 
where <math>\mathrm{Var}[E] = <E^2> - <E>^2 </math>. When implementing this, the kB term was neglected due to the energy values having units of kB. The script used for this purpose is provided [[DMS3053-7|here]]. The plot of heat capacity per spin versus temperature for all of the lattice sizes considered is presented in ''Figure 7''.

==Locating the Curie temperature==
The data for the heat capacity generated using the python script prepared in this experiment was compared to that from longer C++ computations - graphs showing this comparison are presented in ''Table 7'' for a range of lattice sizes.
{| class="wikitable center" width=70%
|+ ''Table 7: Graphs of heat capacity (per spin) versus temperature for C++ and Python data''
|- style="text-align:center;"
| [[File:DMS2x2c.png|300px]] || [[File:DMS4x4c.png|300px]] || [[File:DMS8x8c.png|300px]]
|- style="text-align:center;"
| [[File:DMS16x16c.png|300px]] || [[File:DMS32x32c.png|300px]]
|}
</div>

File:DMS32x32c.png

2015-02-24T14:46:06Z

Ds3012:

File:DMS16x16c.png

2015-02-24T14:45:06Z

Ds3012:

File:DMS8x8c.png

2015-02-24T14:43:58Z

Ds3012:

File:DMS4x4c.png

2015-02-24T14:43:38Z

Ds3012: