def _get_theory(self, **params_values): cosmo = self.provider.get_CCL()['cosmo'] tracer_g = ccl.NumberCountsTracer( cosmo, has_rsd=False, dndz=self.dndz.T, bias=(self.dndz[:, 0], params_values['b1'] * np.ones(len(self.dndz[:, 0]))), mag_bias=(self.dndz[:, 0], params_values['s1'] * np.ones(len(self.dndz[:, 0])))) tracer_k = ccl.CMBLensingTracer(cosmo, z_source=1060) cl_gg = ccl.cls.angular_cl(cosmo, tracer_g, tracer_g, self.ell_auto) # + 1e-7 cl_kg = ccl.cls.angular_cl(cosmo, tracer_k, tracer_g, self.ell_cross) return np.concatenate([cl_gg, cl_kg])
def _get_cl_ccl(self, dtype): ls = np.arange(3 * self.nside) if dtype == 'galaxy_density': z, nz = self.get_nz() b = np.ones_like(z) tracer = ccl.NumberCountsTracer(self.cosmo, has_rsd=False, dndz=(z, nz), bias=(z, b)) elif dtype == 'galaxy_shear': z, nz = self.get_nz() tracer = ccl.WeakLensingTracer(self.cosmo, dndz=(z, nz)) elif dtype == 'cmb_convergence': tracer = ccl.CMBLensingTracer(self.cosmo, z_source=1100) elif dtype == 'cmb_tSZ': # Note that the tSZ power spectrum implemented here is wrong # But it's not worth for now adding all the halo model stuff. tracer = ccl.tSZTracer(self.cosmo, z_max=3.) return ccl.angular_cl(self.cosmo, tracer, tracer, ls)
def logp(self, **params_values): kh, z, PK = self.provider.get_Pk_grid(("delta_tot", "delta_tot"), nonlinear=True) self.wrapper.chi = self.provider.get_comoving_radial_distance(z) self.wrapper.hubble = self.provider.get_Hubble(z) H0 = self.wrapper.hubble[0] h = H0 / 100. self.wrapper.z = z self.wrapper.k = kh #*h self.wrapper.pk = PK #/h**3. self.wrapper.start_ccl() lens = ccl.CMBLensingTracer(self.wrapper.cosmo_ccl, z_source=1100.) cls_theory = ccl.angular_cl(self.wrapper.cosmo_ccl, lens, lens, self.ell) #, p_of_k_a=pk2d) chi2 = (self.cls - cls_theory)**2. / self.dcls**2. return -0.5 * np.sum(chi2)
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 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 get_tracer(tracer_type): 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)) elif tracer_type == 'wl': ntr = 2 tr = ccl.WeakLensingTracer(COSMO, dndz=(z, n), ia_bias=(z, b)) elif tracer_type == 'cl': ntr = 1 tr = ccl.CMBLensingTracer(COSMO, 1100.) else: ntr = 0 tr = ccl.Tracer() return tr, ntr
def _get_tracer(self, cosmo, name, **pars): # Get CCL tracer for tracer with name `name` if 'cv' not in name: nz = self._get_nz(cosmo, name, **pars) if 'gc' in name or 'eBOSS' in name or 'DECALS' in name: # eBOSS, DECALS also gc bz = self._get_bz(cosmo, name, **pars) if '_s' in name: # Magnification bias mag_bias = self._get_mag(cosmo, name, **pars) else: mag_bias = None t = ccl.NumberCountsTracer(cosmo, dndz=nz, bias=bz, has_rsd=False, mag_bias=mag_bias) elif 'wl' in name or 'KiDS1000' in name: ia = self._get_ia_bias(cosmo, name, **pars) t = ccl.WeakLensingTracer(cosmo, nz, ia_bias=ia) elif 'cv' in name: # B.H. TODO: pass z_source as parameter to the YAML file t = ccl.CMBLensingTracer(cosmo, z_source=1100) return t
def test_clfid_halomod_M500c(): tr1 = 'cmb_tSZ' tr2 = 'cmb_convergence' data = get_config(dtype0=tr1, dtype1=tr2, inc_hm=True) data['cov']['fiducial']['halo_model'] = {'mass_def': '500c', 'concentration': 'Duffy08M500c'} data['tracers']['Dummy__0']['gnfw_params'] = {'mass_bias': 0.9} cosmo = ccl.Cosmology(**data['cov']['fiducial']['cosmo']) md = ccl.halos.MassDef(500, 'critical') mf = ccl.halos.MassFuncTinker10(cosmo, mass_def=md) hb = ccl.halos.HaloBiasTinker10(cosmo, mass_def=md) cm = ConcentrationDuffy08M500c(mdef=md) hmc = ccl.halos.HMCalculator(cosmo, mf, hb, md) prof1 = ccl.halos.HaloProfilePressureGNFW(mass_bias=0.9) ccltr1 = ccl.tSZTracer(cosmo, z_max=3.) prof2 = ccl.halos.HaloProfileNFW(cm) ccltr2 = ccl.CMBLensingTracer(cosmo, z_source=1100.) 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, 6., 30)[::-1]) pk = ccl.halos.halomod_Pk2D(cosmo, hmc, prof1, prof2=prof2, normprof1=False, normprof2=True, 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, ccltr1, ccltr2, d['ell'], p_of_k_a=pk) assert np.all(np.fabs(clb[2:]/d['cl'][0][2:]-1) < 1E-4)
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 check_cls_nu(cosmo): """ Check that cls functions can be run. """ # Number density input z = np.linspace(0., 1., 200) n = np.exp(-((z - 0.5) / 0.1)**2) # Bias input b = np.sqrt(1. + z) # ell range input ell_scl = 4 ell_lst = [2, 3, 4, 5, 6, 7, 8, 9] ell_arr = np.arange(2, 10) # Check if power spectrum type is valid for CMB cmb_ok = True if cosmo._config.matter_power_spectrum_method \ == ccl.core.matter_power_spectrum_types['emu']: cmb_ok = False # ClTracer test objects lens1 = ccl.WeakLensingTracer(cosmo, dndz=(z, n)) lens2 = ccl.WeakLensingTracer(cosmo, dndz=(z, n), ia_bias=(z, n), red_frac=(z, n)) nc1 = ccl.NumberCountsTracer(cosmo, False, dndz=(z, n), bias=(z, b)) # Check that for massive neutrinos including rsd raises an error (not yet implemented) assert_raises(CCLError, ccl.NumberCountsTracer, cosmo, True, dndz=(z, n), bias=(z, b)) cmbl = ccl.CMBLensingTracer(cosmo, 1100.) # Check valid ell input is accepted assert_(all_finite(ccl.angular_cl(cosmo, lens1, lens1, ell_scl))) assert_(all_finite(ccl.angular_cl(cosmo, lens1, lens1, ell_lst))) assert_(all_finite(ccl.angular_cl(cosmo, lens1, lens1, ell_arr))) assert_(all_finite(ccl.angular_cl(cosmo, nc1, nc1, ell_scl))) assert_(all_finite(ccl.angular_cl(cosmo, nc1, nc1, ell_lst))) assert_(all_finite(ccl.angular_cl(cosmo, nc1, nc1, ell_arr))) if cmb_ok: assert_(all_finite(ccl.angular_cl(cosmo, cmbl, cmbl, ell_arr))) # Check various cross-correlation combinations assert_(all_finite(ccl.angular_cl(cosmo, lens1, lens2, ell_arr))) assert_(all_finite(ccl.angular_cl(cosmo, lens1, nc1, ell_arr))) if cmb_ok: assert_(all_finite(ccl.angular_cl(cosmo, lens1, cmbl, ell_arr))) assert_(all_finite(ccl.angular_cl(cosmo, lens2, nc1, ell_arr))) if cmb_ok: assert_(all_finite(ccl.angular_cl(cosmo, lens2, cmbl, ell_arr))) if cmb_ok: assert_(all_finite(ccl.angular_cl(cosmo, nc1, cmbl, ell_arr))) # Check that reversing order of ClTracer inputs works assert_(all_finite(ccl.angular_cl(cosmo, nc1, lens1, ell_arr))) assert_(all_finite(ccl.angular_cl(cosmo, nc1, lens2, ell_arr))) # Check get_internal_function() a_scl = 0.5 a_lst = [0.2, 0.4, 0.6, 0.8, 1.] a_arr = np.linspace(0.2, 1., 5) assert_(all_finite(nc1.get_internal_function(cosmo, 'dndz', a_scl))) assert_(all_finite(nc1.get_internal_function(cosmo, 'dndz', a_lst))) assert_(all_finite(nc1.get_internal_function(cosmo, 'dndz', a_arr))) # Check that invalid options raise errors assert_raises(ValueError, nc1.get_internal_function, cosmo, 'x', a_arr) assert_raises(CCLError, ccl.NumberCountsTracer, cosmo, True, dndz=(z, n), bias=(z, b)) assert_raises(ValueError, ccl.WeakLensingTracer, cosmo, dndz=(z, n), ia_bias=(z, n))
def check_cls(cosmo): """ Check that cls functions can be run. """ # Number density input z = np.linspace(0., 1., 200) n = np.exp(-((z - 0.5) / 0.1)**2) # Bias input b = np.sqrt(1. + z) # ell range input ell_scl = 4 ell_lst = [2, 3, 4, 5, 6, 7, 8, 9] ell_arr = np.arange(2, 10) # Check if power spectrum type is valid for CMB cmb_ok = True if cosmo._config.matter_power_spectrum_method \ == ccl.core.matter_power_spectrum_types['emu']: cmb_ok = False # ClTracer test objects lens1 = ccl.WeakLensingTracer(cosmo, (z, n)) lens2 = ccl.WeakLensingTracer(cosmo, dndz=(z, n), ia_bias=(z, n), red_frac=(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.) assert_raises(ValueError, ccl.WeakLensingTracer, cosmo, None) # Check valid ell input is accepted assert_(all_finite(ccl.angular_cl(cosmo, lens1, lens1, ell_scl))) assert_(all_finite(ccl.angular_cl(cosmo, lens1, lens1, ell_lst))) assert_(all_finite(ccl.angular_cl(cosmo, lens1, lens1, ell_arr))) assert_(all_finite(ccl.angular_cl(cosmo, nc1, nc1, ell_scl))) assert_(all_finite(ccl.angular_cl(cosmo, nc1, nc1, ell_lst))) assert_(all_finite(ccl.angular_cl(cosmo, nc1, nc1, ell_arr))) if cmb_ok: assert_(all_finite(ccl.angular_cl(cosmo, cmbl, cmbl, ell_arr))) # Check non-limber calculations assert_(all_finite(ccl.angular_cl(cosmo, nc1, nc1, ell_arr, l_limber=20))) # Non-Limber only implemented for number counts assert_raises(CCLError, ccl.angular_cl, cosmo, lens1, lens1, ell_arr, l_limber=20) # Check various cross-correlation combinations assert_(all_finite(ccl.angular_cl(cosmo, lens1, lens2, ell_arr))) assert_(all_finite(ccl.angular_cl(cosmo, lens1, nc1, ell_arr))) assert_(all_finite(ccl.angular_cl(cosmo, lens1, nc2, ell_arr))) assert_(all_finite(ccl.angular_cl(cosmo, lens1, nc3, ell_arr))) if cmb_ok: assert_(all_finite(ccl.angular_cl(cosmo, lens1, cmbl, ell_arr))) assert_(all_finite(ccl.angular_cl(cosmo, lens2, nc1, ell_arr))) assert_(all_finite(ccl.angular_cl(cosmo, lens2, nc2, ell_arr))) assert_(all_finite(ccl.angular_cl(cosmo, lens2, nc3, ell_arr))) if cmb_ok: assert_(all_finite(ccl.angular_cl(cosmo, lens2, cmbl, ell_arr))) assert_(all_finite(ccl.angular_cl(cosmo, nc1, nc2, ell_arr))) assert_(all_finite(ccl.angular_cl(cosmo, nc1, nc3, ell_arr))) if cmb_ok: assert_(all_finite(ccl.angular_cl(cosmo, nc1, cmbl, ell_arr))) assert_(all_finite(ccl.angular_cl(cosmo, nc2, nc3, ell_arr))) if cmb_ok: assert_(all_finite(ccl.angular_cl(cosmo, nc2, cmbl, ell_arr))) if cmb_ok: assert_(all_finite(ccl.angular_cl(cosmo, nc3, cmbl, ell_arr))) # Check that reversing order of ClTracer inputs works assert_(all_finite(ccl.angular_cl(cosmo, nc1, lens1, ell_arr))) assert_(all_finite(ccl.angular_cl(cosmo, nc1, lens2, ell_arr)))
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 compute_tracer_ccl(self, name, tracer, mapper): cosmo = self.get_cosmo_ccl() hm_par = self.get_halomodel_params() dtype = mapper.get_dtype() ccl_pr = hm_par['prof_NFW'] ccl_pr_2pt = hm_par['prof_2pt'] with_hm = tracer.get('use_halo_model', False) normed_profile = True # Get Tracers if dtype == 'galaxy_density': # Import z, pz z, pz = mapper.get_nz(dz=0) bias = (z, np.ones_like(z)) mag_bias = None mag_s = tracer.get('magnif_s', None) if mag_s: mag_bias = (z, np.ones_like(z) * mag_s) # Get tracer ccl_tr = ccl.NumberCountsTracer(cosmo, has_rsd=False, dndz=(z, pz), bias=bias, mag_bias=mag_bias) if with_hm: hod_pars = tracer.get('hod_params', {}) ccl_pr = ccl.halos.HaloProfileHOD(hm_par['cM'], **hod_pars) ccl_pr_2pt = ccl.halos.Profile2ptHOD() elif dtype == 'galaxy_shear': # Import z, pz z, pz = mapper.get_nz(dz=0) # # Calculate bias IA ia_bias = None if self.config['wl_ia']: # TODO: Improve this in yml file A, eta, z0 = self.config['wl_ia'] # pyccl2 -> has already the factor inside. Only needed bz bz = A * ((1. + z) / (1. + z0))**eta * 0.0139 / 0.013872474 ia_bias = (z, bz) # Get tracer ccl_tr = ccl.WeakLensingTracer(cosmo, dndz=(z, pz), ia_bias=ia_bias) elif dtype == 'cmb_convergence': # TODO: correct z_source ccl_tr = ccl.CMBLensingTracer(cosmo, z_source=1100) elif dtype == 'cmb_tSZ': normed_profile = False ccl_tr = ccl.tSZTracer(cosmo, z_max=3.) if with_hm: pars = tracer.get('gnfw_params', {}) ccl_pr = ccl.halos.HaloProfilePressureGNFW(**pars) else: raise ValueError('Type of tracer not recognized. It can be \ galaxy_density, galaxy_shear, cmb_tSZ, or \ cmb_convergence!') return { 'name': name, 'ccl_tr': ccl_tr, 'ccl_pr': ccl_pr, 'ccl_pr_2pt': ccl_pr_2pt, 'with_hm': with_hm, 'normed': normed_profile }
def test_xcorr(theory): params = {'b1': 1.0, 's1': 0.4} model = get_demo_xcorr_model(theory) lnl = model.loglike(params)[0] assert np.isfinite(lnl) xcorr_lhood = model.likelihood['soliket.XcorrLikelihood'] setup_chi_out = xcorr_lhood._setup_chi() Pk_interpolator = xcorr_lhood.theory.get_Pk_interpolator(("delta_nonu", "delta_nonu"), extrap_kmax=1.e8, nonlinear=False).P from soliket.xcorr.limber import do_limber cl_gg, cl_kappag = do_limber(xcorr_lhood.ell_range, xcorr_lhood.provider, xcorr_lhood.dndz, xcorr_lhood.dndz, params['s1'], params['s1'], Pk_interpolator, params['b1'], params['b1'], xcorr_lhood.alpha_auto, xcorr_lhood.alpha_cross, setup_chi_out, Nchi=xcorr_lhood.Nchi, dndz1_mag=xcorr_lhood.dndz, dndz2_mag=xcorr_lhood.dndz) ell_load = xcorr_lhood.data.x cl_load = xcorr_lhood.data.y # cov_load = xcorr_lhood.data.cov # cl_err_load = np.sqrt(np.diag(cov_load)) n_ell = len(ell_load) // 2 ell_obs_gg = ell_load[n_ell:] ell_obs_kappag = ell_load[:n_ell] cl_obs_gg = cl_load[:n_ell] cl_obs_kappag = cl_load[n_ell:] # Nell_unwise_g = np.ones_like(cl_gg) \ # / (xcorr_lhood.ngal * (60 * 180 / np.pi)**2) Nell_obs_unwise_g = np.ones_like(cl_obs_gg) \ / (xcorr_lhood.ngal * (60 * 180 / np.pi)**2) import pyccl as ccl h2 = (xcorr_lhood.provider.get_param('H0') / 100)**2 cosmo = ccl.Cosmology(Omega_c=xcorr_lhood.provider.get_param('omch2') / h2, Omega_b=xcorr_lhood.provider.get_param('ombh2') / h2, h=xcorr_lhood.provider.get_param('H0') / 100, n_s=xcorr_lhood.provider.get_param('ns'), A_s=xcorr_lhood.provider.get_param('As'), Omega_k=xcorr_lhood.provider.get_param('omk'), Neff=xcorr_lhood.provider.get_param('nnu'), matter_power_spectrum='linear') g_bias_zbz = (xcorr_lhood.dndz[:, 0], params['b1'] * np.ones(len(xcorr_lhood.dndz[:, 0]))) mag_bias_zbz = (xcorr_lhood.dndz[:, 0], params['s1'] * np.ones(len(xcorr_lhood.dndz[:, 0]))) tracer_g = ccl.NumberCountsTracer(cosmo, has_rsd=False, dndz=xcorr_lhood.dndz.T, bias=g_bias_zbz, mag_bias=mag_bias_zbz) tracer_k = ccl.CMBLensingTracer(cosmo, z_source=1100) cl_gg_ccl = ccl.cls.angular_cl(cosmo, tracer_g, tracer_g, xcorr_lhood.ell_range) cl_kappag_ccl = ccl.cls.angular_cl(cosmo, tracer_k, tracer_g, xcorr_lhood.ell_range) assert np.allclose(cl_gg_ccl, cl_gg) assert np.allclose(cl_kappag_ccl, cl_kappag) cl_obs_gg_ccl = ccl.cls.angular_cl(cosmo, tracer_g, tracer_g, ell_obs_gg) cl_obs_kappag_ccl = ccl.cls.angular_cl(cosmo, tracer_k, tracer_g, ell_obs_kappag) assert np.allclose(cl_obs_gg_ccl + Nell_obs_unwise_g, cl_obs_gg) assert np.allclose(cl_obs_kappag_ccl, cl_obs_kappag)
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
def _setup_tracers(self): logger.info('Setting up tracers.') p = self.params self._setup_systematics() ccl_tracer_dict = {} for i, tracer in enumerate(self.tracer_list): if tracer.quantity == 'galaxy_density' or tracer.quantity == 'delta_g': if tracer.quantity == 'delta_g': logger.warning( 'tracer quantity {} will be deprecated soon.'.format( tracer.quantity)) split_name = tracer.name.split('_') if len(split_name) == 2: tracer_no = split_name[1] # Bias if 'bb_{}'.format(tracer_no) in p.keys(): logger.info( 'Galaxy bias array provided for {}.'.format( tracer.name)) bias_tup = (p['bz_{}'.format(tracer_no)], p['bb_{}'.format(tracer_no)]) else: logger.info( 'Galaxy bias array not provided for {}. Setting to unity.' .format(tracer.name)) bias_tup = (tracer.z, np.ones_like(tracer.z)) # z_shift parameter if ('zshift_bin{}'.format(tracer_no) in p.keys()) and ('zwidth_bin{}'.format(tracer_no) in p.keys()): zbins = (tracer.z - self.z_c['zwidth_bin{}'.format(tracer_no)]) * ( 1 + p['zwidth_bin{}'.format(tracer_no)]) + \ p['zshift_bin{}'.format(tracer_no)] + self.z_c['zwidth_bin{}'.format(tracer_no)] elif 'zshift_bin{}'.format(tracer_no) in p.keys(): zbins = tracer.z + p['zshift_bin{}'.format(tracer_no)] else: zbins = tracer.z else: # Bias if 'bb' in p.keys(): logger.info( 'Galaxy bias array provided for {}.'.format( tracer.name)) bias_tup = (p['bz'], p['bb']) else: logger.info( 'Galaxy bias array not provided for {}. Setting to unity.' .format(tracer.name)) bias_tup = (tracer.z, np.ones_like(tracer.z)) # z_shift parameter if ('zshift_bin' in p.keys()) and ('zwidth_bin' in p.keys()): zbins = (tracer.z - self.z_c['zwidth_bin']) * ( 1 + p['zwidth_bin']) + \ p['zshift_bin'] + self.z_c['zwidth_bin'] elif 'zshift_bin' in p.keys(): zbins = tracer.z + p['zshift_bin'] else: zbins = tracer.z # pz method if 'pzMethod' in p.keys(): if p['pzMethod'] != 'COSMOS30': nz = tracer.extra_columns[p['pzMethod']] else: nz = tracer.nz else: nz = tracer.nz if p['HODmod'] == 'zevol': ccl_tracer_dict[tracer.name] = { 'ccl_tracer': ccl.NumberCountsTracer( self.cosmo, False, (zbins[zbins >= 0.], nz[zbins >= 0.]), bias=bias_tup), 'prof': self.pg } else: ccl_tracer_dict[tracer.name] = { 'ccl_tracer': ccl.NumberCountsTracer( self.cosmo, False, (zbins[zbins >= 0.], nz[zbins >= 0.]), bias=bias_tup), 'prof': hod.HaloProfileHOD(c_M_relation=self.cM, lMmin=p['mmin'], lMminp=p['mminp'], lM0=p['m0'], lM0p=p['m0p'], lM1=p['m1'], lM1p=p['m1p']) } elif tracer.quantity == 'cmb_tSZ' or tracer.quantity == 'Compton_y': if tracer.quantity == 'Compton_y': logger.warning( 'tracer quantity {} will be deprecated soon.'.format( tracer.quantity)) ccl_tracer_dict[tracer.name] = { 'ccl_tracer': sz.SZTracer(self.cosmo), 'prof': self.py } elif tracer.quantity == 'cmb_convergence' or tracer.quantity == 'kappa': if tracer.quantity == 'kappa': logger.warning( 'tracer quantity {} will be deprecated soon.'.format( tracer.quantity)) ccl_tracer_dict[tracer.name] = { 'ccl_tracer': ccl.CMBLensingTracer(self.cosmo, z_source=1150), 'prof': self.pM } elif tracer.quantity == 'galaxy_shear' or tracer.quantity == 'cosmic_shear': if tracer.quantity == 'cosmic_shear': logger.warning( 'tracer quantity {} will be deprecated soon.'.format( tracer.quantity)) split_name = tracer.name.split('_') if len(split_name) == 2: tracer_no = split_name[1] # z_shift parameter if ('zshift_bin{}'.format(tracer_no) in p.keys()) and ('zwidth_bin{}'.format(tracer_no) in p.keys()): zbins = (tracer.z - self.z_c['zwidth_bin{}'.format(tracer_no)]) * ( 1 + p['zwidth_bin{}'.format(tracer_no)]) + \ p['zshift_bin{}'.format(tracer_no)] + self.z_c['zwidth_bin{}'.format(tracer_no)] elif 'zshift_bin{}'.format(tracer_no) in p.keys(): zbins = tracer.z + p['zshift_bin{}'.format(tracer_no)] else: zbins = tracer.z else: # z_shift parameter if ('zshift_bin' in p.keys()) and ('zwidth_bin' in p.keys()): zbins = (tracer.z - self.z_c['zwidth_bin']) * ( 1 + p['zwidth_bin']) + \ p['zshift_bin'] + self.z_c['zwidth_bin'] elif 'zshift_bin' in p.keys(): zbins = tracer.z + p['zshift_bin'] else: zbins = tracer.z # pz method if 'pzMethod' in p.keys(): if p['pzMethod'] != 'COSMOS30': nz = tracer.extra_columns[p['pzMethod']] else: nz = tracer.nz else: nz = tracer.nz if 'm_bin{}'.format(tracer_no) in p.keys(): ccl_tracer_dict[tracer.name] = { 'ccl_tracer': ccl.WeakLensingTracer( self.cosmo, (zbins[zbins >= 0.], nz[zbins >= 0.])), 'prof': self.pM, 'm': p['m_bin{}'.format(tracer_no)] } else: ccl_tracer_dict[tracer.name] = { 'ccl_tracer': ccl.WeakLensingTracer( self.cosmo, (zbins[zbins >= 0.], nz[zbins >= 0.])), 'prof': self.pM } else: raise NotImplementedError( 'Only tracers galaxy_density, cmb_tSZ, cmb_convergence and galaxy_shear supported. Aborting.' ) self.ccl_tracers = ccl_tracer_dict
, dNdz_func=redshift_dist) for zi in range(0, len(z_pz)-1)] # galaxy lensing dNdz_len = [ccl.dNdz_tomog(z=z, zmin=z_pz[zi], zmax=z_pz[zi+1], pz_func=pz , dNdz_func=redshift_dist) for zi in range(0, len(z_pz)-1)] # assume linear bias bias = 2.*np.ones(len(z)) gal_counts = ([ccl.NumberCountsTracer(cosmo, has_rsd=False, dndz=(z, dNdz_nc[zi]), bias=(z, bias)) for zi in range(0, len(z_pz)-1)]) gal_lens = ([ccl.WeakLensingTracer(cosmo, dndz=(z, dNdz_len[zi])) for zi in range(0, len(z_pz)-1)]) # tracer objects for CMB lensing cmb_lens = [ccl.CMBLensingTracer(cosmo, z_source=1089.)] all_tracers = gal_counts + gal_lens + cmb_lens ell = np.linspace(1, 2000, 2000) n_tracer = len(all_tracers) c_ells = ([[ccl.angular_cl(cosmo, all_tracers[ni], all_tracers[nj], ell) for ni in range(0, n_tracer)] for nj in range(0, n_tracer)]) # 2 galaxy count bins + 2 galaxy lens bins + 1 cmb lens bin = 5 tracers # np.shape(c_ells) : (5, 5, 2000) plt.figure() plt.loglog(ell, c_ells[0][0], 'k', linewidth=2, label='gg bin 1 auto')
import numpy as np import pyccl as ccl from ccl_cobaya.ccl_camb_wrapper import * wrapper = CCL_CAMB_Wrapper() wrapper.get_camb_pk() wrapper.get_camb_background() wrapper.start_ccl() #cosmo = ccl.Cosmology( # Omega_c=0.27, Omega_b=0.045, h=0.67, A_s=2.1e-9, n_s=0.965, # transfer_function='bbks') lens1 = ccl.CMBLensingTracer(wrapper.cosmo_ccl, z_source=1100.) ell = np.logspace(np.log10(2), np.log10(2000), 50, dtype=int) ell = np.unique(ell) cls = ccl.angular_cl(wrapper.cosmo_ccl, lens1, lens1, ell) dcls = 0.1 * cls # Add some noise noise = np.random.normal(loc=0.0, scale=0.1, size=len(ell)) #cls *= (1 + noise) np.save("./ccl_cobaya/data/cls.npy", cls) np.save("./ccl_cobaya/data/dcls.npy", dcls) np.save("./ccl_cobaya/data/ell.npy", ell)