Last Updated on October 30, 2024 by Max
Matter-wave diffraction occurs when particles such as atoms or sub-atomic particles exhibit wave-like behavior, resulting in interference patterns. This phenomenon is analogous to light wave diffraction, where light waves spread and interfere upon passing through slits.
In this article, we will explore methods for numerically simulating electron matter-wave diffraction patterns in both position and momentum space.
By analyzing the time evolution of an electron’s wave packet through a multi-slit grating, we demonstrate the diffraction patterns that emerge in both real and momentum space. This reveals the quantum behavior of particles. Detailed Python code and animations are provided.
Numerical Methods
Here, we use the Split-Step Fourier Method (SSFM) to simulate the time evolution of an electron’s wave packet through a multi-slit grating. The detailed mathematical steps are described in our article titled “Simulation of Matter-Wave Diffraction Through a Grating.“
For completeness, a brief description of the key mathematical steps is as follows:
1. Time-Dependent Schrödinger Equation (TDSE):
The TDSE in two dimensions is given by:
\[i\hbar \frac{\partial \psi(x, y, t)}{\partial t} = -\frac{\hbar^2}{2m_e} \left(\frac{\partial^2 \psi(x, y, t)}{\partial x^2} + \frac{\partial^2 \psi(x, y, t)}{\partial y^2}\right) + V(x, y) \psi(x, y, t)\]
where \( \psi(x, y, t) \) represents the wave function, \( \hbar \) is the reduced Planck constant, \( m_e \) is the electron mass, and \( V(x, y) \) denotes the potential energy. This equation governs the 2D quantum dynamics of a particle under a potential.
2. Split-Step Fourier Method (SSFM): This numerical technique is highly effective for solving partial differential equations like the TDSE. In the standard SSFM, each time step is divided into three parts:
- Half-Step Evolution in Real Space (Potential Energy): The wave function is first evolved by half a time step in real space by applying an exponential factor involving the potential energy.
- Full-Step Evolution in Momentum Space (Kinetic Energy): The wave function is then transformed into momentum space using the Fast Fourier Transform (FFT) and evolved for a full time step under the kinetic energy operator.
- Final Half-Step Evolution in Real Space (Potential Energy): The wave function is transformed back to real space using the inverse FFT, where it undergoes the remaining half-step evolution under the potential energy.
- This process is repeated iteratively for each time step.
3. Potential Energy Landscape: The potential energy is defined as a multi-slit grating, where regions within the slits have lower potential, while the barriers have higher potential. This potential landscape modulates the wave packet as it passes through the grating, leading to diffraction.
4. Gaussian Wave Packet Initialization: The initial wave packet is a Gaussian function centered at a specific position with a given width and momentum, representing a localized electron.
5. Fourier Transform: The FFT is used to switch between real space (where potential energy acts) and momentum space (where kinetic energy acts). This allows the efficient computation of the wave function’s evolution.
Animation in Real and Momentum-Space
Animation Code in Python
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation
# Constants
hbar = 1.0545718e-34 # Reduced Planck constant (Joule second)
m_e = 9.10938356e-31 # Mass of electron (kg)
wavelength = 20e-9 # de Broglie wavelength (meters)
k0 = 2 * np.pi / wavelength # Wave number
# Grid parameters
Lx, Ly = 1e-6, 1e-6 # Simulation domain size (meters)
Nx, Ny = 512, 512 # Number of grid points
dx, dy = Lx / Nx, Ly / Ny # Grid spacing
x = np.linspace(-Lx / 2, Lx / 2, Nx)
y = np.linspace(-Ly / 2, Ly / 2, Ny)
X, Y = np.meshgrid(x, y)
# Time parameters
dt = 3e-14 # Time step (seconds)
Nt = 501 # Number of time steps
# Wave packet parameters
sigma_x = sigma_y = 60e-9 # Width of the Gaussian packet (meters)
x0, y0 = -2e-7, 0 # Initial position of the packet (meters)
kx0, ky0 = k0, 0 # Initial wave vector
# Grating parameters
slit_width = 3e-8 # Width of each slit (meters)
barrier_width = 3e-8 # Width of the barrier between slits (meters)
grating_thickness = 2e-8 # Thickness of the grating (meters)
h0 = 5 * hbar**2 * k0**2 / (2 * m_e) # Height of the potential for the barrier
num_slits = 40 # Number of slits
# Initial Gaussian wave packet
psi0 = np.exp(-(X - x0) ** 2 / (2 * sigma_x ** 2)) * np.exp(-(Y - y0) ** 2 / (2 * sigma_y ** 2))
psi0 = psi0.astype(np.complex128)
psi0 *= np.exp(1j * (kx0 * X + ky0 * Y))
# Normalize the initial wave packet
psi0 /= np.sqrt(np.sum(np.abs(psi0) ** 2))
# Potential energy (Multi-slit grating)
V = np.zeros_like(X)
x1, x2 = -grating_thickness / 2, grating_thickness / 2
y_coords = np.linspace(-0.45 * num_slits * barrier_width - 0.5 * num_slits * slit_width,
0.45 * num_slits * barrier_width + 0.5 * num_slits * slit_width, 2 * num_slits)
for i in range(Nx):
for j in range(Ny):
if x1 <= X[i, j] <= x2:
for k in range(0, len(y_coords), 2):
if y_coords[k] <= Y[i, j] <= y_coords[k + 1]:
V[i, j] = h0
# Fourier space components
kx = np.fft.fftfreq(Nx, dx) * 2 * np.pi
ky = np.fft.fftfreq(Ny, dy) * 2 * np.pi
KX, KY = np.meshgrid(kx, ky)
K2 = KX ** 2 + KY ** 2
# Split-step Fourier method
psi = psi0.copy()
# Prepare for animation in real space and momentum space
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(16, 8))
# Initialize the plot for real space
real_space_distribution = np.abs(psi) ** 2
normalized_V = V / np.max(V)
im1 = ax1.imshow(real_space_distribution/np.max(real_space_distribution) + 0.5* normalized_V , extent=[-Lx / 2, Lx / 2, -Ly / 2, Ly / 2], cmap='viridis', animated=True)
# Initialize the plot for momentum space
momentum_distribution = np.abs(np.fft.fftshift(np.fft.fft2(psi)))
im2 = ax2.imshow(momentum_distribution/np.max(momentum_distribution), extent=[-1e9, 1e9, -1e9, 1e9], cmap='viridis', animated=True)
# Set the axis limits for real space
ax1.set_xlim([-Lx / 2, Lx / 2])
ax1.set_ylim([-Ly / 2, Ly / 2])
ax1.set_xlabel('x (m)', fontsize=14)
ax1.set_ylabel('y (m)', fontsize=14)
ax1.set_title('Probability Density in Real Space', fontsize=16)
ax1.tick_params(axis='both', which='major', labelsize=18) # Increased tick label size
# Set the axis limits for momentum space
ax2.set_xlim([-0.5e9, 0.5e9])
ax2.set_ylim([-0.5e9, 0.5e9])
ax2.set_xlabel('kx (1/m)', fontsize=14)
ax2.set_ylabel('ky (1/m)', fontsize=14)
ax2.set_title('Momentum Space Distribution', fontsize=16)
ax2.tick_params(axis='both', which='major', labelsize=18) # Increased tick label size
def update(t):
global psi
# (a) 1/2 Evolution for the potential energy in real space
psi *= np.exp(-1j * V * dt / (2 * hbar))
# (b) Forward transform
psi_k = np.fft.fft2(psi)
# (c) Full evolution for the kinetic energy in Fourier space
psi_k *= np.exp(-1j * hbar * K2 * dt / (2 * m_e))
# (d) Inverse Fourier transform
psi = np.fft.ifft2(psi_k)
# (e) 1/2 Evolution for the potential energy in real space
psi *= np.exp(-1j * V * dt / (2 * hbar))
# Update the visualization in real space
real_space_distribution = np.abs(psi)**2
im1.set_array(real_space_distribution/np.max(real_space_distribution) + 0.5* normalized_V)
# Update the visualization in momentum space
momentum_distribution = np.abs(np.fft.fftshift(psi_k))
im2.set_array(momentum_distribution/np.max(momentum_distribution))
# Update the common title with the current time step
fig.suptitle(f'Time Step: {t}', fontsize=24, fontweight='bold')
return [im1, im2]
# Animate the plot
ani = animation.FuncAnimation(fig, update, frames=Nt, repeat=False)
# Save the animation
ani.save('electron_diffraction_real_and_momentum_space.mp4', writer='ffmpeg', fps=20)
plt.show()
Summary
In this article, a method for simulating electron matter-wave diffraction patterns is presented using the Split-Step Fourier Method (SSFM). The Time-Dependent Schrödinger Equation (TDSE) is solved in two dimensions to model how an electron’s wave packet passes through a multi-slit grating. Diffraction patterns in position and momentum space are generated by alternating real-space and momentum-space evolutions. A Gaussian wave packet initialization and FFT are utilized for accurate computations, with Python code and animations provided to illustrate the resulting quantum interference.
I am a science enthusiast and writer, specializing in matter-wave optics and related technologies. My goal is to promote awareness and understanding of these advanced fields among students and the general public.
