Mean Field Theory in Magnetism

Introduction

Mean field theory (MFT) is a critical conceptual and mathematical tool in the field of statistical mechanics and magnetism. It provides a simplified framework to understand complex many-body systems by averaging the effects of all other particles on any given particle. This blog post will delve into the scientific principles of mean field theory and explore its specific applications in understanding magnetism.

Fundamental Principles of Mean Field Theory

Mean field theory simplifies the interactions within a system by assuming that each particle in the system experiences an average field produced by all other particles, rather than a unique interaction with every other individual particle. This approximation reduces the complexity of the problem, making it more tractable while still capturing essential features of the system's behavior.

Mathematical Formulation

In the context of magnetism, mean field theory can be applied to model the behavior of spins in magnetic materials. The key idea is to replace the many interactions of a spin with its neighbors by a single averaged effect. Mathematically, the Hamiltonian of a magnetic system in the presence of an external magnetic field ?? can be expressed as:

where Jij are the exchange interactions between spins Si and Sj, and μ is the magnetic moment of the spins. In mean field theory, the exchange interaction term is simplified by assuming each spin experiences an average field ??eff, given by:

where ?Sj? is the thermal average of the spin at site j, assuming uniformity for simplification.

Application of Mean Field Theory to Magnetism

Magnetization and Phase Transitions

The most direct application of mean field theory in magnetism is in the calculation of magnetization and the analysis of magnetic phase transitions, such as the transition from ferromagnetic to paramagnetic states at the Curie temperature. By using mean field theory, one can derive the so-called self-consistent equation for magnetization of a system

where

includes both the external magnetic field and the mean field contribution from all other spins, and ??0 is the effective exchange interaction parameter.

A Comparative Analysis of Metropolis and Mean Field Methods

The Metropolis algorithm is a cornerstone of computational physics used to model thermal fluctuations within systems described by the Ising model. The Ising model, in its simplest form, consists of a lattice of spins that can interact with their neighbors and an external magnetic field. Here’s a detailed look at the algorithm’s application:

1. Random Spin Selection and Energy Evaluation: In each step of the algorithm, a single spin is randomly selected. The change in the system's energy (Δ??) if this spin were to flip is calculated, taking into account the nearest-neighbor interactions and any external magnetic field.
2. Spin Flip Decision: The algorithm decides whether to flip the spin based on the Boltzmann probability: if ΔE<0, the flip is energetically favorable and automatically accepted. If Δ??>0 the flip may still occur with a probability exp(???Δ??), where ??=1/(??????) is the inverse thermal energy.

Mean field theory offers a more abstract, averaged view of system behavior by approximating the effects of all other particles on any given particle with a single average field. This simplification allows for analytical predictions about the system’s behavior:

• Effective Field Approximation: Each spin is assumed to be subject to an effective magnetic field, which is a sum of the external field and a mean field proportional to the average magnetization of the system.
• Self-consistency Equation: The magnetization in the next time step is predicted using the self-consistency equation derived from mean field assumptions, specifically, ??=tanh(??(????+?)), where ?? is the interaction strength, ?? the average magnetization, and ? the external field.

Python Script

The Python script below performs a simulation of the Ising model using the Metropolis algorithm and compares the results to predictions made by mean field theory

import numpy as np
import matplotlib.pyplot as plt

def energy(s, J, h):
    return -J * (s[:-1] * s[1:]).sum() - h * s.sum()        

• energy(s, J, h): This function calculates the total energy of a state s of spins in the Ising model. The energy consists of two parts:-J * (s[:-1] * s[1:]).sum(): Interaction energy between nearest-neighbor spins. s[:-1] * s[1:] performs element-wise multiplication between all pairs of neighboring spins, capturing the energy contribution from each interaction. The interaction strength J influences whether spins prefer to align (ferromagnetic if J>0) or oppose each other (antiferromagnetic if J<0).-h * s.sum(): Interaction of spins with an external magnetic field h. This term sums the orientation of all spins, multiplied by the external field, affecting their alignment with the field.

def metropolis(s, beta, J, h):
    for _ in range(len(s)):
        i = np.random.randint(len(s))  # choose a random spin
        delta_E = 2 * J * s[i] * (s[i-1] + s[(i+1)%len(s)]) + 2 * h * s[i]  # compute the change in energy
        if delta_E < 0 or np.random.rand() < np.exp(-beta * delta_E):  # Metropolis condition
            s[i] *= -1  # flip the spin        

• metropolis(s, beta, J, h): This function updates the state s of spins according to the Metropolis algorithm. For each spin:i = np.random.randint(len(s)): Randomly select a spin index i.delta_E = 2 * J * s[i] * (s[i-1] + s[(i+1)%len(s)]) + 2 * h * s[i]: Calculate the energy change if spin i were flipped. This includes contributions from interactions with the nearest neighbors and the external field.if delta_E < 0 or np.random.rand() < np.exp(-beta * delta_E): The spin flip is accepted if it lowers the energy (delta_E < 0) or probabilistically if the change increases the energy, governed by the thermal energy k_BT (captured by beta = 1/(k_BT)).

J = 1.0  # interaction strength
h = 0.0  # external magnetic field
T = 2.0  # temperature
beta = 1.0 / T  # inverse temperature
N = 1000  # number of spins
steps = 10000  # number of updates
s = np.ones(N)
magnetizations = np.zeros(steps)
mean_field_predictions = np.zeros(steps)
for i in range(steps):
    metropolis(s, beta, J, h)
    magnetizations[i] = s.sum() / N  # calculate the magnetization
    mean_field_predictions[i] = np.tanh(beta * (J * magnetizations[i] + h))
