window.plot(file_name="%s/window" % (test_dir), ticks_spacing_car=4)
#for spin0 and 2 the window need to be a tuple made of two objects
#the window used for spin0 and the one used for spin 2
window = (window, window)
# Compute spin 0 spin 2 spectra a la pspy
print("Compute spin0 and spin2 power spectra a la pspy")
t0 = time.time()
mbb_inv, Bbl = so_mcm.mcm_and_bbl_spin0and2(window,
binning_file,
lmax=lmax,
type=type,
niter=niter)
alms = sph_tools.get_alms(split, window, niter, lmax)
l, ps = so_spectra.get_spectra(alms, spectra=spectra)
lb_py, Cb_pspy = so_spectra.bin_spectra(l,
ps,
binning_file,
lmax,
type=type,
mbb_inv=mbb_inv,
spectra=spectra)
print("pspy run in %.2f s" % (time.time() - t0))
print("Compute spin0 and spin2 power spectra a la namaster")
# Compute spin 0 spin 2 spectra a la namaster
t0 = time.time()
else:
map_T = d['map_T_%s' % ar]
map_Q = d['map_Q_%s' % ar]
map_U = d['map_U_%s' % ar]
print("compute harmonic transform ...")
count = 0
for T, Q, U in zip(map_T, map_Q, map_U):
map = so_map.from_components(T, Q, U)
map = so_map.get_submap_car(map, box, mode='floor')
if d['use_filtered_maps'] == False:
map = so_map_preprocessing.get_map_kx_ky_filtered_pyfftw(
map, apo, d['filter_dict'])
almList += [sph_tools.get_alms(map, window_tuple, niter, lmax)]
nameList += ['split_%d_%s' % (count, ar)]
count += 1
print("get spectra ...")
Db_dict = {}
Db_dict_auto = {}
Db_dict_cross = {}
for s1 in spectra:
Db_dict_auto[s1] = []
Db_dict_cross[s1] = []
spec_name_list = []
for name1, alm1, c1 in zip(nameList, almList, np.arange(count)):
for name2, alm2, c2 in zip(nameList, almList, np.arange(count)):
if d["use_kspace_filter"]:
print("apply kspace filter on %s" %map)
binary = so_map.read_map("%s/binary_%s_%s.fits" % (window_dir, sv, ar))
split = data_analysis_utils.get_filtered_map(
split, binary, vk_mask=d["vk_mask"], hk_mask=d["hk_mask"], normalize=False)
elif win_T.pixel == "HEALPIX":
split = so_map.read_map(map)
split.data *= cal
if d["remove_mean"] == True:
split = data_analysis_utils.remove_mean(split, window_tuple, ncomp)
#split.plot(file_name="%s/split_%d_%s_%s" % (plot_dir, k, sv, ar), color_range=[250, 100, 100])
master_alms[sv, ar, k] = sph_tools.get_alms(split, window_tuple, niter, lmax)
if d["use_kspace_filter"]:
# there is an extra normalisation for the FFT/IFFT bit
# note that we apply it here rather than at the FFT level because correcting the alm is faster than correcting the maps
master_alms[sv, ar, k] /= (split.data.shape[1]*split.data.shape[2])
print(time.time()- t)
ps_dict = {}
_, _, lb, _ = pspy_utils.read_binning_file(binning_file, lmax)
for id_sv1, sv1 in enumerate(surveys):
arrays_1 = d["arrays_%s" % sv1]
nsplits_1 = nsplit[sv1]
if d["tf_%s" % sv1] is not None:
for k in range(nsplits):
noisy_alms = alms_beamed.copy()
noisy_alms[0] += nlms["T", k][fid]
noisy_alms[1] += nlms["E", k][fid]
noisy_alms[2] += nlms["B", k][fid]
split = sph_tools.alm2map(noisy_alms, template)
# Now that we have generated a split of data of experiment exp
# and frequency freq, we take its harmonic transform
split = maps_to_params_utils.remove_mean(
split, window_tuple, ncomp)
master_alms[exp, freq,
k] = sph_tools.get_alms(split, window_tuple, niter,
lmax)
# We now form auto and cross power spectra from the alms
ps_dict = {}
for id_exp1, exp1 in enumerate(experiments):
freqs1 = d["freqs_%s" % exp1]
nsplits1 = d["nsplits_%s" % exp1]
for id_f1, f1 in enumerate(freqs1):
for id_exp2, exp2 in enumerate(experiments):
freqs2 = d["freqs_%s" % exp2]
nsplits2 = d["nsplits_%s" % exp2]
for id_f2, f2 in enumerate(freqs2):
norm, split = data_analysis_utils.get_filtered_map(
split,
binary,
filter[sv],
weighted_filter=ks_f["weighted"])
del binary
if d["remove_mean"] == True:
split = data_analysis_utils.remove_mean(
split, window_tuple, ncomp)
master_alms[sv, ar,
k] = sph_tools.get_alms(split,
window_tuple,
niter,
lmax,
dtype=sim_alm_dtype)
print("m_alms_dtype", master_alms[sv, ar, k].dtype)
if ks_f["apply"]:
# there is an extra normalisation for the FFT/IFFT bit
# note that we apply it here rather than at the FFT level because correcting the alm is faster than correcting the maps
master_alms[sv, ar, k] /= (split.data.shape[1] *
split.data.shape[2])**norm
print(time.time() - t1)
ps_dict = {}
_, _, lb, _ = pspy_utils.read_binning_file(binning_file, lmax)
for id_sv1, sv1 in enumerate(surveys):
alms_beamed = alms.copy()
alms_beamed[0] += fglms[id_freq[d["nu_eff_%s_%s" % (sv, ar)]]]
# we convolve signal + foreground with the beam of the array
l, bl = pspy_utils.read_beam_file(d["beam_%s_%s" % (sv, ar)])
alms_beamed = curvedsky.almxfl(alms_beamed, bl)
if scenario == "noE": alms_beamed[1] *= 0
if scenario == "noB": alms_beamed[2] *= 0
# generate our signal only sim
split = sph_tools.alm2map(alms_beamed, template[sv])
# compute the alms of the sim
master_alms[sv, ar, "nofilter"] = sph_tools.get_alms(
split, window_tuple, niter, lmax, dtype=sim_alm_dtype)
# apply the k-space filter
binary = so_map.read_map("%s/binary_%s_%s.fits" %
(window_dir, sv, ar))
norm, split = data_analysis_utils.get_filtered_map(
split,
binary,
filter[sv],
weighted_filter=ks_f["weighted"])
# compute the alms of the filtered sim
master_alms[sv, ar,
models = {k: {} for k in presets}
from itertools import product
for preset, freq in product(presets, frequencies):
print("Computing {} model @ {} GHz".format(preset, freq))
# Get emission map
sky = pysm.Sky(nside=nside, preset_strings=[preset], output_unit=u.uK_CMB)
emission = sky.get_emission(freq * u.GHz)
# Compute alm
from pspy import sph_tools
tmpl = so_map.healpix_template(ncomp=3, nside=nside)
tmpl.data = emission.value
alms = sph_tools.get_alms(tmpl, window, niter=niter, lmax=lmax)
# Compute spectra
from pspy import so_spectra
spectra = ["TT", "TE", "TB", "ET", "BT", "EE", "EB", "BE", "BB"]
db = so_spectra.bin_spectra(*so_spectra.get_spectra(alms, spectra=spectra),
binning_file,
lmax=lmax,
type="Dl",
mbb_inv=mbb_inv,
spectra=spectra)
models[preset][freq] = {"spectra": db}
if store_map:
models[preset][freq].update({"map": emission})
if store_alms:
pl_map.data *= 10**6
cov_map = so_map.read_map('%s' % map, fields_healpix=4)
badpix = (cov_map.data == hp.pixelfunc.UNSEEN)
for i in range(3):
pl_map.data[i][badpix] = 0.0
if remove_mono_dipo_T:
pl_map.data[0] = planck_utils.subtract_mono_di(
pl_map.data[0], window_tuple[0].data, pl_map.nside)
if remove_mono_dipo_pol:
pl_map.data[1] = planck_utils.subtract_mono_di(
pl_map.data[1], window_tuple[1].data, pl_map.nside)
pl_map.data[2] = planck_utils.subtract_mono_di(
pl_map.data[2], window_tuple[1].data, pl_map.nside)
alms[hm, freq] = sph_tools.get_alms(pl_map, window_tuple, niter, lmax)
spin_pairs = ['spin0xspin0', 'spin0xspin2', 'spin2xspin0', 'spin2xspin2']
Db_dict = {}
spec_name_list = []
for c1, freq1 in enumerate(freqs):
for c2, freq2 in enumerate(freqs):
if c1 > c2: continue
for s1, hm1 in enumerate(splits):
for s2, hm2 in enumerate(splits):
if (s1 > s2) & (c1 == c2): continue
prefix = '%s/%s_%sx%s_%s-%sx%s' % (mcmDir, experiment, freq1,
experiment, freq2, hm1, hm2)
def get_spectra(window,
maps_info_list,
car_box,
type,
lmax,
binning_file,
ps_method="master",
mbb_inv=None,
compute_T_only=False):
"""compute the power spectra in the patch
Parameters
----------
window: so_map
the window function of the patch
maps_info_list: list of dicts describing the data maps
dictionnary should contain the name, the data type ("IQU" or "I") and optionally a calibration factor to apply to the map
note that all map in the list should have the same data type
car_box: 2x2 array
an array of the form [[dec0,rac0],[dec1,ra1]] it encompasses the patch
and we will only load in memory the map inside the box
type: string
the type of binning, either bin Cl or bin Dl
lmax : integer
the maximum multipole to consider for the spectra computation
ps_method: string
the method for the computation of the power spectrum
can be "master", "pseudo", or "2dflat" for now
binning_file: text file
a binning file with three columns bin low, bin high, bin mean
note that either binning_file or bin_size should be provided
mbb_inv: 2d array
the inverse mode coupling matrix, not in use for 2dflat
compute_T_only: boolean
True to compute only T spectra
"""
ht_list = []
name_list = []
if not compute_T_only:
window = (window, window)
for map_info in maps_info_list:
split = so_map.read_map(map_info["name"], car_box=car_box)
if compute_T_only and map_info["data_type"] == "IQU":
split.data = split.data[0]
split.ncomp = 1
if map_info["cal"] is not None:
split.data *= map_info["cal"]
if ps_method in ["master", "pseudo"]:
print("SPHT of %s in the patch" % map_info["name"])
alms = sph_tools.get_alms(split, window, niter=0, lmax=lmax + 50)
ht_list += [alms]
elif ps_method == "2dflat":
print("FFT of %s in the patch" % map_info["name"])
ffts = flat_tools.get_ffts(split, window, lmax)
ht_list += [ffts]
name_list += [map_info["id"]]
split_num = np.arange(len(maps_info_list))
if compute_T_only:
if ps_method in ["master", "pseudo"]:
spectra = None
elif ps_method == "2dflat":
spectra = ["II"]
else:
if ps_method in ["master", "pseudo"]:
spectra = ["TT", "TE", "TB", "ET", "BT", "EE", "EB", "BE", "BB"]
elif ps_method == "2dflat":
spectra = ["II", "IQ", "IU", "QI", "QQ", "QU", "UI", "UQ", "UU"]
ps_dict = {}
spec_name_list = []
for name1, ht1, c1 in zip(name_list, ht_list, split_num):
for name2, ht2, c2 in zip(name_list, ht_list, split_num):
if c1 > c2: continue
spec_name = "%sx%s" % (name1, name2)
if ps_method in ["master", "pseudo"]:
l, ps = so_spectra.get_spectra(ht1, ht2, spectra=spectra)
ells, ps_dict[spec_name] = so_spectra.bin_spectra(
l,
ps,
binning_file,
lmax,
type=type,
mbb_inv=mbb_inv,
spectra=spectra)
elif ps_method == "2dflat":
ells, ps_dict[spec_name] = flat_tools.power_from_fft(ht1,
ht2,
type=type)
spec_name_list += [spec_name]
if compute_T_only:
# to make TT only behave the same as the other cases, make it a dictionnary
if ps_method in ["master", "pseudo"]:
spectra = ["TT"]
for spec_name in spec_name_list:
ps_dict[spec_name] = {"TT": ps_dict[spec_name]}
return spectra, spec_name_list, ells, ps_dict
plt.savefig("%s/corr_namaster.png" % (test_dir))
plt.clf()
plt.close()
print("cov mat sim")
nsims = 1000
Db_list = []
for iii in range(nsims):
print(iii)
cmb = template.copy()
cmb.data = hp.sphtfunc.synfast(ps_theory["TT"],
nside,
new=True,
verbose=False)
cmb.data -= np.mean(cmb.data * window.data)
alm = sph_tools.get_alms(cmb, window, niter, lmax)
ls, ps = so_spectra.get_spectra(alm, alm)
lb, Db = so_spectra.bin_spectra(ls,
ps,
binning_file,
lmax,
type=type,
mbb_inv=mbb_inv)
Db_list += [Db]
mean = np.mean(Db_list, axis=0)
std = np.std(Db_list, axis=0)
plt.plot(lb,
np.sqrt(cov_pspy.diagonal()) / np.sqrt(cov_namaster.diagonal()),
label="pspy/namaster")
def get_spectra(
window,
maps_info_list,
car_box,
type,
lmax,
binning_file,
ps_method="master",
mbb_inv=None,
compute_T_only=False,
vk_mask=None,
hk_mask=None,
transfer_function=None,
binary=None,
):
"""Compute the power spectra in the patch
Parameters
----------
window: so_map
the window function of the patch
maps_info_list: list of dicts describing the data maps
dictionnary should contain the name, the data type ("IQU" or "I") and optionally a calibration factor to apply to the map
note that all map in the list should have the same data type
car_box: 2x2 array
an array of the form [[dec0,rac0],[dec1,ra1]] it encompasses the patch
and we will only load in memory the map inside the box
type: string
the type of binning, either bin Cl or bin Dl
lmax : integer
the maximum multipole to consider for the spectra computation
ps_method: string
the method for the computation of the power spectrum
can be "master", "pseudo", or "2dflat" for now
binning_file: text file
a binning file with three columns bin low, bin high, bin mean
note that either binning_file or bin_size should be provided
mbb_inv: 2d array
the inverse mode coupling matrix, not in use for 2dflat
compute_T_only: boolean
True to compute only T spectra
vk_mask: list
the vertical band to filter out from 2D FFT (format is [-lx, +lx])
hk_mask: list
the horizontal band to filter out from 2D FFT (format is [-ly, +ly])
transfer_function: str
the path to the transfer function
binary: so_map
the binary mask to be used in the kspace filter process
"""
ht_list = []
name_list = []
if not compute_T_only:
window = (window, window)
for map_info in maps_info_list:
split = so_map.read_map(map_info["name"], car_box=car_box)
if compute_T_only and map_info["data_type"] == "IQU":
split.data = split.data[0]
split.ncomp = 1
if map_info["cal"] is not None:
split.data *= map_info["cal"]
use_kspace_filter = vk_mask is not None or hk_mask is not None
if use_kspace_filter:
timer.start("Filter {} in the patch...".format(
os.path.basename(map_info["name"])))
split = get_filtered_map(split, binary, vk_mask, hk_mask)
timer.stop()
if ps_method in ["master", "pseudo"]:
timer.start("SPHT of {} in the patch...".format(
os.path.basename(map_info["name"])))
alms = sph_tools.get_alms(split, window, niter=0, lmax=lmax + 50)
if use_kspace_filter:
alms /= np.product(split.data.shape[-2:])
ht_list += [alms]
timer.stop()
elif ps_method == "2dflat":
timer.start("FFT of {} in the patch...".format(
os.path.basename(map_info["name"])))
ffts = flat_tools.get_ffts(split, window, lmax)
ht_list += [ffts]
timer.stop()
name_list += [map_info["id"]]
split_num = np.arange(len(maps_info_list))
if compute_T_only:
if ps_method in ["master", "pseudo"]:
spectra = None
elif ps_method == "2dflat":
spectra = ["II"]
else:
if ps_method in ["master", "pseudo"]:
spectra = ["TT", "TE", "TB", "ET", "BT", "EE", "EB", "BE", "BB"]
elif ps_method == "2dflat":
spectra = ["II", "IQ", "IU", "QI", "QQ", "QU", "UI", "UQ", "UU"]
ps_dict = {}
spec_name_list = []
for name1, ht1, c1 in zip(name_list, ht_list, split_num):
for name2, ht2, c2 in zip(name_list, ht_list, split_num):
if c1 > c2:
continue
spec_name = "%sx%s" % (name1, name2)
if ps_method in ["master", "pseudo"]:
l, ps = so_spectra.get_spectra(ht1, ht2, spectra=spectra)
ells, ps_dict[spec_name] = so_spectra.bin_spectra(
l,
ps,
binning_file,
lmax,
type=type,
mbb_inv=mbb_inv,
spectra=spectra)
if use_kspace_filter:
_, _, tf, _ = np.loadtxt(transfer_function, unpack=True)
if compute_T_only:
ps_dict[spec_name] /= tf[np.where(ells < lmax)]
else:
for spec in spectra:
ps_dict[spec_name][spec] /= tf[np.where(
ells < lmax)]
elif ps_method == "2dflat":
ells, ps_dict[spec_name] = flat_tools.power_from_fft(ht1,
ht2,
type=type)
spec_name_list += [spec_name]
if compute_T_only:
# to make TT only behave the same as the other cases, make it a dictionnary
if ps_method in ["master", "pseudo"]:
spectra = ["TT"]
for spec_name in spec_name_list:
ps_dict[spec_name] = {"TT": ps_dict[spec_name]}
return spectra, spec_name_list, ells, ps_dict
window.plot(file_name="%s/window_%s_%s" % (plot_dir, scan, run),
title=scan)
window = (window, window)
mbb_inv, Bbl = so_mcm.mcm_and_bbl_spin0and2(window,
binning_file,
lmax=lmax,
type="Dl",
niter=niter,
save_file="%s/%s_%s" %
(mcm_dir, scan, run))
alm = {}
for split in split_list:
alm[split] = sph_tools.get_alms(sim[split], window, niter, lmax)
for c0, s0 in enumerate(split_list):
for c1, s1 in enumerate(split_list):
if c1 > c0: continue
spec_name = "%s_%sx%s_%s" % (scan, s0, s1, run)
l, ps = so_spectra.get_spectra(alm[s0],
alm[s1],
spectra=spectra)
lb, Db_dict[spec_name] = so_spectra.bin_spectra(
l,
ps,
binning_file,
lmax,
noise1 = so_map.white_noise(template, rms_uKarcmin_T=15)
split0 = cmb_car.copy()
split0.data += noise0.data
split1 = cmb_car.copy()
split1.data += noise1.data
split0_filt = split0.copy()
split1_filt = split1.copy()
split0_filt = so_map_preprocessing.get_map_kx_ky_filtered_pyfftw(
split0_filt, apo, d['filter_dict'])
split1_filt = so_map_preprocessing.get_map_kx_ky_filtered_pyfftw(
split1_filt, apo, d['filter_dict'])
alm0 = sph_tools.get_alms(split0, window_tuple, niter, lmax)
alm1 = sph_tools.get_alms(split1, window_tuple, niter, lmax)
alm0_filt = sph_tools.get_alms(split0_filt, window_tuple, niter, lmax)
alm1_filt = sph_tools.get_alms(split1_filt, window_tuple, niter, lmax)
l, ps = so_spectra.get_spectra(alm0, alm1, spectra=spectra)
l, ps_filt = so_spectra.get_spectra(alm0_filt,
alm1_filt,
spectra=spectra)
lb, Db_dict = so_spectra.bin_spectra(l,
ps,
binning_file,
lmax,
type=type,
