def setUp(self):
data_dir = get_template_dir()
a1_config = models("a1", 64)
AME1 = components.AME(a1_config[0])
AME2 = components.AME(a1_config[1])
signal = lambda nu: AME1.signal()(nu) + AME2.signal()(nu)
ame_1_30GHz = read_map(get_testdata('benchmark',
'check3spinn_30p0_64.fits'),
64,
field=(0, 1, 2))
ame_1_100GHz = read_map(get_testdata('benchmark',
'check3spinn_100p0_64.fits'),
64,
field=(0, 1, 2))
ame_1_353GHz = read_map(get_testdata('benchmark',
'check3spinn_353p0_64.fits'),
64,
field=(0, 1, 2))
self.frac_diff_30GHz = (ame_1_30GHz[0] -
signal(30.)[0]) / (ame_1_30GHz[0] + 1.e-14)
self.frac_diff_100GHz = (ame_1_100GHz[0] -
signal(100.)[0]) / (ame_1_100GHz[0] + 1e-14)
self.frac_diff_353GHz = (ame_1_353GHz[0] -
signal(353.)[0]) / (ame_1_353GHz[0] + 1e-14)
def setUp(self):
data_dir = get_template_dir()
f1_config = models("f1", 64)
freefree = components.Freefree(f1_config[0])
signal = freefree.signal()
freefree_1_30GHz = read_map(get_testdata('benchmark',
'check4freef_30p0_64.fits'),
64,
field=(0, 1, 2))
freefree_1_100GHz = read_map(get_testdata('benchmark',
'check4freef_100p0_64.fits'),
64,
field=(0, 1, 2))
freefree_1_353GHz = read_map(get_testdata('benchmark',
'check4freef_353p0_64.fits'),
64,
field=(0, 1, 2))
self.frac_diff_30GHz = (freefree_1_30GHz[0] - signal(30.)[0]) / (
freefree_1_30GHz[0] + 1.e-14)
self.frac_diff_100GHz = (freefree_1_100GHz[0] - signal(100.)[0]) / (
freefree_1_100GHz[0] + 1e-14)
self.frac_diff_353GHz = (freefree_1_353GHz[0] - signal(353.)[0]) / (
freefree_1_353GHz[0] + 1e-14)
def setUp(self):
data_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'pysm', 'template'))
test_data_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), 'test_data', 'benchmark'))
s1_config = models("s1", 64)
synchrotron = components.Synchrotron(s1_config[0])
signal = synchrotron.signal()
synch_1_30GHz = read_map(os.path.join(test_data_dir, 'check2synch_30p0_64.fits'), 64, field = (0, 1, 2))
synch_1_100GHz = read_map(os.path.join(test_data_dir, 'check2synch_100p0_64.fits'), 64, field = (0, 1, 2))
synch_1_353GHz = read_map(os.path.join(test_data_dir, 'check2synch_353p0_64.fits'), 64, field = (0, 1, 2))
self.model_1_frac_diff = (synch_1_30GHz - signal(30.)) / synch_1_30GHz
self.model_1_frac_diff = (synch_1_30GHz - signal(30.)) / synch_1_30GHz
self.model_1_frac_diff = (synch_1_30GHz - signal(30.)) / synch_1_30GHz
s2_config = models("s2", 64)
synchrotron = components.Synchrotron(s2_config[0])
signal = synchrotron.signal()
synch_1_30GHz = read_map(os.path.join(test_data_dir, 'check7synch_30p0_64.fits'), 64, field = (0, 1, 2))
synch_1_100GHz = read_map(os.path.join(test_data_dir, 'check7synch_100p0_64.fits'), 64, field = (0, 1, 2))
synch_1_353GHz = read_map(os.path.join(test_data_dir, 'check7synch_353p0_64.fits'), 64, field = (0, 1, 2))
self.model_2_frac_diff = (synch_2_30GHz - signal(30.)) / synch_2_30GHz
self.model_2_frac_diff = (synch_2_30GHz - signal(30.)) / synch_2_30GHz
self.model_2_frac_diff = (synch_2_30GHz - signal(30.)) / synch_2_30GHz
s3_config = models("s3", 64)
synchrotron = components.Synchrotron(s3_config[0])
signal = synchrotron.signal()
synch_3_30GHz = read_map(os.path.join(test_data_dir, 'check10synch_30p0_64.fits'), 64, field = (0, 1, 2))
synch_3_100GHz = read_map(os.path.join(test_data_dir, 'check10synch_100p0_64.fits'), 64, field = (0, 1, 2))
synch_3_353GHz = read_map(os.path.join(test_data_dir, 'check10synch_353p0_64.fits'), 64, field = (0, 1, 2))
self.model_1_frac_diff = (synch_3_30GHz - signal(30.)) / synch_1_30GHz
self.model_1_frac_diff = (synch_3_30GHz - signal(30.)) / synch_1_30GHz
self.model_1_frac_diff = (synch_3_30GHz - signal(30.)) / synch_1_30GHz
def test_Synch_model_1(self):
np.testing.assert_array_almost_equal(self.model_1_frac_diff_30GHz, np.zeros_like(self.model_1_frac_diff_30GHz), decimal = 6)
np.testing.assert_array_almost_equal(self.model_1_frac_diff_100GHz, np.zeros_like(self.model_1_frac_diff_30GHz), decimal = 6)
np.testing.assert_array_almost_equal(self.model_1_frac_diff_353GHz, np.zeros_like(self.model_1_frac_diff_30GHz), decimal = 6)
def test_Synch_model_2(self):
np.testing.assert_array_almost_equal(self.model_2_frac_diff_30GHz, np.zeros_like(self.model_2_frac_diff_30GHz), decimal = 6)
np.testing.assert_array_almost_equal(self.model_2_frac_diff_100GHz, np.zeros_like(self.model_2_frac_diff_30GHz), decimal = 6)
np.testing.assert_array_almost_equal(self.model_2_frac_diff_353GHz, np.zeros_like(self.model_2_frac_diff_30GHz), decimal = 6)
def test_Synch_model_3(self):
np.testing.assert_array_almost_equal(self.model_3_frac_diff_30GHz, np.zeros_like(self.model_3_frac_diff_30GHz), decimal = 6)
np.testing.assert_array_almost_equal(self.model_3_frac_diff_100GHz, np.zeros_like(self.model_3_frac_diff_30GHz), decimal = 6)
np.testing.assert_array_almost_equal(self.model_3_frac_diff_353GHz, np.zeros_like(self.model_3_frac_diff_30GHz), decimal = 6)
def setUp(self):
data_dir = get_template_dir()
f1_config = models("f1", 64)
freefree = components.Freefree(f1_config[0])
signal = freefree.signal()
freefree_1_30GHz = read_map(get_testdata('benchmark', 'check4freef_30p0_64.fits'), 64, field = (0, 1, 2))
freefree_1_100GHz = read_map(get_testdata('benchmark', 'check4freef_100p0_64.fits'), 64, field = (0, 1, 2))
freefree_1_353GHz = read_map(get_testdata('benchmark', 'check4freef_353p0_64.fits'), 64, field = (0, 1, 2))
self.frac_diff_30GHz = (freefree_1_30GHz[0] - signal(30.)[0]) / (freefree_1_30GHz[0] + 1.e-14)
self.frac_diff_100GHz = (freefree_1_100GHz[0] - signal(100.)[0]) / (freefree_1_100GHz[0] + 1e-14)
self.frac_diff_353GHz = (freefree_1_353GHz[0] - signal(353.)[0]) / (freefree_1_353GHz[0] +1e-14)
def setUp(self):
data_dir = get_template_dir()
s1_config = models("s1", 64)
synchrotron = components.Synchrotron(s1_config[0])
signal = synchrotron.signal()
synch_1_30GHz = read_map(get_testdata('benchmark', 'check2synch_30p0_64.fits'), 64, field = (0, 1, 2))
synch_1_100GHz = read_map(get_testdata('benchmark', 'check2synch_100p0_64.fits'), 64, field = (0, 1, 2))
synch_1_353GHz = read_map(get_testdata('benchmark', 'check2synch_353p0_64.fits'), 64, field = (0, 1, 2))
self.model_1_frac_diff = (synch_1_30GHz - signal(30.)) / synch_1_30GHz
self.model_1_frac_diff = (synch_1_30GHz - signal(30.)) / synch_1_30GHz
self.model_1_frac_diff = (synch_1_30GHz - signal(30.)) / synch_1_30GHz
s2_config = models("s2", 64)
synchrotron = components.Synchrotron(s2_config[0])
signal = synchrotron.signal()
synch_1_30GHz = read_map(get_testdata('benchmark', 'check7synch_30p0_64.fits'), 64, field = (0, 1, 2))
synch_1_100GHz = read_map(get_testdata('benchmark', 'check7synch_100p0_64.fits'), 64, field = (0, 1, 2))
synch_1_353GHz = read_map(get_testdata('benchmark', 'check7synch_353p0_64.fits'), 64, field = (0, 1, 2))
self.model_2_frac_diff = (synch_2_30GHz - signal(30.)) / synch_2_30GHz
self.model_2_frac_diff = (synch_2_30GHz - signal(30.)) / synch_2_30GHz
self.model_2_frac_diff = (synch_2_30GHz - signal(30.)) / synch_2_30GHz
s3_config = models("s3", 64)
synchrotron = components.Synchrotron(s3_config[0])
signal = synchrotron.signal()
synch_3_30GHz = read_map(get_testdata('benchmark', 'check10synch_30p0_64.fits'), 64, field = (0, 1, 2))
synch_3_100GHz = read_map(get_testdata('benchmark', 'check10synch_100p0_64.fits'), 64, field = (0, 1, 2))
synch_3_353GHz = read_map(get_testdata('benchmark', 'check10synch_353p0_64.fits'), 64, field = (0, 1, 2))
self.model_1_frac_diff = (synch_3_30GHz - signal(30.)) / synch_1_30GHz
self.model_1_frac_diff = (synch_3_30GHz - signal(30.)) / synch_1_30GHz
self.model_1_frac_diff = (synch_3_30GHz - signal(30.)) / synch_1_30GHz
def test_Synch_model_1(self):
np.testing.assert_array_almost_equal(self.model_1_frac_diff_30GHz, np.zeros_like(self.model_1_frac_diff_30GHz), decimal = 6)
np.testing.assert_array_almost_equal(self.model_1_frac_diff_100GHz, np.zeros_like(self.model_1_frac_diff_30GHz), decimal = 6)
np.testing.assert_array_almost_equal(self.model_1_frac_diff_353GHz, np.zeros_like(self.model_1_frac_diff_30GHz), decimal = 6)
def test_Synch_model_2(self):
np.testing.assert_array_almost_equal(self.model_2_frac_diff_30GHz, np.zeros_like(self.model_2_frac_diff_30GHz), decimal = 6)
np.testing.assert_array_almost_equal(self.model_2_frac_diff_100GHz, np.zeros_like(self.model_2_frac_diff_30GHz), decimal = 6)
np.testing.assert_array_almost_equal(self.model_2_frac_diff_353GHz, np.zeros_like(self.model_2_frac_diff_30GHz), decimal = 6)
def test_Synch_model_3(self):
np.testing.assert_array_almost_equal(self.model_3_frac_diff_30GHz, np.zeros_like(self.model_3_frac_diff_30GHz), decimal = 6)
np.testing.assert_array_almost_equal(self.model_3_frac_diff_100GHz, np.zeros_like(self.model_3_frac_diff_30GHz), decimal = 6)
np.testing.assert_array_almost_equal(self.model_3_frac_diff_353GHz, np.zeros_like(self.model_3_frac_diff_30GHz), decimal = 6)
def setUp(self):
data_dir = get_template_dir()
a1_config = models("a1", 64)
AME1 = components.AME(a1_config[0])
AME2 = components.AME(a1_config[1])
signal = lambda nu: AME1.signal()(nu) + AME2.signal()(nu)
ame_1_30GHz = read_map(get_testdata('benchmark', 'check3spinn_30p0_64.fits'), 64, field = (0, 1, 2))
ame_1_100GHz = read_map(get_testdata('benchmark', 'check3spinn_100p0_64.fits'), 64, field = (0, 1, 2))
ame_1_353GHz = read_map(get_testdata('benchmark', 'check3spinn_353p0_64.fits'), 64, field = (0, 1, 2))
self.frac_diff_30GHz = (ame_1_30GHz[0] - signal(30.)[0]) / (ame_1_30GHz[0] + 1.e-14)
self.frac_diff_100GHz = (ame_1_100GHz[0] - signal(100.)[0]) / (ame_1_100GHz[0] + 1e-14)
self.frac_diff_353GHz = (ame_1_353GHz[0] - signal(353.)[0]) / (ame_1_353GHz[0] +1e-14)
def test_cmb_map_bandpass():
nside = 32
# pretend for testing that the Dust is CMB
model = pysm.CMBMap(map_IQU="pysm_2/lensed_cmb.fits", nside=nside)
freq = 100 * u.GHz
expected_map = pysm.read_map("pysm_2/lensed_cmb.fits",
field=0,
nside=nside,
unit=u.uK_CMB).to(
u.uK_RJ,
equivalencies=u.cmb_equivalencies(freq))
print(
"expected_scaling",
(1 * u.K_CMB).to_value(u.K_RJ,
equivalencies=u.cmb_equivalencies(freq)),
)
freqs = np.array([98, 99, 100, 101, 102]) * u.GHz
weights = np.ones(len(freqs))
# just checking that the result is reasonably close
# to the delta frequency at the center frequency
assert_quantity_allclose(expected_map,
model.get_emission(freqs, weights)[0],
rtol=1e-3)
def test_mpi_smoothing(mpi_comm):
nside = 128
lmax = 2 * nside
map_dist = pysm.MapDistribution(pixel_indices=None,
mpi_comm=mpi_comm,
smoothing_lmax=lmax,
nside=nside)
model = pysm.Model(nside, map_dist=map_dist)
distributed_map = model.read_map("pysm_2/dust_temp.fits")
fwhm = 5 * u.deg
smoothed_distributed_map = pysm.mpi_smoothing(distributed_map,
fwhm,
map_dist=map_dist)
full_map_rank0 = pysm.mpi.assemble_map_on_rank0(
mpi_comm,
smoothed_distributed_map,
model.map_dist.pixel_indices,
n_components=1,
npix=hp.nside2npix(nside),
)[0]
if mpi_comm.rank == 0:
np.testing.assert_allclose(
full_map_rank0,
hp.smoothing(
pysm.read_map("pysm_2/dust_temp.fits", nside=nside).value,
fwhm.to(u.rad).value,
iter=0,
lmax=lmax,
use_pixel_weights=False,
),
rtol=1e-5,
)
def test_dust_model(model_tag, freq):
# for 'd6' model fix the random seed and skip buggy 353 GHz
if model_tag == "d6":
if freq == 353:
return
np.random.seed(123)
model = pysm.Sky(preset_strings=[model_tag], nside=64)
model_number = {"d0": 1, "d1": 1, "d2": 6, "d3": 9, "d6": 12}[model_tag]
expected_output = pysm.read_map(
"pysm_2_test_data/check{}therm_{}p0_64.fits".format(
model_number, freq),
64,
unit="uK_RJ",
field=(0, 1, 2),
)
# for some models we do not have tests, we compare with output from a simular model
# and we increase tolerance, mostly just to exercise the code.
rtol = {"d0": 0.9}.get(model_tag, 1e-5)
assert_quantity_allclose(expected_output,
model.get_emission(freq * units.GHz),
rtol=rtol)
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 signal(self, nu, **kwargs):
"""Return map in uK_RJ at given frequency or array of frequencies"""
if np.isscalar(nu):
nu = np.array([nu])
filename = utils.get_data_from_url(self.get_filename())
m = pysm.read_map(
filename,
nside=self.nside,
field=0,
pixel_indices=self.pixel_indices,
mpi_comm=self.mpi_comm,
)
npix = (len(self.pixel_indices) if self.pixel_indices is not None else
hp.nside2npix(self.nside))
all_maps = np.zeros((len(nu), 1, npix), dtype=np.double)
szfac = np.ones(len(nu))
if self.sz_type == "thermal":
szfac = y2uK_CMB(nu)
all_maps[:, 0, :] = np.outer(
pysm.convert_units("uK_CMB", "uK_RJ", nu) * szfac, m)
# the output of out is always 3D, (num_freqs, IQU, npix), if num_freqs is one
# we return only a 2D array.
if len(all_maps) == 1:
return all_maps[0]
else:
return all_maps
def setUp(self):
data_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'pysm', 'template'))
test_data_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), 'test_data', 'benchmark'))
f1_config = models("f1", 64)
freefree = components.Freefree(f1_config[0])
signal = freefree.signal()
freefree_1_30GHz = read_map(os.path.join(test_data_dir, 'check4freef_30p0_64.fits'), 64, field = (0, 1, 2))
freefree_1_100GHz = read_map(os.path.join(test_data_dir, 'check4freef_100p0_64.fits'), 64, field = (0, 1, 2))
freefree_1_353GHz = read_map(os.path.join(test_data_dir, 'check4freef_353p0_64.fits'), 64, field = (0, 1, 2))
self.frac_diff_30GHz = (freefree_1_30GHz[0] - signal(30.)[0]) / (freefree_1_30GHz[0] + 1.e-14)
self.frac_diff_100GHz = (freefree_1_100GHz[0] - signal(100.)[0]) / (freefree_1_100GHz[0] + 1e-14)
self.frac_diff_353GHz = (freefree_1_353GHz[0] - signal(353.)[0]) / (freefree_1_353GHz[0] +1e-14)
def setUp(self):
data_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'pysm', 'template'))
test_data_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), 'test_data', 'benchmark'))
a1_config = models("a1", 64)
AME1 = components.AME(a1_config[0])
AME2 = components.AME(a1_config[1])
signal = lambda nu: AME1.signal()(nu) + AME2.signal()(nu)
ame_1_30GHz = read_map(os.path.join(test_data_dir, 'check3spinn_30p0_64.fits'), 64, field = (0, 1, 2))
ame_1_100GHz = read_map(os.path.join(test_data_dir, 'check3spinn_100p0_64.fits'), 64, field = (0, 1, 2))
ame_1_353GHz = read_map(os.path.join(test_data_dir, 'check3spinn_353p0_64.fits'), 64, field = (0, 1, 2))
self.frac_diff_30GHz = (ame_1_30GHz[0] - signal(30.)[0]) / (ame_1_30GHz[0] + 1.e-14)
self.frac_diff_100GHz = (ame_1_100GHz[0] - signal(100.)[0]) / (ame_1_100GHz[0] + 1e-14)
self.frac_diff_353GHz = (ame_1_353GHz[0] - signal(353.)[0]) / (ame_1_353GHz[0] +1e-14)
def setUp(self):
nside = 64
self.sky_config = {
'synchrotron' : models("s1", nside)
}
self.synch_1_30GHz = pysm.read_map(get_testdata('benchmark', 'check2synch_30p0_64.fits'), 64, field =(0,1,2))[np.newaxis, :, :]
self.synch_1_30GHz_smoothed = pysm.read_map(get_testdata('benchmark', 'check2synch_30p0_64_smoothed1deg.fits'), 64, field =0)
self.instrument_config = {
'frequencies' : np.array([30., 30.]),
'beams' : np.array([60., 60.]),
'nside' : nside,
'add_noise' : False,
'output_units' : 'uK_RJ',
'use_smoothing' : True,
'use_bandpass' : False,
}
def read_map(self, fname, field=None):
return read_map(
get_data_from_url(fname),
nside=self.nside,
field=field,
pixel_indices=self.pixel_indices,
mpi_comm=self.mpi_comm,
verbose=False,
)
def read_map(self, freq):
if self.verbose:
print("Reading map {}".format(self.maps[freq]))
m = pysm.read_map(self.maps[freq],
nside=self.nside,
field = (0,1,2) if self.has_polarization else 0,
pixel_indices=self.pixel_indices,
mpi_comm=self.mpi_comm)
return m * pysm.convert_units(self.input_units, "uK_RJ", freq)
def test_partial_freefree(self):
pixel_indices = np.arange(10000, 11000, dtype=np.int)
f1_config = models("f1", 64, pixel_indices=pixel_indices)
freefree = components.Freefree(f1_config[0])
signal = freefree.signal()
freefree_30_T = signal(30.)[0]
assert len(freefree_30_T) == 1000
freefree_1_30GHz = read_map(get_testdata('benchmark', 'check4freef_30p0_64.fits'), 64, field = (0,))
np.testing.assert_array_almost_equal(freefree_30_T, freefree_1_30GHz[pixel_indices], decimal = 3)
def test_partial_freefree(self):
pixel_indices = np.arange(10000, 11000, dtype=np.int)
f1_config = models("f1", 64, pixel_indices=pixel_indices)
freefree = components.Freefree(f1_config[0])
signal = freefree.signal()
freefree_30_T = signal(30.)[0]
assert len(freefree_30_T) == 1000
test_data_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), 'test_data', 'benchmark'))
freefree_1_30GHz = read_map(os.path.join(test_data_dir, 'check4freef_30p0_64.fits'), 64, field = (0,))
np.testing.assert_array_almost_equal(freefree_30_T, freefree_1_30GHz[pixel_indices], decimal = 3)
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_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 setUp(self):
nside = 64
self.sky_config = {'synchrotron': models("s1", nside)}
self.synch_1_30GHz = pysm.read_map(os.path.join(
TEST_DATA_DIR, 'check2synch_30p0_64.fits'),
64,
field=(0, 1, 2))[np.newaxis, :, :]
self.synch_1_30GHz_smoothed = pysm.read_map(os.path.join(
TEST_DATA_DIR, 'check2synch_30p0_64_smoothed1deg.fits'),
64,
field=0)
self.instrument_config = {
'frequencies': np.array([30., 30.]),
'beams': np.array([60., 60.]),
'nside': nside,
'add_noise': False,
'output_units': 'uK_RJ',
'use_smoothing': True,
'use_bandpass': False,
}
def test_read_map_mpi_pixel_indices(mpi_comm):
# Reads pixel [0] on rank 0
# pixels [0,1] on rank 1
# pixels [0,1,2] on rank 2 and so on.
map_dist = pysm.MapDistribution(mpi_comm=mpi_comm,
pixel_indices=list(
range(0, mpi_comm.rank + 1)))
m = pysm.read_map("pysm_2/dust_temp.fits",
nside=8,
field=0,
map_dist=map_dist)
assert len(m) == mpi_comm.rank + 1
def setUp(self):
data_dir = get_template_dir()
self.cmb_config_1 = {
'model' : 'taylens',
'cmb_specs' : np.loadtxt(os.path.join(data_dir, 'camb_lenspotentialCls.dat'), unpack = True),
'delens' : False,
'delensing_ells' : np.loadtxt(os.path.join(data_dir, 'delens_ells.txt')),
'nside' : 64,
'cmb_seed' : 1234
}
cmb = components.CMB(self.cmb_config_1)
signal = cmb.signal()
self.cmb_1_30GHz = read_map(get_testdata('benchmark', 'check5cmb_30p0_64.fits'), 64, field = (0, 1, 2))
cmb_1_100GHz = read_map(get_testdata('benchmark', 'check5cmb_100p0_64.fits'), 64, field = (0, 1, 2))
cmb_1_353GHz = read_map(get_testdata('benchmark', 'check5cmb_353p0_64.fits'), 64, field = (0, 1, 2))
self.frac_diff_30GHz = (self.cmb_1_30GHz - signal(30.)) / self.cmb_1_30GHz
self.frac_diff_100GHz = (cmb_1_100GHz - signal(100.)) / cmb_1_100GHz
self.frac_diff_353GHz = (cmb_1_353GHz - signal(353.)) / cmb_1_353GHz
def setUp(self):
data_dir = get_template_dir()
self.cmb_config_1 = {
'model':
'taylens',
'cmb_specs':
np.loadtxt(os.path.join(data_dir, 'camb_lenspotentialCls.dat'),
unpack=True),
'delens':
False,
'delensing_ells':
np.loadtxt(os.path.join(data_dir, 'delens_ells.txt')),
'nside':
64,
'cmb_seed':
1234
}
cmb = components.CMB(self.cmb_config_1)
signal = cmb.signal()
self.cmb_1_30GHz = read_map(get_testdata('benchmark',
'check5cmb_30p0_64.fits'),
64,
field=(0, 1, 2))
cmb_1_100GHz = read_map(get_testdata('benchmark',
'check5cmb_100p0_64.fits'),
64,
field=(0, 1, 2))
cmb_1_353GHz = read_map(get_testdata('benchmark',
'check5cmb_353p0_64.fits'),
64,
field=(0, 1, 2))
self.frac_diff_30GHz = (self.cmb_1_30GHz -
signal(30.)) / self.cmb_1_30GHz
self.frac_diff_100GHz = (cmb_1_100GHz - signal(100.)) / cmb_1_100GHz
self.frac_diff_353GHz = (cmb_1_353GHz - signal(353.)) / cmb_1_353GHz
def test_partial_freefree(self):
pixel_indices = np.arange(10000, 11000, dtype=np.int)
f1_config = models("f1", 64, pixel_indices=pixel_indices)
freefree = components.Freefree(f1_config[0])
signal = freefree.signal()
freefree_30_T = signal(30.)[0]
assert len(freefree_30_T) == 1000
freefree_1_30GHz = read_map(get_testdata('benchmark',
'check4freef_30p0_64.fits'),
64,
field=(0, ))
np.testing.assert_array_almost_equal(freefree_30_T,
freefree_1_30GHz[pixel_indices],
decimal=3)
def test_dust_model(model_tag, freq):
model = pysm.Sky(preset_strings=[model_tag], nside=64)
model_number = {"d1": 1, "d2": 6, "d3": 9}[model_tag]
expected_output = pysm.read_map(
"pysm_2_test_data/check{}therm_{}p0_64.fits".format(model_number, freq),
64,
unit="uK_RJ",
field=(0, 1, 2),
).reshape((1, 3, -1))
assert_quantity_allclose(
expected_output, model.get_emission(freq * units.GHz), rtol=1e-5
)
def test_read_map_mpi_uniform_distribution(mpi_comm):
# Spreads the map equally across processes
map_dist = pysm.MapDistribution(
mpi_comm=mpi_comm,
pixel_indices=pysm.mpi.distribute_pixels_uniformly(mpi_comm, nside=8),
)
m = pysm.read_map("pysm_2/dust_temp.fits",
nside=8,
field=0,
map_dist=map_dist)
npix = hp.nside2npix(8)
assert (
npix % mpi_comm.size == 0
), "This test requires the size of the communicator to divide the number of pixels {}".format(
npix)
num_local_pix = len(m)
assert num_local_pix == npix / mpi_comm.size
complete_m = pysm.read_map("pysm_2/dust_temp.fits", nside=8, field=0)
np.testing.assert_allclose(
m,
complete_m[num_local_pix * mpi_comm.rank:num_local_pix *
(mpi_comm.rank + 1)],
)
def test_model(model, freq):
model = pysm.Sky(preset_strings=[model], nside=64)
model_number = 3
expected_map = pysm.read_map(
"pysm_2_test_data/check{}spinn_{}p0_64.fits".format(model_number, freq),
64,
unit=pysm.units.uK_RJ,
field=0,
).reshape((1, 1, -1))
assert_quantity_allclose(
expected_map, model.get_emission(freq << pysm.units.GHz), rtol=1e-5
)
def test_synchrotron_model(model, freq):
synchrotron = pysm.Sky(preset_strings=[model], nside=64)
model_number = {"s1": 2, "s2": 7, "s3": 10}[model]
synch = pysm.read_map(
"pysm_2_test_data/check{}synch_{}p0_64.fits".format(model_number, freq),
64,
unit=pysm.units.uK_RJ,
field=(0, 1, 2),
).reshape((1, 3, -1))
assert_quantity_allclose(
synch, synchrotron.get_emission(freq << pysm.units.GHz), rtol=1e-5
)
def test_highfreq_dust_model(model_tag, freq):
model = pysm.Sky(preset_strings=[model_tag], nside=64)
expected_output = pysm.read_map(
"pysm_2_test_data/check_{}_{}_uK_RJ_64.fits".format(model_tag, freq),
64,
unit="uK_RJ",
field=(0, 1, 2),
)
rtol = 1e-5
assert_quantity_allclose(
expected_output, model.get_emission(freq * units.GHz), rtol=rtol
)
def test_read_map_mpi_uniform_distribution(mpi_comm):
# Spreads the map equally across processes
map_dist = pysm.MapDistribution(
mpi_comm=mpi_comm,
pixel_indices=pysm.mpi.distribute_pixels_uniformly(mpi_comm, nside=8),
)
m = pysm.read_map("pysm_2/dust_temp.fits",
nside=8,
field=0,
map_dist=map_dist)
npix = hp.nside2npix(8)
assert (
npix % mpi_comm.size == 0
), "This test requires the size of the communicator to divide the number of pixels {}".format(
npix)
assert len(m) == npix / mpi_comm.size
def setUp(self):
data_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'pysm', 'template'))
test_data_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), 'test_data', 'benchmark'))
d1_config = models("d1", 64)
dust = components.Dust(d1_config[0])
signal = dust.signal()
dust_1_30GHz = read_map(os.path.join(test_data_dir, 'check1therm_30p0_64.fits'), 64, field = (0, 1, 2))
dust_1_100GHz = read_map(os.path.join(test_data_dir, 'check1therm_100p0_64.fits'), 64, field = (0, 1, 2))
dust_1_353GHz = read_map(os.path.join(test_data_dir, 'check1therm_353p0_64.fits'), 64, field = (0, 1, 2))
self.frac_diff_30GHz = (dust_1_30GHz - signal(30.)) / dust_1_30GHz
self.frac_diff_100GHz = (dust_1_100GHz - signal(100.)) / dust_1_100GHz
self.frac_diff_353GHz = (dust_1_353GHz - signal(353.)) / dust_1_353GHz
d2_config = models("d2", 64)
dust = components.Dust(d2_config[0])
signal = dust.signal()
dust_2_30GHz = read_map(os.path.join(test_data_dir, 'check6therm_30p0_64.fits'), 64, field = (0, 1, 2))
dust_2_100GHz = read_map(os.path.join(test_data_dir, 'check6therm_100p0_64.fits'), 64, field = (0, 1, 2))
dust_2_353GHz = read_map(os.path.join(test_data_dir, 'check6therm_353p0_64.fits'), 64, field = (0, 1, 2))
self.model_2_frac_diff_30GHz = (dust_2_30GHz - signal(30.)) / dust_1_30GHz
self.model_2_frac_diff_100GHz = (dust_2_100GHz - signal(100.)) / dust_1_100GHz
self.model_2_frac_diff_353GHz = (dust_2_353GHz - signal(353.)) / dust_1_353GHz
d3_config = models("d3", 64)
dust = components.Dust(d3_config[0])
signal = dust.signal()
dust_3_30GHz = read_map(os.path.join(test_data_dir, 'check9therm_30p0_64.fits'), 64, field = (0, 1, 2))
dust_3_100GHz = read_map(os.path.join(test_data_dir, 'check9therm_100p0_64.fits'), 64, field = (0, 1, 2))
dust_3_353GHz = read_map(os.path.join(test_data_dir, 'check9therm_353p0_64.fits'), 64, field = (0, 1, 2))
self.model_3_frac_diff_30GHz = (dust_3_30GHz - signal(30.)) / dust_3_30GHz
self.model_3_frac_diff_100GHz = (dust_3_100GHz - signal(100.)) / dust_3_100GHz
self.model_3_frac_diff_353GHz = (dust_3_353GHz - signal(353.)) / dust_3_353GHz
def setUp(self):
data_dir = get_template_dir()
d1_config = models("d1", 64)
dust = components.Dust(d1_config[0])
signal = dust.signal()
dust_1_30GHz = read_map(get_testdata('benchmark', 'check1therm_30p0_64.fits'), 64, field = (0, 1, 2))
dust_1_100GHz = read_map(get_testdata('benchmark', 'check1therm_100p0_64.fits'), 64, field = (0, 1, 2))
dust_1_353GHz = read_map(get_testdata('benchmark', 'check1therm_353p0_64.fits'), 64, field = (0, 1, 2))
self.frac_diff_30GHz = (dust_1_30GHz - signal(30.)) / dust_1_30GHz
self.frac_diff_100GHz = (dust_1_100GHz - signal(100.)) / dust_1_100GHz
self.frac_diff_353GHz = (dust_1_353GHz - signal(353.)) / dust_1_353GHz
d2_config = models("d2", 64)
dust = components.Dust(d2_config[0])
signal = dust.signal()
dust_2_30GHz = read_map(get_testdata('benchmark', 'check6therm_30p0_64.fits'), 64, field = (0, 1, 2))
dust_2_100GHz = read_map(get_testdata('benchmark', 'check6therm_100p0_64.fits'), 64, field = (0, 1, 2))
dust_2_353GHz = read_map(get_testdata('benchmark', 'check6therm_353p0_64.fits'), 64, field = (0, 1, 2))
self.model_2_frac_diff_30GHz = (dust_2_30GHz - signal(30.)) / dust_1_30GHz
self.model_2_frac_diff_100GHz = (dust_2_100GHz - signal(100.)) / dust_1_100GHz
self.model_2_frac_diff_353GHz = (dust_2_353GHz - signal(353.)) / dust_1_353GHz
d3_config = models("d3", 64)
dust = components.Dust(d3_config[0])
signal = dust.signal()
dust_3_30GHz = read_map(get_testdata('benchmark', 'check9therm_30p0_64.fits'), 64, field = (0, 1, 2))
dust_3_100GHz = read_map(get_testdata('benchmark', 'check9therm_100p0_64.fits'), 64, field = (0, 1, 2))
dust_3_353GHz = read_map(get_testdata('benchmark', 'check9therm_353p0_64.fits'), 64, field = (0, 1, 2))
self.model_3_frac_diff_30GHz = (dust_3_30GHz - signal(30.)) / dust_3_30GHz
self.model_3_frac_diff_100GHz = (dust_3_100GHz - signal(100.)) / dust_3_100GHz
self.model_3_frac_diff_353GHz = (dust_3_353GHz - signal(353.)) / dust_3_353GHz
def test_cmb_lensed(model_tag, freq):
# The PySM test was done with a different seed than the one
# baked into the preset models
pysm.sky.PRESET_MODELS["c1"]["cmb_seed"] = 1234
model = pysm.Sky(preset_strings=[model_tag], nside=64)
model_number = 5
expected_output = pysm.read_map(
"pysm_2_test_data/check{}cmb_{}p0_64.fits".format(model_number, freq),
64,
unit="uK_RJ",
field=(0, 1, 2),
)
assert_quantity_allclose(expected_output,
model.get_emission(freq * u.GHz),
rtol=1e-5)
def test_synchrotron_model(model, freq):
synchrotron = pysm.Sky(preset_strings=[model], nside=64)
model_number = {"s0": 2, "s1": 2, "s2": 7, "s3": 10}[model]
synch = pysm.read_map(
"pysm_2_test_data/check{}synch_{}p0_64.fits".format(
model_number, freq),
64,
unit=pysm.units.uK_RJ,
field=(0, 1, 2),
)
# for some models we do not have tests, we compare with output from a simular model
# and we increase tolerance, mostly just to exercise the code.
rtol = {"s0": 5}.get(model, 1e-5)
assert_quantity_allclose(synch,
synchrotron.get_emission(freq << pysm.units.GHz),
rtol=rtol)
def test_mpi_assemble(mpi_comm):
nside = 128
lmax = 2 * nside
map_dist = pysm.MapDistribution(pixel_indices=None,
mpi_comm=mpi_comm,
nside=nside)
model = pysm.Model(nside, map_dist=map_dist)
distributed_map = model.read_map("pysm_2/dust_temp.fits")
full_map_rank0 = pysm.mpi.assemble_map_on_rank0(
mpi_comm,
distributed_map,
model.map_dist.pixel_indices,
n_components=1,
npix=hp.nside2npix(nside),
)[0]
if mpi_comm.rank == 0:
np.testing.assert_allclose(
full_map_rank0,
pysm.read_map("pysm_2/dust_temp.fits", nside=nside).value,
rtol=1e-5,
)
def test_cmb_map():
nside = 32
# pretend for testing that the Dust is CMB
model = pysm.CMBMap(map_IQU="pysm_2/lensed_cmb.fits", nside=nside)
freq = 100 * u.GHz
expected_map = pysm.read_map("pysm_2/lensed_cmb.fits",
field=(0, 1),
nside=nside,
unit=u.uK_CMB).to(
u.uK_RJ,
equivalencies=u.cmb_equivalencies(freq))
simulated_map = model.get_emission(freq)
for pol in [0, 1]:
assert_quantity_allclose(expected_map[pol],
simulated_map[pol],
rtol=1e-5)
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_sky(self, pysm_sky_config, pysm_precomputed_cmb_K_CMB):
if pysm is None:
raise RuntimeError('pysm not available')
autotimer = timing.auto_timer(type(self).__name__)
initialized_sky_config = {}
if pysm_precomputed_cmb_K_CMB is not None:
cmb = \
{
'model': 'pre_computed',
'nside': self._nside,
'pixel_indices': self._local_pixels
}
# PySM expects uK_CMB
cmb['A_I'], cmb['A_Q'], cmb['A_U'] = np.array(pysm.read_map(
pysm_precomputed_cmb_K_CMB, self._nside, field=(0,1,2),
pixel_indices=self._local_pixels, mpi_comm=self._comm)) * 1e6
initialized_sky_config["cmb"] = [cmb]
# remove cmb from the pysm string
pysm_sky_config.pop("cmb", None)
for name, model_id in pysm_sky_config.items():
initialized_sky_config[name] = \
pysm.nominal.models(model_id, self._nside, self._local_pixels,
mpi_comm=self._comm)
return pysm.Sky(initialized_sky_config, mpi_comm=self._comm)
