CLASS (classy)

Synopsis:Managing the CLASS cosmological code
Author:Jesus Torrado (import and get_Cl based on MontePython’s CLASS wrapper Benjamin Audren)

This module imports and manages the CLASS cosmological code.


If you use this cosmological code, please cite it as:
D. Blas, J. Lesgourgues, T. Tram, The Cosmic Linear Anisotropy Solving System (CLASS). Part II: Approximation schemes (arXiv:1104.2933)


CLASS is renamed classy for most purposes within cobaya, due to CLASS’s name being a python keyword.


If you are using a likelihood that requires some observable from CLASS, simply add classy to the theory block.

You can specify any parameter that CLASS understands in the params block:

      [any param that CLASS understands]

    [any param that CLASS understands, fixed, sampled or derived]

If you want to use your own version of CLASS, you need to specify its location with a path option inside the classy block. If you do not specify a path, CLASS will be loaded from the automatic-install packages_path folder, if specified, or otherwise imported as a globally-installed Python package. Cobaya will print at initialisation where it is getting CLASS from.

Modifying CLASS

If you modify CLASS and add new variables, make sure that the variables you create are exposed in the Python interface (instructions here). If you follow those instructions you do not need to make any additional modification in Cobaya.

You can use the model wrapper to test your modification by evaluating observables or getting derived quantities at known points in the parameter space (set debug: True to get more detailed information of what exactly is passed to CLASS).

In your CLASS modification, remember that you can raise a CosmoComputationError whenever the computation of any observable would fail, but you do not expect that observable to be compatible with the data (e.g. at the fringes of the parameter space). Whenever such an error is raised during sampling, the likelihood is assumed to be zero, and the run is not interrupted.



If the installation folder of CLASS is moved, due to CLASS hard-coding some folders, CLASS needs to be recompiled, either manually or by deleting the CLASS installation and repeating the cobaya-install command in the renamed packages folder.

If you do not recompile CLASS, it causes a memory leak (thanks to Stefan Heimersheim).

Automatic installation

If you do not plan to modify CLASS, the easiest way to install it is using the automatic installation script. Just make sure that theory: classy: appears in one of the files passed as arguments to the installation script.

Manual installation (or using your own version)

If you are planning to modify CLASS or use an already modified version, you should not use the automatic installation script. Use the method below instead.

CLASS’s python interface utilizes the cython compiler. If typing cython in the shell produces an error, install it with python -m pip install cython.


The fast way, assuming you are installing all your cosmological codes under /path/to/cosmo/:

$ cd /path/to/cosmo/
$ git clone
$ mv class_public CLASS
$ cd CLASS
$ make

If the second line produces an error (because you don’t have git installed), try

$ cd /path/to/cosmo/
$ wget
$ unzip
$ rm
$ mv class_public-master CLASS
$ cd CLASS
$ make

If the instructions above failed, follow those in the official CLASS web page to get CLASS compiled with the Python interface ready.

classy class

class theories.classy.classy(info: Mapping[str, Any] = mappingproxy({}), name: Optional[str] = None, timing: Optional[bool] = None, packages_path: Optional[str] = None, initialize=True, standalone=True)

CLASS cosmological Boltzmann code cite{Blas:2011rf}.


Importing CLASS from the correct path, if given, and if not, globally.


Sets some common settings for both lensend and unlensed Cl’s.


Specifies the quantities that this Boltzmann code is requested to compute.

