Part 8, Chapter 5

Dusty Plasmas

Charged dust grains and complex plasma phenomena

5.1 Dust Grain Charging

A dust grain immersed in a plasma collects electrons and ions from the background. Since electrons are faster than ions (at the same temperature), the grain initially accumulates a net negative charge. The grain potential adjusts until the electron and ion currents balance, reaching a floating potential.

In the Orbital Motion Limited (OML) theory, the currents to a spherical grain of radius$a$ at potential$\phi_d$ are:

$$I_e = -\pi a^2 n_e e \sqrt{\frac{8T_e}{\pi m_e}} \exp\!\left(\frac{e\phi_d}{T_e}\right), \quad \phi_d < 0$$

$$I_i = \pi a^2 n_i e \sqrt{\frac{8T_i}{\pi m_i}} \left(1 - \frac{e\phi_d}{T_i}\right), \quad \phi_d < 0$$

The equilibrium (floating) condition is:

$$I_e + I_i = 0$$

For a hydrogen plasma with $T_e = T_i$, the floating potential is approximately:

$$\phi_d \approx -2.5\,\frac{T_e}{e}$$

The dust charge is then $Q_d = C_d \phi_d = 4\pi\epsilon_0 a \phi_d$, giving a charge number $Z_d = |Q_d|/e$. For a 1-micrometer grain in a 1 eV plasma, $Z_d \sim 10^3$ -- dust grains carry enormous charges.

5.2 Dust Acoustic Waves

A dusty plasma supports a new low-frequency wave mode: the dust acoustic wave (DAW). The massive, highly charged dust grains provide the inertia, while electrons and ions provide the restoring pressure through Debye shielding.

The dispersion relation, derived from the fluid equations for the dust-ion-electron system with Boltzmann electrons and ions, is:

$$\omega^2 = \frac{k^2 c_{DA}^2}{1 + k^2\lambda_D^2}$$

where the dust acoustic speed is:

$$c_{DA} = \sqrt{\frac{Z_d n_{d0} T_i}{n_{i0} m_d}}$$

and the effective Debye length combines the electron and ion Debye lengths:

$$\frac{1}{\lambda_D^2} = \frac{1}{\lambda_{De}^2} + \frac{1}{\lambda_{Di}^2}$$

The DAW has frequencies in the range of 1-100 Hz (much lower than ion acoustic waves) and phase velocities of centimeters per second -- slow enough to observe individual wave crests with a camera in laboratory experiments. DAWs were first predicted by Rao, Shukla, and Yu in 1990 and observed experimentally shortly thereafter.

5.3 Strongly Coupled Dusty Plasmas

Because dust grains carry thousands of elementary charges and can be cooled to room temperature or below, dusty plasmas can become strongly coupled. The Coulomb coupling parameter is:

$$\Gamma = \frac{Z_d^2 e^2}{4\pi\epsilon_0\, a_{WS}\, T_d}$$

where $a_{WS} = (3/(4\pi n_d))^{1/3}$ is the Wigner-Seitz radius (mean interparticle spacing) and $T_d$ is the dust kinetic temperature.

When $\Gamma \gg 1$, the Coulomb interaction energy dominates over the thermal kinetic energy. The dust component transitions from a gaseous to a liquid-like state, and for $\Gamma > 170$, it crystallizes into a "plasma crystal" or "Coulomb crystal." These crystals have been observed with hexagonal lattice structures in laboratory experiments.

The Debye shielding by electrons and ions modifies the bare Coulomb interaction to a Yukawa (screened Coulomb) potential:

$$\phi(r) = \frac{Z_d e}{4\pi\epsilon_0 r}\exp\!\left(-\frac{r}{\lambda_D}\right)$$

The screening parameter $\kappa = a_{WS}/\lambda_D$ determines how quickly the interaction falls off. The phase diagram of the dust component depends on both$\Gamma$ and $\kappa$.

Interactive Simulation

Dust Charging Curves and Dust Acoustic Dispersion

Python

script.py110 lines

import numpy as np
from scipy.optimize import brentq

# Constants
e = 1.602e-19
eps0 = 8.854e-12
m_e = 9.109e-31
m_p = 1.672e-27
k_B = 1.381e-23

print("=== OML Dust Grain Charging ===")
print()

# Parameters
T_e_eV = 2.0         # Electron temperature (eV)
T_e = T_e_eV * e     # in Joules
a_grain = 1e-6       # Grain radius (m)
n_e = 1e15           # Electron density (m^-3)

# Scan T_i/T_e ratio
tau_values = np.array([0.1, 0.25, 0.5, 1.0, 2.0, 5.0])
# Different ion masses
ion_species = [("H+", 1), ("Ar+", 40), ("Xe+", 131)]

