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
on_vector = CountsSpectrum(energy_lo=energy[:-1],
energy_hi=energy[1:],
data=data_on)
off_vector1 = CountsSpectrum(energy_lo=energy[:-1],
energy_hi=energy[1:],
data=dataoff_1)
off_vector2 = CountsSpectrum(energy_lo=energy[:-1],
energy_hi=energy[1:],
data=dataoff_2)
aeff = EffectiveAreaTable.from_constant(energy, "1 cm2")
edisp = EDispKernel.from_gauss(e_true=energy,
e_reco=energy,
sigma=0.2,
bias=0)
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)
obs1 = SpectrumDatasetOnOff(
counts=on_vector,
counts_off=off_vector1,
aeff=aeff,
edisp=edisp,
livetime=livetime,
mask_safe=np.ones(on_vector.energy.nbin, dtype=bool),
acceptance=1,
acceptance_off=2,
name="1",
gti=gti1,
)
obs2 = SpectrumDatasetOnOff(
counts=on_vector,
counts_off=off_vector2,
aeff=aeff,
edisp=edisp,
livetime=livetime,
mask_safe=np.ones(on_vector.energy.nbin, dtype=bool),
acceptance=1,
acceptance_off=4,
name="2",
gti=gti2,
)
obs_list = [obs1, obs2]
return obs_list
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.aeff = EffectiveAreaTable(etrue[:-1], etrue[1:],
np.ones(9) * u.cm**2)
self.edisp = EnergyDispersion.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)
self.livetime = 1000 * u.s
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,
obs_id="test",
)
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 test_fake(self):
"""Test the fake dataset"""
source_model = SkyModel(spectral_model=PowerLawSpectralModel())
dataset = SpectrumDatasetOnOff(
counts=self.on_counts,
counts_off=self.off_counts,
models=source_model,
aeff=self.aeff,
livetime=self.livetime,
edisp=self.edisp,
acceptance=1,
acceptance_off=10,
)
real_dataset = dataset.copy()
# Define background model counts
elo = self.on_counts.energy.edges[:-1]
ehi = self.on_counts.energy.edges[1:]
data = np.ones(self.on_counts.data.shape)
background_model = CountsSpectrum(elo, ehi, data)
dataset.fake(background_model=background_model,
random_state=314,
name="fake")
assert real_dataset.counts.data.shape == dataset.counts.data.shape
assert real_dataset.counts_off.data.shape == dataset.counts_off.data.shape
assert (real_dataset.counts.energy.center.mean() ==
dataset.counts.energy.center.mean())
assert real_dataset.acceptance.mean() == dataset.acceptance.mean()
assert real_dataset.acceptance_off.mean(
) == dataset.acceptance_off.mean()
assert dataset.counts_off.data.sum() == 39
assert dataset.counts.data.sum() == 5
assert dataset.name == "fake"
def test_peek(self):
dataset = SpectrumDatasetOnOff(
counts=self.on_counts,
counts_off=self.off_counts,
aeff=self.aeff,
livetime=self.livetime,
edisp=self.edisp,
acceptance=1,
acceptance_off=10,
)
with mpl_plot_check():
dataset.peek()
def test_fit_range(self):
"""Test fit range without complication of thresholds"""
dataset = SpectrumDatasetOnOff(counts=self.src,
mask_safe=np.ones(self.src.energy.nbin,
dtype=bool))
dataset.model = self.source_model
assert np.sum(dataset.mask_safe) == self.nbins
e_min, e_max = dataset.energy_range
assert_allclose(e_max.value, 10)
assert_allclose(e_min.value, 0.1)
def test_plot_fit(self):
model = SkyModel(spectral_model=PowerLawSpectralModel())
dataset = SpectrumDatasetOnOff(
counts=self.on_counts,
counts_off=self.off_counts,
models=model,
aeff=self.aeff,
livetime=self.livetime,
edisp=self.edisp,
acceptance=1,
acceptance_off=10,
)
with mpl_plot_check():
dataset.plot_fit()
def simulate_spectrum_dataset(model, random_state=0):
energy = np.logspace(-0.5, 1.5, 21) * u.TeV
aeff = EffectiveAreaTable.from_parametrization(energy=energy)
bkg_model = PowerLawSpectralModel(index=2.5, amplitude="1e-12 cm-2 s-1 TeV-1")
dataset = SpectrumDatasetOnOff(
aeff=aeff, model=model, livetime=100 * u.h, acceptance=1, acceptance_off=5
)
eval = SpectrumEvaluator(model=bkg_model, aeff=aeff, livetime=100 * u.h)
bkg_model = eval.compute_npred()
dataset.fake(random_state=random_state, background_model=bkg_model)
return dataset
def setup(self):
path = "$GAMMAPY_DATA/joint-crab/spectra/hess/"
obs1 = SpectrumDatasetOnOff.from_ogip_files(path + "pha_obs23523.fits")
obs2 = SpectrumDatasetOnOff.from_ogip_files(path + "pha_obs23592.fits")
self.obs_list = [obs1, obs2]
self.pwl = PowerLaw(index=2,
amplitude=1e-12 * u.Unit("cm-2 s-1 TeV-1"),
reference=1 * u.TeV)
self.ecpl = ExponentialCutoffPowerLaw(
index=2,
amplitude=1e-12 * u.Unit("cm-2 s-1 TeV-1"),
reference=1 * u.TeV,
lambda_=0.1 / u.TeV,
)
def test_cta_sensitivity_estimator(spectrum_dataset):
dataset_on_off = SpectrumDatasetOnOff.from_spectrum_dataset(
dataset=spectrum_dataset, acceptance=1, acceptance_off=5)
sens = SensitivityEstimator(gamma_min=20)
table = sens.run(dataset_on_off)
assert len(table) == 4
assert table.colnames == [
"energy", "e2dnde", "excess", "background", "criterion"
]
assert table["energy"].unit == "TeV"
assert table["e2dnde"].unit == "erg / (cm2 s)"
row = table[0]
assert_allclose(row["energy"], 1.33352, rtol=1e-3)
assert_allclose(row["e2dnde"], 3.40101e-11, rtol=1e-3)
assert_allclose(row["excess"], 334.454, rtol=1e-3)
assert_allclose(row["background"], 3600, rtol=1e-3)
assert row["criterion"] == "significance"
row = table[3]
assert_allclose(row["energy"], 7.49894, rtol=1e-3)
assert_allclose(row["e2dnde"], 1.14367e-11, rtol=1e-3)
assert_allclose(row["excess"], 20, rtol=1e-3)
assert_allclose(row["background"], 3.6, rtol=1e-3)
assert row["criterion"] == "gamma"
def test_to_from_ogip_files_no_edisp(self, tmpdir):
dataset = SpectrumDatasetOnOff(
counts=self.on_counts,
aeff=self.aeff,
livetime=self.livetime,
mask_safe=np.ones(self.on_counts.energy.nbin, dtype=bool),
acceptance=1,
obs_id="test",
)
dataset.to_ogip_files(outdir=tmpdir, overwrite=True)
filename = tmpdir / "pha_obstest.fits"
newdataset = SpectrumDatasetOnOff.from_ogip_files(filename)
assert_allclose(self.on_counts.data, newdataset.counts.data)
assert newdataset.counts_off is None
assert newdataset.edisp is None
def read():
model = PowerLawSpectralModel(index=2,
amplitude=2e-11 * u.Unit("cm-2 s-1 TeV-1"),
reference=1 * u.TeV)
stacked = SpectrumDatasetOnOff.from_ogip_files(
filename="pha_obsstacked.fits")
stacked.model = model
return stacked
def test_to_from_ogip_files_no_edisp(self, tmp_path):
dataset = SpectrumDatasetOnOff(
counts=self.on_counts,
aeff=self.aeff,
livetime=self.livetime,
mask_safe=np.ones(self.on_counts.energy.nbin, dtype=bool),
acceptance=1,
name="test",
)
dataset.to_ogip_files(outdir=tmp_path)
newdataset = SpectrumDatasetOnOff.from_ogip_files(tmp_path /
"pha_obstest.fits")
assert_allclose(self.on_counts.data, newdataset.counts.data)
assert newdataset.counts_off is None
assert newdataset.edisp is None
assert newdataset.gti is None
def test_npred_no_edisp(self):
const = 1 / u.TeV / u.cm**2 / u.s
model = ConstantSpectralModel(const)
livetime = 1 * u.s
dataset = SpectrumDatasetOnOff(
counts=self.on_counts,
counts_off=self.off_counts,
aeff=self.aeff,
model=model,
livetime=livetime,
)
energy = self.aeff.energy.edges * self.aeff.energy.unit
expected = self.aeff.data.data[0] * (energy[-1] -
energy[0]) * const * livetime
assert_allclose(dataset.npred_sig().data.sum(), expected.value)
def test_datasets_stack_reduce():
obs_ids = [23523, 23526, 23559, 23592]
dataset_list = []
for obs in obs_ids:
filename = "$GAMMAPY_DATA/joint-crab/spectra/hess/pha_obs{}.fits"
ds = SpectrumDatasetOnOff.from_ogip_files(filename.format(obs))
dataset_list.append(ds)
datasets = Datasets(dataset_list)
stacked = datasets.stack_reduce()
assert_allclose(stacked.livetime.to_value("s"), 6313.8116406202325)
def test_wstat(self):
"""WStat with on source and background spectrum"""
on_vector = self.src.copy()
on_vector.data += self.bkg.data
obs = SpectrumDatasetOnOff(
counts=on_vector,
counts_off=self.off,
acceptance=1,
acceptance_off=1 / self.alpha,
)
obs.model = self.source_model
self.source_model.parameters.index = 1.12
fit = Fit(obs)
result = fit.run()
pars = self.source_model.parameters
assert_allclose(pars["index"].value, 1.997342, rtol=1e-3)
assert_allclose(pars["amplitude"].value, 100245.187067, rtol=1e-3)
assert_allclose(result.total_stat, 30.022316, rtol=1e-3)
def setup(self):
path = "$GAMMAPY_DATA/joint-crab/spectra/hess/"
obs1 = SpectrumDatasetOnOff.from_ogip_files(path + "pha_obs23523.fits")
obs2 = SpectrumDatasetOnOff.from_ogip_files(path + "pha_obs23592.fits")
self.obs_list = [obs1, obs2]
self.pwl = PowerLawSpectralModel(index=2,
amplitude=1e-12 *
u.Unit("cm-2 s-1 TeV-1"),
reference=1 * u.TeV)
self.ecpl = ExpCutoffPowerLawSpectralModel(
index=2,
amplitude=1e-12 * u.Unit("cm-2 s-1 TeV-1"),
reference=1 * u.TeV,
lambda_=0.1 / u.TeV,
)
# Example fit for one observation
self.obs_list[0].model = self.pwl
self.fit = Fit(self.obs_list[0])
def test_npred_no_edisp(self):
const = 1 * u.Unit("cm-2 s-1 TeV-1")
model = SkyModel(spectral_model=ConstantSpectralModel(const=const))
livetime = 1 * u.s
e_reco = self.on_counts.energy.edges
aeff = EffectiveAreaTable(e_reco[:-1], e_reco[1:],
np.ones(4) * u.cm**2)
dataset = SpectrumDatasetOnOff(
counts=self.on_counts,
counts_off=self.off_counts,
aeff=aeff,
models=model,
livetime=livetime,
)
energy = aeff.energy.edges
expected = aeff.data.data[0] * (energy[-1] -
energy[0]) * const * livetime
assert_allclose(dataset.npred_sig().data.sum(), expected.value)
def data_prep():
data_store = DataStore.from_dir("$GAMMAPY_DATA/hess-dl3-dr1/")
OBS_ID = 23523
obs_ids = OBS_ID * np.ones(N_OBS)
observations = data_store.get_observations(obs_ids)
target_position = SkyCoord(ra=83.63308, dec=22.01450, unit="deg")
e_reco = MapAxis.from_bounds(0.1, 40, nbin=40, interp="log",
unit="TeV").edges
e_true = MapAxis.from_bounds(0.05, 100, nbin=200, interp="log",
unit="TeV").edges
on_region_radius = Angle("0.11 deg")
on_region = CircleSkyRegion(center=target_position,
radius=on_region_radius)
dataset_maker = SpectrumDatasetMaker(containment_correction=True,
selection=["counts", "aeff", "edisp"])
empty = SpectrumDatasetOnOff.create(region=on_region,
e_reco=e_reco,
e_true=e_true)
bkg_maker = ReflectedRegionsBackgroundMaker()
safe_mask_masker = SafeMaskMaker(methods=["aeff-max"], aeff_percent=10)
spectral_model = PowerLawSpectralModel(index=2.6,
amplitude=2.0e-11 *
u.Unit("1 / (cm2 s TeV)"),
reference=1 * u.TeV)
spectral_model.index.frozen = False
model = spectral_model.copy()
model.name = "crab"
datasets_1d = []
for observation in observations:
dataset = dataset_maker.run(dataset=empty.copy(),
observation=observation)
dataset_on_off = bkg_maker.run(dataset, observation)
dataset_on_off = safe_mask_masker.run(dataset_on_off, observation)
datasets_1d.append(dataset_on_off)
for dataset in datasets_1d:
model = spectral_model.copy()
model.name = "crab"
dataset.model = model
return datasets_1d
def test_to_from_ogip_files(self, tmp_path):
dataset = SpectrumDatasetOnOff(
counts=self.on_counts,
counts_off=self.off_counts,
aeff=self.aeff,
edisp=self.edisp,
livetime=self.livetime,
mask_safe=np.ones(self.on_counts.energy.nbin, dtype=bool),
acceptance=1,
acceptance_off=10,
name="test",
gti=self.gti,
)
dataset.to_ogip_files(outdir=tmp_path)
newdataset = SpectrumDatasetOnOff.from_ogip_files(tmp_path /
"pha_obstest.fits")
assert_allclose(self.on_counts.data, newdataset.counts.data)
assert_allclose(self.off_counts.data, newdataset.counts_off.data)
assert_allclose(self.edisp.pdf_matrix, newdataset.edisp.pdf_matrix)
assert_time_allclose(newdataset.gti.time_start, dataset.gti.time_start)
def read():
datasets = []
model = PowerLawSpectralModel(index=2,
amplitude=2e-11 * u.Unit("cm-2 s-1 TeV-1"),
reference=1 * u.TeV)
for ind in range(N_OBS):
dataset = SpectrumDatasetOnOff.from_ogip_files(
filename=f"pha_obs{ind}.fits")
dataset.model = model
datasets.append(dataset)
return datasets
def test_str(self):
model = SkyModel(spectral_model=PowerLawSpectralModel())
dataset = SpectrumDatasetOnOff(
counts=self.on_counts,
counts_off=self.off_counts,
models=model,
aeff=self.aeff,
livetime=self.livetime,
edisp=self.edisp,
acceptance=1,
acceptance_off=10,
)
assert "SpectrumDatasetOnOff" in str(dataset)
assert "wstat" in str(dataset)
def setup(self):
path = "$GAMMAPY_DATA/joint-crab/spectra/hess/"
self.datasets = Datasets([
SpectrumDatasetOnOff.from_ogip_files(path + "pha_obs23523.fits"),
SpectrumDatasetOnOff.from_ogip_files(path + "pha_obs23592.fits"),
])
self.pwl = SkyModel(
spectral_model=PowerLawSpectralModel(index=2,
amplitude=1e-12 *
u.Unit("cm-2 s-1 TeV-1"),
reference=1 * u.TeV))
self.ecpl = SkyModel(spectral_model=ExpCutoffPowerLawSpectralModel(
index=2,
amplitude=1e-12 * u.Unit("cm-2 s-1 TeV-1"),
reference=1 * u.TeV,
lambda_=0.1 / u.TeV,
))
# Example fit for one observation
self.datasets[0].models = self.pwl
self.fit = Fit([self.datasets[0]])
def data_prep():
data_store = DataStore.from_dir("$GAMMAPY_DATA/hess-dl3-dr1/")
OBS_ID = 23523
obs_ids = OBS_ID * np.ones(N_OBS)
observations = data_store.get_observations(obs_ids)
target_position = SkyCoord(ra=83.63, dec=22.01, unit="deg", frame="icrs")
on_region_radius = Angle("0.11 deg")
on_region = CircleSkyRegion(center=target_position,
radius=on_region_radius)
exclusion_region = CircleSkyRegion(
center=SkyCoord(183.604, -8.708, unit="deg", frame="galactic"),
radius=0.5 * u.deg,
)
skydir = target_position.galactic
exclusion_mask = Map.create(npix=(150, 150),
binsz=0.05,
skydir=skydir,
proj="TAN",
coordsys="GAL")
mask = exclusion_mask.geom.region_mask([exclusion_region], inside=False)
exclusion_mask.data = mask
e_reco = MapAxis.from_bounds(0.1, 40, nbin=40, interp="log",
unit="TeV").edges
e_true = MapAxis.from_bounds(0.05, 100, nbin=200, interp="log",
unit="TeV").edges
stacked = SpectrumDatasetOnOff.create(e_reco=e_reco, e_true=e_true)
stacked.name = "stacked"
dataset_maker = SpectrumDatasetMaker(region=on_region,
e_reco=e_reco,
e_true=e_true,
containment_correction=False)
bkg_maker = ReflectedRegionsBackgroundMaker(exclusion_mask=exclusion_mask)
safe_mask_masker = SafeMaskMaker(methods=["aeff-max"], aeff_percent=10)
for observation in observations:
dataset = dataset_maker.run(observation,
selection=["counts", "aeff", "edisp"])
dataset_on_off = bkg_maker.run(dataset, observation)
dataset_on_off = safe_mask_masker.run(dataset_on_off, observation)
stacked.stack(dataset_on_off)
return stacked
def test_spectrumdatasetonoff_create(self):
e_reco = u.Quantity([0.1, 1, 10.0], "TeV")
e_true = u.Quantity([0.05, 0.5, 5, 20.0], "TeV")
empty_dataset = SpectrumDatasetOnOff.create(e_reco, e_true)
assert empty_dataset.counts.total_counts == 0
assert empty_dataset.data_shape[0] == 2
assert empty_dataset.counts_off.total_counts == 0
assert empty_dataset.counts_off.energy.nbin == 2
assert_allclose(empty_dataset.acceptance_off, 1)
assert_allclose(empty_dataset.acceptance, 1)
assert empty_dataset.acceptance.shape[0] == 2
assert empty_dataset.acceptance_off.shape[0] == 2
assert empty_dataset.livetime.value == 0
assert len(empty_dataset.gti.table) == 0
assert empty_dataset.energy_range[0] is None
def test_datasets_stack_reduce():
obs_ids = [23523, 23526, 23559, 23592]
dataset_list = []
for obs in obs_ids:
filename = "$GAMMAPY_DATA/joint-crab/spectra/hess/pha_obs{}.fits"
ds = SpectrumDatasetOnOff.from_ogip_files(filename.format(obs))
dataset_list.append(ds)
datasets = Datasets(dataset_list)
stacked = datasets.stack_reduce()
assert_allclose(stacked.livetime.to_value("s"), 6313.8116406202325)
info_table = datasets.info_table()
assert_allclose(info_table["n_on"], [124, 126, 119, 90])
info_table_cum = datasets.info_table(cumulative=True)
assert_allclose(info_table_cum["n_on"], [124, 250, 369, 459])
def test_run(tmpdir, extraction):
"""Test the run method and check if files are written correctly"""
extraction.run()
extraction.write(outdir=str(tmpdir), overwrite=True)
testobs = SpectrumDatasetOnOff.from_ogip_files(
str(tmpdir / "ogip_data" / "pha_obs23523.fits"))
assert_quantity_allclose(
testobs.aeff.data.data,
extraction.spectrum_observations[0].aeff.data.data)
assert_quantity_allclose(
testobs.counts.data,
extraction.spectrum_observations[0].counts.data)
assert_allclose(
testobs.counts.energy.center,
extraction.spectrum_observations[0].counts.energy.center,
)
def _read_hess_obs():
path = "$GAMMAPY_DATA/joint-crab/spectra/hess/"
obs1 = SpectrumDatasetOnOff.from_ogip_files(path + "pha_obs23523.fits")
obs2 = SpectrumDatasetOnOff.from_ogip_files(path + "pha_obs23592.fits")
return [obs1, obs2]
class TestSpectrumOnOff:
""" Test ON OFF SpectrumDataset"""
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 test_spectrumdatasetonoff_create(self):
e_reco = u.Quantity([0.1, 1, 10.0], "TeV")
e_true = u.Quantity([0.05, 0.5, 5, 20.0], "TeV")
empty_dataset = SpectrumDatasetOnOff.create(e_reco, e_true)
assert empty_dataset.counts.total_counts == 0
assert empty_dataset.data_shape[0] == 2
assert empty_dataset.counts_off.total_counts == 0
assert empty_dataset.counts_off.energy.nbin == 2
assert_allclose(empty_dataset.acceptance_off, 1)
assert_allclose(empty_dataset.acceptance, 1)
assert empty_dataset.acceptance.shape[0] == 2
assert empty_dataset.acceptance_off.shape[0] == 2
assert empty_dataset.livetime.value == 0
assert len(empty_dataset.gti.table) == 0
assert empty_dataset.energy_range[0] is None
def test_create_stack(self):
stacked = SpectrumDatasetOnOff.create(self.e_reco, self.e_true)
stacked.stack(self.dataset)
assert_allclose(stacked.energy_range.value,
self.dataset.energy_range.value)
def test_alpha(self):
assert self.dataset.alpha.shape == (4, )
assert_allclose(self.dataset.alpha, 0.1)
def test_data_shape(self):
assert self.dataset.data_shape == self.on_counts.data.shape
def test_npred_no_edisp(self):
const = 1 * u.Unit("cm-2 s-1 TeV-1")
model = SkyModel(spectral_model=ConstantSpectralModel(const=const))
livetime = 1 * u.s
e_reco = self.on_counts.energy.edges
aeff = EffectiveAreaTable(e_reco[:-1], e_reco[1:],
np.ones(4) * u.cm**2)
dataset = SpectrumDatasetOnOff(
counts=self.on_counts,
counts_off=self.off_counts,
aeff=aeff,
models=model,
livetime=livetime,
)
energy = aeff.energy.edges
expected = aeff.data.data[0] * (energy[-1] -
energy[0]) * const * livetime
assert_allclose(dataset.npred_sig().data.sum(), expected.value)
@requires_dependency("matplotlib")
def test_peek(self):
dataset = SpectrumDatasetOnOff(
counts=self.on_counts,
counts_off=self.off_counts,
aeff=self.aeff,
livetime=self.livetime,
edisp=self.edisp,
acceptance=1,
acceptance_off=10,
)
with mpl_plot_check():
dataset.peek()
@requires_dependency("matplotlib")
def test_plot_fit(self):
model = SkyModel(spectral_model=PowerLawSpectralModel())
dataset = SpectrumDatasetOnOff(
counts=self.on_counts,
counts_off=self.off_counts,
models=model,
aeff=self.aeff,
livetime=self.livetime,
edisp=self.edisp,
acceptance=1,
acceptance_off=10,
)
with mpl_plot_check():
dataset.plot_fit()
def test_to_from_ogip_files(self, tmp_path):
dataset = SpectrumDatasetOnOff(
counts=self.on_counts,
counts_off=self.off_counts,
aeff=self.aeff,
edisp=self.edisp,
livetime=self.livetime,
mask_safe=np.ones(self.on_counts.energy.nbin, dtype=bool),
acceptance=1,
acceptance_off=10,
name="test",
gti=self.gti,
)
dataset.to_ogip_files(outdir=tmp_path)
newdataset = SpectrumDatasetOnOff.from_ogip_files(tmp_path /
"pha_obstest.fits")
assert_allclose(self.on_counts.data, newdataset.counts.data)
assert_allclose(self.off_counts.data, newdataset.counts_off.data)
assert_allclose(self.edisp.pdf_matrix, newdataset.edisp.pdf_matrix)
assert_time_allclose(newdataset.gti.time_start, dataset.gti.time_start)
def test_to_from_ogip_files_no_edisp(self, tmp_path):
dataset = SpectrumDatasetOnOff(
counts=self.on_counts,
aeff=self.aeff,
livetime=self.livetime,
mask_safe=np.ones(self.on_counts.energy.nbin, dtype=bool),
acceptance=1,
name="test",
)
dataset.to_ogip_files(outdir=tmp_path)
newdataset = SpectrumDatasetOnOff.from_ogip_files(tmp_path /
"pha_obstest.fits")
assert_allclose(self.on_counts.data, newdataset.counts.data)
assert newdataset.counts_off is None
assert newdataset.edisp is None
assert newdataset.gti is None
def test_energy_mask(self):
mask = self.dataset.counts.energy_mask(emin=0.3 * u.TeV,
emax=6 * u.TeV)
desired = [False, True, True, False]
assert_allclose(mask, desired)
mask = self.dataset.counts.energy_mask(emax=6 * u.TeV)
desired = [True, True, True, False]
assert_allclose(mask, desired)
mask = self.dataset.counts.energy_mask(emin=1 * u.TeV)
desired = [False, False, True, True]
assert_allclose(mask, desired)
def test_str(self):
model = SkyModel(spectral_model=PowerLawSpectralModel())
dataset = SpectrumDatasetOnOff(
counts=self.on_counts,
counts_off=self.off_counts,
models=model,
aeff=self.aeff,
livetime=self.livetime,
edisp=self.edisp,
acceptance=1,
acceptance_off=10,
)
assert "SpectrumDatasetOnOff" in str(dataset)
assert "wstat" in str(dataset)
def test_fake(self):
"""Test the fake dataset"""
source_model = SkyModel(spectral_model=PowerLawSpectralModel())
dataset = SpectrumDatasetOnOff(
counts=self.on_counts,
counts_off=self.off_counts,
models=source_model,
aeff=self.aeff,
livetime=self.livetime,
edisp=self.edisp,
acceptance=1,
acceptance_off=10,
)
real_dataset = dataset.copy()
# Define background model counts
elo = self.on_counts.energy.edges[:-1]
ehi = self.on_counts.energy.edges[1:]
data = np.ones(self.on_counts.data.shape)
background_model = CountsSpectrum(elo, ehi, data)
dataset.fake(background_model=background_model,
random_state=314,
name="fake")
assert real_dataset.counts.data.shape == dataset.counts.data.shape
assert real_dataset.counts_off.data.shape == dataset.counts_off.data.shape
assert (real_dataset.counts.energy.center.mean() ==
dataset.counts.energy.center.mean())
assert real_dataset.acceptance.mean() == dataset.acceptance.mean()
assert real_dataset.acceptance_off.mean(
) == dataset.acceptance_off.mean()
assert dataset.counts_off.data.sum() == 39
assert dataset.counts.data.sum() == 5
assert dataset.name == "fake"
def test_info_dict(self):
info_dict = self.dataset.info_dict()
assert_allclose(info_dict["n_on"], 3)
assert_allclose(info_dict["n_off"], 40)
assert_allclose(info_dict["a_on"], 1)
assert_allclose(info_dict["a_off"], 10)
assert_allclose(info_dict["alpha"], 0.1)
assert_allclose(info_dict["excess"], -1)
assert_allclose(info_dict["livetime"].value, 1e3)
assert info_dict["name"] == "test"
def test_create_stack(self):
stacked = SpectrumDatasetOnOff.create(self.e_reco, self.e_true)
stacked.stack(self.dataset)
assert_allclose(stacked.energy_range.value,
self.dataset.energy_range.value)
