def test_compute_flux_spatial():
center = SkyCoord("0 deg", "0 deg", frame="galactic")
region = CircleSkyRegion(center=center, radius=0.1 * u.deg)
nbin = 2
energy_axis_true = MapAxis.from_energy_bounds(".1 TeV",
"10 TeV",
nbin=nbin,
name="energy_true")
spectral_model = ConstantSpectralModel()
spatial_model = PointSpatialModel(lon_0=0 * u.deg,
lat_0=0 * u.deg,
frame="galactic")
models = SkyModel(spectral_model=spectral_model,
spatial_model=spatial_model)
model = Models(models)
exposure_region = RegionNDMap.create(region,
axes=[energy_axis_true],
binsz_wcs="0.01deg")
exposure_region.data += 1.0
exposure_region.unit = "m2 s"
geom = RegionGeom(region, axes=[energy_axis_true], binsz_wcs="0.01deg")
psf = PSFKernel.from_gauss(geom.to_wcs_geom(), sigma="0.1 deg")
evaluator = MapEvaluator(model=model[0], exposure=exposure_region, psf=psf)
flux = evaluator.compute_flux_spatial()
g = Gauss2DPDF(0.1)
reference = g.containment_fraction(0.1)
assert_allclose(flux.value, reference, rtol=0.003)
def test_convolve_pixel_scale_error():
m = WcsNDMap.create(binsz=0.05 * u.deg, width=5 * u.deg)
kgeom = WcsGeom.create(binsz=0.04 * u.deg, width=0.5 * u.deg)
kernel = PSFKernel.from_gauss(kgeom, sigma=0.1 * u.deg, max_radius=1.5 * u.deg)
with pytest.raises(ValueError):
m.convolve(kernel)
def test_convolve_kernel_size_error():
axis_1 = MapAxis.from_energy_bounds("1 TeV", "10 TeV", nbin=2)
axis_2 = MapAxis.from_energy_bounds("1 TeV", "10 TeV", nbin=3)
m = WcsNDMap.create(binsz=0.05 * u.deg, width=5 * u.deg, axes=[axis_1])
kgeom = WcsGeom.create(binsz=0.05 * u.deg, width=0.5 * u.deg, axes=[axis_2])
kernel = PSFKernel.from_gauss(kgeom, sigma=0.1 * u.deg, max_radius=1.5 * u.deg)
with pytest.raises(ValueError):
m.convolve(kernel)
def test_convolve_wcs(nest):
energy = MapAxis.from_bounds(1, 100, unit='TeV', nbin=2, name='energy')
nside = 256
hpx_geom = HpxGeom.create(nside=nside,
axes=[energy],
region='DISK(0,0,2.5)',
nest=nest)
hpx_map = Map.from_geom(hpx_geom)
hpx_map.set_by_coord((0, 0, [2, 90]), 1)
wcs_geom = WcsGeom.create(width=5, binsz=0.04, axes=[energy])
kernel = PSFKernel.from_gauss(wcs_geom, 0.4 * u.deg)
convolved_map = hpx_map.convolve_wcs(kernel)
assert_allclose(convolved_map.data.sum(), 2, rtol=0.001)
def test_psf_kernel_from_gauss_read_write(tmp_path):
sigma = 0.5 * u.deg
binsz = 0.1 * u.deg
geom = WcsGeom.create(binsz=binsz, npix=150, axes=[MapAxis((0, 1, 2))])
kernel = PSFKernel.from_gauss(geom, sigma)
# Check that both maps are identical
assert_allclose(kernel.psf_kernel_map.data[0], kernel.psf_kernel_map.data[1])
# Is there an odd number of pixels
assert_allclose(np.array(kernel.psf_kernel_map.geom.npix) % 2, 1)
kernel.write(tmp_path / "tmp.fits", overwrite=True)
kernel2 = PSFKernel.read(tmp_path / "tmp.fits")
assert_allclose(kernel.psf_kernel_map.data, kernel2.psf_kernel_map.data)
def test_large_oversampling():
nbin = 2
energy_axis_true = MapAxis.from_energy_bounds(".1 TeV",
"10 TeV",
nbin=nbin,
name="energy_true")
geom = WcsGeom.create(width=1, binsz=0.02, axes=[energy_axis_true])
spectral_model = ConstantSpectralModel()
spatial_model = GaussianSpatialModel(lon_0=0 * u.deg,
lat_0=0 * u.deg,
sigma=1e-4 * u.deg,
frame="icrs")
models = SkyModel(spectral_model=spectral_model,
spatial_model=spatial_model)
model = Models(models)
exposure = Map.from_geom(geom, unit="m2 s")
exposure.data += 1.0
psf = PSFKernel.from_gauss(geom, sigma="0.1 deg")
evaluator = MapEvaluator(model=model[0], exposure=exposure, psf=psf)
flux_1 = evaluator.compute_flux_spatial()
spatial_model.sigma.value = 0.001
flux_2 = evaluator.compute_flux_spatial()
spatial_model.sigma.value = 0.01
flux_3 = evaluator.compute_flux_spatial()
spatial_model.sigma.value = 0.03
flux_4 = evaluator.compute_flux_spatial()
assert_allclose(flux_1.data.sum(), nbin, rtol=1e-4)
assert_allclose(flux_2.data.sum(), nbin, rtol=1e-4)
assert_allclose(flux_3.data.sum(), nbin, rtol=1e-4)
assert_allclose(flux_4.data.sum(), nbin, rtol=1e-4)
def test_compute_npred_sign():
center = SkyCoord("0 deg", "0 deg", frame="galactic")
energy_axis_true = MapAxis.from_energy_bounds(".1 TeV",
"10 TeV",
nbin=2,
name="energy_true")
geom = WcsGeom.create(skydir=center,
width=1 * u.deg,
axes=[energy_axis_true],
frame='galactic',
binsz=0.2 * u.deg)
spectral_model_pos = PowerLawSpectralModel(index=2,
amplitude="1e-11 TeV-1 s-1 m-2")
spectral_model_neg = PowerLawSpectralModel(
index=2, amplitude="-1e-11 TeV-1 s-1 m-2")
spatial_model = PointSpatialModel(lon_0=0 * u.deg,
lat_0=0 * u.deg,
frame="galactic")
model_pos = SkyModel(spectral_model=spectral_model_pos,
spatial_model=spatial_model)
model_neg = SkyModel(spectral_model=spectral_model_neg,
spatial_model=spatial_model)
exposure = Map.from_geom(geom, unit="m2 s")
exposure.data += 1.0
psf = PSFKernel.from_gauss(geom, sigma="0.1 deg")
evaluator_pos = MapEvaluator(model=model_pos, exposure=exposure, psf=psf)
evaluator_neg = MapEvaluator(model=model_neg, exposure=exposure, psf=psf)
npred_pos = evaluator_pos.compute_npred()
npred_neg = evaluator_neg.compute_npred()
assert (npred_pos.data == -npred_neg.data).all()
assert np.all(npred_pos.data >= 0)
assert np.all(npred_neg.data <= 0)
def psf(geom_true):
sigma = 0.5 * u.deg
return PSFKernel.from_gauss(geom_true, sigma)