print(f"Grain radius: {a_grain*1e6:.1f} um, T_e = {T_e_eV:.1f} eV, n_e = {n_e:.0e} m^-3")
print()

for ion_name, A in ion_species:
    m_i = A * m_p
    print(f"--- Ion species: {ion_name} (A={A}) ---")
    print(f"{'T_i/T_e':>8} {'phi_d/T_e':>10} {'Z_d':>10} {'tau_charge (us)':>16}")
    print("-" * 48)

for tau in tau_values:
        T_i = tau * T_e

# Current balance: I_e + I_i = 0
        # I_e = -pi*a^2 * n_e * e * sqrt(8*T_e/(pi*m_e)) * exp(e*phi/T_e)
        # I_i = +pi*a^2 * n_i * e * sqrt(8*T_i/(pi*m_i)) * (1 - e*phi/T_i)
        # At equilibrium n_e ~ n_i (no dust charge correction for simplicity)
        # Set phi = chi * T_e / e (chi < 0)

v_e = np.sqrt(8 * T_e / (np.pi * m_e))
        v_i = np.sqrt(8 * T_i / (np.pi * m_i))

def current_balance(chi):
            # chi = e*phi_d / T_e (negative)
            Ie = -v_e * np.exp(chi)
            Ii = v_i * (1 - chi * T_e / T_i)
            return Ie + Ii

# Find root
        chi_sol = brentq(current_balance, -10, -0.01)
        phi_d = chi_sol * T_e / e  # in Volts

# Charge
        C_d = 4 * np.pi * eps0 * a_grain
        Q_d = C_d * phi_d
        Z_d = abs(Q_d) / e

# Charging time ~ C_d / (dI/dphi) ~ C_d * T_e / (e * I_e0)
        I_e0 = np.pi * a_grain**2 * n_e * e * v_e
        tau_charge = C_d * T_e / (e * I_e0)

print(f"{tau:8.2f} {chi_sol:10.3f} {Z_d:10.0f} {tau_charge*1e6:16.2f}")
    print()

# Dust acoustic wave dispersion
print("=== Dust Acoustic Wave Dispersion ===")
print()

# Parameters
T_i_eV = 0.03       # Room temperature ions
T_e_eV_daw = 3.0    # Electron temperature
T_i = T_i_eV * e
T_e_daw = T_e_eV_daw * e
m_d = 1e-14          # Dust mass (kg, ~10 um grain)
n_i = 1e14           # Ion density (m^-3)
Z_d_val = 5000       # Dust charge number
n_d = 1e10           # Dust density (m^-3)
m_i_ar = 40 * m_p    # Argon ions

lambda_De = np.sqrt(eps0 * T_e_daw / (n_i * e**2))
lambda_Di = np.sqrt(eps0 * T_i / (n_i * e**2))
lambda_D = 1.0 / np.sqrt(1/lambda_De**2 + 1/lambda_Di**2)

c_DA = np.sqrt(Z_d_val * n_d * T_i / (n_i * m_d))

print(f"Z_d = {Z_d_val}, n_d = {n_d:.0e} m^-3, m_d = {m_d:.0e} kg")
print(f"lambda_De = {lambda_De*1e3:.2f} mm, lambda_Di = {lambda_Di*1e3:.3f} mm")
print(f"lambda_D = {lambda_D*1e3:.3f} mm")
print(f"c_DA = {c_DA*100:.2f} cm/s")
print()

k_vals = np.logspace(0, 4, 60)  # 1/m
omega_vals = np.sqrt(k_vals**2 * c_DA**2 / (1 + k_vals**2 * lambda_D**2))
freq_Hz = omega_vals / (2 * np.pi)

print(f"{'k (1/m)':>10} {'f (Hz)':>10} {'v_ph (cm/s)':>14} {'k*lambda_D':>12}")
print("-" * 50)
for i in range(0, len(k_vals), 6):
    k = k_vals[i]
    f = freq_Hz[i]
    v_ph = omega_vals[i] / k * 100  # cm/s
    print(f"{k:10.1f} {f:10.3f} {v_ph:14.3f} {k*lambda_D:12.4f}")

print()
print(f"Long wavelength limit: omega = k * c_DA = k * {c_DA*100:.2f} cm/s")
print(f"Short wavelength limit: omega -> omega_pd = {np.sqrt(Z_d_val**2 * n_d * e**2 / (eps0 * m_d)):.2f} rad/s")

Click Run to execute the Python code

Code will be executed with Python 3 on the server

← Previous Next →