def test_hpxgeom_coord_to_idx(nside, nested, frame, region, axes):
import healpy as hp
geom = HpxGeom(nside, nested, frame, region=region, axes=axes)
lon = np.array([112.5, 135.0, 105.0])
lat = np.array([75.3, 75.3, 74.6])
coords = make_test_coords(geom, lon, lat)
zidx = tuple([ax.coord_to_idx(t) for t, ax in zip(coords[2:], geom.axes)])
if geom.nside.size > 1:
nside = geom.nside[zidx]
else:
nside = geom.nside
phi, theta = coords.phi, coords.theta
idx = geom.coord_to_idx(coords)
assert_allclose(hp.ang2pix(nside, theta, phi), idx[0])
for i, z in enumerate(zidx):
assert_allclose(z, idx[i + 1])
# Test w/ coords outside the geometry
lon = np.array([0.0, 5.0, 10.0])
lat = np.array([75.3, 75.3, 74.6])
coords = make_test_coords(geom, lon, lat)
zidx = [ax.coord_to_idx(t) for t, ax in zip(coords[2:], geom.axes)]
idx = geom.coord_to_idx(coords)
if geom.region is not None:
assert_allclose(np.full_like(coords[0], -1, dtype=int), idx[0])
idx = geom.coord_to_idx(coords, clip=True)
assert np.all(np.not_equal(np.full_like(coords[0], -1, dtype=int), idx[0]))
def test_map_fill_events_hpx(events):
# 2D map
m = Map.from_geom(HpxGeom(1))
m.fill_events(events)
assert m.data[4] == 2
# 3D with energy axis
axis = MapAxis.from_edges([9, 11, 13], name="energy", unit="TeV")
m = Map.from_geom(HpxGeom(1, axes=[axis]))
m.fill_events(events)
assert m.data[0, 4] == 1
assert m.data[1, 4] == 1
def test_hpxgeom_get_hpxregion_dir():
geom = HpxGeom.create(nside=128,
region="DISK(110.,75.,2.)",
frame="galactic")
refdir = geom.center_skydir
assert_allclose(refdir.l.deg, 110.0)
assert_allclose(refdir.b.deg, 75.0)
geom = HpxGeom.create(nside=128, frame="galactic")
refdir = geom.center_skydir
assert_allclose(refdir.l.deg, 0.0)
assert_allclose(refdir.b.deg, 0.0)
def test_hpxgeom_init_with_pix(nside, nested, frame, region, axes):
geom = HpxGeom(nside, nested, frame, region=region, axes=axes)
idx0 = geom.get_idx(flat=True)
idx1 = tuple([t[::10] for t in idx0])
geom = HpxGeom(nside, nested, frame, region=idx0, axes=axes)
assert_allclose(idx0, geom.get_idx(flat=True))
assert_allclose(len(idx0[0]), np.sum(geom.npix))
geom = HpxGeom(nside, nested, frame, region=idx1, axes=axes)
assert_allclose(idx1, geom.get_idx(flat=True))
assert_allclose(len(idx1[0]), np.sum(geom.npix))
def test_interp_to_geom():
energy = MapAxis.from_energy_bounds("1 TeV",
"300 TeV",
nbin=5,
name="energy")
energy_target = MapAxis.from_energy_bounds("1 TeV",
"300 TeV",
nbin=7,
name="energy")
value = 30
coords = {
'skycoord': SkyCoord("0 deg", "0 deg"),
'energy': energy_target.center[3]
}
#WcsNDMap
geom_wcs = WcsGeom.create(npix=(5, 3),
proj="CAR",
binsz=60,
axes=[energy],
skydir=(0, 0))
wcs_map = Map.from_geom(geom_wcs, unit="")
wcs_map.data = value * np.ones(wcs_map.data.shape)
wcs_geom_target = WcsGeom.create(skydir=(0, 0),
width=(10, 10),
binsz=0.1 * u.deg,
axes=[energy_target])
interp_wcs_map = wcs_map.interp_to_geom(wcs_geom_target, interp=1)
assert_allclose(interp_wcs_map.get_by_coord(coords)[0], value, atol=1e-7)
assert isinstance(interp_wcs_map, WcsNDMap)
assert interp_wcs_map.geom == wcs_geom_target
#HpxNDMap
geom_hpx = HpxGeom.create(binsz=60, axes=[energy], skydir=(0, 0))
hpx_map = Map.from_geom(geom_hpx, unit="")
hpx_map.data = value * np.ones(hpx_map.data.shape)
hpx_geom_target = HpxGeom.create(skydir=(0, 0),
width=10,
binsz=0.1 * u.deg,
axes=[energy_target])
interp_hpx_map = hpx_map.interp_to_geom(hpx_geom_target)
assert_allclose(interp_hpx_map.get_by_coord(coords)[0], value, atol=1e-7)
assert isinstance(interp_hpx_map, HpxNDMap)
assert interp_hpx_map.geom == hpx_geom_target
def create_map(nside, nested, coordsys, region, axes):
return HpxNDMap(
HpxGeom(nside=nside,
nest=nested,
coordsys=coordsys,
region=region,
axes=axes))
def create_map(nside, nested, frame, region, axes):
return HpxNDMap(
HpxGeom(nside=nside,
nest=nested,
frame=frame,
region=region,
axes=axes))
def test_hpx_geom_is_aligned():
geom = HpxGeom.create(nside=8, frame="galactic")
assert geom.is_aligned(geom)
cutout = geom.cutout(position=SkyCoord("0d", "0d"), width=30 * u.deg)
assert cutout.is_aligned(geom)
geom_other = HpxGeom.create(nside=4, frame="galactic")
assert not geom.is_aligned(geom_other)
geom_other = HpxGeom.create(nside=8, frame="galactic", nest=False)
assert not geom.is_aligned(geom_other)
geom_other = HpxGeom.create(nside=8, frame="icrs")
assert not geom.is_aligned(geom_other)
def test_convolve_full(region):
energy = MapAxis.from_bounds(1,
100,
unit='TeV',
nbin=2,
name='energy_true')
nside = 256
all_sky_geom = HpxGeom(nside=nside,
axes=[energy],
region=region,
nest=False,
frame='icrs')
all_sky_map = Map.from_geom(all_sky_geom)
all_sky_map.set_by_coord((0, 0, [2, 90]), 1)
all_sky_map.set_by_coord((10, 10, [2, 90]), 1)
all_sky_map.set_by_coord((30, 30, [2, 90]), 1)
all_sky_map.set_by_coord((-40, -40, [2, 90]), 1)
all_sky_map.set_by_coord((60, 0, [2, 90]), 1)
all_sky_map.set_by_coord((-45, 30, [2, 90]), 1)
all_sky_map.set_by_coord((30, -45, [2, 90]), 1)
wcs_geom = WcsGeom.create(width=5, binsz=0.05, axes=[energy])
psf = PSFMap.from_gauss(energy_axis_true=energy, sigma=[0.5, 0.6] * u.deg)
kernel = psf.get_psf_kernel(geom=wcs_geom, max_radius=1 * u.deg)
convolved_map = all_sky_map.convolve_full(kernel)
assert_allclose(convolved_map.data.sum(), 14, rtol=1e-5)
def test_hpxgeom_read_write(tmp_path, nside, nested, frame, region, axes):
geom0 = HpxGeom(nside, nested, frame, region=region, axes=axes)
hdu_bands = geom0.to_bands_hdu(hdu_bands="TEST_BANDS")
hdu_prim = fits.PrimaryHDU()
hdu_prim.header.update(geom0.to_header())
hdulist = fits.HDUList([hdu_prim, hdu_bands])
hdulist.writeto(tmp_path / "tmp.fits")
with fits.open(tmp_path / "tmp.fits", memmap=False) as hdulist:
geom1 = HpxGeom.from_header(hdulist[0].header, hdulist["TEST_BANDS"])
assert_allclose(geom0.nside, geom1.nside)
assert_allclose(geom0.npix, geom1.npix)
assert_allclose(geom0.nest, geom1.nest)
assert geom0.frame == geom1.frame
def test_interp_to_geom():
energy = MapAxis.from_energy_bounds("1 TeV", "300 TeV", nbin=5, name="energy")
energy_target = MapAxis.from_energy_bounds(
"1 TeV", "300 TeV", nbin=7, name="energy"
)
value = 30
coords = {"skycoord": SkyCoord("0 deg", "0 deg"), "energy": energy_target.center[3]}
# WcsNDMap
geom_wcs = WcsGeom.create(
npix=(5, 3), proj="CAR", binsz=60, axes=[energy], skydir=(0, 0)
)
wcs_map = Map.from_geom(geom_wcs, unit="")
wcs_map.data = value * np.ones(wcs_map.data.shape)
wcs_geom_target = WcsGeom.create(
skydir=(0, 0), width=(10, 10), binsz=0.1 * u.deg, axes=[energy_target]
)
interp_wcs_map = wcs_map.interp_to_geom(wcs_geom_target, method="linear")
assert_allclose(interp_wcs_map.get_by_coord(coords)[0], value, atol=1e-7)
assert isinstance(interp_wcs_map, WcsNDMap)
assert interp_wcs_map.geom == wcs_geom_target
# HpxNDMap
geom_hpx = HpxGeom.create(binsz=60, axes=[energy], skydir=(0, 0))
hpx_map = Map.from_geom(geom_hpx, unit="")
hpx_map.data = value * np.ones(hpx_map.data.shape)
hpx_geom_target = HpxGeom.create(
skydir=(0, 0), width=10, binsz=0.1 * u.deg, axes=[energy_target]
)
interp_hpx_map = hpx_map.interp_to_geom(hpx_geom_target)
assert_allclose(interp_hpx_map.get_by_coord(coords)[0], value, atol=1e-7)
assert isinstance(interp_hpx_map, HpxNDMap)
assert interp_hpx_map.geom == hpx_geom_target
# Preserving the counts
geom_initial = WcsGeom.create(skydir=(20, 20), width=(5, 5), binsz=0.2 * u.deg,)
test_map = Map.from_geom(geom_initial, unit="")
test_map.data = value * np.ones(test_map.data.shape)
geom_target = WcsGeom.create(skydir=(20, 20), width=(5, 5), binsz=0.1 * u.deg,)
new_map = test_map.interp_to_geom(geom_target, preserve_counts=True)
assert np.floor(np.sum(new_map.data)) == np.sum(test_map.data)
def test_hpxgeom_pixel_scales():
geom = HpxGeom.create(nside=8,
frame="galactic",
axes=[MapAxis.from_edges([0, 2, 3])])
pixel_scales = geom.pixel_scales
assert_allclose(pixel_scales, [4] * u.deg)
def test_hpxmap_ud_grade(nside, nested, frame, region, axes):
m = HpxNDMap(
HpxGeom(nside=nside,
nest=nested,
frame=frame,
region=region,
axes=axes))
m.to_ud_graded(4)
def create_map(nside, nested, coordsys, region, axes, sparse):
if sparse:
m = HpxSparseMap(
HpxGeom(nside=nside,
nest=nested,
coordsys=coordsys,
region=region,
axes=axes))
else:
m = HpxNDMap(
HpxGeom(nside=nside,
nest=nested,
coordsys=coordsys,
region=region,
axes=axes))
return m
def test_hpxmap_ud_grade(nside, nested, coordsys, region, axes):
m = HpxNDMap(
HpxGeom(nside=nside,
nest=nested,
coordsys=coordsys,
region=region,
axes=axes))
m.to_ud_graded(4)
def test_hpxmap_crop(nside, nested, coordsys, region, axes):
m = HpxNDMap(
HpxGeom(nside=nside,
nest=nested,
coordsys=coordsys,
region=region,
axes=axes))
m.crop(1)
def geom(map_type, ebounds):
axis = MapAxis.from_edges(ebounds, name="energy", unit="TeV", interp="log")
if map_type == "wcs":
return WcsGeom.create(npix=(4, 3), binsz=2, axes=[axis])
elif map_type == "hpx":
return HpxGeom(256, axes=[axis])
else:
raise ValueError()
def test_hpxmap_crop(nside, nested, frame, region, axes):
m = HpxNDMap(
HpxGeom(nside=nside,
nest=nested,
frame=frame,
region=region,
axes=axes))
m.crop(1)
def test_hpxmap_to_wcs(nside, nested, coordsys, region, axes):
m = HpxNDMap(
HpxGeom(nside=nside,
nest=nested,
coordsys=coordsys,
region=region,
axes=axes))
m.to_wcs(sum_bands=False, oversample=2, normalize=False)
m.to_wcs(sum_bands=True, oversample=2, normalize=False)
def test_hpxgeom_solid_angle():
geom = HpxGeom.create(nside=8,
frame="galactic",
axes=[MapAxis.from_edges([0, 2, 3])])
solid_angle = geom.solid_angle()
assert solid_angle.shape == (1, )
assert_allclose(solid_angle.value, 0.016362461737446838)
def test_map_from_geom():
geom = WcsGeom.create(binsz=1.0, width=10.0)
m = Map.from_geom(geom)
assert isinstance(m, WcsNDMap)
assert m.geom.is_image
geom = HpxGeom.create(binsz=1.0, width=10.0)
m = Map.from_geom(geom)
assert isinstance(m, HpxNDMap)
assert m.geom.is_image
def test_from_wcs_tiles():
geom = HpxGeom.create(nside=8)
wcs_geoms = geom.to_wcs_tiles(nside_tiles=4)
wcs_tiles = [Map.from_geom(geom, data=1) for geom in wcs_geoms]
m = HpxNDMap.from_wcs_tiles(wcs_tiles=wcs_tiles)
assert_allclose(m.data, 1)
def test_map_plot_mask():
geom = HpxGeom.create(nside=16)
region = CircleSkyRegion(center=SkyCoord("0d", "0d", frame="galactic"),
radius=20 * u.deg)
mask = geom.region_mask([region])
with mpl_plot_check():
mask.plot_mask()
def test_hpxmap_swap_scheme(nside, nested, coordsys, region, axes):
m = HpxNDMap(
HpxGeom(nside=nside,
nest=nested,
coordsys=coordsys,
region=region,
axes=axes))
fill_poisson(m, mu=1.0, random_state=0)
m2 = m.to_swapped()
coords = m.geom.get_coord(flat=True)
assert_allclose(m.get_by_coord(coords), m2.get_by_coord(coords))
def test_hpxmap_interp_by_coord(nside, nested, coordsys, region, axes):
m = HpxNDMap(
HpxGeom(nside=nside,
nest=nested,
coordsys=coordsys,
region=region,
axes=axes))
coords = m.geom.get_coord(flat=True)
m.set_by_coord(coords, coords[1])
assert_allclose(m.get_by_coord(coords),
m.interp_by_coord(coords, interp="linear"))
def test_hpxmap_swap_scheme(nside, nested, frame, region, axes):
m = HpxNDMap(
HpxGeom(nside=nside,
nest=nested,
frame=frame,
region=region,
axes=axes))
m.data = np.arange(m.data.size).reshape(m.geom.data_shape)
m2 = m.to_swapped()
coords = m.geom.get_coord(flat=True)
assert_allclose(m.get_by_coord(coords), m2.get_by_coord(coords))
def test_hpx_geom_separation():
geom = HpxGeom.create(binsz=0.1, frame="galactic", nest=True)
position = SkyCoord(0, 0, unit="deg", frame="galactic")
separation = geom.separation(position)
assert separation.unit == "deg"
assert_allclose(separation.value[0], 45.000049)
# Make sure it also works for 2D maps as input
separation = geom.to_image().separation(position)
assert separation.unit == "deg"
assert_allclose(separation.value[0], 45.000049)
# make sure works for partial geometry
geom = HpxGeom.create(binsz=0.1,
frame="galactic",
nest=True,
region="DISK(0,0,10)")
separation = geom.separation(position)
assert separation.unit == "deg"
assert_allclose(separation.value[0], 9.978725)
def geom_config_hpx():
energy_axis = MapAxis.from_energy_bounds("0.5 TeV", "30 TeV", nbin=3)
energy_axis_true = MapAxis.from_energy_bounds(
"0.3 TeV", "30 TeV", nbin=3, per_decade=True, name="energy_true"
)
geom_hpx = HpxGeom.create(
binsz=0.1, frame="galactic", axes=[energy_axis], region="DISK(0, 0, 5.)"
)
return {"geom": geom_hpx, "energy_axis_true": energy_axis_true}
def test_hpx_nd_map_to_nside():
axis = MapAxis.from_edges([1, 2, 3], name="test-1")
geom = HpxGeom.create(nside=64, axes=[axis])
m = HpxNDMap(geom, unit="m2")
m.data += 1
m2 = m.to_nside(nside=32)
assert_allclose(m2.data, 4)
m3 = m.to_nside(nside=128)
assert_allclose(m3.data, 0.25)
def test_hpx_geom_to_binsz():
geom = HpxGeom.create(nside=32, frame="galactic", nest=True)
geom_new = geom.to_binsz(1 * u.deg)
assert geom_new.nside[0] == 64
assert geom_new.frame == "galactic"
assert geom_new.nest
geom = HpxGeom.create(nside=32,
frame="galactic",
nest=True,
region="DISK(110.,75.,10.)")
geom_new = geom.to_binsz(1 * u.deg)
assert geom_new.nside[0] == 64
center = geom_new.center_skydir.galactic
assert_allclose(center.l.deg, 110)
assert_allclose(center.b.deg, 75)