plt.figure(figsize=(14, 7))
plt.plot(magnetizations, label='Metropolis Simulation')
plt.plot(mean_field_predictions, label='Mean Field Prediction', linestyle='--')
plt.xlabel('Step')
plt.ylabel('Average Magnetization')
plt.title('Comparison of Metropolis Simulation and Mean Field Theory Prediction')
plt.legend()
plt.show()        

the simulation is setup and spins initiatize with arrays.

s = np.ones(N): Initialize all spins in the up direction.

magnetizations: Array to store the magnetization after each step of the Metropolis algorithm.

mean_field_predictions: Array to store the predicted magnetization from mean field theory after each step.

The loop runs the simulation, updating the spins using the Metropolis algorithm, calculating the system's magnetization, and computing mean field theory predictions for comparison.

Results

1.??? Initial Conditions: At the very beginning, there appears to be a transient where the Metropolis simulation shows a large deviation (spike) in magnetization. This is typical of thermal systems as they start far from equilibrium under certain initial conditions.

2.??? Metropolis Simulation Behavior (Blue Line):

·???????? The Metropolis simulation exhibits considerable fluctuation throughout the process. This fluctuating behavior is characteristic of the stochastic nature of the Metropolis algorithm, which incorporates random spin flips influenced by thermal energy and local interactions.

·???????? The fluctuations appear to remain fairly consistent in amplitude throughout the simulation, indicating a dynamic equilibrium state where the system continually explores various configurations due to thermal agitation.

3.??? Mean Field Prediction (Orange Dashed Line):

·???????? The mean field theory prediction shows much less fluctuation and is generally smoother. This model calculates magnetization based on a deterministic approximation, where each spin is assumed to feel an average field due to the overall magnetization of the system rather than individual interactions.

·???????? The mean field model generally underestimates the variability seen in the actual simulation, suggesting it may not capture short-term dynamical behaviors and local fluctuations effectively.

4.??? Comparison and Discrepancies:

·???????? There is a clear discrepancy between the two models regarding the variability of the magnetization. The mean field prediction does not capture the same level of detail as the Metropolis simulation, highlighting one of the limitations of mean field theory in accounting for microstate variations within the system.

·???????? The average levels of magnetization, when disregarding fluctuations, appear somewhat aligned, suggesting that the mean field theory may still provide a reasonable approximation of the average system behavior over longer timescales.

Curie Point

The Metropolis algorithm itself does not predict the Curie point. However, it can be used in simulations of the Ising model to estimate the Curie temperature, which is the temperature at which a ferromagnetic material loses its magnetization and becomes paramagnetic.

The Curie temperature is associated with a phase transition in the Ising model. Below the Curie temperature, the system is in a ferromagnetic phase, where the spins tend to align and the system has a net magnetization. Above the Curie temperature, the system is in a paramagnetic phase, where the spins are randomly oriented and the system has zero net magnetization.

By running simulations of the Ising model at different temperatures and measuring the average magnetization, you can estimate the Curie temperature as the temperature at which the average magnetization drops to zero.

This code runs the Metropolis algorithm for a range of temperatures and calculates the average magnetization at each temperature. It then estimates the Curie temperature as the temperature at which the magnetization first drops below zero.

Please note that this is a very rough estimate. A more accurate estimate would require running the simulation for longer, averaging over multiple runs, and using a more sophisticated method to determine the transition point.

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt

# Parameters
J = 1.0  # interaction strength
h = 0.0  # external magnetic field
N = 1000  # number of spins
steps = 20000  # number of updates
runs = 10  # number of runs

# Temperature range
T_min = 1.0
T_max = 4.0
T_step = 0.1
temperatures = np.arange(T_min, T_max, T_step)

# Array to store the average magnetization at each temperature
magnetizations = np.zeros(len(temperatures))

# Define the Metropolis step as a TensorFlow function for GPU acceleration
@tf.function
def metropolis(s, beta, J, h):
    for _ in range(len(s)):
        i = tf.random.uniform(shape=[], minval=0, maxval=len(s), dtype=tf.int32)  # choose a random spin
        delta_E = tf.cast(2 * J * s[i] * (s[i-1] + s[(i+1)%len(s)]) + 2 * h * s[i], tf.float32)  # compute the change in energy
        if delta_E < 0 or tf.random.uniform(shape=[]) < tf.exp(-beta * delta_E):  # Metropolis condition
            updates = tf.constant([-1], dtype=tf.float32) * s[i]
            indices = tf.reshape(i, [1, 1])
            s = tf.tensor_scatter_nd_update(s, indices, updates)  # flip the spin
    return s

# Loop over temperatures
for i, T in enumerate(temperatures):
    beta = tf.cast(1.0 / T, tf.float32)  # inverse temperature

    # Average magnetization over multiple runs
    magnetization_runs = np.zeros(runs)
    for r in range(runs):
        # Initial state: all spins up
        s = tf.ones(N, dtype=tf.float32)

        # Thermalization
        for _ in range(steps // 2):
            s = metropolis(s, beta, J, h)

        # Run the Metropolis algorithm and calculate the average magnetization
        magnetization_steps = np.zeros(steps // 2)
        for j in range(steps // 2):
            s = metropolis(s, beta, J, h)
            magnetization_steps[j] = tf.reduce_sum(s).numpy() / N  # calculate the magnetization

        # Average magnetization over the last half of the steps
        magnetization_runs[r] = magnetization_steps.mean()

    # Average magnetization over multiple runs
    magnetizations[i] = magnetization_runs.mean()

# Plot the average magnetization as a function of temperature
plt.figure(figsize=(10, 6))
plt.plot(temperatures, magnetizations, label='Average Magnetization')
plt.xlabel('Temperature')
plt.ylabel('Average Magnetization')
plt.title('Average Magnetization vs Temperature')
plt.grid(True)
plt.legend()
plt.show()