def add_ell_cl(self, tr1, tr2):
ells_nobin = np.arange(3 * self.data.data['sphere']['nside'])
cl = Cl(self.data.data, tr1, tr2, ignore_existing_yml=True)
ells_eff = cl.b.get_effective_ells()
if self.use_fiducial:
# bpw = np.array(self.data.data['bpw_edges'])
# ells_eff = bpw[:-1] + np.diff(bpw)/2.
cl = ClFid(self.data.data, tr1, tr2, ignore_existing_yml=True)
ws_bpw = np.zeros((ells_eff.size, ells_nobin.size))
ws_bpw[np.arange(ells_eff.size), ells_eff.astype(int)] = 1
cl.get_cl_file()
cl_types = self.get_datatypes_from_dof(cl.cl.shape[0])
for i, cl_type in enumerate(cl_types):
if (cl_type == 'cl_be') and (tr1 == tr2):
continue
elif self.use_nl:
cli = cl.nl[i]
wins = None
elif self.use_fiducial:
cli = ws_bpw.dot(cl.cl[i])
wins = sacc.BandpowerWindow(ells_nobin, ws_bpw.T)
else:
wins = sacc.BandpowerWindow(ells_nobin, cl.wins[i, :, i, :].T)
cli = cl.cl[i]
self.s.add_ell_cl(cl_type, tr1, tr2, ells_eff, cli, window=wins)
def get_sacc_windows(self):
windows_wsp = {}
for b1 in range(self.n_bpss):
for b2 in range(b1, self.n_bpss):
name = self.get_workspace_label(b1, b2)
windows_wsp[name] = {}
wsp = self.workspaces[name]
bpw_win = wsp.get_bandpower_windows()
windows_wsp[name]['EE'] = sacc.BandpowerWindow(
self.larr_all, bpw_win[0, :, 0, :].T)
windows_wsp[name]['EB'] = sacc.BandpowerWindow(
self.larr_all, bpw_win[1, :, 1, :].T)
windows_wsp[name]['BE'] = sacc.BandpowerWindow(
self.larr_all, bpw_win[2, :, 2, :].T)
windows_wsp[name]['BB'] = sacc.BandpowerWindow(
self.larr_all, bpw_win[3, :, 3, :].T)
return windows_wsp
def add_ell_cl(self, tr1, tr2):
ells_nobin = np.arange(3 * self.data['healpy']['nside'])
if self.use_fiducial:
bpw = np.array(self.data['bpw_edges'])
ells_eff = bpw[:-1] + np.diff(bpw) / 2.
cl = Cl_fid(self.datafile, tr1, tr2)
ws_bpw = np.zeros((ells_eff.size, ells_nobin.size))
ws_bpw[np.arange(ells_eff.size), ells_eff.astype(int)] = 1
else:
cl = Cl(self.datafile, tr1, tr2)
ells_eff = cl.ell
if not self.use_nl and not self.use_fiducial:
w = cl.get_workspace()
ws_bpw = w.get_bandpower_windows()
cl_types = self.get_datatypes_from_dof(cl.cl.shape[0])
for i, cl_type in enumerate(cl_types):
if (cl_type == 'cl_be') and (tr1 == tr2):
continue
elif self.use_nl:
cli = cl.nl[i]
wins = None
elif self.use_fiducial:
cli = ws_bpw.dot(cl.cl[i])
wins = sacc.BandpowerWindow(ells_nobin, ws_bpw.T)
else:
# b1 = int(tr1[-1])
# b2 = int(tr2[-1])
# predir = '/mnt/extraspace/damonge/S8z_data/outputs/'
# fname_win = predir + f'cls_metacal_win_bins_{b1}{b2}_ns4096.npz'
# ws_bpw = np.load(fname_win)['win']
wins = sacc.BandpowerWindow(ells_nobin, ws_bpw[i, :, i, :].T)
cli = cl.cl[i]
# fname_cl = predir + f'cls_metacal_cls_bins_{b1}{b2}_ns4096.npz'
# cload = np.load(fname_cl)
# cli = cload['cls'][i] - cload['nls'][i]
# ls = cload['ls']
self.s.add_ell_cl(cl_type, tr1, tr2, ells_eff, cli, window=wins)
def test_bandpower_window():
nb = 20
nl = 200
dl = nl // nb
ells = np.arange(nl)
w = np.zeros([nb, nl])
for i in range(nb):
w[i, i * dl:(i + 1) * dl] = 1. / dl
W1 = [sacc.BandpowerWindow(ells, w.T)]
tables = sacc.BandpowerWindow.to_tables(W1)
W2 = sacc.BandpowerWindow.from_tables(tables)
for w1 in W1:
w2 = W2[id(w1)]
assert np.all(w1.values == w2.values)
assert np.all(w1.weight.flatten() == w2.weight.flatten())
def test_io_maps_bpws():
s = sacc.Sacc()
n_ell = 10
d_ell = 100
n_ell_large = n_ell * d_ell
ell = np.linspace(2, 1000, n_ell)
c_ell = 1. / (ell + 1)**3
beam = np.exp(-0.1 * ell * (ell + 1))
nu = np.linspace(30., 60., 100)
bandpass = np.ones(100)
z = np.arange(0., 1.0, 0.01)
nz = (z - 0.5)**2 / 0.1**2
# Tracer
s.add_tracer('NZ', 'gc', z, nz)
s.add_tracer('NuMap', 'cmbp', 2, nu, bandpass, ell, beam)
s.add_tracer('Map', 'sz', 0, ell, beam)
# Window
ells_large = np.arange(n_ell_large)
window_single = np.zeros([n_ell, n_ell_large])
for i in range(n_ell):
window_single[i, i * d_ell:(i + 1) * d_ell] = 1.
wins = sacc.BandpowerWindow(ells_large, window_single.T)
s.add_ell_cl('cl_00', 'gc', 'gc', ell, c_ell, window=wins)
s.add_ell_cl('cl_0e', 'gc', 'cmbp', ell, c_ell, window=wins)
s.add_ell_cl('cl_00', 'gc', 'sz', ell, c_ell, window=wins)
with tempfile.TemporaryDirectory() as tmpdir:
filename = os.path.join(tmpdir, 'test.sacc')
s.save_fits(filename)
s2 = sacc.Sacc.load_fits(filename)
assert len(s2) == 30
l, cl, ind = s2.get_ell_cl('cl_00', 'gc', 'sz', return_ind=True)
w = s2.get_bandpower_windows(ind)
assert np.all(cl == c_ell)
assert w.weight.shape == (n_ell_large, n_ell)
# Bandpasses
bpss = {n: Bpass(n, f'data/bandpasses/{n}.txt') for n in band_names}
# Bandpowers
dell = 10
nbands = 76
lmax = 2 + nbands * dell
larr_all = np.arange(lmax + 1)
lbands = np.linspace(2, lmax, nbands + 1, dtype=int)
leff = 0.5 * (lbands[1:] + lbands[:-1])
windows = np.zeros([nbands, lmax + 1])
for b, (l0, lf) in enumerate(zip(lbands[:-1], lbands[1:])):
windows[b, l0:lf] = (larr_all * (larr_all + 1) / (2 * np.pi))[l0:lf]
windows[b, :] /= dell
s_wins = sacc.BandpowerWindow(larr_all, windows.T)
# Beams
beams = {
band_names[i]: b
for i, b in enumerate(nc.Simons_Observatory_V3_SA_beams(larr_all))
}
# N_ell
nell = np.zeros([nfreqs, lmax + 1])
_, nell[:, 2:], _ = nc.Simons_Observatory_V3_SA_noise(sens, knee, ylf, fsky,
lmax + 1, 1)
n_bpw = np.sum(nell[:, None, :] * windows[None, :, :], axis=2)
bpw_freq_noi = np.zeros((nfreqs, npol, nfreqs, npol, nbands))
for ib, n in enumerate(n_bpw):
bpw_freq_noi[ib, 0, ib, 0, :] = n_bpw[ib, :]
cl_i1j2 = c_ells_binned[i1, j2, :]+n_ells_binned[i1, j2, :]
cl_i2j1 = c_ells_binned[i2, j1, :]+n_ells_binned[i2, j1, :]
cl_i2j2 = c_ells_binned[i2, j2, :]+n_ells_binned[i2, j2, :]
# Knox formula
cov = (cl_i1j1 * cl_i2j2 + cl_i1j2 * cl_i2j1) / (d_ell * fsky * (2 * l_eff + 1))
covar[id_i, :, id_j, :] = np.diag(cov)
id_j += 1
id_i += 1
covar = covar.reshape([n_cross * n_bpw, n_cross * n_bpw])
# Open sacc
s = sacc.Sacc()
# Add tracers
for i, n in enumerate(nzs):
s.add_tracer('NZ', 'wl_%d' % i, # Name
quantity='galaxy_shear', # Quantity
spin=2, # Spin
z=z, # z
nz=n, # nz
sigma_g=0.28) # You can add any extra information as **kwargs
# Add C_ells
wins = sacc.BandpowerWindow(ells, window_single.T)
for i1 in range(n_bins):
for i2 in range(i1, n_bins):
s.add_ell_cl('cl_ee', 'wl_%d' % i1, 'wl_%d' % i2, l_eff, c_ells_binned[i1, i2, :],
window=wins)
# Add covariance
s.add_covariance(covar)
s.save_fits("cls_shear.fits", overwrite=True)
tb_name = "%s_%s_s2" % (eb, fb)
if pb == "T":
cl_type = "cl_" + map_types[pb] + map_types[pa]
else:
cl_type = "cl_" + map_types[pa] + map_types[pb]
lbin = data["%s_%s" % (ea, fa), "%s_%s" % (eb, fb)]["lbin"]
cb = data["%s_%s" % (ea, fa), "%s_%s" % (eb, fb)][pa + pb]
spec_sacc.add_ell_cl(cl_type, ta_name, tb_name, lbin, cb)
if isim == 0:
bbl = get_bbl(ea, fa, pa, eb, fb, pb)
ls_w = np.arange(2, bbl.shape[-1] + 2)
wins = sacc.BandpowerWindow(ls_w, bbl.T)
cov_sacc.add_ell_cl(cl_type,
ta_name,
tb_name,
lbin,
cb,
window=wins)
if isim == 0:
cov_sacc.add_covariance(cov_full)
cov_sacc.save_fits("%s/data_sacc_w_covar_and_Bbl.fits" % sacc_dir,
overwrite=True)
spec_sacc.save_fits("%s/data_sacc_%s.fits" % (sacc_dir, sim_suffix),
overwrite=True)
wth = sacc.TopHatWindow(0., 1.)
ww = sacc.Window(x, y)
s.add_ell_cl('galaxy_density_cl', 'nz', 'nz', x, y, window=[wth] * vecsize)
s.add_theta_xi('galaxy_density_xi', 'nz', 'nz', x, y, window=[ww] * vecsize)
nvec = 2
if version.parse(sacc.__version__) > version.parse('0.2.0'):
wlth = sacc.LogTopHatWindow(-2., 0.)
s.add_ell_cl('galaxy_density_cl',
'nz_b',
'nz_b',
x,
y,
window=[wlth] * vecsize)
nvec += 1
if version.parse(sacc.__version__) > version.parse('0.4.0'):
wbpw = sacc.BandpowerWindow(x, np.ones([vecsize, vecsize]))
s.add_tracer('Misc', 'msc')
s.add_tracer('Map', 'map', 0, x, y)
s.add_tracer('NuMap', 'nap', 2, x, y, x, y)
s.add_ell_cl('cl_00', 'nz', 'map', x, y, window=wbpw)
s.add_theta_xi('xi_plus_re', 'msc', 'nap', x, y, window=[wth] * vecsize)
s.add_ell_cl('cl_00', 'map', 'nz_b', x, y, window=wbpw)
nvec += 3
s.add_covariance(np.eye(nvec * vecsize))
fname_save = 'legacy_files/dummy_v' + sacc.__version__ + '.fits'
s.save_fits(fname_save, overwrite=True)
def get_everything(self):
if self.sacc is None:
fname = os.path.join(self.config['output_dir'], f'cls_all.fits')
fname_n = os.path.join(self.config['output_dir'],
f'cls_noise.fits')
if not os.path.isfile(fname):
self.get_cls()
self.get_covariances()
s = sacc.Sacc()
sn = sacc.Sacc()
# Add tracers
s.add_tracer('NZ',
'LoTSS',
quantity='galaxy_density',
spin=0,
z=np.linspace(0, 5, 512),
nz=np.ones(512)) # We will need a better N(z)
s.add_tracer('Map',
'Planck18',
quantity='cmb_convergence',
spin=0,
ell=np.arange(3 * self.nside),
beam=np.ones(3 * self.nside))
sn.add_tracer('NZ',
'LoTSS',
quantity='galaxy_density',
spin=0,
z=np.linspace(0, 5, 512),
nz=np.ones(512)) # We will need a better N(z)
sn.add_tracer('Map',
'Planck18',
quantity='cmb_convergence',
spin=0,
ell=np.arange(3 * self.nside),
beam=np.ones(3 * self.nside))
order = []
nls = []
ells = np.arange(3 * self.nside)
if 'gg' in self.cls_compute:
d = self.cls['gg']
wins = sacc.BandpowerWindow(ells, d['win'][0, :, 0, :].T)
s.add_ell_cl('cl_00',
'LoTSS',
'LoTSS',
d['ls'],
d['cl'][0] - d['nl'][0],
window=wins)
sn.add_ell_cl('cl_00', 'LoTSS', 'LoTSS', d['ls'],
d['nl'][0])
order.append('gg')
nls.append(len(d['ls']))
if 'gk' in self.cls_compute:
d = self.cls['gk']
wins = sacc.BandpowerWindow(ells, d['win'][0, :, 0, :].T)
s.add_ell_cl('cl_00',
'LoTSS',
'Planck18',
d['ls'],
d['cl'][0] - d['nl'][0],
window=wins)
sn.add_ell_cl('cl_00', 'LoTSS', 'Planck18', d['ls'],
d['nl'][0])
order.append('gk')
nls.append(len(d['ls']))
if 'kk' in self.cls_compute:
d = self.cls['kk']
wins = sacc.BandpowerWindow(ells, d['win'][0, :, 0, :].T)
s.add_ell_cl('cl_00',
'Planck18',
'Planck18',
d['ls'],
d['cl'][0] - d['nl'][0],
window=wins)
sn.add_ell_cl('cl_00', 'Planck18', 'Planck18', d['ls'],
d['nl'][0])
order.append('kk')
nls.append(len(d['ls']))
ncls = len(nls)
cov = np.zeros([ncls, nls[0], ncls, nls[0]])
for i1, t1 in enumerate(order):
for i2, t2 in enumerate(order):
if t1 + t2 in self.cov:
cv = self.cov[t1 + t2]
else:
cv = self.cov[t2 + t1].T
cov[i1, :, i2, :] = cv
cov = cov.reshape([ncls * nls[0], ncls * nls[0]])
s.add_covariance(cov)
s.save_fits(fname)
sn.save_fits(fname_n)
self.sacc = s
self.sacc_noise = sn
else:
self.sacc = sacc.Sacc.load_fits(fname)
self.sacc_noise = sacc.Sacc.load_fits(fname_n)
return self.sacc, self.sacc_noise
##############################################################################
# Add Noise to SACC s_noise instance
##############################################################################
fname = os.path.join(clsdir, "des_sh_{}_noise_ns{}.npz".format(wltype, nside))
clfile = np.load(fname)
lbpw = clfile['l']
if not np.all(lbpw == b.get_effective_ells()):
raise 'Bandpowers from NmtBin and des_sh_{}_noise_ns{}.npz file do NOT coincide'.format(
wltype, nside)
nls = clfile['cls']
for i in range(ntracers_wl):
cl_type = 'cl_ee'
tr1 = tr2 = 'wl{}'.format(i)
wins = sacc.BandpowerWindow(ells_nobin, ws_bpw[tr1 + tr2][0, :, 0, :].T)
s_noise.add_ell_cl(cl_type, tr1, tr2, lbpw, nls[i, 0, 0], window=wins)
cl_type = 'cl_eb'
tr1 = tr2 = 'wl{}'.format(i)
wins = sacc.BandpowerWindow(ells_nobin, ws_bpw[tr1 + tr2][1, :, 1, :].T)
s_noise.add_ell_cl(cl_type, tr1, tr2, lbpw, nls[i, 0, 0] * 0, window=wins)
cl_type = 'cl_be'
tr1 = tr2 = 'wl{}'.format(i)
wins = sacc.BandpowerWindow(ells_nobin, ws_bpw[tr1 + tr2][2, :, 2, :].T)
s_noise.add_ell_cl(cl_type, tr1, tr2, lbpw, nls[i, 0, 0] * 0, window=wins)
cl_type = 'cl_bb'
tr1 = tr2 = 'wl{}'.format(i)
wins = sacc.BandpowerWindow(ells_nobin, ws_bpw[tr1 + tr2][3, :, 3, :].T)
s_noise.add_ell_cl(cl_type, tr1, tr2, lbpw, nls[i, 1, 1], window=wins)
fname = os.path.join(clsdir, "DESwl_nls.fits")
spin_pairs=[
"spin0xspin0", "spin0xspin2", "spin2xspin0", "spin2xspin2"
],
)
Bbl_TT = Bbl["spin0xspin0"]
Bbl_TE = Bbl["spin0xspin2"]
Bbl_EE = Bbl["spin2xspin2"][:Bbl_TE.shape[0], :Bbl_TE.shape[1]]
if spec in ["EE", "EB", "BE", "BB"]:
Bbl = Bbl_EE
elif spec in ["TE", "TB", "ET", "BT"]:
Bbl = Bbl_TE
else:
Bbl = Bbl_TT
ls_w = np.arange(2, Bbl.shape[-1] + 2)
bp_window = sacc.BandpowerWindow(ls_w, Bbl.T)
# Add ell/cl to sacc
Db = proj_data_vec[count * n_bins:(count + 1) * n_bins]
act_sacc.add_ell_cl(cl_type,
ta_name,
tb_name,
lb,
Db,
window=bp_window)
count += 1
print("Adding covariance")
proj_cov_mat = np.load("%s/combined_analytic_cov.npy" % like_product_dir)
act_sacc.add_covariance(proj_cov_mat)
# Initialize and fill tracers
s1 = sacc_and_tracers()
# Add power spectra
ix = 0
for b1, b2, ibx in bin_pair_iterator():
fname_cl = predir + f'cls_metacal_cls_bins_{b1}{b2}_ns{o.nside}.npz'
fname_win = predir + f'cls_metacal_win_bins_{b1}{b2}_ns{o.nside}.npz'
dc = np.load(fname_cl)
ls = dc['ls']
cl = dc['cls'] - dc['nls']
w = np.load(fname_win)['win']
n1 = f'bin{b1}'
n2 = f'bin{b2}'
for p1, p2, ipx in pol_pair_iterator(b1, b2):
cl_h = cl[ipx, :]
w_h = sacc.BandpowerWindow(ls_large, w[ipx, :, ipx, :].T)
s1.add_ell_cl('cl_' + pname[p1] + pname[p2],
n1,
n2,
ls,
cl_h,
window=w_h)
ix += 1
# Add covariance matrix
prefix_cov = predir + 'cls_metacal_covar_bins_new_nka_full_noise'
cov = np.zeros([ncross, nbpw, ncross, nbpw])
ix_a = 0
for b1_a, b2_a, ibx_a in bin_pair_iterator():
covs = {}
# Read all possible covariance elements
for b1_b, b2_b, ibx_b in bin_pair_iterator():
