def test_edisp_kernel_map_stack():
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"
)
edisp_1 = EDispKernelMap.from_diagonal_response(
energy_axis=energy_axis, energy_axis_true=energy_axis_true
)
edisp_1.exposure_map.data += 1
edisp_2 = EDispKernelMap.from_diagonal_response(
energy_axis=energy_axis, energy_axis_true=energy_axis_true
)
edisp_2.exposure_map.data += 2
geom = edisp_1.edisp_map.geom
data = geom.energy_mask(emin=2 * u.TeV)
weights = Map.from_geom(geom=geom, data=data)
edisp_1.stack(edisp_2, weights=weights)
position = SkyCoord(0, 0, unit="deg")
kernel = edisp_1.get_edisp_kernel(position)
actual = kernel.pdf_matrix.sum(axis=0)
exposure = edisp_1.exposure_map.data[:, 0, 0, 0]
assert_allclose(actual, [2.0 / 3.0, 2.0 / 3.0, 2.0, 2.0, 2.0])
assert_allclose(exposure, 3.0)
def test_edisp_map_from_geom_error():
energy_axis = MapAxis.from_energy_bounds("1 TeV", "10 TeV", nbin=3)
energy_axis_true = MapAxis.from_energy_bounds(
"1 TeV", "10 TeV", nbin=3, name="energy_true"
)
geom = WcsGeom.create(npix=(1, 1), axes=[energy_axis_true, energy_axis])
with pytest.raises(ValueError):
EDispKernelMap.from_geom(geom=geom)
def test_spectrum_dataset_stack_nondiagonal_no_bkg(spectrum_dataset):
energy = spectrum_dataset.counts.geom.axes["energy"]
geom = spectrum_dataset.counts.geom.to_image()
edisp1 = EDispKernelMap.from_gauss(
energy_axis=energy,
energy_axis_true=energy.copy(name="energy_true"),
sigma=0.1,
bias=0,
geom=geom)
edisp1.exposure_map.data += 1
aeff = EffectiveAreaTable.from_parametrization(
energy.edges, "HESS").to_region_map(geom.region)
geom = spectrum_dataset.counts.geom
counts = RegionNDMap.from_geom(geom=geom)
gti = GTI.create(start=0 * u.s, stop=100 * u.s)
spectrum_dataset1 = SpectrumDataset(
counts=counts,
exposure=aeff * gti.time_sum,
edisp=edisp1,
meta_table=Table({"OBS_ID": [0]}),
gti=gti.copy(),
)
edisp2 = EDispKernelMap.from_gauss(
energy_axis=energy,
energy_axis_true=energy.copy(name="energy_true"),
sigma=0.2,
bias=0.0,
geom=geom)
edisp2.exposure_map.data += 1
gti2 = GTI.create(start=100 * u.s, stop=200 * u.s)
spectrum_dataset2 = SpectrumDataset(
counts=counts,
exposure=aeff * gti2.time_sum,
edisp=edisp2,
meta_table=Table({"OBS_ID": [1]}),
gti=gti2,
)
spectrum_dataset1.stack(spectrum_dataset2)
assert_allclose(spectrum_dataset1.meta_table["OBS_ID"][0], [0, 1])
assert spectrum_dataset1.background_model is None
assert_allclose(spectrum_dataset1.gti.time_sum.to_value("s"), 200)
assert_allclose(spectrum_dataset1.exposure.quantity[2].to_value("m2 s"),
1573851.079861)
kernel = edisp1.get_edisp_kernel()
assert_allclose(kernel.get_bias(1 * u.TeV), 0.0, atol=1.2e-3)
assert_allclose(kernel.get_resolution(1 * u.TeV), 0.1581, atol=1e-2)
def spectrum_dataset():
e_true = MapAxis.from_energy_bounds("1 TeV",
"10 TeV",
nbin=20,
name="energy_true")
e_reco = MapAxis.from_energy_bounds("1 TeV", "10 TeV", nbin=4)
background = RegionNDMap.create(region="icrs;circle(0, 0, 0.1)",
axes=[e_reco])
background.data += 3600
background.data[0] *= 1e3
background.data[-1] *= 1e-3
edisp = EDispKernelMap.from_diagonal_response(energy_axis_true=e_true,
energy_axis=e_reco,
geom=background.geom)
aeff = RegionNDMap.create(region="icrs;circle(0, 0, 0.1)",
axes=[e_true],
unit="m2")
aeff.data += 1e6
livetime = 1 * u.h
exposure = aeff * livetime
return SpectrumDataset(
name="test",
exposure=exposure,
edisp=edisp,
models=BackgroundModel(background,
name="test-bkg",
datasets_names="test"),
)
def make_edisp_kernel(self, geom, observation):
"""Make energy dispersion.
Parameters
----------
geom : `~gammapy.maps.Geom`
Reference geom. Must contain "energy" and "energy_true" axes in that order.
observation: `~gammapy.data.Observation`
Observation to compute edisp for.
Returns
-------
edisp : `~gammapy.irf.EDispKernelMap`
Energy dispersion kernel map
"""
position = geom.center_skydir
energy_axis = geom.axes["energy"]
energy_axis_true = geom.axes["energy_true"]
offset = observation.pointing_radec.separation(position)
kernel = observation.edisp.to_edisp_kernel(
offset,
energy=energy_axis.edges,
energy_true=energy_axis_true.edges)
edisp = EDispKernelMap.from_edisp_kernel(kernel, geom=geom.to_image())
exposure = self.make_exposure(geom.squash("energy"), observation)
edisp.exposure_map.data = exposure.data[:, :, np.newaxis, :]
return edisp
def create(
cls,
e_reco,
e_true=None,
region=None,
reference_time="2000-01-01",
name=None,
meta_table=None,
):
"""Creates empty spectrum dataset.
Empty containers are created with the correct geometry.
counts, background and aeff are zero and edisp is diagonal.
The safe_mask is set to False in every bin.
Parameters
----------
e_reco : `~gammapy.maps.MapAxis`
counts energy axis. Its name must be "energy".
e_true : `~gammapy.maps.MapAxis`
effective area table energy axis. Its name must be "energy-true".
If not set use reco energy values. Default : None
region : `~regions.SkyRegion`
Region to define the dataset for.
reference_time : `~astropy.time.Time`
reference time of the dataset, Default is "2000-01-01"
meta_table : `~astropy.table.Table`
Table listing informations on observations used to create the dataset.
One line per observation for stacked datasets.
"""
if e_true is None:
e_true = e_reco.copy(name="energy_true")
if region is None:
region = "icrs;circle(0, 0, 1)"
name = make_name(name)
counts = RegionNDMap.create(region=region, axes=[e_reco])
background = RegionNDMap.create(region=region, axes=[e_reco])
exposure = RegionNDMap.create(region=region,
axes=[e_true],
unit="cm2 s",
meta={"livetime": 0 * u.s})
edisp = EDispKernelMap.from_diagonal_response(e_reco,
e_true,
geom=counts.geom)
mask_safe = RegionNDMap.from_geom(counts.geom, dtype="bool")
gti = GTI.create(u.Quantity([], "s"), u.Quantity([], "s"),
reference_time)
return SpectrumDataset(
counts=counts,
exposure=exposure,
background=background,
edisp=edisp,
mask_safe=mask_safe,
gti=gti,
name=name,
)
def spectrum_dataset():
e_true = MapAxis.from_energy_bounds("1 TeV",
"10 TeV",
nbin=20,
name="energy_true")
e_reco = MapAxis.from_energy_bounds("1 TeV", "10 TeV", nbin=4)
background = RegionNDMap.create(region="icrs;circle(0, 0, 0.1)",
axes=[e_reco])
background.data += 3600
background.data[0] *= 1e3
background.data[-1] *= 1e-3
edisp = EDispKernelMap.from_diagonal_response(energy_axis_true=e_true,
energy_axis=e_reco,
geom=background.geom)
exposure = RegionNDMap.create(region="icrs;circle(0, 0, 0.1)",
axes=[e_true],
unit="m2 h",
data=1e6)
return SpectrumDataset(name="test",
exposure=exposure,
edisp=edisp,
background=background)
def simulate_spectrum_dataset(model, random_state=0):
edges = np.logspace(-0.5, 1.5, 21) * u.TeV
energy_axis = MapAxis.from_edges(edges, interp="log", name="energy")
aeff = EffectiveAreaTable.from_parametrization(energy=edges).to_region_map()
bkg_model = SkyModel(
spectral_model=PowerLawSpectralModel(
index=2.5, amplitude="1e-12 cm-2 s-1 TeV-1"
),
name="background",
)
bkg_model.spectral_model.amplitude.frozen = True
bkg_model.spectral_model.index.frozen = True
geom = RegionGeom(region=None, axes=[energy_axis])
acceptance = RegionNDMap.from_geom(geom=geom, data=1)
edisp = EDispKernelMap.from_diagonal_response(
energy_axis=energy_axis,
energy_axis_true=energy_axis.copy(name="energy_true"),
geom=geom
)
dataset = SpectrumDatasetOnOff(
aeff=aeff, livetime=100 * u.h, acceptance=acceptance, acceptance_off=5, edisp=edisp
)
dataset.models = bkg_model
bkg_npred = dataset.npred_sig()
dataset.models = model
dataset.fake(random_state=random_state, background_model=bkg_npred)
return dataset
def data_prep():
counts = Map.read(
"$GAMMAPY_DATA/fermi-3fhl-gc/fermi-3fhl-gc-counts-cube.fits.gz")
background = Map.read(
"$GAMMAPY_DATA/fermi-3fhl-gc/fermi-3fhl-gc-background-cube.fits.gz")
exposure = Map.read(
"$GAMMAPY_DATA/fermi-3fhl-gc/fermi-3fhl-gc-exposure-cube.fits.gz")
# unit is not properly stored on the file. We add it manually
exposure = Map.from_geom(exposure.geom, data=exposure.data, unit="cm2s")
psfmap = PSFMap.read(
"$GAMMAPY_DATA/fermi-3fhl-gc/fermi-3fhl-gc-psf-cube.fits.gz",
format="gtpsf")
edisp = EDispKernelMap.from_diagonal_response(
energy_axis=counts.geom.axes["energy"],
energy_axis_true=exposure.geom.axes["energy_true"],
)
dataset = MapDataset(
counts=counts,
background=background,
exposure=exposure,
psf=psfmap,
name="fermi-3fhl-gc",
edisp=edisp,
)
return dataset
def make_observation_list():
"""obs with dummy IRF"""
nbin = 3
energy = np.logspace(-1, 1, nbin + 1) * u.TeV
livetime = 2 * u.h
data_on = np.arange(nbin)
dataoff_1 = np.ones(3)
dataoff_2 = np.ones(3) * 3
dataoff_1[1] = 0
dataoff_2[1] = 0
axis = MapAxis.from_edges(energy, name="energy", interp="log")
axis_true = axis.copy(name="energy_true")
geom = RegionGeom(region=None, axes=[axis])
geom_true = RegionGeom(region=None, axes=[axis_true])
on_vector = RegionNDMap.from_geom(geom=geom, data=data_on)
off_vector1 = RegionNDMap.from_geom(geom=geom, data=dataoff_1)
off_vector2 = RegionNDMap.from_geom(geom=geom, data=dataoff_2)
mask_safe = RegionNDMap.from_geom(geom, dtype=bool)
mask_safe.data += True
aeff = RegionNDMap.from_geom(geom_true, data=1, unit="m2")
edisp = EDispKernelMap.from_gauss(
energy_axis=axis, energy_axis_true=axis, sigma=0.2, bias=0, geom=geom
)
time_ref = Time("2010-01-01")
gti1 = make_gti({"START": [5, 6, 1, 2], "STOP": [8, 7, 3, 4]}, time_ref=time_ref)
gti2 = make_gti({"START": [14], "STOP": [15]}, time_ref=time_ref)
exposure = aeff * livetime
exposure.meta["livetime"] = livetime
obs1 = SpectrumDatasetOnOff(
counts=on_vector,
counts_off=off_vector1,
exposure=exposure,
edisp=edisp,
mask_safe=mask_safe,
acceptance=1,
acceptance_off=2,
name="1",
gti=gti1,
)
obs2 = SpectrumDatasetOnOff(
counts=on_vector,
counts_off=off_vector2,
exposure=exposure.copy(),
edisp=edisp,
mask_safe=mask_safe,
acceptance=1,
acceptance_off=4,
name="2",
gti=gti2,
)
obs_list = [obs1, obs2]
return obs_list
def get_dataset():
counts = Map.read(
"$GAMMAPY_DATA/fermi-3fhl-gc/fermi-3fhl-gc-counts-cube.fits.gz")
background = Map.read(
"$GAMMAPY_DATA/fermi-3fhl-gc/fermi-3fhl-gc-background-cube.fits.gz")
exposure = Map.read(
"$GAMMAPY_DATA/fermi-3fhl-gc/fermi-3fhl-gc-exposure-cube.fits.gz")
# for some reason the WCS defintions are not aligned...
exposure.geom._wcs = counts.geom.wcs
psf = PSFMap.read(
"$GAMMAPY_DATA/fermi-3fhl-gc/fermi-3fhl-gc-psf-cube.fits.gz",
format="gtpsf")
# reduce size of the PSF
psf = psf.slice_by_idx(slices={"rad": slice(0, 130)})
edisp = EDispKernelMap.from_diagonal_response(
energy_axis=counts.geom.axes["energy"],
energy_axis_true=exposure.geom.axes["energy_true"],
geom=psf.psf_map.geom)
mask_safe = counts.geom.boundary_mask(width="0.2 deg")
return MapDataset(counts=counts,
background=background,
exposure=exposure,
psf=psf,
name="fermi-3fhl-gc",
edisp=edisp,
mask_safe=mask_safe)
def fermi_dataset():
size = Angle("3 deg", "3.5 deg")
counts = Map.read(
"$GAMMAPY_DATA/fermi-3fhl-gc/fermi-3fhl-gc-counts-cube.fits.gz")
counts = counts.cutout(counts.geom.center_skydir, size)
background = Map.read(
"$GAMMAPY_DATA/fermi-3fhl-gc/fermi-3fhl-gc-background-cube.fits.gz")
background = background.cutout(background.geom.center_skydir, size)
exposure = Map.read(
"$GAMMAPY_DATA/fermi-3fhl-gc/fermi-3fhl-gc-exposure-cube.fits.gz")
exposure = exposure.cutout(exposure.geom.center_skydir, size)
psfmap = PSFMap.read(
"$GAMMAPY_DATA/fermi-3fhl-gc/fermi-3fhl-gc-psf-cube.fits.gz",
format="gtpsf")
edisp = EDispKernelMap.from_diagonal_response(
energy_axis=counts.geom.axes["energy"],
energy_axis_true=exposure.geom.axes["energy_true"],
)
return MapDataset(
counts=counts,
background=background,
exposure=exposure,
psf=psfmap,
name="fermi-3fhl-gc",
edisp=edisp,
)
def make_edisp_kernel(self, geom, observation):
"""Make energy dispersion kernel map.
Parameters
----------
geom : `~gammapy.maps.Geom`
Reference geom. Must contain "energy" and "energy_true" axes in that order.
observation : `~gammapy.data.Observation`
Observation container.
Returns
-------
edisp : `~gammapy.irf.EDispKernelMap`
EdispKernel map.
"""
if isinstance(observation.edisp, EDispKernelMap):
exposure = None
interp_map = observation.edisp.edisp_map.interp_to_geom(geom)
return EDispKernelMap(edisp_kernel_map=interp_map, exposure_map=exposure)
exposure = self.make_exposure_irf(geom.squash(axis_name="energy"), observation)
use_region_center = getattr(self, "use_region_center", True)
return make_edisp_kernel_map(
edisp=observation.edisp,
pointing=observation.pointing_radec,
geom=geom,
exposure_map=exposure,
use_region_center=use_region_center,
)
def fermi_dataset():
size = Angle("3 deg", "3.5 deg")
counts = Map.read(
"$GAMMAPY_DATA/fermi-3fhl-gc/fermi-3fhl-gc-counts-cube.fits.gz")
counts = counts.cutout(counts.geom.center_skydir, size)
background = Map.read(
"$GAMMAPY_DATA/fermi-3fhl-gc/fermi-3fhl-gc-background-cube.fits.gz")
background = background.cutout(background.geom.center_skydir, size)
background = BackgroundModel(background, datasets_names=["fermi-3fhl-gc"])
exposure = Map.read(
"$GAMMAPY_DATA/fermi-3fhl-gc/fermi-3fhl-gc-exposure-cube.fits.gz")
exposure = exposure.cutout(exposure.geom.center_skydir, size)
exposure.unit = "cm2 s"
psf = EnergyDependentTablePSF.read(
"$GAMMAPY_DATA/fermi-3fhl-gc/fermi-3fhl-gc-psf-cube.fits.gz")
psfmap = PSFMap.from_energy_dependent_table_psf(psf)
edisp = EDispKernelMap.from_diagonal_response(
energy_axis=counts.geom.axes["energy"],
energy_axis_true=exposure.geom.axes["energy_true"],
)
return MapDataset(
counts=counts,
models=[background],
exposure=exposure,
psf=psfmap,
name="fermi-3fhl-gc",
edisp=edisp,
)
def run(self, geom):
"""Create and fill the map dataset"""
energy = geom.axes[0]
energy_true = energy.copy(name="energy_true")
geom_true = geom.to_image().to_cube([energy_true])
dataset = MapDataset.create(geom,
energy_axis_true=energy_true,
binsz_irf=1.0)
dataset.mask_safe.data += True
dataset.counts.fill_events(self.events)
dataset.gti = self._make_gti()
dataset.psf = self.psf
# recompute exposure on geom
coords = geom_true.get_coord()
data = self.exposure.interp_by_coord(coords)
dataset.exposure = Map.from_geom(geom_true,
data=data,
unit=self.exposure.unit)
# Not the real Fermi-LAT EDISP: Use 5% energy resolution as approximation
edisp = EDispKernelMap.from_gauss(energy_axis=energy,
energy_axis_true=energy_true,
sigma=0.05,
bias=0)
dataset.edisp = edisp
return dataset
def test_spectrum_dataset_stack_diagonal_safe_mask(spectrum_dataset):
geom = spectrum_dataset.counts.geom
energy = MapAxis.from_energy_bounds("0.1 TeV", "10 TeV", nbin=30)
energy_true = MapAxis.from_energy_bounds("0.1 TeV",
"10 TeV",
nbin=30,
name="energy_true")
aeff = EffectiveAreaTable.from_parametrization(energy.edges, "HESS")
edisp = EDispKernelMap.from_diagonal_response(energy,
energy_true,
geom=geom.to_image())
livetime = 100 * u.s
background = spectrum_dataset.background
spectrum_dataset1 = SpectrumDataset(
counts=spectrum_dataset.counts.copy(),
livetime=livetime,
aeff=aeff,
edisp=edisp.copy(),
background=background.copy(),
)
livetime2 = 0.5 * livetime
aeff2 = EffectiveAreaTable(energy.edges[:-1], energy.edges[1:],
2 * aeff.data.data)
bkg2 = RegionNDMap.from_geom(geom=geom, data=2 * background.data)
geom = spectrum_dataset.counts.geom
data = np.ones(spectrum_dataset.data_shape, dtype="bool")
data[0] = False
safe_mask2 = RegionNDMap.from_geom(geom=geom, data=data)
spectrum_dataset2 = SpectrumDataset(
counts=spectrum_dataset.counts.copy(),
livetime=livetime2,
aeff=aeff2,
edisp=edisp,
background=bkg2,
mask_safe=safe_mask2,
)
spectrum_dataset1.stack(spectrum_dataset2)
reference = spectrum_dataset.counts.data
assert_allclose(spectrum_dataset1.counts.data[1:], reference[1:] * 2)
assert_allclose(spectrum_dataset1.counts.data[0], 141363)
assert spectrum_dataset1.livetime == 1.5 * livetime
assert_allclose(spectrum_dataset1.background.data[1:],
3 * background.data[1:])
assert_allclose(spectrum_dataset1.background.data[0], background.data[0])
assert_allclose(
spectrum_dataset1.aeff.data.data.to_value("m2"),
4.0 / 3 * aeff.data.data.to_value("m2"),
)
kernel = edisp.get_edisp_kernel()
kernel_stacked = spectrum_dataset1.edisp.get_edisp_kernel()
assert_allclose(kernel_stacked.pdf_matrix[1:], kernel.pdf_matrix[1:])
assert_allclose(kernel_stacked.pdf_matrix[0], 0.5 * kernel.pdf_matrix[0])
def get_edisp(geom, geom_etrue):
filename = "$GAMMAPY_DATA/hess-dl3-dr1/data/hess_dl3_dr1_obs_id_020136.fits.gz"
edisp2d = EnergyDispersion2D.read(filename, hdu="EDISP")
energy = geom.axes["energy"].edges
energy_true = geom_etrue.axes["energy_true"].edges
edisp_kernel = edisp2d.to_edisp_kernel(
offset="1.2 deg", energy=energy, energy_true=energy_true
)
edisp = EDispKernelMap.from_edisp_kernel(edisp_kernel)
return edisp
def test_edisp_kernel_map_to_image():
e_reco = MapAxis.from_energy_bounds("0.1 TeV", "10 TeV", nbin=3)
e_true = MapAxis.from_energy_bounds(
"0.08 TeV", "20 TeV", nbin=5, name="energy_true"
)
edisp = EDispKernelMap.from_diagonal_response(e_reco, e_true)
im = edisp.to_image()
assert im.edisp_map.data.shape == (5, 1, 1, 2)
assert_allclose(im.edisp_map.data[0, 0, 0, 0], 0.87605894, rtol=1e-5)
def test_edispkernel_from_1D():
energy_axis_true = MapAxis.from_energy_bounds(
"0.5 TeV", "5 TeV", nbin=31, name="energy_true"
)
energy_axis = MapAxis.from_energy_bounds(
"0.1 TeV", "10 TeV", nbin=11, name="energy"
)
edisp = EDispKernel.from_gauss(energy_axis_true.edges, energy_axis.edges, 0.1, 0.0)
region = make_region("fk5;circle(0.,0., 10.")
geom = RegionGeom(region)
region_edisp = EDispKernelMap.from_edisp_kernel(edisp, geom=geom)
sum_kernel = np.sum(region_edisp.edisp_map.data[..., 0, 0], axis=1)
assert_allclose(sum_kernel, 1, rtol=1e-5)
allsky_edisp = EDispKernelMap.from_edisp_kernel(edisp)
sum_kernel = np.sum(allsky_edisp.edisp_map.data[..., 0, 0], axis=1)
assert allsky_edisp.edisp_map.data.shape == (31, 11, 1, 2)
assert_allclose(sum_kernel, 1, rtol=1e-5)
def test__incorrect_edisp_kernel_map_stack():
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"
)
edisp_1 = EDispKernelMap.from_diagonal_response(
energy_axis=energy_axis, energy_axis_true=energy_axis_true
)
edisp_1.exposure_map.data += 1
edisp_2 = EDispKernelMap.from_diagonal_response(
energy_axis=energy_axis, energy_axis_true=energy_axis_true
)
edisp_2.exposure_map = None
with pytest.raises(ValueError) as except_info:
edisp_1.stack(edisp_2)
assert except_info.match("Missing exposure map for EDispKernelMap.stack")
def simulate_spectrum_dataset(model, random_state=0):
energy_edges = np.logspace(-0.5, 1.5, 21) * u.TeV
energy_axis = MapAxis.from_edges(energy_edges, interp="log", name="energy")
energy_axis_true = energy_axis.copy(name="energy_true")
aeff = EffectiveAreaTable2D.from_parametrization(
energy_axis_true=energy_axis_true)
bkg_model = SkyModel(
spectral_model=PowerLawSpectralModel(index=2.5,
amplitude="1e-12 cm-2 s-1 TeV-1"),
name="background",
)
bkg_model.spectral_model.amplitude.frozen = True
bkg_model.spectral_model.index.frozen = True
geom = RegionGeom.create(region="icrs;circle(0, 0, 0.1)",
axes=[energy_axis])
acceptance = RegionNDMap.from_geom(geom=geom, data=1)
edisp = EDispKernelMap.from_diagonal_response(
energy_axis=energy_axis,
energy_axis_true=energy_axis_true,
geom=geom,
)
geom_true = RegionGeom.create(region="icrs;circle(0, 0, 0.1)",
axes=[energy_axis_true])
exposure = make_map_exposure_true_energy(pointing=SkyCoord("0d", "0d"),
aeff=aeff,
livetime=100 * u.h,
geom=geom_true)
mask_safe = RegionNDMap.from_geom(geom=geom, dtype=bool)
mask_safe.data += True
acceptance_off = RegionNDMap.from_geom(geom=geom, data=5)
dataset = SpectrumDatasetOnOff(
name="test_onoff",
exposure=exposure,
acceptance=acceptance,
acceptance_off=acceptance_off,
edisp=edisp,
mask_safe=mask_safe,
)
dataset.models = bkg_model
bkg_npred = dataset.npred_signal()
dataset.models = model
dataset.fake(
random_state=random_state,
npred_background=bkg_npred,
)
return dataset
def test_edisp_kernel_map_resample_axis():
e_reco = MapAxis.from_energy_bounds("0.1 TeV", "10 TeV", nbin=4)
e_true = MapAxis.from_energy_bounds(
"0.08 TeV", "20 TeV", nbin=10, name="energy_true"
)
edisp = EDispKernelMap.from_diagonal_response(e_reco, e_true)
e_reco = MapAxis.from_energy_bounds("0.1 TeV", "10 TeV", nbin=2)
im = edisp.resample_energy_axis(energy_axis=e_reco)
res = np.sum(im.edisp_map.data[4, :, 0, 0])
assert im.edisp_map.data.shape == (10, 2, 1, 2)
assert_allclose(res, 1.0, rtol=1e-5)
def test_spectrum_dataset_stack_nondiagonal_no_bkg(spectrum_dataset):
energy = spectrum_dataset.counts.geom.axes[0]
geom = spectrum_dataset.counts.geom.to_image()
edisp1 = EDispKernelMap.from_gauss(energy, energy, 0.1, 0, geom=geom)
edisp1.exposure_map.data += 1
aeff = EffectiveAreaTable.from_parametrization(
energy.edges, "HESS").to_region_map(geom.region)
livetime = 100 * u.s
spectrum_dataset1 = SpectrumDataset(counts=spectrum_dataset.counts.copy(),
livetime=livetime,
aeff=aeff,
edisp=edisp1,
meta_table=Table({"OBS_ID": [0]}))
livetime2 = livetime
aeff2 = aeff.copy()
edisp2 = EDispKernelMap.from_gauss(energy, energy, 0.2, 0.0, geom=geom)
edisp2.exposure_map.data += 1
spectrum_dataset2 = SpectrumDataset(counts=spectrum_dataset.counts.copy(),
livetime=livetime2,
aeff=aeff2,
edisp=edisp2,
meta_table=Table({"OBS_ID": [1]}))
spectrum_dataset1.stack(spectrum_dataset2)
assert_allclose(spectrum_dataset1.meta_table["OBS_ID"][0], [0, 1])
assert spectrum_dataset1.background is None
assert spectrum_dataset1.livetime == 2 * livetime
assert_allclose(spectrum_dataset1.aeff.quantity.to_value("m2"),
aeff.quantity.to_value("m2"))
kernel = edisp1.get_edisp_kernel()
assert_allclose(kernel.get_bias(1 * u.TeV), 0.0, atol=1.2e-3)
assert_allclose(kernel.get_resolution(1 * u.TeV), 0.1581, atol=1e-2)
def test_spectrum_dataset_stack_nondiagonal_no_bkg(spectrum_dataset):
energy = spectrum_dataset.counts.geom.axes[0]
aeff = EffectiveAreaTable.from_parametrization(energy.edges, "HESS")
geom = spectrum_dataset.counts.geom.to_image()
edisp1 = EDispKernelMap.from_gauss(energy, energy, 0.1, 0, geom=geom)
edisp1.exposure_map.data += 1
livetime = 100 * u.s
spectrum_dataset1 = SpectrumDataset(
counts=spectrum_dataset.counts.copy(),
livetime=livetime,
aeff=aeff,
edisp=edisp1,
)
livetime2 = livetime
aeff2 = EffectiveAreaTable(energy.edges[:-1], energy.edges[1:],
aeff.data.data)
edisp2 = EDispKernelMap.from_gauss(energy, energy, 0.2, 0.0, geom=geom)
edisp2.exposure_map.data += 1
spectrum_dataset2 = SpectrumDataset(
counts=spectrum_dataset.counts.copy(),
livetime=livetime2,
aeff=aeff2,
edisp=edisp2,
)
spectrum_dataset1.stack(spectrum_dataset2)
assert spectrum_dataset1.background is None
assert spectrum_dataset1.livetime == 2 * livetime
assert_allclose(spectrum_dataset1.aeff.data.data.to_value("m2"),
aeff.data.data.to_value("m2"))
kernel = edisp1.get_edisp_kernel()
assert_allclose(kernel.get_bias(1 * u.TeV), 0.0, atol=1.2e-3)
assert_allclose(kernel.get_resolution(1 * u.TeV), 0.1581, atol=1e-2)
def test_edispkernel_from_diagonal_response():
energy_axis_true = MapAxis.from_energy_bounds(
"0.3 TeV", "10 TeV", nbin=11, name="energy_true"
)
energy_axis = MapAxis.from_energy_bounds(
"0.3 TeV", "10 TeV", nbin=11, name="energy"
)
geom = RegionGeom.create("fk5;circle(0, 0, 10)")
region_edisp = EDispKernelMap.from_diagonal_response(
energy_axis, energy_axis_true, geom=geom
)
sum_kernel = np.sum(region_edisp.edisp_map.data[..., 0, 0], axis=1)
# We exclude the first and last bin, where there is no
# e_reco to contribute to
assert_allclose(sum_kernel[1:-1], 1)
def get_map_dataset(geom, geom_etrue, edisp="edispmap", name="test", **kwargs):
"""Returns a MapDatasets"""
# define background model
background = Map.from_geom(geom)
background.data += 0.2
psf = get_psf()
exposure = get_exposure(geom_etrue)
e_reco = geom.axes["energy"]
e_true = geom_etrue.axes["energy_true"]
if edisp == "edispmap":
edisp = EDispMap.from_diagonal_response(energy_axis_true=e_true)
elif edisp == "edispkernelmap":
edisp = EDispKernelMap.from_diagonal_response(
energy_axis=e_reco, energy_axis_true=e_true
)
elif edisp == "edispkernel":
edisp = EDispKernel.from_diagonal_response(
energy_true=e_true.edges, energy=e_reco.edges
)
else:
edisp = None
# define fit mask
center = SkyCoord("0.2 deg", "0.1 deg", frame="galactic")
circle = CircleSkyRegion(center=center, radius=1 * u.deg)
mask_fit = geom.region_mask([circle])
mask_fit = Map.from_geom(geom, data=mask_fit)
models = FoVBackgroundModel(dataset_name=name)
return MapDataset(
models=models,
exposure=exposure,
background=background,
psf=psf,
edisp=edisp,
mask_fit=mask_fit,
name=name,
**kwargs,
)
def run(self, dataset, observation):
"""Make spectrum dataset.
Parameters
----------
dataset : `~gammapy.spectrum.SpectrumDataset`
Spectrum dataset.
observation: `~gammapy.data.Observation`
Observation to reduce.
Returns
-------
dataset : `~gammapy.spectrum.SpectrumDataset`
Spectrum dataset.
"""
kwargs = {
"gti": observation.gti,
"livetime": observation.observation_live_time_duration,
"meta_table": self.make_meta_table(observation)
}
energy_axis = dataset.counts.geom.get_axis_by_name("energy")
energy_axis_true = dataset.aeff.geom.get_axis_by_name("energy_true")
region = dataset.counts.geom.region
if "counts" in self.selection:
kwargs["counts"] = self.make_counts(dataset.counts.geom,
observation)
if "background" in self.selection:
kwargs["background"] = self.make_background(
dataset.counts.geom, observation)
if "aeff" in self.selection:
kwargs["aeff"] = self.make_aeff(dataset.aeff.geom, observation)
if "edisp" in self.selection:
edisp = self.make_edisp(region.center, energy_axis,
energy_axis_true, observation)
kwargs["edisp"] = EDispKernelMap.from_edisp_kernel(
edisp, geom=dataset.counts.geom)
return SpectrumDataset(name=dataset.name, **kwargs)
def get_map_dataset(sky_model,
geom,
geom_etrue,
edisp="edispmap",
name="test",
**kwargs):
"""Returns a MapDatasets"""
# define background model
m = Map.from_geom(geom)
m.quantity = 0.2 * np.ones(m.data.shape)
background_model = BackgroundModel(m, datasets_names=[name])
psf = get_psf()
exposure = get_exposure(geom_etrue)
e_reco = geom.get_axis_by_name("energy")
e_true = geom_etrue.get_axis_by_name("energy_true")
if edisp == "edispmap":
edisp = EDispMap.from_diagonal_response(energy_axis_true=e_true)
elif edisp == "edispkernelmap":
edisp = EDispKernelMap.from_diagonal_response(energy_axis=e_reco,
energy_axis_true=e_true)
elif edisp == "edispkernel":
edisp = EDispKernel.from_diagonal_response(e_true=e_true.edges,
e_reco=e_reco.edges)
else:
edisp = None
# define fit mask
center = sky_model.spatial_model.position
circle = CircleSkyRegion(center=center, radius=1 * u.deg)
mask_fit = background_model.map.geom.region_mask([circle])
mask_fit = Map.from_geom(geom, data=mask_fit)
return MapDataset(models=[sky_model, background_model],
exposure=exposure,
psf=psf,
edisp=edisp,
mask_fit=mask_fit,
name=name,
**kwargs)
def spectrum_dataset():
e_true = MapAxis.from_energy_bounds("1 TeV",
"10 TeV",
nbin=20,
name="energy_true")
e_reco = MapAxis.from_energy_bounds("1 TeV", "10 TeV", nbin=4)
aeff = EffectiveAreaTable.from_constant(value=1e6 * u.m**2,
energy=e_true.edges)
background = RegionNDMap.create(region="icrs;circle(0, 0, 0.1)",
axes=[e_reco])
background.data += 3600
background.data[-1] *= 1e-3
edisp = EDispKernelMap.from_diagonal_response(energy_axis_true=e_true,
energy_axis=e_reco,
geom=background.geom)
return SpectrumDataset(aeff=aeff,
livetime="1h",
edisp=edisp,
background=background)
def prepare_dataset():
energy = MapAxis.from_energy_bounds(0.1,
100,
5,
per_decade=True,
unit="TeV")
energy_true = MapAxis.from_energy_bounds(0.1,
100,
5,
unit="TeV",
per_decade=True,
name="energy_true")
geom = WcsGeom.create(npix=500, binsz=0.01, axes=[energy])
dataset = MapDataset.create(geom, energy_axis_true=energy_true)
dataset.exposure += "1 m2 s"
dataset.psf = PSFMap.from_gauss(energy_true)
dataset.edisp = EDispKernelMap.from_gauss(energy, energy_true, 0.1, 0.)
return Datasets([dataset])
