Support for external non-linear P(k) ratio in lensing calculations

[adammoss]

Motivation:

For non-standard dark matter models, the built-in Halofit/HMcode fitting functions do not accurately capture the non-linear matter power spectrum. Dedicated codes exist for these cosmologies, but there is currently no way to feed their predictions into CAMB for lensed CMB calculations.

Adding support for an external non-linear ratio R(k,z) = sqrt(P_NL/P_L) would enable:

• Accurate lensed CMB power spectra for non-standard DM models
• Flexibility to use any external non-linear P(k) code

Proposed interface:

results = camb.CAMBdata()
results.set_nonlin_ratio(k_h, z_array, ratio_array) # ratio = sqrt(P_NL/P_L)
results.calc_power_spectra(params)
cls_lensed = results.get_lensed_scalar_cls(lmax=lmax)

The ratio array would be interpolated internally and used in place of the Halofit calculation when computing the lensing potential.

Disavantages:

May require 2 passes over running CAMB (the first pass to obtain the linear P(k).

Use case:

I have implemented this in a fork (AxiCAMB) for ultralight axion studies with axionHMcode. Happy to contribute the implementation if there is interest.

[cmbant]

It's a good point and something that's been on the list to think about for a while., e.g. so Cobaya can be used consistently with non-linear model in CCL, taking linear spectrum from CAMB and lensed spectra with consistent non-linearities from CAMB. Do you have this working with Cobaya? Certainly would not want to call CAMB transfer calculation twice, so ideally should be able to make CAMB depend on an external non-linear model, which in turn can get just linear power from CAMB, with CAMB calling the external model before it calculates non-linear spectra. The cobaya split into transfer and powers does allow calling the former separately, though currently there is no way to use an external nonlinear model.

[cmbant]

For reference: for non-linear lensing Cobaya's CambTransfers calculates time transfer separately, then camb uses TimeSourcesToCl. This calls MakeNonlinearSources (which calls Transfer_GetMatterPowerData and then NonLinearModel%GetNonLinRatios), and then it calculates CL transfers and CL using the scaled CL transfer functions.

(The CAMB-aligned way to do this is to implement a new NonLinear class that gets the ratio for the models of interest.)

[adammoss]

Hi @cmbant apologies for the delay working this through. Here is the status of the current implementation:

New Fortran module fortran/ExternalNonLinearRatio.f90:

• TExternalNonLinearRatio extends TNonLinearModel
• Stores a TInterpGrid2D ratio grid and a ratio_set flag
• SetRatio(nk, nz, k_h, z, ratio) — stores the sqrt(P_NL/P_L) grid
• ClearRatio() — releases interpolation data
• GetNonLinRatios — fills CAMB_Pk%nonlin_ratio from the interpolator
• GetNonLinRatios_All — error stop (no velocity corrections)

Python class in camb/nonlinear.py:

• Uses methods mechanism to call the Fortran type-bound procedures
• set_ratio(k_h, z, ratio) and clear_ratio() convenience methods

Usage

results = camb.get_transfer_functions(params, only_time_sources=True)

Apply Halofit

results.Params.NonLinear = camb.model.NonLinear_lens
results.Params.NonLinearModel = Halofit()
results.calc_power_spectra()
cls_halofit = results.get_lensed_scalar_cls(lmax=lmax)

Swap to external ratio

results.Params.NonLinearModel = ExternalNonLinearRatio()
results.Params.NonLinearModel.set_ratio(k_h, z, ratio)
results.calc_power_spectra()
cls_external = results.get_lensed_scalar_cls(lmax=lmax)

Is this along the lines of what you suggested?

[cmbant]

Thanks, I guess so, if the GetNonLinRatios is modified in Fortran to use the parameters/linear power spectrum as needed rather than pre-setting the grid. For using set_ratio from python, we still have the CAMB structural problem that it is not very easy/efficient to get the linear power spectrum (or indeed cosmological parameters) if needed for the non-linear ratio before set_ratio is called.

[adammoss]

Thanks Antony, am I correct in thinking that

1. get_transfer_functions(params, only_time_sources=True) — single Boltzmann solve
2. Extract linear P(k,z), compute external ratio with axionHMcode
3. Swap to ExternalNonLinearRatio, calc_power_spectra() — reuses cached time sources using MakeNonlinearSources → TimeSourcesToCl

is fairly efficient? Or is there still a better way of doing things e.g. a callback mechanism or something? The issue is have with axionHMcode is I have their python code in the middle of this process.

[cmbant]

Yes, it doesn't have to recompute time sources, and certainly not bad if you just get the linear Pk yourself, but you do have to know the primordial power spectrum parameters.

More problematic in cobaya where currently no structure to do this/get just linear Pk (wonder if one could do this by supporting an external ratio requirement [like external_primordial_pk], then one could implement an external Theory class that requests CAMB_transfers and power parameters, gets linear Pk itself, and returns the ratio in time for use by calc_power_spectra).

[cmbant]

I sketched a PR of what this might look like in Cobaya: CobayaSampler/cobaya#480

[adammoss]

Implemented in #191