def testPowers(self):
pars = camb.CAMBparams()
pars.set_cosmology(H0=67.5, ombh2=0.022, omch2=0.122, mnu=0.07, omk=0)
pars.set_dark_energy() # re-set defaults
pars.InitPower.set_params(ns=0.965, As=2e-9)
self.assertAlmostEqual(pars.scalar_power(1), 1.801e-9, 4)
self.assertAlmostEqual(pars.scalar_power([1, 1.5])[0], 1.801e-9, 4)
pars.set_matter_power(redshifts=[0., 0.17, 3.1])
pars.NonLinear = model.NonLinear_none
data = camb.get_results(pars)
kh, z, pk = data.get_matter_power_spectrum(1e-4, 1, 20)
kh2, z2, pk2 = data.get_linear_matter_power_spectrum()
s8 = data.get_sigma8()
self.assertAlmostEqual(s8[0], 0.24686, 4)
self.assertAlmostEqual(s8[2], 0.80044, 4)
pars.NonLinear = model.NonLinear_both
data.calc_power_spectra(pars)
kh3, z3, pk3 = data.get_matter_power_spectrum(1e-4, 1, 20)
self.assertAlmostEqual(pk[-1][-3], 51.909, 2)
self.assertAlmostEqual(pk3[-1][-3], 57.697, 2)
self.assertAlmostEqual(pk2[-2][-4], 53.47, 2)
camb.set_feedback_level(0)
cls = data.get_cmb_power_spectra(pars)
cls_tot = data.get_total_cls(2000)
cls_scal = data.get_unlensed_scalar_cls(2000)
cls_tensor = data.get_tensor_cls(2000)
cls_lensed = data.get_lensed_scalar_cls(2000)
cls_phi = data.get_lens_potential_cls(2000)
PKnonlin = camb.get_matter_power_interpolator(pars, nonlinear=True)
pars.set_matter_power(
redshifts=[0, 0.09, 0.15, 0.42, 0.76, 1.5, 2.3, 5.5, 8.9],
kmax=10,
k_per_logint=5)
pars.NonLinear = model.NonLinear_both
results = camb.get_results(pars)
kh, z, pk = results.get_nonlinear_matter_power_spectrum()
pk_interp = PKnonlin.P(z, kh)
self.assertTrue(np.sum((pk / pk_interp - 1)**2) < 0.005)
camb.set_halofit_version('mead')
_, _, pk = results.get_nonlinear_matter_power_spectrum(
params=pars, var1='delta_cdm', var2='delta_cdm')
self.assertAlmostEqual(pk[0][160], 232.08, 1)
def testPowers(self):
pars = camb.CAMBparams()
pars.set_cosmology(H0=67.5, ombh2=0.022, omch2=0.122, mnu=0.07, omk=0)
pars.set_dark_energy() # re-set defaults
pars.InitPower.set_params(ns=0.965, As=2e-9)
self.assertAlmostEqual(pars.scalar_power(1), 1.801e-9, 4)
self.assertAlmostEqual(pars.scalar_power([1, 1.5])[0], 1.801e-9, 4)
pars.set_matter_power(redshifts=[0., 0.17, 3.1])
pars.NonLinear = model.NonLinear_none
data = camb.get_results(pars)
kh, z, pk = data.get_matter_power_spectrum(1e-4, 1, 20)
kh2, z2, pk2 = data.get_linear_matter_power_spectrum()
s8 = data.get_sigma8()
self.assertAlmostEqual(s8[0], 0.24686, 4)
self.assertAlmostEqual(s8[2], 0.80044, 4)
pars.NonLinear = model.NonLinear_both
data.calc_power_spectra(pars)
kh3, z3, pk3 = data.get_matter_power_spectrum(1e-4, 1, 20)
self.assertAlmostEqual(pk[-1][-3], 51.909, 2)
self.assertAlmostEqual(pk3[-1][-3], 57.697, 2)
self.assertAlmostEqual(pk2[-2][-4], 53.47, 2)
camb.set_feedback_level(0)
cls = data.get_cmb_power_spectra(pars)
cls_tot = data.get_total_cls(2000)
cls_scal = data.get_unlensed_scalar_cls(2000)
cls_tensor = data.get_tensor_cls(2000)
cls_lensed = data.get_lensed_scalar_cls(2000)
cls_phi = data.get_lens_potential_cls(2000)
PKnonlin = camb.get_matter_power_interpolator(pars, nonlinear=True)
pars.set_matter_power(redshifts=[0, 0.09, 0.15, 0.42, 0.76, 1.5, 2.3, 5.5, 8.9], kmax=10, k_per_logint=5)
pars.NonLinear = model.NonLinear_both
results = camb.get_results(pars)
kh, z, pk = results.get_nonlinear_matter_power_spectrum()
pk_interp = PKnonlin.P(z, kh)
self.assertTrue(np.sum((pk / pk_interp - 1) ** 2) < 0.005)
camb.set_halofit_version('mead')
_, _, pk = results.get_nonlinear_matter_power_spectrum(params=pars, var1='delta_cdm', var2='delta_cdm')
self.assertAlmostEqual(pk[0][160], 232.08,1)
def testPowers(self):
pars = camb.CAMBparams()
pars.set_cosmology(H0=67.5, ombh2=0.022, omch2=0.122, mnu=0.07, omk=0)
pars.set_dark_energy() # re-set defaults
pars.InitPower.set_params(ns=0.965, As=2e-9)
self.assertAlmostEqual(pars.scalar_power(1), 1.801e-9, 4)
self.assertAlmostEqual(pars.scalar_power([1, 1.5])[0], 1.801e-9, 4)
pars.set_matter_power(redshifts=[0., 0.17, 3.1])
pars.NonLinear = model.NonLinear_none
data = camb.get_results(pars)
# transfer = data.get_cmb_transfer_data()
kh, z, pk = data.get_matter_power_spectrum(1e-4, 1, 20)
kh2, z2, pk2 = data.get_linear_matter_power_spectrum()
s8 = data.get_sigma8()
self.assertAlmostEqual(s8[0], 0.247, 3)
pars.NonLinear = model.NonLinear_both
data.calc_power_spectra(pars)
kh3, z3, pk3 = data.get_matter_power_spectrum(1e-4, 1, 20)
self.assertAlmostEqual(pk[-1][-3], 51.909, 2)
self.assertAlmostEqual(pk3[-1][-3], 57.697, 2)
self.assertAlmostEqual(pk2[-2][-4], 53.47, 2)
camb.set_feedback_level(0)
cls = data.get_cmb_power_spectra(pars)
cls_tot = data.get_total_cls(2000)
cls_scal = data.get_unlensed_scalar_cls(2000)
cls_tensor = data.get_tensor_cls(2000)
cls_lensed = data.get_lensed_scalar_cls(2000)
cls_phi = data.get_lens_potential_cls(2000)
def testPowers(self):
pars = camb.CAMBparams()
pars.set_cosmology(H0=67.5, ombh2=0.022, omch2=0.122, mnu=0.07, omk=0)
pars.set_dark_energy() # re-set defaults
pars.InitPower.set_params(ns=0.965, As=2e-9)
self.assertAlmostEqual(pars.scalar_power(1), 1.801e-9, 4)
self.assertAlmostEqual(pars.scalar_power([1, 1.5])[0], 1.801e-9, 4)
pars.set_matter_power(redshifts=[0.0, 0.17, 3.1])
pars.NonLinear = model.NonLinear_none
data = camb.get_results(pars)
# transfer = data.get_cmb_transfer_data()
kh, z, pk = data.get_matter_power_spectrum(1e-4, 1, 20)
kh2, z2, pk2 = data.get_linear_matter_power_spectrum()
s8 = data.get_sigma8()
self.assertAlmostEqual(s8[0], 0.247, 3)
pars.NonLinear = model.NonLinear_both
data.calc_power_spectra(pars)
kh3, z3, pk3 = data.get_matter_power_spectrum(1e-4, 1, 20)
self.assertAlmostEqual(pk[-1][-3], 51.909, 2)
self.assertAlmostEqual(pk3[-1][-3], 57.697, 2)
self.assertAlmostEqual(pk2[-2][-4], 53.47, 2)
camb.set_feedback_level(0)
cls = data.get_cmb_power_spectra(pars)
cls_tot = data.get_total_cls(2000)
cls_scal = data.get_unlensed_scalar_cls(2000)
cls_tensor = data.get_tensor_cls(2000)
cls_lensed = data.get_lensed_scalar_cls(2000)
cls_phi = data.get_lens_potential_cls(2000)
def testPowers(self):
pars = camb.CAMBparams()
pars.set_cosmology(H0=67.5, ombh2=0.022, omch2=0.122, mnu=0.07, omk=0)
pars.set_dark_energy() # re-set defaults
pars.InitPower.set_params(ns=0.965, As=2e-9)
self.assertAlmostEqual(pars.scalar_power(1), 1.801e-9, 4)
self.assertAlmostEqual(pars.scalar_power([1, 1.5])[0], 1.801e-9, 4)
pars.set_matter_power(nonlinear=True)
self.assertEqual(pars.NonLinear, model.NonLinear_pk)
pars.set_matter_power(redshifts=[0., 0.17, 3.1], nonlinear=False)
data = camb.get_results(pars)
kh, z, pk = data.get_matter_power_spectrum(1e-4, 1, 20)
kh2, z2, pk2 = data.get_linear_matter_power_spectrum()
s8 = data.get_sigma8()
self.assertAlmostEqual(s8[0], 0.24686, 3)
self.assertAlmostEqual(s8[2], 0.80044, 3)
pars.NonLinear = model.NonLinear_both
data.calc_power_spectra(pars)
kh3, z3, pk3 = data.get_matter_power_spectrum(1e-4, 1, 20)
self.assertAlmostEqual(pk[-1][-3], 51.909, 2)
self.assertAlmostEqual(pk3[-1][-3], 57.697, 2)
self.assertAlmostEqual(pk2[-2][-4], 53.47, 2)
camb.set_feedback_level(0)
PKnonlin = camb.get_matter_power_interpolator(pars, nonlinear=True)
pars.set_matter_power(redshifts=[0, 0.09, 0.15, 0.42, 0.76, 1.5, 2.3, 5.5, 8.9], kmax=10, k_per_logint=5)
pars.NonLinear = model.NonLinear_both
results = camb.get_results(pars)
kh, z, pk = results.get_nonlinear_matter_power_spectrum()
pk_interp = PKnonlin.P(z, kh)
self.assertTrue(np.sum((pk / pk_interp - 1) ** 2) < 0.005)
camb.set_halofit_version('mead')
_, _, pk = results.get_nonlinear_matter_power_spectrum(params=pars, var1='delta_cdm', var2='delta_cdm')
self.assertAlmostEqual(pk[0][160], 824.6, delta=0.5)
lmax = 4000
pars.set_for_lmax(lmax)
cls = data.get_cmb_power_spectra(pars)
data.get_total_cls(2000)
data.get_unlensed_scalar_cls(2500)
data.get_tensor_cls(2000)
cls_lensed = data.get_lensed_scalar_cls(3000)
data.get_lens_potential_cls(2000)
# check lensed CL against python; will only agree well for high lmax as python has no extrapolation template
cls_lensed2 = correlations.lensed_cls(cls['unlensed_scalar'], cls['lens_potential'][:, 0], delta_cls=False)
self.assertTrue(np.all(np.abs(cls_lensed2[2:2000, 2] / cls_lensed[2:2000, 2] - 1) < 1e-3))
self.assertTrue(np.all(np.abs(cls_lensed2[2:3000, 0] / cls_lensed[2:3000, 0] - 1) < 1e-3))
self.assertTrue(np.all(np.abs(cls_lensed2[2:3000, 1] / cls_lensed[2:3000, 1] - 1) < 1e-3))
self.assertTrue(np.all(np.abs((cls_lensed2[2:3000, 3] - cls_lensed[2:3000, 3]) /
np.sqrt(cls_lensed2[2:3000, 0] * cls_lensed2[2:3000, 1])) < 1e-4))
corr, xvals, weights = correlations.gauss_legendre_correlation(cls['lensed_scalar'])
clout = correlations.corr2cl(corr, xvals, weights, 2500)
self.assertTrue(np.all(np.abs(clout[2:2300, 2] / cls['lensed_scalar'][2:2300, 2] - 1) < 1e-3))
def testPowers(self):
pars = camb.CAMBparams()
pars.set_cosmology(H0=67.5, ombh2=0.022, omch2=0.122, mnu=0.07, omk=0)
pars.set_dark_energy() # re-set defaults
pars.InitPower.set_params(ns=0.965, As=2e-9)
pars.NonLinearModel.set_params(halofit_version='takahashi')
self.assertAlmostEqual(pars.scalar_power(1), 1.801e-9, 4)
self.assertAlmostEqual(pars.scalar_power([1, 1.5])[0], 1.801e-9, 4)
pars.set_matter_power(nonlinear=True)
self.assertEqual(pars.NonLinear, model.NonLinear_pk)
pars.set_matter_power(redshifts=[0., 0.17, 3.1], silent=True, nonlinear=False)
data = camb.get_results(pars)
kh, z, pk = data.get_matter_power_spectrum(1e-4, 1, 20)
kh2, z2, pk2 = data.get_linear_matter_power_spectrum()
s8 = data.get_sigma8()
self.assertAlmostEqual(s8[0], 0.24686, 3)
self.assertAlmostEqual(s8[2], 0.80044, 3)
fs8 = data.get_fsigma8()
self.assertAlmostEqual(fs8[0], 0.2431, 3)
self.assertAlmostEqual(fs8[2], 0.424712, 3)
pars.NonLinear = model.NonLinear_both
data.calc_power_spectra(pars)
kh3, z3, pk3 = data.get_matter_power_spectrum(1e-4, 1, 20)
self.assertAlmostEqual(pk[-1][-3], 51.909, 2)
self.assertAlmostEqual(pk3[-1][-3], 57.709, 2)
self.assertAlmostEqual(pk2[-2][-4], 56.436, 2)
camb.set_feedback_level(0)
PKnonlin = camb.get_matter_power_interpolator(pars, nonlinear=True)
pars.set_matter_power(redshifts=[0, 0.09, 0.15, 0.42, 0.76, 1.5, 2.3, 5.5, 8.9],
silent=True, kmax=10, k_per_logint=5)
pars.NonLinear = model.NonLinear_both
results = camb.get_results(pars)
kh, z, pk = results.get_nonlinear_matter_power_spectrum()
pk_interp = PKnonlin.P(z, kh)
self.assertTrue(np.sum((pk / pk_interp - 1) ** 2) < 0.005)
PKnonlin2 = results.get_matter_power_interpolator(nonlinear=True, extrap_kmax=500)
pk_interp2 = PKnonlin2.P(z, kh)
self.assertTrue(np.sum((pk_interp / pk_interp2 - 1) ** 2) < 0.005)
pars.NonLinearModel.set_params(halofit_version='mead')
_, _, pk = results.get_nonlinear_matter_power_spectrum(params=pars, var1='delta_cdm', var2='delta_cdm')
self.assertAlmostEqual(pk[0][160], 824.6, delta=0.5)
lmax = 4000
pars.set_for_lmax(lmax)
cls = data.get_cmb_power_spectra(pars)
data.get_total_cls(2000)
data.get_unlensed_scalar_cls(2500)
data.get_tensor_cls(2000)
cls_lensed = data.get_lensed_scalar_cls(3000)
cphi = data.get_lens_potential_cls(2000)
# check lensed CL against python; will only agree well for high lmax as python has no extrapolation template
cls_lensed2 = correlations.lensed_cls(cls['unlensed_scalar'], cls['lens_potential'][:, 0], delta_cls=False)
np.testing.assert_allclose(cls_lensed2[2:2000, 2], cls_lensed[2:2000, 2], rtol=1e-3)
np.testing.assert_allclose(cls_lensed2[2:2000, 1], cls_lensed[2:2000, 1], rtol=1e-3)
np.testing.assert_allclose(cls_lensed2[2:2000, 0], cls_lensed[2:2000, 0], rtol=1e-3)
self.assertTrue(np.all(np.abs((cls_lensed2[2:3000, 3] - cls_lensed[2:3000, 3]) /
np.sqrt(cls_lensed2[2:3000, 0] * cls_lensed2[2:3000, 1])) < 1e-4))
corr, xvals, weights = correlations.gauss_legendre_correlation(cls['lensed_scalar'])
clout = correlations.corr2cl(corr, xvals, weights, 2500)
self.assertTrue(np.all(np.abs(clout[2:2300, 2] / cls['lensed_scalar'][2:2300, 2] - 1) < 1e-3))
pars = camb.CAMBparams()
pars.set_cosmology(H0=78, YHe=0.22)
pars.set_for_lmax(2000, lens_potential_accuracy=1)
pars.WantTensors = True
results = camb.get_transfer_functions(pars)
from camb import initialpower
cls = []
for r in [0, 0.2, 0.4]:
inflation_params = initialpower.InitialPowerLaw()
inflation_params.set_params(ns=0.96, r=r, nt=0)
results.power_spectra_from_transfer(inflation_params, silent=True)
cls += [results.get_total_cls(CMB_unit='muK')]
self.assertTrue(np.allclose((cls[1] - cls[0])[2:300, 2] * 2, (cls[2] - cls[0])[2:300, 2], rtol=1e-3))
# Check generating tensors and scalars together
pars = camb.CAMBparams()
pars.set_cosmology(H0=67)
lmax = 2000
pars.set_for_lmax(lmax, lens_potential_accuracy=1)
pars.InitPower.set_params(ns=0.96, r=0)
pars.WantTensors = False
results = camb.get_results(pars)
cl1 = results.get_total_cls(lmax, CMB_unit='muK')
pars.InitPower.set_params(ns=0.96, r=0.1, nt=0)
pars.WantTensors = True
results = camb.get_results(pars)
cl2 = results.get_lensed_scalar_cls(lmax, CMB_unit='muK')
ctensor2 = results.get_tensor_cls(lmax, CMB_unit='muK')
results = camb.get_transfer_functions(pars)
results.Params.InitPower.set_params(ns=1.1, r=1)
inflation_params = initialpower.InitialPowerLaw()
inflation_params.set_params(ns=0.96, r=0.05, nt=0)
results.power_spectra_from_transfer(inflation_params, silent=True)
cl3 = results.get_lensed_scalar_cls(lmax, CMB_unit='muK')
ctensor3 = results.get_tensor_cls(lmax, CMB_unit='muK')
self.assertTrue(np.allclose(ctensor2, ctensor3 * 2, rtol=1e-4))
self.assertTrue(np.allclose(cl1, cl2, rtol=1e-4))
# These are identical because all scalar spectra were identical (non-linear corrections change it otherwise)
self.assertTrue(np.allclose(cl1, cl3, rtol=1e-4))
pars = camb.CAMBparams()
pars.set_cosmology(H0=67.5, ombh2=0.022, omch2=0.122, mnu=0.07, omk=0)
pars.set_for_lmax(2500)
pars.min_l = 2
res = camb.get_results(pars)
cls = res.get_lensed_scalar_cls(2000)
pars.min_l = 1
res = camb.get_results(pars)
cls2 = res.get_lensed_scalar_cls(2000)
np.testing.assert_allclose(cls[2:, 0:2], cls2[2:, 0:2], rtol=1e-4)
self.assertAlmostEqual(cls2[1, 0], 1.30388e-10, places=13)
self.assertAlmostEqual(cls[1, 0], 0)
return False
def getnearestsnap(alist,zmid):
""" get the closest snapshot """
zsnap = 1/alist[:,1]-1.
return alist[np.argmin(np.abs(zsnap-zmid)),0]
#-------- Running camb to get comoving distances -----------
#Load all parameters from camb file
pars = camb.read_ini('params_Planck15Table4LastColumn.ini')
h = pars.h
pars.set_for_lmax(2000, lens_potential_accuracy=3)
pars.set_matter_power(redshifts=[0.], kmax=200.0)
pars.NonLinearModel.set_params(halofit_version='takahashi')
camb.set_feedback_level(level=100)
results = camb.get_results(pars)
chilow = shellwidth*(shellnum+0)
chiupp = shellwidth*(shellnum+1)
chimid = 0.5*(chilow+chiupp)
ntiles = int(np.ceil(chiupp/boxL))
print("tiling [%dx%dx%d]"%(2*ntiles,2*ntiles,2*ntiles))
zmid = results.redshift_at_comoving_radial_distance(chimid/h)
print('Generating map for halos in the range [%3.f - %.3f Mpc/h]'%(chilow,chiupp))
nearestsnap = getnearestsnap(alist,zmid)
print('The scalefactor closest to the middle of the shell is [%.6f]'%(nearestsnap))
#--------------Loading the MDPL2-UM data file------------------------
dtype = np.dtype(dtype=[('id', 'i8'),('descid','i8'),('upid','i8'),
def testPowers(self):
pars = camb.CAMBparams()
pars.set_cosmology(H0=67.5, ombh2=0.022, omch2=0.122, mnu=0.07, omk=0)
pars.set_dark_energy() # re-set defaults
pars.InitPower.set_params(ns=0.965, As=2e-9)
pars.NonLinearModel.set_params(halofit_version='takahashi')
self.assertAlmostEqual(pars.scalar_power(1), 1.801e-9, 4)
self.assertAlmostEqual(pars.scalar_power([1, 1.5])[0], 1.801e-9, 4)
pars.set_matter_power(nonlinear=True)
self.assertEqual(pars.NonLinear, model.NonLinear_pk)
pars.set_matter_power(redshifts=[0., 0.17, 3.1], silent=True, nonlinear=False)
data = camb.get_results(pars)
kh, z, pk = data.get_matter_power_spectrum(1e-4, 1, 20)
kh2, z2, pk2 = data.get_linear_matter_power_spectrum()
s8 = data.get_sigma8()
self.assertAlmostEqual(s8[0], 0.24686, 3)
self.assertAlmostEqual(s8[2], 0.80044, 3)
pars.NonLinear = model.NonLinear_both
data.calc_power_spectra(pars)
kh3, z3, pk3 = data.get_matter_power_spectrum(1e-4, 1, 20)
self.assertAlmostEqual(pk[-1][-3], 51.909, 2)
self.assertAlmostEqual(pk3[-1][-3], 57.709, 2)
self.assertAlmostEqual(pk2[-2][-4], 56.436, 2)
camb.set_feedback_level(0)
PKnonlin = camb.get_matter_power_interpolator(pars, nonlinear=True)
pars.set_matter_power(redshifts=[0, 0.09, 0.15, 0.42, 0.76, 1.5, 2.3, 5.5, 8.9],
silent=True, kmax=10, k_per_logint=5)
pars.NonLinear = model.NonLinear_both
results = camb.get_results(pars)
kh, z, pk = results.get_nonlinear_matter_power_spectrum()
pk_interp = PKnonlin.P(z, kh)
self.assertTrue(np.sum((pk / pk_interp - 1) ** 2) < 0.005)
PKnonlin2 = results.get_matter_power_interpolator(nonlinear=True, extrap_kmax=500)
pk_interp2 = PKnonlin2.P(z, kh)
self.assertTrue(np.sum((pk_interp / pk_interp2 - 1) ** 2) < 0.005)
pars.NonLinearModel.set_params(halofit_version='mead')
_, _, pk = results.get_nonlinear_matter_power_spectrum(params=pars, var1='delta_cdm', var2='delta_cdm')
self.assertAlmostEqual(pk[0][160], 824.6, delta=0.5)
lmax = 4000
pars.set_for_lmax(lmax)
cls = data.get_cmb_power_spectra(pars)
data.get_total_cls(2000)
data.get_unlensed_scalar_cls(2500)
data.get_tensor_cls(2000)
cls_lensed = data.get_lensed_scalar_cls(3000)
cphi = data.get_lens_potential_cls(2000)
# check lensed CL against python; will only agree well for high lmax as python has no extrapolation template
cls_lensed2 = correlations.lensed_cls(cls['unlensed_scalar'], cls['lens_potential'][:, 0], delta_cls=False)
np.testing.assert_allclose(cls_lensed2[2:2000, 2], cls_lensed[2:2000, 2], rtol=1e-3)
np.testing.assert_allclose(cls_lensed2[2:2000, 1], cls_lensed[2:2000, 1], rtol=1e-3)
np.testing.assert_allclose(cls_lensed2[2:2000, 0], cls_lensed[2:2000, 0], rtol=1e-3)
self.assertTrue(np.all(np.abs((cls_lensed2[2:3000, 3] - cls_lensed[2:3000, 3]) /
np.sqrt(cls_lensed2[2:3000, 0] * cls_lensed2[2:3000, 1])) < 1e-4))
corr, xvals, weights = correlations.gauss_legendre_correlation(cls['lensed_scalar'])
clout = correlations.corr2cl(corr, xvals, weights, 2500)
self.assertTrue(np.all(np.abs(clout[2:2300, 2] / cls['lensed_scalar'][2:2300, 2] - 1) < 1e-3))
pars = camb.CAMBparams()
pars.set_cosmology(H0=78, YHe=0.22)
pars.set_for_lmax(2000, lens_potential_accuracy=1)
pars.WantTensors = True
results = camb.get_transfer_functions(pars)
from camb import initialpower
cls = []
for r in [0, 0.2, 0.4]:
inflation_params = initialpower.InitialPowerLaw()
inflation_params.set_params(ns=0.96, r=r, nt=0)
results.power_spectra_from_transfer(inflation_params, silent=True)
cls += [results.get_total_cls(CMB_unit='muK')]
self.assertTrue(np.allclose((cls[1] - cls[0])[2:300, 2] * 2, (cls[2] - cls[0])[2:300, 2], rtol=1e-3))
# Check generating tensors and scalars together
pars = camb.CAMBparams()
pars.set_cosmology(H0=67)
lmax = 2000
pars.set_for_lmax(lmax, lens_potential_accuracy=1)
pars.InitPower.set_params(ns=0.96, r=0)
pars.WantTensors = False
results = camb.get_results(pars)
cl1 = results.get_total_cls(lmax, CMB_unit='muK')
pars.InitPower.set_params(ns=0.96, r=0.1, nt=0)
pars.WantTensors = True
results = camb.get_results(pars)
cl2 = results.get_lensed_scalar_cls(lmax, CMB_unit='muK')
ctensor2 = results.get_tensor_cls(lmax, CMB_unit='muK')
results = camb.get_transfer_functions(pars)
results.Params.InitPower.set_params(ns=1.1, r=1)
inflation_params = initialpower.InitialPowerLaw()
inflation_params.set_params(ns=0.96, r=0.05, nt=0)
results.power_spectra_from_transfer(inflation_params, silent=True)
cl3 = results.get_lensed_scalar_cls(lmax, CMB_unit='muK')
ctensor3 = results.get_tensor_cls(lmax, CMB_unit='muK')
self.assertTrue(np.allclose(ctensor2, ctensor3 * 2, rtol=1e-4))
self.assertTrue(np.allclose(cl1, cl2, rtol=1e-4))
# These are identical because all scalar spectra were identical (non-linear corrections change it otherwise)
self.assertTrue(np.allclose(cl1, cl3, rtol=1e-4))
pars = camb.CAMBparams()
pars.set_cosmology(H0=67.5, ombh2=0.022, omch2=0.122, mnu=0.07, omk=0)
pars.set_for_lmax(2500)
pars.min_l = 2
res = camb.get_results(pars)
cls = res.get_lensed_scalar_cls(2000)
pars.min_l = 1
res = camb.get_results(pars)
cls2 = res.get_lensed_scalar_cls(2000)
np.testing.assert_allclose(cls[2:, 0:2], cls2[2:, 0:2], rtol=1e-4)
self.assertAlmostEqual(cls2[1, 0], 1.30388e-10, places=13)
self.assertAlmostEqual(cls[1, 0], 0)
def testPowers(self):
pars = camb.CAMBparams()
pars.set_cosmology(H0=67.5, ombh2=0.022, omch2=0.122, mnu=0.07, omk=0)
pars.set_dark_energy() # re-set defaults
pars.InitPower.set_params(ns=0.965, As=2e-9)
self.assertAlmostEqual(pars.scalar_power(1), 1.801e-9, 4)
self.assertAlmostEqual(pars.scalar_power([1, 1.5])[0], 1.801e-9, 4)
pars.set_matter_power(redshifts=[0., 0.17, 3.1])
pars.NonLinear = model.NonLinear_none
data = camb.get_results(pars)
kh, z, pk = data.get_matter_power_spectrum(1e-4, 1, 20)
kh2, z2, pk2 = data.get_linear_matter_power_spectrum()
s8 = data.get_sigma8()
self.assertAlmostEqual(s8[0], 0.24686, 4)
self.assertAlmostEqual(s8[2], 0.80044, 4)
pars.NonLinear = model.NonLinear_both
data.calc_power_spectra(pars)
kh3, z3, pk3 = data.get_matter_power_spectrum(1e-4, 1, 20)
self.assertAlmostEqual(pk[-1][-3], 51.909, 2)
self.assertAlmostEqual(pk3[-1][-3], 57.697, 2)
self.assertAlmostEqual(pk2[-2][-4], 53.47, 2)
camb.set_feedback_level(0)
PKnonlin = camb.get_matter_power_interpolator(pars, nonlinear=True)
pars.set_matter_power(redshifts=[0, 0.09, 0.15, 0.42, 0.76, 1.5, 2.3, 5.5, 8.9], kmax=10, k_per_logint=5)
pars.NonLinear = model.NonLinear_both
results = camb.get_results(pars)
kh, z, pk = results.get_nonlinear_matter_power_spectrum()
pk_interp = PKnonlin.P(z, kh)
self.assertTrue(np.sum((pk / pk_interp - 1) ** 2) < 0.005)
camb.set_halofit_version('mead')
_, _, pk = results.get_nonlinear_matter_power_spectrum(params=pars, var1='delta_cdm', var2='delta_cdm')
self.assertTrue(np.abs(pk[0][160] / 232.08 - 1) < 1e-3)
lmax = 4000
pars.set_for_lmax(lmax)
cls = data.get_cmb_power_spectra(pars)
cls_tot = data.get_total_cls(2000)
cls_scal = data.get_unlensed_scalar_cls(2500)
cls_tensor = data.get_tensor_cls(2000)
cls_lensed = data.get_lensed_scalar_cls(3000)
cls_phi = data.get_lens_potential_cls(2000)
# check lensed CL against python; will only agree well for high lmax as python has no extrapolation template
cls_lensed2 = correlations.lensed_cls(cls['unlensed_scalar'], cls['lens_potential'][:, 0], delta_cls=False)
self.assertTrue(np.all(np.abs(cls_lensed2[2:2000, 2] / cls_lensed[2:2000, 2] - 1) < 1e-3))
self.assertTrue(np.all(np.abs(cls_lensed2[2:3000, 0] / cls_lensed[2:3000, 0] - 1) < 1e-3))
self.assertTrue(np.all(np.abs(cls_lensed2[2:3000, 1] / cls_lensed[2:3000, 1] - 1) < 1e-3))
self.assertTrue(np.all(np.abs((cls_lensed2[2:3000, 3] - cls_lensed[2:3000, 3]) /
np.sqrt(cls_lensed2[2:3000, 0] * cls_lensed2[2:3000, 1])) < 1e-4))
corr, xvals, weights = correlations.gauss_legendre_correlation(cls['lensed_scalar'])
clout = correlations.corr2cl(corr, xvals, weights, 2500)
self.assertTrue(np.all(np.abs(clout[2:2300, 2] / cls['lensed_scalar'][2:2300, 2] - 1) < 1e-3))
def setup(options):
M, m, v = camb.__version__.split(".")[:3]
if not int(M) > 1 and not int(m) > 0 and not int(v) > 9:
warnings.warn(
f"CAMB version < 1.0.10 (found: {camb.__version__}). Massless neutrino handling not accounted for properly."
)
mode = options.get_string(opt, 'mode', default="all")
if not mode in MODES:
raise ValueError("Unknown mode {}. Must be one of: {}".format(
mode, MODES))
config = {}
config['WantCls'] = mode in [MODE_CMB, MODE_ALL]
config['WantTransfer'] = mode in [MODE_TRANSFER, MODE_ALL]
config['WantScalars'] = True
config['WantTensors'] = options.get_bool(opt, 'do_tensors', default=False)
config['WantVectors'] = options.get_bool(opt, 'do_vectors', default=False)
config['WantDerivedParameters'] = True
config['Want_cl_2D_array'] = False
config['Want_CMB'] = config['WantCls']
config['DoLensing'] = options.get_bool(opt, 'do_lensing', default=False)
config['NonLinear'] = get_choice(
options,
'nonlinear', ['none', 'pk', 'lens', 'both'],
default='none' if mode in [MODE_BG, MODE_THERM] else 'both',
prefix='NonLinear_')
config['scalar_initial_condition'] = 'initial_' + options.get_string(
opt, 'initial', default='adiabatic')
config['want_zstar'] = mode in [MODE_THERM, MODE_CMB, MODE_ALL]
config['want_zdrag'] = config['want_zstar']
# These are parameters that we do not pass directly to CAMBparams,
# but use ourselves in some other way
more_config = {}
more_config["lmax_params"] = get_optional_params(
options,
opt,
[
"max_eta_k",
"lens_potential_accuracy",
"lens_margin",
"k_eta_fac",
"lens_k_eta_reference",
#"min_l", "max_l_tensor", "Log_lvalues", , "max_eta_k_tensor"
])
# lmax is required
more_config["lmax_params"]["lmax"] = options.get_int(opt,
"lmax",
default=2600)
more_config["initial_power_params"] = get_optional_params(
options, opt, ["pivot_scalar", "pivot_tensor"])
more_config["cosmology_params"] = get_optional_params(
options, opt, ["neutrino_hierarchy", "theta_H0_range"])
more_config['do_reionization'] = options.get_bool(opt,
'do_reionization',
default=True)
more_config['use_optical_depth'] = options.get_bool(opt,
'use_optical_depth',
default=True)
more_config["reionization_params"] = get_optional_params(
options, opt, [
"include_helium_fullreion", "tau_solve_accuracy_boost",
("tau_timestep_boost", "timestep_boost"),
("tau_max_redshift", "max_redshift")
])
more_config['use_tabulated_w'] = options.get_bool(opt,
'use_tabulated_w',
default=False)
more_config['use_ppf_w'] = options.get_bool(opt,
'use_ppf_w',
default=False)
more_config["nonlinear_params"] = get_optional_params(
options, opt, ["halofit_version", "Min_kh_nonlinear"])
more_config["accuracy_params"] = get_optional_params(
options, opt, [
'AccuracyBoost', 'lSampleBoost', 'lAccuracyBoost',
'DoLateRadTruncation'
])
# 'TimeStepBoost', 'BackgroundTimeStepBoost', 'IntTolBoost',
# 'SourcekAccuracyBoost', 'IntkAccuracyBoost', 'TransferkBoost',
# 'NonFlatIntAccuracyBoost', 'BessIntBoost', 'LensingBoost',
# 'NonlinSourceBoost', 'BesselBoost', 'LimberBoost', 'SourceLimberBoost',
# 'KmaxBoost', 'neutrino_q_boost', 'AccuratePolarization', 'AccurateBB',
# 'AccurateReionization'])
more_config['zmin'] = options.get_double(opt, 'zmin', default=0.0)
more_config['zmax'] = options.get_double(opt, 'zmax', default=3.01)
more_config['nz'] = options.get_int(opt, 'nz', default=150)
more_config.update(get_optional_params(options, opt, ["zmid", "nz_mid"]))
# Allow for finer redshift sampling at low redshifts
if "zmid" in more_config:
if not more_config["zmin"] < more_config["zmid"] or not more_config[
"zmid"] < more_config["zmax"]:
raise ValueError(
"zmid needs to be larger than zmin and smaller than zmax!")
# Allow usage of both background_* (for backwards compatability), as well *_background
z_background = get_optional_params(options, opt, [
("background_zmin", "zmin_background"),
("zmin_background", "zmin_background"),
("background_zmax", "zmax_background"),
("zmax_background", "zmax_background"),
("background_nz", "nz_background"),
("nz_background", "nz_background"),
])
more_config['zmin_background'] = z_background.get('zmin_background',
more_config['zmin'])
more_config['zmax_background'] = z_background.get('zmax_background',
more_config['zmax'])
more_config['nz_background'] = z_background.get('nz_background',
more_config['nz'])
more_config["transfer_params"] = get_optional_params(
options, opt, ["k_per_logint", "accurate_massive_neutrinos"])
# Adjust CAMB defaults
more_config["transfer_params"]["kmax"] = options.get_double(opt,
"kmax",
default=1.2)
# more_config["transfer_params"]["high_precision"] = options.get_bool(opt, "high_precision", default=True)
camb.set_feedback_level(level=options.get_int(opt, "feedback", default=0))
return [config, more_config]
import contextlib
import time
@contextlib.contextmanager
def timer():
t = []
t.append(time.perf_counter())
yield t
t[-1] = time.perf_counter() - t[-1]
if __name__ == "__main__":
hmx = pyhmx.HMx()
camb.set_feedback_level(4)
# Cosmological parameters for CAMB
h = 0.7
omc = 0.25
omb = 0.048
mnu = 0.06
w = -1.0
wa = 0.0
ns = 0.97
As = 2.1e-9
z_max = 2.0
n_z = 100
k_max = 20.0
