Solving 2D Ising Model Issue with Java

[JohnGano]

Homework Statement

I'm trying to program the 2D Ising model with Java, but for some reason, I cannot get magnetization to come out right. The energy and magnetization appear to be acting right for increase and decrease in temperatures, but I don't see anything significant at a critical temperature when I set it to one. It seems to be just like any other temperature in terms of how it effects it.

Homework Equations

The change in magnetization if a spin is flipped would be
M₂ = M₁ - 2 * flippedspin

Right?

The Attempt at a Solution

/*
 * ising.Ising2D.java
 */

package ising;

import java.util.*;
import java.io.*;

public class Ising2D
{
    public static final int DEFAULT_LATTICE[][] = new int[5][5];
    public static final double DEFAULT_INTERACTION_STRENGTH = 1.0;
    public static final double DEFAULT_EXTERNAL_FIELD = 0.0;
    public static final String OUTPUT_FILE = "C:/spins.txt";

    PrintWriter outputStream = null;
    Scanner reader = null;
    Random random = new Random();
    int spinLattice[][] = DEFAULT_LATTICE;
    double interactionStrength = DEFAULT_INTERACTION_STRENGTH;
    double externalField = DEFAULT_EXTERNAL_FIELD;
    double temperature = 1.0;
    double energy = 0.0;
    double magnetization = 0.0;
    double averageEnergy = 0.0;
    double averageMagnetization = 0.0;
    double totalAverageE = 0.0;
    double totalAverageM = 0.0;

    /**
     * Creates a new instance of Ising2D that takes in
     * the lattice rows, columns, interaction strength,
     * external field value, temperature, and spin pattern.
     * Then it runs through 5 000 flips 100 000 times to
     * come up with a total average energy and magnetization
     *
     * @param rowsIn the rows to set spinLattice to
     * @param columnsIn the colums to set spinLattice to
     * @param interactionStrengthIn the interaction strength to use
     * @param externalFieldIn the external field value to use
     */
    Ising2D(int rowsIn, int columnsIn, double interactionStrengthIn,
            double externalFieldIn, double temperatureIn, int spinPattern)
    {
        setLattice(rowsIn, columnsIn);
        interactionStrength = interactionStrengthIn;
        externalField = externalFieldIn;
        temperature = temperatureIn;

        for(int i = 0; i < 10000; i++)
        {
            switch (spinPattern)
            {
                case 1: setRandomSpins(); break;
                case 2: usePreviousSpins(); break;
                case 3: setCheckerSpins(); break;
                case 4: setEqualSpins(); break;
            }

            System.out.println(magnetization / (20 * 20));

            for(int j = 0; j < 5000; j++)
            {
                spinFlip();
            }

            averageEnergy = averageEnergy / (20 * 20) / (5000) / 2; // per spin
            averageMagnetization = averageMagnetization / (20 * 20) / 5000;

            totalAverageE += averageEnergy;
            totalAverageM += averageMagnetization;

            System.out.println(averageEnergy + "     " + averageMagnetization);
        }

        totalAverageE /= 10000;
        totalAverageM /= 10000;

        System.out.println("Average E   &   Average M");
        System.out.println(totalAverageE + "    " + totalAverageM);
    }    /**
     * Sets spinLattice to the specified amount of rows and columns
     */
    public void setLattice(int rowsIn, int columnsIn)
    {
        spinLattice = new int[rowsIn][columnsIn];
    }

    /**
     * Sums the nearest neighbors of the passed in location on the
     * array spinLattice using periodic boundary conditions.
     *
     * @param rowIn the row to find nearest neighbors of
     * @param columnIn the column to find nearest neighbors of
     * @return the sum of nearest neighbor interactions
     */
    public int sumNearestNeighbors(int rowIn, int columnIn)
    {
        int sum  = 0;
        int top = rowIn - 1;
        int bottom = rowIn + 1;
        int left = columnIn - 1;
        int right = columnIn + 1;

        if(rowIn == 0)
            top = spinLattice.length - 1;
        else if(rowIn == spinLattice.length - 1)
            bottom = 0;

        if(columnIn == 0)
            left = spinLattice[0].length - 1;
        else if(columnIn == spinLattice[0].length - 1)
            right = 0;

        sum = spinLattice[top][columnIn] + spinLattice[bottom][columnIn] +
                spinLattice[rowIn][left] + spinLattice[rowIn][right];

        return sum;
    }

    /**
     * Sums the spin interactions with each other over the entire lattice
     * then multiplies it by their interaction strength to get the spin
     * energy sum.
     *
     * @return the sum of the spin energy
     */
    public double sumSpinEnergy()
    {
        double spinEnergy = 0.0;
        
        for(int i = 0; i < spinLattice.length; i++)
        {
            for(int j = 0; j < spinLattice[i].length; j++)
            {
                spinEnergy += spinLattice[i][j] * sumNearestNeighbors(i, j);
            }
        }

        spinEnergy *= -interactionStrength;

        return spinEnergy;
    }

    /**
     * Sums the magnetization over the entire lattice.
     *
     * @return the sum of the magnetization
     */
    public double sumMagnetization()
    {
        double sumOfMagnetization = 0.0;

        for(int i = 0; i < spinLattice.length; i++)
        {
            for(int j = 0; j < spinLattice[i].length; j++)
            {
                sumOfMagnetization += spinLattice[i][j];
            }
        }

        return sumOfMagnetization;
    }

