Often it is easiest and most flexible to just use the Python version, which includes a command-line "camb" script. This readme instead focuses on using the compiled binary Fortran command-line version. CAMB can also be used as part of the CosmoMC and Cobaya parameter estimation packages.

Code for Anisotropies in the Microwave Background by Antony Lewis and Anthony Challinor.
Originally based on CMBFAST developed by Uros Seljak and Matias Zaldarriaga, itself based on Boltzmann code written by Edmund Bertschinger, Chung-Pei Ma and Paul Bode.

To install the Fortran binary from the command line:

• Download CAMB
• If cloning using git, add --recurse-submodules to get the forutils submodule as well
• If downloading unzip the file (tar xfv filename for tar.gz); all files will be extracted to a directory called "CAMB-xxx". Note you need forutils library in the forutils directory.
• Change to the fortran directory (cd fortran)
• Run make to compile everything you will need. (you may need to edit the supplied Makefile, see below)
• Run ./camb ../inifiles/params.ini, where params.ini is a file of parameter values (sample supplied). The params.ini file should be fairly self-explanatory. The Fortran program should be run from the fortran directory (in order find the .dat template file that it loads).
• To install and use the Python CAMB wrapper see the Python CAMB documentation. After in installing with pip this also has a command-line camb script that will be built automatically with the python version - no need to compile the fortran code directly, and it can be run from any directory.

The Makefile comes set up for gfortran and ifort compilers. Edit the relevant parts of the Makefile to compile on other systems. If you have Intel's Visual Fortran you can use the projects in the VisualStudio folder, no need to use the Makefile. To run on multi-processor machines add the -openmp (or equivalent) option to the Makefile's FFLAGS parameter to compile a parallelized (OPENMP) version.

For a demo of how to use CAMB with the python wrapper see the demo notebook. For some further technical details about the algorithms, equations and code see the CAMB notes.

The params.ini file specifies the parameters used to run the program. Comments in params.ini should make this fairly self-explanatory, more complicated cases, for example to run with multiple neutrino mass eigenstates and sterile neutrinos at different temperatures see the documentation and examples in the CAMB notes. To produce the matter power spectrum in addition to CMB C_l set get_transfer = T; the do_nonlinear input parameter determines whether this is output as the linear power spectrum or includes non-linear corrections from the Halofit model.

The default params.ini file produces results in μK² from the given primordial curvature perturbation power (scalar_amp) on 0.05 MPc^-1 scales. To get unnormalized dimensionless results set scalar_amp=1 and CMB_outputscale=1. To compute lensed C_ls you must set the normalization to some realistic value (the calculation is non-linear, so normalization matters).

Outputs

If transfer functions are requested the columns in the output_root_transfer.dat output file are:

1	k/h	wavenumber in h Mpc-1
2	Delta_CDM/k2	CDM
3	Delta_b/k2	baryons
4	Delta_g/k2	photons
5	Delta_r/k2	massless neutrinos
6	Delta_nu/k2	massive neutrinos
7	Delta_tot/k2	CDM+baryons+massive neutrinos
8	Delta_nonu/k2	CDM+baryons
9	Delta_totde/k2	CDM+baryons+massive neutrinos+ dark energy(numerator only)
10	Φ	The Weyl potential (φ+ψ)/2
11	vel_Newt_cdm/k2	vel_Newt_cdm is -vcdm k/H (Newtonian-gauge CDM velocity vcdm)
12	vel_Newt_b/k2	vel_Newt_b is -vb k/H (Newtonian-gauge baryon velocity vb)
13	vel_baryon_cdm/k2	relative baryon-CDM velocity (vb-vcdm)

where Delta_X is defined as (delta rho_X)/rho_X in the synchronous gauge and evaluated at the requested redshift, given a unit primordial curvature perturbation on superhorizon scales (for adiabatic modes, chi_0=-1). The column numbers correspond to the Transfer_xx integer constants defined in the Transfer module (results.f90).

output_root_matterpower.dat contains the conventionally normalized matter power spectrum (for baryons+cdm+massive neutrinos), in h/Mpc units.

Compilation options and code modifications

The Makefile should work out of the box in most cases for ifort and gfortran. If you define your own new classes, or want to compile with CosmoRec or HyRec recombination support, you can edit the file list variables at the top of Makefile_main. You can also use e.g. make RECOMBINATION_FILES="recfast cosmorec" to override the default and compile with additional files. REIONIZATION is by default a simple relatively fast single-step reionization model (following arXiv:0804.3865), but you could add alternative models by implementing other derived classes.

It's rarely needed, but you can power spectrum produce files in FITS format - to do this you will need to have HEALPIX installed and make some edits to the Makefile - see the Makefile for details. After compiling with make camb_fits, you can then use camb_fits instead of camb - the FITS file produced is given the name specified in params.ini. Note that the FITS file format for polarization changed with HEALPIX 1.2, CAMB uses the new format.

All the equations that need to be modified for simple non-standard models are in the equations.f90 file, or an in separate classes like the dark energy model.

After modifying any of the source code run make clean before running make to recompile (Visual Fortran will re-compile dependent code automatically). Run make all to build a library libcamb.a that you can use when linking to other programs. (You will also need to include the module files using -I/cambfolder).

See the class hierarchy for how the different components of the calculation are structured. Some details about what different source code files do are given below, see also the CAMB notes.

A test suite is included, and will run automatically on Travis when committing or making pull requests on the GitHub repository. Python unit tests are in the camb.tests, and scripts for comparing outputs for a variety of models (as run on Travis) are in the tests directory.

