def test_create_onoff(geom, geom_etrue):
# tests empty datasets created
migra_axis = MapAxis(nodes=np.linspace(0.0, 3.0, 51),
unit="",
name="migra")
rad_axis = MapAxis(nodes=np.linspace(0.0, 1.0, 51),
unit="deg",
name="theta")
empty_dataset = MapDatasetOnOff.create(geom, geom_etrue, migra_axis,
rad_axis)
assert_allclose(empty_dataset.counts.data.sum(), 0.0)
assert_allclose(empty_dataset.counts_off.data.sum(), 0.0)
assert_allclose(empty_dataset.acceptance.data.sum(), 0.0)
assert_allclose(empty_dataset.acceptance_off.data.sum(), 0.0)
assert empty_dataset.psf.psf_map.data.shape == (3, 50, 100, 100)
assert empty_dataset.psf.exposure_map.data.shape == (3, 1, 100, 100)
assert empty_dataset.edisp.edisp_map.data.shape == (3, 50, 100, 100)
assert empty_dataset.edisp.exposure_map.data.shape == (3, 1, 100, 100)
assert_allclose(empty_dataset.edisp.edisp_map.data.sum(), 30000)
assert_allclose(empty_dataset.gti.time_delta, 0.0 * u.s)
def make_edisp_map_test():
etrue = [0.2, 0.7, 1.5, 2.0, 10.0] * u.TeV
migra = np.linspace(0.0, 3.0, 51)
offsets = np.array((0.0, 1.0, 2.0, 3.0)) * u.deg
pointing = SkyCoord(0, 0, unit="deg")
energy_axis = MapAxis(
nodes=[0.2, 0.7, 1.5, 2.0, 10.0],
unit="TeV",
name="energy_true",
node_type="edges",
interp="log",
)
migra_axis = MapAxis(nodes=np.linspace(0.0, 3.0, 51), unit="", name="migra")
edisp2d = EnergyDispersion2D.from_gauss(etrue, migra, 0.0, 0.2, offsets)
geom = WcsGeom.create(
skydir=pointing, binsz=1.0, width=5.0, axes=[migra_axis, energy_axis]
)
aeff2d = fake_aeff2d()
exposure_geom = geom.squash(axis_name="migra")
exposure_map = make_map_exposure_true_energy(pointing, "1 h", aeff2d, exposure_geom)
return make_edisp_map(edisp2d, pointing, geom, exposure_map)
def test_create_onoff(geom):
# tests empty datasets created
migra_axis = MapAxis(nodes=np.linspace(0.0, 3.0, 51),
unit="",
name="migra")
rad_axis = MapAxis(nodes=np.linspace(0.0, 1.0, 51),
unit="deg",
name="theta")
energy_axis = geom.get_axis_by_name("energy").copy(name="energy_true")
empty_dataset = MapDatasetOnOff.create(geom, energy_axis, migra_axis,
rad_axis)
assert_allclose(empty_dataset.counts.data.sum(), 0.0)
assert_allclose(empty_dataset.counts_off.data.sum(), 0.0)
assert_allclose(empty_dataset.acceptance.data.sum(), 0.0)
assert_allclose(empty_dataset.acceptance_off.data.sum(), 0.0)
assert empty_dataset.psf.psf_map.data.shape == (2, 50, 10, 10)
assert empty_dataset.psf.exposure_map.data.shape == (2, 1, 10, 10)
assert empty_dataset.edisp.edisp_map.data.shape == (2, 50, 10, 10)
assert empty_dataset.edisp.exposure_map.data.shape == (2, 1, 10, 10)
assert_allclose(empty_dataset.edisp.edisp_map.data.sum(), 200)
assert_allclose(empty_dataset.gti.time_delta, 0.0 * u.s)
def test_create_with_migra(tmp_path):
# tests empty datasets created
migra_axis = MapAxis(nodes=np.linspace(0.0, 3.0, 51), unit="", name="migra")
rad_axis = MapAxis(nodes=np.linspace(0.0, 1.0, 51), unit="deg", name="rad")
e_reco = MapAxis.from_edges(
np.logspace(-1.0, 1.0, 3), name="energy", unit=u.TeV, interp="log"
)
e_true = MapAxis.from_edges(
np.logspace(-1.0, 1.0, 4), name="energy_true", unit=u.TeV, interp="log"
)
geom = WcsGeom.create(binsz=0.02, width=(2, 2), axes=[e_reco])
empty_dataset = MapDataset.create(
geom=geom, energy_axis_true=e_true, migra_axis=migra_axis, rad_axis=rad_axis
)
empty_dataset.write(tmp_path / "test.fits")
dataset_new = MapDataset.read(tmp_path / "test.fits")
assert isinstance(empty_dataset.edisp, EDispMap)
assert empty_dataset.edisp.edisp_map.data.shape == (3, 50, 10, 10)
assert empty_dataset.edisp.exposure_map.data.shape == (3, 1, 10, 10)
assert_allclose(empty_dataset.edisp.edisp_map.data.sum(), 300)
assert_allclose(empty_dataset.gti.time_delta, 0.0 * u.s)
assert isinstance(dataset_new.edisp, EDispMap)
assert dataset_new.edisp.edisp_map.data.shape == (3, 50, 10, 10)
def test_create(geom, geom_etrue):
# tests empty datasets created
migra_axis = MapAxis(nodes=np.linspace(0.0, 3.0, 51), unit="", name="migra")
rad_axis = MapAxis(nodes=np.linspace(0.0, 1.0, 51), unit="deg", name="theta")
e_reco = MapAxis.from_edges(
np.logspace(-1.0, 1.0, 3), name="energy", unit=u.TeV, interp="log"
)
e_true = MapAxis.from_edges(
np.logspace(-1.0, 1.0, 4), name="energy_true", unit=u.TeV, interp="log"
)
geom = WcsGeom.create(binsz=0.02, width=(2, 2), axes=[e_reco])
empty_dataset = MapDataset.create(
geom=geom, energy_axis_true=e_true, migra_axis=migra_axis, rad_axis=rad_axis
)
assert empty_dataset.counts.data.shape == (2, 100, 100)
assert empty_dataset.exposure.data.shape == (3, 100, 100)
assert empty_dataset.psf.psf_map.data.shape == (3, 50, 10, 10)
assert empty_dataset.psf.exposure_map.data.shape == (3, 1, 10, 10)
assert empty_dataset.edisp.edisp_map.data.shape == (3, 50, 10, 10)
assert empty_dataset.edisp.exposure_map.data.shape == (3, 1, 10, 10)
assert_allclose(empty_dataset.edisp.edisp_map.data.sum(), 300)
assert_allclose(empty_dataset.gti.time_delta, 0.0 * u.s)
def test_map_reproject_wcs_to_wcs():
energy_nodes = np.arange(3)
time_nodes = np.arange(4)
axis1 = MapAxis(energy_nodes,
interp="lin",
name="energy",
node_type="center")
axis2 = MapAxis(time_nodes, interp="lin", name="time", node_type="center")
geom_wcs_1 = WcsGeom.create(
skydir=(266.405, -28.936),
npix=(11, 11),
binsz=0.1,
axes=[axis1, axis2],
coordsys="CEL",
)
geom_wcs_2 = WcsGeom.create(skydir=(0, 0),
npix=(11, 11),
binsz=0.1,
coordsys="GAL")
spatial_data = np.zeros((11, 11))
energy_data = energy_nodes.reshape(3, 1, 1)
time_data = time_nodes.reshape(4, 1, 1, 1)
data = spatial_data + energy_data + 0.5 * time_data
m = WcsNDMap(geom_wcs_1, data=data)
m_r = m.reproject(geom_wcs_2)
assert m.data.shape == m_r.data.shape
for data, idx in m_r.iter_by_image():
ref = idx[1] + 0.5 * idx[0]
assert_allclose(np.nanmean(data), ref)
def test_from_geoms_onoff():
migra_axis = MapAxis(nodes=np.linspace(0.0, 3.0, 51), unit="", name="migra")
rad_axis = MapAxis(nodes=np.linspace(0.0, 1.0, 51), unit="deg", name="theta")
e_reco = MapAxis.from_edges(
np.logspace(-1.0, 1.0, 3), name="energy", unit=u.TeV, interp="log"
)
e_true = MapAxis.from_edges(
np.logspace(-1.0, 1.0, 4), name="energy", unit=u.TeV, interp="log"
)
wcs = WcsGeom.create(binsz=0.02, width=(2, 2))
wcs_irf = WcsGeom.create(binsz=0.1, width=(2.5, 2.5))
geom = wcs.to_cube([e_reco])
geom_exposure = wcs.to_cube([e_true])
geom_psf = wcs_irf.to_cube([rad_axis, e_true])
geom_edisp = wcs_irf.to_cube([migra_axis, e_true])
empty_dataset = MapDataset.from_geoms(geom, geom_exposure, geom_psf, geom_edisp)
assert empty_dataset.counts.data.shape == (2, 100, 100)
assert empty_dataset.exposure.data.shape == (3, 100, 100)
assert empty_dataset.psf.psf_map.data.shape == (3, 50, 25, 25)
assert empty_dataset.psf.exposure_map.data.shape == (3, 1, 25, 25)
assert empty_dataset.edisp.edisp_map.data.shape == (3, 50, 25, 25)
assert empty_dataset.edisp.exposure_map.data.shape == (3, 1, 25, 25)
assert_allclose(empty_dataset.edisp.edisp_map.data.sum(), 1875)
assert_allclose(empty_dataset.gti.time_delta, 0.0 * u.s)
def test_template_ND_EBL(tmpdir):
#TODO: add RegionNDMap.read(format="xspec")
# Create EBL data array
filename = "$GAMMAPY_DATA/ebl/ebl_franceschini.fits.gz"
filename = make_path(filename)
table_param = Table.read(filename, hdu="PARAMETERS")
npar = len(table_param)
par_axes = []
idx_data = []
for k in range(npar):
name = table_param["NAME"][k].lower().strip()
param, idx = np.unique(table_param[0]["VALUE"], return_index=True)
par_axes.append(
MapAxis(param,
node_type="center",
interp="lin",
name=name,
unit=""))
idx_data.append(idx)
idx_data.append(Ellipsis)
idx_data = tuple(idx_data)
# Get energy values
table_energy = Table.read(filename, hdu="ENERGIES")
energy_lo = u.Quantity(table_energy["ENERG_LO"], "keV",
copy=False) # unit not stored in file
energy_hi = u.Quantity(table_energy["ENERG_HI"], "keV",
copy=False) # unit not stored in file
energy = np.sqrt(energy_lo * energy_hi)
# Get spectrum values
table_spectra = Table.read(filename, hdu="SPECTRA")
energy_axis = MapAxis(energy,
node_type="center",
interp="log",
name="energy_true")
region_map = RegionNDMap.create(region="galactic;point(0, 0)",
axes=[energy_axis] + par_axes)
#TODO: here we use a fake position, is it possible to allow region=None ?
data = table_spectra["INTPSPEC"].data[idx_data]
region_map.data[:, :, 0, 0] = data
template = TemplateNDSpectralModel(region_map)
assert len(template.parameters) == 1
assert_allclose(template.parameters["redshift"].value, 1.001, rtol=1e-3)
expected = [9.950501e-01, 4.953951e-01, 1.588062e-06]
assert_allclose(template([1, 100, 1000] * u.GeV), expected, rtol=1e-3)
template.parameters["redshift"].value = 0.1
template.filename = str(tmpdir / "template_ND_ebl_franceschini.fits")
template.write()
dict_ = template.to_dict()
template_new = TemplateNDSpectralModel.from_dict(dict_)
assert_allclose(template_new.map.data, region_map.data)
assert len(template.parameters) == 1
assert_allclose(template.parameters["redshift"].value, 0.1)
def test_mapaxis_equal(nodes, interp, node_type, unit, name, result):
axis1 = MapAxis(
nodes=[0.25, 0.75, 1.0, 2.0],
name="test",
unit="s",
interp="lin",
node_type="edges",
)
axis2 = MapAxis(nodes, name=name, unit=unit, interp=interp, node_type=node_type)
assert (axis1 == axis2) is result
assert (axis1 != axis2) is not result
def test_containment_radius_map():
psf = fake_psf3d(0.15 * u.deg)
pointing = SkyCoord(0, 0, unit="deg")
energy_axis = MapAxis(nodes=[0.2, 1, 2], unit="TeV", name="energy_true")
psf_theta_axis = MapAxis(nodes=np.linspace(0.0, 0.6, 30), unit="deg", name="theta")
geom = WcsGeom.create(
skydir=pointing, binsz=0.5, width=(4, 3), axes=[psf_theta_axis, energy_axis]
)
psfmap = make_psf_map(psf=psf, pointing=pointing, geom=geom)
m = psfmap.containment_radius_map(1 * u.TeV)
coord = SkyCoord(0.3, 0, unit="deg")
val = m.interp_by_coord(coord)
assert_allclose(val, 0.226477, rtol=1e-3)
def test_convolve_vs_smooth():
axes = [
MapAxis(np.logspace(0.0, 3.0, 3), interp="log"),
MapAxis(np.logspace(1.0, 3.0, 4), interp="lin"),
]
binsz = 0.05 * u.deg
m = WcsNDMap.create(binsz=binsz, width=1.05 * u.deg, axes=axes)
m.data[:, :, 10, 10] = 1.0
desired = m.smooth(kernel="gauss", width=0.5 * u.deg, mode="constant")
gauss = Gaussian2DKernel(10).array
actual = m.convolve(kernel=gauss)
assert_allclose(actual.data, desired.data, rtol=1e-3)
def test_smooth(kernel):
axes = [
MapAxis(np.logspace(0.0, 3.0, 3), interp="log"),
MapAxis(np.logspace(1.0, 3.0, 4), interp="lin"),
]
geom = WcsGeom.create(
npix=(10, 10), binsz=1, proj="CAR", frame="galactic", axes=axes
)
m = WcsNDMap(geom, data=np.ones(geom.data_shape), unit="m2")
desired = m.data.sum()
smoothed = m.smooth(0.2 * u.deg, kernel)
actual = smoothed.data.sum()
assert_allclose(actual, desired)
assert smoothed.data.dtype == float
def make_test_psfmap(size, shape="gauss"):
psf = fake_psf3d(size, shape)
aeff2d = fake_aeff2d()
pointing = SkyCoord(0, 0, unit="deg")
energy_axis = MapAxis(nodes=[0.2, 0.7, 1.5, 2.0, 10.0],
unit="TeV",
name="energy")
rad_axis = MapAxis.from_nodes(nodes=np.linspace(0.0, 0.6, 50),
unit="deg",
name="theta")
geom = WcsGeom.create(skydir=pointing,
binsz=0.2,
width=5,
axes=[rad_axis, energy_axis])
exposure_geom = WcsGeom.create(skydir=pointing,
binsz=0.2,
width=5,
axes=[energy_axis])
exposure_map = make_map_exposure_true_energy(pointing, "1 h", aeff2d,
exposure_geom)
return make_psf_map(psf, pointing, geom, 3 * u.deg, exposure_map)
def test_read_write(tmp_path, node_type, interp):
# Regression test for MapAxis interp and node_type FITS serialization
# https://github.com/gammapy/gammapy/issues/1887
e_ax = MapAxis([1, 2], interp, "energy", node_type, "TeV")
t_ax = MapAxis([3, 4], interp, "time", node_type, "s")
m = Map.create(binsz=1, npix=10, axes=[e_ax, t_ax], unit="m2")
# Check what Gammapy writes in the FITS header
header = m.make_hdu().header
assert header["INTERP1"] == interp
assert header["INTERP2"] == interp
# Check that all MapAxis properties are preserved on FITS I/O
m.write(tmp_path / "tmp.fits", overwrite=True)
m2 = Map.read(tmp_path / "tmp.fits")
assert m2.geom == m.geom
def test_mapaxis_pix_to_coord(nodes, interp, node_type):
axis = MapAxis(nodes, interp=interp, node_type=node_type)
assert_allclose(axis.center,
axis.pix_to_coord(np.arange(axis.nbin, dtype=float)))
assert_allclose(
np.arange(axis.nbin + 1, dtype=float) - 0.5,
axis.coord_to_pix(axis.edges))
def test_make_edisp_map():
energy_axis = MapAxis(
nodes=[0.2, 0.7, 1.5, 2.0, 10.0],
unit="TeV",
name="energy_true",
node_type="edges",
interp="log",
)
migra_axis = MapAxis(nodes=np.linspace(0.0, 3.0, 51), unit="", name="migra")
edmap = make_edisp_map_test()
assert edmap.edisp_map.geom.axes[0] == migra_axis
assert edmap.edisp_map.geom.axes[1] == energy_axis
assert edmap.edisp_map.unit == Unit("")
assert edmap.edisp_map.data.shape == (4, 50, 5, 5)
def make_edisp_map_test():
pointing = SkyCoord(0, 0, unit="deg")
energy_axis_true = MapAxis.from_energy_edges(
energy_edges=[0.2, 0.7, 1.5, 2.0, 10.0] * u.TeV,
name="energy_true",
)
migra_axis = MapAxis(nodes=np.linspace(0.0, 3.0, 51), unit="", name="migra")
offset_axis = MapAxis.from_nodes([0.0, 1.0, 2.0, 3.0] * u.deg, name="offset")
edisp2d = EnergyDispersion2D.from_gauss(
energy_axis_true=energy_axis_true,
migra_axis=migra_axis,
offset_axis=offset_axis,
bias=0,
sigma=0.2,
)
geom = WcsGeom.create(
skydir=pointing, binsz=1.0, width=5.0, axes=[migra_axis, energy_axis_true]
)
aeff2d = fake_aeff2d()
exposure_geom = geom.squash(axis_name="migra")
exposure_map = make_map_exposure_true_energy(pointing, "1 h", aeff2d, exposure_geom)
return make_edisp_map(edisp2d, pointing, geom, exposure_map)
def test_make_psf_map():
psf = fake_psf3d(0.3 * u.deg)
pointing = SkyCoord(0, 0, unit="deg")
energy_axis = MapAxis(nodes=[0.2, 0.7, 1.5, 2.0, 10.0], unit="TeV", name="energy")
rad_axis = MapAxis(nodes=np.linspace(0.0, 1.0, 51), unit="deg", name="theta")
geom = WcsGeom.create(
skydir=pointing, binsz=0.2, width=5, axes=[rad_axis, energy_axis]
)
psfmap = make_psf_map(psf, pointing, geom, 3 * u.deg)
assert psfmap.psf_map.geom.axes[0] == rad_axis
assert psfmap.psf_map.geom.axes[1] == energy_axis
assert psfmap.psf_map.unit == Unit("sr-1")
assert psfmap.psf_map.data.shape == (4, 50, 25, 25)
def test_mapaxis_init_from_edges(edges, interp):
axis = MapAxis(edges, interp=interp)
assert_allclose(axis.edges, edges)
assert_allclose(axis.nbin, len(edges) - 1)
with pytest.raises(ValueError):
MapAxis.from_edges([1])
MapAxis.from_edges([0, 1, 1, 2])
MapAxis.from_edges([0, 1, 3, 2])
def test_upsample():
axis = MapAxis(
nodes=[0, 1, 2, 3], unit="TeV", name="energy", node_type="edges", interp="lin"
)
axis_up = axis.upsample(10)
assert_allclose(axis_up.nbin, 10 * axis.nbin)
assert_allclose(axis_up.edges[0], axis.edges[0])
assert_allclose(axis_up.edges[-1], axis.edges[-1])
assert axis_up.node_type == axis.node_type
def test_squash():
axis = MapAxis(
nodes=[0, 1, 2, 3], unit="TeV", name="energy", node_type="edges", interp="lin"
)
ax_sq = axis.squash()
assert_allclose(ax_sq.nbin, 1)
assert_allclose(axis.edges[0], ax_sq.edges[0])
assert_allclose(axis.edges[-1], ax_sq.edges[1])
assert_allclose(ax_sq.center, 1.5 * u.TeV)
def test_set_get_by_coord_quantities():
ax = MapAxis(np.logspace(0.0, 3.0, 3), interp="log", name="energy", unit="TeV")
geom = WcsGeom.create(binsz=0.1, npix=(3, 4), axes=[ax])
m = WcsNDMap(geom)
coords_dict = {"lon": 0, "lat": 0, "energy": 1000 * u.GeV}
m.set_by_coord(coords_dict, 42)
coords_dict["energy"] = 1 * u.TeV
assert_allclose(42, m.get_by_coord(coords_dict))
def test_mapaxis_slice(nodes, interp, node_type):
axis = MapAxis(nodes, interp=interp, node_type=node_type)
saxis = axis.slice(slice(1, 3))
assert_allclose(saxis.nbin, 2)
assert_allclose(saxis.center, axis.center[slice(1, 3)])
axis = MapAxis(nodes, interp=interp, node_type=node_type)
saxis = axis.slice(slice(1, None))
assert_allclose(saxis.nbin, axis.nbin - 1)
assert_allclose(saxis.center, axis.center[slice(1, None)])
axis = MapAxis(nodes, interp=interp, node_type=node_type)
saxis = axis.slice(slice(None, 2))
assert_allclose(saxis.nbin, 2)
assert_allclose(saxis.center, axis.center[slice(None, 2)])
axis = MapAxis(nodes, interp=interp, node_type=node_type)
saxis = axis.slice(slice(None, -1))
assert_allclose(saxis.nbin, axis.nbin - 1)
assert_allclose(saxis.center, axis.center[slice(None, -1)])
def test_smooth(kernel):
axes = [
MapAxis(np.logspace(0.0, 3.0, 3), interp="log"),
MapAxis(np.logspace(1.0, 3.0, 4), interp="lin"),
]
geom_nest = HpxGeom.create(nside=256,
nest=False,
frame="galactic",
axes=axes)
geom_ring = HpxGeom.create(nside=256,
nest=True,
frame="galactic",
axes=axes)
m_nest = HpxNDMap(geom_nest, data=np.ones(geom_nest.data_shape), unit="m2")
m_ring = HpxNDMap(geom_ring, data=np.ones(geom_ring.data_shape), unit="m2")
desired_nest = m_nest.data.sum()
desired_ring = m_ring.data.sum()
smoothed_nest = m_nest.smooth(0.2 * u.deg, kernel)
smoothed_ring = m_ring.smooth(0.2 * u.deg, kernel)
actual_nest = smoothed_nest.data.sum()
assert_allclose(actual_nest, desired_nest)
assert smoothed_nest.data.dtype == float
actual_ring = smoothed_ring.data.sum()
assert_allclose(actual_ring, desired_ring)
assert smoothed_ring.data.dtype == float
# with pytest.raises(NotImplementedError):
cutout = m_nest.cutout(position=(0, 0), width=15 * u.deg)
smoothed_cutout = cutout.smooth(0.1 * u.deg, kernel)
actual_cutout = cutout.data.sum()
desired_cutout = smoothed_cutout.data.sum()
assert_allclose(actual_cutout, desired_cutout, rtol=0.01)
with pytest.raises(ValueError):
m_nest.smooth(0.2 * u.deg, "box")
def test_downsample():
axis = MapAxis(
nodes=[0, 1, 2, 3, 4, 5, 6, 7, 8],
unit="TeV",
name="energy",
node_type="edges",
interp="lin",
)
axis_down = axis.downsample(2)
assert_allclose(axis_down.nbin, 0.5 * axis.nbin)
assert_allclose(axis_down.edges[0], axis.edges[0])
assert_allclose(axis_down.edges[-1], axis.edges[-1])
assert axis_down.node_type == axis.node_type
def test_hpxmap_interp_by_coord_quantities():
ax = MapAxis(np.logspace(0.0, 3.0, 3),
interp="log",
name="energy",
unit="TeV")
geom = HpxGeom(nside=1, axes=[ax])
m = HpxNDMap(geom=geom)
coords_dict = {"lon": 99, "lat": 42, "energy": 1000 * u.GeV}
coords = m.geom.get_coord(flat=True)
m.set_by_coord(coords, coords["lat"])
coords_dict["energy"] = 1 * u.TeV
val = m.interp_by_coord(coords_dict)
assert_allclose(val, 42, rtol=1e-2)
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_map_dataset_on_off_fake(geom):
rad_axis = MapAxis(nodes=np.linspace(0.0, 1.0, 51), unit="deg", name="rad")
energy_true_axis = geom.axes["energy"].copy(name="energy_true")
empty_dataset = MapDataset.create(geom, energy_true_axis, rad_axis=rad_axis)
empty_dataset = MapDatasetOnOff.from_map_dataset(
empty_dataset, acceptance=1, acceptance_off=10.0
)
empty_dataset.acceptance_off.data[0, 50, 50] = 0
background_map = Map.from_geom(geom, data=1)
empty_dataset.fake(background_map, random_state=42)
assert_allclose(empty_dataset.counts.data[0, 50, 50], 0)
assert_allclose(empty_dataset.counts.data.mean(), 0.99445, rtol=1e-3)
assert_allclose(empty_dataset.counts_off.data.mean(), 10.00055, rtol=1e-3)
def test_interp_by_coord_quantities():
ax = MapAxis(
np.logspace(0.0, 3.0, 3),
interp="log",
name="energy",
unit="TeV",
node_type="center",
)
geom = WcsGeom.create(binsz=0.1, npix=(3, 3), axes=[ax])
m = WcsNDMap(geom)
coords_dict = {"lon": 0, "lat": 0, "energy": 1000 * u.GeV}
m.set_by_coord(coords_dict, 42)
coords_dict["energy"] = 1 * u.TeV
assert_allclose(42.0, m.interp_by_coord(coords_dict, method="nearest"))
def test_edisp_map_to_edisp_kernel_map():
energy_axis = MapAxis.from_energy_bounds("1 TeV", "10 TeV", nbin=5)
energy_axis_true = MapAxis.from_energy_bounds(
"0.3 TeV", "30 TeV", nbin=10, per_decade=True, name="energy_true"
)
migra_axis = MapAxis(nodes=np.linspace(0.0, 3.0, 51), unit="", name="migra")
edisp_map = EDispMap.from_diagonal_response(energy_axis_true, migra_axis)
edisp_kernel_map = edisp_map.to_edisp_kernel_map(energy_axis)
position = SkyCoord(0, 0, unit="deg")
kernel = edisp_kernel_map.get_edisp_kernel(position)
assert edisp_kernel_map.exposure_map.geom.axes[0].name == "energy"
actual = kernel.pdf_matrix.sum(axis=0)
assert_allclose(actual, 2.0)
