def test_stack_onoff_cutout(geom_image):
# Test stacking of cutouts
energy_axis_true = MapAxis.from_energy_bounds(
"1 TeV", "10 TeV", nbin=3, name="energy_true"
)
dataset = MapDatasetOnOff.create(geom_image, energy_axis_true=energy_axis_true)
dataset.gti = GTI.create([0 * u.s], [1 * u.h], reference_time="2010-01-01T00:00:00")
kwargs = {"position": geom_image.center_skydir, "width": 1 * u.deg}
geoms = {name: geom.cutout(**kwargs) for name, geom in dataset.geoms.items()}
dataset_cutout = MapDatasetOnOff.from_geoms(**geoms, name="cutout-dataset")
dataset_cutout.gti = GTI.create(
[0 * u.s], [1 * u.h], reference_time="2010-01-01T00:00:00"
)
dataset_cutout.mask_safe.data += True
dataset_cutout.counts.data += 1
dataset_cutout.counts_off.data += 1
dataset_cutout.exposure.data += 1
dataset.stack(dataset_cutout)
assert_allclose(dataset.counts.data.sum(), 2500)
assert_allclose(dataset.counts_off.data.sum(), 2500)
assert_allclose(dataset.alpha.data.sum(), 0)
assert_allclose(dataset.exposure.data.sum(), 7500)
assert dataset_cutout.name == "cutout-dataset"
def test_stack_npred():
pwl = PowerLawSpectralModel()
gauss = GaussianSpatialModel(sigma="0.2 deg")
model = SkyModel(pwl, gauss)
axis = MapAxis.from_energy_bounds("0.1 TeV", "10 TeV", nbin=5)
axis_etrue = MapAxis.from_energy_bounds(
"0.1 TeV", "10 TeV", nbin=11, name="energy_true"
)
geom = WcsGeom.create(
skydir=(0, 0), binsz=0.05, width=(2, 2), frame="icrs", axes=[axis],
)
dataset_1 = MapDataset.create(
geom,
energy_axis_true=axis_etrue,
name="dataset-1",
gti=GTI.create("0 min", "30 min"),
)
dataset_1.psf = None
dataset_1.exposure.data += 1
dataset_1.mask_safe.data = geom.energy_mask(energy_min=1 * u.TeV)
dataset_1.background.data += 1
bkg_model_1 = FoVBackgroundModel(dataset_name=dataset_1.name)
dataset_1.models = [model, bkg_model_1]
dataset_2 = MapDataset.create(
geom,
energy_axis_true=axis_etrue,
name="dataset-2",
gti=GTI.create("30 min", "60 min"),
)
dataset_2.psf = None
dataset_2.exposure.data += 1
dataset_2.mask_safe.data = geom.energy_mask(energy_min=0.2 * u.TeV)
dataset_2.background.data += 1
bkg_model_2 = FoVBackgroundModel(dataset_name=dataset_2.name)
dataset_2.models = [model, bkg_model_2]
npred_1 = dataset_1.npred()
npred_1.data[~dataset_1.mask_safe.data] = 0
npred_2 = dataset_2.npred()
npred_2.data[~dataset_2.mask_safe.data] = 0
stacked_npred = Map.from_geom(geom)
stacked_npred.stack(npred_1)
stacked_npred.stack(npred_2)
stacked = MapDataset.create(geom, energy_axis_true=axis_etrue, name="stacked")
stacked.stack(dataset_1)
stacked.stack(dataset_2)
npred_stacked = stacked.npred()
assert_allclose(npred_stacked.data, stacked_npred.data)
def get_map_datasets():
dataset_1 = simulate_map_dataset(random_state=0, name="dataset_1")
gti1 = GTI.create("0 h", "1 h", "2010-01-01T00:00:00")
dataset_1.gti = gti1
dataset_2 = simulate_map_dataset(random_state=1, name="dataset_2")
gti2 = GTI.create("1 h", "2 h", "2010-01-01T00:00:00")
dataset_2.gti = gti2
return [dataset_1, dataset_2]
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 get_spectrum_datasets():
model = SkyModel(spectral_model=PowerLawSpectralModel())
dataset_1 = simulate_spectrum_dataset(model=model, random_state=0)
dataset_1._name = "dataset_1"
gti1 = GTI.create("0h", "1h", "2010-01-01T00:00:00")
dataset_1.gti = gti1
dataset_2 = simulate_spectrum_dataset(model=model, random_state=1)
dataset_2._name = "dataset_2"
gti2 = GTI.create("1h", "2h", "2010-01-01T00:00:00")
dataset_2.gti = gti2
return [dataset_1, dataset_2]
def dataset():
energy_axis = MapAxis.from_bounds(1,
10,
nbin=3,
unit="TeV",
name="energy",
interp="log")
geom = WcsGeom.create(skydir=(0, 0),
binsz=0.05,
width="5 deg",
frame="galactic",
axes=[energy_axis])
geom_true = geom.copy()
geom_true.axes[0].name = "energy_true"
dataset = get_map_dataset(geom=geom,
geom_etrue=geom_true,
edisp="edispmap",
name="test")
dataset.background /= 400
dataset.gti = GTI.create(start=0 * u.s,
stop=1000 * u.s,
reference_time="2000-01-01")
return dataset
def get_map_datasets():
dataset_1 = simulate_map_dataset(random_state=0, name="dataset_1")
gti1 = GTI.create("0 h", "1 h", "2010-01-01T00:00:00")
dataset_1.gti = gti1
dataset_2 = simulate_map_dataset(random_state=1, name="dataset_2")
gti2 = GTI.create("1 h", "2 h", "2010-01-01T00:00:00")
dataset_2.gti = gti2
model = dataset_1.models["source"].copy("test_source")
dataset_1.models.pop("source")
dataset_2.models.pop("source")
dataset_1.models.append(model)
dataset_2.models.append(model)
return [dataset_1, dataset_2]
def setup(self):
etrue = np.logspace(-1, 1, 10) * u.TeV
self.e_true = etrue
ereco = np.logspace(-1, 1, 5) * u.TeV
elo = ereco[:-1]
ehi = ereco[1:]
self.e_reco = ereco
self.aeff = EffectiveAreaTable(etrue[:-1], etrue[1:],
np.ones(9) * u.cm**2)
self.edisp = EDispKernel.from_diagonal_response(etrue, ereco)
data = np.ones(elo.shape)
data[-1] = 0 # to test stats calculation with empty bins
self.on_counts = CountsSpectrum(elo, ehi, data)
self.off_counts = CountsSpectrum(elo, ehi, np.ones(elo.shape) * 10)
start = u.Quantity([0], "s")
stop = u.Quantity([1000], "s")
time_ref = Time("2010-01-01 00:00:00.0")
self.gti = GTI.create(start, stop, time_ref)
self.livetime = self.gti.time_sum
self.dataset = SpectrumDatasetOnOff(
counts=self.on_counts,
counts_off=self.off_counts,
aeff=self.aeff,
edisp=self.edisp,
livetime=self.livetime,
acceptance=np.ones(elo.shape),
acceptance_off=np.ones(elo.shape) * 10,
name="test",
gti=self.gti,
)
def spectrum_dataset():
name = "test"
energy = np.logspace(-1, 1, 31) * u.TeV
livetime = 100 * u.s
pwl = PowerLawSpectralModel(
index=2.1, amplitude="1e5 cm-2 s-1 TeV-1", reference="0.1 TeV",
)
temp_mod = ConstantTemporalModel()
model = SkyModel(spectral_model=pwl, temporal_model=temp_mod, name="test-source")
axis = MapAxis.from_edges(energy, interp="log", name="energy")
axis_true = MapAxis.from_edges(energy, interp="log", name="energy_true")
background = RegionNDMap.create(region="icrs;circle(0, 0, 0.1)", axes=[axis])
models = Models([model])
exposure = RegionNDMap.create(region="icrs;circle(0, 0, 0.1)", axes=[axis_true])
exposure.quantity = u.Quantity("1 cm2") * livetime
bkg_rate = np.ones(30) / u.s
background.quantity = bkg_rate * livetime
start = [1, 3, 5] * u.day
stop = [2, 3.5, 6] * u.day
t_ref = Time(55555, format="mjd")
gti = GTI.create(start, stop, reference_time=t_ref)
dataset = SpectrumDataset(
models=models, exposure=exposure, background=background, name=name, gti=gti,
)
dataset.fake(random_state=23)
return dataset
def test_info_dict(sky_model, geom, geom_etrue):
dataset = get_map_dataset(geom, geom_etrue)
bkg_model = FoVBackgroundModel(dataset_name=dataset.name)
dataset.models = [sky_model, bkg_model]
dataset.counts = dataset.npred()
info_dict = dataset.info_dict()
assert_allclose(info_dict["counts"], 9526, rtol=1e-3)
assert_allclose(info_dict["background"], 4000.0005, rtol=1e-3)
assert_allclose(info_dict["npred_background"], 4000.0, rtol=1e-3)
assert_allclose(info_dict["excess"], 5525.756, rtol=1e-3)
assert_allclose(info_dict["exposure_min"].value, 8.32e8, rtol=1e-3)
assert_allclose(info_dict["exposure_max"].value, 1.105e10, rtol=1e-3)
assert info_dict["exposure_max"].unit == "m2 s"
assert info_dict["name"] == "test"
gti = GTI.create([0 * u.s], [1 * u.h], reference_time="2010-01-01T00:00:00")
dataset.gti = gti
info_dict = dataset.info_dict()
assert_allclose(info_dict["counts"], 9526, rtol=1e-3)
assert_allclose(info_dict["background"], 4000.0005, rtol=1e-3)
assert_allclose(info_dict["npred_background"], 4000.0, rtol=1e-3)
assert_allclose(info_dict["sqrt_ts"], 74.024180, rtol=1e-3)
assert_allclose(info_dict["excess"], 5525.756, rtol=1e-3)
assert_allclose(info_dict["ontime"].value, 3600)
assert info_dict["name"] == "test"
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 test_map_dataset_on_off_to_spectrum_dataset(images):
e_reco = MapAxis.from_bounds(0.1, 10.0, 1, name="energy", unit=u.TeV, interp="log")
new_images = dict()
for key, image in images.items():
new_images[key] = Map.from_geom(
image.geom.to_cube([e_reco]), data=image.data[np.newaxis, :, :]
)
dataset = get_map_dataset_onoff(new_images)
gti = GTI.create([0 * u.s], [1 * u.h], reference_time="2010-01-01T00:00:00")
dataset.gti = gti
on_region = CircleSkyRegion(
center=dataset.counts.geom.center_skydir, radius=0.1 * u.deg
)
spectrum_dataset = dataset.to_spectrum_dataset(on_region)
assert spectrum_dataset.counts.data[0] == 8
assert spectrum_dataset.data_shape == (1, 1, 1)
assert spectrum_dataset.counts_off.data[0] == 33914
assert_allclose(spectrum_dataset.alpha.data[0], 0.0002143, atol=1e-7)
excess_map = new_images["counts"] - new_images["background"]
excess_true = excess_map.get_spectrum(on_region, np.sum).data[0]
excess = spectrum_dataset.excess.data[0]
assert_allclose(excess, excess_true, atol=1e-6)
assert spectrum_dataset.name != dataset.name
def test_to_spectrum_dataset(sky_model, geom, geom_etrue):
dataset_ref = get_map_dataset(sky_model, geom, geom_etrue, edisp=True)
dataset_ref.counts = dataset_ref.background_model.map * 0.0
dataset_ref.counts.data[1, 50, 50] = 1
dataset_ref.counts.data[1, 60, 50] = 1
gti = GTI.create([0 * u.s], [1 * u.h], reference_time="2010-01-01T00:00:00")
dataset_ref.gti = gti
on_region = CircleSkyRegion(center=geom.center_skydir, radius=0.05 * u.deg)
spectrum_dataset = dataset_ref.to_spectrum_dataset(on_region)
spectrum_dataset_corrected = dataset_ref.to_spectrum_dataset(
on_region, containment_correction=True
)
assert np.sum(spectrum_dataset.counts.data) == 1
assert spectrum_dataset.data_shape == (2, 1, 1)
assert spectrum_dataset.background.geom.axes[0].nbin == 2
assert spectrum_dataset.aeff.energy.nbin == 3
assert spectrum_dataset.aeff.data.data.unit == "m2"
assert spectrum_dataset.edisp.e_reco.nbin == 2
assert spectrum_dataset.edisp.e_true.nbin == 3
assert spectrum_dataset_corrected.aeff.data.data.unit == "m2"
assert_allclose(spectrum_dataset.aeff.data.data.value[1], 853023.423047, rtol=1e-5)
assert_allclose(
spectrum_dataset_corrected.aeff.data.data.value[1], 559476.3357, rtol=1e-5
)
def get_map_datasets():
dataset_1 = simulate_map_dataset(random_state=0, name="dataset_1")
gti1 = GTI.create("0 h", "1 h", "2010-01-01T00:00:00")
dataset_1.gti = gti1
dataset_2 = simulate_map_dataset(random_state=1, name="dataset_2")
gti2 = GTI.create("1 h", "2 h", "2010-01-01T00:00:00")
dataset_2.gti = gti2
model = dataset_1.models["source"].copy("test_source")
bkg_model_1 = FoVBackgroundModel(dataset_name="dataset_1")
bkg_model_2 = FoVBackgroundModel(dataset_name="dataset_2")
dataset_1.models = [model, bkg_model_1]
dataset_2.models = [model, bkg_model_2]
return [dataset_1, dataset_2]
def from_geoms(
cls,
geom,
geom_exposure,
geom_psf,
geom_edisp,
reference_time="2000-01-01",
name="",
**kwargs,
):
"""
Create a MapDatasetOnOff object with zero filled maps according to the specified geometries
Parameters
----------
geom : `Geom`
geometry for the counts, counts_off, acceptance and acceptance_off maps
geom_exposure : `Geom`
geometry for the exposure map
geom_psf : `Geom`
geometry for the psf map
geom_edisp : `Geom`
geometry for the energy dispersion map
reference_time : `~astropy.time.Time`
the reference time to use in GTI definition
name : str
Name of the dataset.
Returns
-------
empty_maps : `MapDatasetOnOff`
A MapDatasetOnOff containing zero filled maps
"""
maps = {}
for name in ["counts", "counts_off", "acceptance", "acceptance_off"]:
maps[name] = Map.from_geom(geom, unit="")
exposure = Map.from_geom(geom_exposure, unit="m2 s")
edisp = EDispMap.from_geom(geom_edisp)
psf = PSFMap.from_geom(geom_psf)
gti = GTI.create([] * u.s, [] * u.s, reference_time=reference_time)
mask_safe = Map.from_geom(geom, dtype=bool)
return cls(
counts=maps["counts"],
counts_off=maps["counts_off"],
acceptance=maps["acceptance"],
acceptance_off=maps["acceptance_off"],
exposure=exposure,
psf=psf,
edisp=edisp,
gti=gti,
mask_safe=mask_safe,
name=name,
**kwargs,
)
def setup(self):
etrue = np.logspace(-1, 1, 10) * u.TeV
self.e_true = etrue
ereco = np.logspace(-1, 1, 5) * u.TeV
elo = ereco[:-1]
ehi = ereco[1:]
self.e_reco = ereco
self.aeff = EffectiveAreaTable(etrue[:-1], etrue[1:], np.ones(9) * u.cm ** 2)
self.edisp = EDispKernel.from_diagonal_response(etrue, ereco)
start = u.Quantity([0], "s")
stop = u.Quantity([1000], "s")
time_ref = Time("2010-01-01 00:00:00.0")
self.gti = GTI.create(start, stop, time_ref)
self.livetime = self.gti.time_sum
self.on_region = make_region("icrs;circle(0.,1.,0.1)")
off_region = make_region("icrs;box(0.,1.,0.1, 0.2,30)")
self.off_region = off_region.union(
make_region("icrs;box(-1.,-1.,0.1, 0.2,150)")
)
self.wcs = WcsGeom.create(npix=300, binsz=0.01, frame="icrs").wcs
data = np.ones(elo.shape)
data[-1] = 0 # to test stats calculation with empty bins
axis = MapAxis.from_edges(ereco, name="energy", interp="log")
self.on_counts = RegionNDMap.create(
region=self.on_region, wcs=self.wcs, axes=[axis]
)
self.on_counts.data += 1
self.on_counts.data[-1] = 0
self.off_counts = RegionNDMap.create(
region=self.off_region, wcs=self.wcs, axes=[axis]
)
self.off_counts.data += 10
acceptance = RegionNDMap.from_geom(self.on_counts.geom)
acceptance.data += 1
data = np.ones(elo.shape)
data[-1] = 0
acceptance_off = RegionNDMap.from_geom(self.off_counts.geom)
acceptance_off.data += 10
self.dataset = SpectrumDatasetOnOff(
counts=self.on_counts,
counts_off=self.off_counts,
aeff=self.aeff,
edisp=self.edisp,
livetime=self.livetime,
acceptance=acceptance,
acceptance_off=acceptance_off,
name="test",
gti=self.gti,
)
def test_gti_create():
start = u.Quantity([1, 2], "min")
stop = u.Quantity([1.5, 2.5], "min")
time_ref = Time("2010-01-01 00:00:00.0")
gti = GTI.create(start, stop, time_ref)
assert len(gti.table) == 2
assert_allclose(gti.time_ref.mjd, time_ref.tt.mjd)
assert_allclose(gti.table["START"], start.to_value("s"))
def test_gti_from_time():
'''Test astropy time is supported as input for GTI.create'''
start = Time("2020-01-01T20:00:00")
stop = Time("2020-01-01T20:15:00")
ref = Time("2020-01-01T00:00:00")
gti = GTI.create(start, stop, ref)
assert u.isclose(gti.table["START"], 20 * u.hour)
assert u.isclose(gti.table["STOP"], 20 * u.hour + 15 * u.min)
def from_geoms(
cls,
geom,
geom_exposure,
geom_psf,
geom_edisp,
reference_time="2000-01-01",
name="",
**kwargs,
):
"""
Create a MapDataset object with zero filled maps according to the specified geometries
Parameters
----------
geom : `Geom`
geometry for the counts and background maps
geom_exposure : `Geom`
geometry for the exposure map
geom_psf : `Geom`
geometry for the psf map
geom_edisp : `Geom`
geometry for the energy dispersion map
reference_time : `~astropy.time.Time`
the reference time to use in GTI definition
name : str
Name of the dataset.
Returns
-------
empty_maps : `MapDataset`
A MapDataset containing zero filled maps
"""
counts = Map.from_geom(geom, unit="")
background = Map.from_geom(geom, unit="")
background_model = BackgroundModel(background)
exposure = Map.from_geom(geom_exposure, unit="m2 s")
edisp = EDispMap.from_geom(geom_edisp)
psf = PSFMap.from_geom(geom_psf)
gti = GTI.create([] * u.s, [] * u.s, reference_time=reference_time)
mask_safe = Map.from_geom(geom, unit="", dtype=bool)
return cls(
counts=counts,
exposure=exposure,
psf=psf,
edisp=edisp,
background_model=background_model,
gti=gti,
mask_safe=mask_safe,
name=name,
**kwargs,
)
def dataset():
position = SkyCoord(0.0, 0.0, frame="galactic", unit="deg")
energy_axis = MapAxis.from_bounds(1,
10,
nbin=3,
unit="TeV",
name="energy",
interp="log")
spatial_model = GaussianSpatialModel(lon_0="0 deg",
lat_0="0 deg",
sigma="0.2 deg",
frame="galactic")
spectral_model = PowerLawSpectralModel(amplitude="1e-11 cm-2 s-1 TeV-1")
t_min = 0 * u.s
t_max = 1000 * u.s
time = np.arange(t_max.value) * u.s
tau = u.Quantity("2e2 s")
norm = np.exp(-time / tau)
table = Table()
table["TIME"] = time
table["NORM"] = norm / norm.max()
t_ref = Time("2000-01-01")
table.meta = dict(MJDREFI=t_ref.mjd, MJDREFF=0, TIMEUNIT="s")
temporal_model = LightCurveTemplateTemporalModel(table)
skymodel = SkyModel(
spatial_model=spatial_model,
spectral_model=spectral_model,
temporal_model=temporal_model,
)
geom = WcsGeom.create(skydir=position,
binsz=1,
width="5 deg",
frame="galactic",
axes=[energy_axis])
gti = GTI.create(start=t_min, stop=t_max, reference_time=t_ref)
geom_true = geom.copy()
geom_true.axes[0].name = "energy_true"
dataset = get_map_dataset(sky_model=skymodel,
geom=geom,
geom_etrue=geom_true,
edisp="edispmap")
dataset.gti = gti
return dataset
def test_flux_map_read_write_gti(tmp_path, partial_wcs_flux_map, reference_model):
start = u.Quantity([1, 2], "min")
stop = u.Quantity([1.5, 2.5], "min")
gti = GTI.create(start, stop)
fluxmap = FluxMaps(partial_wcs_flux_map, reference_model, gti=gti)
fluxmap.write(tmp_path / "tmp.fits", sed_type="dnde")
new_fluxmap = FluxMaps.read(tmp_path / "tmp.fits")
assert len(new_fluxmap.gti.table) == 2
assert_allclose(gti.table["START"], start.to_value("s"))
def get_simple_dataset_on_off():
axis = MapAxis.from_energy_bounds(0.1, 10, 2, unit="TeV")
geom = WcsGeom.create(npix=40, binsz=0.01, axes=[axis])
dataset = MapDatasetOnOff.create(geom)
dataset.mask_safe += 1
dataset.counts += 5
dataset.counts_off += 1
dataset.acceptance += 1
dataset.acceptance_off += 1
dataset.exposure += 1000 * u.m ** 2 * u.s
dataset.gti = GTI.create([0 * u.s], [5 * u.h], reference_time="2010-01-01T00:00:00")
return dataset
def create(cls,
e_reco,
e_true=None,
region=None,
reference_time="2000-01-01",
name=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 : `~astropy.units.Quantity`
edges of counts vector
e_true : `~astropy.units.Quantity`
edges of effective area table. 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"
"""
if e_true is None:
e_true = e_reco
if region is None:
region = "icrs;circle(0, 0, 1)"
# TODO: change .create() API
energy = MapAxis.from_edges(e_reco, interp="log", name="energy")
counts = RegionNDMap.create(region=region, axes=[energy])
background = RegionNDMap.create(region=region, axes=[energy])
aeff = EffectiveAreaTable(e_true[:-1], e_true[1:],
np.zeros(e_true[:-1].shape) * u.m**2)
edisp = EDispKernel.from_diagonal_response(e_true, e_reco)
mask_safe = RegionNDMap.from_geom(counts.geom, dtype="bool")
gti = GTI.create(u.Quantity([], "s"), u.Quantity([], "s"),
reference_time)
livetime = gti.time_sum
return SpectrumDataset(
counts=counts,
aeff=aeff,
edisp=edisp,
mask_safe=mask_safe,
background=background,
livetime=livetime,
gti=gti,
name=name,
)
def create(cls,
e_reco,
e_true=None,
region=None,
reference_time="2000-01-01",
name=None):
"""Create empty SpectrumDatasetOnOff.
Empty containers are created with the correct geometry.
counts, counts_off and aeff are zero and edisp is diagonal.
The safe_mask is set to False in every bin.
Parameters
----------
e_reco : `~astropy.units.Quantity`
edges of counts vector
e_true : `~astropy.units.Quantity`
edges of effective area table. 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"
"""
if e_true is None:
e_true = e_reco
counts = CountsSpectrum(e_reco[:-1], e_reco[1:], region=region)
counts_off = CountsSpectrum(e_reco[:-1], e_reco[1:], region=region)
aeff = EffectiveAreaTable(e_true[:-1], e_true[1:],
np.zeros(e_true[:-1].shape) * u.m**2)
edisp = EDispKernel.from_diagonal_response(e_true, e_reco)
mask_safe = np.zeros_like(counts.data, "bool")
gti = GTI.create(u.Quantity([], "s"), u.Quantity([], "s"),
reference_time)
livetime = gti.time_sum
acceptance = np.ones_like(counts.data, int)
acceptance_off = np.ones_like(counts.data, int)
return SpectrumDatasetOnOff(
counts=counts,
counts_off=counts_off,
aeff=aeff,
edisp=edisp,
mask_safe=mask_safe,
acceptance=acceptance,
acceptance_off=acceptance_off,
livetime=livetime,
gti=gti,
name=name,
)
def test_map_dataset_on_off_cutout(images):
dataset = get_map_dataset_onoff(images)
gti = GTI.create([0 * u.s], [1 * u.h], reference_time="2010-01-01T00:00:00")
dataset.gti = gti
cutout_dataset = dataset.cutout(
images["counts"].geom.center_skydir, ["1 deg", "1 deg"]
)
assert cutout_dataset.counts.data.shape == (1, 50, 50)
assert cutout_dataset.counts_off.data.shape == (1, 50, 50)
assert cutout_dataset.acceptance.data.shape == (1, 50, 50)
assert cutout_dataset.acceptance_off.data.shape == (1, 50, 50)
assert cutout_dataset.name != dataset.name
def test_map_dataset_on_off_fits_io(images, tmp_path):
dataset = get_map_dataset_onoff(images)
gti = GTI.create([0 * u.s], [1 * u.h],
reference_time="2010-01-01T00:00:00")
dataset.gti = gti
hdulist = dataset.to_hdulist()
actual = [hdu.name for hdu in hdulist]
desired = [
"PRIMARY",
"COUNTS",
"COUNTS_BANDS",
"EXPOSURE",
"EXPOSURE_BANDS",
"MASK_SAFE",
"MASK_SAFE_BANDS",
"GTI",
"COUNTS_OFF",
"COUNTS_OFF_BANDS",
"ACCEPTANCE",
"ACCEPTANCE_BANDS",
"ACCEPTANCE_OFF",
"ACCEPTANCE_OFF_BANDS",
]
assert actual == desired
dataset.write(tmp_path / "test.fits")
dataset_new = MapDatasetOnOff.read(tmp_path / "test.fits")
assert len(dataset_new.models) == 0
assert dataset_new.mask.dtype == bool
assert_allclose(dataset.counts.data, dataset_new.counts.data)
assert_allclose(dataset.counts_off.data, dataset_new.counts_off.data)
assert_allclose(dataset.acceptance.data, dataset_new.acceptance.data)
assert_allclose(dataset.acceptance_off.data,
dataset_new.acceptance_off.data)
assert_allclose(dataset.exposure.data, dataset_new.exposure.data)
assert_allclose(dataset.mask_safe, dataset_new.mask_safe)
assert np.all(dataset.mask_safe.data == dataset_new.mask_safe.data) == True
assert dataset.mask_safe.geom == dataset_new.mask_safe.geom
assert dataset.counts.geom == dataset_new.counts.geom
assert dataset.exposure.geom == dataset_new.exposure.geom
assert_allclose(dataset.gti.time_sum.to_value("s"),
dataset_new.gti.time_sum.to_value("s"))
def test_stack_onoff_cutout(geom_image):
# Test stacking of cutouts
dataset = MapDatasetOnOff.create(geom_image)
gti = GTI.create([0 * u.s], [1 * u.h], reference_time="2010-01-01T00:00:00")
dataset.gti = gti
geom_cutout = geom_image.cutout(position=geom_image.center_skydir, width=1 * u.deg)
dataset_cutout = dataset.create(geom_cutout)
dataset.stack(dataset_cutout)
assert_allclose(dataset.counts.data.sum(), dataset_cutout.counts.data.sum())
assert_allclose(dataset.counts_off.data.sum(), dataset_cutout.counts_off.data.sum())
assert_allclose(dataset.alpha.data.sum(), dataset_cutout.alpha.data.sum())
assert_allclose(dataset.exposure.data.sum(), dataset_cutout.exposure.data.sum())
def test_stack_dataset_dataset_on_off():
axis = MapAxis.from_edges([1, 10] * u.TeV, name="energy")
geom = WcsGeom.create(width=1, axes=[axis])
gti = GTI.create([0 * u.s], [1 * u.h])
dataset = MapDataset.create(geom, gti=gti)
dataset_on_off = MapDatasetOnOff.create(geom, gti=gti)
dataset_on_off.mask_safe.data += True
dataset_on_off.acceptance_off += 5
dataset_on_off.acceptance += 1
dataset_on_off.counts_off += 1
dataset.stack(dataset_on_off)
assert_allclose(dataset.npred_background().data, 0.166667, rtol=1e-3)
def get_map_dataset_onoff(images, **kwargs):
"""Returns a MapDatasetOnOff"""
mask_geom = images["counts"].geom
mask_data = np.ones(images["counts"].data.shape, dtype=bool)
mask_safe = Map.from_geom(mask_geom, data=mask_data)
gti = GTI.create([0 * u.s], [1 * u.h],
reference_time="2010-01-01T00:00:00")
return MapDatasetOnOff(counts=images["counts"],
counts_off=images["counts_off"],
acceptance=images["acceptance"],
acceptance_off=images["acceptance_off"],
exposure=images["exposure"],
mask_safe=mask_safe,
gti=gti,
**kwargs)
def test_to_spectrum_dataset(sky_model, geom, geom_etrue):
dataset_ref = get_map_dataset(sky_model, geom, geom_etrue, edisp=True)
dataset_ref.counts = dataset_ref.background_model.map * 0.0
dataset_ref.counts.data[1, 50, 50] = 1
dataset_ref.counts.data[1, 60, 50] = 1
gti = GTI.create([0 * u.s], [1 * u.h], reference_time="2010-01-01T00:00:00")
dataset_ref.gti = gti
on_region = CircleSkyRegion(center=geom.center_skydir, radius=0.1 * u.deg)
spectrum_dataset = dataset_ref.to_spectrum_dataset(on_region)
assert np.sum(spectrum_dataset.counts.data) == 1
assert spectrum_dataset.data_shape == (2,)
assert spectrum_dataset.background.energy.nbin == 2
assert spectrum_dataset.aeff.energy.nbin == 3
assert spectrum_dataset.edisp.e_reco.nbin == 2
assert spectrum_dataset.edisp.e_true.nbin == 3