NMR and MRI physics · Introductory

Chemical shift and shielding

Written by SignalsLab

Early edition: these lessons are being reviewed.

Content

Summary

In NMR, nuclei in different electronic environments resonate at slightly different frequencies because electrons shield the nucleus from the applied magnetic field. This difference is reported as the chemical shift in parts per million (ppm), a field-independent scale that reveals molecular structure.

Intuition

Picture a proton sitting in a strong magnetic field B0. Surrounding electrons are forced by B0 to circulate, and this circulation creates a tiny opposing magnetic field at the nucleus. The nucleus therefore feels slightly less than B0. The more electron density around it, the greater the shielding and the lower its resonance frequency. A nearby electronegative atom such as oxygen pulls electron density away, so the proton is deshielded, feels a larger field, and resonates at higher frequency (further downfield). Because the shielding effect is proportional to B0, we divide frequency differences by the spectrometer frequency to get ppm, so spectra from 300 MHz and 600 MHz instruments line up on the same scale.

Key equations

Beff=B0(1−σ)
(1)

Effective field at the nucleus is reduced by the shielding constant σ (typically ∼10−6 for protons).

ν=γ2πB0(1−σ)
(2)

Larmor frequency depends on the shielded field; γ is the gyromagnetic ratio.

δ=ν−νrefνspectrometer×106
(3)

Chemical shift in ppm relative to a reference such as TMS.

Derivation

  1. Start with the Larmor frequency for a bare nucleus: ν0=γB02π.
  2. Electrons induce a small opposing field proportional to B0: Binduced=−σB0.
  3. The effective field is Beff=B0−σB0=B0(1−σ).
  4. So ν=γB0(1−σ)2π.
  5. For sample and reference: νsample−νref=(γB02π)(σref−σsample).
  6. Divide by νref≈γB02π (the spectrometer frequency) to remove field dependence: δ=(σref−σsample)×106 approximately.

Worked example

Problem

On a 400 MHz spectrometer, a proton resonates 1460 Hz higher than TMS. What is its chemical shift, and what would the offset in Hz be on a 600 MHz instrument?

  1. δ=1460 Hz400×106 Hz×106=3.65 ppm.
  2. The ppm value is field independent, so δ=3.65 ppm at 600 MHz.
  3. Offset at 600 MHz = 3.65 × 600 = 2190 Hz.

Answer 3.65 ppm (typical of a proton on a carbon next to oxygen); 2190 Hz at 600 MHz.

Common mistakes

  • Thinking more shielding means higher frequency; it means lower frequency (upfield, smaller ppm).
  • Believing ppm values change with field strength; only the Hz separation changes.
  • Confusing downfield with a lower ppm; downfield means higher ppm.
  • Forgetting that the reference (TMS) is defined as 0 ppm and is highly shielded.

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(92 lines)
import sys
from manim import *
from blocks import *
import numpy as np

GAMMA_BAR = 42.577  # MHz per tesla for 1H
B0 = 3.0            # tesla
# shielding constants in ppm (illustrative values for three environments)
SIGMAS = {"A": 0.0, "B": 1.5, "C": 3.0}


def local_field(b0, sigma_ppm):
    """Effective field felt by a nucleus: B = B0 (1 - sigma)."""
    return b0 * (1 - sigma_ppm * 1e-6)


def larmor_mhz(b0, sigma_ppm):
    """Larmor frequency in MHz."""
    return GAMMA_BAR * local_field(b0, sigma_ppm)


def shift_ppm(b0, sigma_ppm, ref_sigma=0.0):
    """Chemical shift relative to a reference, in ppm."""
    nu = larmor_mhz(b0, sigma_ppm)
    ref = larmor_mhz(b0, ref_sigma)
    return (nu - ref) / ref * 1e6


class Main(Scene):
    def construct(self):
        self.camera.background_color = "#14161c"
        TitleCard(self, "Chemical shift", "Electrons shield the nucleus")

        # compute values from the formulas
        names = list(SIGMAS)
        freqs = {k: larmor_mhz(B0, s) for k, s in SIGMAS.items()}
        shifts = {k: shift_ppm(B0, s) for k, s in SIGMAS.items()}

        eq = MathTex(r"B_{loc}=B_0(1-\sigma),\quad \nu=\gamma B_{loc}", font_size=36)
        eq.next_to(self.camera.frame_height * 0 + UP * 2.3, DOWN, buff=0)
        eq.move_to(UP * 2.4)
        self.play(Write(eq))

        # three nuclei with electron clouds of growing size
        atoms = VGroup()
        for i, k in enumerate(names):
            nuc = Dot(radius=0.1, color=C_ACCENT)
            cloud = Circle(radius=0.3 + 0.2 * i, color=C_MAIN, fill_opacity=0.15 + 0.12 * i)
            lab = Text(f"{k}: σ={SIGMAS[k]} ppm", font_size=24)
            g = VGroup(cloud, nuc)
            lab.next_to(g, DOWN, buff=0.25)
            atoms.add(VGroup(g, lab))
        atoms.arrange(RIGHT, buff=1.6).move_to(UP * 0.2)
        self.play(FadeIn(atoms))
        StepCaption(self, "More electron density means more shielding")

        # field arrows: weaker local field for more shielded nuclei
        arrows = VGroup()
        for grp, k in zip(atoms, names):
            frac = local_field(B0, SIGMAS[k]) / B0
            length = 1.0 * frac
            a = Arrow(grp[0].get_top() + UP * 0.9, grp[0].get_top() + UP * (0.9 + length),
                      buff=0, color=C_GOOD)
            arrows.add(a)
        self.play(*[Create(a) for a in arrows])
        self.wait(0.5)

        # spectrum axis: shift in ppm, drawn from computed values
        self.play(FadeOut(atoms), FadeOut(arrows), FadeOut(eq))
        axis = NumberLine(x_range=[0, 4, 1], length=9, include_numbers=True,
                          font_size=24, color=C_DIM).move_to(DOWN * 0.8)
        xl = Text("shift δ (ppm)", font_size=24).next_to(axis, DOWN, buff=0.6)
        self.play(Create(axis), FadeIn(xl))
        peaks = VGroup()
        for k in names:
            x = axis.n2p(abs(shifts[k]))
            p = Line(x, x + UP * 2.0, color=C_ACCENT, stroke_width=6)
            t = Text(k, font_size=24).next_to(p, UP, buff=0.1)
            peaks.add(VGroup(p, t))
        self.play(*[Create(p) for p in peaks], run_time=1.5)
        StepCaption(self, "Shielded nuclei resonate at lower frequency, so the peak position reveals the environment")
        self.wait(1)


if __name__ == "__main__" and "--selftest" in sys.argv:
    assert abs(larmor_mhz(B0, 0) - GAMMA_BAR * B0) < 1e-9
    assert larmor_mhz(B0, 3.0) < larmor_mhz(B0, 1.5) < larmor_mhz(B0, 0)
    assert abs(shift_ppm(B0, 0)) < 1e-9
    assert abs(abs(shift_ppm(B0, 3.0)) - 3.0) < 1e-3
    # ppm shift is independent of field strength
    assert abs(shift_ppm(1.5, 1.5) - shift_ppm(7.0, 1.5)) < 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.