def cmb_plot():
import pkg_resources
pysm_ver = pkg_resources.get_distribution("pysm").version
print('Currently using PySm version: %s ' % pysm_ver)
nside = 64
sky_config = {
'synchrotron': models("s1", nside),
'dust': models("d1", nside),
'freefree': models("f1", nside),
'cmb': models("c1", nside),
'ame': models("a1", nside),
}
# initialise Sky
sky = pysm.Sky(sky_config)
cmb = sky.cmb(nu=23.)
fig = plt.figure(figsize=(6, 4))
hp.mollview(cmb[0], min=-30, max=30, title=r'CMB', sub=(111))
plt.show()
plt.close()
total = sky.signal()(100.)
fig = plt.figure(figsize=(6, 4))
hp.mollview(total[0], min=10, max=200, title=r'CMB + DUST', sub=(111))
plt.show()
plt.close()
def simset4(nside):
""" Simset 2 updates the nominal PySM model with a
synchrotron index that varies more on sub degree scales,
produced by Nicoletta Krachmalnicoff.
"""
config = {'dust': models('d0', nside), 'synchrotron': models('s1', nside)}
return config
def simulation(nside):
print '########Simulating#######'
c1_config = models("c1", nside)
s1_config = models("s1", nside)
d1_config = models("d1", nside)
f1_config = models("f1", nside)
a1_config = models("a1", nside)
sky_config = {
'synchrotron' : s1_config,
'dust' : d1_config,
'freefree' : f1_config,
'cmb' : c1_config,
'ame' : a1_config
}
sky = pysm.Sky(sky_config)
global wn, cmb_MASKED, coefficients,mask,cmb
nu = np.array([30., 44., 70., 95., 150., 217., 353., 545., 857.])
coefficients = convert_units("uK_RJ", "uK_CMB", nu)
#dust = sky.dust(nu);synchrotron = sky.synchrotron(nu);freefree = sky.freefree(nu)
#cmb = sky.cmb(nu); ame = sky.ame(nu)
#np.save('../simulation/Nside = 1024/dust_map.npy',convert_unit(dust)); np.save('../simulation/Nside = 1024/synchro_map.npy',convert_unit(synchrotron));
#np.save('../simulation/Nside = 1024/9_fre/cmb_map.npy',convert_unit(cmb)); #np.save('../simulation/Nside = 1024/freefree_map.npy',convert_unit(freefree));
#np.save('../simulation/Nside = 1024/ame_map.npy',convert_unit(ame))
total = sky.signal()(nu)
#total = (total - cmb)*0.7 + cmb #decrease the foreground
np.save('../simulation/Nside = 1024/9_fre/total_map.npy',convert_unit(total))
def simset2(nside):
""" Simset 2 updates the nominal PySM model with a
synchrotron index that varies more on sub degree scales,
produced by Nicoletta Krachmalnicoff.
"""
s1 = models('s1', nside)
beta_high_res = hp.read_map(_HIGH_RES_BETA) - 3.
s1[0].update({'spectral_index': beta_high_res})
config = {'dust': models('d1', nside), 'synchrotron': s1}
return config
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()
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 setUp(self):
self.nside = 1024
sigma_T = 4.
sigma_P = np.sqrt(2.) * sigma_T
self.instrument_config = {
'frequencies': np.array([23.]),
'sens_I': np.array([sigma_T]),
'sens_P': np.array([sigma_P]),
'nside': self.nside,
'noise_seed': 1234,
'use_bandpass': False,
'add_noise': True,
'output_units': 'uK_CMB',
'use_smoothing': False,
'output_directory': os.path.dirname(os.path.abspath(__file__)),
'output_prefix': 'test',
}
s1 = models("s1", self.nside)
s1[0]['A_I'] = np.zeros(hp.nside2npix(self.nside))
s1[0]['A_Q'] = np.zeros(hp.nside2npix(self.nside))
s1[0]['A_U'] = np.zeros(hp.nside2npix(self.nside))
sky_config = {'synchrotron': s1}
self.sky = pysm.Sky(sky_config)
pix2amin = np.sqrt(4. * np.pi * (180. / np.pi * 60.)**2 /
float(hp.nside2npix(self.nside)))
self.expected_T_std = sigma_T / pix2amin
self.expected_P_std = sigma_P / pix2amin
self.test_file = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
"test_nu0023p00GHz_noise_nside%04d.fits" % self.nside)
def test_partial_hensley_draine_2017(self):
pixel_indices = np.arange(10000, 11000, dtype=np.int)
f1_config = models("d5", 64, pixel_indices=pixel_indices)
dust = components.Dust(f1_config[0])
signal = dust.signal()
dust_30_T = signal(30.)[0]
assert len(dust_30_T) == 1000
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 test_partial_hensley_draine_2017(self):
pixel_indices = np.arange(10000, 11000, dtype=np.int)
f1_config = models("d5", 64, pixel_indices=pixel_indices)
dust = components.Dust(f1_config[0])
signal = dust.signal()
dust_30_T = signal(30.)[0]
assert len(dust_30_T) == 1000
def setUp(self):
self.nside = 1024
sigma_T = 4.
sigma_P = np.sqrt(2.) * sigma_T
self.instrument_config = {
'frequencies' : np.array([23.]),
'sens_I' : np.array([sigma_T]),
'sens_P' : np.array([sigma_P]),
'nside' : self.nside,
'noise_seed' : 1234,
'use_bandpass' : False,
'add_noise' : True,
'output_units' : 'uK_CMB',
'use_smoothing' : False,
'output_directory' : os.path.dirname(os.path.abspath(__file__)),
'output_prefix' : 'test',
}
s1 = models("s1", self.nside)
s1[0]['A_I'] = np.zeros(hp.nside2npix(self.nside))
s1[0]['A_Q'] = np.zeros(hp.nside2npix(self.nside))
s1[0]['A_U'] = np.zeros(hp.nside2npix(self.nside))
sky_config = {'synchrotron' : s1}
self.sky = pysm.Sky(sky_config)
pix2amin = np.sqrt(4. * np.pi * (180. / np.pi * 60.) ** 2 / float(hp.nside2npix(self.nside)))
self.expected_T_std = sigma_T / pix2amin
self.expected_P_std = sigma_P / pix2amin
self.test_file = get_testdata("test_nu0023p00GHz_noise_nside%04d.fits"%self.nside)
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 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 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_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 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 comm_betad_binned(nside, nbins=3):
from pysm.nominal import models
beta = models('d1', nside)[0]['spectral_index']
masked_beta = apply_so_mask(beta)
sorted_masked_beta = np.sort(masked_beta)
stride = int(len(sorted_masked_beta.compressed()) / nbins)
bounds = sorted_masked_beta.compressed()[stride::stride]
conds = []
conds.append((beta < bounds[0]))
for i in range(0, nbins - 2):
conds.append((beta > bounds[i]) * (beta < bounds[i + 1]))
conds.append((beta > bounds[-1]))
zeros = np.zeros_like(beta)
for i in range(nbins):
zeros[conds[i]] = i
return zeros
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 = 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):
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 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 build_sky_config(pysm_model, nside, pixel_indices=None, mpi_comm=None):
"""Build a PySM sky configuration dict from a model string"""
sky_components = [
'synchrotron',
'dust',
'freefree',
'cmb',
'ame',
]
sky_config = dict()
for component_model in pysm_model.split(','):
full_component_name = [
each for each in sky_components
if each.startswith(component_model[0])][0]
sky_config[full_component_name] = \
models(component_model, nside=nside, pixel_indices=pixel_indices, mpi_comm=mpi_comm)
return sky_config
def build_sky_config(pysm_model, nside, pixel_indices=None, mpi_comm=None):
"""Build a PySM sky configuration dict from a model string"""
sky_components = [
'synchrotron',
'dust',
'freefree',
'cmb',
'ame',
]
sky_config = dict()
for component_model in pysm_model.split(','):
full_component_name = [
each for each in sky_components
if each.startswith(component_model[0])
][0]
sky_config[full_component_name] = \
models(component_model, nside=nside, pixel_indices=pixel_indices, mpi_comm=mpi_comm)
return sky_config
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_get_simple_sky_map(self):
sky_config0 = {'cmb': models('c1', d['nside'])}
sky0 = si.sky(sky_config0, d, None).get_simple_sky_map()
sky0_q = si.Qubic_sky(sky_config0, d).get_simple_sky_map()
sky0_p = si.Planck_sky(sky_config0, d).get_simple_sky_map()
self.assertTrue(np.all(sky0 == sky0_q))
self.assertTrue(np.all(sky0_p == sky0_q))
self.assertTrue(sky0_p.shape == sky0_q.shape)
self.assertTrue(sky0_q.shape[0] == int(d['nf_sub']))
self.assertTrue(sky0_q.shape[1] == 12 * d['nside']**2)
self.assertTrue(sky0_q.shape[2] == 3)
sky = si.sky(sky_config, d, None).get_simple_sky_map()
skyq = si.Qubic_sky(sky_config, d).get_simple_sky_map()
skyp = si.Planck_sky(sky_config, d).get_simple_sky_map()
for j in range(3):
for i in range(len(sky0)):
self.assertTrue(np.all(sky0[i, :, j] != sky[i, :, j]))
self.assertTrue(np.all(sky0_q[i, :, j] == sky0_p[i, :, j]))
self.assertTrue(np.all(skyq[i, :, j] == skyp[i, :, j]))
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 simset1(nside):
""" Simset 1 is the nominal PySM model with spatially
varying dust and synchrotron spectral parameters.
"""
config = {'dust': models('d1', nside), 'synchrotron': models('s1', nside)}
return config
def simset0(nside):
""" Simset 0 is a model with spatially constant spectral
parameters.
"""
config = {'dust': models('d0', nside), 'synchrotron': models('s0', nside)}
return config
def B_map(maps):
alms = hp.map2alm(maps)
Bmap = hp.alm2map(alms[2], nside=nside, verbose=False)
return Bmap
s_rms = []
d_rms = []
t_rms = []
Cl = []
a_rms = []
c_rms = []
for i in range(1):
for s in range(1, 2): #3
s1_config = models("s%s" % s, nside)
for d in range(1, 3): #7
d1_config = models("d%s" % d, nside)
for a in range(2, 3): #2
a1_config = models("a%s" % a, nside)
c1_config = models("c1", 128)
sky_config = {
'synchrotron': s1_config,
'dust': d1_config,
# 'freefree' : f1_config,
'cmb': models("c1", nside),
'ame': a1_config,
}
nside = 128; bin_w = 20; lmax = 201; lbin = 10;
SamNum = 100;
beams = [19, 11];
fres = [95, 150]; Nf = len(fres);
cpn = np.zeros((Nf, 2, 12*nside**2)); ## CMB plus noise
total = np.zeros((Nf, 2, 12*nside**2));
cl_f_all = np.ones((SamNum, 3, lbin, Nf, Nf))
nl_all = np.zeros((SamNum, 3, lbin, Nf, Nf))
Noise = np.zeros((Nf, 2, 12*nside**2))
cl_hat_all = np.ones((SamNum, 3, lbin, Nf, Nf))
#### foreground ####
sky_config = {'dust':models('d1', nside), 'synchrotron':models('s1', nside)}
sky = pysm.Sky(sky_config);
c95 = convert_units("uK_RJ", "uK_CMB", 95);
c150 = convert_units("uK_RJ", "uK_CMB", 150);
s30 = sky.synchrotron(30);
d353 = sky.dust(353);
fore_maps = sky.signal()(np.array(fres))
fore_maps[0] *= c95;
fore_maps[1] *= c150
ali_ma = hp.read_map('/fnx/jianyao/Likelihood_data/ABSData/ali_mask.fits', field = None)
# ali_ma = hp.read_map('/fnx/jianyao/DataChallenge/AncillaryData/AliCPTWhiteNoiseMatrix/BINARYMASK_95_C_1024.fits', field=None, verbose = False)
#split position coordinates
c = words2[i].split(',')
pos.append(np.array([float(c[0]), float(c[1])]))
#produce maps
nside = pixelization[n][0]
lsize = int(nside / 4)
centralpix = int(lsize / 2)
fwhmpix = pixelization[n][1]
Apix = hp.nside2pixarea(nside) #square radians
fwhmrad = np.sqrt(Apix) * fwhmpix
sigma = fwhmpix / 2.355482
#sky config with the principal models for each component
sky_config = {
'synchrotron': models("s1", nside),
'dust': models("d1", nside),
'freefree': models("f1", nside),
'ame': models("a1", nside),
'cmb': models("c1", nside)
}
sky = pysm.Sky(sky_config)
#unit conversion factor
mapFactor = convert_units("uK_RJ", "uK_CMB", nu)
sourceFactor = convert_units("Jysr", "uK_CMB", nu)
allmaps = sky.signal()(nu)
if verbose:
print('Microwave sky simulated')
import pysm
from pysm.nominal import models
import healpy as hp
from astropy.io import fits
#Sky configuration
nside = 256
sky_config = {
'synchrotron': models('s1', nside),
'dust': models('d1', nside),
'cmb': models('c1', nside),
#'freefree': models('f1', nside), #not polarized
#'ame': models('a1', nside), #not polarized
}
#initialize sky
sky = pysm.Sky(sky_config)
signal = sky.signal()
#choose the frequency
sky_map_g = signal(nu=43)
#change units from u_K to K
sky_map_g = sky_map_g * 1e-06
#rotate map from Galactic to Equatorial Coordinates
r = hp.Rotator(coord=["G", "E"])
sky_map_eq = r.rotate_map(sky_map_g)
from pysimulators import FitsArray
from pysm.nominal import models
from scipy.constants import c
### Instrument ###
d = qubic.qubicdict.qubicDict()
dp = qubic.qubicdict.qubicDict()
d.read_from_file("parameters.dict")
dp.read_from_file("parameters.dict")
dp['MultiBand'] = False
dp['nf_sub'] = 1
### Sky ###
sky_config = {
'synchrotron': models('s1', d['nside']),
'dust': models('d1', d['nside']),
'freefree': models('f1', d['nside']), #not polarized
'cmb': models('c1', d['nside']),
'ame': models('a1', d['nside'])
} #not polarized
planck_sky = si.Planck_sky(sky_config, d)
x0_planck = planck_sky.get_sky_map()
qubic_sky = si.Qubic_sky(sky_config, d)
x0_qubic = qubic_sky.get_sky_map()
### QUBIC TOD ###
p = qubic.get_pointing(d)
TODq = si.create_TOD(d, p, x0_qubic)
map_size = [25., 25.]
sense_P = 70.0
outdir = '/media/jason/SSD2/deep_data/deep_foregrounds'
seed = 1111
#Define effective frequencies for output maps (in GHz).
#CMB-S4 definitions
nu = np.array([20., 30., 40., 85., 95., 145., 155., 220., 270.])
#nu = np.array([20., 40., 145., 220., 270.])
#nu = np.array([20., 155., 270.])
############################################################################
#Load in PySM foreground and CMB models
print('Loading CMB model...')
cmb_config = models('c1', nside=nside)
print('Loading foreground models...')
dust_config = models("d6", nside)
sync_config = models("s2", nside)
ff_config = models("f1", nside)
ame_config = models("a2", nside)
sky_config = {
'dust': dust_config,
'synchrotron': sync_config,
'freefree': ff_config,
'ame': ame_config,
'cmb': cmb_config
}
sky_config_cmb = {'cmb': cmb_config}
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 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
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)