The source files

See the auto-generated source documentation, and a few details below:

camb.f90

Main wrapper routines for running CAMB in your fortran programs. Add "use camb" to your programs and call CAMB_GetResults to generate output from a set of model parameters (specified in the CAMBparams type - defined in model.f90). You can call CAMB_ValidateParams(P) to check that the parameter set is valid, use CAMB_GetAge to compute the age of a model in gigayears, and CAMB_GetCls to retrieve the computed Cls.

Sample programs tester.f90 and sigma8.f90 are supplied showing how to use CAMB from your own programs. You can also use CAMB_GetTransfers to access the C_l transfer functions directly without incorporating the initial power spectrum. In addition this module provides the routines to read settings from a .ini file.

cmbmain.f90

The main subroutine that does integrations, etc.

equations.f90

Files containing background and perturbation evolution equations. The perturbations equations used are derived in the covariant approach, fixing to the CDM (zero acceleration) frame, which are essentially equivalent to the synchronous gauge equations.

The file defines a module called "GaugeInterface" which provides the necessary perturbation calculation routines for "cmbmain".

The subroutine dtauda(a) returns dt/da and is used wherever the background evolution is needed. It can be modified for different backgrounds. If you add additional components, and can edit the init_background routine to do additional initialization.

outtransf writes out the matter transfer functions.

The "output" subroutine computes the scalar sources at a given time for a given wavenumber. These are the temperature, E polarization and (if doing lensing) the lensing source. By editing the equation for the lensing source it should be straightforward to compute power spectra for other matter tracers, e.g. for cross-correlation with the CMB. The lensing power spectrum is automatically computed if DoLensing=T.

InitialPower.f90

This file defines a module called InitialPower with classes returning the initial power spectra. Comments in the code explain this further.

reionization.f90

This file defines a module called Reionization that provides a class implementing a tanh-parameterization of the reionization history. The class gives x_e as a function of redshift. Optical depth input parameters are mapped into z_re (defined as where x_e is half its maximum (ex second He reionization)) using a binary search. See the CAMB notes for discussion. This module should be easily modifiable for alternative reionization models.

halofit.f90

