Nmr Analysis

Background & Key Concepts

Free Induction Decay (FID)

The FID is the time-domain NMR signal recorded after a radiofrequency pulse. It is a sum of exponentially decaying sinusoids; each frequency corresponds to a resonance. The complex FID is Fourier-transformed to yield the frequency-domain spectrum.

Apodization (Window Functions)

Before Fourier transformation, a window function is multiplied with the FID to:

• Improve sensitivity (exponential multiplication — line broadening).
• Improve resolution (Lorentz-to-Gauss transformation — line narrowing).
• Reduce truncation artifacts (cosine/sine bells for 2D data).

Common window functions:

Zero-Filling

Appending zeros to the FID before Fourier transformation increases the number of spectral points and therefore digital resolution. Zero-filling by a factor of 2 is standard; zero-filling by 4–8 is used for high-resolution work.

Phase Correction

The spectrum has real (absorption) and imaginary (dispersion) components. Phase correction (zeroth-order P0 and first-order P1) ensures all peaks have pure absorption lineshapes, which are symmetric and integrable.

Chemical Shift Referencing

Chemical shifts in ppm are calculated relative to a reference compound:

• 1H / 13C: TMS (tetramethylsilane) at 0.00 ppm
• Aqueous solutions: DSS or TSP at 0.00 ppm
• 31P: H3PO4 at 0.00 ppm

J-Coupling Constants

Spin-spin coupling splits resonances into multiplets. The coupling constant J (in Hz) equals the frequency separation between adjacent lines of a first-order multiplet. Accurate J values require fitting each line of the multiplet with a Lorentzian.

Environment Setup

Installation

# Conda environment (recommended)
conda create -n nmr-env python=3.11 -y
conda activate nmr-env

pip install "nmrglue>=0.9" "matplotlib>=3.7" "scipy>=1.11" "numpy>=1.24" "pandas>=2.0"

Verify Installation

import nmrglue as ng
print(ng.__version__)   # e.g. 0.9

import scipy, numpy, pandas, matplotlib
print("All dependencies imported successfully.")

Data Formats Supported by nmrglue

Core Workflow

Step 1 — Load Raw FID and Inspect Parameters

import nmrglue as ng
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

# --- Bruker data directory ---
DATA_DIR = "/path/to/bruker/experiment"   # contains 'fid' and 'acqus' files

dic, data = ng.bruker.read(DATA_DIR)

# Print key acquisition parameters
acqus = dic["acqus"]
print(f"Spectrometer frequency (SF)  : {acqus['SFO1']:.4f} MHz")
print(f"Spectral width (SW)          : {acqus['SW']:.2f} ppm")
print(f"Number of points (TD)        : {acqus['TD']}")
print(f"Relaxation delay (D1)        : {acqus.get('D', [None]*2)[1]} s")
print(f"Number of scans (NS)         : {acqus['NS']}")
print(f"Solvent                      : {acqus.get('SOLVENT', 'N/A')}")
print(f"FID shape                    : {data.shape}")
print(f"FID dtype                    : {data.dtype}")

# Plot raw FID (real part)
fig, ax = plt.subplots(figsize=(10, 3))
ax.plot(data.real[:2048], lw=0.8, color="steelblue")
ax.set_xlabel("Point Index", fontsize=12)
ax.set_ylabel("Intensity (AU)", fontsize=12)
ax.set_title("Raw FID (first 2048 points)", fontsize=13)
ax.grid(alpha=0.3)
plt.tight_layout()
plt.savefig("raw_fid.png", dpi=150)
plt.show()

Step 2 — FID Processing (Apodization, Zero-Filling, FT, Phase Correction)

import nmrglue as ng
import numpy as np
import matplotlib.pyplot as plt

DATA_DIR = "/path/to/bruker/experiment"
dic, data = ng.bruker.read(DATA_DIR)

# Remove digital filter group delay (Bruker-specific)
data = ng.bruker.remove_digital_filter(dic, data)

# ----- Apodization -----
# Lorentz-to-Gauss transformation: lb < 0 (line narrowing), gb > 0 (Gaussian)
data_apod = ng.proc_base.gm(data, g1=0.1, g2=0.1, g3=0.0)   # Gaussian multiply
# Alternative — exponential multiplication (sensitivity mode):
# data_apod = ng.proc_base.em(data, lb=0.3)   # lb in Hz

# ----- Zero-filling -----
# Double the number of points
n_td = data.shape[-1]
data_zf = ng.proc_base.zf_size(data_apod, n_td * 2)

# ----- Fourier Transform -----
data_ft = ng.proc_base.fft(data_zf)

# ----- Phase Correction (manual values) -----
# Determine P0, P1 empirically or from instrument file
P0 = 0.0    # zeroth-order phase (degrees)
P1 = 0.0    # first-order phase (degrees)
data_ph = ng.proc_base.ps(data_ft, p0=P0, p1=P1)

# ----- Reverse spectrum (if needed) -----
data_final = ng.proc_base.rev(data_ph)

print(f"Processed spectrum shape: {data_final.shape}")

# Build ppm axis using udic
udic = ng.bruker.guess_udic(dic, data_final)
uc = ng.fileiobase.uc_from_udic(udic)
ppm_axis = uc.ppm_scale()

fig, ax = plt.subplots(figsize=(12, 4))
ax.plot(ppm_axis, data_final.real, lw=0.8, color="navy")
ax.invert_xaxis()
ax.set_xlabel("Chemical Shift (ppm)", fontsize=12)
ax.set_ylabel("Intensity", fontsize=12)
ax.set_title("Processed 1H NMR Spectrum", fontsize=13)
ax.grid(alpha=0.3)
plt.tight_layout()
plt.savefig("spectrum_1d.png", dpi=150)
plt.show()

Step 3 — Automated Peak Picking

import nmrglue as ng
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.signal import find_peaks

# Assume data_final and ppm_axis from Step 2 are available

spectrum = data_final.real

# Noise estimation (MAD of baseline region outside peaks)
baseline_mask = (ppm_axis < 0.5) | (ppm_axis > 11.0)  # adjust for your nucleus
if baseline_mask.sum() > 10:
    noise = np.median(np.abs(spectrum[baseline_mask]))