Chemistry · Intermediate

Hydrogen orbital shapes

Written by SignalsLab

Early edition: these lessons are being reviewed.

Content

Summary

Hydrogen orbitals are the allowed standing-wave solutions of the Schrödinger equation for an electron bound to a proton. Each orbital is a product of a radial part, which sets size and radial nodes, and an angular part (spherical harmonic), which sets shape: spherical s, dumbbell p, and cloverleaf d. The quantum numbers n, l and m determine the number and orientation of nodes.

Intuition

Think of the electron as a three-dimensional standing wave, like a vibrating drum but in space. Only certain patterns fit, and each is labeled by integers. The number n sets how many total nodes (places where the wave is zero) exist and the overall size. The number l sets how many of those nodes are flat or conical surfaces through the nucleus, which gives the angular shape. The number m picks the orientation in space. The square of the wavefunction gives the probability density of finding the electron. An s orbital has no angular nodes so it is a sphere; a p orbital has one nodal plane, so it has two lobes with opposite sign; a d orbital has two angular nodes, giving four lobes or a ring plus two lobes.

Key equations

ψnlm(r,θ,ϕ)=Rnl(r)Ylm(θ,ϕ)
(1)

Hydrogen wavefunction separates into radial and angular parts.

En=−13.6eVn2
(2)

Energy depends only on n for hydrogen.

l=0,1,…,n−1;m=−l,…,+l
(3)

Allowed quantum number combinations.

ψ1s=1πa03e−r/a0
(4)

Ground state: spherical, decaying exponentially.

ψ2pz=142πa03ra0e−r/2a0cos⁡θ
(5)

A p orbital: angular factor cos θ gives two lobes of opposite sign.

radial nodes=n−l−1,angular nodes=l
(6)

Node counting rule.

Derivation

  1. Write the Schrödinger equation with the Coulomb potential V = -e²/(4πε0 r) in spherical coordinates.
  2. Assume a product solution ψ = R(r)Y(θ,φ) and separate variables.
  3. The angular equation has solutions only if the separation constant equals l(l+1); the solutions are spherical harmonics Y_l^m, with |m| ≤ l.
  4. The radial equation contains an effective potential with the centrifugal term l(l+1)ħ²/(2mr²).
  5. Requiring R to stay finite as r→∞ quantizes energy, giving n = 1,2,3,… with l ≤ n−1.
  6. Plot |ψ|² or the angular part: Y_0^0 is constant (sphere), Y_1^0 ∝ cosθ (two lobes), Y_2^0 ∝ 3cos²θ−1 (two lobes plus a ring).

Worked example

Problem

For the 3p orbital of hydrogen, find the number of radial nodes, angular nodes, and total nodes, and the number of orientations.

  1. For 3p, n = 3 and l = 1.
  2. Radial nodes = n − l − 1 = 3 − 1 − 1 = 1.
  3. Angular nodes = l = 1 (a nodal plane through the nucleus).
  4. Total nodes = n − 1 = 2.
  5. Orientations: m = −1, 0, +1, so three.

Answer 1 radial node, 1 angular node, 2 total nodes, 3 orientations (px, py, pz).

Common mistakes

  • Thinking the electron travels along the lobe surface like a planet; the shape is a probability distribution.
  • Confusing the sign of the wavefunction with charge; the positive and negative lobes are phases.
  • Believing p orbitals have no probability at the nucleus means the electron never crosses it; it only means a node at r = 0 for l > 0.
  • Forgetting that in hydrogen, orbitals with the same n have the same energy regardless of l.
  • Mixing up total nodes (n−1) with radial nodes (n−l−1).

Animation

Animation coming soon

The animated version of this lesson is being prepared for the web. In the Signals AI app, lessons are drawn step by step.

Code

scene.py(116 lines)
import sys
import numpy as np
from manim import *
from blocks import *

# --- Helper functions for orbital shapes ---
# We visualize the angular part |Y_lm| (amplitude) or |Y_lm|^2 (probability).
# For shape visualization, plotting r = |Y_lm(theta, phi=0)| in polar coordinates works well.
# Note: Y_lm are complex, but we take the magnitude of the angular part.

def y_10(theta):
    """Angular part of Y_10 proportional to cos(theta)."""
    return np.cos(theta)

def y_20(theta):
    """Angular part of Y_20 proportional to 3cos^2(theta) - 1."""
    return 3 * np.cos(theta)**2 - 1

def y_21(theta):
    """Angular part of Y_21 proportional to sin(theta)."""
    # Y_21 ~ sin(theta) * e^{i phi}. At phi=0, it's real and proportional to sin(theta).
    return np.sin(theta)

