def compute_power_spectra(self, z): try: from classy import Class except ImportError: print("Cannot precompute power spectra because CLASS "+\ "is not installed.") return cos = self.args['cosmology'] h = cos['h'] params = { 'output': 'mPk', "h": h, "sigma8": cos['sigma8'], "n_s": cos['ns'], "Omega_b": cos['Omega_b'], "Omega_cdm": cos['Omega_m'] - cos['Omega_b'], 'P_k_max_1/Mpc': 1000., 'z_max_pk': 1.0, 'non linear': 'halofit' } class_cosmo = Class() class_cosmo.set(params) class_cosmo.compute() k = np.logspace(-5, 3, num=4000) #1/Mpc comoving kh = k / h #h/Mpc comoving #P(k) are in Mpc^3/h^3 comoving Pnl = np.array([class_cosmo.pk(ki, z) for ki in k]) * h**3 Plin = np.array([class_cosmo.pk_lin(ki, z) for ki in k]) * h**3 self.args['k'] = kh self.args['Plin'] = Plin self.args['Pnl'] = Pnl return
def calc_power_spec(cosmos, zs, lin=True): Nc = len(cosmos) Nz = len(zs) ps = np.zeros((Nc, Nz, len(k))) for i in range(Nc): obh2, och2, w, ns, ln10As, H0, Neff, s8 = cosmos[i] h = H0 / 100. Omega_b = obh2 / h**2 Omega_c = och2 / h**2 Omega_m = Omega_b + Omega_c params = { 'output': 'mPk', 'h': h, 'ln10^{10}A_s': ln10As, 'n_s': ns, 'w0_fld': w, 'wa_fld': 0.0, 'Omega_b': Omega_b, 'Omega_cdm': Omega_c, 'Omega_Lambda': 1. - Omega_m, 'N_eff': Neff, 'P_k_max_1/Mpc': 10., 'z_max_pk': 5. } if not lin: params['non linear'] = 'halofit' cosmo = Class() cosmo.set(params) cosmo.compute() for j in range(len(zs)): if lin: ps[i, j] = np.array([cosmo.pk_lin(ki, zs[j]) for ki in k]) else: ps[i, j] = np.array([cosmo.pk(ki, zs[j]) for ki in k]) continue print("Finished box%d" % i) return ps
def get_ps(**kwargs): Om = kwargs['omega_m_0'] Ob = kwargs['omega_b_0'] s8 = kwargs['sigma_8'] h0 = kwargs['hubble_0'] ns = kwargs['primordial_index'] Omega_ncdm = Om - Ob #m_ncdm = 77319.85488 mTH = kwargs['hmf_extra_par1'] #Bozek2015 msn = 3.9*(mTH)**1.294*(0.1198/0.1225)**(-0.33333)*1000 params = { 'h': h0, 'T_cmb': 2.726, 'Omega_b': Ob, 'Omega_cdm': 1e-10, 'Omega_ncdm': Omega_ncdm, 'N_eff': 3.04, 'N_ncdm': 1, 'm_ncdm': msn, #'m_ncdm_in_eV': msn * 1e3, 'T_ncdm': 0.715985, # ? 'n_s': ns, #'sigma8': s8, 'A_s': 2.02539e-09, 'P_k_max_h/Mpc': 500., # Shouldn't need to be more than ~500? 'k_per_decade_for_pk': 20, # Shouldn't need to be more than ~20? 'output': 'mPk', 'ncdm_fluid_approximation': 3, 'use_ncdm_psd_files': 0, # tolerances 'tol_ncdm_bg': 1e-3, #'tol_ncdm': 1e-3, 'tol_perturb_integration': 1e-6, 'perturb_sampling_stepsize': 0.01, 'format': 'camb', } # Revert to CDM if not np.isfinite(mTH): params['N_ncdm'] = 0 params['Omega_ncdm'] = 0 params['Omega_cdm'] = Om - Ob ncdm_pars = ['tol_ncdm_bg', 'Omega_ncdm', 'use_ncdm_psd_files', 'm_ncdm', 'T_ncdm'] for par in ncdm_pars: del params[par] classinst = Class() classinst.set(params) classinst.compute() k_bin = np.logspace(-5, 2.5, 200) pk_bin = np.array([classinst.pk_lin(k_bin[i],0) for i in range(len(k_bin))]) return k_bin / h0, pk_bin * h0**3
delta_b_ary = one_time['d_b'] delta_chi_ary = one_time['d_chi'] n_s = M.n_s() # Primordial PS k_pivot = 0.05 P_s = 2.105e-9 * (k_ary / k_pivot) ** (n_s - 1) # Power spectra from transfer function # In units of Mpc^3 / h^3 Pk_b_ary = P_s * (delta_b_ary) ** 2 / (k_ary ** 3 / (2 * np.pi ** 2)) * h ** 3 Pk_chi_ary = P_s * (delta_chi_ary) ** 2 / \ (k_ary ** 3 / (2 * np.pi ** 2)) * h ** 3 Pk_chi_b_ary = P_s * (delta_chi_ary * delta_b_ary) / \ (k_ary ** 3 / (2 * np.pi ** 2)) * h ** 3 Pk_tot_lin_ary = np.array([M.pk_lin(k, z_compute) * h ** 3 for k in k_ary]) Pk_tot_nonlin_ary = np.array([M.pk(k, z_compute) * h ** 3 for k in k_ary]) np.savez(output_dir + "p_k_chi_k_max_500_z_" + str(iz_compute), k_ary=k_ary / h, # Convert back to h / Mpc Pk_b_ary=Pk_b_ary, Pk_chi_ary=Pk_chi_ary, Pk_chi_b_ary=Pk_chi_b_ary, Pk_e_ary=Pk_b_ary + Pk_chi_ary + 2 * Pk_chi_b_ary, Pk_e_b_ary=Pk_chi_b_ary + Pk_b_ary, Pk_tot_lin_ary=Pk_tot_lin_ary, Pk_tot_nonlin_ary=Pk_tot_nonlin_ary )
Om = 0.31834 Ocdm = Om - Ob h = 0.670435 params = { 'output': 'mPk', "h":h, "A_s":2.1e-9, "n_s":0.96191, "Omega_b":Ob, "Omega_cdm":Ocdm, 'YHe':0.24755048455476272,#By hand, default value 'P_k_max_h/Mpc':3000., 'z_max_pk':1.0, 'non linear':'halofit'} cosmo = Class() cosmo.set(params) cosmo.compute() k = np.logspace(-5, 3, base=10, num=4000) #1/Mpc, apparently np.savetxt("txt_files/P_files/k.txt", k/h) #h/Mpc now for i in range(len(zs)): z = zs[i] Pmm = np.array([cosmo.pk(ki, z) for ki in k]) Plin = np.array([cosmo.pk_lin(ki, z) for ki in k]) np.savetxt("txt_files/P_files/Pnl_z%.2f.txt"%(z), Pmm*h**3) #Mpc^3/h^3 np.savetxt("txt_files/P_files/Plin_z%.2f.txt"%(z), Plin*h**3) #Mpc^3/h^3 print "Done with z%.2f"%z
} # Create an instance of the CLASS wrapper cosmo = Class() # Set the parameters to the cosmological code cosmo.set(params_def) cosmo.compute() #### Define the linear growth factor and growth rate (growth factor f in class) h = cosmo.h() # ~mcu = cosmo.N_ur() # ~print(mcu) Plin = np.zeros(len(karray)) Pnonlin = np.zeros(len(karray)) for i, k in enumerate(karray): Plin[i] = (cosmo.pk_lin(k, z)) # function .pk(k,z) Pnonlin[i] = (cosmo.pk(k, z)) # function .pk(k,z) Plin *= h**3 Pnonlin *= h**3 #------------------------------------------------------------------------- #------------------------------------------------------------------------- m_1 = 0.02 ocdm_1 = 0.261205 - m_1 * 3 / (93.14 * h**2) params_1 = { 'output': 'mPk', 'non linear': 'halofit', 'Omega_cdm': ocdm_1, 'N_ncdm': 3, 'N_ur': 0.00441,
# omcdm = cosmo.omegach2() # print("omega_cdm =",omcdm) #k1 = 0.7*1.028185622909e-5 #k1 = 1.e-6 #z = 0.0 #k1 = 0.1 #print(cosmo.pk(k1,z)) #print(cosmo.pk_lin(k1,z)) k = np.linspace(log(0.0001), log(50), 200) k = np.exp(k) testout = [[0 for x in range(42)] for y in range(len(k))] for i in range(len(k)): testout[i][0] = k[i] testout[i][41] = cosmo.pk_lin(k[i] * h, z) * h**3 for j in range(40): # print("j=",j) testout[i][j + 1] = cosmo.pk(k[i] * h, z)[j] * h**3 # testout[i][0] = k[i] # testout[i][1] = cosmo.pk(k[i],z)[0] # testout[i][2] = cosmo.pk(k[i],z)[1] # testout[i][3] = cosmo.pk(k[i],z)[2] # testout[i][4] = cosmo.pk(k[i],z)[3] # testout[i][5] = cosmo.pk(k[i],z)[4] # testout[i][6] = cosmo.pk(k[i],z)[5] # testout[i][7] = cosmo.pk(k[i],z)[6] # testout[i][8] = cosmo.pk(k[i],z)[7] # testout[i][9] = cosmo.pk(k[i],z)[8] # testout[i][10] = cosmo.pk_lin(k[i],0) # np.savetxt('ede_pk_nl_bestfit_z038.dat', testout)
cosmo = Class() cosmo.set(params) cosmo.compute() #Derive value of Omega_m density Omega_m = cosmo.Om_m(0) #redshift zero #Prepare logarithmically spaced array of wavenumbers kvec = np.exp(np.log(10) * np.arange(-5, 1, 0.1)) nk = len(kvec) #Interpolate the linear theory power spectrum Pvec = np.zeros(nk) for i in range(nk): Pvec[i] = cosmo.pk_lin(kvec[i], z_lin) #Store the linear power spectrum data as text file (before rescaling!) PowData = np.array([kvec, Pvec]) np.savetxt("PowData.txt", PowData.T, header="k [1/Mpc] Pk [Mpc^3]") #Perform rescaling if necessary D_0 = cosmo.scale_independent_growth_factor(0) D_f = cosmo.scale_independent_growth_factor(z_f) D_lin = cosmo.scale_independent_growth_factor(z_lin) print("D_0: ", D_0) print("D_f: ", D_f) print("D_lin: ", D_lin) #MeshPT needs a z=0 power spectrum, so one can rescale a power spectrum to z=0 #if a different input redshift is desired
plt.plot((ttCLASS[:ell_max + 1] - ttCAMB[:ell_max + 1]) / ttCAMB[:ell_max + 1], '-') plt.xlabel(r'$\ell$') plt.ylabel(r'$\Delta C_{\ell}^{TT} / C_{\ell}^{TT}$') plt.title('TT Comparison of CAMB and CLASS') ########## P(k) ######################### pars.set_matter_power(redshifts=[0.], kmax=2.0) pars.NonLinear = model.NonLinear_none results = camb.get_results(pars) kh, z, pk = results.get_matter_power_spectrum(minkh=1e-4, maxkh=1, npoints=200) s8 = np.array(results.get_sigma8()) PCLASS = np.array([cosmo.pk_lin(ki * cosmo.h(), 0) for ki in kh]) # plt.loglog(kh, Pmm, '-') plt.loglog(kh, PCLASS / (cosmo.h())**(-3), '-') plt.loglog(kh, pk[0, :], '-') plt.title('LINEAR') # P(k) Comparison plt.loglog(kh, np.abs((PCLASS / (cosmo.h())**(-3) - pk[0, :]) / pk[0, :])) plt.xlabel(r'$k/h$') plt.ylabel(r'$|\Delta P(k)| / P(k)$') # Nonlinear P(k) Difference pars.NonLinear = model.NonLinear_both
print(omb) #k1 = 0.7*1.028185622909e-5 #k1 = 1.e-6 #z = 0.0 #k1 = 0.1 #print(cosmo.pk(k1,z)) #print(cosmo.pk_lin(k1,z)) k = np.linspace(log(0.0001), log(50), 400) k = np.exp(k) testout = [[0 for x in range(42)] for y in range(len(k))] for i in range(len(k)): testout[i][0] = k[i] testout[i][41] = cosmo.pk_lin(k[i], z) for j in range(40): # print("j=",j) testout[i][j + 1] = cosmo.pk(k[i], z)[j] # testout[i][0] = k[i] # testout[i][1] = cosmo.pk(k[i],z)[0] # testout[i][2] = cosmo.pk(k[i],z)[1] # testout[i][3] = cosmo.pk(k[i],z)[2] # testout[i][4] = cosmo.pk(k[i],z)[3] # testout[i][5] = cosmo.pk(k[i],z)[4] # testout[i][6] = cosmo.pk(k[i],z)[5] # testout[i][7] = cosmo.pk(k[i],z)[6] # testout[i][8] = cosmo.pk(k[i],z)[7] # testout[i][9] = cosmo.pk(k[i],z)[8] # testout[i][10] = cosmo.pk_lin(k[i],0) np.savetxt('las_damas_pk_nl.dat', testout)
def get_Buzzard_args(z_index, lambda_index, RM): assert z_index in [0, 1, 2] assert lambda_index in [0, 1, 2, 3] zstr = ["0.2_0.35", "0.35_0.5", "0.5_0.65"][z_index] lstr = ["20_30", "30_45", "45_60", "60_10000"][lambda_index] z_title = ["0.2,0.35", "0.35,0.5", "0.5, 0.65"][z_index] lam_title = ["20,30", "30,45", "45,60", "60,\infty"][lambda_index] base = "../data/DeltaSigma_from_Buzzard/" if RM: inpath = base + "DeltaSigma_z_{0}_lam_{1}.dat".format(zstr, lstr) else: inpath = base + "DeltaSigma_same_mass_redshift_distribution_z_{0}_lam_{1}.dat".format( zstr, lstr) columns = ["R", "DeltaSigma", "DeltaSigma_err"] dat = pd.read_csv(inpath, sep=' ', skiprows=0, usecols=[0, 1, 2]) dat.columns = columns DS_data = dat.DeltaSigma Cov = np.diag(dat["DeltaSigma_err"]**2) DS_unc = dat["DeltaSigma_err"] index = 4 * z_index + lambda_index z = np.loadtxt( "../data/DeltaSigma_from_Buzzard/Buzzard_redMaPPer_redshift_information.dat" )[index, 4] richness = np.array([25, 37.5, 52.5, 70])[lambda_index] R_lambda = (richness / 100.)**0.2 #Mpc/h comoving #Define the cosmology h = 0.7 #Hubble constant Omega_m = 0.286 #check this Sigma_crit_inverse = 1. #For now #Radial bin edges in Mpc physical #Radial arrays r = np.logspace(-2, 3, num=1000) #Mpc/h comoving; 3d radii R = np.logspace(-2, 2.4, 1000, base=10) #Mpc/h comoving; 2d projected radii #k = np.logspace(-5, 3, num=4000) #1/Mpc comoving; wavenumbers k = np.logspace(-3, 2, num=1000) #1/Mpc comoving; wavenumbers M = np.logspace(12, 17, 500) #Msun/h; halo masses R_edges = np.logspace(np.log10(0.0323), np.log10(30.), num=15 + 1) #PERFORM SCALE CUTS HERE R_mid = (R_edges[:-1] + R_edges[1:]) / 2. cut = R_mid > 0.2 #cut at 200 kpc phys. DeltaSigma_data = DS_data[cut] DeltaSigma_unc = DS_unc[cut] Cov = Cov[cut] Cov = Cov[:, cut] Re_inds = [] for i in range(len(R_edges) - 1): if R_edges[i] > 0.4 - R_edges[i + 1]: #cut criteria Re_inds.append(i - 1) Re_inds.append(len(R_edges) - 1) R_edges = R_edges[Re_inds] R_mid = (R_edges[:-1] + R_edges[1:]) / 2. #Convert units to Mpc/h comoving R_edges *= h * (1 + z) R_mid *= h * (1 + z) DeltaSigma_data /= h * (1 + z)**2 DeltaSigma_unc /= h * (1 + z)**2 Cov /= (h * (1 + z)**2) #Precompute theory quantities class_params = { # 'N_eff': 3.04 'output': 'mPk', "h": h, "sigma8": 0.82, "n_s": 0.96, "Omega_b": 0.047, "Omega_cdm": Omega_m - 0.047, "N_eff": 3.04, 'YHe': 0.24755048455476272, #By hand, default value 'P_k_max_1/Mpc': 100., 'z_max_pk': 0.5, 'non linear': 'halofit' } class_cosmo = Class() class_cosmo.set(class_params) print("Running CLASS for P(k)") class_cosmo.compute() P_nl = np.array([class_cosmo.pk(ki, z) for ki in k]) * h**3 P_lin = np.array([class_cosmo.pk_lin(ki, z) for ki in k]) * h**3 print("CLASS computation complete") xi_lin = ct.xi.xi_mm_at_r(r, k / h, P_lin) xi_nl = ct.xi.xi_mm_at_r(r, k / h, P_nl) biases = ct.bias.bias_at_M(M, k, P_lin, Omega_m) bias_spline = IUS(np.log(M), biases) #Assemble the args dict args = { "z": z, "richness": richness, "R_lambda": R_lambda, "h": h, "Omega_m": Omega_m, "Sigma_crit_inverse": Sigma_crit_inverse, "DeltaSigma_data": DeltaSigma_data, "DeltaSigma_cov": Cov, "DeltaSigma_unc": DeltaSigma_unc, "R_mid": R_mid, "r": r, "R": R, "k": k / h, "P_lin": P_lin, "P_nl": P_nl, "xi_lin": xi_lin, "xi_nl": xi_nl, "bias_spline": bias_spline, "R_edges": R_edges, "z_title": z_title, "lambda_title": z_title } return args
def make_LSS_data(z, cosmo_dict, outfile=None): """ Args: z (float): redshift cosmo_dict (dictionary): the CLASS cosmology outfile (string): file to save to """ if outfile is None: outfile = "LSS_dict" LSS_dict = {} h = cosmo_dict["h"] Omega_b = cosmo_dict["Omega_b"] Omega_m = cosmo_dict["Omega_cdm"] + cosmo_dict["Omega_b"] n_s = cosmo_dict["n_s"] cosmo = Class() cosmo.set(cosmo_dict) cosmo.compute() sigma8 = cosmo.sigma8() print("sigma8 is:", sigma8) k = np.logspace(-5, 3, base=10, num=4000) #1/Mpc; comoving kh = k / h #h/Mpc; comoving r = np.logspace(-2, 3, num=1000) #Mpc/h comoving M = np.logspace(12, 16.3, 1000) #Msun/h z = np.asarray(z) for zi in z: P_nl = np.array([cosmo.pk(ki, zi) for ki in k]) * h**3 P_lin = np.array([cosmo.pk_lin(ki, zi) for ki in k]) * h**3 xi_nl = ct.xi.xi_mm_at_r(r, kh, P_nl) xi_lin = ct.xi.xi_mm_at_r(r, kh, P_lin) c = np.array([ conc.concentration_at_M(Mi, kh, P_lin, n_s, Omega_b, Omega_m, h, Mass_type="mean") for Mi in M ]) bias = ct.bias.bias_at_M(M, kh, P_lin, Omega_m) args_at_z = { "k": kh, "P_lin": P_lin, "P_nl": P_nl, "r": r, "xi_lin": xi_lin, "xi_nl": xi_nl, "M": M, "concentration": c, "bias": bias, "h": h, "Omega_m": Omega_m, "n_s": n_s, "sigma8": sigma8, "Omega_b": Omega_b } LSS_dict["args_at_{z:.3f}".format(z=zi)] = args_at_z #np.save(outfile, LSS_dict) pickle.dump(LSS_dict, open(outfile + ".p", "wb")) print("Saved {0}".format(outfile)) return
def get_arguments(perc_index, fox_z_index, fox_lambda_index, zi, lj): """Creates the arguments dictionary that is passed around the various functions. Args: perc_index (int): index of the percolation model (0-3) fox_z_index (int): z-index for the fox snapshots (0-3) fox_lambda_index (int): lambda-index for the fox richness bins (0-6) zi (int): z-index of the DES Y1 data set (0-1), zi=2 should NOT be used in fox lj (int): lambda-index of the DES Y1 data set (3-6) """ if not (0 <= fox_z_index <= 3): raise Exception("Invalid fox_z_inded value.") if not (0 <= fox_lambda_index <= 6): raise Exception("Invalid fox_lambda_inded value.") if not (0 <= zi <= 1): raise Exception("Invalid zi value.") if not (3 <= lj <= 6): raise Exception("Invalid lj value.") #Create a dictionary to add things print "Creating arguments dictionary" args = {} #Add the redshift zs = [1.0, 0.5, 0.25, 0.0] z = zs[fox_z_index] args['z'] = z print "\tz = %.2f" % z #Add the richnesses and compure R_lambda (Rlam) in Mpc/h comoving lams = np.loadtxt("Percolation_data/lambdas") lam = lams[fox_lambda_index] Rlams = (lams / 100.)**0.2 #Mpc/h comoving Rlam = Rlams[lj] args['Rlam'] = Rlam print "\tlambda = %.1f" % lam #Add the cosmology h = cosmo['h'] #to be used in this script args['h'] = h args['Omega_m'] = cosmo['om'] print "\th = %.3f" % h print "\tOmega_m = %.3f" % args['Omega_m'] #Add the prior for the multiplicative bias deltap1 = np.loadtxt("photoz_calibration/Y1_deltap1.txt")[zi, lj] deltap1_var = np.loadtxt("photoz_calibration/Y1_deltap1_var.txt")[zi, lj] Am_prior = deltap1 + 0.012 #photo-z + shear Am_prior_var = deltap1_var + 0.013**2 #photo-z + shear variance args['Am_prior'] = Am_prior args['Am_prior_var'] = Am_prior_var print "\tAm = %.3f +- %.3f" % (args['Am_prior'], args['Am_prior_var']) #Add the Sigma_crit_inverse value, after converting to pc^2/hMsun comoving SCI = np.loadtxt("photoz_calibration/sigma_crit_inv.txt")[zi, lj] * h * ( 1 + z)**2 args['Sigma_crit_inv'] = SCI #Add on radial bins r = np.logspace(-2, 3, num=1000, base=10) #3d radii, Mpc/h comoving Rp = np.logspace(-2, 2.4, num=1000, base=10) #perpendicular radii, Mpc/h comoving args['r'] = r args['Rp'] = Rp #Compute the power spectrum and xi_mm #First, make a 'CLASS-formatted' cosmology dictionary from classy import Class params = { "output": "mPk", "h": h, "sigma8": 0.835, "n_s": cosmo["ns"], "Omega_b": cosmo["ob"], "Omega_cdm": cosmo["om"] - cosmo["ob"], "YHe": 0.24755048455476272, #By hand, default value "P_k_max_1/Mpc": 1000., #3000., "z_max_pk": 1.0, "non linear": "halofit" } class_cosmo = Class() class_cosmo.set(params) print "\tConfiguring CLASS cosmology" class_cosmo.compute() print "\tComputing P(k,z) using CLASS" k = np.logspace(-5, 3, base=10, num=4000) #1/Mpc, apparently kh = k / h #h/Mpc args['k'] = kh #Call class to compute P(k,z) Pnl = np.array([class_cosmo.pk(ki, z) for ki in k]) Plin = np.array([class_cosmo.pk_lin(ki, z) for ki in k]) Pnl *= h**3 #matter power spectrum, (Mpc/h)^3 Plin *= h**3 #linear matter power spectrum, (Mpc/h)^3 args['Pnl'] = Pnl args['Plin'] = Plin #Call the toolkit to compute xi(r,z) from P(k,z) print "\tcalling the toolkit to compute xi_mm" xi_nl = ct.xi.xi_mm_at_R(r, k, Pnl) xi_lin = ct.xi.xi_mm_at_R(r, k, Plin) args['xi_nl'] = xi_nl args['xi_lin'] = xi_lin #Add the edges of the radial bins (Y1 version), Mpc/h comoving #Note that the bin edges are defined in Mpc physical Nbins = 15 Redges = np.logspace(np.log10(0.0323), np.log10(30.), num=Nbins + 1) Rmid = (Redges[:-1] + Redges[1:]) / 2. print Rmid args['Redges'] = Redges * h * (1 + z) #converted to Mpc/h comoving #Add the indices used for scale cuts #Note: no upper limit scale cut inds = (Rmid > 0.2) * (Rmid < 9999) #0.2 Mpc physical scale cut args['inds'] = inds #Add the covariance matrix #fullbase = "/Users/tmcclintock/Data" #laptop #fullbase = "/calvin1/tmcclintock/DES_DATA_FILES" #calvin #y1base = fullbase+"/DATA_FILES/y1_data_files/FINAL_FILES/" covpath = "SACs/SAC_z%d_l%d.txt" % (zi, lj) #y1base+"SACs/SAC_z%d_l%d.txt"%(zi, lj) cov = np.genfromtxt(covpath) cov = cov[inds] cov = cov[:, inds] #Apply the hartlap correction Njk = 100. D = len(Rmid[inds]) cov *= (Njk - 1) / (Njk - D - 2) print "\tlen(DeltaSigma) = %d\n\tNjk = %d" % (D, Njk) icov = np.linalg.inv(cov) args['icov'] = icov #(pc^2/Msun physical)^2 #Add the boost factor data #boostpath = y1base+"/full-unblind-v2-mcal-zmix_y1clust_l%d_z%d_zpdf_boost.dat"%(lj, zi) #bcovpath = y1base+"/full-unblind-v2-mcal-zmix_y1clust_l%d_z%d_zpdf_boost_cov.dat"%(lj, zi) boostpath = "boostfactors/full-unblind-v2-mcal-zmix_y1clust_l%d_z%d_zpdf_boost.dat" % ( lj, zi) bcovpath = "boostfactors/full-unblind-v2-mcal-zmix_y1clust_l%d_z%d_zpdf_boost_cov.dat" % ( lj, zi) Bcov = np.loadtxt(bcovpath) Rb, Bp1, Be = np.genfromtxt(boostpath, unpack=True) #Rb is Mpc physical Becut = (Be > 1e-6) * (Rb > 0.2) #Some boost factors are 0. Exclude those Bp1 = Bp1[Becut] Rb = Rb[Becut] Be = Be[Becut] Bcov = Bcov[Becut] Bcov = Bcov[:, Becut] Njk = 100. D = len(Rb) Bcov *= (Njk - 1.) / (Njk - D - 2) #Apply the Hartlap correction icov_B = np.linalg.inv(Bcov) args['Rb'] = Rb args['iBcov'] = icov_B args['Bp1'] = Bp1 #Add the DeltaSigma data vector mass_lim_labels = [ "3e12_5e12", "5e12_9e12", "9e12_2e13", "2e13_6e13", "6e13_2e14", "2e14_5e14", "5e14_5e15" ] lab = mass_lim_labels[fox_lambda_index] DS = np.loadtxt("Percolation_data/fixedmeanDeltaSigma_i%d_%s_z%.1f" % (perc_index, lab, z)) #h Msun/pc^2 comoving DS *= h * (1 + z)**2 #Msun/pc^2 physical args['ds'] = DS[inds] #take only the useful indices return args
class Cosmology(object): """ Class to hold the basic cosmology and CLASS attributes. This can be initialized by a set of cosmological parameters or a pre-defined cosmology. Loaded cosmological models: - **Planck18**: Bestfit cosmology from Planck 2018, using the baseline TT,TE,EE+lowE+lensing likelihood. - **Quijote**: Fiducial cosmology from the Quijote simulations of Francisco Villaescusa-Navarro et al. - **Abacus**: Fiducial cosmology from the Abacus simulations of Lehman Garrison et al. Args: redshift (float): Desired redshift :math:`z` name (str): Load cosmology from a list of predetermined cosmologies (see above). params (kwargs): Any other CLASS parameters. (Note that sigma8 does not seem to be supported by CLASS in Python 3). Keyword Args: verb (bool): If true output useful messages througout run-time, default: False. npoints (int): Number of points to use in the interpolators for sigma^2, default: 100000 """ loaded_models = {'Quijote':{"h":0.6711,"omega_cdm":(0.3175 - 0.049)*0.6711**2, "Omega_b":0.049, "n_s":0.9624, "N_eff":3.046, "A_s":2.134724e-09}, #"sigma8":0.834, 'Abacus':{"h":0.6726,"omega_cdm":0.1199, "omega_b":0.02222,"n_s":0.9652,"A_s":2.135472e-09,#"sigma8":0.830, "N_eff":3.046}, 'Planck18':{"h":0.6732,"omega_cdm":0.12011,"omega_b":0.022383, "n_s":0.96605,"A_s":2.042644e-09}}#,"sigma8":0.8120}} def __init__(self,redshift,name="",verb=False,npoints=int(1e5),**params): """ Initialize the cosmology class with cosmological parameters or a defined model. """ ## Load parameters into a dictionary to pass to CLASS class_params = dict(**params) if len(name)>0: if len(params.items())>0: raise Exception('Must either choose a preset cosmology or specify parameters!') if name in self.loaded_models.keys(): if verb: print('Loading the %s cosmology at z = %.2f'%(name,redshift)) loaded_model = self.loaded_models[name] for key in loaded_model.keys(): class_params[key] = loaded_model[key] else: raise Exception("This cosmology isn't yet implemented") else: if len(params.items())==0: if verb: print('Using default CLASS cosmology') for name, param in params.items(): class_params[name] = param ## # Check we have the correct parameters if 'sigma8' in class_params.keys() and 'A_s' in class_params.keys(): raise NameError('Cannot specify both A_s and sigma8!') ## Define other parameters self.z = redshift self.a = 1./(1.+redshift) if 'output' not in class_params.keys(): class_params['output']='mPk' if 'P_k_max_h/Mpc' not in class_params.keys() and 'P_k_max_1/Mpc' not in class_params.keys(): class_params['P_k_max_h/Mpc']=300. if 'z_pk' in class_params.keys(): assert class_params['z_pk']==redshift, "Can't pass multiple redshifts!" else: class_params['z_pk']=redshift ## Load CLASS and set parameters if verb: print('Loading CLASS') self.cosmo = Class() self.cosmo.set(class_params) self.cosmo.compute() self.h = self.cosmo.h() self.name = name self.npoints = npoints self.verb = verb ## Check if we're using neutrinos here if self.cosmo.Omega_nu>0.: if self.verb: print("Using a neutrino fraction of Omega_nu = %.3e"%self.cosmo.Omega_nu) self.use_neutrinos = True # Define neutrino mass fraction self.f_nu = self.cosmo.Omega_nu/self.cosmo.Omega_m() if self.cosmo.Neff()>3.5: print("N_eff > 3.5, which seems large (standard value: 3.046). This may indicate that N_ur has not been set.") else: if self.verb: print("Assuming massless neturinos.") self.use_neutrinos = False ## Create a vectorized sigma(R) function from CLASS if self.use_neutrinos: self.vector_sigma_R = np.vectorize(lambda r: self.cosmo.sigma_cb(r/self.h,self.z)) else: self.vector_sigma_R = np.vectorize(lambda r: self.cosmo.sigma(r/self.h,self.z)) # get density in physical units at z = 0 # rho_critical is in Msun/h / (Mpc/h)^3 units # rhoM is in **physical** units of Msun/Mpc^3 self.rho_critical = ((3.*100.*100.)/(8.*np.pi*6.67408e-11)) * (1000.*1000.*3.085677581491367399198952281E+22/1.9884754153381438E+30) self.rhoM = self.rho_critical*self.cosmo.Omega0_m() def compute_linear_power(self,kh,kh_min=0.,with_neutrinos=False): """Compute the linear power spectrum from CLASS for a vector of input k. If set, we remove any modes below some minimum k. Args: kh (float, np.ndarray): Wavenumber or vector of wavenumbers (in h/Mpc units) to compute linear power with. Keyword Args: kh_min (float): Value of k (in h/Mpc units) below which to set :math:`P(k) = 0`, default: 0. with_neutrinos (bool): If True, return the full matter power spectrum, else return the CDM+baryon power spectrum (which is generally used in the halo model). Default: False. Returns: np.ndarray: Linear power spectrum in :math:`(h^{-1}\mathrm{Mpc})^3` units """ if type(kh)==np.ndarray: # Define output vector and filter modes with too-small k output = np.zeros_like(kh) filt = np.where(kh>kh_min) N_k = len(filt[0]) # Compute Pk using CLASS (vectorized) if not hasattr(self,'vector_linear_power'): ## NB: This works in physical 1/Mpc units so we convert here if self.use_neutrinos: # Here we need both the CDM+baryon (cb) power spectra and the full matter power spectra # The CDM+baryon spectrum is used for the halo model parts, and the residual (matter-cb) added at the end self.vector_linear_power = np.vectorize(lambda k: self.cosmo.pk_cb_lin(k*self.h,self.z)*self.h**3.) self.vector_linear_power_total = np.vectorize(lambda k: self.cosmo.pk_lin(k*self.h,self.z)*self.h**3.) else: self.vector_linear_power = np.vectorize(lambda k: self.cosmo.pk_lin(k*self.h,self.z)*self.h**3.) if self.use_neutrinos and with_neutrinos: output[filt] = self.vector_linear_power_total(kh[filt]) else: output[filt] = self.vector_linear_power(kh[filt]) return output else: if kh<kh_min: return 0. else: if self.use_neutrinos and with_neutrinos: return self.vector_linear_power_total(kh) else: return self.vector_linear_power(kh) def sigma_logM_int(self,logM_h): """Return the value of :math:`\sigma(M,z)` using the prebuilt interpolators, which are constructed if not present. Args: logM (np.ndarray): Input :math:`\log_{10}(M/h^{-1}M_\mathrm{sun})` Returns: np.ndarray: :math:`\sigma(M,z)` """ if not hasattr(self,'sigma_logM_int_func'): self._interpolate_sigma_and_deriv(npoints=self.npoints) return self._sigma_logM_int_func(logM_h) def dlns_dlogM_int(self,logM_h): """Return the value of :math:`d\ln\sigma/d\log M` using the prebuilt interpolators, which are constructed if not present. Args: logM (np.ndarray): Input :math:`\log_{10}(M/h^{-1}M_\mathrm{sun})` Returns: np.ndarray: :math:`d\ln\sigma/d\log M` """ if not hasattr(self,'dlns_dlogM_int_func'): self._interpolate_sigma_and_deriv(npoints=self.npoints) return self._dlns_dlogM_int_func(logM_h) def _sigmaM(self,M_h): """Compute :math:`\sigma(M,z)` from CLASS as a vector function. Args: M_h (np.ndarray): Mass in :math:`h^{-1}M_\mathrm{sun}` units. z (float): Redshift. Returns: np.ndarray: :math:`\sigma(M,z)` """ # convert to Lagrangian radius r_h = np.power((3.*M_h)/(4.*np.pi*self.rhoM),1./3.) sigma_func = self.vector_sigma_R(r_h) return sigma_func def _interpolate_sigma_and_deriv(self,logM_h_min=6,logM_h_max=17,npoints=int(1e5)): """Create an interpolator function for :math:`d\ln\sigma/d\log M` and :math:`sigma(M)`. NB: This has no effect if the interpolator has already been computed. Keyword Args: logM_min (float): Minimum mass in :math:`\log_{10}(M/h^{-1}M_\mathrm{sun})`, default: 6 logM_max (float): Maximum mass in :math:`\log_{10}(M/h^{-1}M_\mathrm{sun})`, default 17 npoints (int): Number of sampling points, default 100000 """ if not hasattr(self,'_sigma_logM_int_func'): if self.verb: print("Creating an interpolator for sigma(M) and its derivative.") ## Compute log derivative by interpolation and numerical differentiation # First compute the grid of M and sigma M_h_grid = np.logspace(logM_h_min,logM_h_max,10000) all_sigM = self._sigmaM(M_h_grid) logM_h_grid = np.log10(M_h_grid) # Define ln(sigma) and numerical derivatives all_lns = np.log(all_sigM) all_diff = -np.diff(all_lns)/np.diff(logM_h_grid) mid_logM_h = 0.5*(logM_h_grid[:-1]+logM_h_grid[1:]) self._sigma_logM_int_func = interp1d(logM_h_grid,all_sigM) self._dlns_dlogM_int_func = interp1d(mid_logM_h,all_diff) def _h_over_h0(self): """Return the value of :math:`H(z)/H(0)` at the class redshift Returns: float: :math:`H(z)/H(0)` """ Omega0_k = 1.-self.cosmo.Omega0_m()-self.cosmo.Omega_Lambda() Ea = np.sqrt((self.cosmo.Omega0_m()+self.cosmo.Omega_Lambda()*pow(self.a,-3)+Omega0_k*self.a)/pow(self.a,3)) return Ea def _Omega_m(self): """Return the value of :math:`\Omega_m(z)` at the class redshift