← Back to Part III: Einstein Field Equations

Chapter 16: Weak Field Limit

The weak field limit connects general relativity to Newtonian gravity and provides the framework for understanding gravitational waves, gravitational lensing, and post-Newtonian corrections to orbital dynamics.

Linearized Gravity

For weak gravitational fields, the metric is a small perturbation of flat spacetime:

$g_{\mu\nu} = \eta_{\mu\nu} + h_{\mu\nu}, \quad |h_{\mu\nu}| \ll 1$

η_μν = Minkowski metric, h_μν = perturbation

To linear order in h, the Einstein tensor becomes:

$G^{(1)}_{\mu\nu} = \frac{1}{2}\left( \partial^\rho \partial_\mu h_{\nu\rho} + \partial^\rho \partial_\nu h_{\mu\rho} - \Box h_{\mu\nu} - \partial_\mu \partial_\nu h - \eta_{\mu\nu}(\partial^\rho \partial^\sigma h_{\rho\sigma} - \Box h) \right)$

where h = η^μνh_μν and □ = ∂^μ∂_μ

Gauge Freedom

Infinitesimal coordinate transformations give gauge freedom in h_μν:

$h_{\mu\nu} \to h_{\mu\nu} + \partial_\mu \xi_\nu + \partial_\nu \xi_\mu$

Lorenz Gauge (Harmonic)

$\partial^\mu \bar{h}_{\mu\nu} = 0$

where $\bar{h}_{\mu\nu} = h_{\mu\nu} - \frac{1}{2}\eta_{\mu\nu}h$

Wave Equation

$\Box \bar{h}_{\mu\nu} = -\frac{16\pi G}{c^4} T_{\mu\nu}$

Gravitational waves!

Gravitational Waves

In vacuum (T_μν = 0), the wave equation $\Box \bar{h}_{\mu\nu} = 0$ has plane wave solutions:

$h_{\mu\nu} = \epsilon_{\mu\nu} e^{ik_\rho x^\rho}$

k^μk_μ = 0 (null wavevector)

Transverse-Traceless (TT) Gauge

For wave propagating in z-direction:

$h^{TT}_{\mu\nu} = \begin{pmatrix} 0 & 0 & 0 & 0 \\ 0 & h_+ & h_\times & 0 \\ 0 & h_\times & -h_+ & 0 \\ 0 & 0 & 0 & 0 \end{pmatrix} \cos(\omega t - kz)$

Two polarizations: plus (+) and cross (×)

Interactive Simulation: Gravitational Wave Effects

Run this Python code to visualize how gravitational waves deform a ring of test masses. The simulation shows both plus (+) and cross (×) polarizations at different phases, with the amplitude exaggerated for visibility. Try modifying the parameters!

Gravitational Wave Visualization

Python

Visualize GW effects on test masses in the weak field limit

weak_field_gw.py163 lines

#!/usr/bin/env python3
"""
weak_field_gw.py - Gravitational wave effects in the weak field limit
Visualizes how GWs deform a ring of test masses
"""
import numpy as np
import matplotlib.pyplot as plt

def gw_metric_perturbation(t, h_plus, h_cross, omega):
    """
    Compute TT gauge metric perturbation for GW propagating in z-direction
    """
    phase = omega * t
    h_xx = h_plus * np.cos(phase)
    h_yy = -h_plus * np.cos(phase)
    h_xy = h_cross * np.cos(phase)
    return h_xx, h_yy, h_xy

def deform_circle(theta, h_xx, h_yy, h_xy):
    """
    Compute deformation of unit circle under GW perturbation
    x' = x(1 + h_xx/2) + y*h_xy/2
    y' = y(1 + h_yy/2) + x*h_xy/2
    """
    x = np.cos(theta)
    y = np.sin(theta)
    x_new = x * (1 + h_xx/2) + y * h_xy/2
    y_new = y * (1 + h_yy/2) + x * h_xy/2
    return x_new, y_new

# Physical constants
c = 3e8        # Speed of light (m/s)
G = 6.674e-11  # Gravitational constant
M_sun = 1.989e30  # Solar mass (kg)
pc = 3.086e16  # Parsec (m)

# GW150914-like parameters
M_chirp = 30 * M_sun   # Chirp mass
D = 400e6 * pc         # Distance: 400 Mpc
f_gw = 150             # Peak frequency (Hz)

