def test_bcm_correct_smoke(): k_arr = np.geomspace(1E-2, 1, 10) fka = ccl.bcm_model_fka(COSMO, k_arr, 0.5) pk_nobar = ccl.nonlin_matter_power(COSMO, k_arr, 0.5) ccl.bcm_correct_pk2d(COSMO, COSMO._pk_nl['delta_matter:delta_matter']) pk_wbar = ccl.nonlin_matter_power(COSMO, k_arr, 0.5) assert np.all(np.fabs(pk_wbar / (pk_nobar * fka) - 1) < 1E-5)
def test_sampling_error(self): """ P(k) is sampled within some finite window in the interval `[kmin, kmax]`, where `kmin=2pi/L` and `kmax=2pi*sqrt(3)*(N/2)*(1/L)` (for 3D FT). The lack of sampling in some regions of k-space means that sigma8 can't be perfectly reconstructed (see U-L. Pen, arXiv:astro-ph/9709261 for a discussion). This function calculates sigma8 from the realised box, and compares this with the theoretical calculation for sigma8 over a large k-window, and over a k-window of the same size as for the box. """ # Calc. sigma8 from the realisation s8_real = self.sigma8() # Calc. theoretical sigma8 in same k-window as realisation _k = np.linspace(self.kmin, self.kmax, int(5e3)) _pk = ccl.nonlin_matter_power(self.cosmo, k=_k, a=self.scale_factor) _y = _k**2. * _pk * self.window(_k, 8.0 / self.cosmo['h']) _y = np.nan_to_num(_y) s8_th_win = np.sqrt(scipy.integrate.simps(_y, _k) / (2. * np.pi**2.)) # Calc. full sigma8 (in window that is wide enough) _k2 = np.logspace(-5, 2, int(5e4)) _pk2 = ccl.nonlin_matter_power(self.cosmo, k=_k2, a=self.scale_factor) _y2 = _k2**2. * _pk2 * self.window(_k2, 8.0 / self.cosmo['h']) _y2 = np.nan_to_num(_y2) s8_th_full = np.sqrt( scipy.integrate.simps(_y2, _k2) / (2. * np.pi**2.)) # Calculate sigma8 in real space dk = np.reshape(self.delta_k, np.shape(self.k)) dk = dk * self.window1(self.k, 8.0 / self.cosmo['h']) dk = np.nan_to_num(dk) dx = fft.ifftn(dk) s8_realspace = np.std(dx) # sigma20 dk = np.reshape(self.delta_k, np.shape(self.k)) dk = dk * self.window1(self.k, 20.0 / self.cosmo['h']) dk = np.nan_to_num(dk) dx = fft.ifftn(dk) s20_realspace = np.std(dx) s20_real = self.sigmaR(20.) # Print report print("") print("sigma8 (real.): \t", s8_real) print("sigma8 (th.win.):\t", s8_th_win) print("sigma8 (th.full):\t", s8_th_full) print("sigma8 (realsp.):\t", s8_realspace) print("ratio =", 1. / (s8_real / s8_realspace)) print("") print("sigma20 (real.): \t", s20_real) print("sigma20 (realsp.):\t", s20_realspace) print("ratio =", 1. / (s20_real / s20_realspace)) print("var(delta) =", np.std(self.delta_x))
def test_transfer_matter_power_nu_raises(tf, pk, m_nu): cosmo = ccl.Cosmology( Omega_c=0.27, Omega_b=0.045, h=0.67, sigma8=0.8, n_s=0.96, transfer_function=tf, matter_power_spectrum=pk, m_nu=m_nu) if tf is not None: with pytest.warns(CCLWarning): ccl.linear_matter_power(cosmo, 1, 1) with pytest.raises(CCLError): ccl.nonlin_matter_power(cosmo, 1, 1)
def test_mu_sigma_matter_power_err(mp): with pytest.raises(ccl.CCLError): cosmo = ccl.Cosmology(Omega_c=0.25, Omega_b=0.05, h=0.7, A_s=2.1e-9, n_s=0.96, mu_0=0.1, sigma_0=0.2, transfer_function=None, matter_power_spectrum=mp) ccl.nonlin_matter_power(cosmo, 1, 1)
def test_halofit_highz(cosmo): vals = [(25, 75)] + list(zip(range(0, 98), range(1, 99))) for zl, zh in vals: al = 1.0 / (1 + zl) ah = 1.0 / (1 + zh) k = np.logspace(0, 2, 10) pkratl = (ccl.nonlin_matter_power(cosmo, k, al) / ccl.linear_matter_power(cosmo, k, al)) pkrath = (ccl.nonlin_matter_power(cosmo, k, ah) / ccl.linear_matter_power(cosmo, k, ah)) assert np.all(pkratl >= pkrath), (zl, zh, pkratl, pkrath)
def check_power(cosmo): """ Check that power spectrum and sigma functions can be run. """ # Types of scale factor a = 0.9 a_arr = np.linspace(0.2, 1., 5) # Types of wavenumber input (scalar, list, array) k_scl = 1e-1 k_lst = [1e-4, 1e-3, 1e-2, 1e-1, 1e0] k_arr = np.logspace(-4., 0., 5) # Types of smoothing scale, R R_scl = 8. R_lst = [1., 5., 10., 20., 50., 100.] R_arr = np.array([1., 5., 10., 20., 50., 100.]) # linear_matter_power assert_(all_finite(ccl.linear_matter_power(cosmo, k_scl, a))) assert_(all_finite(ccl.linear_matter_power(cosmo, k_lst, a))) assert_(all_finite(ccl.linear_matter_power(cosmo, k_arr, a))) assert_raises(TypeError, ccl.linear_matter_power, cosmo, k_scl, a_arr) assert_raises(TypeError, ccl.linear_matter_power, cosmo, k_lst, a_arr) assert_raises(TypeError, ccl.linear_matter_power, cosmo, k_arr, a_arr) # nonlin_matter_power assert_(all_finite(ccl.nonlin_matter_power(cosmo, k_scl, a))) assert_(all_finite(ccl.nonlin_matter_power(cosmo, k_lst, a))) assert_(all_finite(ccl.nonlin_matter_power(cosmo, k_arr, a))) assert_raises(TypeError, ccl.nonlin_matter_power, cosmo, k_scl, a_arr) assert_raises(TypeError, ccl.nonlin_matter_power, cosmo, k_lst, a_arr) assert_raises(TypeError, ccl.nonlin_matter_power, cosmo, k_arr, a_arr) # sigmaR assert_(all_finite(ccl.sigmaR(cosmo, R_scl))) assert_(all_finite(ccl.sigmaR(cosmo, R_lst))) assert_(all_finite(ccl.sigmaR(cosmo, R_arr))) # sigmaV assert_(all_finite(ccl.sigmaV(cosmo, R_scl))) assert_(all_finite(ccl.sigmaV(cosmo, R_lst))) assert_(all_finite(ccl.sigmaV(cosmo, R_arr))) # sigma8 assert_(all_finite(ccl.sigma8(cosmo)))
def __init__(self, cosmo, hmc, k_range=[0.1, 5], nlk=128, z_range=[0., 6.], nz=16): k_arr = np.geomspace(*k_range, nlk) a_arr = 1 / (1 + np.linspace(*z_range, nz)) a_arr = a_arr[::-1] cM = hmc.mass_def.concentration # extract concentration from mass_def NFW = ccl.halos.profiles.HaloProfileNFW(c_m_relation=cM) pk_hm = ccl.halos.halomod_power_spectrum(cosmo, hmc, k_arr, a_arr, NFW, normprof=True, normprof2=True) pk_hf = np.array( [ccl.nonlin_matter_power(cosmo, k_arr, a) for a in a_arr]) ratio = pk_hf / pk_hm self.rk_func = interp2d(np.log10(k_arr), a_arr, ratio, bounds_error=False, fill_value=1)
def calc_power_spectrum(Omega_v, w0, wa, transfer_fn, matter_power, linear, raise_errors): """ Calculate linear and nonlinear power spectrum for a given set of parameters and choices of transfer function and matter power spectrum. """ k = np.logspace(-5., 1., 300) a = np.logspace(np.log10(0.51), 0., 5) # Emulator only works at z<2 # Set Omega_K in a consistent way Omega_k = 1.0 - Omega_c - Omega_b - Omega_v if (raise_errors == False): if (transfer_fn == 'eisenstein_hu' or transfer_fn == 'bbks'): mnu = 0. # The bbks and E-H P(k) are not defined for massive neutrinos. elif (transfer_fn == 'emulator' and matter_power == 'emu'): mnu = mnu_list # For the emulator, we must have 3 equal masses else: mnu = mnu_sum elif (raise_errors == True): if (transfer_fn == 'eisenstein_hu' or transfer_fn == 'bbks'): mnu = mnu_sum #Use massive neutrinos to deliberately raise an error elif (transfer_fn == 'emulator' and matter_power == 'emu'): mnu = mnu_sum #Use a sum instead of an equal list to deliberately raise an error. else: raise ( ValueError, "Transfer function %s with matter power spectrum method %s has no case for which to test errors are raised." % (transfer_fn, matter_power)) # Create new Parameters and Cosmology objects cosmo = ccl.Cosmology(Omega_c=Omega_c, Omega_b=Omega_b, h=h, sigma8=sigma8, n_s=n_s, Omega_k=Omega_k, w0=w0, wa=wa, transfer_function=transfer_fn, matter_power_spectrum=matter_power, Neff=Neff, m_nu=mnu) # Calculate linear and nonlinear power spectra for each scale factor, a for _a in a: if linear: if raise_errors == False: pk_lin = ccl.linear_matter_power(cosmo, k, _a) assert_(all_finite(pk_lin)) else: assert_raises(RuntimeError, ccl.linear_matter_power, cosmo, k, _a) else: if raise_errors == False: pk_nl = ccl.nonlin_matter_power(cosmo, k, _a) assert_(all_finite(pk_nl)) else: assert_raises(RuntimeError, ccl.nonlin_matter_power, cosmo, k, _a)
def test_nonlin_matter_power_halomod(k): a = 0.8 pk = ccl.nonlin_matter_power(COSMO_HM, k, a) # New implementation mdef = ccl.halos.MassDef('vir', 'matter') hmf = ccl.halos.MassFuncSheth99(COSMO_HM, mdef, mass_def_strict=False, use_delta_c_fit=True) hbf = ccl.halos.HaloBiasSheth99(COSMO_HM, mass_def=mdef, mass_def_strict=False) cc = ccl.halos.ConcentrationDuffy08(mdef) prf = ccl.halos.HaloProfileNFW(cc) hmc = ccl.halos.HMCalculator(COSMO_HM, hmf, hbf, mdef) pkb = ccl.halos.halomod_power_spectrum(COSMO_HM, hmc, k, a, prf, normprof1=True) assert np.allclose(pk, pkb) assert np.all(np.isfinite(pk)) assert np.shape(pk) == np.shape(k)
def test_power_nu(model): mnu = [[0.04, 0., 0.], [0.05, 0.01, 0.], [0.03, 0.02, 0.04]] w_0 = [-1.0, -0.9, -0.9] w_a = [0.0, 0.0, 0.1] cosmo = ccl.Cosmology(Omega_c=0.25, Omega_b=0.05, h=0.7, A_s=2.1e-9, n_s=0.96, Neff=3.046, Omega_k=0, w0=w_0[model], wa=w_a[model], m_nu=mnu[model], m_nu_type='list', transfer_function='boltzmann_class') a = 1 data_lin = np.loadtxt("./benchmarks/data/model%d_pk_nu.txt" % (model + 1)) k_lin = data_lin[:, 0] * cosmo['h'] pk_lin = data_lin[:, 1] / (cosmo['h']**3) pk_lin_ccl = ccl.linear_matter_power(cosmo, k_lin, a) err = np.abs(pk_lin_ccl / pk_lin - 1) assert np.allclose(err, 0, rtol=0, atol=POWER_NU_TOL) data_nl = np.loadtxt("./benchmarks/data/model%d_pk_nl_nu.txt" % (model + 1)) k_nl = data_nl[:, 0] * cosmo['h'] pk_nl = data_nl[:, 1] / (cosmo['h']**3) pk_nl_ccl = ccl.nonlin_matter_power(cosmo, k_nl, a) err = np.abs(pk_nl_ccl / pk_nl - 1) assert np.allclose(err, 0, rtol=0, atol=POWER_NU_TOL)
def test_halomod_f2d_copy(): mdef = ccl.halos.MassDef('vir', 'matter') hmf = ccl.halos.MassFuncSheth99(COSMO_HM, mdef, mass_def_strict=False, use_delta_c_fit=True) hbf = ccl.halos.HaloBiasSheth99(COSMO_HM, mass_def=mdef, mass_def_strict=False) cc = ccl.halos.ConcentrationDuffy08(mdef) prf = ccl.halos.HaloProfileNFW(cc) hmc = ccl.halos.HMCalculator(COSMO_HM, hmf, hbf, mdef) pk2d = ccl.halos.halomod_Pk2D(COSMO_HM, hmc, prf, normprof1=True) psp_new = pk2d.psp # This just triggers the internal calculation pk_old = ccl.nonlin_matter_power(COSMO_HM, 1., 0.8) pk_new = pk2d.eval(1., 0.8, COSMO_HM) psp_old = COSMO_HM.cosmo.data.p_nl assert psp_new.lkmin == psp_old.lkmin assert psp_new.lkmax == psp_old.lkmax assert psp_new.amin == psp_old.amin assert psp_new.amax == psp_old.amax assert psp_new.is_factorizable == psp_old.is_factorizable assert psp_new.is_k_constant == psp_old.is_k_constant assert psp_new.is_a_constant == psp_old.is_a_constant assert psp_new.is_log == psp_old.is_log assert psp_new.growth_factor_0 == psp_old.growth_factor_0 assert psp_new.growth_exponent == psp_old.growth_exponent assert psp_new.extrap_order_lok == psp_old.extrap_order_lok assert psp_new.extrap_order_hik == psp_old.extrap_order_hik assert pk_old == pk_new
def test_emu(model): model_numbers = [1, 3, 5, 6, 8, 10] data = np.loadtxt("./benchmarks/data/emu_smooth_pk_M%d.txt" % model_numbers[model]) cosmos = np.loadtxt("./benchmarks/data/emu_cosmologies.txt") cosmo = ccl.Cosmology( Omega_c=cosmos[model, 0], Omega_b=cosmos[model, 1], h=cosmos[model, 2], sigma8=cosmos[model, 3], n_s=cosmos[model, 4], w0=cosmos[model, 5], wa=cosmos[model, 6], Neff=3.04, Omega_g=0, Omega_k=0, transfer_function='bbks', matter_power_spectrum='emu', ) a = 1 k = data[:, 0] pk = ccl.nonlin_matter_power(cosmo, k, a) err = np.abs(pk / data[:, 1] - 1) assert np.allclose(err, 0, rtol=0, atol=EMU_TOLERANCE)
def test_emu_nu(model): model_numbers = [38, 39, 40, 42] data = np.loadtxt("./benchmarks/data/emu_nu_smooth_pk_M%d.txt" % model_numbers[model]) cosmos = np.loadtxt("./benchmarks/data/emu_nu_cosmologies.txt") mnu = ccl.nu_masses(cosmos[model, 7] * cosmos[model, 2]**2, 'equal', T_CMB=2.725) cosmo = ccl.Cosmology( Omega_c=cosmos[model, 0], Omega_b=cosmos[model, 1], h=cosmos[model, 2], sigma8=cosmos[model, 3], n_s=cosmos[model, 4], w0=cosmos[model, 5], wa=cosmos[model, 6], m_nu=mnu, m_nu_type='list', Neff=3.04, Omega_g=0, Omega_k=0, transfer_function='boltzmann_class', matter_power_spectrum='emu', ) a = 1 k = data[:, 0] pk = ccl.nonlin_matter_power(cosmo, k, a) err = np.abs(pk / data[:, 1] - 1) assert np.allclose(err, 0, rtol=0, atol=EMU_TOLERANCE)
def test_nonlin_camb_power_with_sigma8(): Omega_c = 0.25 Omega_b = 0.05 n_s = 0.97 h = 0.7 ccl_cosmo = ccl.Cosmology(Omega_c=Omega_c, Omega_b=Omega_b, h=h, m_nu=0.0, sigma8=0.8, n_s=n_s, transfer_function="boltzmann_camb", matter_power_spectrum="camb") k = np.logspace(-3, 1, 10) # Check that non-linear power spectrum isn't being used with sigma8 with assert_raises(ccl.errors.CCLError): ccl.nonlin_matter_power(ccl_cosmo, k, 1.0)
def test_pk2d_from_model_emu(): pars = [0.3643, 0.071075, 0.55, 0.8333, 0.9167, -0.7667, 0.1944] cosmo_fixed = ccl.Cosmology(Omega_c=pars[0], Omega_b=pars[1], h=pars[2], sigma8=pars[3], n_s=pars[4], w0=pars[5], wa=pars[6], Neff=3.04, Omega_g=0, Omega_k=0, transfer_function='bbks') cosmo = ccl.Cosmology(Omega_c=pars[0], Omega_b=pars[1], h=pars[2], sigma8=pars[3], n_s=pars[4], w0=pars[5], wa=pars[6], Neff=3.04, Omega_g=0, Omega_k=0, transfer_function='bbks', matter_power_spectrum='emu') pk = ccl.Pk2D.pk_from_model(cosmo_fixed, model='emu') ks = np.geomspace(1E-3, 1E1, 128) for z in [0., 0.5, 2.]: a = 1. / (1 + z) pk1 = pk.eval(ks, a, cosmo) pk2 = ccl.nonlin_matter_power(cosmo, ks, a) maxdiff = np.amax(np.fabs(pk1 / pk2 - 1)) assert maxdiff < 1E-10
def compute_covmat_cv(cosmo, zm, dndz): # Area COSMOS area_deg2 = 1.7 area_rad2 = area_deg2 * (np.pi / 180)**2 theta_rad = np.sqrt(area_rad2 / np.pi) # TODO: Where do we get the area # Bin widths dz = np.mean(zm[1:] - zm[:-1]) # Number of galaxies in each bin dn = dndz * dz # z bin edges zb = np.append((zm - dz / 2.), zm[-1] + dz / 2.) # Comoving distance to bin edges chis = ccl.comoving_radial_distance(cosmo, 1. / (1 + zb)) # Mean comoving distance in each bin chi_m = 0.5 * (chis[1:] + chis[:-1]) # Comoving distance width dchi = chis[1:] - chis[:-1] # Disc radii R_m = theta_rad * chi_m # Galaxy bias b_m = 0.95 / ccl.growth_factor(cosmo, 1. / (1 + zm)) # Growth rate (for RSDs) f_m = ccl.growth_rate(cosmo, 1. / (1 + zm)) # Transverse k bins n_kt = 512 # Parallel k bins n_kp = 512 plt.plot(zm, dn, 'b-') plt.savefig('N_z.png') plt.close() # Transverse modes kt_arr = np.geomspace(0.00005, 10., n_kt) # Parallel modes kp_arr = np.geomspace(0.00005, 10., n_kp) # Total wavenumber k_arr = np.sqrt(kt_arr[None, :]**2 + kp_arr[:, None]**2) # B.H. changed a to float(a) pk_arr = np.array([(b+f*kp_arr[:,None]**2/k_arr**2)**2* ccl.nonlin_matter_power(cosmo,k_arr.flatten(),float(a)).reshape([n_kp,n_kt])\ for a,b,f in zip(1./(1+zm),b_m,f_m)]) window = np.array([2*jv(1,kt_arr[None,:]*R)/(kt_arr[None,:]*R)*np.sin(0.5*kp_arr[:,None]*dc)/\ (0.5*kp_arr[:,None]*dc) for R,dc in zip(R_m,dchi)]) # Estimating covariance matrix # avoiding getting 0s in covariance eps = 0.0 # Changed from dn to dndz B.H. and A.S. TODO: Check print("covmat_cv...") covmat_cv = np.array([[(ni+eps)*(nj+eps)*covar(i,j,window,pk_arr,chi_m,kp_arr,kt_arr) \ for i,ni in enumerate(dndz)] \ for j,nj in enumerate(dndz)]) return covmat_cv
def test_bcm(): cosmo = ccl.Cosmology(Omega_c=0.25, Omega_b=0.05, h=0.7, A_s=2.2e-9, n_s=0.96, Neff=3.046, m_nu_type='normal', m_nu=0.0, Omega_g=0, Omega_k=0, w0=-1, wa=0, bcm_log10Mc=14.0, baryons_power_spectrum='bcm') cosmo_nobar = ccl.Cosmology(Omega_c=0.25, Omega_b=0.05, h=0.7, A_s=2.2e-9, n_s=0.96, Neff=3.046, m_nu_type='normal', m_nu=0.0, Omega_g=0, Omega_k=0, w0=-1, wa=0) data = np.loadtxt("./benchmarks/data/w_baryonspk_nl.dat") data_nobar = np.loadtxt("./benchmarks/data/wo_baryonspk_nl.dat") k = data[:, 0] * cosmo['h'] a = 1 fbcm = ccl.bcm_model_fka(cosmo, k, a) err = np.abs(data[:, 1] / data_nobar[:, 1] / fbcm - 1) assert np.allclose(err, 0, atol=BCM_TOLERANCE, rtol=0) ratio = (ccl.nonlin_matter_power(cosmo, k, a) / ccl.nonlin_matter_power(cosmo_nobar, k, a)) err = np.abs(data[:, 1] / data_nobar[:, 1] / ratio - 1) assert np.allclose(err, 0, atol=BCM_TOLERANCE, rtol=0)
def __init__(self, cosmo, hmc, pM, k_range=[1E-1, 5], nlk=20, z_range=[0., 1.], nz=16): lkarr = np.linspace(np.log10(k_range[0]), np.log10(k_range[1]), nlk) karr = 10.**lkarr zarr = np.linspace(z_range[0], z_range[1], nz) aarr = 1./(1. + zarr) pk_hm = ccl.halos.halomod_power_spectrum(cosmo, hmc, karr, aarr, pM, normprof1=True) pk_hf = np.array([ccl.nonlin_matter_power(cosmo, karr, a) for a in aarr]) ratio = pk_hf / pk_hm self.rk_func = interpolate.interp2d(lkarr, zarr, ratio, bounds_error=False, fill_value=1)
def theoretical_power_spectrum(self): """ Calculate the theoretical nonlinear power spectrum for the given cosmological parameters, using CCL. Does not depend on the realisation. Returns: k, pk (array_like): Wavenumbers, from 10^-3.5 to 10^1, in Mpc^-1, and the theoretical nonlinear power spectrum, in (Mpc)^3. """ k = np.logspace(-3.5, 1., int(1e3)) pk = ccl.nonlin_matter_power(self.cosmo, k=k, a=self.scale_factor) return k, pk
def test_nonlin_camb_power(): import camb logT_AGN = 7.93 Omega_c = 0.25 Omega_b = 0.05 A_s = 2.1e-9 n_s = 0.97 h = 0.7 # Needs to be set for good agreements between CCL and CAMB T_CMB = 2.725 p = camb.CAMBparams(WantTransfer=True, NonLinearModel=camb.nonlinear.Halofit( halofit_version="mead2020_feedback", HMCode_logT_AGN=logT_AGN)) # This affects k_min p.WantCls = False p.DoLensing = False p.Want_CMB = False p.Want_CMB_lensing = False p.Want_cl_2D_array = False p.set_cosmology(H0=h*100, omch2=Omega_c*h**2, ombh2=Omega_b*h**2, mnu=0.0, TCMB=T_CMB) p.share_delta_neff = False p.InitPower.set_params(As=A_s, ns=n_s) z = [0.0, 0.5, 1.0, 1.5] p.set_matter_power(redshifts=z, kmax=10.0, nonlinear=True) p.set_for_lmax(5000) r = camb.get_results(p) k, z, pk_nonlin_camb = r.get_nonlinear_matter_power_spectrum( hubble_units=False, k_hunit=False) ccl_cosmo = ccl.Cosmology( Omega_c=Omega_c, Omega_b=Omega_b, h=h, m_nu=0.0, A_s=A_s, n_s=n_s, transfer_function="boltzmann_camb", matter_power_spectrum="camb", extra_parameters={"camb": {"halofit_version": "mead2020_feedback", "HMCode_logT_AGN": logT_AGN}}) for z_, pk_camb in zip(z, pk_nonlin_camb): pk_nonlin_ccl = ccl.nonlin_matter_power(ccl_cosmo, k, 1/(1+z_)) assert np.allclose(pk_camb, pk_nonlin_ccl, rtol=3e-5)
def test_iswcl(): # Cosmology Ob = 0.05 Oc = 0.25 h = 0.7 COSMO = ccl.Cosmology(Omega_b=Ob, Omega_c=Oc, h=h, n_s=0.96, sigma8=0.8, transfer_function='bbks') # CCL calculation ls = np.arange(2, 100) zs = np.linspace(0, 0.6, 256) nz = np.exp(-0.5 * ((zs - 0.3) / 0.05)**2) bz = np.ones_like(zs) tr_n = ccl.NumberCountsTracer(COSMO, has_rsd=False, dndz=(zs, nz), bias=(zs, bz)) tr_i = ccl.ISWTracer(COSMO) cl = ccl.angular_cl(COSMO, tr_n, tr_i, ls) # Benchmark from Eq. 6 in 1710.03238 pz = nz / simps(nz, x=zs) H0 = h / ccl.physical_constants.CLIGHT_HMPC # Prefactor prefac = 3 * COSMO['T_CMB'] * (Oc + Ob) * H0**3 / (ls + 0.5)**2 # H(z)/H0 ez = ccl.h_over_h0(COSMO, 1. / (1 + zs)) # Linear growth and derivative dz = ccl.growth_factor(COSMO, 1. / (1 + zs)) gz = np.gradient(dz * (1 + zs), zs[1] - zs[0]) / dz # Comoving distance chi = ccl.comoving_radial_distance(COSMO, 1 / (1 + zs)) # P(k) pks = np.array([ ccl.nonlin_matter_power(COSMO, (ls + 0.5) / (c + 1E-6), 1. / (1 + z)) for c, z in zip(chi, zs) ]).T # Limber integral cl_int = pks[:, :] * (pz * ez * gz)[None, :] clbb = simps(cl_int, x=zs) clbb *= prefac assert np.all(np.fabs(cl / clbb - 1) < 1E-3)
def __init__(self, cosmo, k_range=[1E-1, 5], nlk=128, z_range=[0., 1.], nz=32): lkarr = np.linspace(np.log10(k_range[0]), np.log10(k_range[1]), nlk) karr = 10.**lkarr zarr = np.linspace(z_range[0], z_range[1], nz) a_arr = 1 / (1 + zarr) hmd = ccl.halos.MassDef(500, "critical") cM = ccl.halos.ConcentrationDuffy08(mass_def=hmd) NFW = ccl.halos.profiles.HaloProfileNFW(c_m_relation=cM) kwargs = { "mass_function": ccl.halos.mass_function_from_name("Tinker08"), "halo_bias": ccl.halos.halo_bias_from_name("Tinker10") } nM = kwargs["mass_function"](cosmo, mass_def=hmd) bM = kwargs["halo_bias"](cosmo, mass_def=hmd) hmc = ccl.halos.HMCalculator(mass_function=nM, halo_bias=bM, mass_def=hmd) pk_hm = ccl.halos.halomod_power_spectrum(cosmo, hmc, karr, a_arr, NFW, normprof=True, normprof2=True) pk_hf = np.array( [ccl.nonlin_matter_power(cosmo, karr, a) for a in a_arr]) ratio = pk_hf / pk_hm self.rk_func = interp2d(lkarr, 1 / (1 + zarr), ratio, bounds_error=False, fill_value=1)
def test_power_nu(model): mnu = [[0.04, 0., 0.], [0.05, 0.01, 0.], [0.03, 0.02, 0.04]] w_0 = [-1.0, -0.9, -0.9] w_a = [0.0, 0.0, 0.1] cosmo = ccl.Cosmology(Omega_c=0.25, Omega_b=0.05, h=0.7, A_s=2.1e-9, n_s=0.96, Neff=3.046, Omega_k=0, w0=w_0[model], wa=w_a[model], m_nu=mnu[model], m_nu_type='list', transfer_function='boltzmann_class') a = 1 data_lin = np.loadtxt("./benchmarks/data/model%d_pk_nu.txt" % (model + 1)) k_lin = data_lin[:, 0] * cosmo['h'] pk_lin = data_lin[:, 1] / (cosmo['h']**3) with warnings.catch_warnings(): # Linear power with massive neutrinos raises a warning. # Ignore it. # XXX: Do you really want to be raising a warning for this? # This seems spurious to me. (MJ) warnings.simplefilter("ignore") pk_lin_ccl = ccl.linear_matter_power(cosmo, k_lin, a) err = np.abs(pk_lin_ccl / pk_lin - 1) assert np.allclose(err, 0, rtol=0, atol=POWER_NU_TOL) data_nl = np.loadtxt("./benchmarks/data/model%d_pk_nl_nu.txt" % (model + 1)) k_nl = data_nl[:, 0] * cosmo['h'] pk_nl = data_nl[:, 1] / (cosmo['h']**3) pk_nl_ccl = ccl.nonlin_matter_power(cosmo, k_nl, a) err = np.abs(pk_nl_ccl / pk_nl - 1) assert np.allclose(err, 0, rtol=0, atol=POWER_NU_TOL)
def test_emu_lin(model): cosmos = np.loadtxt("./benchmarks/data/emu_input_cosmologies.txt") mnu = ccl.nu_masses(cosmos[model, 7] * cosmos[model, 2]**2, 'equal', T_CMB=2.725) cosmo = ccl.Cosmology( Omega_c=cosmos[model, 0], Omega_b=cosmos[model, 1], h=cosmos[model, 2], sigma8=cosmos[model, 3], n_s=cosmos[model, 4], w0=cosmos[model, 5], wa=cosmos[model, 6], m_nu=mnu, m_nu_type='list', Neff=3.04, Omega_g=0, Omega_k=0, transfer_function='boltzmann_camb', matter_power_spectrum='emu', ) a = 1 k = np.logspace(-3, -2, 50) # Catch warning about neutrino linear growth if (np.sum(mnu) > 0): pk = ccl.pyutils.assert_warns(ccl.CCLWarning, ccl.nonlin_matter_power, cosmo, k, a) else: pk = ccl.nonlin_matter_power(cosmo, k, a) # Catch warning about linear matter power pk_lin = ccl.pyutils.assert_warns(ccl.CCLWarning, ccl.linear_matter_power, cosmo, k, a) err = np.abs(pk / pk_lin - 1) assert np.allclose(err, 0, rtol=0, atol=EMU_TOLERANCE)
def test_nonlin_camb_power(): import camb logT_AGN = 7.93 Omega_c = 0.25 Omega_b = 0.05 A_s = 2.1e-9 n_s = 0.97 h = 0.7 p = camb.CAMBparams(WantTransfer=True, NonLinearModel=camb.nonlinear.Halofit( halofit_version="mead2020", HMCode_logT_AGN=logT_AGN)) p.set_cosmology(H0=h*100, omch2=Omega_c*h**2, ombh2=Omega_b*h**2, mnu=0.0) p.share_delta_neff = False p.InitPower.set_params(As=A_s, ns=n_s) z = [0.0, 0.5, 1.0] p.set_matter_power(redshifts=z, kmax=10.0, nonlinear=True) p.set_for_lmax(5000) r = camb.get_results(p) k, z, pk_nonlin_camb = r.get_nonlinear_matter_power_spectrum( hubble_units=False, k_hunit=False) ccl_cosmo = ccl.Cosmology(Omega_c=Omega_c, Omega_b=Omega_b, h=h, m_nu=0.0, A_s=A_s, n_s=n_s, transfer_function="boltzmann_camb", matter_power_spectrum="camb", extra_parameters={"camb": {"halofit_version": "mead2020", "HMCode_logT_AGN": logT_AGN}}) for z_, pk_camb in zip(z, pk_nonlin_camb): pk_nonlin_ccl = ccl.nonlin_matter_power(ccl_cosmo, k, 1/(1+z_)) assert np.allclose(pk_camb, pk_nonlin_ccl, rtol=3e-3)
def test_halofit(): # We first define equivalent CCL and jax_cosmo cosmologies cosmo_ccl = ccl.Cosmology( Omega_c=0.3, Omega_b=0.05, h=0.7, sigma8=0.8, n_s=0.96, Neff=0, transfer_function="eisenstein_hu", matter_power_spectrum="halofit", ) cosmo_jax = Cosmology( Omega_c=0.3, Omega_b=0.05, h=0.7, sigma8=0.8, n_s=0.96, Omega_k=0.0, w0=-1.0, wa=0.0, ) # Test array of scales k = np.logspace(-4, 2, 512) # Computing matter power spectrum pk_ccl = ccl.nonlin_matter_power(cosmo_ccl, k, 1.0) pk_jax = (power.nonlinear_matter_power( cosmo_jax, k / cosmo_jax.h, a=1.0, transfer_fn=tklib.Eisenstein_Hu, nonlinear_fn=power.halofit, ) / cosmo_jax.h**3) assert_allclose(pk_ccl, pk_jax, rtol=0.5e-2)
def __init__(self, cosmo, k_range=[1E-1, 5], nlk=20, z_range=[0., 1.], nz=16): lkarr = np.linspace(np.log10(k_range[0]), np.log10(k_range[1]), nlk) karr = 10.**lkarr zarr = np.linspace(z_range[0], z_range[1], nz) pk_hm = np.array([ ccl.halomodel_matter_power(cosmo, karr, a) for a in 1. / (1 + zarr) ]) pk_hf = np.array( [ccl.nonlin_matter_power(cosmo, karr, a) for a in 1. / (1 + zarr)]) ratio = pk_hf / pk_hm self.rk_func = interpolate.interp2d(lkarr, zarr, ratio, bounds_error=False, fill_value=1)
# for a given redshift for combo in template_comb_names: Pk_a = np.zeros((len(z_templates), len(ks))) for i in range(len(z_templates)): z_str = 'ztmp%d' % i a_arr[i] = 1. / (1 + z_templates[z_str]) key = z_str + '_' + combo Pk = fid_dPk_Pk_templates[key] + \ fid_dPk_Pk_templates[key+'_'+'omega_b'] * (omega_b - fid_deriv_params['omega_b']) + \ fid_dPk_Pk_templates[key+'_'+'omega_cdm'] * (omega_cdm - fid_deriv_params['omega_cdm']) + \ fid_dPk_Pk_templates[key+'_'+'n_s'] * (n_s - fid_deriv_params['n_s']) + \ fid_dPk_Pk_templates[key+'_'+'sigma8_cb'] * (sigma8_cb - fid_deriv_params['sigma8_cb']) # tuks pk_a[i, :] = ccl.nonlin_matter_power(cosmo_ccl, ks * h, a=1. / (1 + z_templates[z_str])) if want_rat: Pk *= ccl.nonlin_matter_power( cosmo_ccl, ks * h, a=1. / (1 + z_templates[z_str])) * h**3 # convert to Mpc^3 rather than [Mpc/h]^3 Pk_a[i, :] = Pk / h**3. Pk_a_ij[combo] = Pk_a # convert to Mpc^-1 rather than h/Mpc Pk_a_ij['lk_arr'] = np.log(ks * h) # tuks pk_a *= 1.41 pk_tmp = ccl.Pk2D(a_arr=a_arr, lk_arr=np.log(ks * h),
def test_no_sys_pipeline(plot=True): param_dict = { "cosmological_parameters": { "omch2": 0.1, "ombh2": 0.022, "h0": 0.7, "n_s": 0.96, "ln_1e10_A_s": 3.0, "omega_k": 0.0, "w": -1.0, "mnu": 0.06 }, "halo_model_parameters": { "A": 2.0, } } pipeline_ini = cosmosis.runtime.config.Inifile(PIPELINE_FILE) values_ini = cosmosis.runtime.config.Inifile(None) values_ini.read_dict(param_dict) pipeline = cosmosis.runtime.pipeline.LikelihoodPipeline(pipeline_ini, values=values_ini) data = pipeline.run_parameters([]) ccl_cosmo = ccl.Cosmology( Omega_c=data["cosmological_parameters", "omega_c"], Omega_b=data["cosmological_parameters", "omega_b"], Omega_k=data["cosmological_parameters", "omega_k"], h=data["cosmological_parameters", "h0"], n_s=data["cosmological_parameters", "n_s"], A_s=data["cosmological_parameters", "a_s"], Neff=data["cosmological_parameters", "n_eff"], m_nu=data["cosmological_parameters", "mnu"], w0=data["cosmological_parameters", "w"], ) print("Loading n(z) and creating CCL tracers.") nofz_files = pipeline_ini.get("load_nz", "filepath").split(" ") tracers = [] for nofz_file in nofz_files: z, nofz = np.loadtxt(nofz_file, unpack=True) z += (z[1] - z[0]) / 2 tracers.append(ccl.WeakLensingTracer(cosmo=ccl_cosmo, dndz=(z, nofz))) n_tomo_bin = len(tracers) print("Comparing P(k) at z=0") h = data["cosmological_parameters", "h0"] k_lin = data["matter_power_lin", "k_h"] k_nl = data["matter_power_nl", "k_h"] pk_lin_ccl = ccl.linear_matter_power(ccl_cosmo, k_lin * h, 1.0) * h**3 pk_nl_ccl = ccl.nonlin_matter_power(ccl_cosmo, k_nl * h, 1.0) * h**3 frac_diff_pk_lin = data["matter_power_lin", "p_k"][0] / pk_lin_ccl - 1 frac_diff_pk_nl = data["matter_power_nl", "p_k"][0] / pk_nl_ccl - 1 print( f"Maximum fractional difference in linear P(k) at z=0 for k<5 h/Mpc: {max(np.abs(frac_diff_pk_lin[k_lin < 5.0]))}" ) print( f"Maximum fractional difference in non-linear P(k) at z=0 for k<5 h/Mpc: {max(np.abs(frac_diff_pk_nl[k_nl < 5.0]))}" ) ell = data["shear_cl", "ell"] print(ell.min(), ell.max(), len(ell)) print("Setting up MontePython now.") import subprocess statistics_mp = {} for idx, likelihood in enumerate(["K1K_COSEBIs", "K1K_BandPowers"]): set_up_MontePython(likelihood) # we need to set some paths... path_to_param_file = os.path.join( "montepython/", "{:}/INPUT/{:}_Benchmark.param".format(likelihood, likelihood[4:])) path_to_mp_output = os.path.join(PATH_TO_MP_OUTPUT, likelihood) # TODO: unfortunately, MP saves out theory vectors and Cls to folder # from which it reads in its data and NOT to the MCMC output folder... path_to_mp_input = os.path.join(PATH_TO_MP_DATA[likelihood]) # the call to MontePython: cmd = "python {:} run -p {:} -o {:} --conf {:} -N 1".format( os.path.join(PATH_TO_MONTEPYTHON, "montepython/MontePython.py"), path_to_param_file, path_to_mp_output, os.path.join(PATH_TO_MONTEPYTHON, "default.conf")) subprocess.call(cmd, shell=True) # we only need the Cls from one MP likelihood: if idx == 0: print("Loading and re-ordering Cls from MP.") fname = os.path.join(path_to_mp_input, 'Cls_tot.txt') data_mp = np.loadtxt(fname) mp_cl_raw = data_mp[:, 1:] # bring raw Cls from MP into same sorting order: mp_cl_my_sorting = {} idx_unique = 0 for i in range(n_tomo_bin): mp_cl_my_sorting[i] = {} for j in range(i, n_tomo_bin): #print(f"Bin {i+1}-{j+1}") mp_cl_my_sorting[i][j] = mp_cl_raw[:, idx_unique] idx_unique += 1 mp_cl = {} for i in range(n_tomo_bin): mp_cl[i] = {} for j in range(i + 1): print(f"Bin {i+1}-{j+1} = Bin {j+1}-{i+1}") try: mp_cl[i][j] = mp_cl_my_sorting[j][i] except: mp_cl[i][j] = mp_cl_my_sorting[i][j] fname = os.path.join(path_to_mp_input, "{:}_theory.ascii".format(likelihood[4:])) print("Loaded theory vector from MontePython' {:} from: \n {:} \n". format(likelihood, fname)) statistics_mp[likelihood] = np.loadtxt(fname) print(statistics_mp) print(statistics_mp["K1K_COSEBIs"]) theta = data["shear_xi_plus", "theta"] * 180 / pi print("Running CCL for Cls and xis.") ccl_cl = {} ccl_xi = {} for i in range(n_tomo_bin): ccl_cl[i] = {} ccl_xi[i] = {} for j in range(i + 1): print(f"Bin {i+1}-{j+1}") ccl_cl[i][j] = ccl.angular_cl(cosmo=ccl_cosmo, cltracer1=tracers[i], cltracer2=tracers[j], ell=ell) ell_for_xi = np.concatenate( (np.arange(2, 100, dtype=float), np.logspace(2, np.log10(ell[-1]), 300))) cl_for_xi = ccl.angular_cl(cosmo=ccl_cosmo, cltracer1=tracers[i], cltracer2=tracers[j], ell=ell_for_xi) cl_for_xi /= ((ell_for_xi - 1) * ell_for_xi * (ell_for_xi + 1) * (ell_for_xi + 2) / (ell_for_xi + 1 / 2)**4) xip = ccl.correlation(cosmo=ccl_cosmo, ell=ell_for_xi, C_ell=cl_for_xi, theta=theta, corr_type="L+") xim = ccl.correlation(cosmo=ccl_cosmo, ell=ell_for_xi, C_ell=cl_for_xi, theta=theta, corr_type="L-") ccl_xi[i][j] = xip, xim ell_range = 10, 10000 theta_range = 0.05, 10.0 ell_mask = (ell_range[0] < ell) & (ell < ell_range[1]) theta_mask = (theta_range[0] < theta) & (theta < theta_range[1]) for i in range(n_tomo_bin): for j in range(i + 1): frac_diff_cl_KCAP_CCL = data["shear_cl", f"bin_{i+1}_{j+1}"] / ccl_cl[i][j] - 1 frac_diff_cl_KCAP_MP = data["shear_cl", f"bin_{i+1}_{j+1}"] / mp_cl[i][j] - 1 print( f"Maximum fractional difference between KCAP and CCL in Cl (ell>10) for bin {i+1}-{j+1}: {max(np.abs(frac_diff_cl_KCAP_CCL[ell_mask]))}" ) print( f"Maximum fractional difference between KCAP and MP in Cl (ell>10) for bin {i+1}-{j+1}: {max(np.abs(frac_diff_cl_KCAP_MP[ell_mask]))}" ) frac_diff_xi_plus = data["shear_xi_plus", f"bin_{i+1}_{j+1}"] / ccl_xi[i][j][0] - 1 print( f"Maximum fractional difference in xi_p (theta<10 deg) for bin {i+1}-{j+1}: {max(np.abs(frac_diff_xi_plus[theta_mask]))}" ) frac_diff_xi_minus = data["shear_xi_minus", f"bin_{i+1}_{j+1}"] / ccl_xi[i][j][1] - 1 print( f"Maximum fractional difference in xi_m (theta>0.05 deg) for bin {i+1}-{j+1}: {max(np.abs(frac_diff_xi_minus[theta_mask]))}" ) if plot: import matplotlib.pyplot as plt print("Plotting P(k)") fig, ax = plt.subplots(2, 1, sharex=True, sharey=False, figsize=(5, 5)) fig.subplots_adjust(hspace=0, wspace=0) ax[0].loglog(k_lin, pk_lin_ccl, ls="--", label=f"CCL linear P(k)") ax[0].loglog(k_lin, data["matter_power_lin", "p_k"][0], ls="--", label=f"CosmoSIS linear P(k)") ax[0].loglog(k_nl, pk_nl_ccl, label=f"CCL non-linear P(k)") ax[0].loglog(k_nl, data["matter_power_nl", "p_k"][0], label=f"CosmoSIS non-linear P(k)") ax[1].semilogx(k_lin, data["matter_power_lin", "p_k"][0] / pk_lin_ccl - 1, ls="--") ax[1].semilogx(k_nl, data["matter_power_nl", "p_k"][0] / pk_nl_ccl - 1) ax[0].legend(frameon=False) ax[0].set_ylabel("$P(k)$ [$h^{-3}$ Mpc$^{3}$]") ax[1].set_ylim(-0.05, 0.05) ax[1].set_xlabel("$k$ [$h$ Mpc$^{-1}$]") ax[1].set_ylabel("$\Delta P(k)/P(k)$ [$h$ Mpc$^{-1}$]") fig.suptitle("KCAP vs. CCL, P(k)") fig.savefig("KV450_pofk_kcap_vs_ccl.pdf") ell_plot_lim = ell_range print("Plotting Cls") fig, ax = plt.subplots(n_tomo_bin, n_tomo_bin, sharex=True, sharey=True, figsize=(2 * n_tomo_bin, 1.5 * n_tomo_bin)) fig.subplots_adjust(hspace=0, wspace=0) u = ell**2 for i in range(n_tomo_bin): for j in range(n_tomo_bin): if j > i: ax[i][j].axis("off") else: ax[i][j].loglog(ell, u * ccl_cl[i][j], label=f"CCL bin {i+1}-{j+1}") ax[i][j].loglog(ell, u * data["shear_cl", f"bin_{i+1}_{j+1}"], label=f"CosmoSIS") ax[i][j].loglog(ell, u * mp_cl[i][j], label=f"MP") ax[i][j].legend(fontsize="small", frameon=False) ax[i][j].set_xlim(*ell_plot_lim) for p in ax[-1]: p.set_xlabel(r"$\ell$") for p in ax: p[0].set_ylabel(r"$\ell^2\ C_\ell$") fig.suptitle("KCAP vs. CCL vs. MP, Cls") fig.savefig("KV450_Cl_kcap_vs_ccl_vs_mp.pdf") print("Plotting Cl fractional differences.") fig, ax = plt.subplots(n_tomo_bin, n_tomo_bin, sharex=True, sharey=True, figsize=(2 * n_tomo_bin, 1.5 * n_tomo_bin)) fig.subplots_adjust(hspace=0, wspace=0) for i in range(n_tomo_bin): for j in range(n_tomo_bin): if j > i: ax[i][j].axis("off") else: label = f"bin {i+1}-{j+1}" ax[i][j].text(0.75, 0.80, label, horizontalalignment='center', transform=ax[i][j].transAxes) ax[i][j].semilogx( ell, data["shear_cl", f"bin_{i+1}_{j+1}"] / ccl_cl[i][j] - 1, label=f"KCAP vs. CCL") ax[i][j].semilogx( ell, data["shear_cl", f"bin_{i+1}_{j+1}"] / mp_cl[i][j] - 1, label="KCAP vs. MP") #ax[i][j].legend(fontsize="small", frameon=False) ax[i][j].axhline(0., ls='-', color='gray') for val in [0.01, 0.05]: ax[i][j].axhline(val, ls=':', color='gray') ax[i][j].axhline(-val, ls=':', color='gray') ax[i][j].set_xlim(*ell_plot_lim) ax[i][j].set_ylim(-0.1, 0.1) ax[1][1].legend(fontsize="small", frameon=False, bbox_to_anchor=(.95, 1.05)) for p in ax[-1]: p.set_xlabel(r"$\ell$") for p in ax: p[0].set_ylabel(r"$|\Delta C_\ell|/C_\ell$") fig.suptitle("KCAP vs. CCL vs. MP, Cls") fig.savefig("KV450_Cl_kcap_vs_ccl_vs_mp_frac_diff.pdf") print("Plotting xi fractional differences.") theta_plot_lim = theta_range fig, ax = plt.subplots(n_tomo_bin, n_tomo_bin, sharex=True, sharey=True, figsize=(2 * n_tomo_bin, 1.5 * n_tomo_bin)) fig.subplots_adjust(hspace=0, wspace=0) for i in range(n_tomo_bin): for j in range(n_tomo_bin): if j > i: ax[i][j].axis("off") else: ax[i][j].semilogx( theta, data["shear_xi_plus", f"bin_{i+1}_{j+1}"] / ccl_xi[i][j][0] - 1, label=f"xip bin {i+1}-{j+1}") ax[i][j].semilogx( theta, data["shear_xi_minus", f"bin_{i+1}_{j+1}"] / ccl_xi[i][j][1] - 1, label=f"xim bin {i+1}-{j+1}") ax[i][j].legend(fontsize="small", frameon=False) ax[i][j].set_xlim(*theta_plot_lim) ax[i][j].set_ylim(-0.1, 0.1) for p in ax[-1]: p.set_xlabel(r"$\theta$ [deg]") for p in ax: p[0].set_ylabel(r"$|\Delta \xi|/\xi$") fig.suptitle("KCAP vs. CCL, xis") fig.savefig("KV450_xi_kcap_vs_ccl_frac_diff.pdf") print("Plotting COSEBIs fractional differences.") # TODO: this range should be taken from CosmoSIS keywords!!! n_modes = 5 n_tomo_corrs = n_tomo_bin * (n_tomo_bin + 1) // 2 modes = np.arange(1, n_modes + 1) cosebis_mp = statistics_mp["K1K_COSEBIs"].reshape( n_tomo_corrs, n_modes) fig, ax = plt.subplots(n_tomo_bin, n_tomo_bin, sharex=True, sharey=True, figsize=(2 * n_tomo_bin, 1.5 * n_tomo_bin)) fig.subplots_adjust(hspace=0, wspace=0) idx_corr = 0 for i in range(n_tomo_bin): for j in range(n_tomo_bin): if j > i: ax[i][j].axis("off") else: # TODO: add also output from CosmoSIS! #ax[i][j].semilogx(modes, data["cosebis", f"bin_{i+1}_{j+1}"] / cosebis_mp[idx_corr, :] -1, label=f"COSEBIs bin {i+1}-{j+1}") ax[i][j].plot( modes, cosebis_mp[idx_corr, :] / cosebis_mp[idx_corr, :] - 1, label=f"COSEBIs bin {i+1}-{j+1}") ax[i][j].legend(fontsize="small", frameon=False) idx_corr += 1 ax[i][j].set_xlim([0., 6.]) ax[i][j].set_ylim([-0.1, 0.1]) for p in ax[-1]: p.set_xlabel(r"$n$") for p in ax: p[0].set_ylabel(r"$|\Delta E_n|/E_n$") fig.suptitle("KCAP vs. MP, COSEBIs") fig.savefig("KV450_cosebis_kcap_vs_mp_frac_diff.pdf") print("Plotting BandPowers fractional differences.") # TODO: this range should be taken from CosmoSIS keywords!!! n_ell_bins = 8 n_tomo_corrs = n_tomo_bin * (n_tomo_bin + 1) // 2 plot_ell = np.logspace(np.log10(100.), np.log10(1500.), n_ell_bins) bandpowers_mp = statistics_mp["K1K_BandPowers"].reshape( n_tomo_corrs, n_ell_bins) fig, ax = plt.subplots(n_tomo_bin, n_tomo_bin, sharex=True, sharey=True, figsize=(2 * n_tomo_bin, 1.5 * n_tomo_bin)) fig.subplots_adjust(hspace=0, wspace=0) idx_corr = 0 for i in range(n_tomo_bin): for j in range(n_tomo_bin): if j > i: ax[i][j].axis("off") else: # TODO: add also output from CosmoSIS! #ax[i][j].semilogx(modes, data["bandpower", f"bin_{i+1}_{j+1}"] / bandpowers_mp[idx_corr, :] -1, label=f"BandPowers bin {i+1}-{j+1}") ax[i][j].semilogx(plot_ell, bandpowers_mp[idx_corr, :] / bandpowers_mp[idx_corr, :] - 1, label=f"BandPowers bin {i+1}-{j+1}") ax[i][j].legend(fontsize="small", frameon=False) idx_corr += 1 ax[i][j].set_xlim([100., 1500.]) ax[i][j].set_ylim([-0.1, 0.1]) for p in ax[-1]: p.set_xlabel(r"$\ell$") for p in ax: p[0].set_ylabel(r"$|\Delta PeeE|/PeeE $") fig.suptitle("KCAP vs. MP, BandPowers") fig.savefig("MOCK_bandpowers_kcap_vs_mp_frac_diff.pdf") plt.show()
lkmin=-5. lkmax=2. h0=0.69 #Hubble rate #Parameters for N(z) \propto z^\alpha \exp[-(z/z0)^\beta] alpha_nz=2. beta_nz=1.0 z0_nz=0.3 #Number density in arcmin^-2 ndens_amin2=40. cosmo=ccl.Cosmology(Omega_c=0.266,Omega_b=0.049,h=h0,sigma8=0.8,n_s=0.96) karr=10.**(lkmin+(lkmax-lkmin)*np.arange(nk)/(nk-1.)) pklinarr=ccl.linear_matter_power(cosmo,1.,karr*h0)*h0**3 pknlinarr=ccl.nonlin_matter_power(cosmo,1.,karr*h0)*h0**3 zarr=zmax*np.arange(nz)/(nz-1.) gzarr=ccl.growth_factor(cosmo,1./(1+zarr)) bzarr=0.95/gzarr nzarr=zarr**alpha_nz*np.exp(-(zarr/z0_nz)**beta_nz) nzf=interp1d(zarr,nzarr) #Normalize nz ntot=quad(nzf,0,zmax)[0] nzarr*=ndens_amin2*60.**2/ntot nzf=interp1d(zarr,nzarr) print "#Gals : %lE"%(0.4*4*np.pi*(180/np.pi)**2*quad(nzf,0,zmax)[0]) np.savetxt("pk_planck.txt",np.transpose([karr,pklinarr])) np.savetxt("pk_nlin_planck.txt",np.transpose([karr,pknlinarr]))
def test_no_sys_pipeline(plot=True): param_dict = {"cosmological_parameters" : {"omch2" : 0.1, "ombh2" : 0.022, "h0" : 0.7, "n_s" : 0.96, "ln_1e10_A_s" : 3.0, "omega_k" : 0.0, "w" : -1.0, "mnu" : 0.06}, "halo_model_parameters" : {"A" : 2.0,}} pipeline_ini = cosmosis.runtime.config.Inifile(PIPELINE_FILE) values_ini = cosmosis.runtime.config.Inifile(None) values_ini.read_dict(param_dict) pipeline = cosmosis.runtime.pipeline.LikelihoodPipeline(pipeline_ini, values=values_ini) data = pipeline.run_parameters([]) ccl_cosmo = ccl.Cosmology(Omega_c=data["cosmological_parameters", "omega_c"], Omega_b=data["cosmological_parameters", "omega_b"], Omega_k=data["cosmological_parameters", "omega_k"], h=data["cosmological_parameters", "h0"], n_s=data["cosmological_parameters", "n_s"], A_s=data["cosmological_parameters", "a_s"], Neff=data["cosmological_parameters", "n_eff"], m_nu=data["cosmological_parameters", "mnu"], w0=data["cosmological_parameters", "w"], ) print("Loading n(z) and creating CCL tracers.") nofz_files = pipeline_ini.get("load_nz", "filepath").split(" ") tracers = [] for nofz_file in nofz_files: z, nofz = np.loadtxt(nofz_file, unpack=True) z += (z[1]-z[0])/2 tracers.append(ccl.WeakLensingTracer(cosmo=ccl_cosmo, dndz=(z, nofz))) n_tomo_bin = len(tracers) print("Comparing P(k) at z=0") h = data["cosmological_parameters", "h0"] k_lin = data["matter_power_lin", "k_h"] k_nl = data["matter_power_nl", "k_h"] pk_lin_ccl = ccl.linear_matter_power(ccl_cosmo, k_lin*h, 1.0)*h**3 pk_nl_ccl = ccl.nonlin_matter_power(ccl_cosmo, k_nl*h, 1.0)*h**3 frac_diff_pk_lin = data["matter_power_lin", "p_k"][0]/pk_lin_ccl - 1 frac_diff_pk_nl = data["matter_power_nl", "p_k"][0]/pk_nl_ccl - 1 print(f"Maximum fractional difference in linear P(k) at z=0 for k<5 h/Mpc: {max(np.abs(frac_diff_pk_lin[k_lin < 5.0]))}") print(f"Maximum fractional difference in non-linear P(k) at z=0 for k<5 h/Mpc: {max(np.abs(frac_diff_pk_nl[k_nl < 5.0]))}") ell = data["shear_cl", "ell"] theta = data["shear_xi_plus", "theta"]*180/pi print("Running CCL for Cls and xis.") ccl_cl = {} ccl_xi = {} for i in range(n_tomo_bin): ccl_cl[i] = {} ccl_xi[i] = {} for j in range(i+1): print(f"Bin {i+1}-{j+1}") ccl_cl[i][j] = ccl.angular_cl(cosmo=ccl_cosmo, cltracer1=tracers[i], cltracer2=tracers[j], ell=ell) ell_for_xi = np.concatenate((np.arange(2,100, dtype=float), np.logspace(2,np.log10(ell[-1]), 300))) cl_for_xi = ccl.angular_cl(cosmo=ccl_cosmo, cltracer1=tracers[i], cltracer2=tracers[j], ell=ell_for_xi) cl_for_xi /= ((ell_for_xi-1)*ell_for_xi*(ell_for_xi+1)*(ell_for_xi+2)/(ell_for_xi+1/2)**4) xip = ccl.correlation(cosmo=ccl_cosmo, ell=ell_for_xi, C_ell=cl_for_xi, theta=theta, corr_type="L+") xim = ccl.correlation(cosmo=ccl_cosmo, ell=ell_for_xi, C_ell=cl_for_xi, theta=theta, corr_type="L-") ccl_xi[i][j] = xip, xim ell_range = 10, 10000 theta_range = 0.05, 10.0 ell_mask = (ell_range[0] < ell) & (ell < ell_range[1]) theta_mask = (theta_range[0] < theta) & (theta < theta_range[1]) for i in range(n_tomo_bin): for j in range(i+1): frac_diff_cl = data["shear_cl", f"bin_{i+1}_{j+1}"]/ccl_cl[i][j] - 1 print(f"Maximum fractional difference in Cl (ell>10) for bin {i+1}-{j+1}: {max(np.abs(frac_diff_cl[ell_mask]))}") frac_diff_xi_plus = data["shear_xi_plus", f"bin_{i+1}_{j+1}"]/ccl_xi[i][j][0] - 1 print(f"Maximum fractional difference in xi_p (theta<10 deg) for bin {i+1}-{j+1}: {max(np.abs(frac_diff_xi_plus[theta_mask]))}") frac_diff_xi_minus = data["shear_xi_minus", f"bin_{i+1}_{j+1}"]/ccl_xi[i][j][1] - 1 print(f"Maximum fractional difference in xi_m (theta>0.05 deg) for bin {i+1}-{j+1}: {max(np.abs(frac_diff_xi_plus[theta_mask]))}") if plot: import matplotlib.pyplot as plt print("Plotting P(k)") fig, ax = plt.subplots(2, 1, sharex=True, sharey=False, figsize=(5, 5)) fig.subplots_adjust(hspace=0, wspace=0) ax[0].loglog(k_lin, pk_lin_ccl, ls="--", label=f"CCL linear P(k)") ax[0].loglog(k_lin, data["matter_power_lin", "p_k"][0], ls="--", label=f"CosmoSIS linear P(k)") ax[0].loglog(k_nl, pk_nl_ccl, label=f"CCL non-linear P(k)") ax[0].loglog(k_nl, data["matter_power_nl", "p_k"][0], label=f"CosmoSIS non-linear P(k)") ax[1].semilogx(k_lin, data["matter_power_lin", "p_k"][0]/pk_lin_ccl-1, ls="--") ax[1].semilogx(k_nl, data["matter_power_nl", "p_k"][0]/pk_nl_ccl-1) ax[0].legend(frameon=False) ax[0].set_ylabel("$P(k)$ [$h^{-3}$ Mpc$^{3}$]") ax[1].set_ylim(-0.05, 0.05) ax[1].set_xlabel("$k$ [$h$ Mpc$^{-1}$]") ax[1].set_ylabel("$\Delta P(k)/P(k)$ [$h$ Mpc$^{-1}$]") fig.suptitle("KCAP vs CCL, P(k)") # fig.savefig("KV450_pofk_kcap_vs_ccl.pdf") print("Plotting Cls") ell_plot_lim = ell_range fig, ax = plt.subplots(n_tomo_bin, n_tomo_bin, sharex=True, sharey=True, figsize=(2*n_tomo_bin, 1.5*n_tomo_bin)) fig.subplots_adjust(hspace=0, wspace=0) u = ell**2 for i in range(n_tomo_bin): for j in range(n_tomo_bin): if j > i: ax[i][j].axis("off") else: ax[i][j].loglog(ell, u*ccl_cl[i][j], label=f"CCL bin {i+1}-{j+1}") ax[i][j].loglog(ell, u*data["shear_cl", f"bin_{i+1}_{j+1}"], label=f"CosmoSIS") ax[i][j].legend(fontsize="small", frameon=False) ax[i][j].set_xlim(*ell_plot_lim) for p in ax[-1]: p.set_xlabel(r"$\ell$") for p in ax: p[0].set_ylabel(r"$\ell^2\ C_\ell$") fig.suptitle("KCAP vs CCL, Cls") #fig.savefig("KV450_Cl_kcap_vs_ccl.pdf") print("Plotting Cl fractional differences.") fig, ax = plt.subplots(n_tomo_bin, n_tomo_bin, sharex=True, sharey=True, figsize=(2*n_tomo_bin, 1.5*n_tomo_bin)) fig.subplots_adjust(hspace=0, wspace=0) for i in range(n_tomo_bin): for j in range(n_tomo_bin): if j > i: ax[i][j].axis("off") else: ax[i][j].semilogx(ell, data["shear_cl", f"bin_{i+1}_{j+1}"]/ccl_cl[i][j]-1, label=f"bin {i+1}-{j+1}") ax[i][j].legend(fontsize="small", frameon=False) ax[i][j].set_xlim(*ell_plot_lim) ax[i][j].set_ylim(-0.1, 0.1) for p in ax[-1]: p.set_xlabel(r"$\ell$") for p in ax: p[0].set_ylabel(r"$|\Delta C_\ell|/C_\ell$") fig.suptitle("KCAP vs CCL, Cls") #fig.savefig("KV450_Cl_kcap_vs_ccl_frac_diff.pdf") print("Plotting xi fractional differences.") theta_plot_lim = theta_range fig, ax = plt.subplots(n_tomo_bin, n_tomo_bin, sharex=True, sharey=True, figsize=(2*n_tomo_bin, 1.5*n_tomo_bin)) fig.subplots_adjust(hspace=0, wspace=0) for i in range(n_tomo_bin): for j in range(n_tomo_bin): if j > i: ax[i][j].axis("off") else: ax[i][j].semilogx(theta, data["shear_xi_plus", f"bin_{i+1}_{j+1}"]/ccl_xi[i][j][0]-1, label=f"xip bin {i+1}-{j+1}") ax[i][j].semilogx(theta, data["shear_xi_minus", f"bin_{i+1}_{j+1}"]/ccl_xi[i][j][1]-1, label=f"xim bin {i+1}-{j+1}") ax[i][j].legend(fontsize="small", frameon=False) ax[i][j].set_xlim(*theta_plot_lim) ax[i][j].set_ylim(-0.1, 0.1) for p in ax[-1]: p.set_xlabel(r"$\theta$ [deg]") for p in ax: p[0].set_ylabel(r"$|\Delta \xi|/\xi$") fig.suptitle("KCAP vs CCL, xis") #fig.savefig("KV450_xi_kcap_vs_ccl_frac_diff.pdf") plt.show()