def zaemulate(disp, z_ic, z_late, cosmo): ''' Make a Zel'dovich-evolved catalog at late times. Input: -disp: displacement field computed from 'makemesh' -z_ic: initial redshift -z_late: final redshift -cosmo: pyCCL cosmology used to compute growth factors Output: -flatgrid: catalog of positions for files ''' #Get box size and particle number from the displacement Lbox = disp[0].BoxSize[0] nmesh = disp[0].Nmesh[0] #Coordinates to place down the IC particles coord = np.linspace(0, Lbox, nmesh + 1)[:-1] xx, yy, zz = np.meshgrid(coord, coord, coord, indexing='ij') flatgrid = np.stack([xx, yy, zz]) growthratio = pyccl.growth_factor(cosmo, 1. / (1 + z_late)) / pyccl.growth_factor( cosmo, 1. / (1 + z_ic)) #ZAemulate them to z_late for i in range(3): flatgrid[i] += disp[i] * growthratio flatgrid = flatgrid % Lbox #Reshape to catalog flatgrid = flatgrid.reshape(3, nmesh**3) return flatgrid
def test_power_sigma8norm_norms_consistent(tf): # make a cosmo with A_s cosmo = ccl.Cosmology(Omega_c=0.27, Omega_b=0.045, h=0.67, A_s=2e-9, n_s=0.96, transfer_function=tf) sigma8 = ccl.sigma8(cosmo) # remake same but now give sigma8 cosmo_s8 = ccl.Cosmology(Omega_c=0.27, Omega_b=0.045, h=0.67, sigma8=sigma8, n_s=0.96, transfer_function=tf) # make sure they come out the same-ish assert np.allclose(ccl.sigma8(cosmo), ccl.sigma8(cosmo_s8)) # and that the power spectra look right a = 0.8 gfac = (ccl.growth_factor(cosmo, a) / ccl.growth_factor(cosmo_s8, a))**2 pk_rat = (ccl.linear_matter_power(cosmo, 1e-4, a) / ccl.linear_matter_power(cosmo_s8, 1e-4, a)) assert np.allclose(pk_rat, gfac)
def test_power_mu_sigma_sigma8norm(tf): cosmo = ccl.Cosmology( Omega_c=0.27, Omega_b=0.045, h=0.67, sigma8=0.8, n_s=0.96, transfer_function=tf) cosmo_musig = ccl.Cosmology( Omega_c=0.27, Omega_b=0.045, h=0.67, sigma8=0.8, n_s=0.96, transfer_function=tf, mu_0=0.1, sigma_0=0.2) # make sure sigma8 is correct assert np.allclose(ccl.sigma8(cosmo_musig), 0.8) if tf != 'boltzmann_isitgr': # make sure P(k) ratio is right a = 0.8 gfac = ( ccl.growth_factor(cosmo, a) / ccl.growth_factor(cosmo_musig, a))**2 pk_rat = ( ccl.linear_matter_power(cosmo, 1e-4, a) / ccl.linear_matter_power(cosmo_musig, 1e-4, a)) assert np.allclose(pk_rat, gfac) with mock.patch.dict(sys.modules, {'isitgr': None}): with assert_raises(ImportError): get_isitgr_pk_lin(cosmo) # Importing ccl without isitgr is fine. No ImportError triggered. with mock.patch.dict(sys.modules, {'isitgr': None}): reload(ccl.boltzmann)
def test_mgrowth(): """ Compare the modified growth function computed by CCL against the exact result for a particular modification of the growth rate. """ # Define differential growth rate arrays nz_mg = 128 z_mg = np.zeros(nz_mg) df_mg = np.zeros(nz_mg) for i in range(0, nz_mg): z_mg[i] = 4. * (i + 0.0) / (nz_mg - 1.) df_mg[i] = 0.1 / (1. + z_mg[i]) # Define two test cosmologies, without and with modified growth respectively p1 = ccl.Parameters(Omega_c=0.25, Omega_b=0.05, Omega_k=0., N_nu_rel=0., N_nu_mass=0., m_nu=0., w0=-1., wa=0., h=0.7, A_s=2.1e-9, n_s=0.96) p2 = ccl.Parameters(Omega_c=0.25, Omega_b=0.05, Omega_k=0., N_nu_rel=0., N_nu_mass=0., m_nu=0., w0=-1., wa=0., h=0.7, A_s=2.1e-9, n_s=0.96, z_mg=z_mg, df_mg=df_mg) cosmo1 = ccl.Cosmology(p1) cosmo2 = ccl.Cosmology(p2) # We have included a growth modification \delta f = K*a, with K==0.1 # (arbitrarily). This case has an analytic solution, given by # D(a) = D_0(a)*exp(K*(a-1)). Here we compare the growth computed by CCL # with the analytic solution. a = 1. / (1. + z_mg) d1 = ccl.growth_factor(cosmo1, a) d2 = ccl.growth_factor(cosmo2, a) f1 = ccl.growth_rate(cosmo1, a) f2 = ccl.growth_rate(cosmo2, a) f2r = f1 + 0.1 * a d2r = d1 * np.exp(0.1 * (a - 1.)) # Check that ratio of calculated and analytic results is within tolerance assert_allclose(d2r / d2, np.ones(d2.size), rtol=GROWTH_TOLERANCE) assert_allclose(f2r / f2, np.ones(f2.size), rtol=GROWTH_TOLERANCE)
def plot_model(ax, CBase, C, fmt, name): zar = np.linspace(0, 2.5, 100) aar = 1 / (1 + zar) f = ccl.growth_rate(C, aar) s8 = ccl.sigma8(C) * ccl.growth_factor(C, aar) f0 = ccl.growth_rate(CBase, aar) s80 = ccl.sigma8(CBase) * ccl.growth_factor(CBase, aar) ax.plot(zar, (f * s8) / (f0 * s80), fmt, label=name) return interp1d(zar, (s80 * f0))
def check_background(cosmo): """ Check that background and growth functions can be run. """ # Types of scale factor input (scalar, list, array) a_scl = 0.5 a_lst = [0.2, 0.4, 0.6, 0.8, 1.] a_arr = np.linspace(0.2, 1., 5) # growth_factor assert_( all_finite(ccl.growth_factor(cosmo, a_scl)) ) assert_( all_finite(ccl.growth_factor(cosmo, a_lst)) ) assert_( all_finite(ccl.growth_factor(cosmo, a_arr)) ) # growth_factor_unnorm assert_( all_finite(ccl.growth_factor_unnorm(cosmo, a_scl)) ) assert_( all_finite(ccl.growth_factor_unnorm(cosmo, a_lst)) ) assert_( all_finite(ccl.growth_factor_unnorm(cosmo, a_arr)) ) # growth_rate assert_( all_finite(ccl.growth_rate(cosmo, a_scl)) ) assert_( all_finite(ccl.growth_rate(cosmo, a_lst)) ) assert_( all_finite(ccl.growth_rate(cosmo, a_arr)) ) # comoving_radial_distance assert_( all_finite(ccl.comoving_radial_distance(cosmo, a_scl)) ) assert_( all_finite(ccl.comoving_radial_distance(cosmo, a_lst)) ) assert_( all_finite(ccl.comoving_radial_distance(cosmo, a_arr)) ) # h_over_h0 assert_( all_finite(ccl.h_over_h0(cosmo, a_scl)) ) assert_( all_finite(ccl.h_over_h0(cosmo, a_lst)) ) assert_( all_finite(ccl.h_over_h0(cosmo, a_arr)) ) # luminosity_distance assert_( all_finite(ccl.luminosity_distance(cosmo, a_scl)) ) assert_( all_finite(ccl.luminosity_distance(cosmo, a_lst)) ) assert_( all_finite(ccl.luminosity_distance(cosmo, a_arr)) ) # scale_factor_of_chi assert_( all_finite(ccl.scale_factor_of_chi(cosmo, a_scl)) ) assert_( all_finite(ccl.scale_factor_of_chi(cosmo, a_lst)) ) assert_( all_finite(ccl.scale_factor_of_chi(cosmo, a_arr)) ) # omega_m_a assert_( all_finite(ccl.omega_x(cosmo, a_scl, 'matter')) ) assert_( all_finite(ccl.omega_x(cosmo, a_lst, 'matter')) ) assert_( all_finite(ccl.omega_x(cosmo, a_arr, 'matter')) )
def test_growth(): # 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="linear", ) 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 scale factors a = np.linspace(0.01, 1.0) gccl = ccl.growth_factor(cosmo_ccl, a) gjax = bkgrd.growth_factor(cosmo_jax, a) assert_allclose(gccl, gjax, rtol=1e-2)
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 get_log_prob(self, theta): # Check the priors log_prior = self.get_log_prior(theta) if not np.isfinite(log_prior): return -np.inf # Update default cosmological parameters with new sampled parameters params = self.cosmology_params.copy() for param_name in self.arg_names: if param_name in params: params[param_name] = theta[self.arg_names.index(param_name)] cosmo = ccl.Cosmology(**params) # Update data parameters z_tail = theta[self.arg_names.index( 'z_tail')] if 'z_tail' in self.arg_names else self.z_tail bias = theta[self.arg_names.index( 'bias')] if 'bias' in self.arg_names else self.bias # Get redshift distribution z_arr, n_arr = get_lotss_redshift_distribution(z_tail=z_tail) bias_arr = bias * np.ones(len(z_arr)) bias_arr = bias_arr / ccl.growth_factor(cosmo, 1. / (1 + z_arr)) # Get correlations number_counts_tracer = ccl.NumberCountsTracer(cosmo, has_rsd=False, dndz=(z_arr, n_arr), bias=(z_arr, bias_arr)) cmb_lensing_tracer = ccl.CMBLensingTracer(cosmo, 1091) correlations = {} if 'gg' in self.correlation_symbols: correlations['gg'] = ccl.angular_cl(cosmo, number_counts_tracer, number_counts_tracer, self.l_arr) if 'gk' in self.correlation_symbols: correlations['gk'] = ccl.angular_cl(cosmo, number_counts_tracer, cmb_lensing_tracer, self.l_arr) # Bin spectra using coupling matrices in workspaces for correlation_symbol in self.correlation_symbols: correlations[correlation_symbol] = decouple_correlation( self.workspaces[correlation_symbol], correlations[correlation_symbol]) # Calculate log prob model = np.concatenate([ correlations[correlation_symbol][:self.n_ells[correlation_symbol]] for correlation_symbol in self.correlation_symbols ]) diff = self.data_vector - model log_prob = log_prior - np.dot( diff, np.dot(self.inverted_covariance, diff)) / 2.0 return log_prob
def make_component_weights(icdeltalin, cosmo, z_ic, z_late): ''' Make the component fields so you get weights later on. Input: icdeltalin: **NOISELESS** linear fields of your simulation growthratio: ratio of growthfactors between z_late and z_ic Output: linfield: linear noiseless density delta2: squared density field s2: tidal field squared gradsqdelta: laplacian of the density Notes: gradsqdelta currently not implemented ''' Lbox = icdeltalin.BoxSize[0] nmesh = icdeltalin.Nmesh[0] growthratio = pyccl.growth_factor(cosmo, 1. / (1 + z_late)) / pyccl.growth_factor( cosmo, 1. / (1 + z_ic)) delta = growthratio * icdeltalin #Start with tidal field due to memory requirements linfield = fftw.byte_align(icdeltalin.value, dtype='float32') field_fft = fftw.interfaces.numpy_fft.rfftn(linfield, threads=-1) linfield = ArrayMesh(linfield, BoxSize=Lbox).to_real_field() tidesq = delta_to_tidesq(field_fft, nmesh=nmesh, lbox=Lbox) s2 = tidesq - tidesq.cmean() del field_fft gc.collect() #Make the squared density field sqfield = delta**2 delta2 = sqfield - sqfield.cmean() return linfield, delta2, s2
def test_power_mu_sigma_sigma8norm(tf): cosmo = ccl.Cosmology( Omega_c=0.27, Omega_b=0.045, h=0.67, sigma8=0.8, n_s=0.96, transfer_function=tf) cosmo_musig = ccl.Cosmology( Omega_c=0.27, Omega_b=0.045, h=0.67, sigma8=0.8, n_s=0.96, transfer_function=tf, mu_0=0.1, sigma_0=0.2) # make sure sigma8 is correct assert np.allclose(ccl.sigma8(cosmo_musig), 0.8) # make sure P(k) ratio is right a = 0.8 gfac = ( ccl.growth_factor(cosmo, a) / ccl.growth_factor(cosmo_musig, a))**2 pk_rat = ( ccl.linear_matter_power(cosmo, 1e-4, a) / ccl.linear_matter_power(cosmo_musig, 1e-4, a)) assert np.allclose(pk_rat, gfac)
def LSSTSpecParams(C): biasfunc = lambda z: 0.95 / ccl.growth_factor(C, 1 / (1 + z)) ndens = 49 ## per /arcmin^2, LSST SRD, page 47 dndz = lambda z: z**2 * np.exp(-(z / 0.28)**0.94) ## LSST SRD, page 47 arcminfsky = 1 / (4 * np.pi / (np.pi / (180 * 60))**2) ## volume between z=3 zmax = 3 V = 4 * np.pi**3 / 3 * ccl.comoving_radial_distance(C, 1 / (1 + zmax))**3 dVdz = lambda z: 3e3 / C['h'] * 1 / ccl.h_over_h0(C, 1 / ( 1 + z)) * 4 * np.pi * ccl.comoving_radial_distance(C, 1 / (1 + z))**2 norm = ndens / (quad(dndz, 0, zmax)[0] * arcminfsky) nbarofz = lambda z: norm * dndz(z) / dVdz(z) return biasfunc, nbarofz, 0, 3, None
def summon_bz(N_tomo, z_s_cents_theo, z_s_cents): # 6 standard cosmological parameters Omb = 0.0493 Omk = 0.0 s8 = 0.8111 h = 0.6736 n_s = 0.9649 Omc = 0.264 N_zsamples_theo = len(z_s_cents_theo) N_zsamples = len(z_s_cents) # Setting the cosmology FID_COSMO_PARAMS = { 'Omega_b': Omb, 'Omega_k': Omk, 'sigma8': s8, 'h': h, 'n_s': n_s, 'Omega_c': Omc, 'transfer_function': 'boltzmann_class', 'matter_power_spectrum': 'halofit', 'mass_function': 'tinker10' } cosmo_fid = ccl.Cosmology(**FID_COSMO_PARAMS) # load biases a_s_cents_theo = 1. / (1. + z_s_cents_theo) b_zsamples_theo = 0.95 / ccl.growth_factor(cosmo_fid, a_s_cents_theo) # create the matrix bz_data_theo = np.repeat(b_zsamples_theo.reshape(1, N_zsamples_theo), N_tomo, axis=0) bz_data = np.zeros((N_tomo, N_zsamples)) for i in range(N_tomo): bz_data_theo[ i, :] += 0 #.2*np.random.randn(N_zsamples_theo) # TESTING MAKES A HUGE DIFFERENCE IF VARYING DNDZ only # can go down to 0.01 for 7 7 dndz only no reg and 1.6 for 7 20 dndz only D1+D2 or no reg (but f***s up) # interpolating to nearest to pass to code f = interp1d(np.append(z_s_cents_theo,np.array([z_s_cents[0],z_s_cents[-1]])),\ np.append(bz_data_theo[i,:],np.array([bz_data_theo[i,0],bz_data_theo[i,-1]])),\ kind='nearest',bounds_error=0,fill_value=0.) b_zsamples = f(z_s_cents) bz_data[i, :] = b_zsamples return bz_data_theo, bz_data, cosmo_fid
def DESIParams(C): ### the following snippet stolen from PkSNR.py in unimap ## cut start h = C['h'] z, _, _, _, _, _, V, nelg, nlrg, nqso, _, _ = np.loadtxt('desi.dat', unpack=True) V *= 1e9 ## to (Gpc/h)^3 nelg *= 0.1 * 14e3 / V ## now in num/(Mpc/h)^3, 0.1 for dz=0.1 nlrg *= 0.1 * 14e3 / V nqso *= 0.1 * 14e3 / V belg = 0.84 / ccl.growth_factor(C, 1. / (1. + z)) blrg = 1.7 / ccl.growth_factor(C, 1. / (1. + z)) bqso = 1.2 / ccl.growth_factor(C, 1. / (1. + z)) ## --- cut end ### let's use ELGs biasfunc = interp1d(z, belg, bounds_error=False, fill_value='extrapolate') nbarfunc = interp1d(z, nelg * h**3, bounds_error=False, fill_value='extrapolate') Ptfunc = None zmin = 0.1 zmax = 1.8 return biasfunc, nbarfunc, zmin, zmax, Ptfunc
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 ICpk(cosmo, z_ic): ''' Compute the linear theory P(k) at the redshift of initial conditions Input: -cosmo: cosmological parameters -z_ic: initial conditions redshift Output: -fpk: power spectrum function that takes k in units of h/Mpc ''' k = np.logspace(-5, 2.3, 1000) #CCL uses units if 1/Mpc not h/Mpc so we have to convert things pk = pyccl.linear_matter_power(cosmo, k * cosmo['h'], 1) * (cosmo['h'])**3 D = pyccl.growth_factor(cosmo, 1. / (1 + z_ic)) fpk = interp1d(k, pk * D**2) return fpk
def apply(self, cosmo, params, source): """Apply a linear alignment systematic. Parameters ---------- cosmo : pyccl.Cosmology A pyccl.Cosmology object. params : dict A dictionary mapping parameter names to their current values. source : a source object The source to which apply the shear bias. """ pref = (((1.0 + source.z_) / (1.0 + params[self.z_piv]))**params[self.alphaz]) pref *= ccl.growth_factor(cosmo, 1.0 / (1.0 + source.z_))**params[self.alphag] source.bias_ia_ *= pref
def test_pk_cutoff(): # Tests the exponential cutoff ptc1 = ccl.nl_pt.PTCalculator(with_NC=True) ptc2 = ccl.nl_pt.PTCalculator(with_NC=True, k_cutoff=10., n_exp_cutoff=2.) zs = np.array([0., 1.]) gs4 = ccl.growth_factor(COSMO, 1. / (1 + zs))**4 pk_lin_z0 = ccl.linear_matter_power(COSMO, ptc1.ks, 1.) ptc1.update_pk(pk_lin_z0) ptc2.update_pk(pk_lin_z0) Pd1d1 = np.array( [ccl.linear_matter_power(COSMO, ptc1.ks, a) for a in 1. / (1 + zs)]).T one = np.ones_like(zs) zero = np.zeros_like(zs) p1 = ptc1.get_pgg(Pd1d1, gs4, one, zero, zero, one, zero, zero, True).T p2 = ptc2.get_pgg(Pd1d1, gs4, one, zero, zero, one, zero, zero, True).T expcut = np.exp(-(ptc1.ks / 10.)**2) assert np.all(np.fabs(p1 * expcut / p2 - 1) < 1E-10)
def test_k2pk(): # Tests the k2 term scaling ptc = ccl.nl_pt.PTCalculator(with_NC=True) zs = np.array([0., 1.]) gs4 = ccl.growth_factor(COSMO, 1. / (1 + zs))**4 pk_lin_z0 = ccl.linear_matter_power(COSMO, ptc.ks, 1.) ptc.update_pk(pk_lin_z0) Pd1d1 = np.array( [ccl.linear_matter_power(COSMO, ptc.ks, a) for a in 1. / (1 + zs)]).T one = np.ones_like(zs) zero = np.zeros_like(zs) pmm = ptc.get_pgg(Pd1d1, gs4, one, zero, zero, one, zero, zero, True) pmm_b = ptc.get_pgm(Pd1d1, gs4, one, zero, zero) pmk = ptc.get_pgg(Pd1d1, gs4, one, zero, zero, one, zero, zero, True, bk21=one) pmk_b = ptc.get_pgm(Pd1d1, gs4, one, zero, zero, bk2=one) pkk = ptc.get_pgg(Pd1d1, gs4, one, zero, zero, one, zero, zero, True, bk21=one, bk22=one) ks = ptc.ks[:, None] assert np.all(np.fabs(pmm / Pd1d1 - 1) < 1E-10) assert np.all(np.fabs(pmm_b / Pd1d1 - 1) < 1E-10) assert np.all(np.fabs(pmk / (pmm * (1 + 0.5 * ks**2)) - 1) < 1E-10) assert np.all(np.fabs(pmk_b / (pmm * (1 + 0.5 * ks**2)) - 1) < 1E-10) assert np.all(np.fabs(pkk / (pmm * (1 + ks**2)) - 1) < 1E-10)
def set_theory_correlations(self): # Get cosmology parameters with open(os.path.join(PROJECT_PATH, 'cosmologies.yml'), 'r') as cosmology_file: self.cosmology_params = yaml.full_load(cosmology_file)[ self.cosmology_name] self.cosmology_params[ 'matter_power_spectrum'] = self.cosmology_matter_power_spectrum cosmology = ccl.Cosmology(**self.cosmology_params) bias_arr = self.bias * np.ones(len(self.z_arr)) if self.scale_bias: bias_arr = bias_arr / ccl.growth_factor(cosmology, 1. / (1. + self.z_arr)) tracers_dict = { 'g': ccl.NumberCountsTracer(cosmology, has_rsd=False, dndz=(self.z_arr, self.n_arr), bias=(self.z_arr, bias_arr)), 'k': ccl.CMBLensingTracer(cosmology, 1091), 't': ISWTracer(cosmology, z_max=6., n_chi=1024), } for correlation_symbol in self.all_correlation_symbols: # Pass if theory correlation was set earlier with maps if correlation_symbol not in self.theory_correlations: tracer_symbol_a = correlation_symbol[0] tracer_symbol_b = correlation_symbol[1] correlation_symbol = tracer_symbol_a + tracer_symbol_b self.theory_correlations[correlation_symbol] = ccl.angular_cl( cosmology, tracers_dict[tracer_symbol_a], tracers_dict[tracer_symbol_b], self.l_arr) for correlation_symbol in self.theory_correlations.keys(): self.theory_correlations[correlation_symbol] += self.noise_curves[ correlation_symbol]
def test_linear_alignment_systematic_smoke(): src = DummySource() src.z_ = np.linspace(0, 2.0, 10) src.bias_ia_ = 30.0 cosmo = ccl.Cosmology(Omega_c=0.27, Omega_b=0.045, Omega_k=0.0, w0=-1.0, wa=0.0, sigma8=0.8, n_s=0.96, h=0.67) gf = ccl.growth_factor(cosmo, 1.0 / (1.0 + src.z_)) params = {'__alphag': 0.2, '__alphaz': 0.5, '__z_piv': 0.4} sys = LinearAlignmentSystematic(alphag='__alphag', alphaz='__alphaz', z_piv='__z_piv') sys.apply(cosmo, params, src) bias_ia = 30.0 * gf**0.2 * ((1.0 + src.z_) / (1.0 + 0.4))**0.5 assert np.allclose(src.bias_ia_, bias_ia)
def lmax_for_redshift(cosmo, z, kmax0=0.2): """ Calculates an lmax for a bin at a given redshift. This is found by taking some k_max at z=0, scaling it by the growth factor, and converting to an ell value. Parameters: cosmo (ccl.Cosmology): CCL Cosmology object. z (float): Redshift. kmax (float): Max. wavenumber (cutoff) at z=0, in Mpc^-1 units. Returns: lmax (float): Maximum ell for this redshift. """ r = ccl.comoving_radial_distance(cosmo, 1.0 / (1.0 + z)) D = ccl.growth_factor(cosmo, 1.0 / (1.0 + z)) lmax = r * D * kmax0 return lmax
def get_cl(self, ell, cl_types, **kwargs): self._get_cosmo(kwargs['sigma8']) zs, nz = self.get_nz(**kwargs) if self.bias_type == 'constant': bzs = kwargs['bias'] * np.ones_like(zs) elif self.bias_type == 'inv_growth': bzs = kwargs['bias'] / ccl.growth_factor(self.cosmo, 1. / (1 + zs)) elif self.bias_type == 'plateau': zr2 = (zs / 1.5)**2 bzs = kwargs['bias'] * (1 + 2 * zr2) / (1 + zr2) else: raise ValueError("Unknown bias type %s" % bias_type) trs = {} trs['g'] = ccl.NumberCountsTracer(self.cosmo, False, (zs, nz), (zs, bzs)) if 'gk' in cl_types: trs['k'] = ccl.CMBLensingTracer(self.cosmo, z_source=1100.) t = [] for typ in cl_types: t1 = trs[typ[0]] t2 = trs[typ[1]] t.append(ccl.angular_cl(self.cosmo, t1, t2, ell)) return np.array(t)
def set_up(request): t0 = time.time() nztyp = request.param dirdat = os.path.dirname(__file__) + '/data/' cosmo = ccl.Cosmology(Omega_c=0.30, Omega_b=0.00, Omega_g=0, Omega_k=0, h=0.7, sigma8=0.8, n_s=0.96, Neff=0, m_nu=0.0, w0=-1, wa=0, T_CMB=2.7, transfer_function='bbks', mass_function='tinker', matter_power_spectrum='linear') cosmo.cosmo.gsl_params.INTEGRATION_LIMBER_EPSREL = 1E-4 cosmo.cosmo.gsl_params.INTEGRATION_EPSREL = 1E-4 # ell-arrays nls = 541 ells = np.zeros(nls) ells[:50] = np.arange(50) + 2 ells[50:] = ells[49] + 6 * (np.arange(nls - 50) + 1) fl_one = np.ones(nls) fl_dl = (ells + 0.5)**2 / np.sqrt( (ells + 2.) * (ells + 1.) * ells * (ells - 1.)) fl_ll = fl_dl**2 fl_lc = ells * (ells + 1) / np.sqrt( (ells + 2.) * (ells + 1.) * ells * (ells - 1.)) fl_li = 2 * fl_dl lfacs = { 'ells': ells, 'fl_one': fl_one, 'fl_dl': fl_dl, 'fl_ll': fl_ll, 'fl_lc': fl_lc, 'fl_li': fl_li } # Initialize tracers if nztyp == 'analytic': # Analytic case zmean_1 = 1.0 sigz_1 = 0.15 zmean_2 = 1.5 sigz_2 = 0.15 z1, tmp_a1 = np.loadtxt(dirdat + "ia_amp_analytic_1.txt", unpack=True) z2, tmp_a2 = np.loadtxt(dirdat + "ia_amp_analytic_2.txt", unpack=True) pz1 = np.exp(-0.5 * ((z1 - zmean_1) / sigz_1)**2) pz2 = np.exp(-0.5 * ((z2 - zmean_2) / sigz_2)**2) elif nztyp == 'histo': # Histogram case z1, pz1 = np.loadtxt(dirdat + "bin1_histo.txt", unpack=True)[:, 1:] _, tmp_a1 = np.loadtxt(dirdat + "ia_amp_histo_1.txt", unpack=True) z2, pz2 = np.loadtxt(dirdat + "bin2_histo.txt", unpack=True)[:, 1:] _, tmp_a2 = np.loadtxt(dirdat + "ia_amp_histo_2.txt", unpack=True) else: raise ValueError("Wrong Nz type " + nztyp) bz = np.ones_like(pz1) # Renormalize the IA amplitude to be consistent with A_IA D1 = ccl.growth_factor(cosmo, 1. / (1 + z1)) D2 = ccl.growth_factor(cosmo, 1. / (1 + z2)) rho_m = ccl.physical_constants.RHO_CRITICAL * cosmo['Omega_m'] a1 = -tmp_a1 * D1 / (5e-14 * rho_m) a2 = -tmp_a2 * D2 / (5e-14 * rho_m) # Initialize tracers trc = {} trc['g1'] = ccl.NumberCountsTracer(cosmo, False, (z1, pz1), (z2, bz)) trc['g2'] = ccl.NumberCountsTracer(cosmo, False, (z2, pz2), (z2, bz)) trc['l1'] = ccl.WeakLensingTracer(cosmo, (z1, pz1)) trc['l2'] = ccl.WeakLensingTracer(cosmo, (z2, pz2)) trc['i1'] = ccl.WeakLensingTracer(cosmo, (z1, pz1), has_shear=False, ia_bias=(z1, a1)) trc['i2'] = ccl.WeakLensingTracer(cosmo, (z2, pz2), has_shear=False, ia_bias=(z2, a2)) trc['ct'] = ccl.CMBLensingTracer(cosmo, 1100.) # Read benchmarks def read_bm(fname): _, cl = np.loadtxt(fname, unpack=True) return cl[ells.astype('int')] pre = dirdat + 'run_' post = nztyp + "_log_cl_" bms = {} bms['dd_11'] = read_bm(pre + 'b1b1' + post + 'dd.txt') bms['dd_12'] = read_bm(pre + 'b1b2' + post + 'dd.txt') bms['dd_22'] = read_bm(pre + 'b2b2' + post + 'dd.txt') bms['dl_11'] = read_bm(pre + 'b1b1' + post + 'dl.txt') bms['dl_12'] = read_bm(pre + 'b1b2' + post + 'dl.txt') bms['dl_21'] = read_bm(pre + 'b2b1' + post + 'dl.txt') bms['dl_22'] = read_bm(pre + 'b2b2' + post + 'dl.txt') bms['di_11'] = read_bm(pre + 'b1b1' + post + 'di.txt') bms['di_12'] = read_bm(pre + 'b1b2' + post + 'di.txt') bms['di_21'] = read_bm(pre + 'b2b1' + post + 'di.txt') bms['di_22'] = read_bm(pre + 'b2b2' + post + 'di.txt') bms['dc_1'] = read_bm(pre + 'b1b1' + post + 'dc.txt') bms['dc_2'] = read_bm(pre + 'b2b2' + post + 'dc.txt') bms['ll_11'] = read_bm(pre + 'b1b1' + post + 'll.txt') bms['ll_12'] = read_bm(pre + 'b1b2' + post + 'll.txt') bms['ll_22'] = read_bm(pre + 'b2b2' + post + 'll.txt') bms['li_11'] = read_bm(pre + 'b1b1' + post + 'li.txt') bms['li_22'] = read_bm(pre + 'b2b2' + post + 'li.txt') bms['lc_1'] = read_bm(pre + 'b1b1' + post + 'lc.txt') bms['lc_2'] = read_bm(pre + 'b2b2' + post + 'lc.txt') bms['ii_11'] = read_bm(pre + 'b1b1' + post + 'ii.txt') bms['ii_12'] = read_bm(pre + 'b1b2' + post + 'ii.txt') bms['ii_22'] = read_bm(pre + 'b2b2' + post + 'ii.txt') bms['cc'] = read_bm(pre + 'log_cl_cc.txt') print('init and i/o time:', time.time() - t0) return cosmo, trc, lfacs, bms
def main(sim_name, z_nbody, z_ic, R_smooth, machine, want_plot=False): # user choices k_max = 0.5 k_min = 1.e-4 # redshift choice #z_s = np.array([3.0, 2.5, 2.0, 1.7, 1.4, 1.1, 0.8, 0.5, 0.4, 0.3, 0.2, 0.1]) z_s = np.array([0.1, 0.2, 0.3, 0.4, 0.5, 0.8, 1.1]) a_s = 1. / (1 + z_s) # test with class class_dir = os.path.expanduser( "~/repos/AbacusSummit/Cosmologies/abacus_cosm000/") # load parameters user_dict, cosmo_dict = load_dict(z_nbody, sim_name, machine) R_smooth = user_dict['R_smooth'] data_dir = user_dict['data_dir'] # Cosmology cosmo = ccl.Cosmology(**cosmo_dict) # Redshift distributions nz_s = np.exp(-((z_s - 0.8) / 0.05)**2 / 2) # Bias bz_s = 0.95 / ccl.growth_factor(cosmo, a_s) # This tracer will only include the density contribution galaxies = ccl.NumberCountsTracer(cosmo, has_rsd=False, dndz=(z_s, nz_s), bias=(z_s, bz_s), mag_bias=None) # read in CLASS power spectra ks, Pk = np.loadtxt(class_dir + 'abacus_cosm000.z%d_pk_cb.dat' % (1), unpack=True) Pk_a_s = np.zeros((len(a_s), len(ks))) for i in range(len(a_s)): print(i) Pk_a_s[i, :] = np.loadtxt(class_dir + 'abacus_cosm000.z%d_pk_cb.dat' % (i + 1))[:, 1] # generating fake data k = np.load("data/AbacusSummit_base_c000_ph006/z1.100/ks.npy") dk = k[1] - k[0] Lbox = 2000. N_modes = k**2 * dk * Lbox**3. / (2. * np.pi**2) for i in range(len(a_s)): # ccl expects Mpc units todo: improve and ask h = cosmo_dict['h'] # give the ks in Mpc^-1 and get Pk_gg in [Mpc/h]^3 Pk_gg = ccl.nonlin_matter_power(cosmo, k * h, a_s[i]) * h**3 cov = np.diag(Pk_gg**2 * (2. / N_modes)) np.save("data_power/pk_gg_z%4.3f.npy" % z_s[i], Pk_gg) np.save("data_power/ks.npy", k) np.save("data_power/cov_pk_gg_z%4.3f.npy" % z_s[i], cov) # load k and P(k,a) ells, cl_tt_tmp = project_Cl(cosmo, galaxies, Pk_a_s, ks, a_s, want_plot)
r = 0.0 #Call function to evalute growth index for PPNC model z, H, Omega_M, Omega_DE, f, D, gam = PPNC2(z_final, H0, Omega_M0, k, alpha_0, p, gamma_0, gamma_cm0, q, gamma_cDE0, r) # ignore: PPNC(2.0, H0, 0.3, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, -lam/2.0, 1.0) ################################################################################ import pyccl as ccl cosmo = ccl.Cosmology(Omega_c=0.25, Omega_b=0.05, h=0.7324, A_s=2.1e-9, n_s=0.96) ccl_D = ccl.growth_factor(cosmo, 1. / (1. + z)) ccl_f = ccl.growth_rate(cosmo, 1. / (1. + z)) ################################################################################ #Time code in secs #print("Time taken", time.clock() - start, "secs") print('D') #print('H', H) #P.subplot(111) P.figure(1) aa = 1. / (1. + z) #Plot growth factor
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])) np.savetxt("bz_lsst.txt",np.transpose([zarr,bzarr])) np.savetxt("nz_lsst.txt",np.transpose([zarr,nzarr]))
((z - z0) / sz)**2) * ndens / np.sqrt(2 * np.pi * sz**2) pars = { 'h': 0.67, 'Omega_c': 0.27, 'Omega_b': 0.045, 'A_s': 2.1e-9, 'n_s': 0.96, 'w_0': -1., 'w_a': -0. } z_ref = np.linspace(0, 3, 512) cosmo = get_cosmo_ccl(pars) bz_ref = 0.95 * ccl.growth_factor(cosmo, 1.) / ccl.growth_factor( cosmo, 1. / (1 + z_ref)) z = {} pz = {} bz = {} fsky = {} cov_sim = {} cov_th = {} # pz 1 bin z[1] = np.tile(z_ref, [1, 1]) pz[1] = np.array([nofz(z_ref, 0.955, 0.13, 7.55)]) bz[1] = np.tile(0.65 * bz_ref, [1, 1]) fsky[1] = 1. #TODO
def check_background(cosmo): """ Check that background and growth functions can be run. """ # Types of scale factor input (scalar, list, array) a_scl = 0.5 is_comoving = 0 a_lst = [0.2, 0.4, 0.6, 0.8, 1.] a_arr = np.linspace(0.2, 1., 5) # growth_factor assert_(all_finite(ccl.growth_factor(cosmo, a_scl))) assert_(all_finite(ccl.growth_factor(cosmo, a_lst))) assert_(all_finite(ccl.growth_factor(cosmo, a_arr))) # growth_factor_unnorm assert_(all_finite(ccl.growth_factor_unnorm(cosmo, a_scl))) assert_(all_finite(ccl.growth_factor_unnorm(cosmo, a_lst))) assert_(all_finite(ccl.growth_factor_unnorm(cosmo, a_arr))) # growth_rate assert_(all_finite(ccl.growth_rate(cosmo, a_scl))) assert_(all_finite(ccl.growth_rate(cosmo, a_lst))) assert_(all_finite(ccl.growth_rate(cosmo, a_arr))) # comoving_radial_distance assert_(all_finite(ccl.comoving_radial_distance(cosmo, a_scl))) assert_(all_finite(ccl.comoving_radial_distance(cosmo, a_lst))) assert_(all_finite(ccl.comoving_radial_distance(cosmo, a_arr))) # comoving_angular_distance assert_(all_finite(ccl.comoving_angular_distance(cosmo, a_scl))) assert_(all_finite(ccl.comoving_angular_distance(cosmo, a_lst))) assert_(all_finite(ccl.comoving_angular_distance(cosmo, a_arr))) # h_over_h0 assert_(all_finite(ccl.h_over_h0(cosmo, a_scl))) assert_(all_finite(ccl.h_over_h0(cosmo, a_lst))) assert_(all_finite(ccl.h_over_h0(cosmo, a_arr))) # luminosity_distance assert_(all_finite(ccl.luminosity_distance(cosmo, a_scl))) assert_(all_finite(ccl.luminosity_distance(cosmo, a_lst))) assert_(all_finite(ccl.luminosity_distance(cosmo, a_arr))) # scale_factor_of_chi assert_(all_finite(ccl.scale_factor_of_chi(cosmo, a_scl))) assert_(all_finite(ccl.scale_factor_of_chi(cosmo, a_lst))) assert_(all_finite(ccl.scale_factor_of_chi(cosmo, a_arr))) # omega_m_a assert_(all_finite(ccl.omega_x(cosmo, a_scl, 'matter'))) assert_(all_finite(ccl.omega_x(cosmo, a_lst, 'matter'))) assert_(all_finite(ccl.omega_x(cosmo, a_arr, 'matter'))) # Fractional density of different types of fluid assert_(all_finite(ccl.omega_x(cosmo, a_arr, 'dark_energy'))) assert_(all_finite(ccl.omega_x(cosmo, a_arr, 'radiation'))) assert_(all_finite(ccl.omega_x(cosmo, a_arr, 'curvature'))) assert_(all_finite(ccl.omega_x(cosmo, a_arr, 'neutrinos_rel'))) assert_(all_finite(ccl.omega_x(cosmo, a_arr, 'neutrinos_massive'))) # Check that omega_x fails if invalid component type is passed assert_raises(ValueError, ccl.omega_x, cosmo, a_scl, 'xyz') # rho_crit_a assert_(all_finite(ccl.rho_x(cosmo, a_scl, 'critical', is_comoving))) assert_(all_finite(ccl.rho_x(cosmo, a_lst, 'critical', is_comoving))) assert_(all_finite(ccl.rho_x(cosmo, a_arr, 'critical', is_comoving))) # rho_m_a assert_(all_finite(ccl.rho_x(cosmo, a_scl, 'matter', is_comoving))) assert_(all_finite(ccl.rho_x(cosmo, a_lst, 'matter', is_comoving))) assert_(all_finite(ccl.rho_x(cosmo, a_arr, 'matter', is_comoving)))
def compute_mean_covariance(tomo_bin, z, what): """Compute a mean and covariance for the chosen distribution of objects. value can be 'ww' for shear-shear only, 'gg' for galaxy clustering and '3x2' for full '3x2pt' This assumes a cosmology, and the varions parameters affecting the noise and signal: the f_sky, ell choices, sigma_e, and n_eff """ import pyccl as ccl # 10,000 sq deg f_sky = 0.25 # pretend there is no evolution in measurement error. # because LSST is awesome sigma_e = 0.26 # assumed total over all bins, divided proportionally n_eff_total_arcmin2 = 20.0 # Use this fiducial cosmology, which is what I have for TXPipe config = yaml.safe_load(open(default_config_path)) cosmo = ccl.Cosmology(**config['parameters']) # ell values we will use. Computed centrally # since we want to avoid mismatches elsewhere. # should really sort this out better. ell, delta_ell = ell_binning() n_ell = len(ell) # work out the number density per steradian steradian_to_arcmin2 = (180 * 60 / np.pi)**2 n_eff_total = n_eff_total_arcmin2 * steradian_to_arcmin2 nbin = int(tomo_bin.max()) + 1 z_mid, n_of_z = get_n_of_z(tomo_bin, z) bz = 1 / ccl.growth_factor(cosmo, 1 / (1 + z_mid)) bofz = (z_mid, bz) galaxy_galaxy_tracer_bias = [(bz * nz_bin).sum() / (nz_bin).sum() for nz_bin in n_of_z] #print ('biases=',galaxy_galaxy_tracer_bias) tracers = [] counts = [nz_bin.sum() for nz_bin in n_of_z] tracers = [] tracer_type = get_tracer_type(nbin, what) # start with number counts if (what == 'gg' or what == '3x2'): tracers += [ ccl.NumberCountsTracer(cosmo, has_rsd=False, dndz=(z_mid, nz_bin), bias=bofz) for nz_bin in n_of_z ] if (what == 'ww' or what == '3x2'): tracers += [ ccl.WeakLensingTracer(cosmo, dndz=(z_mid, nz_bin)) for nz_bin in n_of_z ] ntracers = len(tracers) #print (tracer_type) # Get the fraction of the total possible number of objects # in each bin, and the consequent effective number density. # We pretend here that all objects have the same weight. fractions = [c / tomo_bin.size for c in counts] n_eff = [n_eff_total * f for f in fractions] # Define an ordering of the theory vector blocks = [] for i in range(ntracers): for j in range(i, ntracers): blocks.append((i, j)) # Get all the spectra, both the signal-only version (for the mean) # and the version with noise (for the covmat) C_sig = {} C_obs = {} for ci, cj in blocks: # ci, cj are tracer numbers as in (g1, g2, g3, g4, s1, s2,s3,s4 etc.) # nbin is 4 in the example above # so ci %n bin gives the tomographic bin i = ci % nbin j = cj % nbin Ti = tracers[ci] Tj = tracers[cj] C_sig[ci, cj] = ccl.angular_cl(cosmo, Ti, Tj, ell) # Noise contribution, if an auto-bin if ci == cj: if tracer_type[ci] == 'g': C_obs[ci, cj] = C_sig[ci, cj] + 1 / n_eff[i] elif tracer_type[ci] == 'w': C_obs[ci, cj] = C_sig[ci, cj] + sigma_e**2 / n_eff[i] else: raise NotImplementedError("Unknown tracer") else: C_obs[ci, cj] = C_sig[ci, cj] C_obs[cj, ci] = C_sig[ci, cj] # concatenate all the theory predictions as our mean mu = np.concatenate([C_sig[i, j] for i, j in blocks]) # empty space for the covariance matrix C = np.zeros((mu.size, mu.size)) # normalization. This and the bit below are Takada & Jain # equation 14 norm = (2 * ell + 1) * delta_ell * f_sky # Fill in each covmat block. We waste time here # doing the flip elements but not significant for a, (i, j) in enumerate(blocks[:]): for b, (m, n) in enumerate(blocks[:]): start_a = a * n_ell start_b = b * n_ell end_a = start_a + n_ell end_b = start_b + n_ell c2 = (C_obs[i, m] * C_obs[j, n] + C_obs[i, n] * C_obs[j, m]) C[start_a:end_a, start_b:end_b] = (c2 / norm) * np.eye(n_ell) return mu, C, galaxy_galaxy_tracer_bias
def set_up(request): t0 = time.time() nztyp = request.param dirdat = os.path.dirname(__file__) + '/data/' cosmo = ccl.Cosmology(Omega_c=0.30, Omega_b=0.00, Omega_g=0, Omega_k=0, h=0.7, sigma8=0.8, n_s=0.96, Neff=0, m_nu=0.0, w0=-1, wa=0, T_CMB=2.7, transfer_function='bbks', mass_function='tinker', matter_power_spectrum='linear') cosmo.cosmo.gsl_params.INTEGRATION_LIMBER_EPSREL = 2.5E-5 cosmo.cosmo.gsl_params.INTEGRATION_EPSREL = 2.5E-5 # Ell-dependent correction factors # Set up array of ells fl = {} lmax = 10000 nls = (lmax - 400) // 20 + 141 ells = np.zeros(nls) ells[:101] = np.arange(101) ells[101:121] = ells[100] + (np.arange(20) + 1) * 5 ells[121:141] = ells[120] + (np.arange(20) + 1) * 10 ells[141:] = ells[140] + (np.arange(nls - 141) + 1) * 20 fl['lmax'] = lmax fl['ells'] = ells # Initialize tracers if nztyp == 'analytic': # Analytic case zmean_1 = 1.0 sigz_1 = 0.15 zmean_2 = 1.5 sigz_2 = 0.15 z1, tmp_a1 = np.loadtxt(dirdat + "ia_amp_analytic_1.txt", unpack=True) z2, tmp_a2 = np.loadtxt(dirdat + "ia_amp_analytic_2.txt", unpack=True) pz1 = np.exp(-0.5 * ((z1 - zmean_1) / sigz_1)**2) pz2 = np.exp(-0.5 * ((z2 - zmean_2) / sigz_2)**2) elif nztyp == 'histo': # Histogram case z1, pz1 = np.loadtxt(dirdat + "bin1_histo.txt", unpack=True)[:, 1:] _, tmp_a1 = np.loadtxt(dirdat + "ia_amp_histo_1.txt", unpack=True) z2, pz2 = np.loadtxt(dirdat + "bin2_histo.txt", unpack=True)[:, 1:] _, tmp_a2 = np.loadtxt(dirdat + "ia_amp_histo_2.txt", unpack=True) else: raise ValueError("Wrong Nz type " + nztyp) bz = np.ones_like(pz1) # Renormalize the IA amplitude to be consistent with A_IA D1 = ccl.growth_factor(cosmo, 1. / (1 + z1)) D2 = ccl.growth_factor(cosmo, 1. / (1 + z2)) rho_m = ccl.physical_constants.RHO_CRITICAL * cosmo['Omega_m'] a1 = -tmp_a1 * D1 / (5e-14 * rho_m) a2 = -tmp_a2 * D2 / (5e-14 * rho_m) # Initialize tracers trc = {} trc['g1'] = ccl.NumberCountsTracer(cosmo, False, (z1, pz1), (z2, bz)) trc['g2'] = ccl.NumberCountsTracer(cosmo, False, (z2, pz2), (z2, bz)) trc['l1'] = ccl.WeakLensingTracer(cosmo, (z1, pz1)) trc['l2'] = ccl.WeakLensingTracer(cosmo, (z2, pz2)) trc['i1'] = ccl.WeakLensingTracer(cosmo, (z1, pz1), has_shear=False, ia_bias=(z1, a1)) trc['i2'] = ccl.WeakLensingTracer(cosmo, (z2, pz2), has_shear=False, ia_bias=(z2, a2)) trc['ct'] = ccl.CMBLensingTracer(cosmo, 1100.) # Read benchmarks def read_bm(fname): th, xi = np.loadtxt(fname, unpack=True) return th, xi pre = dirdat + 'run_' post = nztyp + "_log_wt_" bms = {} theta, bms['dd_11'] = read_bm(pre + 'b1b1' + post + 'dd.txt') _, bms['dd_12'] = read_bm(pre + 'b1b2' + post + 'dd.txt') _, bms['dd_22'] = read_bm(pre + 'b2b2' + post + 'dd.txt') _, bms['dl_11'] = read_bm(pre + 'b1b1' + post + 'dl.txt') _, bms['dl_12'] = read_bm(pre + 'b1b2' + post + 'dl.txt') _, bms['dl_21'] = read_bm(pre + 'b2b1' + post + 'dl.txt') _, bms['dl_22'] = read_bm(pre + 'b2b2' + post + 'dl.txt') _, bms['di_11'] = read_bm(pre + 'b1b1' + post + 'di.txt') _, bms['di_12'] = read_bm(pre + 'b1b2' + post + 'di.txt') _, bms['di_21'] = read_bm(pre + 'b2b1' + post + 'di.txt') _, bms['di_22'] = read_bm(pre + 'b2b2' + post + 'di.txt') _, bms['ll_11_p'] = read_bm(pre + 'b1b1' + post + 'll_pp.txt') _, bms['ll_12_p'] = read_bm(pre + 'b1b2' + post + 'll_pp.txt') _, bms['ll_22_p'] = read_bm(pre + 'b2b2' + post + 'll_pp.txt') _, bms['ll_11_m'] = read_bm(pre + 'b1b1' + post + 'll_mm.txt') _, bms['ll_12_m'] = read_bm(pre + 'b1b2' + post + 'll_mm.txt') _, bms['ll_22_m'] = read_bm(pre + 'b2b2' + post + 'll_mm.txt') _, bms['li_11_p'] = read_bm(pre + 'b1b1' + post + 'li_pp.txt') _, bms['li_12_p'] = read_bm(pre + 'b1b2' + post + 'li_pp.txt') _, bms['li_22_p'] = read_bm(pre + 'b2b2' + post + 'li_pp.txt') _, bms['li_11_m'] = read_bm(pre + 'b1b1' + post + 'li_mm.txt') _, bms['li_12_m'] = read_bm(pre + 'b1b2' + post + 'li_mm.txt') _, bms['li_22_m'] = read_bm(pre + 'b2b2' + post + 'li_mm.txt') _, bms['ii_11_p'] = read_bm(pre + 'b1b1' + post + 'ii_pp.txt') _, bms['ii_12_p'] = read_bm(pre + 'b1b2' + post + 'ii_pp.txt') _, bms['ii_22_p'] = read_bm(pre + 'b2b2' + post + 'ii_pp.txt') _, bms['ii_11_m'] = read_bm(pre + 'b1b1' + post + 'ii_mm.txt') _, bms['ii_12_m'] = read_bm(pre + 'b1b2' + post + 'ii_mm.txt') _, bms['ii_22_m'] = read_bm(pre + 'b2b2' + post + 'ii_mm.txt') bms['theta'] = theta # Read error bars ers = {} d = np.loadtxt("benchmarks/data/sigma_clustering_Nbin5", unpack=True) ers['dd_11'] = interp1d(d[0] / 60., d[1], fill_value=d[1][0], bounds_error=False)(theta) ers['dd_22'] = interp1d(d[0] / 60., d[2], fill_value=d[2][0], bounds_error=False)(theta) d = np.loadtxt("benchmarks/data/sigma_ggl_Nbin5", unpack=True) ers['dl_12'] = interp1d(d[0] / 60., d[1], fill_value=d[1][0], bounds_error=False)(theta) ers['dl_11'] = interp1d(d[0] / 60., d[2], fill_value=d[2][0], bounds_error=False)(theta) ers['dl_22'] = interp1d(d[0] / 60., d[3], fill_value=d[3][0], bounds_error=False)(theta) ers['dl_21'] = interp1d(d[0] / 60., d[4], fill_value=d[4][0], bounds_error=False)(theta) d = np.loadtxt("benchmarks/data/sigma_xi+_Nbin5", unpack=True) ers['ll_11_p'] = interp1d(d[0] / 60., d[1], fill_value=d[1][0], bounds_error=False)(theta) ers['ll_22_p'] = interp1d(d[0] / 60., d[2], fill_value=d[2][0], bounds_error=False)(theta) ers['ll_12_p'] = interp1d(d[0] / 60., d[3], fill_value=d[3][0], bounds_error=False)(theta) d = np.loadtxt("benchmarks/data/sigma_xi-_Nbin5", unpack=True) ers['ll_11_m'] = interp1d(d[0] / 60., d[1], fill_value=d[1][0], bounds_error=False)(theta) ers['ll_22_m'] = interp1d(d[0] / 60., d[2], fill_value=d[2][0], bounds_error=False)(theta) ers['ll_12_m'] = interp1d(d[0] / 60., d[3], fill_value=d[3][0], bounds_error=False)(theta) print('setup time:', time.time() - t0) return cosmo, trc, bms, ers, fl