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 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 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'})
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,