def test_mpi_read():
comm = MPI.COMM_WORLD
assert is_power2(
comm.size), "Run with a number of MPI processes which is power of 2"
nside = 64
npix = hp.nside2npix(nside)
num_local_pixels = npix // comm.size
if comm.size == 1:
pixel_indices = None
comm = None
else:
pixel_indices = np.arange(comm.rank * num_local_pixels,
(comm.rank + 1) * num_local_pixels,
dtype=np.int)
pysm_model = "s3,d7,f1,c1,a2"
sky_config = build_sky_config(pysm_model, nside, pixel_indices, comm)
sky = pysm.Sky(sky_config, mpi_comm=comm)
instrument_bpass = {
'use_smoothing': False,
'nside': nside,
'add_noise': False,
'use_bandpass': True,
'channels': [(np.linspace(20, 25, 10), np.ones(10))],
'channel_names': ['channel_1'],
'output_units': 'uK_RJ',
'output_directory': './',
'output_prefix': 'test',
'noise_seed': 1234,
'pixel_indices': pixel_indices
}
instrument = pysm.Instrument(instrument_bpass)
local_map = instrument.observe(sky, write_outputs=False)
# Run PySM again locally on each process on the full map
sky_config = build_sky_config(pysm_model, nside)
sky = pysm.Sky(sky_config, mpi_comm=comm)
instrument_bpass["pixel_indices"] = None
instrument = pysm.Instrument(instrument_bpass)
complete_map = instrument.observe(sky, write_outputs=False)
if pixel_indices is None:
pixel_indices = np.arange(npix)
np.testing.assert_array_almost_equal(local_map[0],
complete_map[0][:, :, pixel_indices])
def test_Sigma_dust_one_parameter(self):
NSIDE = 8
MODEL = 'd0'
INSTRUMENT = 'litebird'
SIGNAL_TO_NOISE = 10
sky = pysm.Sky(get_sky(NSIDE, MODEL))
instrument = pysm.Instrument(get_instrument(INSTRUMENT, NSIDE))
components = [cm.Dust(100., temp=20.)]
ref = []
for component in components:
ref += component.defaults
with suppress_stdout():
freq_maps, noise_maps = instrument.observe(sky,
write_outputs=False)
signal = freq_maps[:, 0, 0]
noise = noise_maps[:, 0]
signal_ver = signal / np.dot(signal, signal)**0.5
noise_std = np.std([np.dot(n, signal_ver) for n in noise.T])
maps = signal_ver * noise_std * SIGNAL_TO_NOISE
maps = maps[:, np.newaxis] + noise
res = basic_comp_sep(components,
instrument,
maps,
nside=hp.get_nside(maps))
white = (res.x[0] - ref[0]) / res.Sigma[0, 0]**0.5
_, p = kstest(white, 'norm')
assert p > 0.01
def test_Sigma_dust_sync_betas_temp(self):
NSIDE = 8
MODEL = 'd0s0'
INSTRUMENT = 'litebird'
SIGNAL_TO_NOISE = 10000
UNITS = 'uK_CMB'
sky = pysm.Sky(get_sky(NSIDE, MODEL))
instrument = pysm.Instrument(
get_instrument(INSTRUMENT, NSIDE, units=UNITS))
components = [
cm.Dust(150., temp=20., units=UNITS),
cm.Synchrotron(150., units=UNITS)
]
ref = []
for component in components:
ref += component.defaults
ref = np.array(ref)
with suppress_stdout():
freq_maps, noise_maps = instrument.observe(sky,
write_outputs=False)
signal = freq_maps[:, 0, 0] # Same signal for all the pixels
noise = noise_maps[:, 0]
signal_ver = signal / np.dot(signal, signal)**0.5
noise_std = np.std([np.dot(n, signal_ver) for n in noise.T])
maps = signal_ver * noise_std * SIGNAL_TO_NOISE
maps = maps[:, np.newaxis] + noise
res = basic_comp_sep(components, instrument, maps, nside=NSIDE)
diff = (res.x.T - ref)
postS = np.mean(diff[..., None] * diff[..., None, :], axis=0)
S = res.Sigma.T[0]
aac(postS, S, rtol=1. / NSIDE)
def test_smoothing(self):
instrument_config = self.instrument_config
instrument = pysm.Instrument(instrument_config)
smoothed = instrument.smoother(self.synch_1_30GHz)
np.testing.assert_almost_equal(smoothed[0][0],
self.synch_1_30GHz_smoothed,
decimal=3)
def exec(self, local_map, out, bandpasses=None):
if pysm is None:
raise RuntimeError('pysm not available')
autotimer = timing.auto_timer(type(self).__name__)
if self.sky is None:
self.sky = self.init_sky(
self.pysm_sky_config, self.pysm_precomputed_cmb_K_CMB
) if init_sky else None
pysm_instrument_config = {
'beams': None,
'nside': self._nside,
'use_bandpass': True,
'channels': None,
'channel_names': list(bandpasses.keys()),
'add_noise': False,
'output_units': self._units,
'use_smoothing': False,
'pixel_indices': self._local_pixels
}
for ch_name, bandpass in bandpasses.items():
pysm_instrument_config["channels"] = [bandpass]
instrument = pysm.Instrument(pysm_instrument_config)
out_name = (out + "_" + ch_name) if ch_name else out
# output of observe is a tuple, first item is the map
# however the map has 1 extra dimension of size 1,
# so we need to index [0] twice to get a map of (3, npix)
local_map[out_name] = \
instrument.observe(self.sky, write_outputs=False)[0][0]
assert local_map[out_name].shape[0] == 3
assert local_map[out_name].ndim == 2
def test_noise_write_partialsky(self):
local_instrument_config = self.instrument_config.copy()
npix = 20000
local_instrument_config["pixel_indices"] = np.arange(npix,
dtype=np.int)
instrument = pysm.Instrument(local_instrument_config)
s1 = models("s1",
self.nside,
pixel_indices=local_instrument_config["pixel_indices"])
s1[0]['A_I'] = np.zeros(npix)
s1[0]['A_Q'] = np.zeros(npix)
s1[0]['A_U'] = np.zeros(npix)
sky_config = {'synchrotron': s1}
partial_sky = pysm.Sky(sky_config)
instrument.observe(partial_sky)
# use masked array to handle partial sky
T, Q, U = hp.ma(
pysm.read_map(self.test_file, self.nside, field=(0, 1, 2)))
T_std = np.ma.std(T)
Q_std = np.ma.std(Q)
U_std = np.ma.std(U)
np.testing.assert_almost_equal(T_std, self.expected_T_std, decimal=2)
np.testing.assert_almost_equal(Q_std, self.expected_P_std, decimal=2)
np.testing.assert_almost_equal(U_std, self.expected_P_std, decimal=2)
def __init__(self, NSIDE, As):
self.NSIDE = NSIDE
self.Npix = 12 * NSIDE**2
self.As = As
print("Initialising sampler")
self.cosmo = Class()
#print("Maps")
#A recommenter
#self.Qs, self.Us, self.sigma_Qs, self.sigma_Us = aggregate_by_pixels_params(get_pixels_params(self.NSIDE))
#print("betas")
self.matrix_mean, self.matrix_var = aggregate_mixing_params(
get_mixing_matrix_params(self.NSIDE))
print("Cosmo params")
self.cosmo_means = np.array(COSMO_PARAMS_MEANS)
self.cosmo_stdd = np.diag(COSMO_PARAMS_SIGMA)
self.instrument = pysm.Instrument(
get_instrument('litebird', self.NSIDE))
self.components = [CMB(), Dust(150.), Synchrotron(150.)]
self.mixing_matrix = MixingMatrix(*self.components)
self.mixing_matrix_evaluator = self.mixing_matrix.evaluator(
self.instrument.Frequencies)
self.noise_covar_one_pix = self.noise_covariance_in_freq(self.NSIDE)
#A recommenter
#self.noise_stdd_all = np.concatenate([np.sqrt(self.noise_covar_one_pix) for _ in range(2*self.Npix)])
print("End of initialisation")
def __init__(self, NSIDE):
self.NSIDE = NSIDE
self.Npix = 12 * NSIDE**2
print("Initialising sampler")
self.cosmo = Class()
print("Maps")
self.templates_map, self.templates_var = aggregate_pixels_params(
get_pixels_params(self.NSIDE))
print("betas")
self.matrix_mean, self.matrix_var = aggregate_mixing_params(
get_mixing_matrix_params(self.NSIDE))
print("Cosmo params")
self.cosmo_means = np.array(COSMO_PARAMS_MEANS)
self.cosmo_var = (np.diag(COSMO_PARAMS_SIGMA) / 2)**2
plt.hist(self.templates_map)
plt.savefig("mean_values.png")
plt.close()
plt.hist(self.templates_var)
plt.savefig("std_values.png")
plt.close()
self.instrument = pysm.Instrument(
get_instrument('litebird', self.NSIDE))
self.components = [CMB(), Dust(150.), Synchrotron(150.)]
self.mixing_matrix = MixingMatrix(*self.components)
self.mixing_matrix_evaluator = self.mixing_matrix.evaluator(
self.instrument.Frequencies)
print("End of initialisation")
def test_dependence_on_nu0_RJ(self):
NSIDE = 8
MODEL = 'c1s0'
INSTRUMENT = 'litebird'
sky = pysm.Sky(get_sky(NSIDE, MODEL))
instrument = pysm.Instrument(
get_instrument(INSTRUMENT, NSIDE, units='uK_RJ'))
components100 = [
cm.CMB(units='K_RJ'),
cm.Synchrotron(100., units='K_RJ')
]
components10 = [
cm.CMB(units='K_RJ'),
cm.Synchrotron(10., units='K_RJ')
]
with suppress_stdout():
freq_maps, _ = instrument.observe(sky, write_outputs=False)
res100 = basic_comp_sep(components100, instrument, freq_maps)
res10 = basic_comp_sep(components10, instrument, freq_maps)
aac(res100.Sigma, res10.Sigma)
aac(res100.x, res10.x)
aac(res100.s[0], res10.s[0])
aac(res100.s[1], res10.s[1] * 10**res10.x[0])
def __init__(self, skyconfig, d):
Nf = d['nf_sub']
band = d['filter_nu'] / 1e9
filter_relative_bandwidth = d['filter_relative_bandwidth']
_, _, central_nus, _, _, _ = qubic.compute_freq(
band, Nf, filter_relative_bandwidth)
names = [np.str(np.round(cn, 2)) for cn in central_nus]
names = [n.replace('.', 'p') for n in names]
instrument = pysm.Instrument({
'nside': d['nside'],
'frequencies': central_nus, # GHz
'use_smoothing': False,
'beams': np.ones_like(central_nus), # arcmin
'add_noise': False,
'noise_seed': 0,
'sens_I': np.ones_like(central_nus),
'sens_P': np.ones_like(central_nus),
'use_bandpass': False,
'channel_names': names,
'channels': np.ones_like(central_nus),
'output_units': 'uK_RJ',
'output_directory': "./",
'output_prefix': "qubic",
'pixel_indices': None
})
sky.__init__(self, skyconfig, d, instrument)
def test_Sigma_synchrotron(self):
NSIDE = 8
MODEL = 's0'
INSTRUMENT = 'litebird'
SIGNAL_TO_NOISE = 20
sky = pysm.Sky(get_sky(NSIDE, MODEL))
instrument = pysm.Instrument(get_instrument(INSTRUMENT, NSIDE))
components = [cm.Synchrotron(100.)]
ref = []
for component in components:
ref += component.defaults
with suppress_stdout():
freq_maps, noise_maps = instrument.observe(sky,
write_outputs=False)
signal = freq_maps[:, 0, 0]
noise = np.std(noise_maps[:, 0], axis=-1)
maps = signal / np.dot(signal, noise) * SIGNAL_TO_NOISE
maps = maps[:, np.newaxis] + noise_maps[:, 0]
res = basic_comp_sep(components,
instrument,
maps,
nside=hp.get_nside(maps))
white = (res.x[0] - ref[0]) / res.Sigma[0, 0]**0.5
_, p = kstest(white, 'norm')
assert p > 0.01
def test_noise(self):
instrument = pysm.Instrument(self.instrument_config)
instrument.observe(self.sky)
T, Q, U = pysm.read_map(self.test_file, self.nside, field=(0, 1, 2))
T_std = np.std(T)
Q_std = np.std(Q)
U_std = np.std(U)
np.testing.assert_almost_equal(T_std, self.expected_T_std, decimal=2)
np.testing.assert_almost_equal(Q_std, self.expected_P_std, decimal=2)
np.testing.assert_almost_equal(U_std, self.expected_P_std, decimal=2)
def test_smoothing_partial_sky(self):
"""Smoothing on a partial sky sets the UNSEEN pixels to zero, so take a large fraction of the sky and check
only close to the galactic plane"""
pixel_indices = np.arange(10000, 30000, dtype=np.int)
instrument_config = self.instrument_config
instrument_config["pixel_indices"] = pixel_indices
instrument = pysm.Instrument(instrument_config)
smoothed = instrument.smoother(self.synch_1_30GHz[..., pixel_indices])
np.testing.assert_almost_equal(
smoothed[0, 0, 10000:10100],
self.synch_1_30GHz_smoothed[20000:20100],
decimal=1)
def __init__(self, skyconfig, d, output_directory="./", output_prefix="planck_sky", band=143):
self.band = band
self.planck_central_nus = np.array([30, 44, 70, 100, 143, 217, 353, 545, 857])
self.planck_relative_bandwidths = np.array([0.2, 0.2, 0.2, 0.33, 0.33, 0.33, 0.33, 0.33, 0.33])
self.planck_beams = np.array([33, 24, 14, 9.2, 7.1, 5.5, 5, 5, 5])
self.planck_Isensitivities_pixel = np.array([2, 2.7, 4.7, 2, 2.2, 4.8, 14.7, 147, 6700])
self.planck_Psensitivities_pixel = np.array([2.8, 3.9, 6.7, np.NaN, 4.2, 9.8, 29.8, np.NaN, np.NaN])
self.planck_channels = self.create_planck_bandwidth()
self.planck_channels_names = ['33_GHz', '44_GHz', '70_GHz', '100_GHz', '143_GHz', '217_GHz', '353_GHz',
'545_GHz', '857_GHz']
if band is not None:
idx = np.argwhere(self.planck_central_nus == band)[0][0]
instrument = pysm.Instrument(
{'nside': d['nside'], 'frequencies': self.planck_central_nus[idx:idx + 1], # GHz
'use_smoothing': True, 'beams': self.planck_beams[idx:idx + 1], # arcmin
'add_noise': True, # If True `sens_I` and `sens_Q` are required
'noise_seed': 0, # Not used if `add_noise` is False
'sens_I': self.get_planck_sensitivity("I")[idx:idx + 1], # Not used if `add_noise` is False
'sens_P': self.get_planck_sensitivity("P")[idx:idx + 1], # Not used if `add_noise` is False
'use_bandpass': True, # If True pass banpasses with the key `channels`
'channel_names': self.planck_channels_names[idx:idx + 1],
'channels': self.planck_channels[idx:idx + 1], 'output_units': 'uK_RJ',
'output_directory': output_directory, 'output_prefix': output_prefix, 'pixel_indices': None})
else:
instrument = pysm.Instrument({'nside': d['nside'], 'frequencies': self.planck_central_nus, # GHz
'use_smoothing': True, 'beams': self.planck_beams, # arcmin
'add_noise': True, # If True `sens_I` and `sens_Q` are required
'noise_seed': 0, # Not used if `add_noise` is False
'sens_I': self.get_planck_sensitivity("I"),
# Not used if `add_noise` is False
'sens_P': self.get_planck_sensitivity("P"),
# Not used if `add_noise` is False
'use_bandpass': True, # If True pass banpasses with the key `channels`
'channel_names': self.planck_channels_names, 'channels': self.planck_channels,
'output_units': 'uK_RJ', 'output_directory': output_directory,
'output_prefix': output_prefix, 'pixel_indices': None})
sky.__init__(self, skyconfig, d, instrument, output_directory, output_prefix)
def test_noise_partialsky(self):
local_instrument_config = self.instrument_config.copy()
local_instrument_config["pixel_indices"] = np.arange(20000,
dtype=np.int)
instrument = pysm.Instrument(local_instrument_config)
noise = instrument.noiser()
assert noise[0].shape == (
3, len(local_instrument_config["pixel_indices"]))
np.testing.assert_almost_equal(np.std(noise[0][0]),
self.expected_T_std,
decimal=2)
np.testing.assert_almost_equal(np.std(noise[0][1]),
self.expected_P_std,
decimal=2)
np.testing.assert_almost_equal(np.std(noise[0][2]),
self.expected_P_std,
decimal=2)
def setUp(self):
NSIDE = 16
MODEL = 'c1d0s0f1'
INSTRUMENT = 'litebird'
X0_FACTOR = 0.99
sky = pysm.Sky(get_sky(NSIDE, MODEL))
self.instrument = pysm.Instrument(get_instrument(INSTRUMENT, NSIDE))
with suppress_stdout():
self.freq_maps, self.noise = self.instrument.observe(
sky, write_outputs=False)
self.components = [cm.CMB(), cm.Dust(200.), cm.Synchrotron(100.)]
freefree = cm.PowerLaw(100.)
freefree.defaults = [-2.14] # Otherwise it is the same as Synchrotron
self.components.append(freefree)
self.input = []
for component in self.components:
self.input += component.defaults
component.defaults = [d * X0_FACTOR for d in component.defaults]
def __init__(self, skyconfig, d, output_directory="./", output_prefix="qubic_sky"):
_, nus_edge_in, central_nus, deltas, _, _ = qubic.compute_freq(d['filter_nu'] / 1e9, d['nf_sub'],
# Multiband instrument model
d['filter_relative_bandwidth'])
self.qubic_central_nus = central_nus
self.qubic_resolution_nus = 61.347409 / self.qubic_central_nus
self.qubic_channels_names = ["{:.3s}".format(str(i)) + "_GHz" for i in self.qubic_central_nus]
instrument = pysm.Instrument({'nside': d['nside'], 'frequencies': central_nus, # GHz
'use_smoothing': False, 'beams': np.ones_like(central_nus), # arcmin
'add_noise': False, # If True `sens_I` and `sens_Q` are required
'noise_seed': 0., # Not used if `add_noise` is False
'sens_I': np.ones_like(central_nus), # Not used if `add_noise` is False
'sens_P': np.ones_like(central_nus), # Not used if `add_noise` is False
'use_bandpass': False, # If True pass banpasses with the key `channels`
'channel_names': self.qubic_channels_names, # np.ones_like(central_nus),
'channels': np.ones_like(central_nus), 'output_units': 'uK_RJ',
'output_directory': output_directory, 'output_prefix': output_prefix,
'pixel_indices': None})
sky.__init__(self, skyconfig, d, instrument, output_directory, output_prefix)
def _get_instrument(tag, nside=None):
if 'dict' in tag:
instrument = {}
instrument['Frequencies'] = np.arange(10., 300, 30.)
if 'h**o' in tag:
instrument['Sens_I'] = (np.linspace(20., 40., 10) - 30)**2
instrument['Sens_P'] = instrument['Sens_I']
elif 'vary' in tag:
np.random.seed(0)
instrument['Cov_N'] = (np.linspace(20., 40., 10) - 30)**4
instrument['Cov_N'] /= hp.nside2resol(nside, arcmin=True)**2
shape = (instrument['Frequencies'].size, hp.nside2npix(nside))
factor = 10**np.random.uniform(-1, 1, size=np.prod(shape))
factor = factor.reshape(shape)
instrument['Cov_N'] = instrument['Cov_N'][:, np.newaxis] * factor
instrument['Cov_I'] = instrument['Cov_N'][:, np.newaxis]
instrument['Cov_P'] = np.stack([instrument['Cov_N']] * 2, axis=1)
elif 'pysm' in tag:
instrument = pysm.Instrument(get_instrument('test', nside))
else:
raise ValueError('Unsupported tag: %s' % tag)
return instrument
def __init__(self, skyconfig, d, band=143, channel_length=100):
self.band = band
self.planck_central_nus = np.array(
[30, 44, 70, 100, 143, 217, 353, 545, 857])
self.planck_relative_bandwidths = np.array(
[0.2, 0.2, 0.2, 0.33, 0.33, 0.33, 0.33, 0.33, 0.33])
self.planck_beams = np.array([33, 24, 14, 10, 7.1, 5, 5, 5, 5])
self.planck_Isensitivities_pixel = np.array(
[2, 2.7, 4.7, 2.5, 2.2, 4.8, 14.7, 147, 6700])
self.planck_Psensitivities_pixel = np.array(
[2.8, 3.9, 6.7, 4.0, 4.2, 9.8, 29.8, np.NaN, np.NaN])
self.planck_channels = self.create_planck_bandwidth(channel_length)
self.planck_channels_names = [
'33_GHz', '44_GHz', '70_GHz', '100_GHz', '143_GHz', '217_GHz',
'353_GHz', '545_GHz', '857_GHz'
]
if band is not None:
idx = np.argwhere(self.planck_central_nus == band)[0][0]
instrument = pysm.Instrument({
'nside':
d['nside'],
'frequencies':
self.planck_central_nus[idx:idx + 1], # GHz
'use_smoothing':
True,
'beams':
self.planck_beams[idx:idx + 1], # arcmin
'add_noise':
True,
'noise_seed':
0,
'sens_I':
self.get_planck_sensitivity("I")[idx:idx + 1],
'sens_P':
self.get_planck_sensitivity("P")[idx:idx + 1],
'use_bandpass':
True,
'channel_names':
self.planck_channels_names[idx:idx + 1],
'channels':
self.planck_channels[idx:idx + 1],
'output_units':
'uK_RJ',
'output_directory':
"./",
'output_prefix':
"planck_one",
'pixel_indices':
None
})
else:
instrument = pysm.Instrument({
'nside':
d['nside'],
'frequencies':
self.planck_central_nus, # GHz
'use_smoothing':
True,
'beams':
self.planck_beams, # arcmin
'add_noise':
True,
'noise_seed':
0,
'sens_I':
self.get_planck_sensitivity("I"),
'sens_P':
self.get_planck_sensitivity("P"),
'use_bandpass':
True,
'channel_names':
self.planck_channels_names,
'channels':
self.planck_channels,
'output_units':
'uK_RJ',
'output_directory':
"./",
'output_prefix':
"planck_all",
'pixel_indices':
None
})
sky.__init__(self, skyconfig, d, instrument)
def test_planck_sky(self):
maps_p = sky_p.get_sky_map()
maps_p_all = sky_p_all.get_sky_map()
for i in [0, 1, 2, 3, 5, 6, 7, 8]:
self.assertFalse(
np.allclose(np.std(maps_p_all[i], axis=0),
np.std(maps_p[0], axis=0),
atol=1e-2))
self.assertFalse(
np.allclose(np.mean(maps_p_all[i], axis=0),
np.mean(maps_p[0], axis=0),
atol=1e-2))
self.assertTrue(
np.allclose(np.std(maps_p_all[4], axis=0),
np.std(maps_p[0], axis=0),
atol=1e-2))
self.assertTrue(
np.allclose(np.mean(maps_p_all[4], axis=0),
np.mean(maps_p[0], axis=0),
atol=1e-2))
instrument_nless_pless = pysm.Instrument({
'nside':
d['nside'],
'frequencies':
sky_p.planck_central_nus[4:5], # GHz
'use_smoothing':
False,
'beams':
None, # arcmin
'add_noise':
False,
'noise_seed':
None,
'sens_I':
None,
'sens_P':
None,
'use_bandpass':
True,
'channel_names':
sky_p.planck_channels_names[4:5],
'channels':
sky_p.planck_channels[4:5],
'output_units':
'Jysr',
'output_directory':
"./",
'output_prefix':
"planck_sky_pless_nless",
'pixel_indices':
None
})
sky_p_nless_pless = si.sky(sky_config, d, instrument_nless_pless)
maps_p_nless_pless = sky_p_nless_pless.get_sky_map()
disintegrated_maps = np.rollaxis(
sky_p_nless_pless.sky.signal()(nu=sky_p.planck_channels[4:5][0][0])
* pysm.pysm.convert_units(
"uK_RJ", "Jysr", sky_p.planck_channels[4:5][0][0])[..., None,
None], 2, 1)
integrated_maps = np.mean(disintegrated_maps, axis=0)
self.assertTrue(np.allclose(maps_p_nless_pless, integrated_maps))
instrument_noisy = pysm.Instrument({
'nside':
d['nside'],
'frequencies':
sky_p.planck_central_nus[4:5], # GHz
'use_smoothing':
False,
'beams':
None, # arcmin
'add_noise':
True,
'noise_seed':
0,
'sens_I':
sky_p.get_planck_sensitivity("I")[4:5],
'sens_P':
sky_p.get_planck_sensitivity("P")[4:5],
'use_bandpass':
False,
'channel_names':
sky_p.planck_channels_names[4:5],
'channels':
None,
'output_units':
'uK_RJ',
'output_directory':
"./",
'output_prefix':
"planck_sky_noisy",
'pixel_indices':
None
})
sky_p_noisy = si.sky(sky_config, d, instrument_noisy)
maps_p_noisy, noise_map_produced = sky_p_noisy.get_sky_map(
noise_map=True)
noise_map = maps_p_noisy[0] - sky_p.sky.signal()(
nu=sky_p.planck_central_nus[4:5]).T
self.assertTrue(np.allclose(noise_map, noise_map_produced))
c = np.sqrt(hp.nside2pixarea(d['nside'], degrees=True)) * 60 # arcmin
C = pysm.pysm.convert_units("uK_RJ", "uK_CMB",
sky_p.planck_central_nus[4:5][0])
self.assertTrue(
np.allclose(np.std(noise_map, axis=0)[0] * c * C,
sky_p.get_planck_sensitivity("I")[4:5],
atol=1e-1))
self.assertTrue(
np.allclose(np.std(noise_map, axis=0)[1] * c * C,
sky_p.get_planck_sensitivity("P")[4:5],
atol=1e-1))
self.assertTrue(
np.allclose(np.std(noise_map, axis=0)[2] * c * C,
sky_p.get_planck_sensitivity("P")[4:5],
atol=1e-1))
sm_pns = sky_p.planck_beams[4:5][0] * np.pi / (60 * 180)
jysky = sky_p.instrument.apply_bandpass(sky_p.sky.signal(), sky_p.sky)
maps_a = sky_p.instrument.smoother(jysky)[0].T
maps_b = hp.smoothing(jysky[0], fwhm=sm_pns).T
self.assertTrue(np.allclose(maps_a, maps_b))
# instrument_mono = pysm.Instrument({
# 'nside': d['nside'],
# 'frequencies' : sky_p.planck_central_nus[4:5], # GHz
# 'use_smoothing' : True,
# 'beams' : sky_p.planck_beams[4:5], # arcmin
# 'add_noise' : True,
# 'noise_seed' : 0,
# 'sens_I': sky_p.get_planck_sensitivity("I")[4:5],
# 'sens_P': sky_p.get_planck_sensitivity("P")[4:5],
# 'use_bandpass' : False,
# 'channel_names' : sky_p.planck_channels_names[4:5],
# 'channels' : None,
# 'output_units' : 'uK_RJ',
# 'output_directory' : "./",
# 'output_prefix' : "planck_sky_mono",
# 'pixel_indices' : None})
# sky_p_mono = si.sky(sky_config, d, instrument_mono)
# maps_p_mono = sky_p_mono.get_sky_map()
# self.assertTrue(maps_p_mono.shape == (1, 196608, 3))
# instrument_mono_nless = pysm.Instrument({
# 'nside': d['nside'],
# 'frequencies' : sky_p.planck_central_nus[4:5], # GHz
# 'use_smoothing' : True,
# 'beams' : sky_p.planck_beams[4:5], # arcmin
# 'add_noise' : False,
# 'noise_seed' : None,
# 'sens_I': None,
# 'sens_P': None,
# 'use_bandpass' : False,
# 'channel_names' : sky_p.planck_channels_names[4:5],
# 'channels' : None,
# 'output_units' : 'uK_RJ',
# 'output_directory' : "./",
# 'output_prefix' : "planck_sky_nless_mono",
# 'pixel_indices' : None})
# sky_p_mono_nless = si.sky(sky_config, d, instrument_mono_nless)
# maps_p_mono_nless = sky_p_mono_nless.get_sky_map()
# self.assertTrue(maps_p_mono_nless.shape == (1, 196608, 3))
instrument_mono_nless_pless = pysm.Instrument({
'nside':
d['nside'],
'frequencies':
sky_p.planck_central_nus[4:5], # GHz
'use_smoothing':
False,
'beams':
None, # arcmin
'add_noise':
False,
'noise_seed':
None,
'sens_I':
None,
'sens_P':
None,
'use_bandpass':
False,
'channel_names':
sky_p.planck_channels_names[4:5],
'channels':
None,
'output_units':
'uK_RJ',
'output_directory':
"./",
'output_prefix':
"planck_sky_pless_nless_mono",
'pixel_indices':
None
})
sky_p_mono_nless_pless = si.sky(sky_config, d,
instrument_mono_nless_pless)
maps_p_mono_nless_pless = sky_p_mono_nless_pless.get_sky_map()
self.assertTrue(
np.allclose(maps_p_mono_nless_pless[0],
pysm.Sky(sky_config).signal()(nu=143).T))
def test_d0s0(self):
# EXTERNAL_xFORECAST_RUN RESULTS
EXT_BETA = [1.54000015, 19.99999402, -3.00000035]
EXT_SIGMA_BETA = np.array(
[[1.07107731e+09, 1.02802459e+07, 3.05900728e+07],
[1.02802459e+07, 8.80751745e+05, 2.64258857e+05],
[3.05900728e+07, 2.64258857e+05, 8.80649611e+05]])
EXT_NOISE_POST_COMP_SEP = [
6.985360419978725e-07, 6.954968812329504e-07,
6.952971018678473e-07, 6.97621370087622e-07, 6.97915989771863e-07,
6.981532542428136e-07, 6.984690244398313e-07,
6.963706038663776e-07, 6.962958090983174e-07,
6.999793141962897e-07, 6.966029199088166e-07,
6.998332244730213e-07, 6.97245540450936e-07, 7.013469190449905e-07,
6.98145319051069e-07, 6.997552902541847e-07, 7.006828378883164e-07,
6.993357502111902e-07, 7.016843277673384e-07, 7.02276431905913e-07,
7.009651598790946e-07, 7.024327502574484e-07,
7.058590396724249e-07, 7.035637090541009e-07,
7.034402740635456e-07, 7.05326337473677e-07, 7.086905417607417e-07,
7.067287662339356e-07, 7.06396320822362e-07, 7.075857215168964e-07,
7.102089978543108e-07, 7.118461226661247e-07
]
EXT_CL_STAT_RES = [
3.43065437e-08, 2.13752688e-07, 2.50160994e-08, 4.39734801e-08,
1.75192647e-08, 2.10382699e-08, 9.55361360e-09, 8.80726572e-09,
7.34671936e-09, 4.24354505e-09, 3.50430309e-09, 3.21803173e-09,
3.62342203e-09, 1.83222822e-09, 2.40687985e-09, 1.76806752e-09,
2.57252032e-09, 1.19987889e-09, 1.71606507e-09, 1.01867261e-09,
1.11709059e-09, 1.05584166e-09, 8.37499498e-10, 1.04610499e-09,
7.27953346e-10, 7.55604710e-10, 5.50190292e-10, 6.38657310e-10,
4.82912230e-10, 5.21029442e-10, 4.77954181e-10
]
EXT_BIAS_R = 0.00100556
EXT_SIGMA_R = 0.0003163
nside = 16
# define sky and foregrounds simulations
sky = pysm.Sky(get_sky(nside, 'd0s0'))
# define instrument
instrument = pysm.Instrument(get_instrument('litebird', nside))
# get noiseless frequency maps
with suppress_stdout():
freq_maps = instrument.observe(sky, write_outputs=False)[0]
# take only the Q and U maps
freq_maps = freq_maps[:, 1:]
# define components used in the modeling
components = [CMB(), Dust(150.), Synchrotron(150.)]
# call for xForecast
with suppress_stdout():
res = xForecast(components,
instrument,
freq_maps,
2,
2 * nside - 1,
1.0,
make_figure=False)
# list of checks
aac(EXT_BETA, res.x, rtol=1e-03)
aac(np.diag(EXT_SIGMA_BETA), np.diag(res.Sigma_inv), rtol=5e-02)
aac(EXT_NOISE_POST_COMP_SEP[0], res.noise[0], rtol=1e-02)
aac(EXT_BIAS_R, res.cosmo_params['r'][0][0], rtol=1e-02)
aac(EXT_SIGMA_R, res.cosmo_params['r'][1][0], rtol=1e-02)
hp.mollview(sigma_U_dust, sub=(248), title='sigma U dust')
pl.show()
# exit()
def p_template_computation(temp_):
logprob = -0.5*np.sum(templates_map**2/np.diag(covariance_templates)**2)
return logprob
# build a random vector of template of size 4 x Npix
# for example :
template_test = np.random.normal(0,1,(4,Npix))
print p_template_computation(template_test)
'''
############################################
#### CONSTRUCTING THE MIXING MATRIX A
############################################
# define the instrumental specifications
instrument = pysm.Instrument(get_instrument(NSIDE, 'litebird'))
# define the components in the sky and their scaling laws
components=[CMB(), Dust(150.), Synchrotron(150.)]
# initiate function to estimate scaling laws for LiteBIRD frequencies
A = MixingMatrix(*components)
A_ev = A.evaluator(instrument.Frequencies)
print(A_ev([1.56,20,-3.1]).shape)
print(instrument.Frequencies)
'''
####################################################
#### CONSTRUCTING TEMPLATES OF BETA AND SIGMA BETA
#### -> p(\beta} \propto exp[-1/2 (\beta-\bar{\beta})^T \sigma_\beta^{-2} (\beta-\bar{\beta})]
####################################################
dust_spectral_indices_ = hp.read_map('COM_CompMap_dust-commander_0256_R2.00.fits', field=(3,5,6,8))
dust_spectral_indices_ = hp.ud_grade(dust_spectral_indices_, nside_out=NSIDE)
def test_no_smoothing(self):
instrument_config = self.instrument_config
instrument_config['use_smoothing'] = False
instrument = pysm.Instrument(instrument_config)
smoothed = instrument.smoother(self.synch_1_30GHz)
np.testing.assert_almost_equal(smoothed, self.synch_1_30GHz, decimal=6)
#Instrument config
instr_config = {
'nside': nside,
'frequencies': nu,
'use_smoothing': True,
'beams': np.ones(len(nu)) * 30., # arcmin
'add_noise': True,
'sens_I': np.ones(len(nu)) * sense_P / np.sqrt(2),
'sens_P': np.ones(len(nu)) * sense_P,
'noise_seed': seed + i,
'use_bandpass': False,
'output_units': 'uK_RJ',
'output_directory': outdir,
'output_prefix': 'test',
}
instr = pysm.Instrument(instr_config)
x = instr.observe(sky, write_outputs=False)
tot_map_flat = x[0][:, :, hp_pixels]
noise = x[1][:, :, hp_pixels]
#tot_map_flat = instr.observe(sky, write_outputs=False)[0][:,:,hp_pixels]
tot_map_flat = np.array(tot_map_flat, dtype=np.float32)
np.save(
os.path.join(
outdir, 'total_signal_SV_' + str(int(npix)) + 'x' +
str(int(npix)) + '_senseP' + str(sense_P) + '_seed' +
str(int(seed)) + '_nu' + str(len(nu)),
'tot_' + str(i).zfill(6) + '.npy'), tot_map_flat)
def get_sky_realization(nside, seed=None, mean_pars=None, moment_pars=None,
compute_cls=False, delta_ell=10):
""" Generate a sky realization for a set of input sky parameters.
Args:
nside: HEALPix resolution parameter.
seed: seed to be used (if `None`, then a random seed will
be used).
mean_pars: mean parameters (see `get_default_params`).
If `None`, then a default set will be used.
moment_pars: mean parameters (see `get_default_params`).
If `None`, then a default set will be used.
compute_cls: return also the power spectra? Default: False.
delta_ell: bandpower size to use if compute_cls is True.
Returns:
A dictionary containing the different component maps,
spectral index maps and frequency maps.
If `compute_cls=True`, then the dictionary will also
contain power spectrum information.
"""
nu = get_freqs()
npix = hp.nside2npix(nside)
if seed is not None:
np.random.seed(seed)
if mean_pars is None:
mean_pars, _ = get_default_params()
if moment_pars is None:
_, moment_pars = get_default_params()
lmax = 3*nside-1
ells, dl2cl, cl2dl, cl_dust_bb, cl_dust_ee, cl_sync_bb, cl_sync_ee, cl_cmb_bb, cl_cmb_ee = get_mean_spectra(lmax, mean_pars)
cl0 = 0 * cl_dust_bb
# Dust amplitudes
Q_dust, U_dust = hp.synfast([cl0, cl_dust_ee, cl_dust_bb, cl0, cl0, cl0],
nside, new=True, verbose=False)[1:]
# Sync amplitudes
Q_sync, U_sync = hp.synfast([cl0, cl_sync_ee, cl_sync_bb, cl0, cl0, cl0],
nside, new=True, verbose=False)[1:]
# CMB amplitude
Q_cmb, U_cmb = hp.synfast([cl0, cl_cmb_ee, cl_cmb_bb, cl0, cl0, cl0],
nside, new=True, verbose=False)[1:]
# Dust spectral index
beta_dust = get_beta_map(nside,
mean_pars['beta_dust'],
moment_pars['amp_beta_dust'],
moment_pars['gamma_beta_dust'],
moment_pars['l0_beta_dust'],
moment_pars['l_cutoff_beta_dust'])
# Dust temperature
temp_dust = np.ones(npix) * mean_pars['temp_dust']
# Synchrotron spectral index
beta_sync = get_beta_map(nside,
mean_pars['beta_sync'],
moment_pars['amp_beta_sync'],
moment_pars['gamma_beta_sync'],
moment_pars['l0_beta_sync'],
moment_pars['l_cutoff_beta_sync'])
# Create PySM simulation
zeromap = np.zeros(npix)
# Dust
d2 = models("d2", nside)
d2[0]['nu_0_I'] = mean_pars['nu0_dust']
d2[0]['nu_0_P'] = mean_pars['nu0_dust']
d2[0]['A_I'] = zeromap
d2[0]['A_Q'] = Q_dust
d2[0]['A_U'] = U_dust
d2[0]['spectral_index'] = beta_dust
d2[0]['temp'] = temp_dust
# Sync
s1 = models("s1", nside)
s1[0]['nu_0_I'] = mean_pars['nu0_sync']
s1[0]['nu_0_P'] = mean_pars['nu0_sync']
s1[0]['A_I'] = zeromap
s1[0]['A_Q'] = Q_sync
s1[0]['A_U'] = U_sync
s1[0]['spectral_index'] = beta_sync
# CMB
c1 = models("c1", nside)
c1[0]['model'] = 'pre_computed' #different output maps at different seeds
c1[0]['A_I'] = zeromap
c1[0]['A_Q'] = Q_cmb
c1[0]['A_U'] = U_cmb
sky_config = {'dust' : d2, 'synchrotron' : s1, 'cmb' : c1}
sky = pysm.Sky(sky_config)
instrument_config = {
'nside' : nside,
'frequencies' : nu, #Expected in GHz
'use_smoothing' : False,
'beams' : np.ones_like(nu), #Expected in arcmin
'add_noise' : False,
'use_bandpass' : False,
'channel_names' : ['LF1', 'LF2', 'MF1', 'MF2', 'UHF1', 'UHF2'],
'output_units' : 'uK_RJ',
'output_directory' : 'none',
'output_prefix' : 'none',
}
sky = pysm.Sky(sky_config)
instrument = pysm.Instrument(instrument_config)
maps_signal, _ = instrument.observe(sky, write_outputs=False)
maps_signal = maps_signal[:,1:,:]
# Change to CMB units
maps_signal = maps_signal/fcmb(nu)[:,None,None]
dict_out = {'maps_dust': np.array([Q_dust, U_dust]),
'maps_sync': np.array([Q_sync, U_sync]),
'maps_cmb': np.array([Q_cmb, U_cmb]),
'beta_dust': beta_dust,
'beta_sync': beta_sync,
'freq_maps': maps_signal}
if compute_cls:
cls_unbinned = map2cl(maps_signal)
l_binned, windows, cls_binned = bin_cls(cls_unbinned,
delta_ell=delta_ell)
indices, cls_binned, cov_binned = get_vector_and_covar(l_binned,
cls_binned)
dict_out['ls_unbinned'] = ells
dict_out['cls_unbinned'] = cls_unbinned
dict_out['ls_binned'] = l_binned
dict_out['cls_binned'] = cls_binned
dict_out['cov_binned'] = cov_binned
dict_out['ind_cl'] = indices
dict_out['windows'] = windows
return dict_out
bandpass_low = det["Frequency"] - det["Bandwidth"]/2
bandpass_high = det["Frequency"] + det["Bandwidth"]/2
unit = 'uK_CMB'
use_bandpass = False
output_directory = 'pysm_components/nside{}_{}bandpass_{}'.format(nside, "tophat" if use_bandpass else "delta", unit)
os.makedirs(output_directory, exist_ok=True)
instrument_bpass = {
'use_smoothing' : True,
'beams' : np.array([det["Beam_FWHM"]]),
'nside' : nside,
'add_noise' : False,
'use_bandpass' : use_bandpass,
'channels' : [(np.linspace(bandpass_low, bandpass_high, 10), np.ones(10))],
'frequencies' : [det["Frequency"]],
'output_units' : unit,
'output_directory' : output_directory,
'output_prefix' : 'pico',
'noise_seed' : 1234,
}
for c in components:
full_name = components_name[c[0]]
instrument_bpass['channel_names'] = [f'band_{band}_{full_name}_{unit}']
sky_config = { full_name : models(c, nside=nside) }
sky = pysm.Sky(sky_config)
instrument = pysm.Instrument(instrument_bpass)
instrument.observe(sky)
Npix = 12 * NSIDE**2
COSMO_PARAMS_NAMES = [
"n_s", "omega_b", "omega_cdm", "100*theta_s", "ln10^{10}A_s", "tau_reio"
]
COSMO_PARAMS_MEANS = [0.9665, 0.02242, 0.11933, 1.04101, 3.047, 0.0561]
COSMO_PARAMS_SIGMA = [0.0038, 0.00014, 0.00091, 0.00029, 0.014, 0.0071]
LiteBIRD_sensitivities = np.array([
36.1, 19.6, 20.2, 11.3, 10.3, 8.4, 7.0, 5.8, 4.7, 7.0, 5.8, 8.0, 9.1, 11.4,
19.6
])
Qs, Us, sigma_Qs, sigma_Us = aggregate_by_pixels_params(
get_pixels_params(NSIDE))
instrument = pysm.Instrument(get_instrument('litebird', NSIDE))
components = [CMB(), Dust(150.), Synchrotron(150.)]
mixing_matrix = MixingMatrix(*components)
mixing_matrix_evaluator = mixing_matrix.evaluator(instrument.Frequencies)
def noise_covariance_in_freq(nside):
cov = LiteBIRD_sensitivities**2 / hp.nside2resol(nside, arcmin=True)**2
return cov
noise_covar_one_pix = noise_covariance_in_freq(NSIDE)
def sample_mixing_matrix_parallel(betas):
return mixing_matrix_evaluator(betas)[:, 1:]
