def testInstances(self):
pars = camb.set_params(H0=69.1, ombh2=0.032, omch2=0.122, As=3e-9, ns=0.91, omk=0.013,
redshifts=[0.], kmax=0.5)
data = camb.get_background(pars)
res1 = data.angular_diameter_distance(0.7)
drag1 = data.get_derived_params()['rdrag']
pars2 = camb.set_params(H0=65, ombh2=0.022, omch2=0.122, As=3e-9, ns=0.91)
data2 = camb.get_background(pars2)
res2 = data2.angular_diameter_distance(1.7)
drag2 = data2.get_derived_params()['rdrag']
self.assertAlmostEqual(res1, data.angular_diameter_distance(0.7))
self.assertAlmostEqual(res2, data2.angular_diameter_distance(1.7))
self.assertAlmostEqual(drag1, data.get_derived_params()['rdrag'])
self.assertEqual(pars2.InitPower.ns, data2.Params.InitPower.ns)
data2.calc_background(pars)
self.assertEqual(pars.InitPower.ns, data2.Params.InitPower.ns)
self.assertAlmostEqual(res1, data2.angular_diameter_distance(0.7))
data3 = camb.get_results(pars2)
cl3 = data3.get_lensed_scalar_cls(1000)
self.assertAlmostEqual(res2, data3.angular_diameter_distance(1.7))
self.assertAlmostEqual(drag2, data3.get_derived_params()['rdrag'], places=3)
self.assertAlmostEqual(drag1, data.get_derived_params()['rdrag'], places=3)
pars.set_for_lmax(3000, lens_potential_accuracy=1)
camb.get_results(pars)
del data3
data4 = camb.get_results(pars2)
cl4 = data4.get_lensed_scalar_cls(1000)
self.assertTrue(np.allclose(cl4, cl3))
def testInstances(self):
pars = camb.set_params(H0=69.1, ombh2=0.032, omch2=0.122, As=3e-9, ns=0.91, omk=0.013,
redshifts=[0.], kmax=0.5)
data = camb.get_background(pars)
res1 = data.angular_diameter_distance(0.7)
drag1 = data.get_derived_params()['rdrag']
pars2 = camb.set_params(H0=65, ombh2=0.022, omch2=0.122, As=3e-9, ns=0.91)
data2 = camb.get_background(pars2)
res2 = data2.angular_diameter_distance(1.7)
drag2 = data2.get_derived_params()['rdrag']
self.assertAlmostEqual(res1, data.angular_diameter_distance(0.7))
self.assertAlmostEqual(res2, data2.angular_diameter_distance(1.7))
self.assertAlmostEqual(drag1, data.get_derived_params()['rdrag'])
self.assertEqual(pars2.InitPower.ns, data2.Params.InitPower.ns)
data2.calc_background(pars)
self.assertEqual(pars.InitPower.ns, data2.Params.InitPower.ns)
self.assertAlmostEqual(res1, data2.angular_diameter_distance(0.7))
data3 = camb.get_results(pars2)
cl3 = data3.get_lensed_scalar_cls(1000)
self.assertAlmostEqual(res2, data3.angular_diameter_distance(1.7))
self.assertAlmostEqual(drag2, data3.get_derived_params()['rdrag'], places=3)
self.assertAlmostEqual(drag1, data.get_derived_params()['rdrag'], places=3)
pars.set_for_lmax(3000, lens_potential_accuracy=1)
camb.get_results(pars)
del data3
data4 = camb.get_results(pars2)
cl4 = data4.get_lensed_scalar_cls(1000)
self.assertTrue(np.allclose(cl4, cl3))
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 neg2LogL(x, cls_data):
camb_index = {'TT': 0, 'EE': 1, 'BB': 3, 'TE': 2}
fsky = 1500 / (4 * np.pi / ((2 * np.pi / 360)**2))
Tnoise = {150: 2.2} # uK arcmin
H0 = x[0]
ombh2 = x[1]
omch2 = x[2]
if H0 > 80 or H0 < 50 or ombh2 > 0.03 or \
ombh2 < 0.012 or omch2 > 0.15 or omch2 < 0.07:
return 1e9
pars = camb.CAMBparams()
# This function sets up CosmoMC-like settings,
# with one massive neutrino and helium set using BBN consistency
pars.set_cosmology(H0=H0,
ombh2=ombh2,
omch2=omch2,
mnu=0.06,
omk=0,
tau=0.0666)
camb.set_params(lmax=5000)
pars.InitPower.set_params(As=2.141e-9, ns=0.9683, r=0)
#calculate results for these parameters
results = camb.get_results(pars)
powers = results.get_cmb_power_spectra(pars, CMB_unit='muK')
totCL = powers['total']
ells_theory = np.arange(totCL.shape[0])
ells_theory_binned = np.intersect1d(ells_theory, cls_data['ell'])
ells_data = cls_data['ell'][np.isin(cls_data['ell'], ells_theory_binned)]
chi2 = 0
for spectrum in ['TT', 'EE']:
dls_theory_binned = totCL[:,camb_index[spectrum]] \
[np.isin(ells_theory, ells_theory_binned)]
cls_theory_binned = dls_theory_binned / (ells_theory_binned *
(ells_theory_binned + 1) /
(2 * np.pi))
cls_data_binned = cls_data[spectrum][np.isin(cls_data['ell'],
ells_theory_binned)]
residual = cls_theory_binned - cls_data_binned
if spectrum == 'TT':
noise = Tnoise[150]
else:
noise = Tnoise[150] * np.sqrt(2.)
cl_cov = knox_errors(ells_theory_binned, cls_theory_binned, fsky,
noise)**2
chi2 += np.sum(residual**2. / cl_cov)
return chi2
def test_mflike(self):
# As of now, there is not a mechanism
# in soliket to ensure there is .loglike that can be called like this
# w/out cobaya
camb_cosmo = cosmo_params.copy()
camb_cosmo.update({"lmax": 9000, "lens_potential_accuracy": 1})
pars = camb.set_params(**camb_cosmo)
results = camb.get_results(pars)
powers = results.get_cmb_power_spectra(pars, CMB_unit="muK")
cl_dict = {k: powers["total"][:, v] for k, v in {"tt": 0, "ee": 1, "te": 3}.items()}
for select, chi2 in chi2s.items():
MFLike = self.get_mflike_type()
my_mflike = MFLike(
{
"packages_path": packages_path,
"input_file": pre + "00000.fits",
"cov_Bbl_file": pre + "w_covar_and_Bbl.fits",
"defaults": {
"polarizations": select.upper().split("-"),
"scales": {
"TT": [2, 5000],
"TE": [2, 5000],
"ET": [2, 5000],
"EE": [2, 5000],
},
"symmetrize": False,
},
}
)
loglike = my_mflike.loglike(cl_dict, **nuisance_params)
self.assertAlmostEqual(-2 * (loglike - my_mflike.logp_const), chi2, 2)
def testEvolution(self):
redshifts = [0.4, 31.5]
pars = camb.set_params(H0=67.5,
ombh2=0.022,
omch2=0.122,
As=2e-9,
ns=0.95,
redshifts=redshifts,
kmax=0.1)
pars.WantCls = False
# check transfer function routines and evolution code agree
# Note transfer function redshifts are re-sorted in outputs
data = camb.get_transfer_functions(pars)
mtrans = data.get_matter_transfer_data()
transfer_k = mtrans.transfer_z('delta_cdm', z_index=1)
transfer_k2 = mtrans.transfer_z('delta_baryon', z_index=0)
kh = mtrans.transfer_z('k/h', z_index=1)
ev = data.get_redshift_evolution(
mtrans.q,
redshifts, ['delta_baryon', 'delta_cdm', 'delta_photon'],
lAccuracyBoost=1)
self.assertTrue(
np.all(
np.abs(transfer_k * kh**2 *
(pars.H0 / 100)**2 / ev[:, 0, 1] - 1) < 1e-3))
ix = 1
self.assertAlmostEqual(
transfer_k2[ix] * kh[ix]**2 * (pars.H0 / 100)**2, ev[ix, 1, 0], 4)
def test_mflike(self):
from mflike import MFLike
my_mflike = MFLike({"path_install": modules_path, "sim_id": 0})
import camb
camb_cosmo = cosmo_params.copy()
camb_cosmo.update({
"lmax": my_mflike.lmax,
"lens_potential_accuracy": 1
})
pars = camb.set_params(**camb_cosmo)
results = camb.get_results(pars)
powers = results.get_cmb_power_spectra(pars, CMB_unit="muK")
cl_dict = {
k: powers["total"][:, v]
for k, v in {
"tt": 0,
"ee": 1,
"te": 3
}.items()
}
for select, chi2 in chi2s.items():
my_mflike = MFLike({
"path_install": modules_path,
"sim_id": 0,
"select": select
})
loglike = my_mflike.loglike(cl_dict, **nuisance_params)
self.assertAlmostEqual(-2 * loglike, chi2, 3)
def _init_cosmology(self,params,halofit):
try:
theta = params['theta100']/100.
H0 = None
print("WARNING: Using theta100 parameterization. H0 ignored.")
except:
H0 = params['H0']
theta = None
try:
omm = params['omm']
h = params['H0']/100.
params['omch2'] = omm*h**2-params['ombh2']
print("WARNING: omm specified. Ignoring omch2.")
except:
pass
self.pars = camb.set_params(ns=params['ns'],As=params['As'],H0=H0,
cosmomc_theta=theta,ombh2=params['ombh2'],
omch2=params['omch2'], mnu=params['mnu'],
tau=params['tau'],nnu=params['nnu'],
num_massive_neutrinos=
params['num_massive_neutrinos'],
w=params['w0'],wa=params['wa'],
dark_energy_model='ppf',
halofit_version=self.p['default_halofit'] if halofit is None else halofit,
AccuracyBoost=2)
self.results = camb.get_background(self.pars)
self.params = params
self.h = self.params['H0']/100.
omh2 = self.params['omch2']+self.params['ombh2'] # FIXME: neutrinos
self.om0 = omh2 / (self.params['H0']/100.)**2.
try: self.as8 = self.params['as8']
except: self.as8 = 1
def test_indep(self):
from plancklensing import PlanckLensingMarged
import camb
lmax = 2500
opts = camb_params.copy()
opts['lens_potential_accuracy'] = 1
opts['lmax'] = lmax
opts['halofit_version'] = 'mead'
pars = camb.set_params(**opts)
results = camb.get_results(pars)
cls = results.get_total_cls(lmax, CMB_unit='muK')
cl_dict = {
p: cls[:, i]
for i, p in enumerate(['tt', 'ee', 'bb', 'te'])
}
cl_dict['pp'] = results.get_lens_potential_cls(lmax)[:, 0]
like = PlanckLensingMarged()
self.assertAlmostEqual(-2 * like.log_likelihood(cl_dict), 8.76, 1)
from plancklensing import PlanckLensing
like = PlanckLensing()
self.assertAlmostEqual(-2 * like.log_likelihood(cl_dict, A_planck=1.0),
8.734, 1)
# aggressive likelihood
like = PlanckLensingMarged({
'dataset_file':
'data_2018/smicadx12_Dec5_ftl_mv2_ndclpp_p_teb_agr2_CMBmarged.dataset'
})
self.assertAlmostEqual(-2 * like.log_likelihood(cl_dict), 13.5, 1)
def testEmissionAnglePostBorn(self):
from camb import emission_angle, postborn
pars = camb.set_params(H0=67.5, ombh2=0.022, omch2=0.122, As=2e-9, ns=0.95, tau=0.055)
BB = emission_angle.get_emission_delay_BB(pars, lmax=3500)
self.assertAlmostEqual(BB(80) * 2 * np.pi / 80 / 81., 1.1e-10, delta=1e-11)
Bom = postborn.get_field_rotation_BB(pars, lmax=3500)
self.assertAlmostEqual(Bom(100) * 2 * np.pi / 100 / 101., 1.65e-11, delta=1e-12)
def testEmissionAnglePostBorn(self):
from camb import emission_angle, postborn
pars = camb.set_params(H0=67.5, ombh2=0.022, omch2=0.122, As=2e-9, ns=0.95, tau=0.055)
BB = emission_angle.get_emission_delay_BB(pars, lmax=3500)
self.assertAlmostEqual(BB(80) * 2 * np.pi / 80 / 81., 1.1e-10, delta=1e-11)
Bom = postborn.get_field_rotation_BB(pars, lmax=3500)
self.assertAlmostEqual(Bom(100) * 2 * np.pi / 100 / 101., 1.65e-11, delta=1e-12)
def test_quintessence(self):
n = 3
# set zc and fde_zc
pars = camb.set_params(ombh2=0.022, omch2=0.122, thetastar=0.01044341764253,
dark_energy_model='EarlyQuintessence',
m=8e-53, f=0.05, n=n, theta_i=3.1, use_zc=True, zc=1e4, fde_zc=0.1)
camb.get_background(pars)
results = camb.get_results(pars)
self.assertAlmostEqual(results.get_derived_params()['thetastar'], 1.044341764253, delta=1e-5)
def __init__(self, redshift=0.0, omega_m=0.3121, omega_b=0.0491, hubble=0.6751, omega_k=0.0, tau=0.063, As=2.130e-9, ns=0.9653,
neutrino_hierarchy='degenerate', num_massive_neutrinos=1, mnu=0.06, nnu=3.046, w=-1.0, sound_speed=1.0, dark_energy_model='fluid', sigma8=None, r_s=None, r_s_type='CAMB',
degree=13, sigma=1, weight=0.5, verbose=False):
import camb
self.verbose = verbose
self.redshift = redshift
self.omega_m = omega_m
self.omega_b = omega_b
self.hubble = hubble
self.ns = ns
self.sigma8 = sigma8
self.degree = degree
self.sigma = sigma
self.weight = weight
if (self.verbose):
print "Using CAMB to generate matter power spectrum"
params = camb.set_params(omch2=(omega_m-omega_b)*hubble**2, ombh2=omega_b*hubble**2, H0=100.0*hubble, omk=omega_k, tau=tau, As=As, ns=ns,
neutrino_hierarchy=neutrino_hierarchy, num_massive_neutrinos=num_massive_neutrinos, mnu=mnu, nnu=nnu,
w=w, sound_speed=sound_speed, dark_energy_model=dark_energy_model)
params.set_matter_power(redshifts=[redshift],kmax=100,accurate_massive_neutrino_transfers=True)
results = camb.get_results(params)
self.k, z, self.pk = results.get_matter_power_spectrum(minkh=1e-4, maxkh=100, npoints = 2000)
self.pk = self.pk[0]
# Normalise the input power spectrum to the current value of sigma8 if one has been passed
if (self.sigma8 is None):
self.sigma8 = results.get_sigma8()[0]
else:
pknorm = norm_pk(self.k, self.pk, self.sigma8)
self.pk *= pknorm
if (r_s is None):
if (r_s_type == 'EH98'):
self.r_s = self.EH98_rs()
if (self.verbose):
print "Setting sound horizon using EH98 formulae: r_s = ", self.r_s
print "Note: This is only used for BAOExtractor model"
elif (r_s_type == 'CAMB'):
self.r_s = camb.get_background(params).get_derived_params()['rdrag']
if (self.verbose):
print "Setting sound horizon using CAMB value: r_s = ", self.r_s
print "Note: This is only used for BAOExtractor model"
else:
print "r_s_type not supported (", r_s_type, "), must be either 'EH98' or 'CAMB', or you must pass in a value for r_s"
exit()
else:
self.r_s = r_s
if (self.verbose):
print "Setting sound horizon using user-defined value: r_s = ", self.r_s
print "Note: This is only used for BAOExtractor model"
self.set_pksmooth()
def testSymbolic(self):
if fast:
return
import camb.symbolic as s
monopole_source, ISW, doppler, quadrupole_source = s.get_scalar_temperature_sources()
temp_source = monopole_source + ISW + doppler + quadrupole_source
pars = camb.set_params(H0=67.5, ombh2=0.022, omch2=0.122, As=2e-9, ns=0.95, omk=0.1)
data = camb.get_background(pars)
tau = np.linspace(1, 1200, 300)
ks = [0.001, 0.05, 1]
monopole2 = s.make_frame_invariant(s.newtonian_gauge(monopole_source), 'Newtonian')
Delta_c_N = s.make_frame_invariant(s.Delta_c, 'Newtonian')
Delta_c_N2 = s.make_frame_invariant(s.synchronous_gauge(Delta_c_N), 'CDM')
ev = data.get_time_evolution(ks, tau, ['delta_photon', s.Delta_g, Delta_c_N, Delta_c_N2,
monopole_source, monopole2,
temp_source, 'T_source'])
self.assertTrue(np.allclose(ev[:, :, 0], ev[:, :, 1]))
self.assertTrue(np.allclose(ev[:, :, 2], ev[:, :, 3]))
self.assertTrue(np.allclose(ev[:, :, 4], ev[:, :, 5]))
self.assertTrue(np.allclose(ev[:, :, 6], ev[:, :, 7]))
pars = camb.set_params(H0=67.5, ombh2=0.022, omch2=0.122, As=2e-9, ns=0.95)
pars.set_accuracy(lSampleBoost=2)
try:
pars.set_custom_scalar_sources([monopole_source + ISW + doppler + quadrupole_source,
s.scalar_E_source], source_names=['T2', 'E2'],
source_ell_scales={'E2': 2})
data = camb.get_results(pars)
dic = data.get_cmb_unlensed_scalar_array_dict(CMB_unit='muK')
self.assertTrue(np.all(np.abs(dic['T2xT2'][2:2000] / dic['TxT'][2:2000] - 1) < 1e-3))
self.assertTrue(np.all(np.abs(dic['TxT2'][2:2000] / dic['TxT'][2:2000] - 1) < 1e-3))
# default interpolation errors much worse for E
self.assertTrue(np.all(np.abs(dic['E2xE2'][10:2000] / dic['ExE'][10:2000] - 1) < 2e-3))
self.assertTrue(np.all(np.abs(dic['E2xE'][10:2000] / dic['ExE'][10:2000] - 1) < 2e-3))
dic1 = data.get_cmb_power_spectra(CMB_unit='muK')
self.assertTrue(np.allclose(dic1['unlensed_scalar'][2:2000, 1], dic['ExE'][2:2000]))
finally:
pars.set_accuracy(lSampleBoost=1)
s.internal_consistency_checks()
def testSymbolic(self):
if fast: return
import camb.symbolic as s
monopole_source, ISW, doppler, quadrupole_source = s.get_scalar_temperature_sources()
temp_source = monopole_source + ISW + doppler + quadrupole_source
pars = camb.set_params(H0=67.5, ombh2=0.022, omch2=0.122, As=2e-9, ns=0.95, omk=0.1)
data = camb.get_background(pars)
tau = np.linspace(1, 1200, 300)
ks = [0.001, 0.05, 1]
monopole2 = s.make_frame_invariant(s.newtonian_gauge(monopole_source), 'Newtonian')
Delta_c_N = s.make_frame_invariant(s.Delta_c, 'Newtonian')
Delta_c_N2 = s.make_frame_invariant(s.synchronous_gauge(Delta_c_N), 'CDM')
ev = data.get_time_evolution(ks, tau, ['delta_photon', s.Delta_g, Delta_c_N, Delta_c_N2,
monopole_source, monopole2,
temp_source, 'T_source'])
self.assertTrue(np.allclose(ev[:, :, 0], ev[:, :, 1]))
self.assertTrue(np.allclose(ev[:, :, 2], ev[:, :, 3]))
self.assertTrue(np.allclose(ev[:, :, 4], ev[:, :, 5]))
self.assertTrue(np.allclose(ev[:, :, 6], ev[:, :, 7]))
pars = camb.set_params(H0=67.5, ombh2=0.022, omch2=0.122, As=2e-9, ns=0.95)
pars.set_accuracy(lSampleBoost=2)
try:
pars.set_custom_scalar_sources([monopole_source + ISW + doppler + quadrupole_source,
s.scalar_E_source], source_names=['T2', 'E2'],
source_ell_scales={'E2': 2})
data = camb.get_results(pars)
dic = data.get_cmb_unlensed_scalar_array_dict(CMB_unit='muK')
self.assertTrue(np.all(np.abs(dic['T2xT2'][2:2000] / dic['TxT'][2:2000] - 1) < 1e-3))
self.assertTrue(np.all(np.abs(dic['TxT2'][2:2000] / dic['TxT'][2:2000] - 1) < 1e-3))
# default interpolation errors much worse for E
self.assertTrue(np.all(np.abs(dic['E2xE2'][10:2000] / dic['ExE'][10:2000] - 1) < 2e-3))
self.assertTrue(np.all(np.abs(dic['E2xE'][10:2000] / dic['ExE'][10:2000] - 1) < 2e-3))
dic1 = data.get_cmb_power_spectra(CMB_unit='muK')
self.assertTrue(np.allclose(dic1['unlensed_scalar'][2:2000, 1], dic['ExE'][2:2000]))
finally:
pars.set_accuracy(lSampleBoost=1)
s.internal_consistency_checks()
def compute_map(r, lmax=1500, nside=512, seed=None):
np.random.seed(seed)
cp = camb.set_params(r=r, WantCls=True, lmax=lmax, H0=67,
Want_CMB_lensing=False, DoLensing=False,
WantScalars=False)
res = camb.get_results(cp)
cls = res.get_cmb_power_spectra(CMB_unit='muK')
cls = np.transpose(cls['total'])
ells = np.arange(len(cls[0, :]))
# return cls
cls[:, 1:] = cls[:, 1:] / (ells[1:] * (ells[1:] + 1))
outmap = healpy.synfast(cls, nside, new=True, pol=True)
outmap *= 2.7255 * 1e-6
return outmap
def test_lollipop(self):
import camb
import planck_2020_lollipop
camb_cosmo = cosmo_params.copy()
camb_cosmo.update({"lmax": 145, "lens_potential_accuracy": 1})
pars = camb.set_params(**camb_cosmo)
results = camb.get_results(pars)
powers = results.get_cmb_power_spectra(pars, CMB_unit="muK", raw_cl=True)
cl_dict = {k: powers["total"][:, v] for k, v in {"ee": 1, "bb": 2}.items()}
for mode, chi2 in chi2s.items():
_llp = getattr(planck_2020_lollipop, mode)
my_lik = _llp({"packages_path": packages_path})
loglike = my_lik.loglike(cl_dict, **{})
self.assertLess( abs(-2 * loglike - chi2), 1)
def test_hillipop(self):
import camb
import planck_2020_hillipop
camb_cosmo = cosmo_params.copy()
camb_cosmo.update({"lmax": 2500, "lens_potential_accuracy": 1})
pars = camb.set_params(**camb_cosmo)
results = camb.get_results(pars)
powers = results.get_cmb_power_spectra(pars, CMB_unit="muK")
cl_dict = {k: powers["total"][:, v] for k, v in {"tt": 0, "ee": 1, "te": 3}.items()}
for mode, chi2 in chi2s.items():
_hlp = getattr(planck_2020_hillipop, mode)
my_lik = _hlp({"packages_path": packages_path})
loglike = my_lik.loglike(cl_dict, **{**calib_params, **nuisance_params[mode]})
self.assertLess( abs(-2 * loglike - chi2), 1)
def testEvolution(self):
redshifts = [0.4, 31.5]
pars = camb.set_params(H0=67.5, ombh2=0.022, omch2=0.122, As=2e-9, ns=0.95,
redshifts=redshifts, kmax=0.1)
pars.WantCls = False
# check transfer function routines and evolution code agree
# Note transfer function redshifts are re-sorted in outputs
data = camb.get_transfer_functions(pars)
mtrans = data.get_matter_transfer_data()
transfer_k = mtrans.transfer_z('delta_cdm', z_index=1)
transfer_k2 = mtrans.transfer_z('delta_baryon', z_index=0)
kh = mtrans.transfer_z('k/h', z_index=1)
ev = data.get_redshift_evolution(mtrans.q, redshifts, ['delta_baryon', 'delta_cdm', 'delta_photon'],
lAccuracyBoost=1)
self.assertTrue(np.all(np.abs(transfer_k * kh ** 2 * (pars.H0 / 100) ** 2 / ev[:, 0, 1] - 1) < 1e-3))
ix = 1
self.assertAlmostEqual(transfer_k2[ix] * kh[ix] ** 2 * (pars.H0 / 100) ** 2, ev[ix, 1, 0], 4)
def test_mflike(self):
import camb
camb_cosmo = cosmo_params.copy()
camb_cosmo.update({"lmax": 9000, "lens_potential_accuracy": 1})
pars = camb.set_params(**camb_cosmo)
results = camb.get_results(pars)
powers = results.get_cmb_power_spectra(pars, CMB_unit="muK")
cl_dict = {
k: powers["total"][:, v]
for k, v in {
"tt": 0,
"ee": 1,
"te": 3
}.items()
}
for select, chi2 in chi2s.items():
from mflike import MFLike
my_mflike = MFLike({
"packages_path": packages_path,
"input_file": pre + "00000.fits",
"cov_Bbl_file": pre + "w_covar_and_Bbl.fits",
"defaults": {
"polarizations": select.upper().split("-"),
"scales": {
"TT": [2, 5000],
"TE": [2, 5000],
"ET": [2, 5000],
"EE": [2, 5000],
},
"symmetrize": False,
},
"band_integration": {
"nsteps": 1,
"bandwidth": 0,
"external_bandpass": False,
},
})
loglike = my_mflike.loglike(cl_dict, **nuisance_params)
self.assertAlmostEqual(-2 * (loglike - my_mflike.logp_const), chi2,
2)
def get_g_camb(self):
import camb
dw_dz = lambda z: 1 / (self.a0 * self.H0 * self.E(z))
z_vis = np.linspace(0, 20, 5000)
pars = camb.set_params(H0=100 * self.h,
ombh2=self.Omega_Bh2,
omch2=self.Omega0 * self.h**2 - self.Omega_Bh2,
ns=self.n,
tau=self.tau)
data = camb.get_background(pars)
back_ev = data.get_background_redshift_evolution(z_vis,
['x_e', 'visibility'],
format='array')
g_interpolation = glueAsymptode(
interpolate(z_vis, back_ev[:, 1]),
min=0.1,
minAsym=lambda z: interpolate(z_vis, back_ev[:, 1])(0.1) *
(1 + z)**2)
norm = self.__num.integrate(lambda z: g_interpolation(z) * dw_dz(z),
min(z_vis), max(z_vis))
g_func = lambda z: (1 - np.exp(-self.tau)) / norm * g_interpolation(z)
return g_func
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):
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 __init__(
self,
cosmo_input=dict(f_NL=0,
H0=67.0,
cosmomc_theta=None,
ombh2=0.022,
omch2=0.12,
omk=0.0,
neutrino_hierarchy='degenerate',
num_massive_neutrinos=1,
mnu=0.06,
nnu=3.046,
YHe=None,
meffsterile=0.0,
standard_neutrino_neff=3.046,
TCMB=2.7255,
tau=None,
deltazrei=None,
bbn_predictor=None,
theta_H0_range=[10, 100],
w=-1.0,
wa=0.,
cs2=1.0,
dark_energy_model='ppf',
As=2e-09,
ns=0.96,
nrun=0,
nrunrun=0.0,
r=0.0,
nt=None,
ntrun=0.0,
pivot_scalar=0.05,
pivot_tensor=0.05,
parameterization=2,
halofit_version='mead'),
model_type='LF',
model_name='SchCut',
model_par={
'phistar': 9.6e-11 * u.Lsun**-1 * u.Mpc**-3,
'Lstar': 2.1e6 * u.Lsun,
'alpha': -1.87,
'Lmin': 5000 * u.Lsun
},
hmf_model='ST',
bias_model='ST99',
bias_par={}, #Otherwise, write a dict with the corresponding values
nu=115 * u.GHz,
nuObs=30 * u.GHz,
Mmin=1e9 * u.Msun,
Mmax=1e15 * u.Msun,
nM=5000,
Lmin=100 * u.Lsun,
Lmax=1e8 * u.Lsun,
nL=5000,
kmin=1e-2 * u.Mpc**-1,
kmax=10. * u.Mpc**-1,
nk=100,
k_kind='log',
sigma_scatter=0.,
fduty=1.,
do_onehalo=False,
do_Jysr=False,
do_RSD=True,
sigma_NL=7 * u.Mpc,
nmu=1000,
nonlinear_pm=False,
FoG_damp='Lorentzian',
smooth=False):
# Get list of input values to check type and units
self._lim_params = locals()
self._lim_params.pop('self')
# Get list of input names and default values
self._default_lim_params = get_default_params(LineModel.__init__)
# Check that input values have the correct type and units
check_params(self._lim_params, self._default_lim_params)
# Set all given parameters
for key in self._lim_params:
setattr(self, key, self._lim_params[key])
# Create overall lists of parameters (Only used if using one of
# lim's subclasses
self._input_params = {} # Don't want .update to change _lim_params
self._default_params = {}
self._input_params.update(self._lim_params)
self._default_params.update(self._default_lim_params)
# Create list of cached properties
self._update_list = []
# Check if model_name is valid
check_model(self.model_type, self.model_name)
check_bias_model(self.bias_model)
#Set cosmology and call camb
self.cosmo_input = self._default_params['cosmo_input']
for key in cosmo_input:
self.cosmo_input[key] = cosmo_input[key]
self.camb_pars = camb.set_params(
H0=self.cosmo_input['H0'],
cosmomc_theta=self.cosmo_input['cosmomc_theta'],
ombh2=self.cosmo_input['ombh2'],
omch2=self.cosmo_input['omch2'],
omk=self.cosmo_input['omk'],
neutrino_hierarchy=self.cosmo_input['neutrino_hierarchy'],
num_massive_neutrinos=self.cosmo_input['num_massive_neutrinos'],
mnu=self.cosmo_input['mnu'],
nnu=self.cosmo_input['nnu'],
YHe=self.cosmo_input['YHe'],
meffsterile=self.cosmo_input['meffsterile'],
standard_neutrino_neff=self.cosmo_input['standard_neutrino_neff'],
TCMB=self.cosmo_input['TCMB'],
tau=self.cosmo_input['tau'],
deltazrei=self.cosmo_input['deltazrei'],
bbn_predictor=self.cosmo_input['bbn_predictor'],
theta_H0_range=self.cosmo_input['theta_H0_range'],
w=self.cosmo_input['w'],
cs2=self.cosmo_input['cs2'],
dark_energy_model=self.cosmo_input['dark_energy_model'],
As=self.cosmo_input['As'],
ns=self.cosmo_input['ns'],
nrun=self.cosmo_input['nrun'],
nrunrun=self.cosmo_input['nrunrun'],
r=self.cosmo_input['r'],
nt=self.cosmo_input['nt'],
ntrun=self.cosmo_input['ntrun'],
pivot_scalar=self.cosmo_input['pivot_scalar'],
pivot_tensor=self.cosmo_input['pivot_tensor'],
parameterization=self.cosmo_input['parameterization'],
halofit_version=self.cosmo_input['halofit_version'])
self.camb_pars.WantTransfer = True
import scipy.integrate as integrate
warnings.filterwarnings('ignore',
category=DeprecationWarning,
module='.*/IPython/.*')
sys.path.insert(0, r'c:\work\dist\git\camb\pycamb')
import camb
from camb.symbolic import *
sympy.init_printing()
monopole_source, ISW, doppler, quadrupole_source = get_scalar_temperature_sources(
)
pars = camb.set_params(H0=70.0,
ombh2=0.01809,
omch2=0.12400,
As=2.1e-9,
ns=0.96,
tau=0.08)
from matplotlib import rcParams
rcParams.update({
'axes.labelsize': 14,
'font.size': 14,
'legend.fontsize': 14,
'xtick.labelsize': 13,
'ytick.labelsize': 13
})
cl_label = r'$\ell(\ell+1)C_\ell/2\pi\quad [\mu {\rm K}^2]$'
#Example of plotting the time evolution of Newtonian gauge variables and the monopole sources
# data= camb.get_background(pars)
def testBackground(self):
pars = camb.CAMBparams()
pars.set_cosmology(H0=68.5,
ombh2=0.022,
omch2=0.122,
YHe=0.2453,
mnu=0.07,
omk=0)
zre = camb.get_zre_from_tau(pars, 0.06)
age = camb.get_age(pars)
self.assertAlmostEqual(zre, 8.39, 2)
self.assertAlmostEqual(age, 13.65, 2)
data = camb.CAMBdata()
bao = data.get_BAO([0.57, 0.27], pars)
data = camb.CAMBdata()
data.calc_background(pars)
DA = data.angular_diameter_distance(0.57)
H = data.hubble_parameter(0.27)
self.assertAlmostEqual(DA, bao[0][2], 3)
self.assertAlmostEqual(H, bao[1][1], 3)
age2 = data.physical_time(0)
self.assertAlmostEqual(age, age2, 4)
data.comoving_radial_distance(0.48)
t0 = data.conformal_time(0)
t1 = data.conformal_time(11.5)
t2 = data.comoving_radial_distance(11.5)
self.assertAlmostEqual(t2, t0 - t1, 2)
self.assertAlmostEqual(t1, 4200.78, 2)
chistar = data.conformal_time(0) - model.tau_maxvis.value
chis = np.linspace(0, chistar, 197)
zs = data.redshift_at_comoving_radial_distance(chis)
chitest = data.comoving_radial_distance(zs)
self.assertTrue(np.sum((chitest - chis)**2) < 1e-3)
theta = data.cosmomc_theta()
self.assertAlmostEqual(theta, 0.0104759965, 5)
derived = data.get_derived_params()
self.assertAlmostEqual(derived['age'], age, 2)
self.assertAlmostEqual(derived['rdrag'], 146.976, 2)
# Test BBN consistency, base_plikHM_TT_lowTEB best fit model
pars.set_cosmology(H0=67.31,
ombh2=0.022242,
omch2=0.11977,
mnu=0.06,
omk=0)
self.assertAlmostEqual(pars.YHe, 0.245336, 5)
data.calc_background(pars)
self.assertAlmostEqual(data.cosmomc_theta(), 0.01040862, 7)
self.assertAlmostEqual(data.get_derived_params()['kd'], 0.14055, 4)
pars.set_cosmology(H0=67.31,
ombh2=0.022242,
omch2=0.11977,
mnu=0.06,
omk=0,
bbn_predictor=bbn.BBN_table_interpolator())
self.assertAlmostEqual(pars.YHe, 0.2453469, 5)
self.assertAlmostEqual(pars.get_Y_p(),
bbn.BBN_table_interpolator().Y_p(0.022242, 0),
5)
# test massive sterile models as in Planck papers
pars.set_cosmology(H0=68.0,
ombh2=0.022305,
omch2=0.11873,
mnu=0.06,
nnu=3.073,
omk=0,
meffsterile=0.013)
self.assertAlmostEqual(pars.omegan * (pars.H0 / 100)**2, 0.00078, 5)
self.assertAlmostEqual(pars.YHe, 0.24573, 5)
self.assertAlmostEqual(pars.N_eff(), 3.073, 4)
data.calc_background(pars)
self.assertAlmostEqual(data.get_derived_params()['age'], 13.773, 2)
self.assertAlmostEqual(data.cosmomc_theta(), 0.0104103, 6)
# test dark energy
pars.set_cosmology(H0=68.26,
ombh2=0.022271,
omch2=0.11914,
mnu=0.06,
omk=0)
pars.set_dark_energy(w=-1.0226, dark_energy_model='fluid')
data.calc_background(pars)
self.assertAlmostEqual(data.get_derived_params()['age'], 13.789, 2)
scal = data.luminosity_distance(1.4)
vec = data.luminosity_distance([1.2, 1.4, 0.1, 1.9])
self.assertAlmostEqual(scal, vec[1], 5)
pars.set_dark_energy() # re-set defaults
# test theta
pars.set_cosmology(cosmomc_theta=0.0104085,
H0=None,
ombh2=0.022271,
omch2=0.11914,
mnu=0.06,
omk=0)
self.assertAlmostEqual(pars.H0, 67.5512, 2)
with self.assertRaises(CAMBParamRangeError):
pars.set_cosmology(cosmomc_theta=0.0204085,
H0=None,
ombh2=0.022271,
omch2=0.11914,
mnu=0.06,
omk=0)
pars = camb.set_params(cosmomc_theta=0.0104077,
H0=None,
ombh2=0.022,
omch2=0.122,
w=-0.95)
self.assertAlmostEqual(
camb.get_background(pars, no_thermo=True).cosmomc_theta(),
0.0104077, 7)
pars.set_dark_energy()
def testBackground(self):
pars = camb.CAMBparams()
pars.set_cosmology(H0=68.5, ombh2=0.022, omch2=0.122, YHe=0.2453, mnu=0.07, omk=0)
zre = camb.get_zre_from_tau(pars, 0.06)
age = camb.get_age(pars)
self.assertAlmostEqual(zre, 8.39, 2)
self.assertAlmostEqual(age, 13.65, 2)
data = camb.CAMBdata()
bao = data.get_BAO([0.57, 0.27], pars)
data = camb.CAMBdata()
data.calc_background(pars)
DA = data.angular_diameter_distance(0.57)
H = data.hubble_parameter(0.27)
self.assertAlmostEqual(DA, bao[0][2], 3)
self.assertAlmostEqual(H, bao[1][1], 3)
age2 = data.physical_time(0)
self.assertAlmostEqual(age, age2, 4)
data.comoving_radial_distance(0.48)
t0 = data.conformal_time(0)
self.assertAlmostEqual(t0, data.tau0)
t1 = data.conformal_time(11.5)
t2 = data.comoving_radial_distance(11.5)
self.assertAlmostEqual(t2, t0 - t1, 2)
self.assertAlmostEqual(t1, 4200.78, 2)
chistar = data.conformal_time(0) - data.tau_maxvis
chis = np.linspace(0, chistar, 197)
zs = data.redshift_at_comoving_radial_distance(chis)
chitest = data.comoving_radial_distance(zs)
self.assertTrue(np.sum((chitest - chis) ** 2) < 1e-3)
theta = data.cosmomc_theta()
self.assertAlmostEqual(theta, 0.0104759965, 5)
derived = data.get_derived_params()
self.assertAlmostEqual(derived['age'], age, 2)
self.assertAlmostEqual(derived['rdrag'], 146.976, 2)
self.assertAlmostEqual(derived['rstar'], data.sound_horizon(derived['zstar']), 2)
# Test BBN consistency, base_plikHM_TT_lowTEB best fit model
pars.set_cosmology(H0=67.31, ombh2=0.022242, omch2=0.11977, mnu=0.06, omk=0)
self.assertAlmostEqual(pars.YHe, 0.245347, 5)
data.calc_background(pars)
self.assertAlmostEqual(data.cosmomc_theta(), 0.010408566, 7)
self.assertAlmostEqual(data.get_derived_params()['kd'], 0.14055, 4)
pars.set_cosmology(H0=67.31, ombh2=0.022242, omch2=0.11977, mnu=0.06, omk=0,
bbn_predictor=bbn.BBN_table_interpolator())
self.assertAlmostEqual(pars.YHe, 0.2453469, 5)
self.assertAlmostEqual(pars.get_Y_p(), bbn.BBN_table_interpolator().Y_p(0.022242, 0), 5)
# test massive sterile models as in Planck papers
pars.set_cosmology(H0=68.0, ombh2=0.022305, omch2=0.11873, mnu=0.06, nnu=3.073, omk=0, meffsterile=0.013)
self.assertAlmostEqual(pars.omnuh2, 0.00078, 5)
self.assertAlmostEqual(pars.YHe, 0.24573, 5)
self.assertAlmostEqual(pars.N_eff, 3.073, 4)
data.calc_background(pars)
self.assertAlmostEqual(data.get_derived_params()['age'], 13.773, 2)
self.assertAlmostEqual(data.cosmomc_theta(), 0.0104103, 6)
# test dark energy
pars.set_cosmology(H0=68.26, ombh2=0.022271, omch2=0.11914, mnu=0.06, omk=0)
pars.set_dark_energy(w=-1.0226, dark_energy_model='fluid')
data.calc_background(pars)
self.assertAlmostEqual(data.get_derived_params()['age'], 13.789, 2)
scal = data.luminosity_distance(1.4)
vec = data.luminosity_distance([1.2, 1.4, 0.1, 1.9])
self.assertAlmostEqual(scal, vec[1], 5)
pars.set_dark_energy() # re-set defaults
# test theta
pars.set_cosmology(cosmomc_theta=0.0104085, ombh2=0.022271, omch2=0.11914, mnu=0.06, omk=0)
self.assertAlmostEqual(pars.H0, 67.5512, 2)
with self.assertRaises(CAMBParamRangeError):
pars.set_cosmology(cosmomc_theta=0.0204085, ombh2=0.022271, omch2=0.11914, mnu=0.06, omk=0)
pars = camb.set_params(cosmomc_theta=0.0104077, ombh2=0.022, omch2=0.122, w=-0.95)
self.assertAlmostEqual(camb.get_background(pars, no_thermo=True).cosmomc_theta(), 0.0104077, 7)
pars = camb.set_params(thetastar=0.010311, ombh2=0.022, omch2=0.122)
self.assertAlmostEqual(camb.get_background(pars).get_derived_params()['thetastar'] / 100, 0.010311, 7)
pars = camb.set_params(thetastar=0.010311, ombh2=0.022, omch2=0.122, omk=-0.05)
self.assertAlmostEqual(camb.get_background(pars).get_derived_params()['thetastar'] / 100, 0.010311, 7)
self.assertAlmostEqual(pars.H0, 49.7148, places=3)
pars = camb.set_params(cosmomc_theta=0.0104077, ombh2=0.022, omch2=0.122, w=-0.95, wa=0,
dark_energy_model='ppf')
self.assertAlmostEqual(camb.get_background(pars, no_thermo=True).cosmomc_theta(), 0.0104077, 7)
pars = camb.set_params(cosmomc_theta=0.0104077, ombh2=0.022, omch2=0.122, w=-0.95,
dark_energy_model='DarkEnergyFluid', initial_power_model='InitialPowerLaw')
self.assertAlmostEqual(camb.get_background(pars, no_thermo=True).cosmomc_theta(), 0.0104077, 7)
with self.assertRaises(CAMBValueError):
camb.set_params(dark_energy_model='InitialPowerLaw')
data.calc_background(pars)
h2 = (data.Params.H0 / 100) ** 2
self.assertAlmostEqual(data.get_Omega('baryon'), data.Params.ombh2 / h2, 7)
self.assertAlmostEqual(data.get_Omega('nu'), data.Params.omnuh2 / h2, 7)
self.assertAlmostEqual(data.get_Omega('photon') + data.get_Omega('neutrino') + data.get_Omega('de') +
(pars.ombh2 + pars.omch2 + pars.omnuh2) / h2 + pars.omk, 1, 8)
pars.set_cosmology(H0=67, mnu=1, neutrino_hierarchy='normal')
data.calc_background(pars)
h2 = (pars.H0 / 100) ** 2
self.assertAlmostEqual(data.get_Omega('photon') + data.get_Omega('neutrino') + data.get_Omega('de') +
(pars.ombh2 + pars.omch2 + pars.omnuh2) / h2 + pars.omk, 1, 8)
redshifts = np.array([0.005, 0.01, 0.3, 0.9342, 4, 27, 321.5, 932, 1049, 1092, 2580, 1e4, 2.1e7])
self.assertTrue(
np.allclose(data.redshift_at_conformal_time(data.conformal_time(redshifts)), redshifts, rtol=1e-7))
pars.set_dark_energy(w=-1.8)
data.calc_background(pars)
self.assertTrue(
np.allclose(data.redshift_at_conformal_time(data.conformal_time(redshifts)), redshifts, rtol=1e-7))
pars.set_cosmology(cosmomc_theta=0.0104085)
data.calc_background(pars)
self.assertAlmostEqual(data.cosmomc_theta(), 0.0104085)
derived = data.get_derived_params()
pars.Accuracy.BackgroundTimeStepBoost = 2
data.calc_background(pars)
derived2 = data.get_derived_params()
self.assertAlmostEqual(derived['thetastar'], derived2['thetastar'], places=5)
pars.set_cosmology(H0=67.5, ombh2=0.022, omch2=0.122, mnu=0.11, neutrino_hierarchy='inverted')
self.assertEqual(pars.num_nu_massive, 3)
self.assertEqual(pars.nu_mass_numbers[1], 1)
self.assertEqual(pars.nu_mass_eigenstates, 2)
self.assertAlmostEqual(pars.nu_mass_fractions[0], 0.915197, places=4)
def COMPUTE_AXION_KSZ(phys,
modeEvolution,
axion_power_spectrum_file,
folder="",
MODEL=["AXION_CAMB", "CDM_CAMB"]):
###SET COMPUTATION OPTIONS
SINGULARITY = True #use substitution to deal with singularity in S(k) integrand
GAUSS = True #use Gauss-Legendre Quadrature for 2D integration (False: use Riemann integration)
COMPUTE_VISH = True #compute the vishniac spectrum (False: load from file)
READ_AXION_GROWTH_NEW = True #solve pertrubation equation numerically for axion time evolution
COMPUTE_W = True #compute the comoving distacne as function of redshift (False: load from file)
COMPUTE_D = True #compute the growth factor as function of redshift (False: load from file)
COMPUTE_T = True #compute the time as function of redshift (False: load from file)
COMPUTE_PROJECTION = True #compute projection of vishniac spectrum on the line of sight
PRINT_PARAMS = False
PLOT_MASS_POWER = False #plot mass power spectrum
PLOT_AXION_GROWTH = False #plot axion growth function
PLOT_VISIBILITY_FUNCTION = False
NUM_PLOT_VISH = 3
PLOT_APPROXIMATION = (
COMPUTE_PROJECTION and False
) #plot approximate projection (without integration) (only available when projection is being plotted)
num = IntegrationNumerics(GAUSS, gaussPoints=300)
aa = (46.9 * phys.Omega0 *
phys.h**2)**0.67 * (1.0 + (32.1 * phys.Omega0 * phys.h**2)**(-0.532))
ab = (12.0 * phys.Omega0 *
phys.h**2)**0.424 * (1.0 + (45. * phys.Omega0 * phys.h**2)**(-0.582))
al = aa**(-phys.Omega_Bh2 / phys.h**2 / phys.Omega0) * ab**(
(phys.Omega_Bh2 / phys.h**2 / phys.Omega0)**3)
correctionQ = 1 / np.sqrt(al) * 1.0104**2 / np.sqrt(
1.0 - phys.Omega_Bh2 / phys.h**2 / phys.Omega0)
#primary mass power spectrum (Cold Dark Matter) (Bardeen, Bond, Kaiser, Szalay; 1986)
def P_cdm(kp):
return ((kp / phys.H0)**phys.n) * (trans(
kp / (phys.Omega0 * phys.h**2) * correctionQ))**2
#mass power spectrum fuzzy dark matter (Hu, Barakana, Gruzinov; 2000)
def P_fcdm(kp):
kj_eq = 9 * (phys.m_axion / 1e-22)**0.5
x = 1.61 * (phys.m_axion / 1e-22)**(1 / 18) * kp / kj_eq
return (np.cos(x**3) / (1 + x**8))**2 * P_cdm(kp)
#bbks transfer function as a function of q=k/Omega0*h^2
def trans(q):
return np.log(1 + 2.34 * q) / (2.34 * q) / ((1 + 3.89 * q +
(16.1 * q)**2 +
(5.46 * q)**3 +
(6.71 * q)**4)**(1 / 4))
def sigma8(P, kmin=None, kmax=None):
R = 8 / phys.h
integrand = lambda k: k**2 * P(k) * (3 * bessel_j(1, k * R) /
(k * R))**2
if kmin is not None and kmax is not None:
return 1 / (2 * np.pi**2) * num.integrate(integrand, kmin, kmax)
else:
if kmin is None:
xmin = 0
else:
xmin = kmin / (1 + kmin)
if kmax is None:
xmax = 1
else:
xmax = kmax / (kmax + 1)
integrand_new = lambda x: integrand(x / (1 - x)) * 1 / (1 - x)**2
return 1 / (2 * np.pi**2) * num.integrate(integrand_new, xmin,
xmax)
#vishniac power spectrum
def vish_Spec(k, P=None):
def x_integrand(k, x, y, P=None):
factorA = 1 + y**2 - 2 * x * y
factorB = (1 - x**2) * (1 - 2 * x * y)**2
return P(k * y) * P(k * np.sqrt(factorA)) * factorB / factorA**2
integrand = lambda t, u: 10**u * 2 / phys.n * t**(
2 / phys.n - 1) * x_integrand(k, 1.0 - t**(2 / phys.n), 10**u, P)
integrand2 = lambda x, u: 10**u * x_integrand(k, x, 10**u, P)
lk = np.log10(k)
if SINGULARITY:
return k * np.log(10) * (num.integrate2D(integrand, 0, 2**(
phys.n / 2), min([-7 - lk, -1]), 0) + num.integrate2D(
integrand, 0, 2**(phys.n / 2), 0, max([3 - lk, 1])))
else:
return k * np.log(10) * (
num.integrate2D(integrand2, -1, 1, min([-7 - lk, -1]), 0) +
num.integrate2D(integrand2, -1, 1, 0, max([3 - lk, 1])))
def S_integrand(k, X_T, U, z, P, G, dG):
def x_integrand(k, x, y, z):
factorA = (1 - x**2)
factorB = 1 + y**2 - 2 * x * y
sqrt_factorB = np.sqrt(factorB)
a = 1 / (1 + z)
power = P(k * y) * P(k * sqrt_factorB)
numerator = factorA * (
dG(a, k * sqrt_factorB) * G(a, k * y) * y**2 -
dG(a, k * y) * G(a, k * sqrt_factorB) * factorB)**2
#numerator=factorA*(y**2-factorB)**2
denominator = factorB**2
return power * numerator / denominator
integrand = lambda t, u: 10**u * 2 / phys.n * t**(
2 / phys.n - 1) * x_integrand(k, 1.0 - t**(2 / phys.n), 10**u, z)
integrand2 = lambda x, u: 10**u * x_integrand(k, x, 10**u, z)
#return x_integrand(k, X_T, U, z)
if SINGULARITY:
return np.log(10) * integrand(X_T, U)
else:
return np.log(10) * integrand2(X_T, U)
def vish_axions(k, z, P, G, dG):
lk = np.log10(k)
if SINGULARITY:
return k * (
num.integrate2D(lambda t, u: S_integrand(k, t, u, z, P, G, dG),
0, 2**(phys.n / 2), min([-7 - lk, -1]), 0) +
num.integrate2D(lambda t, u: S_integrand(k, t, u, z, P, G, dG),
0, 2**(phys.n / 2), 0, max([3 - lk, 1])))
else:
return k * (
num.integrate2D(lambda x, u: S_integrand(k, x, u, z, P, G, dG),
-1, 1, min([-7 - lk, -1]), 0) +
num.integrate2D(lambda x, u: S_integrand(k, t, u, z, P, G, dG),
-1, 1, 0, max([3 - lk, 1])))
def C_proj_axions(ell, g, S, w, z_of_w, zmin=0, zmax=20):
#print("computing ell={}".format(ell))
dw_dz = lambda z: 1 / (phys.a0 * phys.H0 * phys.E(z))
integrand_a = lambda a: g((phys.a0 - a) / a)**2 / w(
(phys.a0 - a) / a)**2 * S(a, (ell + 1 / 2) / w(
(1 - a) / a)) * dw_dz((phys.a0 - a) / a)
integrand_loga = lambda loga: 10**loga * np.log(10) * integrand_a(10**
loga)
#integrand_z=lambda z:g(z)**2/w(z)**2*a(z)**2*S(1/(1+z), (ell+1/2)/w(z))*dw_dz(z)
return 1 / (16 * np.pi**2) * num.integrate(
integrand_loga, np.log10(phys.a0 /
(1 + zmax)), np.log10(phys.a0 /
(1 + zmin)))
#COBE normalization (Note: need to change to planck)
def deltaH():
return (1e-5) * (2.422 - 1.166 * np.exp(Omega0) +
0.800 * np.exp(OmegaLambda) + 3.780 * Omega0 -
2.267 * Omega0 * np.exp(OmegaLambda) +
0.487 * Omega0**2 + 0.561 * OmegaLambda +
3.392 * OmegaLambda * np.exp(Omega0) -
8.568 * Omega0 * OmegaLambda + 1.080 * OmegaLambda**2)
def C_proj(ell, g, D, dD, D0, S, w, z_of_w, zmin=0, zmax=20):
#print("computing ell={}".format(ell))
dw_dz = lambda z: 1 / (phys.a0 * phys.H0 * phys.E(z))
integrand_a = lambda a: g((phys.a0 - a) / a)**2 / w(
(phys.a0 - a) / a)**2 * (dD((phys.a0 - a) / a) * D(
(phys.a0 - a) / a) / D0**2)**2 * S((ell + 1 / 2) / w(
(phys.a0 - a) / a)) * dw_dz((phys.a0 - a) / a)
integrand_loga = lambda loga: 10**loga * np.log(10) * integrand_a(10**
loga)
return 1 / (16 * np.pi**2) * num.integrate(
integrand_loga, np.log10(phys.a0 /
(1 + zmax)), np.log10(phys.a0 /
(1 + zmin)))
def rmsT(cls, min, max):
return np.sqrt(num.integrate(cls, min, max) / (2 * np.pi))
axion_G_interp, axion_dG_interp = modeEvolution.get_growth(
), modeEvolution.get_dG_dt()
P_CDM = lambda k: phys.sig8**2 / sigma8(P_cdm) * P_cdm(k)
P_FCDM = lambda k: phys.sig8**2 / sigma8(P_fcdm) * P_fcdm(k)
P_AxionCAMB = np.loadtxt(axion_power_spectrum_file)
P_CAMB = np.loadtxt("../CAMB-0.1.6.1/test_matterpower.dat")
p_AxionCAMB_interp = interpolate(P_AxionCAMB[:, 0] * phys.h,
P_AxionCAMB[:, 1], P_CDM, P_CDM) #
p_CAMB_interp = interpolate(P_CAMB[:, 0] * phys.h, P_CAMB[:, 1], P_CDM,
P_CDM)
a_vals = np.logspace(-5, 0, 3000)
z_vals = (1 - a_vals) / a_vals
dz_interp = phys.get_D_interpolation(recompute=COMPUTE_D)
tz_interp, zt_interp = phys.get_t_interpolation(recompute=COMPUTE_T,
doInverse=True)
wz_interp, zw_interp = phys.get_w_interpolation(recompute=COMPUTE_W,
doInverse=True)
def get_MassPower(model):
if model == "CDM":
return lambda k: P_CDM(k)
elif model == "FCDM":
return P_FCDM
elif model == "CDM_CAMB":
return lambda k: p_CAMB_interp(k)
elif model == "AXION_CAMB":
return lambda k: p_AxionCAMB_interp(k)
elif model == "AXION_CAMB_simple":
return lambda k: p_AxionCAMB_interp(k)
for m in MODEL:
print("{}: sigma8={}".format(m, np.sqrt(sigma8(get_MassPower(m)))))
if PLOT_MASS_POWER:
plt.figure()
k_vals = np.logspace(-5, 4, 1000)
for m in MODEL:
plt.loglog(k_vals / phys.h, get_MassPower(m)(k_vals), label=m)
plt.legend()
plt.xlabel(r"$k_{ph} h^{-1} \left[Mpc^{-1}\right]$")
plt.ylabel(r"$P(k)$")
plt.title("Mass Power Spectrum")
"""
plt.figure()
k=1
lk=np.log10(k)
x_vals=np.linspace(-1, 1, 1000)
y_vals=np.logspace(-6-np.log10(k), 3-np.log10(k), 1000)
t_vals=np.linspace(0, 2**(phys.n/2), 1000)
u_vals=np.linspace(-7-np.log10(k), 3-np.log10(k), 1000)
print('plotting integrand')
tGrid,uGrid=np.meshgrid(t_vals,u_vals)
xGrid,yGrid=np.meshgrid(x_vals, y_vals)
plt.imshow(np.log10(S_integrand(k, tGrid, uGrid, phys.z_r, get_MassPower(m), axion_G_interp, axion_dG_interp)), aspect='auto')
plt.colorbar()
plt.xlabel("t")
plt.ylabel("u")
plt.show()
"""
g_func_gauss = lambda z: phys.g(wz_interp(z))
dw_dz = lambda z: 1 / (phys.a0 * phys.H0 * phys.E(z))
z_vis = np.linspace(0, 20, 5000)
pars = camb.set_params(H0=100 * phys.h,
ombh2=phys.Omega_Bh2,
omch2=phys.Omega0 * phys.h**2 - phys.Omega_Bh2,
ns=phys.n,
tau=phys.tau)
data = camb.get_background(pars)
back_ev = data.get_background_redshift_evolution(z_vis,
['x_e', 'visibility'],
format='array')
g_interpolation = glueAsymptode(
interpolate(z_vis, back_ev[:, 1]),
min=0.1,
minAsym=lambda z: interpolate(z_vis, back_ev[:, 1])(0.1) * (1 + z)**2)
norm = num.integrate(lambda z: g_interpolation(z) * dw_dz(z), min(z_vis),
max(z_vis))
g_func = lambda z: (1 - np.exp(-phys.tau)) / norm * g_interpolation(z)
if PLOT_VISIBILITY_FUNCTION:
plt.figure()
plt.plot(z_vis, g_func(z_vis))
plt.xlabel(r"$g(z)$")
plt.ylabel(r"$z$")
a_vals = np.logspace(np.log10(1 / (1 + max(z_vis))), 0, 7)
z_vals = (1 - a_vals) / a_vals
vish_interp = {}
k_vals = np.logspace(-3, 6, 300) * phys.h #physical k
if not COMPUTE_VISH:
for m in MODEL:
if m == "AXION_CAMB":
try:
kVals, aVals, vish = np.load(folder + "vishniac_" + m +
".npy")
interpolation = RectBivariateSpline(
np.log10(aVals),
np.log10(kVals),
np.log10(vish),
bbox=[
min(np.log10(aVals)),
max(np.log10(aVals)),
min(np.log10(kVals)),
max(np.log10(kVals))
])
interp_func = lambda a, k: 10**np.squeeze(
interpolation.ev(np.log10(np.array([a])),
np.log10(np.array([k]))))
vish_interp[m] = interp_func
except Exception as ex:
print(ex)
print("Vishniac spectrum for model " + m +
" does not exist yet.")
else:
try:
k_vals, vish = np.load(folder + "vishniac_" + m + ".npy")
vish_interp[m] = interpolate(k_vals, vish)
except:
print("Vishniac spectrum for model " + m +
" does not exist yet.")
print("Computing...")
with MyProcessPool(4) as p:
vish = list(
p.imap(lambda k: vish_Spec(k, get_MassPower(m)),
k_vals))
np.save(folder + "vishniac_" + m, (k, vish))
vish_interp[m] = interpolate(k, vish)
else:
#plt.figure()
vish = {}
for m in MODEL:
if m == "AXION_CAMB":
vish_z = []
for i in range(len(z_vals)):
z = z_vals[i]
print("computing S(k,z) for z={}...".format(z))
with MyProcessPool(4) as p:
vish_z.append(
list(
p.imap(
lambda k: vish_axions(
k, z, get_MassPower(m), axion_G_interp,
axion_dG_interp), k_vals)))
#if i%(len(z_vals)//NUM_PLOT_VISH + 1)==0:
#plt.loglog(k_vals/phys.h, (k_vals)**2*vish_z[-1], label=m+" at a={:.3f}".format(1/(1+z)))
vish[m] = np.array(vish_z)
try:
np.save(folder + "vishniac_" + m,
(k_vals, a_vals, vish[m]))
except Exception as ex:
print(ex)
interpolation = RectBivariateSpline(np.log10(a_vals),
np.log10(k_vals),
np.log10(vish[m]))
interp_func = lambda a, k: 10**np.squeeze(
interpolation.ev(np.log10(np.array([a])),
np.log10(np.array([k]))))
vish_interp[m] = interp_func
else:
with MyProcessPool(4) as p:
vish[m] = list(
p.imap(lambda k: vish_Spec(k, get_MassPower(m)),
k_vals))
for i in range(len(z_vals)):
if i % (len(z_vals) // NUM_PLOT_VISH + 1) == 0:
z = z_vals[i]
d_factor = (phys.dD(z) * dz_interp(z) /
phys.D(0)**2)
#plt.loglog(k_vals/phys.h, (k_vals)**2*vish[m]*d_factor**2, label=m+" at a={:.3f}".format(1/(1+z)))
else:
continue
np.save(folder + "vishniac_" + m, (k_vals, vish[m]))
vish_interp[m] = interpolate(k_vals, vish[m])
#plt.legend()
#plt.xlabel(r"$k/h$ [Mpc$^{-1}$]")
#plt.ylabel(r"$S(k) k^2$ [A.U.]")
#plt.title("Vishniac Power Spectrum")
#plt.savefig("../Axion_vishniac.png")
proj_interp = {}
if COMPUTE_PROJECTION:
#plt.figure()
l_vals = np.logspace(0, 5, 500)
pp_vals = {}
for m in MODEL:
with MyProcessPool(4) as p:
if m == "AXION_CAMB":
pp_vals[m] = list(
p.imap(
lambda l: C_proj_axions(l, g_func, vish_interp[
m], wz_interp, zw_interp), l_vals))
#plt.loglog(l_vals, l_vals*(l_vals+1)*pp_vals[m], label=m)
np.save(folder + "projectedPower_" + m,
(l_vals, pp_vals[m]))
proj_interp[m] = interpolate(l_vals, pp_vals[m])
else:
pp_vals[m] = list(
p.imap(
lambda l: C_proj(l, g_func, dz_interp, phys.dD,
phys.D(0), vish_interp[m],
wz_interp, zw_interp), l_vals))
# #plt.loglog(l_vals, l_vals*(l_vals+1)*pp_vals[m], label=m)
np.save(folder + "projectedPower_" + m,
(l_vals, pp_vals[m]))
proj_interp[m] = interpolate(l_vals, pp_vals[m])
#plt.legend()
#plt.xlabel(r"$\ell$")
#plt.ylabel(r"$\ell(\ell+1) C_\ell$")
#plt.savefig("../Axion_kSZ.png")
else:
for m in MODEL:
try:
l_vals, pp_vals = np.load(folder + "projectedPower_" + m +
".npy")
proj_interp[m] = interpolate(l_vals, pp_vals)
except:
print("Projected power spectrum for model " + m +
" does not exist yet.")
print("Computing...")
l_vals = np.logspace(1, 4, 100)
with MyProcessPool(4) as p:
if m == "AXION_CAMB":
pp_vals = list(
p.imap(
lambda l: C_proj_axions(
l, g_func, vish_interp[m], wz_interp,
zw_interp), l_vals))
np.save(folder + "projectedPower_" + m,
(l_vals, pp_vals))
proj_interp[m] = interpolate(l_vals, pp_vals)
else:
pp_vals = list(
p.imap(
lambda l: C_proj(l, g_func, dz_interp, phys.dD,
phys.D(0), vish_interp[m],
wz_interp, zw_interp),
l_vals))
np.save(folder + "projectedPower_" + m,
(l_vals, pp_vals))
proj_interp[m] = interpolate(l_vals, pp_vals)
return proj_interp
plt.savefig(path + 'bmod.pdf')
plt.close()
k=10**np.linspace(-5, 1, 50)
pars.InitPower.set_params(ns=0.96, r=0.2) #this functions imposes inflation consistency relation by default
scalar_pk= pars.scalar_power(k)
tensor_pk= pars.tensor_power(k)
plt.semilogx(k,scalar_pk);
plt.semilogx(k,tensor_pk);
plt.xlabel(r'$k \rm{Mpc}$')
plt.ylabel(r'${\cal P}(k)$')
plt.legend(['scalar', 'tensor']);
plt.savefig(path + 'scaltens.pdf')
plt.close()
pars = camb.set_params(H0=67.5, ombh2=0.022, omch2=0.122, As=2e-9, ns=0.95)
data= camb.get_background(pars)
eta = 10**(np.linspace(1, 4,300))
back_ev = data.get_background_time_evolution(eta, ['x_e', 'visibility'])
fig, axs= plt.subplots(1,2, figsize=(12,5))
axs[0].semilogx(eta, back_ev['x_e'])
axs[1].loglog(eta, back_ev['visibility'])
axs[0].set_xlabel(r'$\eta/\rm{Mpc}$')
axs[0].set_ylabel('$x_e$')
axs[1].set_xlabel(r'$\eta/\rm{Mpc}$')
axs[1].set_ylabel('Visibility');
fig.suptitle('Ionization history, including both hydrogen and helium recombination and reionization');
plt.savefig(path + 'ionz.pdf')
plt.close()
z = 10**np.linspace(2, 4, 300)
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)
#
import camb
import numpy as np
z=0.
kmin=1e-3
kmax=1e4
hh = 0.6766
# Set the cosmological parameters for our model.
cp = camb.set_params(ns=0.9665, H0=67.66, ombh2=0.02242, omch2=0.11933, w=-1.0, Alens=1.0, lmax=2000, As=(0.87/0.81)*np.exp(3.047)*10**-10,
mnu = 0.06, neutrino_hierarchy='degenerate',num_massive_neutrinos=1,YHe=0.2454,
WantTransfer=True, dark_energy_model='DarkEnergyPPF',
kmax=kmax, redshifts=[z], Want_CMB=False, Want_CMB_lensing =False,WantCls=False)
r = camb.get_results(cp)
k, z, P = r.get_linear_matter_power_spectrum('delta_nonu','delta_nonu')
PK_NN = camb.get_matter_power_interpolator(cp, nonlinear=False,
hubble_units=True, k_hunit=True, kmax=kmax,
zmax=0.1,
var1 = 'delta_nonu', var2 = 'delta_nonu')
z = 0
#kmin = -3.0
def TestAgainstCAMB(results_dir):
""" Function to compare our implementation to CAMB for the comoving angular
diameter distance, Hubble rate, and ionization fraction, as well as the
redshift of baryon drag, and sound horizon at baryon drag.
"""
# Parameters from PL18
p = Params(omega_b=0.02212,
omega_c=0.1206,
H0=66.88,
Nnu_massive=1.0,
Nnu_massless=2.046,
mnu=0.06 * eV,
Omega_k=0.,
Tcmb=2.7255,
w=-1,
Gamma_P=0.24,
F=1.14,
fDM=0.)
# Redshift range of interest for recombination
z = np.linspace(500, 2500, 1000)
# Compute recfast
zarr, Xe_H, Xe_He, Xe, TM = recfast.Xe_frac(p.Gamma_P,
p.Tcmb,
p.Omega_c,
p.Omega_b,
p.Omega_lambda,
p.Omega_k,
np.sqrt(p.hsquared),
p.Nnu_massless + p.Nnu_massive,
p.F,
p.fDM,
switch=1)
xe = interp1d(zarr, Xe, kind='cubic')
# Comopute ionization history from CAMB (also uses RECFAST)
camb_res = camb.get_background(
camb.set_params(H0=p.H0,
ombh2=p.omega_b,
omch2=p.omega_c,
mnu=p.mnu,
nnu=p.Nnu_massive + p.Nnu_massless,
tau=0.07,
YHe=p.Gamma_P,
recombination_model='Recfast'))
back_ev = camb_res.get_background_redshift_evolution(z, ['x_e'],
format='array')
# 1. Plot comparison of ionization histories
fig, ax = plt.subplots(1, 1)
ax.plot(z, xe(z), label=r"${\rm Ours}$")
ax.plot(z, back_ev[:, 0], label=r"${\rm CAMB}$")
ax.legend(loc=4, frameon=False)
ax.tick_params(axis='both', direction='inout')
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)
ax.set_ylabel(r"${\rm Ionization~Fraction,}~X_{\rm e}$")
ax.set_xlabel(r"${\rm Redshift,}~z$")
fig.savefig(results_dir / "CompareXeCAMB.pdf")
# 2. Plot comparison of comoving angular diameter distance
z = np.linspace(0, 4, 100)
DA = camb_res.angular_diameter_distance(z)
ourda = np.vectorize(lambda x: angular_diameter_distance(x, p))
fig, ax = plt.subplots(1, 1)
ax.plot(z, DA, label=r"${\rm CAMB}$")
ax.plot(z, ourda(z) / Mpc / (1 + z), '--', label=r"${\rm Ours}$")
ax.legend(loc=2, frameon=False)
ax.set_ylabel(
r"${\rm Comoving~Angular~Diameter~Distance,}~D_A(z)~({\rm Mpc})$")
ax.set_xlabel(r"${\rm Redshift,}~z$")
ax.tick_params(axis='both', direction='inout')
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)
fig.savefig(results_dir / "CompareDACAMB.pdf")
# 3. Plot comparison of Hubble rate
z = np.linspace(0, 4, 100)
CAMB_H = camb_res.hubble_parameter(z)
ourH = np.vectorize(lambda x: H(x, p))
fig, ax = plt.subplots(1, 1)
ax.plot(z, CAMB_H, label=r"${\rm CAMB}$")
ax.plot(z, ourH(z) / km * second * Mpc, '--', label=r"${\rm Ours}$")
ax.legend(loc=2, frameon=False)
ax.set_ylabel(r"${\rm Hubble~Rate,}~H(z)~({\rm km/s/Mpc})$")
ax.set_xlabel(r"${\rm Redshift,}~z$")
ax.tick_params(axis='both', direction='inout')
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)
fig.savefig(results_dir / "CompareHCAMB.pdf")
# Compare derived parameters
CAMB_params = camb_res.get_derived_params()
print("Dark Energy")
print("-----------------------")
print("CAMB: ", camb_res.get_Omega('de'))
print("Ours: ", p.Omega_lambda)
print("Redshift of baryon drag")
print("-----------------------")
print("CAMB: ", CAMB_params['zdrag'])
print("Ours: ", z_drag(p))
print("Sound Horizon at Baryon Drag")
print("----------------------------")
print("CAMB :", camb_res.sound_horizon(CAMB_params['zdrag']))
print("Ours :", r_drag(p) / Mpc)
return
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'})
def testBackground(self):
pars = camb.CAMBparams()
pars.set_cosmology(H0=68.5, ombh2=0.022, omch2=0.122, YHe=0.2453, mnu=0.07, omk=0)
zre = camb.get_zre_from_tau(pars, 0.06)
age = camb.get_age(pars)
self.assertAlmostEqual(zre, 8.39, 2)
self.assertAlmostEqual(age, 13.65, 2)
data = camb.CAMBdata()
bao = data.get_BAO([0.57, 0.27], pars)
data = camb.CAMBdata()
data.calc_background(pars)
DA = data.angular_diameter_distance(0.57)
H = data.hubble_parameter(0.27)
self.assertAlmostEqual(DA, bao[0][2], 3)
self.assertAlmostEqual(H, bao[1][1], 3)
age2 = data.physical_time(0)
self.assertAlmostEqual(age, age2, 4)
data.comoving_radial_distance(0.48)
t0 = data.conformal_time(0)
self.assertAlmostEqual(t0, data.tau0)
t1 = data.conformal_time(11.5)
t2 = data.comoving_radial_distance(11.5)
self.assertAlmostEqual(t2, t0 - t1, 2)
self.assertAlmostEqual(t1, 4200.78, 2)
chistar = data.conformal_time(0) - data.tau_maxvis
chis = np.linspace(0, chistar, 197)
zs = data.redshift_at_comoving_radial_distance(chis)
chitest = data.comoving_radial_distance(zs)
self.assertTrue(np.sum((chitest - chis) ** 2) < 1e-3)
theta = data.cosmomc_theta()
self.assertAlmostEqual(theta, 0.0104759965, 5)
derived = data.get_derived_params()
self.assertAlmostEqual(derived['age'], age, 2)
self.assertAlmostEqual(derived['rdrag'], 146.976, 2)
self.assertAlmostEqual(derived['rstar'], data.sound_horizon(derived['zstar']), 2)
# Test BBN consistency, base_plikHM_TT_lowTEB best fit model
pars.set_cosmology(H0=67.31, ombh2=0.022242, omch2=0.11977, mnu=0.06, omk=0)
self.assertAlmostEqual(pars.YHe, 0.245347, 5)
data.calc_background(pars)
self.assertAlmostEqual(data.cosmomc_theta(), 0.010408566, 7)
self.assertAlmostEqual(data.get_derived_params()['kd'], 0.14055, 4)
pars.set_cosmology(H0=67.31, ombh2=0.022242, omch2=0.11977, mnu=0.06, omk=0,
bbn_predictor=bbn.BBN_table_interpolator())
self.assertAlmostEqual(pars.YHe, 0.2453469, 5)
self.assertAlmostEqual(pars.get_Y_p(), bbn.BBN_table_interpolator().Y_p(0.022242, 0), 5)
# test massive sterile models as in Planck papers
pars.set_cosmology(H0=68.0, ombh2=0.022305, omch2=0.11873, mnu=0.06, nnu=3.073, omk=0, meffsterile=0.013)
self.assertAlmostEqual(pars.omnuh2, 0.00078, 5)
self.assertAlmostEqual(pars.YHe, 0.24573, 5)
self.assertAlmostEqual(pars.N_eff, 3.073, 4)
data.calc_background(pars)
self.assertAlmostEqual(data.get_derived_params()['age'], 13.773, 2)
self.assertAlmostEqual(data.cosmomc_theta(), 0.0104103, 6)
# test dark energy
pars.set_cosmology(H0=68.26, ombh2=0.022271, omch2=0.11914, mnu=0.06, omk=0)
pars.set_dark_energy(w=-1.0226, dark_energy_model='fluid')
data.calc_background(pars)
self.assertAlmostEqual(data.get_derived_params()['age'], 13.789, 2)
scal = data.luminosity_distance(1.4)
vec = data.luminosity_distance([1.2, 1.4, 0.1, 1.9])
self.assertAlmostEqual(scal, vec[1], 5)
pars.set_dark_energy() # re-set defaults
# test theta
pars.set_cosmology(cosmomc_theta=0.0104085, ombh2=0.022271, omch2=0.11914, mnu=0.06, omk=0)
self.assertAlmostEqual(pars.H0, 67.5512, 2)
with self.assertRaises(CAMBParamRangeError):
pars.set_cosmology(cosmomc_theta=0.0204085, ombh2=0.022271, omch2=0.11914, mnu=0.06, omk=0)
pars = camb.set_params(cosmomc_theta=0.0104077, ombh2=0.022, omch2=0.122, w=-0.95)
self.assertAlmostEqual(camb.get_background(pars, no_thermo=True).cosmomc_theta(), 0.0104077, 7)
pars = camb.set_params(thetastar=0.010311, ombh2=0.022, omch2=0.122)
self.assertAlmostEqual(camb.get_background(pars).get_derived_params()['thetastar'] / 100, 0.010311, 7)
pars = camb.set_params(thetastar=0.010311, ombh2=0.022, omch2=0.122, omk=-0.05)
self.assertAlmostEqual(camb.get_background(pars).get_derived_params()['thetastar'] / 100, 0.010311, 7)
self.assertAlmostEqual(pars.H0, 49.7148, places=3)
pars = camb.set_params(cosmomc_theta=0.0104077, ombh2=0.022, omch2=0.122, w=-0.95, wa=0,
dark_energy_model='ppf')
self.assertAlmostEqual(camb.get_background(pars, no_thermo=True).cosmomc_theta(), 0.0104077, 7)
pars = camb.set_params(cosmomc_theta=0.0104077, ombh2=0.022, omch2=0.122, w=-0.95,
dark_energy_model='DarkEnergyFluid', initial_power_model='InitialPowerLaw')
self.assertAlmostEqual(camb.get_background(pars, no_thermo=True).cosmomc_theta(), 0.0104077, 7)
with self.assertRaises(CAMBValueError):
camb.set_params(dark_energy_model='InitialPowerLaw')
data.calc_background(pars)
h2 = (data.Params.H0 / 100) ** 2
self.assertAlmostEqual(data.get_Omega('baryon'), data.Params.ombh2 / h2, 7)
self.assertAlmostEqual(data.get_Omega('nu'), data.Params.omnuh2 / h2, 7)
self.assertAlmostEqual(data.get_Omega('photon') + data.get_Omega('neutrino') + data.get_Omega('de') +
(pars.ombh2 + pars.omch2 + pars.omnuh2) / h2 + pars.omk, 1, 8)
pars.set_cosmology(H0=67, mnu=1, neutrino_hierarchy='normal')
data.calc_background(pars)
h2 = (pars.H0 / 100) ** 2
self.assertAlmostEqual(data.get_Omega('photon') + data.get_Omega('neutrino') + data.get_Omega('de') +
(pars.ombh2 + pars.omch2 + pars.omnuh2) / h2 + pars.omk, 1, 8)
redshifts = np.array([0.005, 0.01, 0.3, 0.9342, 4, 27, 321.5, 932, 1049, 1092, 2580, 1e4, 2.1e7])
self.assertTrue(
np.allclose(data.redshift_at_conformal_time(data.conformal_time(redshifts)), redshifts, rtol=1e-7))
pars.set_dark_energy(w=-1.8)
data.calc_background(pars)
self.assertTrue(
np.allclose(data.redshift_at_conformal_time(data.conformal_time(redshifts)), redshifts, rtol=1e-7))
pars.set_cosmology(cosmomc_theta=0.0104085)
data.calc_background(pars)
self.assertAlmostEqual(data.cosmomc_theta(), 0.0104085)
derived = data.get_derived_params()
pars.Accuracy.BackgroundTimeStepBoost = 2
data.calc_background(pars)
derived2 = data.get_derived_params()
self.assertAlmostEqual(derived['thetastar'], derived2['thetastar'], places=5)
pars.set_cosmology(H0=67.5, ombh2=0.022, omch2=0.122, mnu=0.11, neutrino_hierarchy='inverted')
self.assertEqual(pars.num_nu_massive, 3)
self.assertEqual(pars.nu_mass_numbers[1], 1)
self.assertEqual(pars.nu_mass_eigenstates, 2)
self.assertAlmostEqual(pars.nu_mass_fractions[0], 0.915197, places=4)
ps_theory = {}
import camb
camb_lmin = 0
camb_lmax = 10000
l_camb = np.arange(camb_lmin, camb_lmax)
cosmo_params = {
"H0": 67.5,
"As": 1e-10 * np.exp(3.044),
"ombh2": 0.02237,
"omch2": 0.1200,
"ns": 0.9649,
"Alens": 1.0,
"tau": 0.0544
}
pars = camb.set_params(**cosmo_params)
pars.set_for_lmax(camb_lmax, lens_potential_accuracy=1)
results = camb.get_results(pars)
powers = results.get_cmb_power_spectra(pars, CMB_unit="muK")
for c, spec in enumerate(["TT", "EE", "BB", "TE"]):
ps_theory[spec] = powers["total"][:, c][:camb_lmax] * 2 * np.pi / (
l_camb * (l_camb + 1))
ps_theory[spec][0], ps_theory[spec][1] = 0, 0
# Cov mat pspy
print("cov mat pspy")
mbb_inv, Bbl = so_mcm.mcm_and_bbl_spin0(window,
binning_file,
lmax=lmax,
def update(self, **new_params):
# Check if params dict contains valid parameters
#check_params(new_params,self._default_params)
# If model_type or model_name is updated, check if model_name is valid
if ('model_type' in new_params) and ('model_name' in new_params):
check_model(new_params['model_type'], new_params['model_name'])
elif 'model_type' in new_params:
check_model(new_params['model_type'], self.model_name)
elif 'model_name' in new_params:
check_model(self.model_type, new_params['model_name'])
# Clear cached properties so they can be updated
for attribute in self._update_list:
# Use built-in hmf updater to change h
if attribute != 'cosmo_input':
delattr(self, attribute)
self._update_list = []
# Set new parameter values
for key in new_params:
if key != 'cosmo_input':
setattr(self, key, new_params[key])
if 'cosmo_input' in new_params:
temp = new_params['cosmo_input']
for key in temp:
self.cosmo_input[key] = temp[key]
self.camb_pars = camb.set_params(
H0=self.cosmo_input['H0'],
cosmomc_theta=self.cosmo_input['cosmomc_theta'],
ombh2=self.cosmo_input['ombh2'],
omch2=self.cosmo_input['omch2'],
omk=self.cosmo_input['omk'],
neutrino_hierarchy=self.cosmo_input['neutrino_hierarchy'],
num_massive_neutrinos=self.
cosmo_input['num_massive_neutrinos'],
mnu=self.cosmo_input['mnu'],
nnu=self.cosmo_input['nnu'],
YHe=self.cosmo_input['YHe'],
meffsterile=self.cosmo_input['meffsterile'],
standard_neutrino_neff=self.
cosmo_input['standard_neutrino_neff'],
TCMB=self.cosmo_input['TCMB'],
tau=self.cosmo_input['tau'],
deltazrei=self.cosmo_input['deltazrei'],
bbn_predictor=self.cosmo_input['bbn_predictor'],
theta_H0_range=self.cosmo_input['theta_H0_range'],
w=self.cosmo_input['w'],
wa=self.cosmo_input['wa'],
cs2=self.cosmo_input['cs2'],
dark_energy_model=self.cosmo_input['dark_energy_model'],
As=self.cosmo_input['As'],
ns=self.cosmo_input['ns'],
nrun=self.cosmo_input['nrun'],
nrunrun=self.cosmo_input['nrunrun'],
r=self.cosmo_input['r'],
nt=self.cosmo_input['nt'],
ntrun=self.cosmo_input['ntrun'],
pivot_scalar=self.cosmo_input['pivot_scalar'],
pivot_tensor=self.cosmo_input['pivot_tensor'],
parameterization=self.cosmo_input['parameterization'],
halofit_version=self.cosmo_input['halofit_version'])
import camb
# Some standard cosmo parameters
cosmo_params = d["cosmo_params"]
camb_cosmo = {k: v for k, v in cosmo_params.items() if k not in ["logA", "As"]}
camb_cosmo.update({
"As": 1e-10 * np.exp(cosmo_params["logA"]),
"lmax": ell_max,
"lens_potential_accuracy": d["lens_potential_accuracy"],
"lens_margin": d["lens_margin"],
"AccuracyBoost": d["AccuracyBoost"],
"lSampleBoost": d["lSampleBoost"],
"lAccuracyBoost": d["lAccuracyBoost"]
})
pars = camb.set_params(**camb_cosmo)
results = camb.get_results(pars)
powers = results.get_cmb_power_spectra(pars, CMB_unit="muK")
dls = {}
dls["tt"] = powers["total"][ell_min:ell_max][:, 0]
dls["ee"] = powers["total"][ell_min:ell_max][:, 1]
dls["bb"] = powers["total"][ell_min:ell_max][:, 2]
dls["te"] = powers["total"][ell_min:ell_max][:, 3]
cosmo_fg_dir = ("sim_data/cosmo_and_fg")
pspy_utils.create_directory(cosmo_fg_dir)
np.savetxt("%s/cosmo_spectra.dat" % cosmo_fg_dir,
np.transpose([ell, dls["tt"], dls["ee"], dls["bb"], dls["te"]]))
fig, ax = plt.subplots(2, 1, figsize=(12, 12))
kmin = 1e-3
kmax = 1e4
hh = 0.6766
cp = camb.set_params(ns=0.9665,
H0=67.66,
ombh2=0.02242,
omch2=0.11933,
w=-1.0,
Alens=1.0,
lmax=2000,
As=np.exp(3.047) * 10**-10,
mnu=0.06,
neutrino_hierarchy='degenerate',
num_massive_neutrinos=1,
YHe=0.2454,
WantTransfer=True,
dark_energy_model='DarkEnergyPPF',
kmax=kmax,
redshifts=[z],
Want_CMB=False,
Want_CMB_lensing=False,
WantCls=False)
r = camb.get_results(cp)
k, z, P = r.get_linear_matter_power_spectrum('delta_nonu', 'delta_nonu')
PK_NN = camb.get_matter_power_interpolator(cp,
