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)
