🔭 astrophysics

nanoCMB: A minimal CMB power spectrum calculator in Python

The paper introduces nanoCMB, a concise and transparent Python implementation of the line-of-sight integration method that accurately computes unlensed CMB power spectra for flat $\Lambda$ CDM cosmologies, achieving sub-percent agreement with CAMB while serving as an educational bridge between textbook theory and research-level Boltzmann solvers.

Original authors: Adam Moss

Published 2026-03-02

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Adam Moss

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine the universe as a giant, expanding balloon. A long time ago, when this balloon was very hot and small, it was filled with a thick, foggy soup of particles and light. As the balloon expanded and cooled, the fog suddenly cleared, and the light was set free to travel across the universe forever. This ancient light is what we call the Cosmic Microwave Background (CMB). It's like a baby picture of the universe, taken when it was only 380,000 years old.

Scientists study this "baby picture" by looking at the tiny ripples and patterns in the light. These patterns tell us exactly how the universe is made (how much dark matter, how much normal matter, how fast it's expanding). To read these patterns, they need a calculator that can predict what the picture should look like based on different theories.

Enter nanoCMB.

What is nanoCMB?

Think of the existing calculators (like CAMB or CLASS) as massive, industrial-grade supercomputers. They are incredibly powerful and accurate, but they are also huge, complex, and written in a language that is hard for beginners to read (like thousands of lines of dense, old-school code). They are like a black box: you put numbers in, and you get answers out, but it's hard to see how the magic happens inside.

nanoCMB is different. It is a minimalist, "kitchen-table" calculator.

Size: It's tiny. The entire program is only about 1,400 lines of code (roughly the size of a short story).
Language: It's written in Python, a language known for being readable and easy to understand, like English.
Goal: It's designed to be a teaching tool. It strips away all the complicated shortcuts and hidden settings to show you the raw physics, step-by-step.

How Does It Work? (The Analogy)

Imagine you are trying to predict the sound of a drum being hit in a giant, echoing hall. To do this, you have to solve a massive set of equations that describe how the air moves, how the drum skin vibrates, and how the sound bounces off the walls.

The Background (The Room): First, nanoCMB calculates the size and shape of the "hall" (the universe) as it expands.
The Recombination (The Fog Clearing): It calculates the exact moment the "fog" cleared. It tracks how electrons and protons decided to stick together to form atoms, letting the light escape. It even accounts for the tricky physics of helium, not just hydrogen.
The Ripples (The Sound Waves): It simulates the tiny ripples in the early universe. Imagine a crowded dance floor where people (particles) are bumping into each other. The code tracks how these bumps travel, how they get squeezed by gravity, and how they push back against each other.
The View from the Edge (The Line-of-Sight): Instead of tracking every single particle to every single point in the sky (which would take forever), it uses a clever trick called "Line-of-Sight Integration." Think of it like taking a photo of the drum from a specific angle. It calculates the final pattern you would see on the wall by summing up the contributions of the sound waves as they travel toward you.

Why Is This Special?

You might ask, "If the big calculators are better, why do we need this tiny one?"

Transparency: In the big calculators, if you want to change a rule, you have to dig through thousands of lines of code and hope you don't break something. In nanoCMB, every single rule and number is visible. If you want to change how the universe expands, you just change one line.
Accuracy: Despite being small and simple, it is surprisingly accurate. The author tested it against the giant super-calculator (CAMB), and they agreed with each other to within less than 1%. That's like measuring the distance from London to New York and being off by less than a meter.
Speed: It runs in about 10 seconds on a normal laptop. While the big calculators are faster (because they are written in a faster language), nanoCMB is fast enough for learning and testing new ideas.

The "Secret Sauce"

The author used some clever tricks to keep the code small but accurate:

Smart Grids: Instead of checking every single point in the universe equally (which is a waste of time), the code checks the important spots more often and the boring spots less often. It's like a photographer focusing on the subject's face and blurring the background.
Pre-computed Tables: It calculates the complex math for sound waves (Bessel functions) once, saves them in a notebook, and just looks them up later instead of doing the math over and over.

The Bottom Line

nanoCMB is the "Hello World" of cosmology. It bridges the gap between reading a textbook (where the math looks simple) and using professional research software (where the code looks terrifying).

It proves that you don't need a supercomputer or a black box to understand the universe's baby picture. Sometimes, you just need a clear, readable script that shows you exactly how the pieces fit together. It's a tool for students, teachers, and anyone who wants to peek behind the curtain of the universe's most famous photograph.

1. Problem Statement

The Cosmic Microwave Background (CMB) angular power spectrum is a fundamental tool in precision cosmology. Calculating these spectra requires solving coupled Einstein–Boltzmann equations through recombination and performing line-of-sight (LOS) integrations.

The Gap: While research-level codes like CAMB and CLASS are highly accurate, they are complex, written in compiled languages (Fortran/C), contain tens of thousands of lines of code, and rely on historical conventions and deep optimization layers. This makes them difficult for students or researchers new to the field to understand, modify, or use as a pedagogical bridge between textbook theory and production code.
The Need: There is a lack of transparent, minimal, yet accurate implementations that explicitly show every approximation and numerical choice, allowing for easy modification and educational use.

2. Methodology

nanoCMB is a Python implementation of the CMB power spectrum calculation designed to be a "minimal but accurate" solver. It consists of approximately 1,400 lines of readable Python code contained in a single script (nanocmb.py), relying only on NumPy and SciPy (with optional Numba for speed).

The code follows the standard physical pipeline:

Background Cosmology: Solves the Friedmann equation in conformal time for a flat $\Lambda$ CDM model with massless neutrinos. It computes the Hubble parameter and conformal time evolution.
Recombination: Implements the full RECFAST algorithm. This includes:
- The Peebles equation for hydrogen recombination (Case-B recombination, Lyman- $\alpha$ escape, two-photon decay).
- Helium recombination (He III $\to$ He II $\to$ He I) with singlet and triplet channels.
- Evolution of matter temperature ( $T_m$ ) via Compton heating/cooling and adiabatic expansion.
- A parameterized reionization model (tanh transition) constrained by the optical depth $\tau_{reion}$ .
Perturbation Theory:
- Gauge: Uses the synchronous gauge with the CDM rest-frame convention (matching CAMB).
- Boltzmann Hierarchy: Solves coupled ODEs for photons (temperature and E-mode polarization), massless neutrinos, cold dark matter (CDM), and baryons.
- Tight-Coupling Approximation: Uses an algebraic solution for the photon quadrupole and baryon velocity during the early tightly-coupled era to reduce numerical stiffness.
- Initial Conditions: Sets adiabatic growing modes deep in the radiation era.
- Truncation: Truncates the hierarchy at $\ell_{max}=15$ using a free-streaming closure relation.
Line-of-Sight (LOS) Integration:
- Instead of evolving the full hierarchy to high multipoles, it uses the Seljak & Zaldarriaga LOS method.
- Integration by Parts: Decomposes the source function into three channels ( $S_0, S_1, S_2$ ) to transfer derivatives from the noisy visibility function to smooth spherical Bessel functions.
- Source Terms: Includes the monopole, dipole, quadrupole, and the Integrated Sachs-Wolfe (ISW) effect.
Numerical Optimization:
- Non-Uniform Grids: Implements an error equidistribution principle to construct optimal, non-uniform grids for wavenumber ( $k$ ) and conformal time ( $\tau$ ). This concentrates grid points where the integrand has high curvature (acoustic oscillations) rather than using uniform spacing.
- Bessel Functions: Precomputes spherical Bessel functions ( $j_\ell$ ) and their derivatives on a uniform grid, using recurrence relations and disk caching to avoid expensive repeated evaluations.
- Two-Grid Strategy: Solves the ODEs on a coarse grid (200 modes), interpolates source functions to a fine grid (4000 modes) using Akima interpolation, and performs the LOS integration on the fine grid.

3. Key Contributions

Pedagogical Transparency: The code is designed to be read alongside the paper. Every physical approximation (e.g., tight-coupling, RECFAST fudge factors) and numerical choice (grid sizes, tolerances) is explicit and visible, unlike the "black box" nature of CAMB/CLASS.
Minimalism: Achieves high accuracy without complex class hierarchies, configuration files, or build systems. The entire calculation is in one file.
Accuracy: Despite its brevity, it achieves sub-percent agreement with CAMB across the multipole range $2 \le \ell \le 2500$ .
Optimized Grids: The paper details the derivation of optimal non-uniform grids based on the curvature of the source functions, demonstrating significant computational efficiency gains over uniform grids.
Extensibility: The modular structure allows for straightforward extensions (e.g., adding lensing, tensors, or massive neutrinos) by editing specific functions rather than navigating a large codebase.

4. Results

The paper validates nanoCMB against CAMB (configured with AccuracyBoost=3, no lensing, no tensors, massless neutrinos) using Planck 2018 best-fit parameters and a multi-cosmology benchmark.

Intermediate Quantities:
- Hubble parameter $H(z)$ : Agreement at the $10^{-4}$ level.
- Ionization history ( $x_e$ ) and visibility function: Agreement within $\lesssim 0.5\%$ .
- Perturbation variables: Agreement within $\sim 1\%$ .
- Transfer functions: Sub-percent agreement.
Power Spectra ( $C_\ell$ ):
- Temperature ($TT$): Mean ratio to CAMB is $\approx 0.999$ with standard deviation $< 0.1\%$ across all $\ell$ .
- Polarization ($EE$): Mean ratio $\approx 1.000$ with standard deviation $< 0.3\%$ (slightly higher residuals at low $\ell$ due to the small amplitude of the reionization bump).
- Cross-Spectrum ($TE$): Consistent with CAMB.
Multi-Cosmology Benchmark: Tested against 50 cosmologies spanning $\pm 3\sigma$ of the Planck posterior. The RMS fractional residuals remained $\lesssim 0.2\%$ for $TT$ and $EE$, confirming the accuracy is not tuned to a single parameter set.
Performance:
- Runs in ~10 seconds on a modern laptop (with Numba JIT) or ~30 seconds (pure Python).
- While slower than compiled Fortran codes (CAMB runs in <1s), the speed is sufficient for pedagogical use and rapid prototyping.

5. Significance

nanoCMB serves as a crucial "Rosetta Stone" for cosmology education and research:

Education: It bridges the gap between textbook equations and complex production codes, allowing students to see exactly how the physics is translated into numerical algorithms.
Research Tool: It provides a lightweight, easily modifiable platform for testing new physical ideas (e.g., alternative recombination models or modified gravity) without the overhead of modifying massive legacy codebases.
Verification: It acts as an independent check for the numerical implementation of standard physics, helping to identify potential bugs or misunderstandings in more complex solvers.

The code is publicly available, fostering reproducibility and transparency in CMB power spectrum calculations.