def plot_orbital_slice(func, scale=2.0, color=WHITE, fill_opacity=0.3):
    """
    Plot a 2D polar shape of the function func(theta).
    Returns a VGroup with the polygon and the curve.
    """
    thetas = np.linspace(0, np.pi, 100)
    vals = func(thetas)
    
    # To handle negative values (phase), we plot the absolute value for the "lobe" shape
    # but we can color code positive/negative if needed. 
    # For simplicity in teaching shapes, we often show the magnitude envelope.
    # However, to show the "dumbbell" nature of p-orbitals, we need two lobes.
    # The polar plot r = |cos(theta)| creates a single loop if not careful?
    # No, cos(theta) is positive in [0, pi/2] and negative in [pi/2, pi].
    # r = |cos(theta)| creates two loops touching at origin.
    
    r_vals = np.abs(vals) * scale
    
    x_vals = r_vals * np.sin(thetas)
    y_vals = r_vals * np.cos(thetas)
    
    # Create polygon points: origin -> curve -> origin
    pts = [[0, 0, 0]]
    for x, y in zip(x_vals, y_vals):
        pts.append([x, y, 0])
    pts.append([0, 0, 0])
    
    poly = Polygon(*pts, fill_color=color, fill_opacity=fill_opacity, 
                   stroke_color=color, stroke_width=2)
    return poly

class Main(Scene):
    def construct(self):
        TitleCard(self, "Hydrogen Orbitals", "Angular shapes from quantum numbers")
        
        # 1. s-orbital (l=0, m=0)
        # Y_00 is constant. Shape is a circle.
        s_circle = Circle(radius=1.2, color=C_MAIN, fill_opacity=0.2, stroke_width=2)
        s_circle.move_to(LEFT * 3.5 + UP * 0.5)
        self.play(Create(s_circle), run_time=1)
        s_label = Text("1s (l=0)", font_size=32, color=C_ACCENT)
        s_label.next_to(s_circle, DOWN, buff=0.2)
        self.play(FadeIn(s_label))
        
        # 2. p-orbital (l=1, m=0)
        # Y_10 ~ cos(theta). Two lobes.
        p_shape = plot_orbital_slice(y_10, scale=1.8, color=C_GOOD, fill_opacity=0.4)
        p_shape.move_to(RIGHT * 3.5 + UP * 0.5)
        self.play(Create(p_shape), run_time=1.5)
        p_label = Text("2p (l=1)", font_size=32, color=C_ACCENT)
        p_label.next_to(p_shape, DOWN, buff=0.2)
        self.play(FadeIn(p_label))
        
        # 3. d-orbital (l=2, m=0)
        # Y_20 ~ 3cos^2 - 1. Four lobes (cloverleaf).
        d_shape = plot_orbital_slice(y_20, scale=1.8, color=C_ACCENT, fill_opacity=0.3)
        d_shape.move_to(ORIGIN + DOWN * 2.0)
        self.play(Create(d_shape), run_time=1.5)
        d_label = Text("3d (l=2, m=0)", font_size=28, color=C_ACCENT)
        d_label.next_to(d_shape, DOWN, buff=0.2)
        self.play(FadeIn(d_label))
        
        # 4. d-orbital (l=2, m=1) - Two lobes with donut? 
        # Y_21 ~ sin(theta). This is like a p-orbital but with different radial node structure?
        # Actually, |Y_21|^2 has two lobes along the equator? 
        # sin(theta) is max at pi/2. So it's a ring/donut in 3D, but in 2D slice (xz plane, phi=0),
        # it looks like two lobes along the x-axis?
        # Let's plot Y_21.
        y21_shape = plot_orbital_slice(y_21, scale=1.8, color=C_BAD, fill_opacity=0.3)
        y21_shape.move_to(LEFT * 3.5 + DOWN * 2.0)
        self.play(Create(y21_shape), run_time=1.5)
        y21_label = Text("3d (l=2, m=1)", font_size=28, color=C_ACCENT)
        y21_label.next_to(y21_shape, DOWN, buff=0.2)
        self.play(FadeIn(y21_label))
        
        StepCaption(self, "Shapes determined by angular quantum numbers l and m.")
        self.wait(1.5)

if __name__ == "__main__" and "--selftest" in sys.argv:
    # Test Y_10 at theta=0 (should be 1)
    assert abs(y_10(0) - 1.0) < 1e-6
    # Test Y_10 at theta=pi/2 (should be 0)
    assert abs(y_10(np.pi/2) - 0.0) < 1e-6
    # Test Y_20 at theta=0 (should be 2)
    assert abs(y_20(0) - 2.0) < 1e-6
    # Test Y_20 at theta=pi/2 (should be -1)
    assert abs(y_20(np.pi/2) - (-1.0)) < 1e-6
    # Test Y_21 at theta=pi/2 (should be 1)
    assert abs(y_21(np.pi/2) - 1.0) < 1e-6
    # Test Y_21 at theta=0 (should be 0)
    assert abs(y_21(0) - 0.0) < 1e-6
    
    print("selftest ok")

The Manim scene code that draws this lesson's animation in the Signals AI app (Python, Manim Community).

ccBYNC© 2026 SignalsLab. Lesson text shared as is under CC BY-NC 4.0.