    /**
     * Generates a random spin of either 1 or -1
     *
     * @return a number of either 1 or -1
     */
    public int generateRandomSpin()
    {
        return (int)Math.pow(-1, Math.abs(random.nextInt()) % 2);
    }

    /**
     * Uses the Monte Carlo method to flip a spin based on the change
     * of energy. If energy change < 0, flip the spin, if > 0, flip it
     * with a certain probability.
     */
    public void spinFlip()
    {
        int randomRow = random.nextInt(spinLattice.length);
        int randomColumn = random.nextInt(spinLattice[0].length);
        int trialSpin = -spinLattice[randomRow][randomColumn];
        double deltaEnergy = 2 * (trialSpin * interactionStrength *
                             sumNearestNeighbors(randomRow, randomColumn)
                             + externalField);

        if(deltaEnergy < 0 || Math.exp(-deltaEnergy / temperature)
                                           <= random.nextDouble())
        {
            spinLattice[randomRow][randomColumn] = trialSpin;
            energy += deltaEnergy;
            magnetization -= 2 * spinLattice[randomRow][randomColumn];
            averageEnergy += energy;
            averageMagnetization += magnetization;
        }
    }

    /**
     * Sets the spins in spinLattice to be random 1 or -1
     */
    public void setRandomSpins()
    {
        try
        {
            outputStream = new PrintWriter(OUTPUT_FILE);
        }
        catch(FileNotFoundException e)
        {
            System.out.println("Could not open file: " + OUTPUT_FILE);
            System.exit(0);
        }

        for(int i = 0; i < spinLattice.length; i++)
        {
            for(int j = 0; j < spinLattice[i].length; j++)
            {
                spinLattice[i][j] = 1;
                spinLattice[i][j] *= generateRandomSpin();
                outputStream.println(spinLattice[i][j]);
            }
        }

        outputStream.close();

        energy = sumSpinEnergy();
        magnetization = sumMagnetization();
        averageMagnetization = magnetization;
        averageEnergy = energy;
    }

    /**
     * Sets up a checkerboard pattern of spins in spinLattice
     */
    public void setCheckerSpins()
    {
        for(int i = 0; i < spinLattice.length; i++)
        {
            for(int j = 0; j < spinLattice[i].length; j++)
            {
                if(i % 2 == 0)
                {
                    if(j % 2 == 0)
                        spinLattice[i][j] = 1;
                    else
                        spinLattice[i][j] = -1;
                }
                else
                {
                    if(j % 2 == 0)
                        spinLattice[i][j] = -1;
                    else
                        spinLattice[i][j] = 1;
                }
            }
        }
        
        energy = sumSpinEnergy() - sumMagnetization() * externalField;
        magnetization = sumMagnetization();
        averageMagnetization = magnetization;
        averageEnergy = energy;
    }

    /**
     * Sets spinLattice to use the previously recorded spins
     */
    public void usePreviousSpins()
    {
        try
        {
            reader = new Scanner(new File(OUTPUT_FILE));
        }
        catch(FileNotFoundException e)
        {
            System.out.println("Could not open file: " + OUTPUT_FILE);
            System.exit(0);
        }

        while(reader.hasNextLine())
        {
            for(int i = 0; i < spinLattice.length; i++)
            {
                for(int j = 0; j < spinLattice[i].length; j++)
                {
                    spinLattice[i][j] = Integer.parseInt(reader.nextLine());
                }
            }
        }

        reader.close();

        energy = sumSpinEnergy();
        magnetization = sumMagnetization();
        averageMagnetization = magnetization;
        averageEnergy = energy;
    }

    /**
     * Sets up all the spins in spinLattice to be the same, in this case, 1
     */
    public void setEqualSpins()
    {
        for(int i = 0; i < spinLattice.length; i++)
        {
            for(int j = 0; j < spinLattice[i].length; j++)
            {
                spinLattice[i][j] = 1;
            }
        }

        energy = sumSpinEnergy();
        magnetization = sumMagnetization();
        averageMagnetization = magnetization;
        averageEnergy = energy;
    }

}

If someone knows what I'm doing wrong, I'd really appreciate the help.

 

[KataKoniK]

Hi there,

It's hard to say exactly what might be causing the issue without seeing the specific code for the magnetization calculation. However, there are a few things you can check to try and troubleshoot the problem:

1. Make sure your random number generator is working properly. If you're not getting a good distribution of random numbers, it could affect the results of your simulation.

2. Double check your equations for calculating the magnetization. Make sure you're taking into account all the necessary factors, such as the external field and the interaction strength.

3. Check your boundary conditions. If your lattice is not properly set up or if you're not taking into account periodic boundary conditions, it could affect the results.

4. Try running the simulation with different temperatures to see if the issue persists. If the problem only occurs at a specific temperature, it could indicate a problem with your code for handling the critical temperature.

Hopefully one of these suggestions will help you identify and fix the issue. Good luck with your project!

 

[Mene]

Hello,

Thank you for sharing your code and explaining the issue you are facing. It seems like you have put in a lot of effort into your program and have a good understanding of the Ising model.

One possible reason for your magnetization not coming out correctly could be due to a mistake in your spin flip function. It looks like you are using the Monte Carlo method, which is a good approach. However, in your code, you are only considering the change in energy when deciding whether to flip a spin or not. In the Ising model, the magnetization is also affected by the neighboring spins. So, in your spin flip function, you may want to also consider the change in magnetization when deciding whether to flip a spin or not.

Another thing to check is the temperature that you are setting. The critical temperature for the Ising model is usually around 2.269, so setting it to 1 may not show any significant changes in magnetization.

I hope this helps and good luck with your project!