Implements the NonLinearModel class, to calculate non-linear scalings of the matter power spectrum as a function of redshift. Uses HALOFIT (astro-ph/0207664, code thanks to Robert Smith, with tweaks from arXiv:1208.2701 (thanks Ryuichi Takahashi) - see that paper for discussion of numerical accuracy. This module can be replaced to use a different non-linear fitting method if desired.

inidriver.f90

Reads in parameters from a file of name/value pairs and calls CAMB. The fortran equivalent of camb.py.

model.f90

Defined CAMBparams input parameter types.

results.f90

Defines types used by calculated intermediate results (e.g. time interpolation tables), and outputs like CAMBdata and transfer functions

bessels.f90

Module to calculate spherical and hyper-spherical Bessel functions. Hyper-spherical functions generated by use of either the recursion relation or Kosowsky's WKB approximation. Based on Arthur Kosowsky's "hyperjl.c".

lensing.f90

Lensing module for computing the lensed CMB power spectra from the unlensed spectra and a lensing power spectrum. See astro-ph/0502425.

subroutines.f90

Various subroutines for interpolation, and modified Runge-Kutta dverk for parallelized evolution.

writefits.f90

Subroutine WriteFitsCls that uses HEALPIX routines to output power spectrum in FITS format. Not usually used (also not tested regularly).

recfast.f90

RECFAST integrator for Cosmic Recombination of Hydrogen and Helium by Douglas Scott (with minor modifications for CMBFAST and the CAMB). See RECFAST for the original code. This module implements the TRecombinationModel class required by CAMB. Sample wrappers are also provided for CosmoRec and HyRec, but the libraries for these must be installed separately.

SeparableBispectrum.f90

Implements calculation of simple separable primordial bispectra, specifically the local constant f_NL model, and the CMB lensing bispectrum due to the linear temperature and polarization cross-correlation with the lensing potential. Compile with FISHER defined in the makefile to also calculate Fisher elements, including the effects of lensing signal variance (edit Makefile to link to LAPACK if necessary). Note that the primordial bispectra here are unlensed (see arXiv:0905.4732 for a calculation), but the lensed bispectra are calculated non-perturbatively (but approximately) using the lensed small-scale CMB power spectra. Note that calculating primordial bispectra is significantly slower than doing standard power spectrum calculations, however it parallelizes well.

camb_python.f90

Interface functions for the python wrapper.

Accuracy

Scalar numerical errors should rarely exceed 0.3% and 0.1% for 500<L<3000. Matter power spectrum errors are usually dominated by interpolation in the acoustic oscillations, with about 0.2% accuracy (but much better rms accuracy). For a detailed study of numerical accuracy as of January 2012 see arXiv:1201.3654.

Accuracy of course assumes the model is correct, and is dependent on RECFAST being the correct ionization history. Lensed C_l TT, TE and EE are accurate at the same level (to within the approximation that the lensing potential is linear, or the accuracy of the HALOFIT non-linear model).

Extreme models (e.g. scale > 4, h>1) may give errors of 5% or more.

Tensor errors around 2% or more on small scales (e.g. due to l-interpolation). Low l accuracy somewhat worse than scalars (typically < 1%). Turn on neutrinos in the input file for accurate results (automatic on high accuracy setting).

Hierarchy truncation errors up to 5% at high l (>1500) in some closed models

You can improve or check accuracy (or increase speed) by changing global accuracy parameters at the bottom of the params.ini input file. Convergence and stability can be checked using the test suite, and accuracy parameters can also be changed from the python version.

Version history

• Integrated CAMB and CAMB sources, for CMB, CMB lensing, lensing convergence, number counts and 21cm.
• Fortran 2003 Object-oriented code restructuring; fortran code structure now closer to the python (see class trees).
• Changed CAMBparam parameters to be physical density parameters ombh2, omch3, omnuh2 (+omk)
• Modest speed improvement from using higher order series solutions for background neutrino density combined with linear rather than log spline.
• Uses splined a(t) for perturbation evolution rather than evolving for each perturbation mode; tensor spectrum results now much faster
• More accurate background calculations with partial parallelism
• Finer every-L sampling at L=11-15 (small change in EE). Updated c_l interpolation template.
• min_l and custom source functions now set as parts of CAMBparams
• Account for radiation when setting dark energy density from matter densities and omk
• Smoother default reionization history parameters around helium second reionization
• Use matter temperature evolution from recfast (still harmlessly wrong - as before - from reionization onwards)
• scalarCovCls.dat and _array outputs for lensing potential now deflection angle
• Fix for auto-kmax when using lensing from command line
• Halofit default updated to HMcode to match Planck 2018 analysis
• Dark Energy, InitialPower, NonLinearModel, ReionizationModel and RecombinationModel are now all classes that can be switched dynamically. General spline fit implementation for the initial power spectrum and lensing/count source distributions.
• SplinedInitialPower and SplinedSourceWindow implementations for general interpolated initial power spectra and source window functions
• Added TAxionEffectiveFluid example specific dark energy class implementation
• high_accuracy_default option removed (is now the default).
• Git repository now uses submodule for forutils
• Python CAMB:
  • CAMB is now packaged as a Python-focused module, but fortran directory still has support for fortran executable as before.
  • Lensing convergence, number counts and 21cm now available from Python
  • SplinedSourceWindow and GaussianWindow for setting SourceWindows array (see example notebook)
  • Reworked python-fortran interface using metaclass and decorators, supporting allocatable arrays and class instances and directly import and call of fortran class methods
  • Support multiple CAMBdata instances, and results object can be called safely in any order (removing most global variables)
  • Dark Energy, InitialPower, NonLinearModel, ReionizationModel and RecombinationModel classes that can be dynamically assigned to CAMBparam class member elements
  • set_initial_power_function and set_initial_power_table to set initial power spectra from arbitrary python function or sampled arrays
  • set_cosmology() now supports more general exact thetastar as well as H0 and cosmomc_theta. No H0 default.
  • CAMBParams read-only properties for omegam, N_eff, omegab, omegac, omaganu, h
  • T_CMB changes handled consistently
  • camb.set_params supports options for changing dark energy, initial power and non-linear model classes
  • camb.set_params can set CAMBparam members if not already used as an argument (and things like InitPower.ns via an input string)
  • Fields support named enumerations, name-length fields for arrays, fortran-compatible boolean and help
  • Docs include help for field values (auto-generated via metaclass)
  • Faster and array versions of various background functions
  • SecondOrderPK non-linear model class
  • Optional support for CosmoRec and HyRec RecombinationModel classes (need to compile with them linked)
  • Updated BBN model default to Parthenope 2017 as Planck 2018 analysis

• Option to use HMCode 2015 version (thanks Alex Mead)
• accurate_massive_neutrino_transfers option if accurate neutrino transfer functions needed at late time
• Output text file precision increased
• Warning if accurate_BB=T but other options not set sensibly for accurate lensing BB
• Python CAMB wrapper:
  • On linux system now builds with ifort if available (~35% faster)
  • More efficient and new vector support for angular_diameter_distance and related background functions
  • bbn module generalisation to allow more general table interpolation and vector arguments; added PRIMAT table (thanks Cyril Pitrou)
  • Improvements for default settings in various cases
  • get_background_time_evolution can now get T_b, the baryon temperature
  • save_cmb_pwoer_spectra convenience function
  • Changes for Cobaya compatibility (thanks Jesus Torrado)
  • get_matter_power_interpolator has extrap_kmap to efficiently get tails by extrapolation
  • get_matter_power_interpolator now also available as method of results object for optimization purposes
  • mathutils module with convenience functions like Wigner 3j, pseudo-CL coupling, and fast Gauss-Legendre and x^T C^{-1} x evaluation
  • Doc and example notebook improvements/additional examples and warnings

• HMCode bug fix and speed up (thanks Alex Mead)
• Refactoring in equations.f90 so all scalar source outputs now computed in derivs function; support for custom source functions (as used by python camb.symbolic module)
• Python CAMB wrapper:
  • Added camb.symbolic module using sympy, to get equations, convert between gauges, and produce and compile CAMB code from analytic results in different gauges. See the demo notebook demonstrating how to use this, set custom sources, plot perturbation evolution and calculate angular power spectra of different things.
  • Add camb.emission_angle module to get BB power from emission angle and time delay (1706.02673)
  • Added camb.postborn module to get the field rotation power spectrum and associated BB power (1605.05662)
  • Support for BBN-consistency values of Y_He by interpolation from table; new tables from Parthenope supplied (thanks Ofelia Pisanti)
  • H_of_z functions now support arrays of redshifts
  • Add nonlinear parameter to model.set_matter_power
  • AccurateReionization is now switched on by default
  • CMB_outputscale and raw_cl options to python CMB power spectra output functions to get CL or DL, and use different units
  • Added get_fsigma8() function
  • Python 3.6 compatibility
  • "pip install camb" now working cleanly
  • Makefile improvements to build pycamb using gfortran even if ifort present (can use "make COMPILER=gfortran" to force gfortran)
  • Bug fixes

• Python CAMB wrapper correlations module: Transform between C_L and CMB correlation functions; calculate lensed power spectra and correlation functions from unlensed spectra and lensing power spectrum (useful for delensing); calculate matrix of derivatives of lensed power spectra with respect to lensing power and unlensed C_L.
• Added halofit_casarini=7 for PKequal dark energy fitting (thanks Luciano Casarini; arXiv:0810.0190, arXiv:1601.07230)
• Fixed compilation issue with gfortran 6.3

• CAMB_SetNeutrinoHierarchy function and python wrapper neutrino_hierarchy option for set_cosmology function (to configure to use two eigenstate approximation to normal or inverted hierarchies)
• Various misc small bug fixes, improvements and compiler compatibility changes

• Added support for HMCODE Halofit version (halofit_version=5; thanks Alex Mead); Takahashi remains the default as before
• Python CAMB wrapper
  • camb.get_matter_power_interpolator function get 2D spline object for evaluating P(k,z);
    See the sample notebook for an example of how to use this to calculate a lensing spectrum
  • Result object functions to get unsplined matter power (get_linear_matter_power_spectrum,get_nonlinear_matter_power_spectrum)
  • Result object function to get redshift from conformal time (redshift_at_comoving_radial_distance)
  • camb.set_halofit_version to set halofit version;
  • Option to set cosmomc_theta rather than H_0 (thanks Marius Millea)
  • Wigner 3j function for convenience (camb.bispectrum.threej).

• New Python CAMB wrapper
• Option to add comment headers to output files giving column names (output_file_headers = T)
• New input parameters to change the default second helium reionization redshift and duration
• Output of transfer functions will now also work at very early times

• Tidied up Makefile (auto-detect gfortran/ifort, release/debug builds)
• Small tweak for accuracy with higher neutrino masses
• A CodeBlocks project file is provided (camb.cbp), which can also be used to run and debug from the cross-platform CodeBlocks IDE

• Transfer function output now includes more variables, including different total densities and velocities (see list)
• Generalized matter power and sigma8 functions; output of "growth" (from CDM velocity correlation sigma8_vd^2/sigma8)
• Output of additional derived parameters (k_eq, D_A, θ_s,eq - the angular scale of the sound horizon at matter-radiation equality)
• Add halofit_version (=1,2,3,4) to set halofit version (see params.ini)
• Halofit tweak to prevent negative values in neutrino models for high Ω_m (thanks Simeon Bird)
• Add tensors when calculating bispectrum Fisher values
• Add AngularDiameterDistance2 utility function
• Added internal ALens_Fiducial as alternative to Alens

• Added two alternative tensor power spectrum parameterizations (see CAMB notes section on initial power spectra), allowing easy specification of r or tensor amplitude with different scalar/tensor pivot scales
• Added optional parameters scalar_nrunrun (for running of running of scalar power), and tensor_nrun for running of tensors
• Start lensing potential integration at tau_maxvis (gets T-phi slightly closer to result from using visibility, very small change to anything else) and added negligible anisotropic stress correction for consistency in extended models.

• Fixed problem with tensor modes having DoTensorNeutrinos=T and massive neutrinos
• Set DoTensorNeutrinos=T by default when called from code (e.g. for use with CosmoMC)
• Modified massive neutrino halofit parameters to be more accurate with the new halofit from Takahashi 2012 (thanks to Simeon Bird).

• Minor fix so to set NLL_num_redshifts=0 by default so transfer functions don't have to always be integrated down to z=0
• Added ./python folder with some sample plotting scripts and utilities

• Fixed issue calling CAMB programmatically, e.g. with tensors and lensing
• CAMB_GetCls function in camb.f90 now returns total lensed C_l if DoLensing is true (rather than always unlensed)
• Code fixes that do not affect results unless code is modified

• Fix to equations_ppf for w/=-1 models; corrected source output fixes C_L error at very low L (<2% for w>-0.8, more for w<-0.8). (thanks David Rapetti and Matteo Cataneo)
• Updated writefits.f90 consistently

• Modified more general neutrino mass input specification: share_delta_neff and massive_neutrinos now integer array. See section the CAMB notes for detailed documentation and examples.
• Changes to support non-linear CMB lensing and non-linear matter power (do_nonlinear = 3); (thanks Jason Dossett)
• Replaced numerical recipes functions with internal fortran or new versions (thanks Martin Reinecke)
• Fixed memory issue for CosmoMC compatibility

• [31 July] fixed compatibility with gfortran
• Improved speed and accuracy of lensed CMB calculation at L>5000 (tweaks to correlation function apodization, etc.)
• More accurate Limber approximation for lensing potential (arXiv:0809.5112); result much more stable around Limber switch scale
• A few internal changes for greater consistency with CAMB sources
• Updated high-L template file for Planck parameters, non-linear lensing and higher L

• Fix numerical accuracy for larger neutrino masses and bug in and non-linear lensing calculation in very closed models
• Read in AccuracyBoost parameters earlier so they are reflected e.g. in e.g. Transfer_SetForNonlinearLensing.
• Temperatures of massive neutrinos set from the degeneracy, e.g. 3.046, unless same_neutrino_Neff set (no degeneracies specific in .ini)
• Updated default T_CMB=2.7255 (does not change results for same input parameters)
• Derived sound horizon output parameter now uses more accurate sound speed using correct CMB temperature (power spectrum results and CosmoMC theta unchanged)
• Fixed bug calculating zstar with Feedback=0 and accurate_reionization (gave wrong results)
• Utility functions Hofz, DeltaPhysicalTimeGyr, and dsound_da_exact for getting H(z), age and the accurate sound speed

• Updated Recfast to 1.5.2 (~0.15% change in C_l from small tweaks to fudge parameters to match CosmoRec and HyRec)
• Updated Halofit model from arXiv:1208.2701 (thanks Ryuichi Takahashi)
• Calculation of various potentially useful derived parameters (if derived_parameters=T)
• Change to allow N_eff<1 to work (thanks Zhen Hou)
• Typo in approximation result in equations.f90 corrected (thanks Alex Hall; no effect on numerics)
• Switch off use_spline_template for non-adiabatic models (thanks Jo Dunkley)
• Support for compiling with and linking to CosmoRec for recombination model (make RECOMBINATION=cosmorec) and HyRec HyRec (make RECOMBINATION=hyrec)
• IniFile module updated [supports overridden and common parameters via DEFAULT(name.ini) and INCLUDE(name.ini)].

• Interpolation accuracy and speed improved by using fiducial template (set use_spline_template=F to recover previous behaviour). For summary of current accuracy performance see arXiv:1201.3654.

• Halofit changes from arXiv:1109.4416 for better accuracy on small scales (thanks to Simeon Bird)
• Added version_check to output .ini files to track CAMB version being used
• Option to export curvature alpha_l(r) and beta_l(r) [useful for local non-Gaussianity]
• Minor bug fixes that don't affect numerical results
• Example params.ini parameters changed to be consistent with CosmoMC's defaults (CMB temperature, effective number of neutrinos)

• Fixed array bounds issue for closed-model tensor calculation
• Tweaks for high_accuracy_default stability in closed models
• L sampling slightly increased (1.2 factor) at high L for high_accuracy_default
• Added global_error_flag and Errors module for handling bailout from various modules
• Updated Makefile

• Added high_accuracy_default parameter, to give target accuracy of 0.1% for 500<L<2000 rather than default of 0.3%. This is much faster than increasing the accuracy boost parameters.
• Added improved high kτ approximations from arXiv:1104.2933.
• Optimized very accurate massive neutrino evolution and perturbatively relativistic expansion (much faster, see the notes)
• Fractional numbers of neutrinos now used to increase neutrino temperature equally for all neutrinos, giving consistency for number densities of massive neutrinos
• Merged flat and non-flat derivative routines in equations.f90, time evolution restructuring and some higher-order tight coupling terms from arXiv:1012.0569.
• Various tweaks to fixed internal accuracy parameters for consistency with high_accuracy_default (very small decrease in speed)
• Added apodization in lensing.f90 so that slow full integration is now only used for lmax>=5000 rather than lmax>=3000 (or if AccurateBB is set).
• Added quick calculation of the high-L tails of the lensing convolution by rescaling a template (speeds up high-accuracy lensedCl calculation with minimal loss of accuracy).
• Removed a couple of options relating to unlensed or temperature-only calculations that are now rarely relevant

• (14 Jan) updated Makefile for gfortran compatibility and easier compilation for bispectrum fisher calculations
• Added Bispectrum module to calculate CMB lensing and local primordial non-Gaussianity bispectra for temperature and polarization (see arXiv:1101.2234). Define FISHER in the makefile to also calculate Fisher elements for the bispectra, including lensing signal variance effects (you make need to edit makefile to link to LAPACK). Corresponding new parameters in the .ini file.
• lens_potential_output_file format changed to included temperature and polarization spectra (scalar+tensor), and extra column giving [l(l+1)]^3/2C_ψE/2π - the correlation of the lensing potential with the E polarization.
• Updates for BAO calculations were in CosmoMC May 2010.

January 2010
Recfast updated to version 1.5 (rising to 2% change at l=2000; added rate fudge to match 0910.4383; use RECFAST_Hswitch = F to recover old result). Added lens_potential_output_file parameter to get sensibly normalized lensing potential ([l(l+1)]²C_l/2π and temperature correlation). Added code parameter do_bispectrum to modules.f90 for parameter tweaks to get accurate transfer functions for f_NL calculations.

February 2009
Fixed serious bug in the calculation of lensed non-flat models (introduced in the Feb 2008 version).

November 2008
Fixed proton mass error (and hence incorrect baryon evolution on pressure-damping scales; note CAMB is not as accurate as CAMB sources anyway due to use of adiabatic pressure).

September 2008
Restructured recombination module to allow use of different models. RECFAST default implementation updated to version 1.4.2 (+fixes, tiny change to results). Misc minor changes.

March 2008
(26th March, fixed pivot parameters in sample .ini)
New reionization history model: new input parameter re_delta_redshift (does not change optical depth), and option to set re_ionization_frac=-1 to automatically set the reionization fraction from input Y_He assuming Helium is singly reionized at the same time as hydrogen (hence mapping of redshift to optical depth different to before at 10% level; see the notes). Reionization history now specified in (replaceable) module in reionization.f90; default includes tiny effect of He double reionization at z~3.5. Some internal reorganization. Added pivot_scalar and pivot_tensor input parameters for initial power spectrum. output subroutine (equations.f90) re-arranged to separated ISW source terms.

February 2008
Updated RECFAST to version 1.4 (~0.5% effect at high l; new RECFAST_fudge_He,RECFAST_Heswitch parameters, removed Dubrovich modifications). lensed_total_output_file parameter to get lensed scalar plus tensor power spectrum. Calculates CosmoMC's theta parameter for each model (code in modules.f90). Modules routine MatterPowerData_Load to read in matter power (for splining from pre-computed file); MatterPowerData_k function now extrapolates low-k out of range. transfer_interp_matterpower parameter to switch between interpolated regular grid in log k or array at actual computed values (better for later re-interpolation). Added camb.vfproj Intel Visual Fortran project file. Simplifying internal changes from CAMB sources, e.g. use of Ranges module for setting time steps and k sampling values; also now switches to log k source spacing at very high l to speed up calculation where spectra smooth. More diagnostics and options in the test suite.

November 2006
Updated RECFAST to version 1.3 (0.1% effect on C_l). Tweak to get <0.3% error in matter power spectrum around the peak when transfer_high_precision = T.

September 2006
Fixed problem generating combinations of scalars and tensors in camb.f90 (since August version).

August 2006
Speeded calculation of lensed spectra and lensing power spectrum by using Limber approximation on small scales (no loss of accuracy). Fixed missing f_K in source term for non-flat lensing potential. Minor changes to default parameters and compatibility tweaks. Can download test suite for comparing accuracy and code versions.

July 2006
Fixed bug setting default neutrino degeneracy if none specified and initialization of nu_mass_eigenstates for programmatic access. Other minor fixes.

June 2006
Added support for arbitrary neutrino mass splittings. New option to set transfer_k_per_logint=0 to get automatic accurate k-sampling of the matter power spectrum. Fixed Transfer_GetMatterPower at large scales for non-flat models. New setting value massive_nu_approx=3 to use whatever method is good to get fast accurate results. Other internal changes.

March 2006
Fixed bug lensing scalar spectrum when generated at the same time as tensors. New (hard coded) parameter lmin in modules.f90 - set to 1 if you want to generate temperature and lensing potential l=1 (Newtonian Gauge) C_l.

April 2005
Added do_nonlinear option to apply non-linear corrections from HALOFIT (astro-ph/0207664). do_nonlinear = 1 applies just to the matter power spectra, do_nonlinear=2 applies corrections to the lensed CMB power spectra (important for BB). HALOFIT should only be used for standard adiabatic ΛCDM models with power law initial power spectra. New recombination option (1 does RECFAST as before, 2 uses modified version from astro-ph/0501672). New option do_late_rad_trunction to turn off the small scale radiation hierarchies after matter domination (see astro-ph/0503277 and the notes) - saves some time. New output_root option to prefix output file names and generate output_root_params.ini file of input parameters for the run.

November 2004
Default lensing routine (lensing_method=1) changed to use new full-sky correlation function method (astro-ph/0502425) in preference to the harmonic method of astro-ph/0001303 (lensing_method=3; inaccurate at l>1000 at ~1.5% level by l=2000). The lensed result is now significantly faster and more accurate. Also added flat-sky method (lensing_method=2) of astro-ph/9505109 and astro-ph/9803150 as in CMBFAST (accurate to 0.4%). New accurate_BB parameter to get lensed BB accurately (within assumptions of linearity and given k_max, l_max, etc.). Note lensed_output_file no longer contains any tensor contribution. Various changes for better accuracy and compiler compatibility, including same accuracy with massive neutrinos as with massless.

August 2004
Fixed effect of reionization on the lensed C_l (0.5% on small scale TT).

Fixed serious problem with tensor mode polarized C_l from reionization (significantly underestimated power). Changed default tensor pivot scale to 0.05 Mpc^-1 (same as for scalars). Flat Bessel functions no longer cached to disk (faster to compute than read in many cases; prevents problems in uses with MPI). New accurate_reionization flag for accurate calculation of large scale scalar EE around the first dip (also outputs computed optical depth due to reionization). Option to output vector mode spectra from regular vorticity mode (astro-ph/0403583) or magnetic field (astro-ph/0406096).

Improved accuracy of non-flat calculation, and allowed for very nearly flat models (Ω_K ~ 1e-5). Non-flat code should be as accurate as the flat (0.5%) on most scales. Added run-time parameters do_tensor_neutrinos (to include the neutrino evolution in the tensor equations) and cs2_lam (constant sound speed of the dark energy) instead of having to modify the code. Fixed fatal bug in tensor neutrino setup introduced some time this year. Added parameter CMB_outputscale to scale output Cls by a constant (see comments in params.ini for getting microK^2 output).

Fixed instability in bessels.f90 which gave problem for very nearly flat closed models with abnormal Helium fractions (and possibly other models). Dark energy equations in equations.f90 changed to use simpler general fluid equations for the perturbations (see astro-ph/0307104). inidriver.F90 now reads in scalar amplitude even if computing tensors only (so combination with the initial ratio sets correct tensor amplitude).

Fixed bug in equations.f90 giving errors with non-flat models. Fixed bug in inidriver.F90 setting H₀ with use_physical=F. Fixed camb.f90 file in download - missing routines for getting C_l transfer functions.

Some major restructuring, including new functions to return the CMB transfer functions (see camb.f90). The tight coupling code has been re-written, adding quadrupole terms and accounting for the time variation of the opacity numerically. The code should be more accurate and faster, especially on small scales. Minor fixes to RECFAST to match version in CMBFAST (0.01% effect on C_ls), and bug fix in output routine (0.3%). Includes constant w dark energy and running spectral index parameters by default (rather than with an add-on). New use_physical parameter to allow alternative model specification by Om_b h^2, Om_b h^2 and Om_k. Polarization .fits files now compatible with HEALPIX 1.2.

Minor changes for greater compiler compatibility, in particular with Visual Fortran. Makefile includes suggested options for a variety of compilers.

Added support for neutrino isocurvature initial conditions, and totally correlated mixed initial conditions (assuming the same power spectrum for each mode) - new initial_vector parameter in params.ini. Partially correlated mixed initial conditions can be computed by combining results from different runs with totally correlated initial conditions.

Changes for compatibility with CosmoMC. New option to output matter power spectrum. Changed default pivot point for tensor initial power spectrum to 0.002 MPc^-1 (power_tilt.f90), added pivot point and normalization to initial power parameters. Minor enhancements to inifile.f90. Utility routines Re_OpticalDepthAtZ and Transfer_GetMatterPower added to modules.f90.

Massive neutrino support improved. Background evolution is much faster, and only ever needs to be computed once for all neutrino masses. Output transfer function files now include columns for the massive neutrino and total perturbations. Sigma_8 is now computed including CDM, baryons and massive neutrinos. Fixed problem computing matter power spectrum in massive neutrino models. New parameter massive_nu_approx to control how the massive neutrinos are evolved - option for new approximate fast scheme that is quite accurate for the CMB. New feedback_level parameter that can be used to get useful information about the model being calculated.
Fixed rare problem computing closed models, and bug in computation of closed transfer functions. The names of the massive neutrino subroutines have been changed because the argument that is passed has changed.

Fixed FITS file output to start at l=0 rather than l=2 to be consistent with HEALPIX.

The code is now fully internally parallelized and lensing is supported. Can now use about 16 processors with good efficiency - just compile with the OpenMP -mp compiler flag. The lensing power spectrum is computed explicitly and then used to computed the lensed CMB power spectra using the full-sky results of astro-ph/0001303 (many thanks for Gayoung Chon for work on the lensed power spectrum code). To generate the lensed power spectra set do_lensing=T in params.ini and the output will be in the lensed_output_file. The lensing power spectrum l⁴ C_l^φφ is also output as the 5th column of the scalar_output_file, followed by the cross-correlation with the temperature l³ C_l^φT.

Fixed bug in RECFAST - corrects C_l errors at 1-2% level. Background evolution is now determined from routines in gauge_inv.f90 (and gauge_sync.f90) - you now only need to edit these files to add additional matter components, use extended theories, etc. RECFAST now consistent with massive neutrinos. Added Makefile for better compilation, and added option to create FITS format power spectrum files. Changed driver.f90 to driver.F90, and new file writefits.f90. Some minor changes to ease use with a wider range of compilers (e.g. NaG F95 for Linux).

May 2001

Fixed the neutrino ratio factor in the normalization of the scalar power spectrum to be consistent with the power spectrum as defined since the January 2001 version. Changes to gauge_inv.f90 and gauge_sync.f90.

April 2001

New example code. These samples show how you can call CAMB from other programs via a subroutine. There are also improved InitialPower modules for parameterizing the initial power spectrum to obtain meaningful tensor/scalar ratios for general models and for parameterizing in terms of slow-roll inflation parameters.

Fixed a floating error arising when both tensor and scalar spectra are generated but with ratio zero.

February 2001

Fixed bug in recfast.f90 introduced in August 2000 update (caused erroneous blip in ionization history).

January 2001

New file power.f90 added to separate out the InitialPower module for easily modifying the initial power spectrum. The InitialPower module now has additional parameters to control the normalization of the output Cls, allowing absolute computations using correctly normalized initial power spectra (set the UseScalTensRatio parameter to false to compute the tensor/scalar ratio correctly from the initial power spectra in general models). The InitialPower module is now commented to fully explain the definition of the power spectra that should be returned by the TensorPower and ScalarPower routines.

The transfer functions are now output in terms of k rather than beta (nu*K) in non-flat models, and the way to compute the matter power spectrum from the transfer functions via d2norm is documented. The variables used to propagate the tensor modes in gauge_inv.f90 have been changed to be equivalent to the metric variables, improving stability when DoTensorNeutrinos=true.

September 2000

Now uses an accurate approximation to propagate massive neutrino perturbations once no longer highly relativistic, speeding up computation by about a factor of two (gauge_inv routine only). All massive neutrino code is now re-organized into a module called MassiveNu in modules.f90. The massive neutrino equations are described in astro-ph/0203507

August 2000

Minor changes to recfast.f90 and modules.f90 to prevent floating point errors on some systems. (Thanks for Louise Griffiths)

July 2000

Fixes inaccurate computation of the tensor quadrupole in flat models, pointed out in astro-ph/0006392 . The only code change is to subroutine TensSourceSumIntJl in cmbmain.f90.

February 2000

Massive neutrinos are now supported. The treatment is essentially the same as CMBFAST. However gauge_inv now includes neutrino anisotropic stress in the tensor computation by default, accounting for massive neutrinos when appropriate. You can revert to the old default by changing the "DoTensorNeutrinos" parameter in gauge_inv.

This version also fixes the tight coupling switch over to give accurate results with gauge_sync. This fixes errors introduced in CMBFAST 3.0/CAMB Nov 99.

November 1999

Adds support for RECFAST recombination and fixes various bugs that were in CMBFAST 2.4.1 but fixed in CMBFAST 3.0. RECFAST is an option via the fifth line in the input file as in CMBFAST. Using it does not slow things down significantly and corrects errors at around the 2% level.

Add-ons, extensions, external sites

• MGCAMB
• EFTCAMB

Some notes and relevant Maple derivations are given here (see also the Appendix of astro-ph/0406096). The CAMB notes outline the equations and approximations used, and relation to standard synchronous-gauge and Newtonian-gauge variables; see also arXiv:1201.3654. There is a BibTex file of references (including CosmoMC).

CMB power spectrum parameter degeneracies in the era of precision cosmology
Cullan Howlett, Antony Lewis, Alex Hall, Anthony Challinor arXiv:1201.3654.

Efficient computation of CMB anisotropies in closed FRW Models
Antony Lewis, Anthony Challinor and Anthony Lasenby astro-ph/9911177 Ap. J. 538:473-476, 2000.

Geometric Algebra and Covariant Methods in Physics and Cosmology, Chapters 6&7
PhD thesis, Antony Lewis 2000. PostScript.

Covariant theory

Cosmic Microwave Background Anisotropies in the CDM model: A Covariant and Gauge-Invariant Approach
Anthony Challinor and Anthony Lasenby, astro-ph/9804301 Ap. J. 513:1 1-22, 1999

Evolution of cosmological dark matter perturbations
Antony Lewis and Anthony Challinor astro-ph/0203507 Phys. Rev. D66, 023531 (2002)

Microwave background anisotropies from gravitational waves: the 1+3 covariant approach
Anthony Challinor, astro-ph/9906474

Microwave background polarization in cosmological models
Anthony Challinor, astro-ph/9911481

CMB anisotropies from primordial inhomogeneous magnetic fields
Antony Lewis, astro-ph/0406096
(The appendix contains general derivations of the multipole equations and C_l as used in CAMB)

Initial conditions

The General Primordial Cosmic Perturbation
Martin Bucher, Kavilan Moodley and Neil Turok, astro-ph/9904231 (These results extended to the non-flat case; see the theory page)

Observable primordial vector modes
Antony Lewis, astro-ph/0403583

HALOFIT

Stable clustering, the halo model and nonlinear cosmological power spectra
Smith, R. E. and others, astro-ph/0207664.

Revising the Halofit Model for the Nonlinear Matter Power Spectrum
Ryuichi Takahashi and others, arXiv:1208.2701.

RECOMBINATION

A new calculation of the recombination epoch.
Seager, S., Sasselov, D. & Scott, D., 1999, ApJ, 523, L1, astro-ph/9909275.

How well do we understand cosmological recombination?
Wong, Wan Yan and Moss, Adam and Scott, Douglas, arXiv:0711.1357.

Weak lensing of the CMB

lensing_method=1
Lensed CMB power spectra from all-sky correlation functions
A. Challinor and A. Lewis. astro-ph/0502425. (For Maple derivations see the theory page.)
Also: Weak Lensing of the CMB, astro-ph/0601594.

lensing_method=2
Gravitational lensing effect on cosmic microwave background anisotropies: A Power spectrum approach
Uros Seljak. astro-ph/9505109

Gravitational Lensing Effect on Cosmic Microwave Background Polarization
Uros Seljak and Matias Zaldarriaga. astro-ph/9803150

lensing_method=3
Weak Lensing of the CMB: A Harmonic Approach
Wayne Hu. astro-ph/0001303
See also astro-ph/0301064, astro-ph/0301031

The shape of the CMB lensing bispectrum
Antony Lewis, Anthony Challinor and Duncan Hanson arXiv:1101.2234

The Cosmic Linear Anisotropy Solving System (CLASS) II: Approximation schemes
Blas, Diego and Lesgourgues, Julien and Tram, Thomas. arXiv:1104.2933

CMB power spectrum parameter degeneracies in the era of precision cosmology
Cullan Howlett, Antony Lewis, Alex Hall, Anthony Challinor. arXiv:1201.3654 JCAP 04(2012)027

Evolution of cosmological dark matter perturbations
Antony Lewis and Anthony Challinor astro-ph/0203507 Phys. Rev. D66, 023531 (2002)

Synchronous gauge theory and non-flat models

Complete treatment of CMB anisotropies in a FRW universe
Wayne Hu, Uros Seljak and Matias Zaldarriaga. Phys. Rev. D57:6, 3290-3301, 1998. astro-ph/9709066.

WKB approx to hyperspherical Bessel functions

Efficient Computation of Hyperspherical Bessel Functions
Arthur Kosowsky, astro-ph/9805173

CMBFAST and the line of sight approach

A line of sight integration approach to Cosmic Microwave Background Anisotropies
Uros Seljak and Matias Zaldarriaga, astro-ph/9603033 Ap.J. 469:2 437-444, 1996

Integral solution for the microwave background anisotropies in nonflat universes
Matias Zaldarriaga, Uros Seljak, Edmund Bertschinger. ApJ. 494:491-501, 1998. astro-ph/9704265.

CMBFAST for spatially closed universes
Uros Seljak and Matias Zaldariaga, astro-ph/9911219