def simulate_single(self,
pointing,
models=None,
empty=None,
random_state="random-seed"):
obs = Observation.create(pointing=pointing,
livetime=self.livetime,
irfs=self.get_irf())
maker = MapDatasetMaker(
selection=["exposure", "background", "psf", "edisp"])
maker_safe_mask = SafeMaskMaker(methods=["offset-max"],
offset_max=2.0 * u.deg)
dataset = maker.run(empty, obs)
dataset = maker_safe_mask.run(dataset, obs)
dataset.models = Models([models])
#fluctuate the background - gaussian fluctuations
bkg_factor = np.random.normal(self.mean_bkg, self.sigma_bkg)
while bkg_factor < 0.0:
bkg_factor = np.random.normal(self.mean_bkg, self.sigma_bkg)
dataset.background.data = bkg_factor * dataset.background.data
self.bkg_norms.append(bkg_factor)
#Poission fluctuate source + background
dataset.fake()
dataset.models = None #remove the model on the dataset
dataset.background.data /= bkg_factor # restore the old background
return dataset
def test_safe_mask_maker_bkg_invalid(observations_hess_dl3):
obs = observations_hess_dl3[0]
axis = MapAxis.from_bounds(0.1,
10,
nbin=16,
unit="TeV",
name="energy",
interp="log")
axis_true = MapAxis.from_bounds(0.1,
50,
nbin=30,
unit="TeV",
name="energy_true",
interp="log")
geom = WcsGeom.create(npix=(9, 9), axes=[axis], skydir=obs.pointing_radec)
empty_dataset = MapDataset.create(geom=geom, energy_axis_true=axis_true)
dataset_maker = MapDatasetMaker()
safe_mask_maker_nonan = SafeMaskMaker([])
dataset = dataset_maker.run(empty_dataset, obs)
bkg = dataset.background.data
bkg[0, 0, 0] = np.nan
mask_nonan = safe_mask_maker_nonan.make_mask_bkg_invalid(dataset)
assert not mask_nonan[0, 0, 0]
assert_allclose(bkg[mask_nonan].max(), 20.656366)
dataset = safe_mask_maker_nonan.run(dataset, obs)
assert_allclose(dataset.mask_safe, mask_nonan)
def create_datasets_1d(observations, target_position):
on_region_radius = Angle("0.11 deg")
on_region = CircleSkyRegion(center=target_position,
radius=on_region_radius)
# Target geometry definition
e_reco = MapAxis.from_energy_bounds(0.23, 20, 12, "TeV")
e_true = MapAxis.from_energy_bounds(0.1, 40, 40, "TeV", name="energy_true")
#data reduction makers
dataset_maker = SpectrumDatasetMaker(
containment_correction=True, selection=["counts", "exposure", "edisp"])
bkg_maker = ReflectedRegionsBackgroundMaker()
safe_mask_maker = SafeMaskMaker(methods=["aeff-max"], aeff_percent=10)
datasets = []
geom = RegionGeom(on_region, axes=[e_reco])
dataset_empty = SpectrumDataset.create(geom=geom, energy_axis_true=e_true)
for obs in observations:
dataset = dataset_maker.run(dataset_empty.copy(), obs)
dataset_on_off = bkg_maker.run(dataset, obs)
if dataset_on_off.counts_off.data.sum() > 0:
dataset_on_off = safe_mask_maker.run(dataset_on_off, obs)
datasets.append(dataset_on_off)
return datasets
def test_adaptive_ring_bkg_maker(pars, geom, observations, exclusion_mask):
adaptive_ring_bkg_maker = AdaptiveRingBackgroundMaker(
r_in="0.2 deg",
width="0.3 deg",
r_out_max="2 deg",
stepsize="0.2 deg",
exclusion_mask=exclusion_mask,
method=pars["method"],
)
safe_mask_maker = SafeMaskMaker(methods=["offset-max"], offset_max="2 deg")
map_dataset_maker = MapDatasetMaker(
selection=["counts", "background", "exposure"])
obs = observations[pars["obs_idx"]]
dataset = MapDataset.create(geom).cutout(obs.pointing_radec, width="4 deg")
dataset = map_dataset_maker.run(dataset, obs)
dataset = safe_mask_maker.run(dataset, obs)
dataset = dataset.to_image()
dataset_on_off = adaptive_ring_bkg_maker.run(dataset)
mask = dataset.mask_safe
assert_allclose(dataset_on_off.counts_off.data[mask].sum(),
pars["counts_off"])
assert_allclose(dataset_on_off.acceptance_off.data[mask].sum(),
pars["acceptance_off"])
assert_allclose(dataset_on_off.alpha.data[0][100][100], pars["alpha"])
assert_allclose(dataset_on_off.exposure.data[0][100][100],
pars["exposure"])
def test_ring_bkg_maker(geom, observations, exclusion_mask):
ring_bkg_maker = RingBackgroundMaker(r_in="0.2 deg",
width="0.3 deg",
exclusion_mask=exclusion_mask)
safe_mask_maker = SafeMaskMaker(methods=["offset-max"], offset_max="2 deg")
map_dataset_maker = MapDatasetMaker(
selection=["counts", "background", "exposure"])
reference = MapDataset.create(geom)
datasets = []
for obs in observations:
cutout = reference.cutout(obs.pointing_radec, width="4 deg")
dataset = map_dataset_maker.run(cutout, obs)
dataset = safe_mask_maker.run(dataset, obs)
dataset = dataset.to_image()
dataset_on_off = ring_bkg_maker.run(dataset)
datasets.append(dataset_on_off)
mask = dataset.mask_safe
assert_allclose(datasets[0].counts_off.data[mask].sum(), 2511333)
assert_allclose(datasets[1].counts_off.data[mask].sum(), 2143577.0)
assert_allclose(datasets[0].acceptance_off.data[mask].sum(),
2961300,
rtol=1e-5)
assert_allclose(datasets[1].acceptance_off.data[mask].sum(),
2364657.2,
rtol=1e-5)
assert_allclose(datasets[0].alpha.data[0][100][100],
0.00063745599,
rtol=1e-5)
assert_allclose(datasets[0].exposure.data[0][100][100],
806254444.8480084,
rtol=1e-5)
def test_extract(
pars,
results,
observations_hess_dl3,
spectrum_dataset_crab_fine,
reflected_regions_bkg_maker,
):
"""Test quantitative output for various configs"""
safe_mask_maker = SafeMaskMaker()
maker = SpectrumDatasetMaker(
containment_correction=pars["containment_correction"])
obs = observations_hess_dl3[0]
dataset = maker.run(spectrum_dataset_crab_fine, obs)
dataset = reflected_regions_bkg_maker.run(dataset, obs)
dataset = safe_mask_maker.run(dataset, obs)
aeff_actual = dataset.aeff.data.evaluate(energy_true=5 * u.TeV)
edisp_actual = dataset.edisp.data.evaluate(energy_true=5 * u.TeV,
energy=5.2 * u.TeV)
assert_quantity_allclose(aeff_actual, results["aeff"], rtol=1e-3)
assert_quantity_allclose(edisp_actual, results["edisp"], rtol=1e-3)
# TODO: Introduce assert_stats_allclose
info = dataset.info_dict()
assert info["n_on"] == results["n_on"]
assert_allclose(info["significance"], results["sigma"], atol=1e-2)
gti_obs = obs.gti.table
gti_dataset = dataset.gti.table
assert_allclose(gti_dataset["START"], gti_obs["START"])
assert_allclose(gti_dataset["STOP"], gti_obs["STOP"])
def test_safe_mask_maker_dc1(spectrum_dataset_gc, observations_cta_dc1):
safe_mask_maker = SafeMaskMaker(methods=["edisp-bias", "aeff-max"])
obs = observations_cta_dc1[0]
maker = SpectrumDatasetMaker()
dataset = maker.run(spectrum_dataset_gc, obs)
dataset = safe_mask_maker.run(dataset, obs)
assert_allclose(dataset.energy_range[0].value, 3.162278, rtol=1e-3)
assert dataset.energy_range[0].unit == "TeV"
def data_prep():
data_store = DataStore.from_dir("$GAMMAPY_DATA/cta-1dc/index/gps/")
OBS_ID = 110380
obs_ids = OBS_ID * np.ones(N_OBS)
observations = data_store.get_observations(obs_ids)
energy_axis = MapAxis.from_bounds(0.1,
10,
nbin=10,
unit="TeV",
name="energy",
interp="log")
geom = WcsGeom.create(
skydir=(0, 0),
binsz=0.02,
width=(10, 8),
frame="galactic",
proj="CAR",
axes=[energy_axis],
)
energy_axis_true = MapAxis.from_bounds(0.05,
20,
nbin=30,
unit="TeV",
name="energy_true",
interp="log")
offset_max = 4 * u.deg
maker = MapDatasetMaker()
safe_mask_maker = SafeMaskMaker(methods=["offset-max"],
offset_max=offset_max)
stacked = MapDataset.create(geom=geom, energy_axis_true=energy_axis_true)
spatial_model = PointSpatialModel(lon_0="-0.05 deg",
lat_0="-0.05 deg",
frame="galactic")
spectral_model = ExpCutoffPowerLawSpectralModel(
index=2,
amplitude=3e-12 * u.Unit("cm-2 s-1 TeV-1"),
reference=1.0 * u.TeV,
lambda_=0.1 / u.TeV,
)
model = SkyModel(spatial_model=spatial_model,
spectral_model=spectral_model,
name="gc-source")
datasets = Datasets([])
for idx, obs in enumerate(observations):
cutout = stacked.cutout(obs.pointing_radec,
width=2 * offset_max,
name=f"dataset{idx}")
dataset = maker.run(cutout, obs)
dataset = safe_mask_maker.run(dataset, obs)
dataset.models = [model, FoVBackgroundModel(dataset_name=dataset.name)]
datasets.append(dataset)
return datasets
def test_compute_energy_threshold(self, spectrum_dataset_crab_fine,
observations_hess_dl3):
maker = SpectrumDatasetMaker(containment_correction=True)
safe_mask_maker = SafeMaskMaker(methods=["aeff-max"], aeff_percent=10)
obs = observations_hess_dl3[0]
dataset = maker.run(spectrum_dataset_crab_fine, obs)
dataset = safe_mask_maker.run(dataset, obs)
actual = dataset.energy_range[0]
assert_quantity_allclose(actual, 0.8799225 * u.TeV, rtol=1e-3)
def obs_dataset(geom, observation):
safe_mask_maker = SafeMaskMaker(methods=["offset-max"], offset_max="2 deg")
map_dataset_maker = MapDatasetMaker(selection=["counts", "background", "exposure"])
reference = MapDataset.create(geom)
cutout = reference.cutout(
observation.pointing_radec, width="4 deg", name="test-fov"
)
dataset = map_dataset_maker.run(cutout, observation)
dataset = safe_mask_maker.run(dataset, observation)
return dataset
def test_datasetsmaker_map_2steps(observations_cta, makers_map, tmp_path):
makers = DatasetsMaker(
[MapDatasetMaker()],
stack_datasets=False,
cutout_mode="partial",
cutout_width="5 deg",
n_jobs=None,
)
dataset = get_mapdataset(name="2steps")
datasets = makers.run(dataset, observations_cta)
makers_list = [
SafeMaskMaker(methods=["offset-max"], offset_max="2 deg"),
FoVBackgroundMaker(method="scale"),
]
makers = DatasetsMaker(
makers_list,
stack_datasets=True,
cutout_mode="partial",
cutout_width="5 deg",
n_jobs=None,
)
datasets = makers.run(dataset, observations_cta, datasets)
counts = datasets[0].counts
assert counts.unit == ""
assert_allclose(counts.data.sum(), 46716, rtol=1e-5)
exposure = datasets[0].exposure
assert exposure.unit == "m2 s"
assert_allclose(exposure.data.mean(), 1.350841e09, rtol=3e-3)
def makers_spectrum(exclusion_mask):
return [
SpectrumDatasetMaker(containment_correction=True,
selection=["counts", "exposure", "edisp"]),
ReflectedRegionsBackgroundMaker(exclusion_mask=exclusion_mask),
SafeMaskMaker(methods=["aeff-max"], aeff_percent=10),
]
def _create_safe_mask_maker(self):
"""Create the SafeMaskMaker."""
log.debug("Creating the mask_safe Maker.")
safe_mask_selection = self.config.datasets.safe_mask.methods
safe_mask_settings = self.config.datasets.safe_mask.parameters
return SafeMaskMaker(methods=safe_mask_selection, **safe_mask_settings)
def test_extract(
pars,
results,
observations_hess_dl3,
spectrum_dataset_crab_fine,
reflected_regions_bkg_maker,
):
"""Test quantitative output for various configs"""
safe_mask_maker = SafeMaskMaker()
maker = SpectrumDatasetMaker(
containment_correction=pars["containment_correction"]
)
obs = observations_hess_dl3[0]
dataset = maker.run(spectrum_dataset_crab_fine, obs)
dataset = reflected_regions_bkg_maker.run(dataset, obs)
dataset = safe_mask_maker.run(dataset, obs)
exposure_actual = (
dataset.exposure.interp_by_coord(
{
"energy_true": 5 * u.TeV,
"skycoord": dataset.counts.geom.center_skydir,
}
)
* dataset.exposure.unit
)
edisp_actual = dataset.edisp.get_edisp_kernel().evaluate(
energy_true=5 * u.TeV, energy=5.2 * u.TeV
)
aeff_actual = exposure_actual / dataset.exposure.meta["livetime"]
assert_quantity_allclose(aeff_actual, results["aeff"], rtol=1e-3)
assert_quantity_allclose(edisp_actual, results["edisp"], rtol=1e-3)
# TODO: Introduce assert_stats_allclose
info = dataset.info_dict()
assert info["counts"] == results["n_on"]
assert_allclose(info["sqrt_ts"], results["sigma"], rtol=1e-2)
gti_obs = obs.gti.table
gti_dataset = dataset.gti.table
assert_allclose(gti_dataset["START"], gti_obs["START"])
assert_allclose(gti_dataset["STOP"], gti_obs["STOP"])
def data_prep():
data_store = DataStore.from_dir("$GAMMAPY_DATA/cta-1dc/index/gps/")
OBS_ID = 110380
obs_ids = OBS_ID * np.ones(N_OBS)
observations = data_store.get_observations(obs_ids)
energy_axis = MapAxis.from_bounds(0.1,
10,
nbin=10,
unit="TeV",
name="energy",
interp="log")
geom = WcsGeom.create(
skydir=(0, 0),
binsz=0.05,
width=(10, 8),
frame="galactic",
proj="CAR",
axes=[energy_axis],
)
stacked = MapDataset.create(geom, name="stacked_ds")
maker = MapDatasetMaker()
safe_mask_maker = SafeMaskMaker(methods=["offset-max"], offset_max="4 deg")
for obs in observations:
dataset = maker.run(stacked, obs)
dataset = safe_mask_maker.run(dataset, obs)
stacked.stack(dataset)
spatial_model = PointSpatialModel(lon_0="0.01 deg",
lat_0="0.01 deg",
frame="galactic")
spectral_model = ExpCutoffPowerLawSpectralModel(
index=2,
amplitude=3e-12 * u.Unit("cm-2 s-1 TeV-1"),
reference=1.0 * u.TeV,
lambda_=0.1 / u.TeV,
)
model = SkyModel(spatial_model=spatial_model,
spectral_model=spectral_model,
name="gc-source")
stacked.models.append(model)
return Datasets([stacked])
def test_map_maker(pars, observations):
stacked = MapDataset.create(
geom=pars["geom"],
energy_axis_true=pars["e_true"],
binsz_irf=pars["binsz_irf"],
migra_axis=pars["migra"],
)
maker = MapDatasetMaker(
background_oversampling=pars.get("background_oversampling"))
safe_mask_maker = SafeMaskMaker(methods=["offset-max"], offset_max="2 deg")
for obs in observations:
cutout = stacked.cutout(position=obs.pointing_radec, width="4 deg")
dataset = maker.run(cutout, obs)
dataset = safe_mask_maker.run(dataset, obs)
stacked.stack(dataset)
counts = stacked.counts
assert counts.unit == ""
assert_allclose(counts.data.sum(), pars["counts"], rtol=1e-5)
exposure = stacked.exposure
assert exposure.unit == "m2 s"
assert_allclose(exposure.data.mean(), pars["exposure"], rtol=3e-3)
background = stacked.npred_background()
assert background.unit == ""
assert_allclose(background.data.sum(), pars["background"], rtol=1e-4)
image_dataset = stacked.to_image()
counts = image_dataset.counts
assert counts.unit == ""
assert_allclose(counts.data.sum(), pars["counts"], rtol=1e-4)
exposure = image_dataset.exposure
assert exposure.unit == "m2 s"
assert_allclose(exposure.data.sum(), pars["exposure_image"], rtol=1e-3)
background = image_dataset.npred_background()
assert background.unit == ""
assert_allclose(background.data.sum(), pars["background"], rtol=1e-4)
def test_minimal_datastore():
""" "Check that a standard analysis runs on a minimal datastore"""
energy_axis = MapAxis.from_energy_bounds(1,
10,
nbin=3,
per_decade=False,
unit="TeV",
name="energy")
geom = WcsGeom.create(
skydir=(83.633, 22.014),
binsz=0.5,
width=(2, 2),
frame="icrs",
proj="CAR",
axes=[energy_axis],
)
data_store = DataStore.from_dir("$GAMMAPY_DATA/tests/minimal_datastore")
observations = data_store.get_observations()
maker = MapDatasetMaker()
offset_max = 2.3 * u.deg
maker_safe_mask = SafeMaskMaker(methods=["offset-max"],
offset_max=offset_max)
circle = CircleSkyRegion(center=SkyCoord("83.63 deg", "22.14 deg"),
radius=0.2 * u.deg)
exclusion_mask = ~geom.region_mask(regions=[circle])
maker_fov = FoVBackgroundMaker(method="fit", exclusion_mask=exclusion_mask)
stacked = MapDataset.create(geom=geom, name="crab-stacked")
for obs in observations:
dataset = maker.run(stacked, obs)
dataset = maker_safe_mask.run(dataset, obs)
dataset = maker_fov.run(dataset)
stacked.stack(dataset)
assert_allclose(stacked.exposure.data.sum(), 6.01909e10)
assert_allclose(stacked.counts.data.sum(), 1446)
assert_allclose(stacked.background.data.sum(), 1445.9841)
def create_datasets_3d(observations, target_position):
# Target geometry definition
e_reco = MapAxis.from_energy_bounds(0.23, 20, 12, "TeV")
e_true = MapAxis.from_energy_bounds(0.1, 40, 40, "TeV", name="energy_true")
geom = WcsGeom.create(skydir=target_position,
width=(2, 2),
binsz=0.02,
axes=[e_reco])
exclusion_region = CircleSkyRegion(target_position, 0.3 * u.deg)
exclusion_mask = geom.region_mask([exclusion_region], inside=False)
offset_max = 2.0 * u.deg
#data reduction makers
maker = MapDatasetMaker()
bkg_maker = FoVBackgroundMaker(method="scale",
exclusion_mask=exclusion_mask)
safe_mask_maker = SafeMaskMaker(methods=["aeff-max", "offset-max"],
aeff_percent=10,
offset_max=offset_max)
datasets = []
dataset_empty = MapDataset.create(geom=geom, energy_axis_true=e_true)
for obs in observations:
cutout = dataset_empty.cutout(obs.pointing_radec, width=2 * offset_max)
# A MapDataset is filled in this cutout geometry
dataset = maker.run(cutout, obs)
# The data quality cut is applied
dataset = safe_mask_maker.run(dataset, obs)
# fit background model
dataset = bkg_maker.run(dataset)
print(
f"Background norm obs {obs.obs_id}: {dataset.background_model.spectral_model.norm.value:.2f}"
)
datasets.append(dataset)
return datasets
def test_map_dataset_maker_hpx(geom_config_hpx, observations):
reference = MapDataset.create(**geom_config_hpx, binsz_irf=5 * u.deg)
maker = MapDatasetMaker()
safe_mask_maker = SafeMaskMaker(offset_max="2.5 deg",
methods=["aeff-default", "offset-max"])
dataset = maker.run(reference, observation=observations[0])
dataset = safe_mask_maker.run(dataset,
observation=observations[0]).to_masked()
assert_allclose(dataset.counts.data.sum(), 4264)
assert_allclose(dataset.background.data.sum(), 2964.5369, rtol=1e-5)
assert_allclose(dataset.exposure.data[4, 1000], 5.987e09, rtol=1e-4)
coords = SkyCoord([0, 3], [0, 0], frame="galactic", unit="deg")
coords = {"skycoord": coords, "energy": 1 * u.TeV}
assert_allclose(dataset.mask_safe.get_by_coord(coords), [True, False])
kernel = dataset.edisp.get_edisp_kernel()
assert_allclose(kernel.data.sum(axis=1)[3], 1, rtol=0.01)
def test_reflected_bkg_maker_no_off(reflected_bkg_maker, observations, caplog):
pos = SkyCoord(83.6333313, 21.51444435, unit="deg", frame="icrs")
radius = Angle(0.11, "deg")
region = CircleSkyRegion(pos, radius)
maker = SpectrumDatasetMaker(selection=["counts", "exposure"])
datasets = []
e_reco = MapAxis.from_edges(np.logspace(0, 2, 5) * u.TeV, name="energy")
e_true = MapAxis.from_edges(np.logspace(-0.5, 2, 11) * u.TeV,
name="energy_true")
geom = RegionGeom.create(region=region, axes=[e_reco])
dataset_empty = SpectrumDataset.create(geom=geom, energy_axis_true=e_true)
safe_mask_masker = SafeMaskMaker(methods=["aeff-max"], aeff_percent=10)
for obs in observations:
dataset = maker.run(dataset_empty, obs)
dataset_on_off = reflected_bkg_maker.run(dataset, obs)
dataset_on_off = safe_mask_masker.run(dataset_on_off, obs)
datasets.append(dataset_on_off)
assert datasets[0].counts_off is None
assert_allclose(datasets[0].acceptance_off, 0)
assert_allclose(datasets[0].mask_safe.data, False)
assert "WARNING" in [record.levelname for record in caplog.records]
message1 = (
f"ReflectedRegionsBackgroundMaker failed. "
f"No OFF region found outside exclusion mask for dataset '{datasets[0].name}'."
)
message2 = (f"ReflectedRegionsBackgroundMaker failed. "
f"Setting {datasets[0].name} mask to False.")
assert message1 in [record.message for record in caplog.records]
assert message2 in [record.message for record in caplog.records]
def test_safe_mask_maker(observations, caplog):
obs = observations[0]
axis = MapAxis.from_bounds(0.1,
10,
nbin=16,
unit="TeV",
name="energy",
interp="log")
axis_true = MapAxis.from_bounds(0.1,
50,
nbin=30,
unit="TeV",
name="energy_true",
interp="log")
geom = WcsGeom.create(npix=(11, 11),
axes=[axis],
skydir=obs.pointing_radec)
empty_dataset = MapDataset.create(geom=geom, energy_axis_true=axis_true)
dataset_maker = MapDatasetMaker()
safe_mask_maker = SafeMaskMaker(offset_max="3 deg",
bias_percent=0.02,
position=obs.pointing_radec)
dataset = dataset_maker.run(empty_dataset, obs)
mask_offset = safe_mask_maker.make_mask_offset_max(dataset=dataset,
observation=obs)
assert_allclose(mask_offset.sum(), 109)
mask_energy_aeff_default = safe_mask_maker.make_mask_energy_aeff_default(
dataset=dataset, observation=obs)
assert_allclose(mask_energy_aeff_default.data.sum(), 1936)
mask_aeff_max = safe_mask_maker.make_mask_energy_aeff_max(dataset)
assert_allclose(mask_aeff_max.data.sum(), 1210)
mask_edisp_bias = safe_mask_maker.make_mask_energy_edisp_bias(dataset)
assert_allclose(mask_edisp_bias.data.sum(), 1815)
mask_bkg_peak = safe_mask_maker.make_mask_energy_bkg_peak(dataset)
assert_allclose(mask_bkg_peak.data.sum(), 1815)
assert caplog.records[-1].levelname == "WARNING"
assert caplog.records[
-1].message == "No default thresholds defined for obs 110380"
def test_safe_mask_maker_dl3(spectrum_dataset_crab, observations_hess_dl3):
safe_mask_maker = SafeMaskMaker()
maker = SpectrumDatasetMaker()
obs = observations_hess_dl3[0]
dataset = maker.run(spectrum_dataset_crab, obs)
dataset = safe_mask_maker.run(dataset, obs)
assert_allclose(dataset.energy_range[0].value, 1)
assert dataset.energy_range[0].unit == "TeV"
mask_safe = safe_mask_maker.make_mask_energy_aeff_max(dataset)
assert mask_safe.data.sum() == 4
mask_safe = safe_mask_maker.make_mask_energy_edisp_bias(dataset)
assert mask_safe.data.sum() == 3
mask_safe = safe_mask_maker.make_mask_energy_bkg_peak(dataset)
assert mask_safe.data.sum() == 3
def makers_map():
return [
MapDatasetMaker(),
SafeMaskMaker(methods=["offset-max"], offset_max="2 deg"),
FoVBackgroundMaker(method="scale"),
]
def test_safe_mask_maker(observations, caplog):
obs = observations[0]
axis = MapAxis.from_bounds(
0.1, 10, nbin=16, unit="TeV", name="energy", interp="log"
)
axis_true = MapAxis.from_bounds(
0.1, 50, nbin=30, unit="TeV", name="energy_true", interp="log"
)
geom = WcsGeom.create(npix=(11, 11), axes=[axis], skydir=obs.pointing_radec)
empty_dataset = MapDataset.create(geom=geom, energy_axis_true=axis_true)
dataset_maker = MapDatasetMaker()
safe_mask_maker = SafeMaskMaker(
offset_max="3 deg", bias_percent=0.02, position=obs.pointing_radec
)
fixed_offset = 1.5 * u.deg
safe_mask_maker_offset = SafeMaskMaker(
offset_max="3 deg", bias_percent=0.02, fixed_offset=fixed_offset
)
dataset = dataset_maker.run(empty_dataset, obs)
mask_offset = safe_mask_maker.make_mask_offset_max(dataset=dataset, observation=obs)
assert_allclose(mask_offset.sum(), 109)
mask_energy_aeff_default = safe_mask_maker.make_mask_energy_aeff_default(
dataset=dataset, observation=obs
)
assert_allclose(mask_energy_aeff_default.data.sum(), 1936)
mask_aeff_max = safe_mask_maker.make_mask_energy_aeff_max(dataset)
mask_aeff_max_offset = safe_mask_maker_offset.make_mask_energy_aeff_max(
dataset, obs
)
assert_allclose(mask_aeff_max.data.sum(), 1210)
assert_allclose(mask_aeff_max_offset.data.sum(), 1210)
mask_edisp_bias = safe_mask_maker.make_mask_energy_edisp_bias(dataset)
mask_edisp_bias_offset = safe_mask_maker_offset.make_mask_energy_edisp_bias(
dataset, obs
)
assert_allclose(mask_edisp_bias.data.sum(), 1815)
assert_allclose(mask_edisp_bias_offset.data.sum(), 1694)
mask_bkg_peak = safe_mask_maker.make_mask_energy_bkg_peak(dataset)
assert_allclose(mask_bkg_peak.data.sum(), 1936)
assert "WARNING" in [_.levelname for _ in caplog.records]
message1 = "No default thresholds defined for obs 110380"
assert message1 in [_.message for _ in caplog.records]
safe_mask_maker_noroot = SafeMaskMaker(
offset_max="3 deg", aeff_percent=-10, bias_percent=-10
)
mask_aeff_max_noroot = safe_mask_maker_noroot.make_mask_energy_aeff_max(dataset)
mask_edisp_bias_noroot = safe_mask_maker_noroot.make_mask_energy_edisp_bias(dataset)
assert_allclose(mask_aeff_max_noroot.data.sum(), 1815)
assert_allclose(mask_edisp_bias_noroot.data.sum(), 1936)
## test if the peak is in the first bin
axis = MapAxis.from_bounds(1.0, 10, nbin=6, unit="TeV", name="energy", interp="log")
geom = WcsGeom.create(npix=(5, 5), axes=[axis], skydir=obs.pointing_radec)
empty_dataset = MapDataset.create(geom=geom, energy_axis_true=axis_true)
dataset = dataset_maker.run(empty_dataset, obs)
mask_bkg_peak = safe_mask_maker.make_mask_energy_bkg_peak(dataset)
assert np.all(mask_bkg_peak)
def _spectrum_extraction(self):
"""Run all steps for the spectrum extraction."""
log.info("Reducing spectrum datasets.")
datasets_settings = self.config.datasets
on_lon = datasets_settings.on_region.lon
on_lat = datasets_settings.on_region.lat
on_center = SkyCoord(on_lon,
on_lat,
frame=datasets_settings.on_region.frame)
on_region = CircleSkyRegion(on_center,
datasets_settings.on_region.radius)
maker_config = {}
if datasets_settings.containment_correction:
maker_config[
"containment_correction"] = datasets_settings.containment_correction
e_reco = self._make_energy_axis(datasets_settings.geom.axes.energy)
maker_config["selection"] = ["counts", "exposure", "edisp"]
dataset_maker = SpectrumDatasetMaker(**maker_config)
bkg_maker_config = {}
if datasets_settings.background.exclusion:
exclusion_region = Map.read(datasets_settings.background.exclusion)
bkg_maker_config["exclusion_mask"] = exclusion_region
bkg_maker_config.update(datasets_settings.background.parameters)
bkg_method = datasets_settings.background.method
if bkg_method == "reflected":
bkg_maker = ReflectedRegionsBackgroundMaker(**bkg_maker_config)
log.debug(
f"Creating ReflectedRegionsBackgroundMaker with arguments {bkg_maker_config}"
)
else:
bkg_maker = None
log.warning(
f"No background maker set for 1d analysis. Check configuration."
)
safe_mask_selection = datasets_settings.safe_mask.methods
safe_mask_settings = datasets_settings.safe_mask.parameters
safe_mask_maker = SafeMaskMaker(methods=safe_mask_selection,
**safe_mask_settings)
e_true = self._make_energy_axis(
datasets_settings.geom.axes.energy_true, name="energy_true")
geom = RegionGeom.create(region=on_region, axes=[e_reco])
reference = SpectrumDataset.create(geom=geom, energy_axis_true=e_true)
datasets = []
for obs in self.observations:
log.info(f"Processing observation {obs.obs_id}")
dataset = dataset_maker.run(reference.copy(), obs)
if bkg_maker is not None:
dataset = bkg_maker.run(dataset, obs)
if dataset.counts_off is None:
log.info(
f"No OFF region found for observation {obs.obs_id}. Discarding."
)
continue
dataset = safe_mask_maker.run(dataset, obs)
log.debug(dataset)
datasets.append(dataset)
self.datasets = Datasets(datasets)
if datasets_settings.stack:
stacked = self.datasets.stack_reduce(name="stacked")
self.datasets = Datasets([stacked])
def _map_making(self):
"""Make maps and datasets for 3d analysis."""
datasets_settings = self.config.datasets
log.info("Creating geometry.")
geom = self._create_geometry()
geom_settings = datasets_settings.geom
geom_irf = dict(energy_axis_true=None, binsz_irf=None)
if geom_settings.axes.energy_true.min is not None:
geom_irf["energy_axis_true"] = self._make_energy_axis(
geom_settings.axes.energy_true, name="energy_true")
geom_irf["binsz_irf"] = geom_settings.wcs.binsize_irf.to("deg").value
offset_max = geom_settings.selection.offset_max
log.info("Creating datasets.")
maker = MapDatasetMaker(selection=datasets_settings.map_selection)
safe_mask_selection = datasets_settings.safe_mask.methods
safe_mask_settings = datasets_settings.safe_mask.parameters
maker_safe_mask = SafeMaskMaker(methods=safe_mask_selection,
**safe_mask_settings)
bkg_maker_config = {}
if datasets_settings.background.exclusion:
exclusion_region = Map.read(datasets_settings.background.exclusion)
bkg_maker_config["exclusion_mask"] = exclusion_region
bkg_maker_config.update(datasets_settings.background.parameters)
bkg_method = datasets_settings.background.method
if bkg_method == "fov_background":
log.debug(
f"Creating FoVBackgroundMaker with arguments {bkg_maker_config}"
)
bkg_maker = FoVBackgroundMaker(**bkg_maker_config)
elif bkg_method == "ring":
bkg_maker = RingBackgroundMaker(**bkg_maker_config)
log.debug(
f"Creating RingBackgroundMaker with arguments {bkg_maker_config}"
)
if datasets_settings.geom.axes.energy.nbins > 1:
raise ValueError(
"You need to define a single-bin energy geometry for your dataset."
)
else:
bkg_maker = None
log.warning(
f"No background maker set for 3d analysis. Check configuration."
)
stacked = MapDataset.create(geom=geom, name="stacked", **geom_irf)
if datasets_settings.stack:
for obs in self.observations:
log.info(f"Processing observation {obs.obs_id}")
cutout = stacked.cutout(obs.pointing_radec,
width=2 * offset_max)
dataset = maker.run(cutout, obs)
dataset = maker_safe_mask.run(dataset, obs)
if bkg_maker is not None:
dataset = bkg_maker.run(dataset)
if bkg_method == "ring":
dataset = dataset.to_map_dataset()
log.debug(dataset)
stacked.stack(dataset)
datasets = [stacked]
else:
datasets = []
for obs in self.observations:
log.info(f"Processing observation {obs.obs_id}")
cutout = stacked.cutout(obs.pointing_radec,
width=2 * offset_max)
dataset = maker.run(cutout, obs)
dataset = maker_safe_mask.run(dataset, obs)
if bkg_maker is not None:
dataset = bkg_maker.run(dataset)
log.debug(dataset)
datasets.append(dataset)
self.datasets = Datasets(datasets)
def simulate():
irfs = load_cta_irfs(
"$GAMMAPY_DATA/cta-1dc/caldb/data/cta/1dc/bcf/South_z20_50h/irf_file.fits"
)
center = SkyCoord(0.0, 0.0, unit="deg", frame="galactic")
energy_reco = MapAxis.from_edges(np.logspace(-1.0, 1.0, 10),
unit="TeV",
name="energy",
interp="log")
pointing = SkyCoord(0.5, 0.5, unit="deg", frame="galactic")
geom = WcsGeom.create(
skydir=center,
binsz=0.02,
width=(4, 4),
frame="galactic",
axes=[energy_reco],
)
energy_true = MapAxis.from_edges(np.logspace(-1.5, 1.5, 30),
unit="TeV",
name="energy_true",
interp="log")
spectral_model = PowerLawSpectralModel(index=3,
amplitude="1e-11 cm-2 s-1 TeV-1",
reference="1 TeV")
temporal_model = ExpDecayTemporalModel(t0="6 h", t_ref=gti_t0.mjd * u.d)
spatial_model = GaussianSpatialModel(lon_0="0.2 deg",
lat_0="0.1 deg",
sigma="0.3 deg",
frame="galactic")
model_simu = SkyModel(
spectral_model=spectral_model,
spatial_model=spatial_model,
temporal_model=temporal_model,
name="model-simu",
)
lvtm = np.ones(N_OBS) * 1.0 * u.hr
tstart = 1.0 * u.hr
datasets = []
for i in range(N_OBS):
obs = Observation.create(
pointing=pointing,
livetime=lvtm[i],
tstart=tstart,
irfs=irfs,
reference_time=gti_t0,
)
empty = MapDataset.create(geom,
name=f"dataset_{i}",
energy_axis_true=energy_true)
maker = MapDatasetMaker(
selection=["exposure", "background", "psf", "edisp"])
maker_safe_mask = SafeMaskMaker(methods=["offset-max"],
offset_max=4.0 * u.deg)
dataset = maker.run(empty, obs)
dataset = maker_safe_mask.run(dataset, obs)
dataset.models = [
model_simu,
FoVBackgroundModel(dataset_name=dataset.name)
]
dataset.fake()
datasets.append(dataset)
tstart = tstart + 2.0 * u.hr
return datasets
obs = Observation.create(pointing=pointing, livetime=livetime, irfs=irfs)
# ## Start the simulations and get the limits
#masses = [70, 200, 500, 800, 1000, 5000, 8000, 10000, 30000, 50000, 60000, 100000]*u.GeV
masses = [200, 1000, 50000] * u.GeV
#channels = ["b", "mu", "tau", "Z"]
channels = ["b"]
columns = ['ch', 'mass', 'sigma_v']
table = pd.DataFrame(columns=columns)
# Make the MapDataset
empty = MapDataset.create(geom, name="dataset-simu")
maker = MapDatasetMaker(selection=["exposure", "background", "psf", "edisp"])
maker_safe_mask = SafeMaskMaker(methods=["offset-max"], offset_max=offset)
NumberOfRuns = 2
for run in range(NumberOfRuns):
# Create simulated dataset
dataset = maker.run(empty, obs)
dataset = maker_safe_mask.run(dataset, obs)
dataset.models = models
dataset.fake(int(time.time()))
for ch in channels:
for mass in masses:
flux_model_fit = DarkMatterAnnihilationSpectralModel(mass=mass,
channel=ch,
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",
frame="galactic")
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",
name="energy")
e_true = MapAxis.from_bounds(0.05,
100,
nbin=200,
interp="log",
unit="TeV",
name="energy_true")
stacked = SpectrumDatasetOnOff.create(region=on_region,
e_reco=e_reco,
e_true=e_true,
name="stacked")
dataset_maker = SpectrumDatasetMaker(containment_correction=False,
selection=["counts", "aeff", "edisp"])
bkg_maker = ReflectedRegionsBackgroundMaker(exclusion_mask=exclusion_mask)
safe_mask_masker = SafeMaskMaker(methods=["aeff-max"], aeff_percent=10)
spectral_model = PowerLawSpectralModel(index=2,
amplitude=2e-11 *
u.Unit("cm-2 s-1 TeV-1"),
reference=1 * u.TeV)
spatial_model = PointSpatialModel(lon_0=target_position.ra,
lat_0=target_position.dec,
frame="icrs")
spatial_model.lon_0.frozen = True
spatial_model.lat_0.frozen = True
sky_model = SkyModel(spatial_model=spatial_model,
spectral_model=spectral_model,
name="")
for observation in observations:
dataset = stacked.copy(name=f"dataset-{observation.obs_id}")
dataset = dataset_maker.run(dataset=dataset, observation=observation)
dataset_on_off = bkg_maker.run(dataset, observation)
dataset_on_off = safe_mask_masker.run(dataset_on_off, observation)
stacked.stack(dataset_on_off)
stacked.models = sky_model
return Datasets([stacked])