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)