Wave Equation in 2D: Membranes

Learning Objectives

By the end of this section, you will be able to:

1. Derive the 2D wave equation for a vibrating membrane and understand each term physically
2. Apply separation of variables to transform the 2D wave PDE into three independent ODEs
3. Compute the eigenvalues $\lambda_{mn}$ and natural frequencies $\omega_{mn}$ for rectangular membranes
4. Construct the general solution as a double Fourier series with oscillatory (not decaying) time behavior
5. Explain mode degeneracy and Chladni patterns as observable consequences of the mathematics
6. Extend the theory to circular membranes using Bessel functions
7. Connect 2D wave analysis to modern applications in acoustics, engineering, and machine learning

The Big Picture: Vibrations in Two Dimensions

"The vibrations of a drumhead contain the entire physics of wave propagation in two dimensions — every frequency, every pattern, every principle of superposition, all visible in the motion of a stretched membrane."

In the previous sections, we studied the 1D wave equation — vibrations of a string. A string vibrates in one spatial dimension, and its modes are simple sine waves. Now we extend these ideas to two spatial dimensions: the vibrations of a thin, stretched membrane fixed at its boundary.

Think of a drumhead. When struck, it vibrates in complex patterns that are fundamentally different from a vibrating string. The membrane can move up and down at every point $(x, y)$ on its surface, and the patterns of motion — the normal modes — are two-dimensional standing waves described by products of sine functions (for rectangular membranes) or Bessel functions (for circular drums).

This extension from 1D to 2D is not merely a mathematical exercise. It reveals phenomena that have no analogue in one dimension:

Historical Context

The study of vibrating membranes has a rich history that connects some of the greatest names in mathematics and physics.

The 2D Wave Equation

Consider a thin, elastic membrane stretched over a frame. Let $u(x, y, t)$ denote the vertical displacement of the membrane at position $(x, y)$ and time $t$. Newton's second law applied to a small patch of membrane yields:

Understanding Each Term

The Physical Logic

The equation says: if the membrane is curved at a point (Laplacian is nonzero), then the net restoring force from the surrounding tension causes the point to accelerate back toward the flat position. A positive Laplacian $\nabla^2 u > 0$ means the point is lower than the average of its neighbors, so the tension pulls it up (positive acceleration). A negative Laplacian means the point is higher, and tension pulls it down.

Contrast with the 2D Heat Equation

Separation of Variables for Rectangular Membranes

We solve the 2D wave equation on a rectangular membrane $[0, L_x] \times [0, L_y]$ with fixed (zero-displacement) boundaries:

Step 1: Assume a product solution. We guess that $u(x, y, t) = X(x) \cdot Y(y) \cdot T(t)$. Substituting into the PDE:

Step 2: Divide by $c^2 X Y T$:

The left side depends only on $t$, the right side only on $x$ and $y$. For these to be equal for all values, both must equal a constant $-\lambda$.

Step 3: Separate the spatial variables. From $\frac{X''}{X} + \frac{Y''}{Y} = -\lambda$, set $\frac{X''}{X} = -\mu$ so that $\frac{Y''}{Y} = -(\lambda - \mu) = -\nu$.

Step 4: Solve three independent ODEs.

Eigenvalues and Natural Frequencies

Each pair of mode numbers $(m, n)$ with $m, n = 1, 2, 3, \ldots$ gives a combined eigenvalue and natural frequency:

Mode Frequency Table (Unit Square)

For a unit square membrane ($L_x = L_y = 1$, $c = 1$):

The General Solution

Assembling all the pieces, each normal mode has the form:

The general solution is the superposition of all modes:

Finding the Coefficients

The coefficients $A_{mn}$ and $B_{mn}$ are determined by the two initial conditions using orthogonality of the eigenfunctions:

Interactive Membrane Simulation

Explore the vibrations of a rectangular membrane in real time. Select different modes $(m, n)$, adjust the wave speed, and observe how the membrane oscillates. Enable the superposition toggle to see how two modes combine.

Exploring Mode Patterns

Each mode $(m, n)$ has a characteristic spatial pattern: $m$ half-waves in the $x$-direction and $n$ half-waves in the $y$-direction. The nodal lines — where the displacement is always zero — form a grid of $(m-1)$ vertical and $(n-1)$ horizontal lines.

Click on any mode in the grid below to see its details:

Reading the Mode Patterns

• Red regions represent positive displacement (membrane displaced upward)
• Blue regions represent negative displacement (membrane displaced downward)
• Boundaries between colors are the nodal lines where $u = 0$ at all times
• Adjacent regions always have opposite signs — when one is up, its neighbor is down

Circular Membranes: The Mathematics of Drums

Real drums are circular, not rectangular. On a circular membrane of radius $a$, the wave equation in polar coordinates $(r, \theta)$ becomes:

