def test_wstat(self):
"""WStat with on source and background spectrum"""
on_vector = self.src.copy()
on_vector.data += self.bkg.data
acceptance = RegionNDMap.from_geom(self.src.geom, data=1)
acceptance_off = RegionNDMap.from_geom(self.bkg.geom,
data=1 / self.alpha)
dataset = SpectrumDatasetOnOff(
counts=on_vector,
counts_off=self.off,
exposure=self.exposure,
acceptance=acceptance,
acceptance_off=acceptance_off,
)
dataset.models = self.source_model
self.source_model.parameters.index = 1.12
fit = Fit()
result = fit.run(datasets=[dataset])
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 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 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 test_fake(self):
"""Test the fake dataset"""
source_model = SkyModel(spectral_model=PowerLawSpectralModel())
dataset = SpectrumDatasetOnOff(
name="test",
counts=self.on_counts,
counts_off=self.off_counts,
models=source_model,
exposure=self.aeff * self.livetime,
edisp=self.edisp,
acceptance=1,
acceptance_off=10,
)
real_dataset = dataset.copy()
background = RegionNDMap.from_geom(dataset.counts.geom)
background.data += 1
background_model = BackgroundModel(background,
name="test-bkg",
datasets_names="test")
dataset.fake(background_model=background_model, random_state=314)
assert real_dataset.counts.data.shape == dataset.counts.data.shape
assert real_dataset.counts_off.data.shape == dataset.counts_off.data.shape
assert dataset.counts_off.data.sum() == 39
assert dataset.counts.data.sum() == 5
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 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")
geom = RegionGeom(region=None, axes=[axis])
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 = 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=mask_safe,
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=mask_safe,
acceptance=1,
acceptance_off=4,
name="2",
gti=gti2,
)
obs_list = [obs1, obs2]
return obs_list
def test_stack_livetime():
dataset_ref = SpectrumDatasetOnOff.from_ogip_files(
"$GAMMAPY_DATA/joint-crab/spectra/hess/pha_obs23523.fits"
)
energy_axis = dataset_ref.counts.geom.axes["energy"]
energy_axis_true = dataset_ref.exposure.geom.axes["energy_true"]
dataset = SpectrumDatasetOnOff.create(e_reco=energy_axis, e_true=energy_axis_true)
dataset.stack(dataset_ref)
assert_allclose(dataset.exposure.meta["livetime"], 1581.736758 * u.s)
dataset.stack(dataset_ref)
assert_allclose(dataset.exposure.meta["livetime"], 2 * 1581.736758 * u.s)
def run(self, dataset, observation):
"""Run all steps.
Parameters
----------
dataset : `SpectrumDataset`
Input dataset.
observation : `Observation`
Data store observation.
Returns
-------
dataset_on_off : `SpectrumDatasetOnOff`
On off dataset.
"""
counts_off = self.make_counts_off(dataset, observation)
counts = self.make_counts(dataset, observation)
acceptance = np.sum([_[1] - _[0] for _ in self.on_phase])
acceptance_off = np.sum([_[1] - _[0] for _ in self.off_phase])
dataset_on_off = SpectrumDatasetOnOff.from_spectrum_dataset(
dataset=dataset,
counts_off=counts_off,
acceptance=acceptance,
acceptance_off=acceptance_off,
)
dataset_on_off.counts = counts
return dataset_on_off
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 run(self, dataset, observation):
"""Run reflected regions background maker
Parameters
----------
dataset : `SpectrumDataset`
Spectrum dataset.
observation : `DatastoreObservation`
Data store observation.
Returns
-------
dataset_on_off : `SpectrumDatasetOnOff`
On off dataset.
"""
counts_off, acceptance_off = self.make_counts_off(dataset, observation)
acceptance = RegionNDMap.from_geom(geom=dataset.counts.geom, data=1)
dataset_onoff = SpectrumDatasetOnOff.from_spectrum_dataset(
dataset=dataset,
acceptance=acceptance,
acceptance_off=acceptance_off,
counts_off=counts_off,
name=dataset.name,
)
if dataset_onoff.counts_off is None:
dataset_onoff.mask_safe.data[...] = False
log.warning(
f"ReflectedRegionsBackgroundMaker failed. Setting {dataset_onoff.name} mask to False."
)
return dataset_onoff
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=25, bkg_syst_fraction=0.075)
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"], 2.74559e-08, rtol=1e-3)
assert_allclose(row["excess"], 270000, rtol=1e-3)
assert_allclose(row["background"], 3.6e+06, rtol=1e-3)
assert row["criterion"] == "bkg"
row = table[1]
assert_allclose(row["energy"], 2.37137, rtol=1e-3)
assert_allclose(row["e2dnde"], 6.04795e-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.42959e-11, rtol=1e-3)
assert_allclose(row["excess"], 25, rtol=1e-3)
assert_allclose(row["background"], 3.6, rtol=1e-3)
assert row["criterion"] == "gamma"
def data_reduction(instrument):
log.info(f"data_reduction: {instrument}")
config = AnalysisConfig.read(f"config.yaml")
config.observations.datastore = f"$JOINT_CRAB/data/{instrument}"
config.datasets.stack = instrument_opts[instrument]['stack']
config.datasets.containment_correction = instrument_opts[instrument][
'containment']
config.datasets.on_region.radius = instrument_opts[instrument]['on_radius']
analysis = Analysis(config)
analysis.get_observations()
analysis.get_datasets()
# TODO remove when safe mask can be set on config
if instrument is 'fact':
from gammapy.datasets import SpectrumDatasetOnOff
stacked = SpectrumDatasetOnOff.create(
e_reco=analysis.datasets[0]._energy_axis.edges,
e_true=analysis.datasets[0]._energy_axis.edges,
region=None)
for ds in analysis.datasets:
ds.mask_safe[:] = True
stacked.stack(ds)
analysis.datasets = Datasets([stacked])
analysis.datasets.write(f"reduced_{instrument}", overwrite=True)
def extract_spectrum_fermi(on_region, off_region, energy, containment_correction):
"""Perform the spectral extraction at target_position for a circular region."""
geom = WcsGeom.create(
skydir=on_region.center, width="5 deg", binsz=0.01, axes=[energy]
)
ds = FermiDatasetMaker().run(geom)
spec_dataset = ds.to_spectrum_dataset(
on_region, containment_correction=containment_correction, name="fermi"
)
on_mask = ds.counts.geom.region_mask([on_region])
on_solid_angle = np.sum(ds.counts.geom.solid_angle() * on_mask)
off_dataset = ds.to_spectrum_dataset(off_region, containment_correction=False)
off_mask = ds.counts.geom.region_mask([off_region])
off_solid_angle = np.sum(ds.counts.geom.solid_angle() * off_mask)
return SpectrumDatasetOnOff(
counts=spec_dataset.counts,
counts_off=off_dataset.counts,
gti=spec_dataset.gti,
exposure=spec_dataset.exposure,
edisp=spec_dataset.edisp,
acceptance=1,
acceptance_off=(off_solid_angle / on_solid_angle).to_value(""),
name="fermi-3fhl"
)
def test_to_from_ogip_files_no_mask(self, tmp_path):
dataset = self.dataset.copy(name="test")
dataset.mask_safe = None
dataset.write(tmp_path / "test.fits")
newdataset = SpectrumDatasetOnOff.read(tmp_path / "test.fits")
assert_allclose(newdataset.mask_safe.data, True)
def test_datasets_stack_reduce_no_off():
datasets = Datasets()
obs_ids = [23523, 23526, 23559, 23592]
for obs_id in obs_ids:
filename = f"$GAMMAPY_DATA/joint-crab/spectra/hess/pha_obs{obs_id}.fits"
ds = SpectrumDatasetOnOff.read(filename)
datasets.append(ds)
datasets[-1].counts_off = None
with pytest.raises(ValueError):
stacked = datasets.stack_reduce(name="stacked")
datasets[-1].mask_safe.data[...] = False
stacked = datasets.stack_reduce(name="stacked")
assert_allclose(stacked.exposure.meta["livetime"].to_value("s"),
4732.5469999)
assert stacked.counts == 369
datasets[0].mask_safe.data[...] = False
stacked = datasets.stack_reduce(name="stacked")
assert_allclose(stacked.exposure.meta["livetime"].to_value("s"),
3150.81024152)
assert stacked.counts == 245
def test_to_from_ogip_files_zip(self, tmp_path):
dataset = self.dataset.copy(name="test")
dataset.write(tmp_path / "test.fits.gz")
newdataset = SpectrumDatasetOnOff.read(tmp_path / "test.fits.gz")
assert newdataset.counts.meta["RESPFILE"] == "test_rmf.fits.gz"
assert newdataset.counts.meta["BACKFILE"] == "test_bkg.fits.gz"
assert newdataset.counts.meta["ANCRFILE"] == "test_arf.fits.gz"
def test_stack_livetime():
dataset_ref = SpectrumDatasetOnOff.read(
"$GAMMAPY_DATA/joint-crab/spectra/hess/pha_obs23523.fits")
energy_axis = dataset_ref.counts.geom.axes["energy"]
energy_axis_true = dataset_ref.exposure.geom.axes["energy_true"]
geom = RegionGeom(region=None, axes=[energy_axis])
dataset = SpectrumDatasetOnOff.create(geom=geom,
energy_axis_true=energy_axis_true)
dataset.stack(dataset_ref)
assert_allclose(dataset.exposure.meta["livetime"], 1581.736758 * u.s)
dataset.stack(dataset_ref)
assert_allclose(dataset.exposure.meta["livetime"], 2 * 1581.736758 * u.s)
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 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.geom.axes[0].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 test_create_stack(self):
geom = RegionGeom(region=None, axes=[self.e_reco])
stacked = SpectrumDatasetOnOff.create(geom=geom,
energy_axis_true=self.e_true)
stacked.mask_safe.data += True
stacked.stack(self.dataset)
assert_allclose(stacked.energy_range.value,
self.dataset.energy_range.value)
def hess_datasets():
datasets = Datasets([])
for obsid in [23523, 23526]:
datasets.append(
SpectrumDatasetOnOff.from_ogip_files(
f"$GAMMAPY_DATA/joint-crab/spectra/hess/pha_obs{obsid}.fits"))
PLmodel = PowerLawSpectralModel(amplitude="3.5e-11 cm-2s-1TeV-1",
index=2.7)
for dataset in datasets:
dataset.models = SkyModel(spectral_model=PLmodel, name="Crab")
return datasets
def test_to_from_ogip_files_no_edisp(self, tmp_path):
mask_safe = RegionNDMap.from_geom(self.on_counts.geom, dtype=bool)
mask_safe.data += True
dataset = SpectrumDatasetOnOff(
counts=self.on_counts,
aeff=self.aeff,
livetime=self.livetime,
mask_safe=mask_safe,
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 hess_datasets():
datasets = Datasets([])
pwl = PowerLawSpectralModel(amplitude="3.5e-11 cm-2s-1TeV-1", index=2.7)
model = SkyModel(spectral_model=pwl, name="Crab")
for obsid in [23523, 23526]:
dataset = SpectrumDatasetOnOff.read(
f"$GAMMAPY_DATA/joint-crab/spectra/hess/pha_obs{obsid}.fits")
dataset.models = model
datasets.append(dataset)
return datasets
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
aeff = RegionNDMap.create(region=self.on_region,
unit="cm2",
axes=[self.e_reco.copy(name="energy_true")])
aeff.data += 1
dataset = SpectrumDatasetOnOff(
counts=self.on_counts,
counts_off=self.off_counts,
aeff=aeff,
models=model,
livetime=livetime,
)
energy = aeff.geom.axes[0].edges
expected = aeff.data[0] * (energy[-1] - energy[0]) * const * livetime
assert_allclose(dataset.npred_sig().data.sum(), expected.value)
def test_wstat(self):
"""WStat with on source and background spectrum"""
on_vector = self.src.copy()
on_vector.data += self.bkg.data
dataset = SpectrumDatasetOnOff(
counts=on_vector,
counts_off=self.off,
exposure=self.aeff * self.livetime,
acceptance=1,
acceptance_off=1 / self.alpha,
)
dataset.models = self.source_model
self.source_model.parameters.index = 1.12
fit = Fit([dataset])
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 test_to_from_ogip_files_no_edisp(self, tmp_path):
mask_safe = RegionNDMap.from_geom(self.on_counts.geom, dtype=bool)
mask_safe.data += True
exposure = self.aeff * self.livetime
exposure.meta["livetime"] = self.livetime
dataset = SpectrumDatasetOnOff(
counts=self.on_counts,
exposure=exposure,
mask_safe=mask_safe,
acceptance=1,
name="test",
)
dataset.write(tmp_path / "pha_obstest.fits")
newdataset = SpectrumDatasetOnOff.read(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_str(self):
model = SkyModel(spectral_model=PowerLawSpectralModel())
dataset = SpectrumDatasetOnOff(
counts=self.on_counts,
counts_off=self.off_counts,
models=model,
exposure=self.aeff * self.livetime,
edisp=self.edisp,
acceptance=RegionNDMap.from_geom(geom=self.on_counts.geom, data=1),
acceptance_off=RegionNDMap.from_geom(geom=self.off_counts.geom, data=10),
)
assert "SpectrumDatasetOnOff" in str(dataset)
assert "wstat" in str(dataset)
def test_fit_range(self):
"""Test fit range without complication of thresholds"""
geom = self.src.geom
mask_safe = RegionNDMap.from_geom(geom, dtype=bool)
mask_safe.data += True
dataset = SpectrumDatasetOnOff(counts=self.src, mask_safe=mask_safe)
assert np.sum(dataset.mask_safe) == self.nbins
energy_min, energy_max = dataset.energy_range
assert_allclose(energy_max.value, 10)
assert_allclose(energy_min.value, 0.1)
def test_str(self):
model = SkyModel(spectral_model=PowerLawSpectralModel())
dataset = SpectrumDatasetOnOff(
counts=self.on_counts,
counts_off=self.off_counts,
models=model,
exposure=self.aeff * self.livetime,
edisp=self.edisp,
acceptance=1,
acceptance_off=10,
)
assert "SpectrumDatasetOnOff" in str(dataset)
assert "wstat" in str(dataset)
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
