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 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)