Separation of variables $u(r, \theta, t) = R(r)\,\Theta(\theta)\,T(t)$ leads to:

Here $J_m$ is the Bessel function of the first kind of order $m$, and $j_{mn}$ is the $n$-th zero of $J_m$. The boundary condition $R(a) = 0$ (fixed rim) forces $J_m(j_{mn}) = 0$, which selects the allowed frequencies.

First Few Bessel Function Zeros

The nodal patterns of a circular membrane have two types of nodal lines:

• Nodal circles: $n - 1$ concentric circles where $J_m = 0$
• Nodal diameters: $m$ equally spaced lines through the center where $\cos(m\theta) = 0$

Explore the circular membrane modes below. Toggle between top view (showing the pattern) and 3D view (showing the surface shape):

Chladni Patterns: Seeing Sound

In 1787, Ernst Chladni demonstrated one of the most elegant experiments in physics: he scattered fine sand on a vibrating metal plate, and the sand migrated to the nodal lines — the curves where the plate remains at rest. The result was a gallery of stunning geometric patterns, now called Chladni figures.

Mathematically, Chladni patterns show the zero set of the mode shape function. For a rectangular plate vibrating in mode $(m, n)$, the nodal lines are the simple grid where $\sin(m\pi x / L_x) = 0$ or $\sin(n\pi y / L_y) = 0$. But when multiple modes are superimposed, the nodal lines curve and intersect in complex ways.

Explore Chladni patterns for different modes and plate shapes:

Machine Learning Connections

The 2D wave equation connects to modern machine learning and computational science in several important ways.

1. Physics-Informed Neural Networks (PINNs)

2. Fourier Neural Operators (FNOs)

FNOs learn to map initial conditions to solutions by operating in Fourier space — exactly the eigenmode representation we derived. The key insight: the 2D Fourier modes $\sin(m\pi x / L_x)\sin(n\pi y / L_y)$ are the natural basis for these operators, and FNOs learn the relationship between input modes and output modes.

3. Acoustic Signal Processing

The modal analysis of 2D membranes directly applies to:

• Speaker design: Understanding how speaker cones vibrate to radiate sound
• Microphone arrays: Spatial filtering based on 2D wave propagation principles
• Room acoustics: Modal analysis of room surfaces for noise control and acoustic design

4. Structural Health Monitoring

Machine learning models trained on vibration mode shapes can detect damage in structures. A crack or defect changes the natural frequencies and mode shapes, and neural networks can learn to identify damage location and severity from vibration measurements — using exactly the modal theory we developed here.

Python Implementation

Implement the 2D wave equation solution for both rectangular and circular membranes:

