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 = pysm3.Sky(preset_strings=[model_tag], nside=64) model_number = {"d0": 1, "d1": 1, "d2": 6, "d3": 9, "d6": 12}[model_tag] expected_output = pysm3.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_cmb_map_bandpass(): nside = 32 # pretend for testing that the Dust is CMB model = pysm3.CMBMap(map_IQU="pysm_2/lensed_cmb.fits", nside=nside) freq = 100 * u.GHz expected_map = pysm3.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 = pysm3.MapDistribution( pixel_indices=None, mpi_comm=mpi_comm, smoothing_lmax=lmax, nside=nside ) model = pysm3.Model(nside, map_dist=map_dist) distributed_map = model.read_map("pysm_2/dust_temp.fits") fwhm = 5 * u.deg smoothed_distributed_map = pysm3.mpi_smoothing( distributed_map, fwhm, map_dist=map_dist ) full_map_rank0 = pysm3.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( pysm3.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_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 = pysm3.MapDistribution( mpi_comm=mpi_comm, pixel_indices=list(range(0, mpi_comm.rank + 1)) ) m = pysm3.read_map("pysm_2/dust_temp.fits", nside=8, field=0, map_dist=map_dist) assert len(m) == mpi_comm.rank + 1
def test_read_map_mpi_uniform_distribution(mpi_comm): # Spreads the map equally across processes map_dist = pysm3.MapDistribution( mpi_comm=mpi_comm, pixel_indices=pysm3.mpi.distribute_pixels_uniformly(mpi_comm, nside=8), ) m = pysm3.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 = pysm3.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_bandpass_unit_conversion(): nside = 32 freqs = np.array([250, 300, 350]) * u.GHz weights = np.ones(len(freqs)) sky = pysm3.Sky(nside=nside, preset_strings=["c2"]) CMB_rj_int = sky.get_emission(freqs, weights) CMB_thermo_int = CMB_rj_int*pysm3.utils.bandpass_unit_conversion( freqs, weights, u.uK_CMB ) expected_map = pysm3.read_map( "pysm_2/lensed_cmb.fits", field=(0, 1), nside=nside, unit=u.uK_CMB ) for pol in [0, 1]: assert_quantity_allclose(expected_map[pol], CMB_thermo_int[pol], rtol=1e-4)
def test_highfreq_dust_model(model_tag, freq): model = pysm3.Sky(preset_strings=[model_tag], nside=64) expected_output = pysm3.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_cmb_map(): nside = 32 # pretend for testing that the Dust is CMB model = pysm3.CMBMap(map_IQU="pysm_2/lensed_cmb.fits", nside=nside) freq = 100 * u.GHz expected_map = pysm3.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_model(model, freq): model = pysm3.Sky(preset_strings=[model], nside=64) model_number = 8 expected_map = pysm3.read_map( "pysm_2_test_data/check{}spinn_{}p0_64.fits".format( model_number, freq), 64, unit=pysm3.units.uK_RJ, field=(0, 1, 2), ) assert_quantity_allclose(expected_map, model.get_emission(freq << pysm3.units.GHz), rtol=1e-3)
def test_model_d12(freq): sky = Sky( preset_strings=["d12"], nside=8, output_unit=u.MJy / u.sr, ) emission = sky.get_emission(freq * u.GHz) expected_map = read_map( f"mkd_dust/test/layermodel_nside8_{freq}.fits", 8, unit=u.MJy / u.sr, field=(0, 1, 2), ) assert_quantity_allclose(expected_map, emission, rtol=1e-5)
def test_mpi_assemble(mpi_comm): nside = 128 map_dist = pysm3.MapDistribution(pixel_indices=None, mpi_comm=mpi_comm, nside=nside) model = pysm3.Model(nside, map_dist=map_dist) distributed_map = model.read_map("pysm_2/dust_temp.fits") full_map_rank0 = pysm3.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, pysm3.read_map("pysm_2/dust_temp.fits", nside=nside).value, rtol=1e-5, )
def test_cmb_lensed(model_tag, freq): # The PySM test was done with a different seed than the one # baked into the preset models pysm3.sky.PRESET_MODELS["c1"]["cmb_seed"] = 1234 model = pysm3.Sky(preset_strings=[model_tag], nside=64) model_number = 5 expected_output = pysm3.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_model(model, freq): model = pysm3.Sky(preset_strings=[model], nside=64) model_number = 3 expected_map = pysm3.read_map( "pysm_2_test_data/check{}spinn_{}p0_64.fits".format( model_number, freq), 64, unit=pysm3.units.uK_RJ, field=0, ) emission = model.get_emission(freq << pysm3.units.GHz) assert_quantity_allclose(expected_map, emission[0], rtol=1e-5) for i in [1, 2]: assert_quantity_allclose(0 * pysm3.units.uK_RJ, emission[i])
def test_synchrotron_model(model, freq): synchrotron = pysm3.Sky(preset_strings=[model], nside=64) model_number = {"s0": 2, "s1": 2, "s2": 7, "s3": 10}[model] synch = pysm3.read_map( "pysm_2_test_data/check{}synch_{}p0_64.fits".format( model_number, freq), 64, unit=pysm3.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 << pysm3.units.GHz), rtol=rtol)
def test_read_map_unit_dimensionless(): m = pysm3.read_map("pysm_2/dust_temp.fits", nside=8, field=0) assert u.Unit("") == m.unit
def test_read_map_unit(): m = pysm3.read_map("pysm_2/dust_temp.fits", nside=8, field=0, unit="uK_RJ") assert u.Unit("uK_RJ") == m.unit