Typical requisites in Cosmology (as keywords, case insensitive):

  • Cl={...}: CMB lensed power spectra, as a dictionary {[spectrum]: l_max}, where the possible spectra are combinations of "t", "e", "b" and "p" (lensing potential). Get with get_Cl().
  • unlensed_Cl={...}: CMB unlensed power spectra, as a dictionary {[spectrum]: l_max}, where the possible spectra are combinations of "t", "e", "b". Get with get_unlensed_Cl().
  • [BETA: CAMB only; notation may change!] source_Cl={...}: \(C_\ell\) of given sources with given windows, e.g.: source_name: {"function": "spline"|"gaussian", [source_args]; for now, [source_args] follows the notation of CAMBSources. If can also take "lmax": [int], "limber": True if Limber approximation desired, and "non_linear": True if non-linear contributions requested. Get with get_source_Cl().
  • Pk_interpolator={...}: Matter power spectrum interpolator in \((z, k)\). Takes "z": [list_of_evaluated_redshifts], "k_max": [k_max], "extrap_kmax": [max_k_max_extrapolated], "nonlinear": [True|False], "vars_pairs": [["delta_tot", "delta_tot"], ["Weyl", "Weyl"], [...]]}. Non-linear contributions are included by default. Note that the non-linear setting determines whether non-linear corrections are calculated; the get_Pk_interpolator() method also has a non-linear argument to specify if you want the linear or non-linear spectrum returned (to have both linear and non-linear spectra available request a tuple (False,True) for the non-linear argument). All \(k\) values should be in units of \(1/\mathrm{Mpc}\).
  • Pk_grid={...}: similar to Pk_interpolator except that rather than returning a bicubic spline object it returns the raw power spectrum grid as a (k, z, P(z,k)) set of arrays. Get with get_Pk_grid().
  • sigma_R={...}: RMS linear fluctuation in spheres of radius \(R\) at redshifts \(z\). Takes "z": [list_of_evaluated_redshifts], "k_max": [k_max], "vars_pairs": [["delta_tot", "delta_tot"],  [...]]}, "R": [list_of_evaluated_R]. Note that \(R\) is in \(\mathrm{Mpc}\), not \(h^{-1}\,\mathrm{Mpc}\). Get with get_sigma_R().
  • Hubble={'z': [z_1, ...]}: Hubble rate at the requested redshifts. Get it with get_Hubble().
  • angular_diameter_distance={'z': [z_1, ...]}: Physical angular diameter distance to the redshifts requested. Get it with get_angular_diameter_distance().
  • comoving_radial_distance={'z': [z_1, ...]}: Comoving radial distance from us to the redshifts requested. Get it with get_comoving_radial_distance().
  • sigma8_z={'z': [z_1, ...]}: Amplitude of rms fluctuations \(\sigma_8\) at the redshifts requested. Get it with get_sigma8().
  • fsigma8={'z': [z_1, ...]}: Structure growth rate \(f\sigma_8\) at the redshifts requested. Get it with get_fsigma8().
  • k_max=[...]: Fixes the maximum comoving wavenumber considered.
  • Other derived parameters that are not included in the input but whose value the likelihood may need.
add_P_k_max(k_max, units)

Unifies treatment of \(k_\mathrm{max}\) for matter power spectrum: P_k_max_[1|h]/Mpc].

Make units="1/Mpc"|"h/Mpc".

calculate(state, want_derived=True, **params_values_dict)

Do the actual calculation and store results in state dict

  • state – dictionary to store results
  • want_derived – whether to set state[‘derived’] derived parameters
  • params_values_dict – parameter values

None or True if success, False for fail

get_Cl(ell_factor=False, units='FIRASmuK2')

Returns a dictionary of lensed CMB power spectra and the lensing potential pp power spectrum.

Set the units with the keyword units=number|'muK2'|'K2'|'FIRASmuK2'|'FIRASK2'. The default is FIRASmuK2, which returns CMB \(C_\ell\)’s in FIRAS-calibrated \(\mu K^2\), i.e. scaled by a fixed factor of \((2.7255\cdot 10^6)^2\) (except for the lensing potential power spectrum, which is always unitless). The muK2 and K2 options use the model’s CMB temperature.

If ell_factor=True (default: False), multiplies the spectra by \(\ell(\ell+1)/(2\pi)\) (or by \(\ell^2(\ell+1)^2/(2\pi)\) in the case of the lensing potential pp spectrum).

get_unlensed_Cl(ell_factor=False, units='FIRASmuK2')

Returns a dictionary of unlensed CMB power spectra.

For units options, see get_Cl().

If ell_factor=True (default: False), multiplies the spectra by \(\ell(\ell+1)/(2\pi)\).


Finalizes the class, if something needs to be cleaned up.


Get a list of derived parameters that this component can calculate. The default implementation returns the result based on the params attribute set via the .yaml file or class params (with derived:True for derived parameters).

Returns:iterable of parameter names

Get a list of parameters supported by this component, can be used to support parameters that don’t explicitly appear in the .yaml or class params attribute or are otherwise explicitly supported (e.g. via requirements)

Returns:iterable of names of parameters

Get version information for this component.

Returns:string or dict of values or None