17. MHD κΈ°μ΄ μ΄λ‘ (Magnetohydrodynamics Basics)
17. MHD κΈ°μ΄ μ΄λ‘ (Magnetohydrodynamics Basics)¶
νμ΅ λͺ©ν¶
- μκΈ°μ 체μν(MHD)μ κΈ°λ³Έ κ°λ μ΄ν΄
- MHD κ°μ κ³Ό μ μ© λ²μ νμ
- μ΄μ MHD λ°©μ μ μ λ
- Alfven μλμ MHD νλ μ΄ν΄
- μκΈ°μκ³Ό μκΈ°μ₯λ ₯ κ°λ νμ΅
1. MHD μκ°¶
1.1 μ μμ μμ©¶
μκΈ°μ 체μν (Magnetohydrodynamics, MHD):
- μ κΈ° μ λμ± μ 체μ μ μκΈ°μ₯μ μνΈμμ©
- μ 체μν + μ μκΈ°νμ κ²°ν©
μμ© λΆμΌ:
1. μ²μ²΄λ¬Όλ¦¬: νμ, νμ±, μν, μ±κ° λ§€μ§
2. ν΅μ΅ν©: ν μΉ΄λ§, μ€ν
λ¬λ μ΄ν° νλΌμ¦λ§ κ°λ
3. μ§κ΅¬λ¬Όλ¦¬: μ§κ΅¬ μκΈ°μ₯ λ€μ΄λλͺ¨
4. 곡ν: MHD λ°μ , μ μκΈ° νν, κΈμ μ£Όμ‘°
5. μ°μ£Όλ¬Όλ¦¬: νμν, μκΈ°κΆ, μ°μ£Ό λ μ¨
μμ¬:
- AlfvΓ©n (1942): MHD νλ λ°κ²¬ β 1970 λ
Έλ²¨ 물리νμ
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
# 물리 μμ
mu0 = 4 * np.pi * 1e-7 # μ§κ³΅ ν¬μμ¨ [H/m]
eps0 = 8.854e-12 # μ§κ³΅ μ μ μ¨ [F/m]
c = 299792458 # κ΄μ [m/s]
kB = 1.381e-23 # λ³ΌμΈ λ§ μμ [J/K]
me = 9.109e-31 # μ μ μ§λ [kg]
mp = 1.673e-27 # μμ±μ μ§λ [kg]
e = 1.602e-19 # κΈ°λ³Έ μ ν [C]
def mhd_introduction():
"""MHD κ°μ"""
print("=" * 60)
print("μκΈ°μ 체μν (MHD) κ°μ")
print("=" * 60)
intro = """
MHDμ ν΅μ¬ κ°λ
:
1. μ λμ± μ 체:
- νλΌμ¦λ§, μ‘체 κΈμ, μΌμ
- μμ μ νκ° μ μκΈ°μ₯μ λ°μ
- μ κΈ° μ λλ Ο > 0
2. μ 체-μκΈ°μ₯ μνΈμμ©:
- μκΈ°μ₯μ΄ μ 체 μ΄λμ νμ κ°ν¨ (Lorentz ν)
- μ 체 μ΄λμ΄ μκΈ°μ₯μ λ³νμν΄ (μ λ)
3. κ²°ν© λ°©μ μ:
- μ 체μν: μ°μ, μ΄λλ, μλμ§
- μ μκΈ°ν: Maxwell λ°©μ μ (μΌλΆ)
βββββββββββββββββββββββββββββββββββββββββββββββββββ
β MHD μμ β
β β
β [μ 체μν] βββββ κ²°ν© βββββ [μ μκΈ°ν] β
β β
β Ο, v, p J = Ο(E + vΓB) E, B β
β μ°μ/μ΄λλ Ohm's law Maxwell β
β μλμ§ (μΌλΆ) β
βββββββββββββββββββββββββββββββββββββββββββββββββββ
"""
print(intro)
mhd_introduction()
1.2 MHD μκ°/κ³΅κ° μ€μΌμΌ¶
def mhd_scales():
"""MHD κ΄λ ¨ μκ°/κ³΅κ° μ€μΌμΌ λΉκ΅"""
# νμ μ½λ‘λ νλΌμ¦λ§ μμ
n = 1e15 # λ°λ [m^-3]
T = 1e6 # μ¨λ [K]
B = 1e-2 # μκΈ°μ₯ [T]
L = 1e8 # νΉμ± κΈΈμ΄ [m]
# νλΌμ¦λ§ μ£Όνμ
omega_pe = np.sqrt(n * e**2 / (eps0 * me))
omega_pi = np.sqrt(n * e**2 / (eps0 * mp))
# μ¬μ΄ν΄λ‘νΈλ‘ μ£Όνμ
omega_ce = e * B / me
omega_ci = e * B / mp
# Debye κΈΈμ΄
lambda_D = np.sqrt(eps0 * kB * T / (n * e**2))
# μ΄μλ
v_te = np.sqrt(2 * kB * T / me)
v_ti = np.sqrt(2 * kB * T / mp)
# Alfven μλ
rho = n * mp
v_A = B / np.sqrt(mu0 * rho)
# μμ
gamma = 5/3
p = n * kB * T
c_s = np.sqrt(gamma * p / rho)
print("=" * 60)
print("νλΌμ¦λ§ μ€μΌμΌ (νμ μ½λ‘λ μμ)")
print("=" * 60)
print(f"\nμ
λ ₯ νλΌλ―Έν°:")
print(f" λ°λ n = {n:.2e} m^-3")
print(f" μ¨λ T = {T:.2e} K")
print(f" μκΈ°μ₯ B = {B*1000:.1f} mT")
print(f" νΉμ± κΈΈμ΄ L = {L/1e6:.0f} Mm")
print(f"\nμ£Όνμ:")
print(f" μ μ νλΌμ¦λ§ μ£Όνμ Οpe = {omega_pe:.2e} rad/s")
print(f" μ΄μ¨ νλΌμ¦λ§ μ£Όνμ Οpi = {omega_pi:.2e} rad/s")
print(f" μ μ μ¬μ΄ν΄λ‘νΈλ‘ Οce = {omega_ce:.2e} rad/s")
print(f" μ΄μ¨ μ¬μ΄ν΄λ‘νΈλ‘ Οci = {omega_ci:.2e} rad/s")
print(f"\nμλ:")
print(f" μ μ μ΄μλ vte = {v_te/1e6:.2f} Mm/s")
print(f" μ΄μ¨ μ΄μλ vti = {v_ti/1e3:.2f} km/s")
print(f" Alfven μλ vA = {v_A/1e3:.2f} km/s")
print(f" μμ cs = {c_s/1e3:.2f} km/s")
print(f"\nκΈΈμ΄ μ€μΌμΌ:")
print(f" Debye κΈΈμ΄ Ξ»D = {lambda_D:.4f} m")
print(f" μ μ κ΄μ± κΈΈμ΄ c/Οpe = {c/omega_pe:.4f} m")
print(f" μ΄μ¨ κ΄μ± κΈΈμ΄ c/Οpi = {c/omega_pi:.2f} m")
# MHD μ ν¨μ± 쑰건 νμΈ
print(f"\nMHD μ ν¨μ± 쑰건:")
print(f" L >> Ξ»D: {L:.2e} >> {lambda_D:.4f} β" if L > 1000*lambda_D else f" L >> Ξ»D: {L} !>> {lambda_D}")
print(f" L >> c/Οpi: {L:.2e} >> {c/omega_pi:.2f} β" if L > 100*c/omega_pi else f" L >> c/Οpi νμΈ νμ")
# μκ°ν
fig, ax = plt.subplots(figsize=(12, 6))
scales = {
'Ξ»D': lambda_D,
'c/Οpe': c/omega_pe,
'c/Οpi': c/omega_pi,
'vA/Οci': v_A/omega_ci,
'L (MHD)': L
}
y_pos = np.arange(len(scales))
values = list(scales.values())
labels = list(scales.keys())
ax.barh(y_pos, np.log10(values), color=['red', 'orange', 'yellow', 'green', 'blue'])
ax.set_yticks(y_pos)
ax.set_yticklabels(labels)
ax.set_xlabel('logββ(Length [m])')
ax.set_title('νλΌμ¦λ§ κΈΈμ΄ μ€μΌμΌ λΉκ΅')
ax.axvline(x=np.log10(L), color='black', linestyle='--', label='MHD μ€μΌμΌ')
ax.grid(True, alpha=0.3)
for i, v in enumerate(values):
ax.text(np.log10(v) + 0.1, i, f'{v:.2e} m', va='center')
plt.tight_layout()
plt.savefig('mhd_scales.png', dpi=150, bbox_inches='tight')
plt.show()
# mhd_scales()
2. MHD κ°μ ¶
2.1 κΈ°λ³Έ κ°μ ¶
MHDμ ν΅μ¬ κ°μ :
1. μ€μ€μ± (Quasi-neutrality):
ni β ne = n
- Debye κΈΈμ΄λ³΄λ€ ν° μ€μΌμΌμμ μ±λ¦½
- μ ν λΆλ¦¬ 무μ
2. μ μ£Όν κ·Όμ¬ (Low-frequency):
Ο << Οci << Οce
- λ³μ μ λ₯ 무μ: βD/βt β 0
- μ μ κ΄μ± 무μ
3. μ 체 κ·Όμ¬:
L >> Ξ»mfp (νκ· μμ κ²½λ‘)
- κ΅μ μ΄νν κ°μ
- μ΄λλ‘ μ ν¨κ³Ό 무μ
4. λΉμλλ‘ μ :
v << c
- μλλ‘ μ 보μ λΆνμ
κ²°κ³Ό:
- Maxwell λ°©μ μ λ¨μν
- μ κΈ°μ₯μ μκΈ°μ₯κ³Ό μλμμ μ λ
- μκΈ° μ λ λ°©μ μ λμΆ
def mhd_assumptions():
"""MHD κ°μ μ 물리μ μλ―Έ"""
print("=" * 60)
print("MHD κ°μ κ³Ό Maxwell λ°©μ μ λ¨μν")
print("=" * 60)
assumptions = """
Maxwell λ°©μ μ:
(1) βΒ·E = Οc/Ξ΅β β MHDμμ: μ€μ€μ±, Οc β 0
(2) βΒ·B = 0 β κ·Έλλ‘ μ μ§
(3) βΓE = -βB/βt β κ·Έλλ‘ μ μ§
(4) βΓB = ΞΌβJ + ΞΌβΞ΅ββE/βt β λ³μ μ λ₯ 무μ
λ¨μνλ Maxwell λ°©μ μ (MHD):
(1') βΒ·E β 0 (μ€μ€μ±)
(2') βΒ·B = 0
(3') βΓE = -βB/βt
(4') βΓB = ΞΌβJ (AmpΓ¨re λ²μΉ)
μΌλ°νλ Ohmμ λ²μΉ:
E + vΓB = Ξ·J + (JΓB)/ne - βpe/ne + (me/neΒ²)βJ/βt
β β β β
μ ν Hall μ μμλ ₯ μ μκ΄μ±
μ΄μ MHD (Ideal MHD):
E + vΓB = 0 (λͺ¨λ μ°λ³ ν 무μ)
β μκΈ°μ₯μ΄ μ 체μ ν¨κ» "λκ²°" (frozen-in)
μ νμ± MHD (Resistive MHD):
E + vΓB = Ξ·J (μ ν ν¨κ³Όλ§ ν¬ν¨)
β μκΈ°μ₯ νμ° λ° μ¬κ²°ν© κ°λ₯
"""
print(assumptions)
mhd_assumptions()
3. μ΄μ MHD λ°©μ μ¶
3.1 μ§λ°° λ°©μ μ¶
μ΄μ MHD λ°©μ μ 체κ³:
1. μ§λ 보쑴:
βΟ/βt + βΒ·(Οv) = 0
2. μ΄λλ 보쑴:
Ο(βv/βt + (vΒ·β)v) = -βp + JΓB + Οg
β
Lorentz ν
JΓB = (βΓB)ΓB/ΞΌβ = (BΒ·β)B/ΞΌβ - β(BΒ²/2ΞΌβ)
β β
μκΈ°μ₯λ ₯ μκΈ°μ
3. μλμ§ λ³΄μ‘΄ (λ¨μ΄):
β/βt(p/Ο^Ξ³) + vΒ·β(p/Ο^Ξ³) = 0
λλ: βp/βt + vΒ·βp + Ξ³pβΒ·v = 0
4. μ λ λ°©μ μ:
βB/βt = βΓ(vΓB)
(E = -vΓB λμ
)
5. λ°μ° 쑰건:
βΒ·B = 0 (νμ μ μ§)
def ideal_mhd_equations():
"""μ΄μ MHD λ°©μ μ μκ°ν"""
print("=" * 60)
print("μ΄μ MHD λ°©μ μ 체κ³")
print("=" * 60)
equations = """
보쑴 νν (Conservative Form):
βU/βt + βΒ·F = S
μ¬κΈ°μ:
βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
β 보쑴 λ³μ U: β
β U = [Ο, Οv, B, E]α΅ β
β E = p/(Ξ³-1) + ΟvΒ²/2 + BΒ²/2ΞΌβ (μ΄ μλμ§) β
βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ€
β νλμ€ F (x λ°©ν₯): β
β Fβ = Οvx (μ§λ) β
β Fβ = Οvxv - BxB/ΞΌβ + P*I (μ΄λλ) β
β Fβ = vxB - Bxv (μκΈ°μ₯) β
β Fβ = (E + P*)vx - Bx(vΒ·B)/ΞΌβ (μλμ§) β
β β
β P* = p + BΒ²/2ΞΌβ (μ΄ μλ ₯) β
βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ€
β 8κ° λ³μ: Ο, vx, vy, vz, Bx, By, Bz, p β
β 8κ° λ°©μ μ: μ°μ(1), μ΄λλ(3), μ λ(3), μλμ§(1) β
β + μ μ½μ‘°κ±΄: βΒ·B = 0 β
βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
"""
print(equations)
# Lorentz ν μκ°ν
fig, axes = plt.subplots(1, 2, figsize=(14, 5))
# (1) μκΈ° μλ ₯
ax1 = axes[0]
# κ· μΌ μκΈ°μ₯ μμκ³Ό μΈλΆ
x = np.linspace(-2, 2, 50)
y = np.linspace(-2, 2, 50)
X, Y = np.meshgrid(x, y)
# μκΈ°μ₯ (z λ°©ν₯, μ€μ¬ μμμμ κ°ν¨)
Bz = np.exp(-(X**2 + Y**2))
# μκΈ° μλ ₯ β(BΒ²/2ΞΌβ)
B_pressure = Bz**2 / (2 * mu0)
grad_Bp_x, grad_Bp_y = np.gradient(B_pressure, x[1]-x[0])
im = ax1.pcolormesh(X, Y, B_pressure * 1e6, cmap='hot', shading='auto')
plt.colorbar(im, ax=ax1, label=r'$B^2/2\mu_0$ [ΞΌPa]')
# μκΈ°μ ꡬ배 (ν) νμ
skip = 5
ax1.quiver(X[::skip, ::skip], Y[::skip, ::skip],
-grad_Bp_x[::skip, ::skip], -grad_Bp_y[::skip, ::skip],
color='white', alpha=0.8)
ax1.set_xlabel('x')
ax1.set_ylabel('y')
ax1.set_title(r'μκΈ° μλ ₯ $-\nabla(B^2/2\mu_0)$: λ°κΉ₯ λ°©ν₯ ν')
ax1.set_aspect('equal')
# (2) μκΈ° μ₯λ ₯
ax2 = axes[1]
# 곑μ μκΈ°μ₯μ
theta = np.linspace(0, 2*np.pi, 100)
for r in [0.5, 1.0, 1.5]:
x_line = r * (1 + 0.3 * np.sin(2*theta)) * np.cos(theta)
y_line = r * (1 + 0.3 * np.sin(2*theta)) * np.sin(theta)
ax2.plot(x_line, y_line, 'b-', linewidth=1.5)
# μ₯λ ₯ λ°©ν₯ νμ (곑λ₯ μ€μ¬ λ°©ν₯)
for r in [1.0]:
theta_arrows = np.linspace(0, 2*np.pi, 8, endpoint=False)
for t in theta_arrows:
x0 = r * (1 + 0.3 * np.sin(2*t)) * np.cos(t)
y0 = r * (1 + 0.3 * np.sin(2*t)) * np.sin(t)
# 곑λ₯ μ€μ¬ λ°©ν₯ (λλ΅μ )
dx = -x0 * 0.3
dy = -y0 * 0.3
ax2.annotate('', xy=(x0+dx, y0+dy), xytext=(x0, y0),
arrowprops=dict(arrowstyle='->', color='red', lw=2))
ax2.set_xlabel('x')
ax2.set_ylabel('y')
ax2.set_title(r'μκΈ° μ₯λ ₯ $(B\cdot\nabla)B/\mu_0$: 곑λ₯ μ€μ¬ λ°©ν₯')
ax2.set_aspect('equal')
ax2.set_xlim(-2, 2)
ax2.set_ylim(-2, 2)
ax2.grid(True, alpha=0.3)
# λ²λ‘
ax2.plot([], [], 'b-', linewidth=2, label='μκΈ°λ ₯μ ')
ax2.plot([], [], 'r-', linewidth=2, label='μ₯λ ₯ λ°©ν₯')
ax2.legend()
plt.tight_layout()
plt.savefig('mhd_lorentz_force.png', dpi=150, bbox_inches='tight')
plt.show()
# ideal_mhd_equations()
4. Alfven μλ¶
4.1 μ μμ 물리μ μλ―Έ¶
Alfven μλ (AlfvΓ©n velocity):
vA = B / β(ΞΌβΟ)
물리μ μλ―Έ:
- μκΈ°λ ₯μ μ λ°λΌ μ ννλ ν‘νμ μλ
- μκΈ° μλμ§μ μ΄λ μλμ§μ λ±λΆλ°°
- BΒ²/2ΞΌβ ~ ΟvAΒ²/2
무차μ νλΌλ―Έν°:
- Alfven Mach μ: MA = v/vA
- νλΌμ¦λ§ λ² ν: Ξ² = 2ΞΌβp/BΒ² = (cs/vA)Β² Γ 2/Ξ³
Ξ² << 1: μκΈ°μ μ§λ°° (νμ μ½λ‘λ)
Ξ² >> 1: μ΄μ μ§λ°° (νμ λλ₯κΆ)
Ξ² ~ 1: λ λ€ μ€μ
def alfven_velocity_analysis():
"""Alfven μλ λΆμ"""
fig, axes = plt.subplots(1, 2, figsize=(14, 5))
# (1) λ€μν νκ²½μμμ Alfven μλ
ax1 = axes[0]
# νκ²½λ³ νλΌλ―Έν°
environments = {
'νμ μ½λ‘λ': {'n': 1e14, 'B': 0.01, 'T': 1e6},
'νμν (1AU)': {'n': 5e6, 'B': 5e-9, 'T': 1e5},
'μ±κ° λ§€μ§': {'n': 1e6, 'B': 3e-10, 'T': 1e4},
'ν μΉ΄λ§': {'n': 1e20, 'B': 5, 'T': 1e8},
'μ‘체 λνΈλ₯¨': {'n': 2.5e28, 'B': 0.1, 'T': 400} # λ°λλ₯Ό μ
μ μλ‘ λ³ν
}
names = []
v_A_values = []
v_s_values = []
for name, params in environments.items():
n = params['n']
B = params['B']
T = params['T']
# μ΄μ¨ μ§λ (νλΌμ¦λ§λ μμ±μ, λνΈλ₯¨μ Na)
if 'λνΈλ₯¨' in name:
m_ion = 23 * mp # Na μ§λ
rho = n * m_ion
else:
m_ion = mp
rho = n * m_ion
# Alfven μλ
v_A = B / np.sqrt(mu0 * rho)
# μμ
gamma = 5/3
p = n * kB * T
c_s = np.sqrt(gamma * p / rho)
names.append(name)
v_A_values.append(v_A)
v_s_values.append(c_s)
y_pos = np.arange(len(names))
ax1.barh(y_pos - 0.2, np.log10(v_A_values), 0.4, label=r'$v_A$', color='blue')
ax1.barh(y_pos + 0.2, np.log10(v_s_values), 0.4, label=r'$c_s$', color='red')
ax1.set_yticks(y_pos)
ax1.set_yticklabels(names)
ax1.set_xlabel('logββ(velocity [m/s])')
ax1.set_title('λ€μν νκ²½μμμ Alfven μλμ μμ')
ax1.legend()
ax1.grid(True, alpha=0.3)
# (2) νλΌμ¦λ§ λ² ν λ μ§
ax2 = axes[1]
B_range = np.logspace(-10, 1, 100) # μκΈ°μ₯ λ²μ
n_values = [1e6, 1e14, 1e20] # λ°λ
T = 1e6 # κ³ μ μ¨λ
colors = ['blue', 'green', 'red']
for n, color in zip(n_values, colors):
rho = n * mp
p = n * kB * T
# νλΌμ¦λ§ λ² ν
beta = 2 * mu0 * p / B_range**2
ax2.loglog(B_range, beta, color=color, linewidth=2, label=f'n = {n:.0e} mβ»Β³')
ax2.axhline(y=1, color='black', linestyle='--', label=r'$\beta = 1$')
ax2.fill_between([1e-10, 1e1], 1e-6, 1, alpha=0.2, color='blue', label=r'$\beta < 1$ (μκΈ°μ μ§λ°°)')
ax2.fill_between([1e-10, 1e1], 1, 1e6, alpha=0.2, color='red', label=r'$\beta > 1$ (μ΄μ μ§λ°°)')
ax2.set_xlabel('B [T]')
ax2.set_ylabel(r'$\beta = 2\mu_0 p / B^2$')
ax2.set_title(f'νλΌμ¦λ§ λ² ν (T = {T:.0e} K)')
ax2.legend(loc='upper right')
ax2.grid(True, alpha=0.3)
ax2.set_ylim(1e-6, 1e6)
ax2.set_xlim(1e-10, 1e1)
plt.tight_layout()
plt.savefig('alfven_velocity.png', dpi=150, bbox_inches='tight')
plt.show()
# alfven_velocity_analysis()
5. MHD νλ¶
5.1 νλ μ ν¶
μ΄μ MHDμ μΈ κ°μ§ νλ λͺ¨λ:
1. Alfven ν (μ λ¨ Alfven ν):
- μλ: vA = Bβ/β(ΞΌβΟ)
- λ°©ν₯: μκΈ°μ₯ λ°©ν₯μΌλ‘λ§ μ ν
- νΉμ±: ν‘ν, λΉμμΆμ±, μκΈ°λ ₯μ μ§λ
- μλ μλ: Ξ΄v β₯ Bβ, k
2. λΉ λ₯Έ μκΈ°μν (Fast Magnetosonic):
- μλ: vf = β[(vAΒ² + csΒ²)/2 + β((vAΒ² + csΒ²)Β² - 4vAΒ²csΒ²cosΒ²ΞΈ)/2]
- νΉμ±: μκΈ°μ + μ΄μ 볡μλ ₯
- λ±λ°©μ μ ν (λͺ¨λ λ°©ν₯)
3. λλ¦° μκΈ°μν (Slow Magnetosonic):
- μλ: vs = β[(vAΒ² + csΒ²)/2 - β((vAΒ² + csΒ²)Β² - 4vAΒ²csΒ²cosΒ²ΞΈ)/2]
- νΉμ±: μκΈ°μκ³Ό μ΄μμ λ°λ μμ©
- μκΈ°μ₯ λ°©ν₯ κ·Όμ²λ‘ μ ν
μ¬κΈ°μ ΞΈ = β (k, Bβ)
νΉμ κ²½μ°:
- ΞΈ = 0 (νν): vf = max(vA, cs), vs = min(vA, cs)
- ΞΈ = Ο/2 (μμ§): vf = β(vAΒ² + csΒ²), vs = 0
def mhd_wave_speeds():
"""MHD νλ μλ λΆμ° κ΄κ³"""
fig, axes = plt.subplots(1, 2, figsize=(14, 5))
# (1) νλ μλ vs μ ν κ°λ
ax1 = axes[0]
theta = np.linspace(0, np.pi/2, 100)
# vA/cs λΉμ¨ (νλΌμ¦λ§ λ² ν κ΄λ ¨)
ratios = [0.5, 1.0, 2.0] # vA/cs
for ratio in ratios:
vA = ratio
cs = 1.0
# λΉ λ₯Έ/λλ¦° ν
term1 = (vA**2 + cs**2) / 2
term2 = np.sqrt((vA**2 + cs**2)**2 - 4 * vA**2 * cs**2 * np.cos(theta)**2) / 2
v_fast = np.sqrt(term1 + term2)
v_slow = np.sqrt(np.maximum(term1 - term2, 0))
# Alfven ν (μ±λΆ)
v_alfven = np.abs(vA * np.cos(theta))
ax1.plot(np.degrees(theta), v_fast, '-', linewidth=2, label=f'Fast (vA/cs={ratio})')
ax1.plot(np.degrees(theta), v_slow, '--', linewidth=2, label=f'Slow (vA/cs={ratio})')
ax1.plot(np.degrees(theta), v_alfven, ':', linewidth=2, label=f'Alfven (vA/cs={ratio})')
ax1.set_xlabel('ΞΈ [degrees]')
ax1.set_ylabel('Phase velocity / cs')
ax1.set_title('MHD νλ μλ vs μ ν κ°λ')
ax1.legend(loc='upper right', fontsize=8)
ax1.grid(True, alpha=0.3)
ax1.set_xlim(0, 90)
# (2) ν리λ리νμ€ λ€μ΄μ΄κ·Έλ¨ (κ·Ήμ’ν)
ax2 = axes[1]
theta_full = np.linspace(0, 2*np.pi, 360)
vA = 2.0
cs = 1.0
term1 = (vA**2 + cs**2) / 2
term2 = np.sqrt((vA**2 + cs**2)**2 - 4 * vA**2 * cs**2 * np.cos(theta_full)**2) / 2
v_fast = np.sqrt(term1 + term2)
v_slow = np.sqrt(np.maximum(term1 - term2, 0))
v_alfven = np.abs(vA * np.cos(theta_full))
# κ·Ήμ’ν -> μ§κ΅μ’ν
x_fast = v_fast * np.sin(theta_full)
y_fast = v_fast * np.cos(theta_full)
x_slow = v_slow * np.sin(theta_full)
y_slow = v_slow * np.cos(theta_full)
x_alf = v_alfven * np.sin(theta_full)
y_alf = v_alfven * np.cos(theta_full)
ax2.plot(x_fast, y_fast, 'b-', linewidth=2, label='Fast')
ax2.plot(x_slow, y_slow, 'r-', linewidth=2, label='Slow')
ax2.plot(x_alf, y_alf, 'g--', linewidth=2, label='Alfven')
# Bβ λ°©ν₯ νμ
ax2.annotate('', xy=(0, 3), xytext=(0, 0),
arrowprops=dict(arrowstyle='->', color='black', lw=2))
ax2.text(0.2, 2.8, r'$B_0$', fontsize=14)
ax2.set_xlabel(r'$v_\perp / c_s$')
ax2.set_ylabel(r'$v_\parallel / c_s$')
ax2.set_title(f'Friedrichs λ€μ΄μ΄κ·Έλ¨ (vA/cs = {vA/cs})')
ax2.legend()
ax2.grid(True, alpha=0.3)
ax2.set_aspect('equal')
ax2.set_xlim(-3, 3)
ax2.set_ylim(-3, 3)
plt.tight_layout()
plt.savefig('mhd_waves.png', dpi=150, bbox_inches='tight')
plt.show()
# mhd_wave_speeds()
5.2 Alfven ν μκ°ν¶
def alfven_wave_visualization():
"""Alfven ν μκ°ν"""
fig = plt.figure(figsize=(14, 10))
# (1) Alfven ν κ°λ
λ (3D)
ax1 = fig.add_subplot(221, projection='3d')
z = np.linspace(0, 4*np.pi, 100)
t = 0
# νν μκΈ°μ₯ λ°©ν₯ (z)
B0 = 1.0
# μλ (y λ°©ν₯ μ§λ)
k = 1
omega = k # vA = 1λ‘ μ κ·ν
By = 0.3 * np.sin(k*z - omega*t)
# μκΈ°λ ₯μ μμΉ
x_line = np.zeros_like(z)
y_line = By
ax1.plot(x_line, y_line, z, 'b-', linewidth=2, label='μκΈ°λ ₯μ ')
ax1.plot([0]*len(z), [0]*len(z), z, 'k--', alpha=0.5, label='νν μμΉ')
# μλ μλ
vy = -0.3 * np.sin(k*z - omega*t) # v β -B (Alfven κ΄κ³)
skip = 10
ax1.quiver(x_line[::skip], y_line[::skip], z[::skip],
np.zeros(len(z[::skip])), vy[::skip], np.zeros(len(z[::skip])),
color='red', length=0.5, arrow_length_ratio=0.3, label='μλ μλ')
ax1.set_xlabel('x')
ax1.set_ylabel('y')
ax1.set_zlabel('z (Bβ λ°©ν₯)')
ax1.set_title('Alfven ν: μκΈ°λ ₯μ ν‘λ°©ν₯ μ§λ')
ax1.legend()
# (2) μκ° μ κ°
ax2 = fig.add_subplot(222)
z = np.linspace(0, 4*np.pi, 200)
times = [0, 0.5, 1.0, 1.5, 2.0]
colors = plt.cm.viridis(np.linspace(0, 1, len(times)))
for t, color in zip(times, colors):
By = 0.3 * np.sin(k*z - omega*t)
ax2.plot(z, By, color=color, linewidth=1.5, label=f't = {t:.1f}')
ax2.set_xlabel('z')
ax2.set_ylabel(r'$\delta B_y$')
ax2.set_title('Alfven ν μ ν')
ax2.legend()
ax2.grid(True, alpha=0.3)
# (3) μλμ§ λΆλ°°
ax3 = fig.add_subplot(223)
# μκΈ° μλμ§μ μ΄λ μλμ§
z = np.linspace(0, 4*np.pi, 200)
t = 0.5
B_pert = 0.3 * np.sin(k*z - omega*t)
v_pert = -0.3 * np.sin(k*z - omega*t)
# μλμ§ λ°λ (λ¨μ 무μ, λΉλ‘ κ΄κ³λ§)
E_mag = B_pert**2 / 2 # β BΒ²/2ΞΌβ
E_kin = v_pert**2 / 2 # β ΟvΒ²/2
ax3.plot(z, E_mag, 'b-', linewidth=2, label=r'$\delta B^2/2\mu_0$ (μκΈ°)')
ax3.plot(z, E_kin, 'r--', linewidth=2, label=r'$\rho\delta v^2/2$ (μ΄λ)')
ax3.plot(z, E_mag + E_kin, 'k-', linewidth=2, label='Total')
ax3.set_xlabel('z')
ax3.set_ylabel('Energy density')
ax3.set_title('Alfven ν μλμ§ λ±λΆλ°°')
ax3.legend()
ax3.grid(True, alpha=0.3)
# (4) μλ κ΄κ³
ax4 = fig.add_subplot(224)
# Ξ΄v = -Ξ΄B/β(ΞΌβΟ) (Alfven κ΄κ³)
info_text = """
Alfven ν νΉμ±:
1. μ ν λ°©ν₯: Bβ λ°©ν₯ (k β₯ Bβ)
2. νΈκ΄: ν‘ν (Ξ΄v β₯ Bβ, Ξ΄B β₯ Bβ)
3. μλ: vA = Bβ/β(ΞΌβΟ)
μλ κ΄κ³:
Ξ΄v = β Ξ΄B/β(ΞΌβΟ)
(Β± for kΒ·Bβ β· 0)
νΉμ§:
- λΉμμΆμ±: βΒ·Ξ΄v = 0
- λ°λ/μλ ₯ μλ μμ
- μκΈ°λ ₯μ μ΄ "κΈ°ν μ€"μ²λΌ μ§λ
- μ₯λ ₯μ΄ λ³΅μλ ₯ μ 곡
Alfven μ 리 (λκ²° 쑰건):
μ΄μ MHDμμ μκΈ°λ ₯μ μ
μ 체μ ν¨κ» μμ§μ
("frozen-in" 쑰건)
"""
ax4.text(0.1, 0.95, info_text, transform=ax4.transAxes,
fontsize=10, verticalalignment='top', fontfamily='monospace',
bbox=dict(boxstyle='round', facecolor='wheat', alpha=0.5))
ax4.axis('off')
plt.tight_layout()
plt.savefig('alfven_wave_detail.png', dpi=150, bbox_inches='tight')
plt.show()
# alfven_wave_visualization()
6. μκΈ°μκ³Ό μκΈ°μ₯λ ₯¶
6.1 νμ λΆν΄¶
Lorentz ν λΆν΄:
JΓB = (1/ΞΌβ)(βΓB)ΓB
λ²‘ν° νλ±μ μ¬μ©:
(βΓB)ΓB = (BΒ·β)B - β(BΒ²/2)
λ°λΌμ:
JΓB = (BΒ·β)B/ΞΌβ - β(BΒ²/2ΞΌβ)
β β
μκΈ°μ₯λ ₯ μκΈ°μ ꡬ배
1. μκΈ° μλ ₯ (Magnetic Pressure):
pm = BΒ²/2ΞΌβ
- λ±λ°©μ (λͺ¨λ λ°©ν₯ λμΌ)
- Bκ° ν° μμμμ μμ μμμΌλ‘ ν
- μκΈ°μ₯μ λ°μ§ β λμ μλ ₯
2. μκΈ° μ₯λ ₯ (Magnetic Tension):
T = (BΒ·β)B/ΞΌβ = (BΒ²/ΞΌβ)ΞΊ
- 곑λ₯ ΞΊμ μ€μ¬ λ°©ν₯
- ν μκΈ°λ ₯μ μ ν΄λ €λ ν
- "κΈ°ν μ€ μ₯λ ₯"κ³Ό μ μ¬
def magnetic_pressure_tension():
"""μκΈ°μκ³Ό μκΈ°μ₯λ ₯μ κ· ν μμ"""
fig, axes = plt.subplots(1, 3, figsize=(15, 5))
# (1) μκΈ° μλ ₯ νν (Z-pinch)
ax1 = axes[0]
r = np.linspace(0.1, 2, 50)
theta = np.linspace(0, 2*np.pi, 50)
R, Theta = np.meshgrid(r, theta)
# μκΈ°μ₯ (μΆ λ°©ν₯ μ λ₯μ μν ΞΈ λ°©ν₯ μκΈ°μ₯)
# B_theta β 1/r (μΈλΆ), B_theta β r (λ΄λΆ)
r_plasma = 1.0
B_theta = np.where(R < r_plasma, R, 1/R)
X = R * np.cos(Theta)
Y = R * np.sin(Theta)
# μκΈ°μ
P_mag = B_theta**2 / 2
im = ax1.pcolormesh(X, Y, P_mag, cmap='hot', shading='auto')
plt.colorbar(im, ax=ax1, label=r'$B^2/2\mu_0$')
# μκΈ°λ ₯μ (λμ¬μ)
for r_line in [0.3, 0.6, 0.9, 1.2, 1.5]:
circle = plt.Circle((0, 0), r_line, fill=False, color='blue', linewidth=1)
ax1.add_patch(circle)
# μλ ₯ ꡬ배 λ°©ν₯
ax1.annotate('', xy=(0.7, 0), xytext=(0.3, 0),
arrowprops=dict(arrowstyle='->', color='white', lw=2))
ax1.annotate('', xy=(1.7, 0), xytext=(1.3, 0),
arrowprops=dict(arrowstyle='<-', color='white', lw=2))
ax1.set_xlabel('x')
ax1.set_ylabel('y')
ax1.set_title('Z-pinch: μκΈ°μμ΄ νλΌμ¦λ§ μμΆ')
ax1.set_aspect('equal')
ax1.set_xlim(-2, 2)
ax1.set_ylim(-2, 2)
# (2) μκΈ° μ₯λ ₯ (ν μκΈ°λ ₯μ )
ax2 = axes[1]
# ν μκΈ°λ ₯μ
x = np.linspace(-2, 2, 100)
y_lines = [0.3 * np.sin(np.pi * x / 2),
0.6 * np.sin(np.pi * x / 2),
0.9 * np.sin(np.pi * x / 2)]
for y in y_lines:
ax2.plot(x, y, 'b-', linewidth=2)
# μ₯λ ₯ λ°©ν₯ (곑λ₯ μ€μ¬ λ°©ν₯ = μλ)
x_arrows = [-1, 0, 1]
for xa in x_arrows:
idx = np.argmin(np.abs(x - xa))
y_arrow = 0.6 * np.sin(np.pi * xa / 2)
# 곑λ₯ μ΄ μμλ©΄ μ₯λ ₯μ μλ
tension_dir = -1 if xa == 0 else (-0.5 if xa > 0 else 0.5)
ax2.annotate('', xy=(xa, y_arrow + tension_dir * 0.3),
xytext=(xa, y_arrow),
arrowprops=dict(arrowstyle='->', color='red', lw=2))
ax2.set_xlabel('x')
ax2.set_ylabel('y')
ax2.set_title('μκΈ° μ₯λ ₯: ν μκΈ°λ ₯μ μ ν΄λ ν')
ax2.set_aspect('equal')
ax2.set_xlim(-2.5, 2.5)
ax2.set_ylim(-1.5, 1.5)
ax2.grid(True, alpha=0.3)
# λ²λ‘
ax2.plot([], [], 'b-', linewidth=2, label='μκΈ°λ ₯μ ')
ax2.plot([], [], 'r-', linewidth=2, label='μ₯λ ₯ λ°©ν₯')
ax2.legend()
# (3) νν μμ
ax3 = axes[2]
info_text = """
MHD νν 쑰건:
μ μ ννμμ:
βp = JΓB = (BΒ·β)B/ΞΌβ - β(BΒ²/2ΞΌβ)
μ¬λ°°μ΄:
β(p + BΒ²/2ΞΌβ) = (BΒ·β)B/ΞΌβ
β β
μ΄ μλ ₯ μκΈ° μ₯λ ₯
μμ© μμ:
1. ΞΈ-pinch:
- Bz λ§ μ‘΄μ¬ (μ§μ )
- μ₯λ ₯ μμ, μλ ₯ νν
- β/βz(p + BΒ²/2ΞΌβ) = 0
2. Z-pinch:
- BΞΈ λ§ μ‘΄μ¬ (μν)
- μλ ₯ + μ₯λ ₯μ΄ μ΄μκ³Ό κ· ν
- (1/r)β/βr[r(p + BΒ²/2ΞΌβ)] = BΞΈΒ²/ΞΌβr
3. μ€ν¬λ₯ νμΉ:
- Bz + BΞΈ μ‘°ν©
- 볡μ‘ν νν 쑰건
- ν μΉ΄λ§μ κΈ°λ³Έ νν
"""
ax3.text(0.05, 0.95, info_text, transform=ax3.transAxes,
fontsize=10, verticalalignment='top', fontfamily='monospace',
bbox=dict(boxstyle='round', facecolor='wheat', alpha=0.5))
ax3.axis('off')
plt.tight_layout()
plt.savefig('magnetic_pressure_tension.png', dpi=150, bbox_inches='tight')
plt.show()
# magnetic_pressure_tension()
7. Frozen-in μ 리¶
7.1 μκΈ°μ₯ λκ²° 쑰건¶
μκΈ°λ ₯μ λκ²° (Frozen-in Theorem):
μ΄μ MHDμμ:
E + vΓB = 0 (무μ ν)
μ λ λ°©μ μ:
βB/βt = βΓ(vΓB)
물리μ μλ―Έ:
1. μκΈ°λ ₯μ μ μ 체 μμμ ν¨κ» μμ§μ
2. μκΈ°λ ₯μ μ "νμ§"λ₯Ό νλ©΄ μ 체μ ν¨κ» μ΄λ
3. λ μ 체 μμκ° κ°μ μκΈ°λ ₯μ μμ μμΌλ©΄
μμν κ°μ μκΈ°λ ₯μ μμ μμ
μκΈ° νλμ€ λ³΄μ‘΄:
d/dt β«β« BΒ·dS = 0 (μμ§μ΄λ λ©΄μ λν΄)
μλ° μ‘°κ±΄ (μ νμ± MHD):
E + vΓB = Ξ·J
μ λ λ°©μ μ:
βB/βt = βΓ(vΓB) + Ξ·/ΞΌβ βΒ²B
β
μκΈ° νμ°
μκΈ° Reynolds μ:
Rm = ΞΌβvL/Ξ·
Rm >> 1: λκ²° 쑰건 μ±λ¦½ (λλΆλΆμ μ²μ²΄ νλΌμ¦λ§)
Rm ~ 1: νμ°κ³Ό λλ₯ κ²½μ
Rm << 1: νμ° μ§λ°°
def frozen_in_theorem():
"""Frozen-in μ 리 μκ°ν"""
fig, axes = plt.subplots(2, 2, figsize=(12, 10))
# (1) μ΄μ MHD: μκΈ°λ ₯μ μ΄ μ 체μ ν¨κ» μ΄λ
ax1 = axes[0, 0]
# μ΄κΈ° 격μμ μκΈ°λ ₯μ
x = np.linspace(0, 2, 6)
y = np.linspace(0, 1, 6)
# μ΄κΈ° μν
for xi in x:
ax1.plot([xi, xi], [0, 1], 'b-', linewidth=1, alpha=0.5)
for yi in y:
ax1.plot([0, 2], [yi, yi], 'b-', linewidth=1, alpha=0.5)
# λ³ν ν (μ λ¨ μ λ)
# v = (y, 0) -> x' = x + t*y
t = 0.5
for yi in y:
x_new = x + t * yi
ax1.plot(x_new, np.full_like(x_new, yi), 'r--', linewidth=1, alpha=0.7)
for xi in x:
y_line = np.linspace(0, 1, 20)
x_line = xi + t * y_line
ax1.plot(x_line, y_line, 'r--', linewidth=1, alpha=0.7)
ax1.plot([], [], 'b-', linewidth=2, label='μ΄κΈ° (μκΈ°λ ₯μ )')
ax1.plot([], [], 'r--', linewidth=2, label='λ³ν ν')
ax1.set_xlabel('x')
ax1.set_ylabel('y')
ax1.set_title('μ΄μ MHD: μκΈ°λ ₯μ μ΄ μ 체μ λκ²°')
ax1.legend()
ax1.set_aspect('equal')
ax1.grid(True, alpha=0.3)
# (2) μκΈ° νλμ€ λ³΄μ‘΄
ax2 = axes[0, 1]
theta = np.linspace(0, 2*np.pi, 100)
# μ΄κΈ° μν 루ν
r0 = 1
x0 = r0 * np.cos(theta)
y0 = r0 * np.sin(theta)
ax2.plot(x0, y0, 'b-', linewidth=2, label='μ΄κΈ° 루ν')
ax2.fill(x0, y0, alpha=0.2, color='blue')
# λ³νλ 루ν (μμΆ)
rx, ry = 0.5, 2.0 # μμΆ/μ°μ
x1 = rx * np.cos(theta)
y1 = ry * np.sin(theta)
ax2.plot(x1, y1, 'r-', linewidth=2, label='λ³νλ 루ν')
ax2.fill(x1, y1, alpha=0.2, color='red')
# λ©΄μ λΉκ΅
A0 = np.pi * r0**2
A1 = np.pi * rx * ry
ax2.text(0, 0, f'Ξ¦ = β«BΒ·dA\n보쑴!', ha='center', va='center', fontsize=11)
ax2.text(1.5, 0, f'Aβ = {A0:.2f}', fontsize=10)
ax2.text(0.3, 1.5, f'Aβ = {A1:.2f}', fontsize=10)
ax2.set_xlabel('x')
ax2.set_ylabel('y')
ax2.set_title('μκΈ° νλμ€ λ³΄μ‘΄')
ax2.legend()
ax2.set_aspect('equal')
ax2.set_xlim(-2.5, 2.5)
ax2.set_ylim(-2.5, 2.5)
ax2.grid(True, alpha=0.3)
# (3) μκΈ° Reynolds μ
ax3 = axes[1, 0]
# λ€μν νκ²½μ Rm
environments = {
'μ€νμ€\nνλΌμ¦λ§': 1e2,
'νμ\nκ΄κ΅¬': 1e6,
'νμ\nμ½λ‘λ': 1e12,
'μ±κ°\nλ§€μ§': 1e18,
'μ‘체\nκΈμ': 1e1
}
names = list(environments.keys())
Rm_values = list(environments.values())
y_pos = np.arange(len(names))
colors = ['red' if Rm < 100 else 'green' for Rm in Rm_values]
ax3.barh(y_pos, np.log10(Rm_values), color=colors)
ax3.axvline(x=np.log10(100), color='black', linestyle='--', label=r'$R_m = 100$')
ax3.set_yticks(y_pos)
ax3.set_yticklabels(names)
ax3.set_xlabel(r'logββ($R_m$)')
ax3.set_title('μκΈ° Reynolds μ λΉκ΅')
ax3.grid(True, alpha=0.3)
# λ²λ‘
ax3.plot([], [], 'g-', linewidth=10, label='λκ²° 쑰건 μ±λ¦½')
ax3.plot([], [], 'r-', linewidth=10, label='νμ° ν¨κ³Ό μ€μ')
ax3.legend()
# (4) κ°λ
μ 리
ax4 = axes[1, 1]
info_text = """
Frozen-in μ 리 μμ½:
쑰건: μ΄μ MHD (Ξ· = 0, E + vΓB = 0)
κ²°κ³Ό:
1. βB/βt = βΓ(vΓB)
2. d/dt β«β« BΒ·dS = 0 (μ΄λ λ©΄)
3. μκΈ°λ ₯μ μ μ 체μ ν¨κ» μ΄λ
물리μ ν΄μ:
- μκΈ°λ ₯μ μ "λκ²°"λ μ 체 μμ
- μκΈ°μ₯ μμΆ β λ°λ μ¦κ°
- B/Ο β μμ (1D μμΆ)
μλ° μ (Ξ· β 0):
- μκΈ°μ₯ νμ°: Ο_diff = ΞΌβLΒ²/Ξ·
- μκΈ° μ¬κ²°ν© κ°λ₯
- μλμ§ λ³ν (μκΈ° β μ΄λ/μ΄)
μ€μμ±:
- νμ νλ μ΄: μ¬κ²°ν©
- ν μΉ΄λ§: λκ²° 쑰건 μ€μ
- μκΈ°κΆ: μ¬κ²°ν© νμ
"""
ax4.text(0.05, 0.95, info_text, transform=ax4.transAxes,
fontsize=10, verticalalignment='top', fontfamily='monospace',
bbox=dict(boxstyle='round', facecolor='wheat', alpha=0.5))
ax4.axis('off')
plt.tight_layout()
plt.savefig('frozen_in_theorem.png', dpi=150, bbox_inches='tight')
plt.show()
# frozen_in_theorem()
8. μ°μ΅ λ¬Έμ ¶
μ°μ΅ 1: Alfven μλ¶
νμ μ½λ‘λμμ B = 10 G, n = 10^8 cm^-3 μΌ λ Alfven μλλ₯Ό κ³μ°νμμ€. μ΄κ²μ μμ(T = 10^6 K)κ³Ό λΉκ΅νκ³ νλΌμ¦λ§ λ² νλ₯Ό ꡬνμμ€.
μ°μ΅ 2: MHD νλ μλ¶
vA = 2cs μΈ κ²½μ°, μκΈ°μ₯μ μμ§ν λ°©ν₯(ΞΈ = 90Β°)μΌλ‘ μ ννλ λΉ λ₯Έ μκΈ°μνμ μμ μλλ₯Ό ꡬνμμ€.
μ°μ΅ 3: μκΈ°μ νν¶
κ· μΌν μκΈ°μ₯ Bz μμκ³Ό 무μκΈ°μ₯ μμ μ¬μ΄μ κ²½κ³μμ μλ ₯ νν 쑰건μ ꡬνμμ€.
μ°μ΅ 4: Frozen-in¶
κΈΈμ΄ L = 1 Mm, μ λλ Ο = 10^6 S/mμΈ νλΌμ¦λ§μμ μκΈ° νμ° μκ°μ κ³μ°νμμ€. μλ v = 100 km/sμΌ λ μκΈ° Reynolds μλ?
9. μ°Έκ³ μλ£¶
ν΅μ¬ κ΅μ¬¶
- Goedbloed & Poedts, "Principles of Magnetohydrodynamics"
- Kulsrud, "Plasma Physics for Astrophysics"
- Freidberg, "Ideal MHD"
λ Όλ¬Έ/리뷰¶
- AlfvΓ©n (1942) μλ Όλ¬Έ (MHD νλ)
- Priest & Forbes, "Magnetic Reconnection" (μ¬κ²°ν©)
μ¨λΌμΈ μλ£¶
- Thorne & Blandford, "Modern Classical Physics" (Ch. 19)
- Chen, "Introduction to Plasma Physics" (MHD μ₯)
μμ½¶
MHD κΈ°μ΄ ν΅μ¬:
1. MHD κ°μ :
- μ€μ€μ±, μ μ£Όν, μ 체 κ·Όμ¬
- L >> Ξ»D, c/Οpi
- Maxwell λ¨μν
2. μ΄μ MHD λ°©μ μ:
- μ°μ: βΟ/βt + βΒ·(Οv) = 0
- μ΄λλ: ΟDv/Dt = -βp + JΓB
- μλμ§: D(p/Ο^Ξ³)/Dt = 0
- μ λ: βB/βt = βΓ(vΓB)
- μ μ½: βΒ·B = 0
3. μ£Όμ μλ:
- Alfven: vA = B/β(ΞΌβΟ)
- μμ: cs = β(Ξ³p/Ο)
- νλΌμ¦λ§ λ² ν: Ξ² = 2ΞΌβp/BΒ²
4. MHD νλ:
- Alfven ν: vA (μκΈ°μ₯ λ°©ν₯)
- λΉ λ₯Έ μκΈ°μν: β(vAΒ² + csΒ²) (μμ§)
- λλ¦° μκΈ°μν: min(vA, cs) (νν)
5. Lorentz ν:
JΓB = -β(BΒ²/2ΞΌβ) + (BΒ·β)B/ΞΌβ
μκΈ°μ μκΈ°μ₯λ ₯
6. Frozen-in:
- μ΄μ MHD: E + vΓB = 0
- μκΈ°λ ₯μ μ΄ μ 체μ λκ²°
- Rm >> 1 μΌ λ μ ν¨
λ€μ λ μ¨μμλ MHD λ°©μ μμ μμΉν΄λ²μ λ€λ£Ήλλ€.