def testTimeTransfers(self):
from camb import initialpower
pars = camb.set_params(H0=69, YHe=0.22, lmax=2000, lens_potential_accuracy=1, ns=0.96, As=2.5e-9)
results1 = camb.get_results(pars)
cl1 = results1.get_total_cls()
pars = camb.set_params(H0=69, YHe=0.22, lmax=2000, lens_potential_accuracy=1)
results = camb.get_transfer_functions(pars, only_time_sources=True)
inflation_params = initialpower.InitialPowerLaw()
inflation_params.set_params(ns=0.96, As=2.5e-9)
results.power_spectra_from_transfer(inflation_params)
cl2 = results.get_total_cls()
np.testing.assert_allclose(cl1, cl2, rtol=1e-4)
inflation_params.set_params(ns=0.96, As=1.9e-9)
results.power_spectra_from_transfer(inflation_params)
inflation_params.set_params(ns=0.96, As=2.5e-9)
results.power_spectra_from_transfer(inflation_params)
cl2 = results.get_total_cls()
np.testing.assert_allclose(cl1, cl2, rtol=1e-4)
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, only_time_sources=True)
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)
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))
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)
def testAssigments(self):
ini = os.path.join(os.path.dirname(__file__), '..', 'inifiles', 'planck_2018.ini')
if os.path.exists(ini):
pars = camb.read_ini(ini)
self.assertTrue(np.abs(camb.get_background(pars).cosmomc_theta() * 100 / 1.040909 - 1) < 2e-5)
pars = camb.CAMBparams()
pars.set_cosmology(H0=68.5, ombh2=0.022, mnu=0, omch2=0.1)
self.assertAlmostEqual(pars.omegam, (0.022 + 0.1) / 0.685 ** 2)
with self.assertRaises(AttributeError):
# noinspection PyPropertyAccess
pars.omegam = 1
pars.InitPower.set_params(ns=0.01)
data = camb.CAMBdata()
data.Params = pars
self.assertEqual(data.Params.InitPower.ns, pars.InitPower.ns)
d = dark_energy.DarkEnergyFluid(w=-0.95)
pars.DarkEnergy = d
self.assertEqual(pars.DarkEnergy.w, -0.95)
pars.DarkEnergy = dark_energy.AxionEffectiveFluid(w_n=0.4)
data.Params = pars
self.assertEqual(pars.DarkEnergy.w_n, 0.4)
pars.z_outputs = [0.1, 0.4]
self.assertEqual(pars.z_outputs[1], 0.4)
pars.z_outputs[0] = 0.3
self.assertEqual(pars.z_outputs[0], 0.3)
pars.z_outputs = pars.z_outputs
pars.z_outputs = []
pars.z_outputs = None
self.assertFalse(len(pars.z_outputs))
with self.assertRaises(TypeError):
pars.DarkEnergy = initialpower.InitialPowerLaw()
pars.NonLinear = model.NonLinear_both
printstr = str(pars)
self.assertTrue('Want_CMB_lensing = True' in printstr and
"NonLinear = NonLinear_both" in printstr)
pars.NonLinear = model.NonLinear_lens
self.assertTrue(pars.NonLinear == model.NonLinear_lens)
with self.assertRaises(ValueError):
pars.NonLinear = 4
pars.nu_mass_degeneracies = np.zeros(3)
self.assertTrue(len(pars.nu_mass_degeneracies) == 3)
pars.nu_mass_degeneracies = [1, 2, 3]
self.assertTrue(pars.nu_mass_degeneracies[1] == 2)
pars.nu_mass_degeneracies[1] = 5
self.assertTrue(pars.nu_mass_degeneracies[1] == 5)
with self.assertRaises(CAMBParamRangeError):
pars.nu_mass_degeneracies = np.zeros(7)
pars.nu_mass_eigenstates = 0
self.assertFalse(len((pars.nu_mass_degeneracies[:1])))
pars = camb.set_params(**{'InitPower.ns': 1.2, 'WantTransfer': True})
self.assertEqual(pars.InitPower.ns, 1.2)
self.assertTrue(pars.WantTransfer)
pars.DarkEnergy = None
from camb.sources import GaussianSourceWindow
pars = camb.CAMBparams()
pars.SourceWindows = [GaussianSourceWindow(), GaussianSourceWindow(redshift=1)]
self.assertEqual(pars.SourceWindows[1].redshift, 1)
pars.SourceWindows[0].redshift = 2
self.assertEqual(pars.SourceWindows[0].redshift, 2)
self.assertTrue(len(pars.SourceWindows) == 2)
pars.SourceWindows[0] = GaussianSourceWindow(redshift=3)
self.assertEqual(pars.SourceWindows[0].redshift, 3)
self.assertTrue('redshift = 3.0' in str(pars))
pars.SourceWindows = pars.SourceWindows[0:1]
self.assertTrue(len(pars.SourceWindows) == 1)
pars.SourceWindows = []
self.assertTrue(len(pars.SourceWindows) == 0)
def testAssigments(self):
ini = os.path.join(os.path.dirname(__file__), '..', 'inifiles',
'planck_2018.ini')
if os.path.exists(ini):
pars = camb.read_ini(ini)
self.assertTrue(
np.abs(
camb.get_background(pars).cosmomc_theta() * 100 /
1.040909 - 1) < 2e-5)
pars = camb.CAMBparams()
pars.set_cosmology(H0=68.5, ombh2=0.022, mnu=0, omch2=0.1)
self.assertAlmostEqual(pars.omegam, (0.022 + 0.1) / 0.685**2)
with self.assertRaises(AttributeError):
# noinspection PyPropertyAccess
pars.omegam = 1
pars.InitPower.set_params(ns=0.01)
data = camb.CAMBdata()
data.Params = pars
self.assertEqual(data.Params.InitPower.ns, pars.InitPower.ns)
d = dark_energy.DarkEnergyFluid(w=-0.95)
pars.DarkEnergy = d
self.assertEqual(pars.DarkEnergy.w, -0.95)
pars.DarkEnergy = dark_energy.AxionEffectiveFluid(w_n=0.4)
data.Params = pars
self.assertEqual(pars.DarkEnergy.w_n, 0.4)
pars.z_outputs = [0.1, 0.4]
self.assertEqual(pars.z_outputs[1], 0.4)
pars.z_outputs[0] = 0.3
self.assertEqual(pars.z_outputs[0], 0.3)
pars.z_outputs = pars.z_outputs
pars.z_outputs = []
pars.z_outputs = None
# noinspection PyTypeChecker
self.assertFalse(len(pars.z_outputs))
with self.assertRaises(TypeError):
pars.DarkEnergy = initialpower.InitialPowerLaw()
pars.NonLinear = model.NonLinear_both
printstr = str(pars)
self.assertTrue('Want_CMB_lensing = True' in printstr
and "NonLinear = NonLinear_both" in printstr)
pars.NonLinear = model.NonLinear_lens
self.assertTrue(pars.NonLinear == model.NonLinear_lens)
with self.assertRaises(ValueError):
pars.NonLinear = 4
pars.nu_mass_degeneracies = np.zeros(3)
self.assertTrue(len(pars.nu_mass_degeneracies) == 3)
pars.nu_mass_degeneracies = [1, 2, 3]
self.assertTrue(pars.nu_mass_degeneracies[1] == 2)
pars.nu_mass_degeneracies[1] = 5
self.assertTrue(pars.nu_mass_degeneracies[1] == 5)
with self.assertRaises(CAMBParamRangeError):
pars.nu_mass_degeneracies = np.zeros(7)
pars.nu_mass_eigenstates = 0
self.assertFalse(len((pars.nu_mass_degeneracies[:1])))
pars = camb.set_params(**{'InitPower.ns': 1.2, 'WantTransfer': True})
self.assertEqual(pars.InitPower.ns, 1.2)
self.assertTrue(pars.WantTransfer)
pars.DarkEnergy = None
pars = camb.set_params(**{
'H0': 67,
'ombh2': 0.002,
'r': 0.1,
'Accuracy.AccurateBB': True
})
self.assertEqual(pars.Accuracy.AccurateBB, True)
from camb.sources import GaussianSourceWindow
pars = camb.CAMBparams()
pars.SourceWindows = [
GaussianSourceWindow(),
GaussianSourceWindow(redshift=1)
]
self.assertEqual(pars.SourceWindows[1].redshift, 1)
pars.SourceWindows[0].redshift = 2
self.assertEqual(pars.SourceWindows[0].redshift, 2)
self.assertTrue(len(pars.SourceWindows) == 2)
pars.SourceWindows[0] = GaussianSourceWindow(redshift=3)
self.assertEqual(pars.SourceWindows[0].redshift, 3)
self.assertTrue('redshift = 3.0' in str(pars))
pars.SourceWindows = pars.SourceWindows[0:1]
self.assertTrue(len(pars.SourceWindows) == 1)
pars.SourceWindows = []
self.assertTrue(len(pars.SourceWindows) == 0)
params = camb.get_valid_numerical_params()
self.assertEqual(
params, {
'ombh2', 'deltazrei', 'omnuh2', 'tau', 'omk', 'zrei',
'thetastar', 'nrunrun', 'meffsterile', 'nnu', 'ntrun',
'HMCode_A_baryon', 'HMCode_eta_baryon', 'HMCode_logT_AGN',
'cosmomc_theta', 'YHe', 'wa', 'cs2', 'H0', 'mnu', 'Alens',
'TCMB', 'ns', 'nrun', 'As', 'nt', 'r', 'w', 'omch2'
})
params2 = camb.get_valid_numerical_params(
dark_energy_model='AxionEffectiveFluid')
self.assertEqual(params2.difference(params),
{'fde_zc', 'w_n', 'zc', 'theta_i'})