1import numpy as np
2import matplotlib.pyplot as plt
3from mpl_toolkits.mplot3d import Axes3D
4from matplotlib import cm
5from scipy.special import jn, jn_zeros
6
7def rectangular_mode(x, y, t, m, n, Lx=1.0, Ly=1.0, c=1.0):
8    """
9    Normal mode (m, n) of a rectangular membrane.
10
11    u_mn(x, y, t) = sin(m*pi*x/Lx) * sin(n*pi*y/Ly) * cos(omega_mn * t)
12
13    omega_mn = pi * c * sqrt(m^2/Lx^2 + n^2/Ly^2)
14    """
15    omega = np.pi * c * np.sqrt(m**2/Lx**2 + n**2/Ly**2)
16    spatial = np.sin(m * np.pi * x / Lx) * np.sin(n * np.pi * y / Ly)
17    temporal = np.cos(omega * t)
18    return spatial * temporal
19
20
21def solve_rectangular_membrane(x, y, t, initial_disp, initial_vel=None,
22                                Lx=1.0, Ly=1.0, c=1.0, n_modes=10):
23    """
24    Solve the 2D wave equation on [0,Lx] x [0,Ly] with zero BCs.
25
26    u(x,y,t) = sum_m sum_n [A_mn cos(w_mn t) + B_mn sin(w_mn t)]
27                            * sin(m*pi*x/Lx) * sin(n*pi*y/Ly)
28
29    A_mn = (4/LxLy) int int f(x,y) sin(m*pi*x/Lx) sin(n*pi*y/Ly) dxdy
30    B_mn = (4/LxLy) * (1/w_mn) int int g(x,y) sin(...) sin(...) dxdy
31    """
32    # Integration grid
33    ni = 100
34    xi = np.linspace(0, Lx, ni)
35    yi = np.linspace(0, Ly, ni)
36    Xi, Yi = np.meshgrid(xi, yi)
37    dx_i, dy_i = Lx / (ni - 1), Ly / (ni - 1)
38
39    f_vals = initial_disp(Xi, Yi)
40    g_vals = initial_vel(Xi, Yi) if initial_vel else np.zeros_like(Xi)
41
42    u = np.zeros_like(x)
43
44    for m in range(1, n_modes + 1):
45        for n in range(1, n_modes + 1):
46            omega = np.pi * c * np.sqrt(m**2/Lx**2 + n**2/Ly**2)
47            basis = np.sin(m*np.pi*Xi/Lx) * np.sin(n*np.pi*Yi/Ly)
48
49            # Fourier coefficients via numerical integration
50            A_mn = (4/(Lx*Ly)) * np.sum(f_vals * basis) * dx_i * dy_i
51            B_mn = (4/(Lx*Ly*omega)) * np.sum(g_vals * basis) * dx_i * dy_i
52
53            if abs(A_mn) < 1e-12 and abs(B_mn) < 1e-12:
54                continue
55
56            spatial = np.sin(m*np.pi*x/Lx) * np.sin(n*np.pi*y/Ly)
57            u += (A_mn * np.cos(omega*t) + B_mn * np.sin(omega*t)) * spatial
58
59    return u
60
61
62def circular_mode(r, theta, t, m, n, a=1.0, c=1.0):
63    """
64    Normal mode of a circular membrane (drum).
65
66    u_mn(r, theta, t) = J_m(j_mn * r / a) * cos(m*theta) * cos(omega_mn * t)
67
68    where j_mn is the n-th zero of J_m, and omega_mn = c * j_mn / a
69    """
70    j_mn = jn_zeros(m, n)[-1]  # n-th zero of J_m
71    omega = c * j_mn / a
72    radial = jn(m, j_mn * r / a)
73    angular = np.cos(m * theta)
74    temporal = np.cos(omega * t)
75    return radial * angular * temporal
76
77
78def visualize_membrane():
79    """Visualize rectangular membrane vibration at several time steps."""
80    Lx, Ly, c = 1.0, 1.0, 1.0
81    nx, ny = 50, 50
82    x = np.linspace(0, Lx, nx)
83    y = np.linspace(0, Ly, ny)
84    X, Y = np.meshgrid(x, y)
85
86    # Initial condition: Gaussian bump
87    def f(x, y):
88        return np.exp(-30 * ((x - 0.5)**2 + (y - 0.5)**2))
89
90    times = [0, 0.2, 0.5, 0.8, 1.2, 2.0]
91    fig = plt.figure(figsize=(15, 10))
92
93    for i, t in enumerate(times):
94        ax = fig.add_subplot(2, 3, i+1, projection='3d')
95        Z = solve_rectangular_membrane(X, Y, t, f, Lx=Lx, Ly=Ly, c=c, n_modes=12)
96        ax.plot_surface(X, Y, Z, cmap=cm.coolwarm, linewidth=0, alpha=0.9)
97        ax.set_xlabel('x')
98        ax.set_ylabel('y')
99        ax.set_zlabel('u')
100        ax.set_title(f't = {t}')
101        ax.set_zlim(-1, 1)
102
103    plt.suptitle('2D Wave Equation: Rectangular Membrane', fontsize=14)
104    plt.tight_layout()
105    plt.show()
106
107    # Frequency analysis
108    print("\n--- Mode Frequency Analysis ---")
109    print("Mode (m,n) | omega_mn | frequency | period")
110    print("-" * 55)
111    for m in range(1, 5):
112        for n in range(1, 5):
113            omega = np.pi * c * np.sqrt(m**2 + n**2)
114            freq = omega / (2 * np.pi)
115            period = 1 / freq
116            print(f"  ({m},{n})   | {omega:8.3f} | {freq:9.4f} | {period:8.4f}")
117
118
119visualize_membrane()

Common Pitfalls

Test Your Understanding

Summary

The 2D wave equation extends the vibrating string theory to membranes and surfaces, revealing rich phenomena like mode degeneracy and Chladni patterns that have no analogue in one dimension.

Key Equations

Key Takeaways

1. The 2D wave equation $u_{tt} = c^2 \nabla^2 u$ describes vibrating membranes with the Laplacian measuring surface curvature
2. Separation of variables yields three ODEs: two spatial (eigenvalue problems) and one temporal (oscillator)
3. Unlike the heat equation where modes decay, wave modes oscillate forever at their natural frequencies
4. The natural frequency $\omega_{mn}$ depends on $\sqrt{m^2/L_x^2 + n^2/L_y^2}$ — the square root of the sum, not the sum of square roots
5. Degeneracy occurs on square membranes: modes $(m, n)$ and $(n, m)$ share the same frequency
6. Circular membranes use Bessel functions instead of sines, with non-harmonic overtone series
7. Chladni patterns make the nodal lines of vibrating surfaces visible and are direct manifestations of the eigenmodes

Coming Next: In the next section, we'll explore Numerical Methods for Waves — finite difference schemes, stability conditions, and practical algorithms for simulating wave propagation when analytical solutions are not available.