# Calculate peak strain
h_peak = (4/D) * (G*M_chirp/c**2)**(5/3) * (np.pi*f_gw/c)**(2/3)

print("=" * 70)
print("Weak Field Limit: Gravitational Wave Analysis")
print("=" * 70)
print()
print("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
print("  LINEARIZED GRAVITY")
print("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
print()
print("  Metric perturbation:")
print()
print("  (g_{\\mu\\nu} = \\eta_{\\mu\\nu} + h_{\\mu\\nu}, \\quad |h_{\\mu\\nu}| \\ll 1 \)")
print()
print("  TT gauge metric for wave in z-direction:")
print()
print("  (h^{TT}_{\\mu\\nu} = \\begin{pmatrix} 0 & 0 & 0 & 0 \\\\ 0 & h_+ & h_\\times & 0 \\\\ 0 & h_\\times & -h_+ & 0 \\\\ 0 & 0 & 0 & 0 \\end{pmatrix} \\cos(\\omega t - kz) \)")
print()
print("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
print("  GW150914-LIKE EVENT")
print("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
print()
print(f"  Chirp mass:        (\\mathcal{{M}}_c = {M_chirp/M_sun:.0f} \\, M_\\odot \)")
print(f"  Distance:          (D_L = 400 \) Mpc")
print(f"  Peak frequency:    (f = {f_gw} \) Hz")
print(f"  Peak strain:       (h \\approx {h_peak:.2e} \)")
print()
print("  Strain formula:")
print()
print("  (h \\sim \\frac{4}{D_L} \\left(\\frac{G\\mathcal{M}_c}{c^2}\\right)^{5/3} \\left(\\frac{\\pi f}{c}\\right)^{2/3} \)")
print()

# LIGO sensitivity
L_arm = 4000  # LIGO arm length in meters
delta_L = h_peak * L_arm

print("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
print("  LIGO DETECTION")
print("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
print()
print(f"  Arm length:        (L = 4 \) km")
print(f"  Length change:     (\\Delta L = h \\times L \\approx {delta_L:.2e} \) m")
print()
print("  This is about 1/10,000 of a proton diameter!")
print()
print("  Sensitivity:       (h_{\\text{min}} \\sim 10^{-23} \) (design)")
print()

# Create visualization
omega = 2 * np.pi  # Normalized angular frequency
h_plus_viz = 0.3   # Exaggerated for visibility
theta = np.linspace(0, 2*np.pi, 100)

fig, axes = plt.subplots(2, 3, figsize=(14, 9))

# Plus polarization at different phases
for i, phase in enumerate([0, np.pi/2, np.pi]):
    ax = axes[0, i]
    t = phase / omega
    h_xx, h_yy, h_xy = gw_metric_perturbation(t, h_plus_viz, 0, omega)
    x_new, y_new = deform_circle(theta, h_xx, h_yy, h_xy)

ax.fill(np.cos(theta), np.sin(theta), alpha=0.1, color='gray')
    ax.plot(np.cos(theta), np.sin(theta), 'k--', alpha=0.4, linewidth=1, label='Unperturbed')
    ax.fill(x_new, y_new, alpha=0.3, color='blue')
    ax.plot(x_new, y_new, 'b-', linewidth=2.5, label='Deformed')

# Add test masses
    for angle in np.linspace(0, 2*np.pi, 8, endpoint=False):
        x_m = np.cos(angle) * (1 + h_xx/2 * np.cos(angle)**2 + h_yy/2 * np.sin(angle)**2)
        y_m = np.sin(angle) * (1 + h_yy/2 * np.sin(angle)**2 + h_xx/2 * np.cos(angle)**2)
        ax.plot(x_m, y_m, 'bo', markersize=8)

ax.set_xlim(-1.6, 1.6)
    ax.set_ylim(-1.6, 1.6)
    ax.set_aspect('equal')
    ax.set_title(f'Plus (+) polarization: φ = {phase*180/np.pi:.0f}°', fontsize=12, fontweight='bold')
    ax.grid(True, alpha=0.3)
    ax.axhline(y=0, color='gray', linestyle='-', alpha=0.2)
    ax.axvline(x=0, color='gray', linestyle='-', alpha=0.2)
    if i == 0:
        ax.legend(loc='upper right', fontsize=9)

# Cross polarization at different phases
for i, phase in enumerate([0, np.pi/2, np.pi]):
    ax = axes[1, i]
    t = phase / omega
    h_xx, h_yy, h_xy = gw_metric_perturbation(t, 0, h_plus_viz, omega)
    x_new, y_new = deform_circle(theta, h_xx, h_yy, h_xy)

ax.fill(np.cos(theta), np.sin(theta), alpha=0.1, color='gray')
    ax.plot(np.cos(theta), np.sin(theta), 'k--', alpha=0.4, linewidth=1, label='Unperturbed')
    ax.fill(x_new, y_new, alpha=0.3, color='red')
    ax.plot(x_new, y_new, 'r-', linewidth=2.5, label='Deformed')

ax.set_xlim(-1.6, 1.6)
    ax.set_ylim(-1.6, 1.6)
    ax.set_aspect('equal')
    ax.set_title(f'Cross (×) polarization: φ = {phase*180/np.pi:.0f}°', fontsize=12, fontweight='bold')
    ax.grid(True, alpha=0.3)
    ax.axhline(y=0, color='gray', linestyle='-', alpha=0.2)
    ax.axvline(x=0, color='gray', linestyle='-', alpha=0.2)
    if i == 0:
        ax.legend(loc='upper right', fontsize=9)

plt.suptitle('Gravitational Wave Effect on Ring of Test Masses\n(Amplitude exaggerated for visibility)',
             fontsize=14, fontweight='bold')
plt.tight_layout()
plt.savefig('weak_field_gw.png', dpi=150, bbox_inches='tight')

print("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
print("  TWO POLARIZATION MODES")
print("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
print()
print("  Plus (+):  Stretches along x, compresses along y (and vice versa)")
print("  Cross (×): Stretches along 45°, compresses along 135° (and vice versa)")
print()
print("  General wave is superposition: (h = h_+ e_+^{\\mu\\nu} + h_\\times e_\\times^{\\mu\\nu} \)")
print()
print("✓ Plot saved as 'weak_field_gw.png'")

Click Run to execute the Python code

Code will be executed with Python 3 on the server

Fortran: Linearized Gravity Analysis

This Fortran code demonstrates the weak field equations, calculates GW150914-like event parameters, and shows how LIGO detects gravitational waves through tiny length changes.

Gravitational Wave Visualization

Python

GW strain waveform and detection parameters

weak_field_plot.py149 lines

import subprocess, tempfile, os, io, base64
import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt

fortran_source = r"""
program gw_waveform
    implicit none
    integer, parameter :: dp = selected_real_kind(15)
    real(dp), parameter :: pi = 4.0_dp * atan(1.0_dp)
    real(dp), parameter :: c = 3.0e8_dp
    real(dp), parameter :: G = 6.674e-11_dp
    real(dp), parameter :: M_sun = 1.989e30_dp
    real(dp), parameter :: pc = 3.086e16_dp

real(dp) :: M_chirp, D_L, f_gw, h_strain
    real(dp) :: omega, period, t, dt
    real(dp) :: L_arm, delta_L
    integer :: i, n_pts
    real(dp) :: freq, h_at_f

M_chirp = 30.0_dp * M_sun
    D_L = 400.0_dp * 1.0e6_dp * pc
    f_gw = 150.0_dp
    omega = 2.0_dp * pi * f_gw
    period = 1.0_dp / f_gw

h_strain = (4.0_dp/D_L) * (G*M_chirp/c**2)**(5.0_dp/3.0_dp) * &
               (pi*f_gw/c)**(2.0_dp/3.0_dp)

L_arm = 4000.0_dp
    delta_L = h_strain * L_arm

! Output waveform data
    n_pts = 500
    dt = 3.0_dp * period / real(n_pts, dp)
    print '(A)', 'DATA_START waveform'
    do i = 0, n_pts
        t = real(i, dp) * dt
        write(*,'(ES16.8,A,ES16.8,A,ES16.8)') &
            t*1000.0_dp, ',', h_strain*cos(omega*t), ',', 0.5_dp*h_strain*sin(omega*t)
    end do
    print '(A)', 'DATA_END'

! Output strain vs frequency
    print '(A)', 'DATA_START spectrum'
    do i = 1, 200
        freq = 10.0_dp + real(i-1, dp) * 990.0_dp / 199.0_dp
        h_at_f = (4.0_dp/D_L) * (G*M_chirp/c**2)**(5.0_dp/3.0_dp) * &
                 (pi*freq/c)**(2.0_dp/3.0_dp)
        write(*,'(F12.4,A,ES16.8)') freq, ',', h_at_f
    end do
    print '(A)', 'DATA_END'

write(*,'(A,ES12.4)') 'Peak strain h = ', h_strain
    write(*,'(A,ES12.4,A)') 'Arm length change = ', delta_L, ' m'
    write(*,'(A,ES12.4,A)') 'Proton diameter ratio = ', delta_L/1.7e-15_dp, ''
end program gw_waveform
"""

workdir = tempfile.mkdtemp()
src = os.path.join(workdir, 'gw.f90')
exe = os.path.join(workdir, 'gw')

with open(src, 'w') as f:
    f.write(fortran_source)

comp = subprocess.run(['gfortran', '-O2', '-o', exe, src],
                      capture_output=True, text=True, timeout=30)
if comp.returncode != 0:
    print("Compilation error:", comp.stderr)
else:
    result = subprocess.run([exe], capture_output=True, text=True, timeout=30, cwd=workdir)
    output = result.stdout

sections = {}
    current = None
    for line in output.split('\n'):
        if 'DATA_START' in line:
            current = line.split('DATA_START')[1].strip()
            sections[current] = []
            continue
        if 'DATA_END' in line:
            current = None
            continue
        if current and line.strip():
            sections[current].append(line.strip())

# Print text output
    for line in output.split('\n'):
        if 'DATA_' not in line and not any(line.strip() == l for sec in sections.values() for l in sec):
            if line.strip():
                print(line.strip())

fig, axes = plt.subplots(1, 2, figsize=(14, 6))
    fig.patch.set_facecolor('#0f172a')
    fig.suptitle('Gravitational Wave Analysis (GW150914-like)', color='white', fontsize=14, fontweight='bold')

# Waveform
    if 'waveform' in sections:
        t_ms, hp, hx = [], [], []
        for line in sections['waveform']:
            vals = [float(x) for x in line.split(',')]
            t_ms.append(vals[0])
            hp.append(vals[1])
            hx.append(vals[2])
        ax = axes[0]
        ax.set_facecolor('#1e293b')
        ax.plot(t_ms, hp, color='#22d3ee', linewidth=1.5, label='$h_+$')
        ax.plot(t_ms, hx, color='#f472b6', linewidth=1.5, label='$h_\\times$')
        ax.set_xlabel('Time (ms)', color='#cbd5e1')
        ax.set_ylabel('Strain h', color='#cbd5e1')
        ax.set_title('GW Strain Waveform', color='white')
        ax.legend(facecolor='#1e293b', edgecolor='#334155', labelcolor='#cbd5e1')
        ax.tick_params(colors='#cbd5e1')
        for spine in ax.spines.values():
            spine.set_color('#334155')
        ax.grid(True, color='#334155', alpha=0.4)

# Spectrum
    if 'spectrum' in sections:
        freq, h_f = [], []
        for line in sections['spectrum']:
            vals = [float(x) for x in line.split(',')]
            freq.append(vals[0])
            h_f.append(vals[1])
        ax2 = axes[1]
        ax2.set_facecolor('#1e293b')
        ax2.loglog(freq, h_f, color='#4ade80', linewidth=2)
        ax2.axvline(x=150, color='#fbbf24', linestyle='--', alpha=0.7, label='Peak (150 Hz)')
        ax2.set_xlabel('Frequency (Hz)', color='#cbd5e1')
        ax2.set_ylabel('Characteristic strain h', color='#cbd5e1')
        ax2.set_title('Strain vs Frequency', color='white')
        ax2.legend(facecolor='#1e293b', edgecolor='#334155', labelcolor='#cbd5e1')
        ax2.tick_params(colors='#cbd5e1')
        for spine in ax2.spines.values():
            spine.set_color('#334155')
        ax2.grid(True, color='#334155', alpha=0.4)

plt.tight_layout()
    buf = io.BytesIO()
    plt.savefig(buf, format='png', dpi=150, bbox_inches='tight', facecolor=fig.get_facecolor())
    buf.seek(0)
    img_b64 = base64.b64encode(buf.read()).decode()
    buf.close()
    plt.close()
    # Image saved as output.png

Click Run to execute the Python code

Code will be executed with Python 3 on the server

← Einstein-Hilbert Action Next: Newtonian Limit →