Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

https://github.com/zeehio/ising

An Ising Model simulator using the Metropolis algorithm
https://github.com/zeehio/ising

Last synced: about 1 month ago
JSON representation

An Ising Model simulator using the Metropolis algorithm

Awesome Lists containing this project

README 

        
ISING - An Ising model simulator

=================================



## Building the source code

Simply run:



     ./autogen.sh

     ./configure

     make

     make install



After `make install`, the **ising** program will be found in 

the `install/bin` directory. If you want to install the ising model simulator

in a global directory you can use the `--prefix` option:



     ./autogen.sh

     ./configure --prefix=/usr/local

     make

     sudo make install



## Using the Ising model simulator:



### Quick start:



First, obtain the latest version of the source code:



     git clone https://github.com/zeehio/ising.git



Then we build the sources. You will need autotools (`autoconf`, `automake`

and `libtool`).



     ./autogen.sh

     ./configure

     make

     make install



Finally we move to the default install directory:



     cd "install/bin"



Now we will perform a simulation and extract some measurements:



     ising -d 2 -L 20 -T 4.0 --nmeas 500 --nmcs 10000000 --ieq 5000 --dyn 0 > simulation.txt



This command runs a 20x20 lattice, at a T=4 temperature, performing 10 

millions of montecarlo sweeps of the lattice, printing the energy, the

magnetization and a simple estimation of average cluster radius every 500

sweeps to the `simulation.txt`. Before the 10 millions sweeps are performed,

5000 sweeps are done for thermalization. Each sweep is done using a random 

glauber dynamic (a simple random spin flip).



     mycut -f 1  < simulation.txt > simulationenergies.txt



This command takes the first column of "simulation.txt" and saves it into

`simulation_energies.txt`.



     cat simulationenergies.txt | jackknife > energyinfo.txt



This command returns the jackknife estimations of the energies. Notice how

the quantity ` - ^2` can be used to compute the heat capacity using

the fluctuation-dissipation theorem.



### Introduction



To be written. If you are here you should know a bit about the Ising model

and the Metropolis algorithm.



#### Program workflow

This is more or less how the program works:



 1. Parse input parameters.

 2. Initialize geometry.

 3. Initialize spins values (+1,-1).

 4. Compute Energy and Magnetization.

 5. Perform `--ieq` Metropolis sweeps to thermalize the state of the system.

 6. Perform `--nmcs` sweeps, printing the Energy, the Magnetization and an 

    estimation of the cluster radius every `--nmeas` measures.



### Geometry

The ising model simulator defines an hypercubic lattice, which allows

the following parameters to be set:



 * Dimension (-d):

     - 2: Square lattice

     - 3: Cubic lattice

     - 4: Hypercubic lattice

     - 5: 5-dimesion cube

     - ...

 * Side length (-L): The number of spins of each dimension.



 * Print state (--print-state): This option, only enabled if dimension is 2,

     will create a "state" subdirectory with several text files that contain

     a  LxL square matrix with the position of the spins (either UP or DOWN). This 

     text file can be used later on to plot an image of the system and seeing

     the formed clusters.



Examples:



 * On a "-d 2 -L 20" lattice, we will have 20^2 = 400 spins

 * On a "-d 3 -L 8" lattice, we will have 8^3 = 512 spins



#### Using non hypercubic geometries:

The Ising model simulator may be used with any given geometry. However, an

initialization routine for any other specific geometry has to be implemented.



If you want to use a different geometry, only the `main` function would need

to be changed, preferably by replacing the `InitHypercubicLattice` function

or adding another switch option to the program (i.e. `--geometry`).



Patches are welcome.



Generic initialization routines for reading geometries from files would also

be very welcome.



### Metropolis parameters



We consider a "MonteCarlo sample" a loop over all sites of the system 

(this is "full sweep of the lattice"). This means that a single sample 

on a lattice of 400 spins, consists of 400 update proposals.



Using this convention, it is easier to compare Metropolis convergence

on different system sizes. Bear in mind that the larger the system is,

the longer will take a single "MonteCarlo sample" as more updates will 

be necessary to do a single sweep.



The Metropolis algorithm allows the following parameters:



  * Thermalization iterations (--ieq): Just after the system initialization,

      it may be convenient to discard a number of samples in order to allow 

      the system to reach an equilibrium state. Set this parameter to 0 if 

      you want to see the thermalization.

  * Number of MonteCarlo samples (--nmcs): The total number of MonteCarlo 

      samples to perform after thermalization.

  * Number of samples between each measurement (--nmeas): The number of 

      samples to perform between each system printing. For instance, if 

      we want to do 100000 sweeps, but only print 1000 values of the energy

      and magnetization, we would use an `--nmeas 100`.



### Dynamics

The Metropolis algorithm does not impose a particular dynamic of the system. 

A dynamic describes "how the updates should be performed". The available

dynamics are:



  * Glauber: A spin is chosen randomly and flipped.

  * Glauber sequential: Spins are flipped sequentially, following on every 

       sweep the same order.

  * Kawasaki random: Two opposite spins are chosen randomly and and exchanged.

  * Kawasaki neighbours: Two opposite neighbouring spins are chosen randomly

       and exchanged. TODO: The implementation of this dynamic is biased for 

       geometries where some spins have more neighbours than others (not the

       hypercubic case).

  * Wolff: This is a clustering dynamic:

   1. A spin S1 is chosen randomly.

   2. Check the spin of each of the S1 neighbours. If the neighbour's spin is 

       the opposite of S1, then that neighbour is not added to the cluster but

       if spins are the same, then the neighbour is added to the cluster with

       an acceptance rate which depends on the temperature.

   3. Move to the added neighbours and repeat until a cluster is formed.

   4. Flip the cluster.