def test_p2d_init(): """ Test initialization of Pk2D objects """ cosmo = ccl.Cosmology(Omega_c=0.27, Omega_b=0.045, h=0.67, A_s=1e-10, n_s=0.96) #If no input assert_raises(ValueError, ccl.Pk2D) #Input function has incorrect signature assert_raises(ValueError, ccl.Pk2D, pkfunc=pk1d) ccl.Pk2D(pkfunc=lpk2d, cosmo=cosmo) #Input arrays have incorrect sizes lkarr = -4. + 6 * np.arange(100) / 99. aarr = 0.05 + 0.95 * np.arange(100) / 99. pkarr = np.zeros([len(aarr), len(lkarr)]) assert_raises(ValueError, ccl.Pk2D, a_arr=aarr, lk_arr=lkarr, pk_arr=pkarr[1:]) #Check all goes well if we initialize things correctly psp = ccl.Pk2D(a_arr=aarr, lk_arr=lkarr, pk_arr=pkarr) assert_(not np.isnan(psp.eval(1E-2, 0.5, cosmo)))
def test_pk2d_function(): """ Test evaluation of Pk2D objects """ cosmo = ccl.Cosmology( Omega_c=0.27, Omega_b=0.045, h=0.67, A_s=1e-10, n_s=0.96) psp = ccl.Pk2D(pkfunc=lpk2d, cosmo=cosmo) # Test at single point ktest = 1E-2 atest = 0.5 ptrue = pk2d(ktest, atest) phere = psp.eval(ktest, atest, cosmo) assert_almost_equal(np.fabs(phere/ptrue), 1., 6) dphere = psp.eval_dlogpk_dlogk(ktest, atest, cosmo) assert_almost_equal(dphere, -1., 6) ktest = 1 atest = 0.5 ptrue = pk2d(ktest, atest) phere = psp.eval(ktest, atest, cosmo) assert_almost_equal(np.fabs(phere/ptrue), 1., 6) dphere = psp.eval_dlogpk_dlogk(ktest, atest, cosmo) assert_almost_equal(dphere, -1., 6) # Test at array of points ktest = np.logspace(-3, 1, 10) ptrue = pk2d(ktest, atest) phere = psp.eval(ktest, atest, cosmo) assert_allclose(phere, ptrue, rtol=1E-6) dphere = psp.eval_dlogpk_dlogk(ktest, atest, cosmo) assert_allclose(dphere, -1.*np.ones_like(dphere), 6) # Test input is not logarithmic psp = ccl.Pk2D(pkfunc=pk2d, is_logp=False, cosmo=cosmo) phere = psp.eval(ktest, atest, cosmo) assert_allclose(phere, ptrue, rtol=1E-6) dphere = psp.eval_dlogpk_dlogk(ktest, atest, cosmo) assert_allclose(dphere, -1.*np.ones_like(dphere), 6) # Test input is arrays karr = np.logspace(-4, 2, 1000) aarr = np.linspace(0.01, 1., 100) parr = np.array([pk2d(karr, a) for a in aarr]) psp = ccl.Pk2D( a_arr=aarr, lk_arr=np.log(karr), pk_arr=parr, is_logp=False) phere = psp.eval(ktest, atest, cosmo) assert_allclose(phere, ptrue, rtol=1E-6) dphere = psp.eval_dlogpk_dlogk(ktest, atest, cosmo) assert_allclose(dphere, -1.*np.ones_like(dphere), 6)
def test_pk2d_cls(): """ Test interplay between Pk2D and the Limber integrator """ cosmo = ccl.Cosmology(Omega_c=0.27, Omega_b=0.045, h=0.67, A_s=1e-10, n_s=0.96) z = np.linspace(0., 1., 200) n = np.exp(-((z - 0.5) / 0.1)**2) lens1 = ccl.WeakLensingTracer(cosmo, (z, n)) ells = np.arange(2, 10) # Check that passing no power spectrum is fine cells = ccl.angular_cl(cosmo, lens1, lens1, ells) assert all_finite(cells) # Check that passing a bogus power spectrum fails as expected assert_raises(ValueError, ccl.angular_cl, cosmo, lens1, lens1, ells, p_of_k_a=1) # Check that passing a correct power spectrum runs as expected psp = ccl.Pk2D(pkfunc=lpk2d, cosmo=cosmo) cells = ccl.angular_cl(cosmo, lens1, lens1, ells, p_of_k_a=psp) assert all_finite(cells)
def test_pk2d_init(): """ Test initialization of Pk2D objects """ cosmo = ccl.Cosmology(Omega_c=0.27, Omega_b=0.045, h=0.67, A_s=1e-10, n_s=0.96) # If no input assert_raises(ValueError, ccl.Pk2D) # Input function has incorrect signature assert_raises(ValueError, ccl.Pk2D, pkfunc=pk1d) ccl.Pk2D(pkfunc=lpk2d, cosmo=cosmo) # Input function but no cosmo assert_raises(ValueError, ccl.Pk2D, pkfunc=lpk2d) # Input arrays have incorrect sizes lkarr = -4. + 6 * np.arange(100) / 99. aarr = 0.05 + 0.95 * np.arange(100) / 99. pkarr = np.zeros([len(aarr), len(lkarr)]) assert_raises(ValueError, ccl.Pk2D, a_arr=aarr, lk_arr=lkarr, pk_arr=pkarr[1:])
def project_Cl(cosmo, tracer, Pk_a_s, ks, a_s, want_plot=False): # number of redshifts num_zs = Pk_a_s.shape[0] # hubble parameter h = cosmo._params_init_kwargs['h'] # change the order cause that's what CCL prefers i_sort = np.argsort(a_s) a_s = a_s[i_sort] Pk_a_s = Pk_a_s[i_sort, :] assert num_zs == len( a_s), "Different number of input spectra and redshifts" # wave numbers ells = np.geomspace(2, 1000, 20) ''' # simple power spectrum for testing lpk_array = np.log(np.array([ccl.nonlin_matter_power(cosmo, ks*h, a) for a in a_s])) cl_tt = ccl.angular_cl(cosmo, tracer, tracer, ells) # generating fake data Cl_err = cl_tt*np.sqrt(2./(2*ells+1.)) cov = np.diag(Cl_err**2) np.save("data_power/cl_gg_z%4.3f.npy"%a2z(a_s[0]),cl_tt) np.save("data_power/ells.npy",ells) np.save("data_power/cov_cl_gg_z%4.3f.npy"%a2z(a_s[0]),cov) ''' # Create a Pk2D object, giving log k in Mpc^-1 and pk_arr in Mpc^3 #lpk_array = np.log(Pk_a_s/h**3) #pk_tmp = ccl.Pk2D(a_arr=a_s, lk_arr=np.log(ks*h), pk_arr=lpk_array, is_logp=True) pk_tmp = ccl.Pk2D(a_arr=a_s, lk_arr=np.log(ks * h), pk_arr=Pk_a_s / h**3, is_logp=False) # Compute power spectra with and without cutoff cl_tt_tmp = ccl.angular_cl(cosmo, tracer, tracer, ells, p_of_k_a=pk_tmp) if want_plot: # plot the power spectra plt.plot(np.log(ks * h), lpk_array[-1, :], label="ccl") plt.plot(np.log(ks * h), np.log(Pk_a_s[-1, :] / h**3), label="buba") plt.legend() plt.show() # plot the angular power spectra plt.plot(ells, 1E4 * cl_tt, 'r-', label='built-in tracer') plt.plot(ells, 1E4 * cl_tt_tmp, 'k--', label='custom tracer') plt.xscale('log') plt.xlabel('$\\ell$', fontsize=14) plt.ylabel('$10^4\\times C_\\ell$', fontsize=14) plt.legend(loc='upper right', fontsize=12, frameon=False) plt.savefig("figs/Cls.png") plt.show() return ells, cl_tt_tmp
def test_pk2d_smoke(): """Make sure it works once.""" cosmo = ccl.Cosmology( Omega_c=0.27, Omega_b=0.045, h=0.67, A_s=1e-10, n_s=0.96) lkarr = -4.+6*np.arange(100)/99. aarr = 0.05+0.95*np.arange(100)/99. pkarr = np.zeros([len(aarr), len(lkarr)]) psp = ccl.Pk2D(a_arr=aarr, lk_arr=lkarr, pk_arr=pkarr) assert_(not np.isnan(psp.eval(1E-2, 0.5, cosmo)))
def get_response_func() : zarr=np.array([4,3,2,1,0]) resp2d=[] for iz,z in enumerate(zarr) : kresph,_,_,_,resp1d=np.loadtxt("ssc_responses/Response_z%d.txt"%(int(z)),unpack=True) resp2d.append(resp1d) kresp=kresph*0.67 aresp=1./(1.+zarr) resp2d=np.array(resp2d) return ccl.Pk2D(a_arr=aresp,lk_arr=np.log(kresp),pk_arr=resp2d,is_logp=False)
def test_pk2d_mul_pow(): x = np.linspace(0.1, 1, 10) log_y = np.linspace(-3, 1, 20) zarr_a = np.outer(x, np.exp(log_y)) zarr_b = np.outer(-1*x, 4*np.exp(log_y)) pk2d_a = ccl.Pk2D(a_arr=x, lk_arr=log_y, pk_arr=np.log(zarr_a), is_logp=True) pk2d_b = ccl.Pk2D(a_arr=x, lk_arr=log_y, pk_arr=zarr_b, is_logp=False) # This raises an error because multiplication is only defined for # float, int, and Pk2D with pytest.raises(TypeError): pk2d_a*np.array([0.1, 0.2]) # This raises an error because exponention is only defined for # float and int with pytest.raises(TypeError): pk2d_a**pk2d_b # This raises a warning because the power spectrum is non-negative and the # power is non-integer with pytest.warns(CCLWarning): pk2d_b**0.5 pk2d_g = pk2d_a * pk2d_b pk2d_h = 2*pk2d_a pk2d_i = pk2d_a**1.8 _, _, zarr_g = pk2d_g.get_spline_arrays() _, _, zarr_h = pk2d_h.get_spline_arrays() _, _, zarr_i = pk2d_i.get_spline_arrays() assert np.allclose(zarr_a * zarr_b, zarr_g) assert np.allclose(2 * zarr_a, zarr_h) assert np.allclose(zarr_a**1.8, zarr_i) pk2d_j = (pk2d_a + 0.5*pk2d_i)**1.5 _, _, zarr_j = pk2d_j.get_spline_arrays() assert np.allclose((zarr_a + 0.5*zarr_i)**1.5, zarr_j)
def test_pk2d_parsing(): a_arr = np.linspace(0.1, 1, 100) k_arr = np.geomspace(1E-4, 1E3, 1000) pk_arr = a_arr[:, None] * ((k_arr / 0.01) / (1 + (k_arr / 0.01)**3))[None, :] psp = ccl.Pk2D(a_arr=a_arr, lk_arr=np.log(k_arr), pk_arr=np.log(pk_arr)) cosmo = ccl.CosmologyCalculator(Omega_c=0.27, Omega_b=0.045, h=0.67, sigma8=0.8, n_s=0.96, pk_nonlin={ 'a': a_arr, 'k': k_arr, 'delta_matter:delta_matter': pk_arr, 'a:b': pk_arr }) z = np.linspace(0., 1., 200) n = np.exp(-((z - 0.5) / 0.1)**2) lens1 = ccl.WeakLensingTracer(cosmo, (z, n)) ells = np.linspace(2, 100, 10) cls1 = ccl.angular_cl(cosmo, lens1, lens1, ells, p_of_k_a=None) cls2 = ccl.angular_cl(cosmo, lens1, lens1, ells, p_of_k_a='delta_matter:delta_matter') cls3 = ccl.angular_cl(cosmo, lens1, lens1, ells, p_of_k_a='a:b') cls4 = ccl.angular_cl(cosmo, lens1, lens1, ells, p_of_k_a=psp) assert all_finite(cls1) assert all_finite(cls2) assert all_finite(cls3) assert all_finite(cls4) assert np.all(np.fabs(cls2 / cls1 - 1) < 1E-10) assert np.all(np.fabs(cls3 / cls1 - 1) < 1E-10) assert np.all(np.fabs(cls4 / cls1 - 1) < 1E-10) # Wrong name with pytest.raises(KeyError): ccl.angular_cl(cosmo, lens1, lens1, ells, p_of_k_a='a:c') # Wrong type with pytest.raises(ValueError): ccl.angular_cl(cosmo, lens1, lens1, ells, p_of_k_a=3)
def test_spline2d(): x = np.linspace(0.1, 1, 10) log_y = np.linspace(-3, 1, 20) zarr_in = np.outer(x, np.exp(log_y)) pk2d = ccl.Pk2D(a_arr=x, lk_arr=log_y, pk_arr=zarr_in, is_logp=False) pk2d_gsl_spline2d = pk2d.psp.fka xarr, yarr, zarr_out_spline = \ ccl.pyutils._get_spline2d_arrays(pk2d_gsl_spline2d) cosmo = ccl.CosmologyVanillaLCDM() zarr_out_eval = pk2d.eval(k=np.exp(log_y), a=x[-1], cosmo=cosmo) assert np.allclose(x, xarr) assert np.allclose(log_y, yarr) assert np.allclose(zarr_in, zarr_out_spline) assert np.allclose(zarr_in[-1], zarr_out_eval)
def test_pk2d_add(): x = np.linspace(0.1, 1, 10) log_y = np.linspace(-3, 1, 20) zarr_a = np.outer(x, np.exp(log_y)) zarr_b = np.outer(-1*x, 4*np.exp(log_y)) empty_pk2d = ccl.Pk2D(empty=True) pk2d_a = ccl.Pk2D(a_arr=x, lk_arr=log_y, pk_arr=np.log(zarr_a), is_logp=True) pk2d_b = ccl.Pk2D(a_arr=2*x, lk_arr=log_y, pk_arr=zarr_b, is_logp=False) pk2d_b2 = ccl.Pk2D(a_arr=x, lk_arr=log_y+0.5, pk_arr=zarr_b, is_logp=False) # This raises an error because the a ranges don't match with pytest.raises(ValueError): pk2d_a + pk2d_b # This raises an error because the k ranges don't match with pytest.raises(ValueError): pk2d_a + pk2d_b2 # This raises an error because addition with an empty Pk2D should not work with pytest.raises(ValueError): pk2d_a + empty_pk2d pk2d_c = ccl.Pk2D(a_arr=x, lk_arr=log_y, pk_arr=zarr_b, is_logp=False) pk2d_d = pk2d_a + pk2d_c pk2d_d2 = pk2d_a + 1.0 xarr_d, yarr_d, zarr_d = pk2d_d.get_spline_arrays() _, _, zarr_d2 = pk2d_d2.get_spline_arrays() assert np.allclose(x, xarr_d) assert np.allclose(log_y, yarr_d) assert np.allclose(zarr_a + zarr_b, zarr_d) assert np.allclose(zarr_a + 1.0, zarr_d2) pk2d_e = ccl.Pk2D(a_arr=x[1:-1], lk_arr=log_y[1:-1], pk_arr=zarr_b[1:-1, 1:-1], is_logp=False) # This raises a warning because the power spectra are not defined on the # same support with pytest.warns(CCLWarning): pk2d_f = pk2d_e + pk2d_a xarr_f, yarr_f, zarr_f = pk2d_f.get_spline_arrays() assert np.allclose((zarr_a + zarr_b)[1:-1, 1:-1], zarr_f)
def test_tracers_analytic(set_up, alpha, beta, gamma, is_factorizable, w_transfer, mismatch, der_bessel, der_angles): cosmo = set_up zmax = 0.8 zi = 0.4 zf = 0.6 nchi = 1024 nk = 512 # x arrays chii = ccl.comoving_radial_distance(cosmo, 1. / (1 + zi)) chif = ccl.comoving_radial_distance(cosmo, 1. / (1 + zf)) chimax = ccl.comoving_radial_distance(cosmo, 1. / (1 + zmax)) chiarr = np.linspace(0.1, chimax, nchi) if mismatch: # Remove elements around the edges mask = (chiarr < 0.9 * chif) & (chiarr > 1.1 * chii) chiarr_transfer = chiarr[mask] else: chiarr_transfer = chiarr aarr_transfer = ccl.scale_factor_of_chi(cosmo, chiarr_transfer)[::-1] aarr = ccl.scale_factor_of_chi(cosmo, chiarr)[::-1] lkarr = np.log(10.**np.linspace(-6, 3, nk)) # Kernel wchi = np.ones_like(chiarr) wchi[chiarr < chii] = 0 wchi[chiarr > chif] = 0 # Transfer t = ccl.Tracer() if w_transfer: ta = (chiarr_transfer**gamma)[::-1] tk = np.exp(beta * lkarr) if is_factorizable: # 1D t.add_tracer(cosmo, kernel=(chiarr, wchi), transfer_k=(lkarr, tk), transfer_a=(aarr_transfer, ta), der_bessel=der_bessel, der_angles=der_angles) else: # 2D tka = ta[:, None] * tk[None, :] t.add_tracer(cosmo, kernel=(chiarr, wchi), transfer_ka=(aarr_transfer, lkarr, tka), der_bessel=der_bessel, der_angles=der_angles) else: t.add_tracer(cosmo, kernel=(chiarr, wchi), der_bessel=der_bessel, der_angles=der_angles) # Power spectrum pkarr = np.ones_like(aarr)[:, None] * (np.exp(alpha * lkarr))[None, :] pk2d = ccl.Pk2D(a_arr=aarr, lk_arr=lkarr, pk_arr=pkarr, is_logp=False) # C_ells larr = np.linspace(2, 3000, 100) # 1D cl = ccl.angular_cl(cosmo, t, t, larr, p_of_k_a=pk2d) # Prediction clpred = get_prediction(larr, chii, chif, alpha, beta, gamma, der_bessel, der_angles) assert np.all(np.fabs(cl / clpred - 1) < 5E-3)
def compute_Cls(par,z_cent=z_s_cents,N_gal_sample=N_gal_bin,k_arr=k_ar,z_arr=z_ar,a_arr=a_ar,ell=ells,compute_inv_cov=False,plot_for_sanity=False,powerspec='halofit',simple_bias=False): # HOD parameters -- don't need to be called every time so can be taken out hod_par = { 'sigm_0': 0.4, 'sigm_1': 0., 'alpha_0': 1.0, 'alpha_1': 0., 'fc_0': 1., 'fc_1': 0., 'lmmin_0': par['lmmin_0']['val'], 'lmmin_1': par['lmmin_1']['val'], 'm0_0': par['m0_0']['val'], 'm0_1': par['m0_1']['val'], 'm1_0': par['m1_0']['val'], 'm1_1': par['m1_1']['val']} if powerspec == 'halofit': # Compute matter pk using halofit -- preferred pk_mm_arr = np.array([ccl.nonlin_matter_power(cosmo_fid, k_arr, a) for a in a_arr]) elif powerspec == 'halomodel': # Alternatively use halo model pk_mm_arr = np.array([ccl.halomodel.halomodel_matter_power(cosmo_fid, k_arr, a) for a in a_arr]) if simple_bias == True: # Using bias parameters # Pk_gg = b^2 Pmm and Pk_gm = b Pmm; however, this is taken into account when def tracers pk_gg_arr = pk_mm_arr.copy() pk_gm_arr = pk_mm_arr.copy() # load bias parameter b_z = np.array([par['b_%02d'%k]['val'] for k in range(N_zsamples)]) else: # Using the HOD model # load HOD and compute profile hodpars = hod_funcs_evol_fit.HODParams(hod_par, islogm0=True, islogm1=True) hodprof = hod.HODProfile(cosmo_fid, hodpars.lmminf, hodpars.sigmf,\ hodpars.fcf, hodpars.m0f, hodpars.m1f, hodpars.alphaf) # Compute galaxy power spectrum using halofit pk_gg_arr = np.array([hodprof.pk(k_arr, a_arr[i]) for i in range(a_arr.shape[0])]) # Compute galaxy-matter pk using halofit pk_gm_arr = np.array([hodprof.pk_gm(k_arr, a_arr[i]) for i in range(a_arr.shape[0])]) # Here we don't vary the bias parameters b_z = np.ones(N_zsamples) # Create pk2D objects for interpolation pk_mm = ccl.Pk2D(a_arr=a_arr, lk_arr=np.log(k_arr), pk_arr=np.log(pk_mm_arr), is_logp=True) pk_gg = ccl.Pk2D(a_arr=a_arr, lk_arr=np.log(k_arr), pk_arr=np.log(pk_gg_arr), is_logp=True) pk_gm = ccl.Pk2D(a_arr=a_arr, lk_arr=np.log(k_arr), pk_arr=np.log(pk_gm_arr), is_logp=True) # Assume a functional form of 0.95/D(a) for the bias parameters (notice how this plays in # the case of varying b(z)) it doesn't matter a lot in this case for we take finite diff #a_cent = 1./(1.+z_cent) #b_z *= 0.95/ccl.growth_factor(cosmo_fid,a_cent) # load the dndz parameters dndz_z = np.zeros((N_tomo,N_zsamples)) for i_z in range(N_tomo): dndz_z[i_z,:] = np.array([par['dndz_%02d_%02d'%(i_z,k)]['val'] for k in range(N_zsamples)]) # Number of total correlation elements for all of gg gs and ss variants tot_corr = N_ell*(N_tomo*(2*N_tomo+1)) # make CL_all of size N_ell*N_tomo*(2N_tomo+1) CL_ALL = np.zeros(tot_corr) # this lists all possible combinations of all gg gs and ss's for a given number of tomo bins # here is how it works: say we have 3 tomo bins, then we make an array of 2x3 = 6 numbers # from 0 through 5; where 0 through 2 correspond to galaxy tracer (g) and 3 through 5 to # shear tracer (s). # Our final list all_combos consists of every possible pair between # tracer 1 which can be any of 3 tomos and either g or s and tracer 2 which can also be # any of 3 tomos and either g or s. The way I do this is by first listing in temp # the 6 pairs making up all the tracer 1 and tracer 2 combs where they are either # both g or both s at the same tomographic redshift, i.e. temp is (0,0), (1,1) ... (5,5) # then I use the function combinations which finds all unique combinations between # two lists i.e. (0,1),(0,2)...(0,5),(1,2)...(1,5),(2,3)...(2,5),(3,4),(3,5),(4,5) # and call this list combs. Finally I combine the two in all_combos. # Note: combs does not have (1,0) for it contributes the same info as (0,1) # example pair (2,4) in this example corresponds to tracer 1 being galaxies in third tomographic # bin and tracer 2 being shear in second tomographic bin, in short (2,4)=(g2,s1) temp = np.arange(2*N_tomo) temp = np.vstack((temp,temp)).T combs = np.array(list(combinations(range(2*N_tomo),2))) all_combos = np.vstack((temp,combs)) for c, comb in enumerate(all_combos): # comb is the list pair, e.g. (2,5) while c is its order no. (b/n 0 and Ntomo(2Ntomo+1)-1) i = comb[0]%N_tomo # redshift bin of tracer 1 (b/n 0 and N_tomo-1 regardless of g or s) j = comb[1]%N_tomo # redshift bin of tracer 2 (b/n 0 and N_tomo-1 regardless of g or s) t_i = comb[0]//N_tomo # tracer type (0 or 1): 0 means g and 1 means s t_j = comb[1]//N_tomo # tracer type (0 or 1): 0 means g and 1 means s # Adding NOISE to only the diagonal elements if (i == j): # number density of galaxies - use area cosmos for these are the gals that overlap N_gal = N_gal_sample[i] n_gal = N_gal/area_COSMOS # in rad^-2 # Adding noise noise_gal = 1./n_gal noise_shape = sigma_e2[i]/n_gal else: noise_gal = 0. noise_shape = 0. # Now create corresponding Cls with pk2D objects matched to pk if t_i*2+t_j == 0: # this is gg (notice that this can only be 2*0+0 = 0) tracer_z1 = ccl.NumberCountsTracer(cosmo_fid, bias=(z_cent, b_z), \ dndz=(z_cent, dndz_z[i,:]),mag_bias=None, \ has_rsd=False) tracer_z2 = ccl.NumberCountsTracer(cosmo_fid, bias=(z_cent, b_z), \ dndz=(z_cent, dndz_z[j,:]),mag_bias=None, \ has_rsd=False) cl_gg = ccl.angular_cl(cosmo_fid, tracer_z1, tracer_z2, ell, p_of_k_a=pk_gg) cl_gg_no = cl_gg + noise_gal CL_ALL[(N_ell*c):(N_ell*c)+N_ell] = cl_gg_no elif t_i*2+t_j == 1: # this is gs (notice that this can only be 2*0+1 = 1, never 2*1+0=2) tracer_z1 = ccl.NumberCountsTracer(cosmo_fid, bias=(z_cent, b_z), \ dndz=(z_cent, dndz_z[i,:]),mag_bias=None, \ has_rsd=False) tracer_z2 = ccl.WeakLensingTracer(cosmo_fid, dndz=(z_cent, dndz_z[j,:])) cl_gs = ccl.angular_cl(cosmo_fid, tracer_z1, tracer_z2, ell, p_of_k_a=pk_gm) cl_gs_no = cl_gs CL_ALL[(N_ell*c):(N_ell*c)+N_ell] = cl_gs_no elif t_i*2+t_j == 3: # this is ss (notice that this can only be 2*1+1 = 3) tracer_z1 = ccl.WeakLensingTracer(cosmo_fid, dndz=(z_cent, dndz_z[i,:])) tracer_z2 = ccl.WeakLensingTracer(cosmo_fid, dndz=(z_cent, dndz_z[j,:])) cl_ss = ccl.angular_cl(cosmo_fid, tracer_z1, tracer_z2, ell, p_of_k_a=pk_mm) cl_ss_no = cl_ss + noise_shape CL_ALL[(N_ell*c):(N_ell*c)+N_ell] = cl_ss_no # check whether things make sense if plot_for_sanity == True: if c == 0: # Plot for sanity plt.loglog(ells, cl_gg, label=r'$\mathrm{gg}$') plt.loglog(ells, cl_gg_no, label=r'$\mathrm{gg}+{\rm noise}$') plt.loglog(ells, cl_ss, label=r'$\mathrm{ss}$') plt.loglog(ells, cl_gs, label=r'$\mathrm{gs}$') plt.xlabel(r'$\ell$') plt.ylabel(r'$C_{\ell}$') plt.legend() plt.savefig('Cls.png') plt.close() # if we don't want the inverse covariance matrix if compute_inv_cov == False: print(len(CL_ALL)) return CL_ALL # print out numbers to make sure there is internet connection print(len(CL_ALL)) print(np.sum(CL_ALL>0)) # initiate covariance matrix into the trade COV_ALL = np.zeros((len(CL_ALL),len(CL_ALL))) # COMPUTE COVARIANCE MATRIX: Cov(A,B) for c_A, comb_A in enumerate(all_combos): # remove half the computations for c_B, comb_B in enumerate(all_combos): # pair A=(ti,tj), pair B=(tm,tn) at same ell, where t stands for either g or s i = comb_A[0]%N_tomo # redshift bin of tracer A_1 (i.e. along rows of Cov) j = comb_A[1]%N_tomo # redshift bin of tracer A_2 (i.e. along rows of Cov) m = comb_B[0]%N_tomo # redshift bin of tracer B_1 (i.e. along columns of Cov) n = comb_B[1]%N_tomo # redshift bin of tracer B_2 (i.e. along columns of Cov) # These are the pairs (their order number in all_combos) we need for Knox # cov(ij,mn) = im,jn + in,jm c_im = np.argmax(np.product(np.sort(np.array([comb_A[0],comb_B[0]]))==all_combos,axis=1)) c_jn = np.argmax(np.product(np.sort(np.array([comb_A[1],comb_B[1]]))==all_combos,axis=1)) c_in = np.argmax(np.product(np.sort(np.array([comb_A[0],comb_B[1]]))==all_combos,axis=1)) c_jm = np.argmax(np.product(np.sort(np.array([comb_A[1],comb_B[0]]))==all_combos,axis=1)) # retrieving their Cls C_im = CL_ALL[(c_im*N_ell):(c_im*N_ell)+N_ell] C_jn = CL_ALL[(c_jn*N_ell):(c_jn*N_ell)+N_ell] C_in = CL_ALL[(c_in*N_ell):(c_in*N_ell)+N_ell] C_jm = CL_ALL[(c_jm*N_ell):(c_jm*N_ell)+N_ell] # Knox formula Cov_ijmn = (C_im*C_jn+C_in*C_jm)/((2*ell+1.)*delta_ell*f_sky) if plot_for_sanity == True: if (c_A == c_B): print(i,j,'=',m,n) print(c_A) Cl_err = np.sqrt(Cov_ijmn) t_i = comb_A[0]//N_tomo t_j = comb_A[1]//N_tomo print(N_tomo*i+j+1) plt.subplot(N_tomo, N_tomo, N_tomo*i+j+1) plt.title("z=%f x z=%f"%(z_bin_cents[i],z_bin_cents[j])) c_ij = np.argmax(np.product(np.sort(np.array([comb_A[0],comb_A[1]]))==all_combos,axis=1)) C_ij = CL_ALL[(c_ij*N_ell):(c_ij*N_ell)+N_ell] # maybe add legend and make sure colors are the same for each type (_,caps,eb)=plt.errorbar(ell,C_ij,yerr=Cl_err,lw=2.,ls='-',capsize=5,label=str(t_i*2+t_j)) plt.legend() plt.xscale('log') plt.yscale('log') #plt.ylim([1.e-12,1.e-5]) # fill in the diagonals of the cov matrix and make use of its symmetry Cov(A,B)=Cov(B,A) COV_ALL[(N_ell*c_A):(N_ell*c_A)+\ N_ell,(N_ell*c_B):(N_ell*c_B)+N_ell] = np.diag(Cov_ijmn) COV_ALL[(N_ell*c_B):(N_ell*c_B)+\ N_ell,(N_ell*c_A):(N_ell*c_A)+N_ell] = np.diag(Cov_ijmn) # check matrix is positive definite if (is_pos_def(COV_ALL) != True): print("Covariance is not positive definite!"); exit(0) # compute and return inverse ICOV_ALL = la.inv(COV_ALL) return ICOV_ALL
def hm_ang_power_spectrum(cosmo, hmc, l, profiles, include_1h=True, include_2h=True, hm_correction=None, kpts=128, zpts=16, **kwargs): """Angular power spectrum using CCL. Args: cosmo (~pyccl.core.Cosmology): a Cosmology object hmc (`~pyccl.halos.halo_model.HMCalculator): halo model calculator l (`numpy.array`): effective multipoles to sample profiles (tuple of `model.data.ProfTracer`): profile and tracer pair include_1h (`bool`): whether to include the 1-halo term include_2h (`bool`): whether to include the 2-halo term kpts (`int`): number of wavenumber integration points zpts (`int`): number of redshift integration points **kwagrs: Parametrisation of the profiles and cosmology. Returns: `numpy.array`: Angular power spectrum of input profiles. """ p1, p2 = profiles p1.update_parameters(cosmo, **kwargs) p2.update_parameters(cosmo, **kwargs) # Set up covariance p2pt = get_2pt(p1, p2, **kwargs) k_arr = np.logspace(-3, 2, kpts) if p1.type == "g": zmin, zmax = p1.zrange elif p2.type == "g": zmin, zmax = p2.zrange else: zmax = 6.0 a_arr = np.linspace(1 / (1 + zmax), 1., zpts) smooth, supress = None, None if hm_correction == "Mead": aHM = kwargs.get("a_HM_" + p1.type + p2.type) if aHM is not None: smooth = lambda a: aHM sHM = kwargs.get("s_HM_" + p1.type + p2.type) if sHM is not None: supress = lambda a: sHM pk_arr = ccl.halos.halomod_power_spectrum(cosmo, hmc, k_arr, a_arr, prof=p1.profile, prof_2pt=p2pt, prof2=p2.profile, normprof=(p1.type != "y"), normprof2=(p2.type != "y"), get_1h=include_1h, get_2h=include_2h, smooth_transition=smooth, supress_1h=supress) if hm_correction == "HALOFIT": pk_arr *= hm_correction(k_arr, a_arr) pk = ccl.Pk2D(a_arr=a_arr, lk_arr=np.log(k_arr), pk_arr=pk_arr, cosmo=cosmo, is_logp=False) cl = ccl.angular_cl(cosmo, p1.tracer, p2.tracer, ell=l, p_of_k_a=pk) return cl
def _get_p_of_k_a(self, emu_spec, cosmo, b_trs, clm): # eBOSS, DECALS also gc # Initialize power spectrum Pk_a(as, ks) Pk_a = np.zeros_like(emu_spec[:, 0, :]) # If both tracers are galaxies, Pk^{tr1,tr2} = f_i^bin1 * f_j^bin2 * Pk_ij if ('gc' in clm['bin_1'] or 'eBOSS' in clm['bin_1'] or 'DECALS' in clm['bin_1']) and ('gc' in clm['bin_2'] or 'eBOSS' in clm['bin_2'] or 'DECALS' in clm['bin_2']): bias_eft1 = b_trs[clm['bin_1']] bias_eft2 = b_trs[clm['bin_2']] for key1 in bias_eft1.keys(): bias1 = bias_eft1[key1] for key2 in bias_eft2.keys(): bias2 = bias_eft2[key2] if key1 + '_' + key2 in self.emu_dict.keys(): comb = self.emu_dict[key1 + '_' + key2] else: comb = self.emu_dict[key2 + '_' + key1] Pk_a += bias1 * bias2 * emu_spec[:, comb, :] # If first tracer is galaxies, Pk^{tr1,tr2} = f_i^bin1 * 1. * Pk_0i elif ('gc' in clm['bin_1'] or 'eBOSS' in clm['bin_1'] or 'DECALS' in clm['bin_1']) and ('wl' in clm['bin_2'] or 'KiDS1000' in clm['bin_2']): bias_eft1 = b_trs[clm['bin_1']] for key1 in bias_eft1.keys(): bias1 = bias_eft1[key1] comb = self.emu_dict['b0' + '_' + key1] Pk_a += bias1 * emu_spec[:, comb, :] # If second tracer is galaxies, Pk^{tr1,tr2} = f_j^bin2 * 1. * Pk_0j elif ('wl' in clm['bin_1'] or 'KiDS1000' in clm['bin_1']) and ('gc' in clm['bin_2'] or 'eBOSS' in clm['bin_2'] or 'DECALS' in clm['bin_2']): bias_eft2 = b_trs[clm['bin_2']] for key2 in bias_eft2.keys(): bias2 = bias_eft2[key2] comb = self.emu_dict['b0' + '_' + key2] Pk_a += bias2 * emu_spec[:, comb, :] # Convert ks from [Mpc/h]^-1 to [Mpc]^-1 lk_arr = np.log(self.k * cosmo['H0'] / 100.) # Same for the power spectrum: convert to Mpc^3 Pk_a /= (cosmo['H0'] / 100.)**3. # Compute the 2D power spectrum p_of_k_a = ccl.Pk2D(a_arr=self.a, lk_arr=lk_arr, pk_arr=Pk_a, is_logp=False) return p_of_k_a
def compute_Cls(cosmo_fid, dndz_z, b_z, z_cent, N_gal_sample, ell, a_arr, k_arr, sigma_e2, area_overlap, powerspec='halofit', simple_bias=True): N_ell = len(ell) N_zsamples_theo = len(z_cent) N_tomo = len(N_gal_sample) # choose a scheme for evaluating the matter power spectrum -- halofit is recommended if powerspec == 'halofit': # Compute matter pk using halofit pk_mm_arr = np.array( [ccl.nonlin_matter_power(cosmo_fid, k_arr, a) for a in a_arr]) elif powerspec == 'halomodel': # Alternatively use halo model pk_mm_arr = np.array([ ccl.halomodel.halomodel_matter_power(cosmo_fid, k_arr, a) for a in a_arr ]) # choose a scheme for evaluating the galaxy power spectrum between simple bias and HOD model if simple_bias == True: # Set the power spectra equal to the matter PS -- this changes later in the code pk_gg_arr = pk_mm_arr.copy() pk_gm_arr = pk_mm_arr.copy() else: # HOD parameter values hod_par = {'sigm_0': 0.4,'sigm_1': 0.,'alpha_0': 1.0,'alpha_1': 0.,'fc_0': 1.,'fc_1': 0.,\ 'lmmin_0': 3.71,'lmmin_1': 9.99,'m0_0': 1.28,'m0_1': 10.34,'m1_0': 7.08,'m1_1': 9.34} # Evolve HOD parameters and create an HOD profile hodpars = hod_funcs_evol_fit.HODParams(hod_par, islogm0=True, islogm1=True) hodprof = hod.HODProfile(cosmo_fid, hodpars.lmminf, hodpars.sigmf,\ hodpars.fcf, hodpars.m0f, hodpars.m1f, hodpars.alphaf) # Compute galaxy pk using halofit pk_gg_arr = np.array( [hodprof.pk(k_arr, a_arr[i]) for i in range(a_arr.shape[0])]) # Compute galaxy-matter pk using halofit pk_gm_arr = np.array( [hodprof.pk_gm(k_arr, a_arr[i]) for i in range(a_arr.shape[0])]) # Wipe b_z since HOD is adopted b_z[:, :] = 1. # Create pk2D objects for interpolation pk_mm = ccl.Pk2D(a_arr=a_arr, lk_arr=np.log(k_arr), pk_arr=np.log(pk_mm_arr), is_logp=True) pk_gg = ccl.Pk2D(a_arr=a_arr, lk_arr=np.log(k_arr), pk_arr=np.log(pk_gg_arr), is_logp=True) pk_gm = ccl.Pk2D(a_arr=a_arr, lk_arr=np.log(k_arr), pk_arr=np.log(pk_gm_arr), is_logp=True) # number of indep correlation functions per type gg gs ss N_tot_corr = N_ell * (N_tomo * (2 * N_tomo + 1)) # make C_ell of size N_ell*N_tomo*(2N_tomo+1) C_ell = np.zeros(N_tot_corr) # List all redshift bin combinations temp = np.arange(2 * N_tomo) temp = np.vstack((temp, temp)).T combs = np.array(list(combinations(range(2 * N_tomo), 2))) all_combos = np.vstack((temp, combs)) for c, comb in enumerate(all_combos): i = comb[0] % N_tomo # first redshift bin j = comb[1] % N_tomo # second redshift bin t_i = comb[0] // N_tomo # tracer type 0 means g and 1 means s t_j = comb[1] // N_tomo # tracer type 0 means g and 1 means s # Noise if (i == j): # number density of galaxies N_gal = N_gal_sample[i] n_gal = N_gal / area_overlap # in rad^-2 # Adding noise noise_gal = 1. / n_gal noise_shape = sigma_e2[i] / n_gal else: noise_gal = 0. noise_shape = 0. # Now create corresponding Cls with pk2D objects matched to pk # this is gg if t_i * 2 + t_j == 0: tracer_z1 = ccl.NumberCountsTracer(cosmo_fid, bias=(z_cent, b_z[i,:]), \ dndz=(z_cent, dndz_z[i,:]),mag_bias=None, \ has_rsd=False) tracer_z2 = ccl.NumberCountsTracer(cosmo_fid, bias=(z_cent, b_z[j,:]), \ dndz=(z_cent, dndz_z[j,:]),mag_bias=None, \ has_rsd=False) cl_gg = ccl.angular_cl(cosmo_fid, tracer_z1, tracer_z2, ell, p_of_k_a=pk_gg) cl_gg_no = cl_gg + noise_gal C_ell[(N_ell * c):(N_ell * c) + N_ell] = cl_gg_no # this is gs elif t_i * 2 + t_j == 1: tracer_z1 = ccl.NumberCountsTracer(cosmo_fid, bias=(z_cent, b_z[i,:]), \ dndz=(z_cent, dndz_z[i,:]),mag_bias=None, \ has_rsd=False) tracer_z2 = ccl.WeakLensingTracer(cosmo_fid, dndz=(z_cent, dndz_z[j, :])) cl_gs = ccl.angular_cl(cosmo_fid, tracer_z1, tracer_z2, ell, p_of_k_a=pk_gm) cl_gs_no = cl_gs C_ell[(N_ell * c):(N_ell * c) + N_ell] = cl_gs_no # this is ss elif t_i * 2 + t_j == 3: tracer_z1 = ccl.WeakLensingTracer(cosmo_fid, dndz=(z_cent, dndz_z[i, :])) tracer_z2 = ccl.WeakLensingTracer(cosmo_fid, dndz=(z_cent, dndz_z[j, :])) cl_ss = ccl.angular_cl(cosmo_fid, tracer_z1, tracer_z2, ell, p_of_k_a=pk_mm) cl_ss_no = cl_ss + noise_shape C_ell[(N_ell * c):(N_ell * c) + N_ell] = cl_ss_no print(len(C_ell)) return C_ell
import numpy as np import pytest import pyccl as ccl COSMO = ccl.Cosmology( Omega_c=0.27, Omega_b=0.045, h=0.67, sigma8=0.8, n_s=0.96, transfer_function='bbks', matter_power_spectrum='linear') PKA = ccl.Pk2D(lambda k, a: np.log(a/k), cosmo=COSMO) HBFS = [ccl.halos.HaloBiasSheth99, ccl.halos.HaloBiasSheth01, ccl.halos.HaloBiasTinker10, ccl.halos.HaloBiasBhattacharya11] MS = [1E13, [1E12, 1E15], np.array([1E12, 1E15])] MFOF = ccl.halos.MassDef('fof', 'matter') MVIR = ccl.halos.MassDef('vir', 'critical') MDFS = [MVIR, MVIR, MFOF, MVIR] @pytest.mark.parametrize('bM_class', HBFS) def test_bM_subclasses_smoke(bM_class): bM = bM_class(COSMO) for m in MS: b = bM.get_halo_bias(COSMO, m, 0.9) assert np.all(np.isfinite(b)) assert np.shape(b) == np.shape(m) @pytest.mark.parametrize('bM_pair', zip(HBFS, MDFS)) def test_bM_mdef_raises(bM_pair): bM_class, mdef = bM_pair
def test_pk2d_get_spline_arrays(): empty_pk2d = ccl.Pk2D(empty=True) # Pk2D needs splines defined to get splines out with pytest.raises(ValueError): empty_pk2d.get_spline_arrays()
def compute_mCs(par,i_zs,j_zs,z_cent=z_s_cents,k_arr=k_ar,z_arr=z_ar,a_arr=a_ar,ell=ells): # Compute matter pk using halofit pk_mm_arr = np.array([ccl.nonlin_matter_power(cosmo_fid, k_arr, a) for a in a_arr]) pk_gg_arr = pk_mm_arr.copy() # because we later include bias pk_gm_arr = pk_mm_arr.copy() # because we later include bias # Create pk2D objects for interpolation pk_mm = ccl.Pk2D(a_arr=a_arr, lk_arr=np.log(k_arr), pk_arr=np.log(pk_mm_arr), is_logp=True) pk_gg = ccl.Pk2D(a_arr=a_arr, lk_arr=np.log(k_arr), pk_arr=np.log(pk_gg_arr), is_logp=True) pk_gm = ccl.Pk2D(a_arr=a_arr, lk_arr=np.log(k_arr), pk_arr=np.log(pk_gm_arr), is_logp=True) # bias parameters should be set to 1 b_z = np.ones(N_zsamples) # load the dndz parameters for curly C matrix element i_zs,j_zs dndz_z_single_i = np.zeros((N_tomo_single,N_zsamples)) dndz_z_single_j = np.zeros((N_tomo_single,N_zsamples)) # D_i_many is defined below for i_z in range(N_tomo_single): if interp == 'nearest': dndz_z_single_i[i_z,:] = D_i_many_near[i_zs,:] dndz_z_single_j[i_z,:] = D_i_many_near[j_zs,:] elif interp == 'linear': dndz_z_single_i[i_z,:] = D_i_many[i_zs,:] dndz_z_single_j[i_z,:] = D_i_many[j_zs,:] # per type gg gs ss tot_corr = N_ell*(N_tomo_single*(2*N_tomo_single+1)) # make Cl_all of size N_ell*N_tomo_single*(2N_tomo_single+1)=30 CL_ALL = np.zeros(tot_corr) temp = np.arange(2*N_tomo_single) temp = np.vstack((temp,temp)).T combs = np.array(list(combinations(range(2*N_tomo_single),2))) all_combos = np.vstack((temp,combs)) for c, comb in enumerate(all_combos): # this is artifact from the other code -- here N_tomo_single is always 1 i = comb[0]%N_tomo_single # first redshift bin (ALWAYS 0 HERE) j = comb[1]%N_tomo_single # second redshift bin (ALWAYS 0 HERE) t_i = comb[0]//N_tomo_single # tracer type 0 means g and 1 means s t_j = comb[1]//N_tomo_single # tracer type 0 means g and 1 means s # Now create corresponding Cls with pk2D objects matched to pk if t_i*2+t_j == 0: # this is gg tracer_z1 = ccl.NumberCountsTracer(cosmo_fid, bias=(z_cent, b_z), \ dndz=(z_cent, dndz_z_single_i[i,:]),mag_bias=None, \ has_rsd=False) tracer_z2 = ccl.NumberCountsTracer(cosmo_fid, bias=(z_cent, b_z), \ dndz=(z_cent, dndz_z_single_j[j,:]),mag_bias=None, \ has_rsd=False) cl_gg = ccl.angular_cl(cosmo_fid, tracer_z1, tracer_z2, ell, p_of_k_a=pk_gg) cl_gg_no = cl_gg + 0. CL_ALL[(N_ell*c):(N_ell*c)+N_ell] = cl_gg_no elif t_i*2+t_j == 1: # this is gs tracer_z1 = ccl.NumberCountsTracer(cosmo_fid, bias=(z_cent, b_z), \ dndz=(z_cent, dndz_z_single_i[i,:]),mag_bias=None, \ has_rsd=False) tracer_z2 = ccl.WeakLensingTracer(cosmo_fid, dndz=(z_cent, dndz_z_single_j[j,:])) cl_gs = ccl.angular_cl(cosmo_fid, tracer_z1, tracer_z2, ell, p_of_k_a=pk_gm) cl_gs_no = cl_gs CL_ALL[(N_ell*c):(N_ell*c)+N_ell] = cl_gs_no elif t_i*2+t_j == 3: # this is ss tracer_z1 = ccl.WeakLensingTracer(cosmo_fid, dndz=(z_cent, dndz_z_single_i[i,:])) tracer_z2 = ccl.WeakLensingTracer(cosmo_fid, dndz=(z_cent, dndz_z_single_j[j,:])) cl_ss = ccl.angular_cl(cosmo_fid, tracer_z1, tracer_z2, ell, p_of_k_a=pk_mm) cl_ss_no = cl_ss + 0. CL_ALL[(N_ell*c):(N_ell*c)+N_ell] = cl_ss_no return CL_ALL
def getCls(self, tr_i_name, tr_j_name, l_arr): """ typ - is a two character string gg, gs,ss, sy, sk etc... i,j are indices for g and s""" if self.params['corr_halo_mod']: logger.info('Correcting halo model Pk with HALOFIT ratio.') if not hasattr(self, 'rk_hm'): logger.info('Computing halo model correction.') HMCorr = HaloModCorrection(self.cosmo, self.hmc, self.pM, k_range=[1e-4, 1e2], nlk=256, z_range=[0., 3.], nz=50) self.rk_hm = HMCorr.rk_interp(GSKYTheory.k_arr, GSKYTheory.a_arr) if 'wl' in tr_i_name and 'wl' in tr_j_name or 'wl' in tr_i_name and 'kappa' in tr_j_name or \ 'kappa' in tr_i_name and 'wl' in tr_j_name or 'kappa' in tr_i_name and 'kappa' in tr_j_name: if not hasattr(self, 'pk_MMf'): if not self.params['corr_halo_mod']: Pk = ccl.halos.halomod_Pk2D(self.cosmo, self.hmc, self.pM, normprof1=True, lk_arr=np.log( GSKYTheory.k_arr), a_arr=GSKYTheory.a_arr) else: Pk_arr = ccl.halos.halomod_power_spectrum(self.cosmo, self.hmc, GSKYTheory.k_arr, GSKYTheory.a_arr, self.pM, normprof1=True) Pk_arr *= self.rk_hm Pk = ccl.Pk2D(a_arr=GSKYTheory.a_arr, lk_arr=np.log(GSKYTheory.k_arr), pk_arr=Pk_arr, cosmo=self.cosmo, is_logp=False) self.pk_MMf = Pk else: Pk = self.pk_MMf elif 'wl' in tr_i_name and 'y' in tr_j_name or 'y' in tr_i_name and 'wl' in tr_j_name or \ 'kappa' in tr_i_name and 'y' in tr_j_name or 'y' in tr_i_name and 'kappa' in tr_j_name: if not hasattr(self, 'pk_yMf'): if not self.params['corr_halo_mod']: Pk = ccl.halos.halomod_Pk2D(self.cosmo, self.hmc, self.py, prof2=self.pM, normprof1=False, normprof2=True, lk_arr=np.log( GSKYTheory.k_arr), a_arr=GSKYTheory.a_arr) else: Pk_arr = ccl.halos.halomod_power_spectrum(self.cosmo, self.hmc, GSKYTheory.k_arr, GSKYTheory.a_arr, self.py, prof2=self.pM, normprof1=False, normprof2=True) Pk_arr *= self.rk_hm Pk = ccl.Pk2D(a_arr=GSKYTheory.a_arr, lk_arr=np.log(GSKYTheory.k_arr), pk_arr=Pk_arr, cosmo=self.cosmo, is_logp=False) self.pk_yMf = Pk else: Pk = self.pk_yMf elif 'g' in tr_i_name and 'wl' in tr_j_name or 'wl' in tr_i_name and 'g' in tr_j_name or \ 'kappa' in tr_i_name and 'g' in tr_j_name or 'g' in tr_i_name and 'kappa' in tr_j_name: if self.params['HODmod'] == 'zevol': if not hasattr(self, 'pk_gMf'): if not self.params['corr_halo_mod']: Pk = ccl.halos.halomod_Pk2D(self.cosmo, self.hmc, self.pg, prof2=self.pM, normprof1=True, normprof2=True, lk_arr=np.log( GSKYTheory.k_arr), a_arr=GSKYTheory.a_arr) else: Pk_arr = ccl.halos.halomod_power_spectrum( self.cosmo, self.hmc, GSKYTheory.k_arr, GSKYTheory.a_arr, self.pg, prof2=self.pM, normprof1=True, normprof2=True) Pk_arr *= self.rk_hm Pk = ccl.Pk2D(a_arr=GSKYTheory.a_arr, lk_arr=np.log(GSKYTheory.k_arr), pk_arr=Pk_arr, cosmo=self.cosmo, is_logp=False) self.pk_gMf = Pk else: Pk = self.pk_gMf else: if 'g' in tr_i_name: tr_g_name = tr_i_name else: tr_g_name = tr_j_name if not self.params['corr_halo_mod']: Pk = ccl.halos.halomod_Pk2D( self.cosmo, self.hmc, self.ccl_tracers[tr_g_name]['prof'], prof2=self.pM, normprof1=True, normprof2=True, lk_arr=np.log(GSKYTheory.k_arr), a_arr=GSKYTheory.a_arr) else: Pk_arr = ccl.halos.halomod_power_spectrum( self.cosmo, self.hmc, GSKYTheory.k_arr, GSKYTheory.a_arr, self.ccl_tracers[tr_g_name]['prof'], prof2=self.pM, normprof1=True, normprof2=True) Pk_arr *= self.rk_hm Pk = ccl.Pk2D(a_arr=GSKYTheory.a_arr, lk_arr=np.log(GSKYTheory.k_arr), pk_arr=Pk_arr, cosmo=self.cosmo, is_logp=False) elif 'g' in tr_i_name and 'y' in tr_j_name or 'y' in tr_i_name and 'g' in tr_j_name: if self.params['HODmod'] == 'zevol': if not hasattr(self, 'pk_ygf'): if not self.params['corr_halo_mod']: Pk = ccl.halos.halomod_Pk2D(self.cosmo, self.hmc, self.pg, prof2=self.py, normprof1=True, normprof2=False, lk_arr=np.log( GSKYTheory.k_arr), a_arr=GSKYTheory.a_arr) else: Pk_arr = ccl.halos.halomod_power_spectrum( self.cosmo, self.hmc, GSKYTheory.k_arr, GSKYTheory.a_arr, self.pg, prof2=self.py, normprof1=True, normprof2=False) Pk_arr *= self.rk_hm Pk = ccl.Pk2D(a_arr=GSKYTheory.a_arr, lk_arr=np.log(GSKYTheory.k_arr), pk_arr=Pk_arr, cosmo=self.cosmo, is_logp=False) self.pk_ygf = Pk else: Pk = self.pk_ygf else: if 'g' in tr_i_name: tr_g_name = tr_i_name else: tr_g_name = tr_j_name Pk = ccl.halos.halomod_Pk2D( self.cosmo, self.hmc, self.ccl_tracers[tr_g_name]['prof'], prof2=self.py, normprof1=True, normprof2=False, lk_arr=np.log(GSKYTheory.k_arr), a_arr=GSKYTheory.a_arr) elif 'g' in tr_i_name and 'g' in tr_j_name: if self.params['HODmod'] == 'zevol': if not hasattr(self, 'pk_ggf'): if not self.params['corr_halo_mod']: Pk = ccl.halos.halomod_Pk2D(self.cosmo, self.hmc, self.pg, prof2=self.pg, prof_2pt=self.HOD2pt, normprof1=True, normprof2=True, lk_arr=np.log( GSKYTheory.k_arr), a_arr=GSKYTheory.a_arr) else: Pk_arr = ccl.halos.halomod_power_spectrum( self.cosmo, self.hmc, GSKYTheory.k_arr, GSKYTheory.a_arr, self.pg, prof_2pt=self.HOD2pt, prof2=self.pg, normprof1=True, normprof2=True) Pk_arr *= self.rk_hm Pk = ccl.Pk2D(a_arr=GSKYTheory.a_arr, lk_arr=np.log(GSKYTheory.k_arr), pk_arr=Pk_arr, cosmo=self.cosmo, is_logp=False) self.pk_ggf = Pk else: Pk = self.pk_ggf else: if not self.params['corr_halo_mod']: Pk = ccl.halos.halomod_Pk2D( self.cosmo, self.hmc, self.ccl_tracers[tr_i_name]['prof'], prof2=self.ccl_tracers[tr_j_name]['prof'], prof_2pt=self.HOD2pt, normprof1=True, normprof2=True, lk_arr=np.log(GSKYTheory.k_arr), a_arr=GSKYTheory.a_arr) else: Pk_arr = ccl.halos.halomod_power_spectrum( self.cosmo, self.hmc, GSKYTheory.k_arr, GSKYTheory.a_arr, self.ccl_tracers[tr_i_name]['prof'], prof_2pt=self.HOD2pt, prof2=self.ccl_tracers[tr_j_name]['prof'], normprof1=True, normprof2=True) Pk_arr *= self.rk_hm Pk = ccl.Pk2D(a_arr=GSKYTheory.a_arr, lk_arr=np.log(GSKYTheory.k_arr), pk_arr=Pk_arr, cosmo=self.cosmo, is_logp=False) else: ## eg yy logger.warning( 'Tracer combination {}, {} not implemented. Returning zero.'. format(tr_i_name, tr_j_name)) return np.zeros_like(l_arr) cls = ccl.angular_cl(self.cosmo, self.ccl_tracers[tr_i_name]['ccl_tracer'], self.ccl_tracers[tr_j_name]['ccl_tracer'], l_arr, p_of_k_a=Pk) if 'wl' in tr_i_name and 'm' in self.ccl_tracers[tr_i_name].keys(): cls *= (1. + self.ccl_tracers[tr_i_name]['m']) if 'wl' in tr_j_name and 'm' in self.ccl_tracers[tr_j_name].keys(): cls *= (1. + self.ccl_tracers[tr_j_name]['m']) return cls
COSMO = ccl.Cosmology( Omega_c=0.27, Omega_b=0.045, h=0.67, sigma8=0.8, n_s=0.96, transfer_function='bbks', matter_power_spectrum='linear') M200 = ccl.halos.MassDef200m() HMF = ccl.halos.MassFuncTinker10(COSMO, mass_def=M200) HBF = ccl.halos.HaloBiasTinker10(COSMO, mass_def=M200) P1 = ccl.halos.HaloProfileNFW(ccl.halos.ConcentrationDuffy08(M200), fourier_analytic=True) P2 = P1 PKC = ccl.halos.Profile2pt() KK = np.geomspace(1E-3, 10, 32) MM = np.geomspace(1E11, 1E15, 16) AA = 1.0 PK2D = ccl.Pk2D(cosmo=COSMO, pkfunc=lambda k, a: a / k) def test_prof2pt_smoke(): uk_NFW = P1.fourier(COSMO, KK, MM, AA, mass_def=M200) uk_EIN = P2.fourier(COSMO, KK, MM, AA, mass_def=M200) # Variance cv_NN = PKC.fourier_2pt(P1, COSMO, KK, MM, AA, mass_def=M200) assert np.all(np.fabs((cv_NN - uk_NFW**2)) < 1E-10) # 2-point cv_NE = PKC.fourier_2pt(P1, COSMO, KK, MM, AA, prof2=P2, mass_def=M200)
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), pk_arr=pk_a, is_logp=False) ells = np.geomspace(2, 1000, 20) z_arr = np.linspace(0, 4, 100)[::-1] nz_arr = np.exp(-((z_arr - 0.5) / 0.05)**2 / 2) bz_arr = np.ones(len(z_arr)) * 1.41 g_tracer = ccl.NumberCountsTracer(cosmo_ccl, has_rsd=False, dndz=(z_arr[::-1], nz_arr[::-1]), bias=(z_arr[::-1], bz_arr[::-1])) g_1_tracer = ccl.NumberCountsTracer(cosmo_ccl, has_rsd=False, dndz=(z_arr[::-1], nz_arr[::-1]), bias=(z_arr[::-1], np.ones(len(z_arr)))) wl_tracer = ccl.WeakLensingTracer(cosmo_ccl, dndz=(z_arr[::-1], nz_arr[::-1])) cl_gg = ccl.angular_cl(cosmo_ccl, g_tracer, wl_tracer, ells)
def compute_Cls(par,hod_par=hod_params,z_cent=z_s_cents,N_gal_sample=N_gal_bin,k_arr=k_ar,z_arr=z_ar,a_arr=a_ar,ell=ells, compute_cov=False, compute_inv_cov=False,plot_for_sanity=False,powerspec='halofit',simple_bias=True): if powerspec == 'halofit': # Compute matter pk using halofit pk_mm_arr = np.array([ccl.nonlin_matter_power(cosmo_fid, k_arr, a) for a in a_arr]) elif powerspec == 'halomodel': # Alternatively use halo model pk_mm_arr = np.array([ccl.halomodel.halomodel_matter_power(cosmo_fid, k_arr, a) for a in a_arr]) if simple_bias == True: pk_gg_arr = pk_mm_arr.copy() # because we later include bias pk_gm_arr = pk_mm_arr.copy() # because we later include bias else: # Compute HOD hodpars = hod_funcs_evol_fit.HODParams(hod_par, islogm0=True, islogm1=True) hodprof = hod.HODProfile(cosmo_fid, hodpars.lmminf, hodpars.sigmf,\ hodpars.fcf, hodpars.m0f, hodpars.m1f, hodpars.alphaf) # Compute galaxy pk using halofit pk_gg_arr = np.array([hodprof.pk(k_arr, a_arr[i]) for i in range(a_arr.shape[0])]) # Compute galaxy-matter pk using halofit pk_gm_arr = np.array([hodprof.pk_gm(k_arr, a_arr[i]) for i in range(a_arr.shape[0])]) # Create pk2D objects for interpolation pk_mm = ccl.Pk2D(a_arr=a_arr, lk_arr=np.log(k_arr), pk_arr=np.log(pk_mm_arr), is_logp=True) pk_gg = ccl.Pk2D(a_arr=a_arr, lk_arr=np.log(k_arr), pk_arr=np.log(pk_gg_arr), is_logp=True) pk_gm = ccl.Pk2D(a_arr=a_arr, lk_arr=np.log(k_arr), pk_arr=np.log(pk_gm_arr), is_logp=True) # load the bias parameters # k # indicates which of N_tomo sampling bins b_z = np.array([par['b_%02d'%k]['val'] for k in range(N_zsamples)]) # load the dndz parameters dndz_z = np.zeros((N_tomo,N_zsamples)) for i_z in range(N_tomo): dndz_z[i_z,:] = np.array([par['dndz_%02d_%02d'%(i_z,k)]['val'] for k in range(N_zsamples)]) # per type gg gs ss tot_corr = N_ell*(N_tomo*(2*N_tomo+1)) # make Cl_all of size N_ell*N_tomo*(2N_tomo+1) CL_ALL = np.zeros(tot_corr) temp = np.arange(2*N_tomo) temp = np.vstack((temp,temp)).T combs = np.array(list(combinations(range(2*N_tomo),2))) all_combos = np.vstack((temp,combs)) for c, comb in enumerate(all_combos): i = comb[0]%N_tomo # first redshift bin j = comb[1]%N_tomo # second redshift bin t_i = comb[0]//N_tomo # tracer type 0 means g and 1 means s t_j = comb[1]//N_tomo # tracer type 0 means g and 1 means s # NOISE if (i == j): # number density of galaxies N_gal = N_gal_sample[i] n_gal = N_gal/area_COSMOS # in rad^-2 # Adding noise noise_gal = 1./n_gal noise_shape = sigma_e2[i]/n_gal else: noise_gal = 0. noise_shape = 0. # Now create corresponding Cls with pk2D objects matched to pk if t_i*2+t_j == 0: # this is gg tracer_z1 = ccl.NumberCountsTracer(cosmo_fid, bias=(z_cent, b_z), \ dndz=(z_cent, dndz_z[i,:]),mag_bias=None, \ has_rsd=False) tracer_z2 = ccl.NumberCountsTracer(cosmo_fid, bias=(z_cent, b_z), \ dndz=(z_cent, dndz_z[j,:]),mag_bias=None, \ has_rsd=False) cl_gg = ccl.angular_cl(cosmo_fid, tracer_z1, tracer_z2, ell, p_of_k_a=pk_gg) cl_gg_no = cl_gg + noise_gal CL_ALL[(N_ell*c):(N_ell*c)+N_ell] = cl_gg_no elif t_i*2+t_j == 1: # this is gs tracer_z1 = ccl.NumberCountsTracer(cosmo_fid, bias=(z_cent, b_z), \ dndz=(z_cent, dndz_z[i,:]),mag_bias=None, \ has_rsd=False) tracer_z2 = ccl.WeakLensingTracer(cosmo_fid, dndz=(z_cent, dndz_z[j,:])) cl_gs = ccl.angular_cl(cosmo_fid, tracer_z1, tracer_z2, ell, p_of_k_a=pk_gm) cl_gs_no = cl_gs CL_ALL[(N_ell*c):(N_ell*c)+N_ell] = cl_gs_no elif t_i*2+t_j == 3: # this is ss tracer_z1 = ccl.WeakLensingTracer(cosmo_fid, dndz=(z_cent, dndz_z[i,:])) tracer_z2 = ccl.WeakLensingTracer(cosmo_fid, dndz=(z_cent, dndz_z[j,:])) cl_ss = ccl.angular_cl(cosmo_fid, tracer_z1, tracer_z2, ell, p_of_k_a=pk_mm) cl_ss_no = cl_ss + noise_shape CL_ALL[(N_ell*c):(N_ell*c)+N_ell] = cl_ss_no if plot_for_sanity == True: if c == 0: # Plot for sanity plt.loglog(ells, cl_gg, label=r'$\mathrm{gg}$') plt.loglog(ells, cl_gg_no, label=r'$\mathrm{gg}+{\rm noise}$') plt.loglog(ells, cl_ss, label=r'$\mathrm{ss}$') plt.loglog(ells, cl_gs, label=r'$\mathrm{gs}$') plt.xlabel(r'$\ell$') plt.ylabel(r'$C_{\ell}$') plt.legend() plt.savefig('Cls.png') plt.close() if compute_inv_cov == False and compute_cov == False: print(len(CL_ALL)) return CL_ALL print(len(CL_ALL)) print(np.sum(CL_ALL>0)) COV_ALL = np.zeros((len(CL_ALL),len(CL_ALL))) # COMPUTE COVARIANCE MATRIX for c_A, comb_A in enumerate(all_combos): for c_B, comb_B in enumerate(all_combos): i = comb_A[0]%N_tomo # first redshift bin j = comb_A[1]%N_tomo # second redshift bin m = comb_B[0]%N_tomo # first redshift bin n = comb_B[1]%N_tomo # second redshift bin c_im = np.argmax(np.product(np.sort(np.array([comb_A[0],comb_B[0]]))==all_combos,axis=1)) c_jn = np.argmax(np.product(np.sort(np.array([comb_A[1],comb_B[1]]))==all_combos,axis=1)) c_in = np.argmax(np.product(np.sort(np.array([comb_A[0],comb_B[1]]))==all_combos,axis=1)) c_jm = np.argmax(np.product(np.sort(np.array([comb_A[1],comb_B[0]]))==all_combos,axis=1)) # PAIRS A,B ARE (ti,tj),(tm,tn) at same ell #cov(ij,mn) = im,jn + in,jm C_im = CL_ALL[(c_im*N_ell):(c_im*N_ell)+N_ell] C_jn = CL_ALL[(c_jn*N_ell):(c_jn*N_ell)+N_ell] C_in = CL_ALL[(c_in*N_ell):(c_in*N_ell)+N_ell] C_jm = CL_ALL[(c_jm*N_ell):(c_jm*N_ell)+N_ell] # Knox formula Cov_ijmn = (C_im*C_jn+C_in*C_jm)/((2*ell+1.)*delta_ell*f_sky) if plot_for_sanity == True: if (c_A == c_B): print(i,j,'=',m,n) print(c_A) Cl_err = np.sqrt(Cov_ijmn) t_i = comb_A[0]//N_tomo t_j = comb_A[1]//N_tomo print(N_tomo*i+j+1) plt.subplot(N_tomo, N_tomo, N_tomo*i+j+1) plt.title("z=%f x z=%f"%(z_bin_cents[i],z_bin_cents[j])) c_ij = np.argmax(np.product(np.sort(np.array([comb_A[0],comb_A[1]]))==all_combos,axis=1)) C_ij = CL_ALL[(c_ij*N_ell):(c_ij*N_ell)+N_ell] # maybe add legend (_,caps,eb)=plt.errorbar(ell,C_ij,yerr=Cl_err,lw=2.,ls='-',capsize=5,label=str(t_i*2+t_j)) plt.legend() plt.xscale('log') plt.yscale('log') COV_ALL[(N_ell*c_A):(N_ell*c_A)+\ N_ell,(N_ell*c_B):(N_ell*c_B)+N_ell] = np.diag(Cov_ijmn) COV_ALL[(N_ell*c_B):(N_ell*c_B)+\ N_ell,(N_ell*c_A):(N_ell*c_A)+N_ell] = np.diag(Cov_ijmn) if compute_cov: return COV_ALL evals,evecs = la.eig(COV_ALL) if (is_pos_def(COV_ALL) != True): print("Covariance is not positive definite!"); exit(0) ICOV_ALL = la.inv(COV_ALL) return ICOV_ALL