def get_power_spectrum(self, cosmo, nz1, nz2): """ Compute power spectrum between two redshift distributions """ t1 = ccl.WeakLensingTracer(cosmo, nz1) t2 = ccl.WeakLensingTracer(cosmo, nz2) return ccl.angular_cl(cosmo, t1, t2, self.ells)
def test_tracer_lensing_kernel_spline_vs_gsl_intergation( z_min, z_max, n_z_samples): # Create a new Cosmology object so that we're not messing with the other # tests 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') z = np.linspace(z_min, z_max, n_z_samples) n = dndz(z) # Make sure case where z[0] > 0 and n[0] > 0 is tested for if z_min > 0: assert n[0] > 0 cosmo.cosmo.gsl_params.LENSING_KERNEL_SPLINE_INTEGRATION = True tr_wl = ccl.WeakLensingTracer(cosmo, dndz=(z, n)) w_wl_spline, _ = tr_wl.get_kernel(chi=None) cosmo.cosmo.gsl_params.LENSING_KERNEL_SPLINE_INTEGRATION = False tr_wl = ccl.WeakLensingTracer(cosmo, dndz=(z, n)) w_wl_gsl, chi = tr_wl.get_kernel(chi=None) # Peak of kernel is ~1e-5 if n_z_samples >= 1000: assert np.allclose(w_wl_spline[0], w_wl_gsl[0], atol=1e-10, rtol=1e-9) else: assert np.allclose(w_wl_spline[0], w_wl_gsl[0], atol=5e-9, rtol=1e-5)
def test_method(self, cosmo): z_n = np.linspace(0., 1., 200) n = np.ones(z_n.shape) tracer1 = ccl.WeakLensingTracer(cosmo, dndz=(z_n, n)) tracer2 = ccl.WeakLensingTracer(cosmo, dndz=(z_n, n)) ell = np.logspace(np.log10(3), 3) cls = ccl.cls.angular_cl(cosmo, tracer1, tracer2, ell) return cls
def get_cl_ccl(pars, ell_bp): cosmo = get_cosmo_ccl(pars) clust = ccl.NumberCountsTracer(cosmo, has_rsd=False, dndz=(z, pz), bias=(z, bz)) lens = ccl.WeakLensingTracer(cosmo, dndz=(z, pz)) ell = np.arange(nell) cl0 = np.zeros(nell) * 0. cls = np.zeros([3, 3, nell]) cls[0, 0, :] = ccl.angular_cl(cosmo, clust, clust, ell) cls[0, 1, :] = ccl.angular_cl(cosmo, clust, lens, ell) cls[0, 2, :] = cl0 cls[1, 0, :] = cls[0, 1, :] cls[1, 1, :] = ccl.angular_cl(cosmo, lens, lens, ell) cls[1, 2, :] = cl0 cls[2, 0, :] = cls[0, 2, :] cls[2, 1, :] = cls[1, 2, :] cls[2, 2, :] = cl0 cl_flat = np.concatenate( [cls[0, 0, ell_bp], cls[0, 1, ell_bp], cls[1, 1, ell_bp]]) return cl_flat
def get_cl(dtype): config = get_config(dtype) cosmo_pars = config['cosmo'] cosmo = ccl.Cosmology(**cosmo_pars) if config['dtype'] == 'generic': return np.ones(3 * config['nside']) if config['dtype'] == 'galaxy_density': z, nz = np.loadtxt('xcell/tests/data/DESY1gc_dndz_bin0.txt', usecols=(1, 3), unpack=True) b = np.ones_like(z) tracer = ccl.NumberCountsTracer(cosmo, dndz=(z, nz), bias=(z, b), has_rsd=None) elif config['dtype'] == 'galaxy_shear': z, nz = np.loadtxt('xcell/tests/data/Nz_DIR_z0.1t0.3.asc', usecols=(0, 1), unpack=True) tracer = ccl.WeakLensingTracer(cosmo, dndz=(z, nz)) elif config['dtype'] == 'cmb_convergence': tracer = ccl.CMBLensingTracer(cosmo, z_source=1100) elif config['dtype'] == 'cmb_tSZ': tracer = ccl.tSZTracer(cosmo, z_max=3.) cl = ccl.angular_cl(cosmo, tracer, tracer, np.arange(3 * config['nside'])) return cl
def theory_corr(self, n_z2, xvals, lmax2, chi_max, zlo2, zhi2, cosmo_cat): '''compute the correlation function from limber integration over the CAMB power spectrum''' nz_int = self.compute_nz(n_z2) z_vals = np.linspace(zlo2, zhi2, 1000) n_vals = nz_int(z_vals) ns = getattr(cosmo_cat, 'n_s', 0.963) s8 = getattr(cosmo_cat, 'sigma8', 0.8) Omega_c = (cosmo_cat.Om0 - cosmo_cat.Ob0) Omega_b = cosmo_cat.Ob0 h = cosmo_cat.H0.value / 100. cosmo_ccl = ccl.Cosmology( Omega_c=Omega_c, Omega_b=Omega_b, h=h, sigma8=s8, n_s=ns ) #, transfer_function='boltzmann_class', matter_power_spectrum='emu') ll = np.arange(0, 15000) lens1 = ccl.WeakLensingTracer(cosmo_ccl, dndz=(z_vals, n_vals)) pp = ccl.angular_cl(cosmo_ccl, lens1, lens1, ll) pp3_2 = np.zeros((lmax2, 4)) pp3_2[:, 1] = pp[:] * (ll * (ll + 1.)) / (2. * np.pi) cxvals = np.cos(xvals / (60.) / (180. / np.pi)) vals = camb.correlations.cl2corr(pp3_2, cxvals) return xvals, vals[:, 1], vals[:, 2]
def test_tracer_nz_support(): z_max = 1.0 a = np.linspace(1 / (1 + z_max), 1.0, 100) background_def = { "a": a, "chi": ccl.comoving_radial_distance(COSMO, a), "h_over_h0": ccl.h_over_h0(COSMO, a) } calculator_cosmo = ccl.CosmologyCalculator(Omega_c=0.27, Omega_b=0.045, h=0.67, sigma8=0.8, n_s=0.96, background=background_def) z = np.linspace(0., 2., 2000) n = dndz(z) with pytest.raises(ValueError): _ = ccl.WeakLensingTracer(calculator_cosmo, (z, n)) with pytest.raises(ValueError): _ = ccl.NumberCountsTracer(calculator_cosmo, has_rsd=False, dndz=(z, n), bias=(z, np.ones_like(z))) with pytest.raises(ValueError): _ = ccl.CMBLensingTracer(calculator_cosmo, z_source=2.0)
def get_tomo_xi_ccl(sigma8, Omega_cm0, Omega_bm0, h, zpts, zhist, theta_deg, ell): ns = 0.965 ell_num = len(ell) # tomo panel num tomo_bin_num, zpts_num = zhist.shape tomo_panel_num = int((tomo_bin_num * tomo_bin_num + tomo_bin_num) / 2) cosmo = pyccl.Cosmology(Omega_c=Omega_cm0, Omega_b=Omega_bm0, h=h, n_s=ns, sigma8=sigma8, transfer_function="boltzmann_camb") ccl_lens_trs = [] ccl_PL = numpy.zeros((tomo_panel_num, ell_num)) ccl_xip = numpy.zeros_like(theta_deg) ccl_xim = numpy.zeros_like(theta_deg) for i in range(tomo_bin_num): lens_tr = pyccl.WeakLensingTracer(cosmo, dndz=(zpts, zhist[i])) ccl_lens_trs.append(lens_tr) tag = 0 for i in range(tomo_bin_num): for j in range(i, tomo_bin_num): ccl_PL[tag] = pyccl.angular_cl(cosmo, ccl_lens_trs[i], ccl_lens_trs[j], ell) ccl_xip[tag] = pyccl.correlation(cosmo, ell, ccl_PL[tag], theta_deg[tag], type='GG+', method='FFTLog') ccl_xim[tag] = pyccl.correlation(cosmo, ell, ccl_PL[tag], theta_deg[tag], type='GG-', method='FFTLog') tag += 1 return ccl_xip, ccl_xim, ccl_PL
def get_tracer(tracer_type, cosmo=None, **tracer_kwargs): if cosmo is None: cosmo = COSMO z = np.linspace(0., 1., 2000) n = dndz(z) b = np.sqrt(1. + z) if tracer_type == 'nc': ntr = 3 tr = ccl.NumberCountsTracer(cosmo, True, dndz=(z, n), bias=(z, b), mag_bias=(z, b), **tracer_kwargs) elif tracer_type == 'wl': ntr = 2 tr = ccl.WeakLensingTracer(cosmo, dndz=(z, n), ia_bias=(z, b), **tracer_kwargs) elif tracer_type == 'cl': ntr = 1 tr = ccl.CMBLensingTracer(cosmo, 1100., **tracer_kwargs) else: ntr = 0 tr = ccl.Tracer(**tracer_kwargs) return tr, ntr
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_cls_raise_ell_reversed(ells): z = np.linspace(0., 1., 200) n = np.exp(-((z - 0.5) / 0.1)**2) lens = ccl.WeakLensingTracer(COSMO, (z, n)) with pytest.raises(ValueError): ccl.angular_cl(COSMO, lens, lens, ells)
def test_clfid_halomod(tr1, tr2): data = get_config(dtype0=tr1, dtype1=tr2, inc_hm=True) cosmo = ccl.Cosmology(**data['cov']['fiducial']['cosmo']) md = ccl.halos.MassDef200m() mf = ccl.halos.MassFuncTinker10(cosmo, mass_def=md) hb = ccl.halos.HaloBiasTinker10(cosmo, mass_def=md) cm = ccl.halos.ConcentrationDuffy08(mdef=md) hmc = ccl.halos.HMCalculator(cosmo, mf, hb, md) pNFW = ccl.halos.HaloProfileNFW(cm) profs = {} ccltr = {} normed = {} for tr, lab in [(tr1, 'Dummy__0'), (tr2, 'Dummy__1')]: if tr == 'galaxy_density': data['tracers'][lab]['hod_params'] = {'lMmin_0': 12.1, 'lM1_p': 0.1, 'bg_0': 1.2} profs[tr] = ccl.halos.HaloProfileHOD(cm, lMmin_0=12.1, lM1_p=0.1, bg_0=1.2) z, nz = np.loadtxt('xcell/tests/data/DESY1gc_dndz_bin0.txt', usecols=(1, 3), unpack=True) ccltr[tr] = ccl.NumberCountsTracer(cosmo, False, dndz=(z, nz), bias=(z, np.ones_like(z))) normed[tr] = True elif tr == 'cmb_tSZ': data['tracers'][lab]['gnfw_params'] = {'mass_bias': 0.9} profs[tr] = ccl.halos.HaloProfilePressureGNFW(mass_bias=0.9) ccltr[tr] = ccl.tSZTracer(cosmo, z_max=3.) normed[tr] = False elif tr == 'galaxy_shear': profs[tr] = pNFW z, nz = np.loadtxt('xcell/tests/data/Nz_DIR_z0.1t0.3.asc', usecols=(0, 1), unpack=True) ccltr[tr] = ccl.WeakLensingTracer(cosmo, dndz=(z, nz)) normed[tr] = True elif tr == 'cmb_convergence': profs[tr] = pNFW ccltr[tr] = ccl.CMBLensingTracer(cosmo, z_source=1100.) normed[tr] = True clf = ClFid(data, 'Dummy__0', 'Dummy__1') d = clf.get_cl_file() shutil.rmtree(tmpdir1) k_arr = np.geomspace(1E-4, 1E2, 512) a_arr = 1./(1+np.linspace(0, 3, 15)[::-1]) pk = ccl.halos.halomod_Pk2D(cosmo, hmc, profs[tr1], prof2=profs[tr2], normprof1=normed[tr1], normprof2=normed[tr2], lk_arr=np.log(k_arr), a_arr=a_arr) # Commented out until these features are pushed to the pip release of CCL # smooth_transition=(lambda a: 0.7), # supress_1h=(lambda a: 0.01)) clb = ccl.angular_cl(cosmo, ccltr[tr1], ccltr[tr2], d['ell'], p_of_k_a=pk) assert np.all(np.fabs(clb[2:]/d['cl'][0][2:]-1) < 1E-4)
def test_cls_raise_weird_pk(): z = np.linspace(0., 1., 200) n = np.exp(-((z - 0.5) / 0.1)**2) lens = ccl.WeakLensingTracer(COSMO, (z, n)) ells = [10, 11] with pytest.raises(ValueError): ccl.angular_cl(COSMO, lens, lens, ells, p_of_k_a=lambda k, a: 10)
def get_tomo_xi_ccl_2(sigma8, Omega_cm0, Omega_bm0, h, zpts, zhist, theta_deg, theta_num_per_bin, ell, used_zbins, xi_pm="xi_p"): """ for the MCMC :param sigma8: :param Omega_cm0: :param Omega_bm0: :param h: :param zpts: the center of the Z bins :param zhist: Z histogram, (n,m), n is the tomographic bin num, includes the histograms of all bins, the used_zbins will determine which bins are used :param theta_deg: where the signals are measured, (n,) :param ell: \ell of C(\ell), the angular power spectrum :param uesd_zbins: numpy array,(n,), labels, 1 for used, 0 for not used :return: """ # tomo panel num tomo_bin_num, zbin_num = used_zbins.shape[0],used_zbins.sum() cosmo = pyccl.Cosmology(Omega_c=Omega_cm0, Omega_b=Omega_bm0, h=h, n_s=0.965, sigma8=sigma8, transfer_function="boltzmann_camb") ccl_lens_trs = [] for i in range(tomo_bin_num): if used_zbins[i] == 1: lens_tr = pyccl.WeakLensingTracer(cosmo, dndz=(zpts, zhist[i])) ccl_lens_trs.append(lens_tr) if xi_pm == "all": pts_num = int(2*theta_deg.shape[0]) ccl_xipm = numpy.zeros((pts_num,)) tag = 0 for i in range(zbin_num): for j in range(i, zbin_num): st, ed = int(tag * theta_num_per_bin), int((tag + 1) * theta_num_per_bin) ccl_cls = pyccl.angular_cl(cosmo, ccl_lens_trs[i], ccl_lens_trs[j], ell) ccl_xipm[st:ed] = pyccl.correlation(cosmo, ell, ccl_cls, theta_deg[st:ed], type='GG+', method='FFTLog') ccl_xipm[pts_num+st:pts_num+ed] = pyccl.correlation(cosmo, ell, ccl_cls, theta_deg[st:ed], type='GG-', method='FFTLog') tag += 1 return ccl_xipm if xi_pm == "xi_p": corr_type = "GG+" elif xi_pm == "xi_m": corr_type = "GG-" else: print("xi_pm must be one of [\"xi_p\", \"xi_m\",\"all\"]") return None ccl_xi = numpy.zeros_like(theta_deg) tag = 0 for i in range(zbin_num): for j in range(i, zbin_num): st, ed = int(tag*theta_num_per_bin), int((tag+1)*theta_num_per_bin) ccl_cls = pyccl.angular_cl(cosmo, ccl_lens_trs[i], ccl_lens_trs[j], ell) ccl_xi[st:ed] = pyccl.correlation(cosmo, ell, ccl_cls, theta_deg[st:ed], type=corr_type, method='FFTLog') tag += 1 return ccl_xi
def get_ccl_tracer(self, cosmo): _, z, _, nz = np.loadtxt(self.get_path(self.config_h['dndz']), unpack=True) if self.type == 'gc': bz = np.ones_like(z) * self.config_h['bias'] tr = ccl.NumberCountsTracer(cosmo, False, (z, nz), (z, bz)) elif self.type == 'sh': tr = ccl.WeakLensingTracer(cosmo, (z, nz)) return tr
def compute_tracer_ccl(self, tr): tracer = self.data['tracers'][tr] fiducial = self.data['cov']['fiducial'] # Get Tracers if tracer['type'] == 'gc': # Import z, pz z, pz = np.loadtxt(tracer['dndz'], usecols=tracer['dndz_cols'], unpack=True) # Calculate z bias dz = 0 z_dz = z - dz # Set to 0 points where z_dz < 0: sel = z_dz >= 0 z_dz = z_dz[sel] pz = pz[sel] # Calculate bias bias = None if fiducial['gc_bias'] is True: bias = (z, tracer['bias'] * np.ones_like(z)) # Get tracer return ccl.NumberCountsTracer(self.cosmo, has_rsd=False, dndz=(z_dz, pz), bias=bias) elif tracer['type'] == 'wl': # Import z, pz z, pz = np.loadtxt(tracer['dndz'], usecols=tracer['dndz_cols'], unpack=True) # Calculate z bias dz = 0 z_dz = z - dz # Set to 0 points where z_dz < 0: sel = z_dz >= 0 z_dz = z_dz[sel] pz = pz[sel] # # Calculate bias IA ia_bias = None if fiducial['wl_ia']: A, eta, z0 = fiducial[ 'wl_ia'] # TODO: Improve this in yml file bz = A * ( (1. + z) / (1. + z0) )**eta * 0.0139 / 0.013872474 # pyccl2 -> has already the factor inside. Only needed bz ia_bias = (z, bz) # Get tracer return ccl.WeakLensingTracer(self.cosmo, dndz=(z_dz, pz), ia_bias=ia_bias) elif tracer['type'] == 'cv': return ccl.CMBLensingTracer(self.cosmo, z_source=1100) #TODO: correct z_source else: raise ValueError( 'Type of tracer not recognized. It can be gc, wl or cv!')
def compute_theory_c_ell(self, cosmo, nz, sacc_data): # Turn the nz into CCL Tracer objects # Use the cosmology object to calculate C_ell values import pyccl as ccl import sacc CEE = sacc.standard_types.galaxy_shear_cl_ee CEd = sacc.standard_types.galaxy_shearDensity_cl_e Cdd = sacc.standard_types.galaxy_density_cl theory = {} for data_type in [CEE, CEd, Cdd]: for t1, t2 in sacc_data.get_tracer_combinations(data_type): ell = sacc_data.get_tag('ell', data_type, (t1, t2)) tracer1 = sacc_data.get_tracer(t1) tracer2 = sacc_data.get_tracer(t2) dndz1 = (tracer1.z, tracer1.nz) dndz2 = (tracer2.z, tracer2.nz) if data_type in [CEE, CEd]: cTracer1 = ccl.WeakLensingTracer(cosmo, dndz=dndz1) else: bias = (tracer1.z, np.ones_like(tracer1.z)) cTracer1 = ccl.NumberCountsTracer(cosmo, has_rsd=False, bias=bias, dndz=dndz1) warnings.warn("Not including bias in fiducial cosmology") if data_type == CEE: cTracer2 = ccl.WeakLensingTracer(cosmo, dndz=dndz1) else: bias = (tracer2.z, np.ones_like(tracer2.z)) cTracer2 = ccl.NumberCountsTracer(cosmo, has_rsd=False, bias=bias, dndz=dndz2) print(" - Calculating fiducial C_ell for ", data_type, t1, t2) theory[(data_type, t1, t2)] = ccl.angular_cl(cosmo, cTracer1, cTracer2, ell) return theory
def test_tracer_n_sample_wl(): z = np.linspace(0., 1., 2000) n = dndz(z) n_samples = 50 tr_wl = ccl.WeakLensingTracer(COSMO, dndz=(z, n), n_samples=n_samples) w, chi = tr_wl.get_kernel(chi=None) assert w[0].shape[-1] == n_samples assert chi[0].shape[-1] == n_samples
def get_tracer_info(self, two_point_data={}): """ Creates CCL tracer objects and computes the noise for all the tracers Check usage: Can we call all the tracer at once? Parameters: ----------- two_point_data (sacc obj): Returns: -------- ccl_tracers: dict, ccl obj ccl.WeakLensingTracer or ccl.NumberCountsTracer tracer_Noise ({dict: float}): shot (shape) noise for lens (sources) """ ccl_tracers = {} tracer_Noise = {} # b = { l:bi*np.ones(len(z)) for l, bi in self.lens_bias.items()} for tracer in two_point_data.tracers: tracer_dat = two_point_data.get_tracer(tracer) z = tracer_dat.z # FIXME: Following should be read from sacc dataset.-------------- #Ngal = 26. # arc_min^2 #sigma_e = .26 #b = 1.5*np.ones(len(z)) # Galaxy bias (constant with scale and z) # AI = .5*np.ones(len(z)) # Galaxy bias (constant with scale and z) #Ngal = Ngal*3600/d2r**2 # --------------------------------------------------------------- dNdz = tracer_dat.nz dNdz /= (dNdz * np.gradient(z)).sum() dNdz *= self.Ngal[tracer] #FAO this should be called by tomographic bin if 'source' in tracer or 'src' in tracer: IA_bin = self.IA * np.ones(len(z)) # fao: refactor this ccl_tracers[tracer] = ccl.WeakLensingTracer(self.cosmo, dndz=(z, dNdz), ia_bias=(z, IA_bin)) # CCL automatically normalizes dNdz tracer_Noise[ tracer] = self.sigma_e[tracer]**2 / self.Ngal[tracer] elif 'lens' in tracer: # import pdb; pdb.set_trace() b = self.bias_lens[tracer] * np.ones(len(z)) tracer_Noise[tracer] = 1. / self.Ngal[tracer] ccl_tracers[tracer] = ccl.NumberCountsTracer(self.cosmo, has_rsd=False, dndz=(z, dNdz), bias=(z, b)) return ccl_tracers, tracer_Noise
def test_cls_smoke(p_of_k_a): # make a set of tracers to test with z = np.linspace(0., 1., 200) n = np.exp(-((z - 0.5) / 0.1)**2) b = np.sqrt(1. + z) lens1 = ccl.WeakLensingTracer(COSMO, (z, n)) lens2 = ccl.WeakLensingTracer(COSMO, dndz=(z, n), ia_bias=(z, n)) nc1 = ccl.NumberCountsTracer(COSMO, False, dndz=(z, n), bias=(z, b)) nc2 = ccl.NumberCountsTracer(COSMO, True, dndz=(z, n), bias=(z, b)) nc3 = ccl.NumberCountsTracer(COSMO, True, dndz=(z, n), bias=(z, b), mag_bias=(z, b)) cmbl = ccl.CMBLensingTracer(COSMO, 1100.) tracers = [lens1, lens2, nc1, nc2, nc3, cmbl] ell_scl = 4. ell_int = 4 ell_lst = [2, 3, 4, 5] ell_arr = np.arange(2, 5) ells = [ell_int, ell_scl, ell_lst, ell_arr] for i in range(len(tracers)): for j in range(i, len(tracers)): for ell in ells: corr = ccl.angular_cl(COSMO, tracers[i], tracers[j], ell, p_of_k_a=p_of_k_a) assert np.all(np.isfinite(corr)) assert np.shape(corr) == np.shape(ell) # reversing should be fine corr_rev = ccl.angular_cl(COSMO, tracers[j], tracers[i], ell, p_of_k_a=p_of_k_a) assert np.allclose(corr, corr_rev)
def get_tracers_ccl(cosmo, z, pz, bz): n_bins = pz.shape[0] # Tracers tracers = [] for i in range(n_bins): tracers.append( ccl.NumberCountsTracer(cosmo, has_rsd=False, dndz=(z[i], pz[i]), bias=(z[i], bz[i]))) tracers.append(ccl.WeakLensingTracer(cosmo, dndz=(z[i], pz[i]))) return np.array(tracers)
def euclid_ccl(Omega_c, sigma8=0.83): """ Generate C_ell as function of ell for a given Omega_c and Sigma8 Inputs Omega_c -- float: CDM density Sigma_8 -- float: sigma_8 Assumed global variables z -- np.array: samples of z ells -- np.array: samples of ell dNdz_true -- ccl.dNdzSmail: dNdz distribution pz -- ccl.PhotoZGaussian: PhotoZ error nbins -- the amount of tomographic redshift bins Outputs Cls -- np.array, shape (nbins*(nbins-1)/2 + nbins, len(ell)): Cross/Auto correlation shear spectra for the tomographic bins dNdzs -- np.array, shape (nbins,len(z): dNdz per redshift bin, for all redshifts """ cosmo_fid = ccl.Cosmology(Omega_c=Omega_c, Omega_b=0.045, h=0.71, sigma8=sigma8, n_s=0.963) dNdzs = np.zeros((nbins, z.size)) shears = [] for i in range(nbins): # edges of 1 equal width redshift bins, between 0 and 2 zmin, zmax = i * (2. / nbins), (i + 1) * (2. / nbins) # generate dNdz per bin dNdzs[i, :] = ccl.dNdz_tomog(z=z, zmin=zmin, zmax=zmax, pz_func=pz, dNdz_func=dNdz_true) # calculate the shear per bin gal_shapes = ccl.WeakLensingTracer(cosmo_fid, dndz=(z, dNdzs[i, :])) shears.append(gal_shapes) print('Shears calculated, calculating power spectra now...') # calculate nbin*(nbin+1)/2 = 1 spectra from the shears Cls = [] for i in range(nbins): for j in range(0, i + 1): Cls.append(ccl.angular_cl(cosmo_fid, shears[i], shears[j], ells)) return np.array(Cls), dNdzs
def setup(self): # Initialize cosmology par = self.get_cosmological_parameters() dpk = self.get_pk() a = 1./(1+dpk['z'][::-1]) self.cosmo = ccl.CosmologyCalculator(Omega_c=par['Omega_m']-par['Omega_b'], Omega_b=par['Omega_b'], h=par['h'], n_s=par['n_s'], A_s=par['A_s'], w0=par['w0'], pk_linear={'a': a, 'k': dpk['k'], 'delta_matter:delta_matter': dpk['pk_lin'][::-1][:]}, pk_nonlin={'a': a, 'k': dpk['k'], 'delta_matter:delta_matter': dpk['pk_nl'][::-1][:]}) # Initialize tracers if self.config.get('tracers_from_kernels', False): tpar = self.get_tracer_parameters() ker = self.get_tracer_kernels() a_g = 1./(1+ker['z_cl'][::-1]) self.t_g = [] for k in ker['kernels_cl']: t = ccl.Tracer() barr = np.ones_like(a_g) t.add_tracer(self.cosmo, (ker['chi_cl'], k), transfer_a=(a_g, barr)) self.t_g.append(t) self.t_s = [] for k in ker['kernels_sh']: t = ccl.Tracer() t.add_tracer(self.cosmo, kernel=(ker['chi_sh'], k), der_bessel=-1, der_angles=2) self.t_s.append(t) else: nzs = self.get_tracer_dndzs() tpar = self.get_tracer_parameters() z_g = nzs['z_cl'] z_s = nzs['z_sh'] self.t_g = [ccl.NumberCountsTracer(self.cosmo, True, (z_g, nzs['dNdz_cl'][:, ni]), bias=(z_g, np.full(len(z_g), b))) for ni, b in zip(range(0, 10), tpar['b_g'])] self.t_s = [ccl.WeakLensingTracer(self.cosmo, (z_s, nzs['dNdz_sh'][:, ni]), True) for ni in range(0, 5)]
def getCl(cosmo, dndz_sliced, ell): """This function calculats auto- and cross-power spectra for given sliced galaxy-redshift distribution.""" n = len(dndz_sliced) lens = [[]] * n for i, dndz in enumerate(dndz_sliced.values()): lens[i] = ccl.WeakLensingTracer(cosmo, dndz=(dndz[:, 0], dndz[:, 1])) #create an empty n-by-n array that stores the lensing cross power spectrum between the ith and jth bin cl = [] for j in range(n): cl.extend( ccl.angular_cl(cosmo, lens[j], lens[j + i], ell) for i in range(n - j)) cl_arr = np.array(cl) return cl_arr
def get_ccl_tracer(tr): if tr == 'galaxy_density': z, nz = np.loadtxt('xcell/tests/data/DESY1gc_dndz_bin0.txt', usecols=(1, 3), unpack=True) t = ccl.NumberCountsTracer(cosmo, False, dndz=(z, nz), bias=(z, np.ones_like(z)), mag_bias=(z, np.ones_like(z))) elif tr == 'galaxy_shear': z, nz = np.loadtxt('xcell/tests/data/Nz_DIR_z0.1t0.3.asc', usecols=(0, 1), unpack=True) t = ccl.WeakLensingTracer(cosmo, dndz=(z, nz)) elif tr == 'cmb_convergence': t = ccl.CMBLensingTracer(cosmo, z_source=1100.) return t
def get_tracers_ccl(cosmo, tracers_info): # Get Tracers for tr in tracers_info['maps']: if tr['type'] == 'gc': # Import z, pz fname = os.path.join(files_root, tr['dndz_file']) z, pz = np.loadtxt(fname, usecols=(1, 3), unpack=True) # Calculate z bias dz = 0 z_dz = z - dz # Set to 0 points where z_dz < 0: sel = z_dz >= 0 z_dz = z_dz[sel] pz = pz[sel] # Calculate bias bias = tr['bias'] bz = bias * np.ones(z.shape) # Get tracer tr['tracer'] = ccl.NumberCountsTracer(cosmo, has_rsd=False, dndz=(z_dz, pz), bias=(z, bz)) elif tr['type'] == 'wl': # Import z, pz fname = os.path.join(files_root, tr['dndz_file']) z, pz = np.loadtxt(fname, usecols=(1, 3), unpack=True) # Calculate z bias dz = 0 z_dz = z - dz # Set to 0 points where z_dz < 0: sel = z_dz >= 0 z_dz = z_dz[sel] pz = pz[sel] # # Calculate bias IA # A = # eta = # z0 = # bz = A*((1.+z)/(1.+z0))**eta*0.0139/0.013872474 # pyccl2 -> has already the factor inside. Only needed bz # Get tracer tr['tracer'] = ccl.WeakLensingTracer(cosmo, dndz=(z_dz, pz)) # ,ia_bias=(z,bz)) elif tr['type'] == 'cv': tr['tracer'] = ccl.CMBLensingTracer( cosmo, z_source=1100) #TODO: correct z_source else: raise ValueError( 'Type of tracer not recognized. It can be gc, wl or cv!')
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 run(self, inputs): cosmo = ccl.Cosmology(Omega_c=inputs["Omega_c"], Omega_b=inputs["Omega_b"], h=inputs["h"], n_s=inputs["n_s"], A_s=inputs["A_s"], T_CMB=2.7255, m_nu=inputs["m_nu"], transfer_function=self.transfer_function, matter_power_spectrum=self.matter_pk, baryons_power_spectrum=self.baryons_pk) if not self.run_boltzmann: # Ingest pre-calculated distances cosmo._set_background_from_arrays(a_array=inputs["a_bg"], chi_array=inputs["distance"], hoh0_array=inputs["E_of_z"]) # Ingest pre-calculated P(k) cosmo._set_linear_power_from_arrays(inputs["a_lin"], inputs["k_lin"], inputs["Pk_lin"]) cosmo._set_nonlin_power_from_arrays(inputs["a_nl"], inputs["k_nl"], inputs["Pk_nl"]) data_type = 'galaxy_shear_cl_ee' nz_info = inputs['nz'] ia_info = inputs['ia'] tracers = {} for b in self.tracer_names[data_type]: tracers[data_type, b] = ccl.WeakLensingTracer( cosmo, nz_info[b], ia_bias=ia_info[b] ) results = {} results[data_type] = {} for bin1, bin2 in self.calculations[data_type]: ell = self.ell[data_type][bin1, bin2] T1 = tracers[data_type, bin1] T2 = tracers[data_type, bin2] cl = ccl.angular_cl(cosmo, T1, T2, ell) results[data_type][bin1, bin2] = cl return results
def euclid_ccl(Omega_c, sigma8): """ Generate C_ell as function of ell for a given Omega_c and Sigma8 Assumes a redshift distribution given by z^alpha * exp(z/z0)^beta with alpha=1.3, beta = 1.5 and z0 = 0.65 Assumes photo-z error is Gaussian with a bias is 0.05(1+z) """ cosmo_fid = ccl.Cosmology(Omega_c=Omega_c, Omega_b=0.045, h=0.71, sigma8=sigma8, n_s=0.963) ell = np.logspace(np.log10(100), np.log10(6000), 10) pz = ccl.PhotoZGaussian(sigma_z0=0.05) dNdz_true = ccl.dNdzSmail(alpha=1.3, beta=1.5, z0=0.65) dNdzs = np.zeros((nbins, z.size)) shears = [] for i in range(nbins): # edges of nbins equal width redshift bins, between 0 and 2 zmin, zmax = i * (2. / nbins), (i + 1) * (2. / nbins) # generate dNdz per bin dNdzs[i, :] = ccl.dNdz_tomog(z=z, zmin=zmin, zmax=zmax, pz_func=pz, dNdz_func=dNdz_true) # calculate the shear per bin gal_shapes = ccl.WeakLensingTracer(cosmo_fid, dndz=(z, dNdzs[i, :])) shears.append(gal_shapes) # calculate nbin*(nbin+1)/2 spectra from the shears Cls = [] bin_indices = [ ] # list of length nbin*(nbin+1)/2 containing tuples with the indices of the bins for i in range(nbins): for j in range(0, i + 1): bin_indices.append((i, j)) Cls.append(ccl.angular_cl(cosmo_fid, shears[i], shears[j], ell)) return ell, np.array(Cls), dNdzs, bin_indices
def euclid_ccl(Omega_c, Omega_b=0.045, sigma8=0.83, n_s=0.963, h=0.71, mps='halofit'): """ Generate C_ell as function of ell for a given Omega_c and Sigma8 Inputs Omega_c -- float: CDM density Sigma_8 -- float: sigma_8 mps -- string: model to use for matter power spectrum Assumed global variables z -- np.array: samples of z ells -- np.array: samples of ell dNdz_true -- ccl.dNdzSmail: dNdz distribution pz -- ccl.PhotoZGaussian: PhotoZ error nbins -- the amount of tomographic redshift bins Outputs Cls -- np.array, shape (nbins*(nbins-1)/2 + nbins, len(ell)): Cross/Auto correlation shear spectra for the tomographic bins dNdzs -- np.array, shape (nbins,len(z): dNdz per redshift bin, for all redshifts """ cosmo_fid = ccl.Cosmology(Omega_c=Omega_c, Omega_b=Omega_b, h=h, sigma8=sigma8, n_s=n_s, matter_power_spectrum=mps) dNdzs = np.zeros((nbins, z.size)) shears = [] for i in range(nbins): # edges of 2 redshift bins zmin_b, zmax_b = zbins[i] print (f'Redshift bin {i}: {zmin_b} - {zmax_b}') # generate dNdz per bin dNdzs[i,:] = ccl.dNdz_tomog(z=z, zmin=zmin_b, zmax=zmax_b, pz_func=pz, dNdz_func = dNdz_true) # calculate the shear per bin gal_shapes = ccl.WeakLensingTracer(cosmo_fid, dndz=(z, dNdzs[i,:])) shears.append(gal_shapes) # calculate nbin*(nbin+1)/2 = 3 spectra from the shears Cls = [] for i in range(nbins): for j in range(0,i+1): Cls.append(ccl.angular_cl(cosmo_fid, shears[i], shears[j], ells)) return np.array(Cls), dNdzs