def check_cls(cosmo):
"""
Check that cls functions can be run.
"""
# Number density input
z = np.linspace(0., 1., 200)
n = np.ones(z.shape)
# 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)
# ClTracer test objects
lens1 = ccl.ClTracerLensing(cosmo, False, n=n, z=z)
lens2 = ccl.ClTracerLensing(cosmo, True, n=(z,n), bias_ia=(z,n), f_red=(z,n))
nc1 = ccl.ClTracerNumberCounts(cosmo, False, False, n=(z,n), bias=(z,b))
nc2 = ccl.ClTracerNumberCounts(cosmo, True, False, n=(z,n), bias=(z,b))
nc3 = ccl.ClTracerNumberCounts(cosmo, True, True, n=(z,n), bias=(z,b),
mag_bias=(z,b))
cmbl=ccl.ClTracerCMBLensing(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)) )
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)) )
assert_( all_finite(ccl.angular_cl(cosmo, lens1, nc2, ell_arr)) )
assert_( all_finite(ccl.angular_cl(cosmo, lens1, nc3, ell_arr)) )
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)) )
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)) )
assert_( all_finite(ccl.angular_cl(cosmo, nc1, cmbl, ell_arr)) )
assert_( all_finite(ccl.angular_cl(cosmo, nc2, nc3, ell_arr)) )
assert_( all_finite(ccl.angular_cl(cosmo, nc2, cmbl, ell_arr)) )
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 get_tracers(self, cosmo, dic_par):
tr_out = []
has_rsd = dic_par.get('has_rds', False)
has_magnification = dic_par.get('has_magnification', False)
for (tr_index, thistracer) in enumerate(self.s.tracers):
if thistracer.type.__contains__('point'):
try:
z_b_arr = dic_par[thistracer.exp_sample + '_z_b']
b_b_arr = dic_par[thistracer.exp_sample + '_b_b']
except:
raise ValueError("bias needed for each tracer")
if 'zshift_bin' + str(tr_index) in dic_par:
zbins = thistracer.z + dic_par['zshift_bin' +
str(tr_index)]
else:
zbins = thistracer.z
bf = interp1d(
z_b_arr, b_b_arr, kind='nearest'
) #Assuming linear interpolation. Decide on extrapolation.
b_arr = bf(
thistracer.z) #Assuming that tracers have this attribute
tr_out.append(
ccl.ClTracerNumberCounts(cosmo,
dic_par['has_rsd'],
dic_par['has_magnification'],
z=thistracer.z,
n=(zbins, thistracer.Nz),
bias=(z_b_arr, b_b_arr)))
else:
raise ValueError("Only \"point\" tracers supported")
return tr_out
def test_two_point_some(kind, tmpdir):
cosmo = ccl.Cosmology(Omega_c=0.27,
Omega_b=0.045,
Omega_k=0.0,
w0=-1.0,
wa=0.0,
sigma8=0.8,
n_s=0.96,
h=0.67)
sources = {}
for i, mn in enumerate([0.25, 0.75]):
sources['src%d' % i] = DummySource()
z = np.linspace(0, 2, 50)
nz = np.exp(-0.5 * (z - mn)**2 / 0.25 / 0.25)
if ('g' in kind and i == 0) or kind == 'gg':
sources['src%d' % i].tracer_ = ccl.ClTracerNumberCounts(
cosmo,
has_rsd=False,
has_magnification=False,
z=z,
n=nz,
bias=np.ones_like(z) * 2.0)
else:
sources['src%d' % i].tracer_ = ccl.ClTracerLensing(
cosmo, has_intrinsic_alignment=False, z=z, n=nz)
sources['src%d' % i].scale_ = i / 2.0 + 1.0
# compute the statistic
tracers = [v.tracer_ for k, v in sources.items()]
scale = np.prod([v.scale_ for k, v in sources.items()])
data = os.path.join(tmpdir, 'stat.csv')
if kind == 'cl':
ell = np.logspace(1, 3, 10)
cell = ccl.angular_cl(cosmo, *tracers, ell) * scale
pd.DataFrame({'l': ell, 'cl': cell}).to_csv(data, index=False)
else:
theta = np.logspace(1, 2, 100)
ell = _ell_for_xi()
cell = ccl.angular_cl(cosmo, *tracers, ell)
xi = ccl.correlation(cosmo, ell, cell, theta / 60.0,
corr_type=kind) * scale
pd.DataFrame({'t': theta, 'xi': xi}).to_csv(data, index=False)
stat = TwoPointStatistic(data=data, kind=kind, sources=['src0', 'src1'])
stat.compute(cosmo, {}, sources, systematics=None)
if kind == 'cl':
assert np.allclose(stat.measured_statistic_, cell)
else:
assert np.allclose(stat.measured_statistic_, xi)
assert np.allclose(stat.measured_statistic_, stat.predicted_statistic_)
def render(self, cosmo, params, systematics=None):
"""
Render a source by applying systematics.
Parameters
----------
cosmo : pyccl.Cosmology
A pyccl.Cosmology object.
params : dict
A dictionary mapping parameter names to their current values.
systematics : dict
A dictionary mapping systematic names to their objects. The
default of `None` corresponds to no systematics.
"""
systematics = systematics or {}
self.z_ = self._z_orig.copy()
self.nz_ = self._nz_orig.copy()
self.scale_ = self.scale
self.bias_ = np.ones_like(self.z_) * params[self.bias]
if self.has_magnification:
self.mag_bias_ = np.ones_like(self.z_) * params[self.mag_bias]
for systematic in self.systematics:
systematics[systematic].apply(cosmo, params, self)
if self.has_magnification:
tracer = ccl.ClTracerNumberCounts(cosmo,
has_rsd=self.has_rsd,
has_magnification=True,
n=(self.z_, self.nz_),
bias=(self.z_, self.bias_),
mag_bias=(self.z_,
self.mag_bias_))
else:
tracer = ccl.ClTracerNumberCounts(cosmo,
has_rsd=self.has_rsd,
has_magnification=False,
n=(self.z_, self.nz_),
bias=(self.z_, self.bias_))
self.tracer_ = tracer
def sacc2ccl_tracer(t):
if len(t.z) != 1:
toret = ccl.ClTracerNumberCounts(ccl_cosmo,
has_rsd=False,
has_magnification=False,
n=(t.z, t.Nz),
bias=(t.z, t.extraColumn('b')),
mag_bias=(t.z, np.zeros(len(t.z))))
else:
toret = None
return toret
def get_tracers(self, cosmo, dic_par):
tr_out = []
for tr in self.s.tracers:
if tr.type == 'point':
try:
z_b_arr = dic_par[tr.exp_sample + '_z_b']
b_b_arr = dic_par[tr.exp_sample + '_b_b']
except:
raise ValueError("bias needed for each tracer")
bf = interp1d(
z_b_arr, b_b_arr, kind='nearest'
) #Assuming linear interpolation. Decide on extrapolation.
b_arr = bf(tr.z) #Assuming that tracers have this attribute
tr_out.append(
ccl.ClTracerNumberCounts(cosmo, False, False, tr.z, tr.Nz,
tr.z, b_arr))
else:
raise ValueError("Only \"point\" tracers supported")
return tr_out
def getTracers(cosmo, dic_par):
#Create SACC tracers and corresponding CCL tracers
tracers = []
cltracers = []
for i, z in enumerate(zbins):
zar = np.arange(z - 3 * zbin_size, z + 3 * zbin_size, 0.001)
Nz = np.exp(-(z - zar)**2 / (2 * zbin_size**2))
T = sacc.Tracer("des_gals_" + str(i),
"point",
zar,
Nz,
exp_sample="gals",
Nz_sigma_logmean=0.01,
Nz_sigma_logwidth=0.1)
bias = np.ones_like(zar)
T.addColumns({'b': bias})
tracers.append(T)
cltracers.append(
ccl.ClTracerNumberCounts(cosmo, dic_par['has_rsd'],
dic_par['has_magnification'], zar, Nz,
zar, bias))
return tracers, cltracers
plt.plot(zarr_dlo_n12, nzarr_dlo_n12, 'r-')
plt.plot(zarr_dlo_n12b, nzarr_dlo_n12b, 'r--')
plt.plot(zarr_dlo_g16, nzarr_dlo_g16, 'r-.')
plt.plot(zarr_qso_n12, nzarr_qso_n12, 'b-')
plt.plot(zarr_qso_n12b, nzarr_qso_n12b, 'b--')
plt.plot(zarr_qso_g16, nzarr_qso_g16, 'b-.')
plt.plot(zarr_qsu, nzarr_qsu, 'g-')
if not os.path.isfile(outdir + "cls_th.txt"):
cosmo = ccl.Cosmology(Omega_c=0.27,
Omega_b=0.045,
h=0.69,
sigma8=0.83,
n_s=0.96)
clt_dlo_n12 = ccl.ClTracerNumberCounts(cosmo, False, False,
(zarr_dlo_n12, nzarr_dlo_n12),
(zarr_dlo_n12, bzarr_dlo_n12))
clt_qso_n12 = ccl.ClTracerNumberCounts(cosmo, False, False,
(zarr_qso_n12, nzarr_qso_n12),
(zarr_qso_n12, bzarr_qso_n12))
clt_dlo_n12b = ccl.ClTracerNumberCounts(cosmo, False, False,
(zarr_dlo_n12b, nzarr_dlo_n12b),
(zarr_dlo_n12b, bzarr_dlo_n12b))
clt_qso_n12b = ccl.ClTracerNumberCounts(cosmo, False, False,
(zarr_qso_n12b, nzarr_qso_n12b),
(zarr_qso_n12b, bzarr_qso_n12b))
clt_dlo_g16 = ccl.ClTracerNumberCounts(cosmo, False, False,
(zarr_dlo_g16, nzarr_dlo_g16),
(zarr_dlo_g16, bzarr_dlo_g16))
clt_qso_g16 = ccl.ClTracerNumberCounts(cosmo, False, False,
(zarr_qso_g16, nzarr_qso_g16),
def calc_sn(z_phot, z_bins, hsc_z_phot, hsc_ids, matched_pdf_ids, matched_pdfs, n_z, ell, area_in_sr,
plot_cls=True, hsc_z_mc=None, nz_mc=False,
save_plots=False, dont_show_plots=False, filetag=None, outDir=None):
print('-----------------------------------------\nRunning calc_sn for %s bins ... '%(len(z_phot)-1))
if nz_mc:
if hsc_z_mc is None:
raise ValueError('Need either the N(z) or z_mc to estimate dn/dz.')
# set up the bins
z_edges_all = [min(z_bins)] + list(z_phot) + [max(z_bins)] # cover the entire range, even outside the target bins
target_bins, target_bin_ends = get_bins_ends(z_bin_array=z_phot)
all_bins, all_bin_ends = get_bins_ends(z_bin_array=z_edges_all)
print('Target bins: %s'%(target_bins))
print('All bins: %s\n'%(all_bins))
# get dn/dz
dn_dz, num_gals = get_dn_dz(z_edges=z_edges_all, hsc_z_phot=hsc_z_phot,
hsc_ids=hsc_ids, matched_pdf_ids=matched_pdf_ids, matched_pdfs=matched_pdfs,
nz_mc=nz_mc, hsc_z_mc=hsc_z_mc, z_bins=z_bins)
# plot the dn/dz for the different bins
fontsize = 20
plt.clf()
for key in dn_dz:
if key in target_bin_ends:
plt.plot(z_bins, dn_dz[key], lw=4, label=r'** dn_dz: $%s$: %s galaxies'%(key, num_gals[key]))
else:
plt.plot(z_bins, dn_dz[key], lw=4, label=r' dn_dz: $%s$: %s galaxies'%(key, num_gals[key]))
# plot n(z) for reference
plt.plot(z_bins, n_z, 'k-.', label=' n_z', alpha=0.7)
# plot bin edges
ymin, ymax = plt.gca().get_ylim()
for key in target_bin_ends:
for z_edge in target_bin_ends[key]:
plt.plot([z_edge, z_edge], [0, ymax], 'k:', alpha=0.7)
plt.title(filetag, fontsize=fontsize)
plt.gca().tick_params(axis='both', labelsize=fontsize-2)
plt.xlabel('z', fontsize=fontsize)
plt.gcf().set_size_inches(10, 6)
plt.legend(bbox_to_anchor=(1,1), fontsize=fontsize-5)
if save_plots:
filename = '%s_dndz_%sbins.png'%(filetag, len(z_phot)-1)
plt.savefig('%s/%s'%(outDir, filename), format='png', bbox_inches='tight')
print('\n## Saved plot: %s\n'%filename)
if dont_show_plots:
plt.close('all')
else:
plt.show()
# set up ccl
cosmo_fid= ccl.Cosmology(Omega_c=0.25, Omega_b=0.05, h=0.7, sigma8=0.8, n_s=0.96)
bias = 1 + 0.84*z_bins
# calculate the signal matrix
print('Calculating the signal matrix ... ')
S = np.zeros(shape=(len(ell), len(all_bins), len(all_bins)))
for i, bin1_key in enumerate(all_bins):
nc_bin1 = ccl.ClTracerNumberCounts(cosmo_fid, has_rsd=False, has_magnification=False,
n=dn_dz[bin1_key], bias=bias, z=z_bins)
for j, bin2_key in enumerate(all_bins):
nc_bin2= ccl.ClTracerNumberCounts(cosmo_fid, has_rsd=False, has_magnification=False,
n=dn_dz[bin2_key], bias=bias, z=z_bins)
S[:, i, j] = ccl.angular_cl(cosmo_fid, nc_bin1, nc_bin2, ell)
# calculate the noise matrix
print('Calculating the noise matrix ... ')
N = np.zeros(shape=(len(ell), len(all_bins), len(all_bins)))
for i, bin_key in enumerate(all_bins):
zmin, zmax = all_bin_ends[bin_key]
n_obj = len(np.where((hsc_z_phot > zmin) & (hsc_z_phot < zmax))[0])
print('%s objects in %s'%(n_obj, bin_key))
num_density = get_surface_number_density(n_objs=n_obj, area_in_sr=area_in_sr)
N[:, i, i] = 1./num_density
###############################################################################################
# plot all cls
if plot_cls:
plt.clf()
nrow, ncol = 2, 2
fig, axes = plt.subplots(nrow, ncol)
# plot cross spectra
for i, bin1_key in enumerate(all_bins):
# plot auto spectrum and noise
p = axes[0, 0].plot(ell, S[:, i, i], 'o-', label=r'$%s$'%(bin1_key))
axes[1, 0].plot(ell, N[:, i, i], 'o:', color= p[0].get_color(), label='$%s$'%(bin1_key))
# plot cross spectrum
for j, bin2_key in enumerate(all_bins):
if i!=j: # cross spectrum
if j>i:
p = axes[0, 1].plot(ell, S[:, i, j], 'o-', label=r'$%s$ - $%s$'%(bin1_key, bin2_key))
axes[1, 1].plot(ell, N[:, i, j], 'o:', color=p[0].get_color(), label='$%s$ - $%s$'%(bin1_key, bin2_key))
else:
# check to ensure that we really dont need to plot j, i entry.
if (abs(S[:, i, j]-S[:, j, i])>1e-5).any():
print('Somethings wrong. Signal matrix isnt symmetric: S[:, i, j]-S[:, j, i]:\n%s'%(S[:, i, j]-S[:, j, i]))
if (abs(N[:, i, j]-N[:, j, i])>1e-5).any():
print('Somethings wrong. Noise matrix isnt symmetric: N[:, i, j]-N[:, j, i]:\n%s'%(N[:, i, j]-N[:, j, i]))
for row in range(nrow):
for col in range(ncol):
axes[1, col].set_xlabel('$\ell$', fontsize=fontsize)
axes[row, col].ticklabel_format(style='sci',scilimits=(-3,4),axis='y')
axes[row, col].set_xscale('log')
axes[0, col].set_yscale('log')
axes[row, col].tick_params(axis='x', labelsize=fontsize-2)
axes[row, col].tick_params(axis='y', labelsize=fontsize-2)
axes[0, 0].set_ylabel('Auto C$_\ell$', fontsize=fontsize)
axes[1, 0].set_ylabel('Auto Noise', fontsize=fontsize)
axes[0, 1].set_ylabel('Cross C$_\ell$', fontsize=fontsize)
axes[1, 1].set_ylabel('Cross Noise', fontsize=fontsize)
axes[0, 0].legend(bbox_to_anchor=(-0.15,1), fontsize=fontsize-4)
axes[0, 1].legend(bbox_to_anchor=(1,1), fontsize=fontsize-4)
plt.suptitle(filetag, fontsize=fontsize)
plt.gcf().set_size_inches(20, 10)
if save_plots:
filename = '%s_%sbins_spectra.png'%(filetag, len(z_phot)-1)
plt.savefig('%s/%s'%(outDir, filename), format='png', bbox_inches='tight')
print('\n## Saved plot: %s\n'%filename)
if dont_show_plots:
plt.close('all')
else:
plt.show()
###############################################################################################
# (2*ell+1) Tr(S_ell . C_ell^-1 . S_ell . C_ell^-1)
C = S+N
sn_sq = 0
for j in range(len(ell)):
inv = np.linalg.inv(C[j, :, :])
mat = np.dot(S[j, :, :], inv)
mat = np.dot(inv, mat)
mat = np.dot(S[j, :, :], mat)
sn_sq += (2*ell[j]+1)*np.trace(mat)
fsky = area_in_sr/(4*np.pi) # total sky area: 4pi Sr
print('\n## fsky: %.2e\n'%fsky)
return np.sqrt((fsky/2.)*sn_sq)
#This just generates the theory power spectra
if not os.path.isfile('cls_flat.txt'):
import pyccl as ccl
z = np.linspace(0.2, 1.2, 256)
pz = np.exp(-((z - 0.7) / 0.1)**2)
bz = np.ones_like(z)
plt.figure()
plt.plot(z, pz)
plt.xlabel('$z$', fontsize=16)
plt.ylabel('$p(z)$', fontsize=16)
cosmo = ccl.Cosmology(Omega_c=0.27,
Omega_b=0.045,
h=0.67,
A_s=2.1e-9,
n_s=0.96)
clust = ccl.ClTracerNumberCounts(cosmo, False, False, z=z, n=pz, bias=bz)
lens = ccl.ClTracerLensing(cosmo, False, z=z, n=pz)
ell = np.arange(20000)
cltt = ccl.angular_cl(cosmo, clust, clust, ell)
clte = ccl.angular_cl(cosmo, clust, lens, ell)
clee = ccl.angular_cl(cosmo, lens, lens, ell)
clbb = np.zeros_like(clee)
np.savetxt("cls_flat.txt", np.transpose([ell, cltt, clee, clbb, clte]))
ell, cltt, clee, clbb, clte = np.loadtxt("cls_flat.txt", unpack=True)
cltt[0] = 0
clee[0] = 0
clbb[0] = 0
clte[0] = 0
if plotres:
plt.figure()
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.configuration.matter_power_spectrum_method \
== ccl.core.matter_power_spectrum_types['emu']: cmb_ok = False
# ClTracer test objects
lens1 = ccl.ClTracerLensing(cosmo, False, n=n, z=z)
lens2 = ccl.ClTracerLensing(cosmo, True, n=(z,n), bias_ia=(z,n), f_red=(z,n))
nc1 = ccl.ClTracerNumberCounts(cosmo, False, False, n=(z,n), bias=(z,b))
# Check that for massive neutrinos including rsd raises an error (not yet implemented)
assert_raises(RuntimeError, ccl.ClTracerNumberCounts, cosmo, True, False, n=(z,n), bias=(z,b))
cmbl=ccl.ClTracerCMBLensing(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(KeyError, nc1.get_internal_function, cosmo, 'x', a_arr)
assert_raises(ValueError, ccl.ClTracerNumberCounts, cosmo, True, True,
n=(z,n), bias=(z,b))
assert_raises(KeyError, ccl.ClTracer, cosmo, 'x', True, True,
n=(z,n), bias=(z,b))
assert_raises(ValueError, ccl.ClTracerLensing, cosmo,
has_intrinsic_alignment=True, n=(z,n), bias_ia=(z,n))
assert_no_warnings(ccl.cls._cltracer_obj, nc1)
assert_no_warnings(ccl.cls._cltracer_obj, nc1.cltracer)
assert_raises(TypeError, ccl.cls._cltracer_obj, None)
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.configuration.matter_power_spectrum_method \
== ccl.core.matter_power_spectrum_types['emu']: cmb_ok = False
# ClTracer test objects
lens1 = ccl.ClTracerLensing(cosmo, False, n=n, z=z)
lens2 = ccl.ClTracerLensing(cosmo, True, n=(z,n), bias_ia=(z,n), f_red=(z,n))
nc1 = ccl.ClTracerNumberCounts(cosmo, False, False, n=(z,n), bias=(z,b))
nc2 = ccl.ClTracerNumberCounts(cosmo, True, False, n=(z,n), bias=(z,b))
nc3 = ccl.ClTracerNumberCounts(cosmo, True, True, n=(z,n), bias=(z,b),
mag_bias=(z,b))
cmbl=ccl.ClTracerCMBLensing(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 non-limber calculations
assert_( all_finite(ccl.angular_cl(cosmo, nc1, nc1, ell_arr, l_limber=20, non_limber_method="native")))
assert_( all_finite(ccl.angular_cl(cosmo, nc1, nc1, ell_arr, l_limber=20, non_limber_method="angpow")))
# 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)) )
# Wrong non limber method
assert_raises(KeyError, ccl.angular_cl, cosmo, lens1, lens1, ell_scl, non_limber_method='xx')
return zarr, pzarr
nz, bn = np.histogram(data_dla['z_abs'], range=[0, 7], bins=50)
zarr_dlo, nzarr_dlo = get_nz_oversample(bn, nz, 256)
bzarr_dlo = bdla * np.ones_like(zarr_dlo)
nz, bins = np.histogram(data_dla['zqso'], range=[0, 7], bins=50)
zarr_qso, nzarr_qso = get_nz_oversample(bn, nz, 256)
bzarr_qso = bqso * np.ones_like(zarr_qso)
cosmo = ccl.Cosmology(Omega_c=0.27,
Omega_b=0.045,
h=0.69,
sigma8=0.83,
n_s=0.96)
clt_dlo = ccl.ClTracerNumberCounts(cosmo, False, False, (zarr_dlo, nzarr_dlo),
(zarr_dlo, bzarr_dlo))
clt_qso = ccl.ClTracerNumberCounts(cosmo, False, False, (zarr_qso, nzarr_qso),
(zarr_qso, bzarr_qso))
clt_cmbl = ccl.ClTracerCMBLensing(cosmo, z_source=1100.)
def get_fisher(xp):
ll = np.arange(xp.lmin, xp.lmax)
cl_dd = ccl.angular_cl(cosmo, clt_dlo, clt_dlo, ll) #,l_limber=-1)
cl_dq = ccl.angular_cl(cosmo, clt_dlo, clt_qso, ll) #,l_limber=-1)
cl_dc = ccl.angular_cl(cosmo, clt_dlo, clt_cmbl, ll) #,l_limber=-1)
cl_qq = ccl.angular_cl(cosmo, clt_qso, clt_qso, ll) #,l_limber=-1)
cl_qc = ccl.angular_cl(cosmo, clt_qso, clt_cmbl, ll) #,l_limber=-1)
cl_cc = ccl.angular_cl(cosmo, clt_cmbl, clt_cmbl, ll) #,l_limber=-1)
cl_aa = cl_dd + 2 * cl_dq + cl_qq
cl_aq = cl_dq + cl_qq
h=0.69,
sigma8=0.83,
n_s=0.96)
cosmo = ccl.Cosmology(parameters)
lens = ccl.ClTracerCMBLensing(cosmo)
#use ccl to predict cls
bias_qso = np.ones(rdshift.size)
bias_dla = np.ones(rdshift.size)
b = nmt.NmtBin(2048, nlb=bsize)
ell_arr = b.get_effective_ells()
source_dla = ccl.ClTracerNumberCounts(cosmo,
False,
False,
z=rdshift,
n=n_dla,
bias=bias_dla)
theory_dla = ccl.angular_cl(cosmo, lens, source_dla, ell_arr, l_limber=-1)
source_qso = ccl.ClTracerNumberCounts(cosmo,
False,
False,
z=rdshift,
n=n_qso,
bias=bias_qso)
theory_qso = ccl.angular_cl(cosmo, lens, source_qso, ell_arr, l_limber=-1)
#import precalculated power spectra
if args.nsim == None:
return theo
def getTheoryVec(s, cls_theory):
vec=np.zeros((s.size(),))
for t1i,t2i,ells,ndx in s.sortTracers():
vec[ndx]=cls_theory[(t1i,t2i)]
return sacc.MeanVec(vec)
print 'Setting up cosmology'
cosmo = ccl.Cosmology(ccl.Parameters(Omega_c=0.266,Omega_b=0.049,h=hhub,sigma8=0.8,n_s=0.96,),matter_power_spectrum='linear',transfer_function='eisenstein_hu')
#Compute grid scale
zmax=2.5
ngrid=3072
a_grid=2*ccl.comoving_radial_distance(cosmo,1./(1+zmax))*(1+2./ngrid)/ngrid*hhub
print "Grid smoothing : %.3lf Mpc/h"%a_grid
print 'Reading SACC file'
#SACC File with the N(z) to analyze
binning_sacc = sacc.SACC.loadFromHDF('../test/catalog0.sacc')
#Bias file (it can also be included in the SACC file in the line before)
bias_tab = astropy.table.Table.read('../test/bz_lsst.txt',format='ascii')
tracers = binning_sacc.tracers
print 'Got ',len(tracers),' tracers'
cltracers=[ccl.ClTracerNumberCounts(cosmo,False,False,n=(t.z,t.Nz),bias=(bias_tab['col1'],bias_tab['col2']),r_smooth=0.5*a_grid) for t in tracers]
print 'Cl tracers ready'
theories = getTheories(cosmo,binning_sacc,cltracers)
mean=getTheoryVec(binning_sacc,theories)
csacc=sacc.SACC(tracers,binning_sacc.binning,mean)
csacc.printInfo()
csacc.saveToHDF('theory.sacc',save_precision=False)
