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 create_stacked_dataset(analysis):
# source_pos = SkyCoord.from_name("MSH 15-52")
source_pos = SkyCoord(228.32, -59.08, unit="deg")
# get the geom that we use
geom = analysis.datasets[0].counts.geom
energy_axis = analysis.datasets[0].counts.geom.axes["energy"]
geom_image = geom.to_image().to_cube([energy_axis.squash()])
# Make the exclusion mask
regions = CircleSkyRegion(center=source_pos, radius=0.3 * u.deg)
exclusion_mask = geom_image.region_mask([regions], inside=False)
ring_maker = RingBackgroundMaker(r_in="0.5 deg",
width="0.3 deg",
exclusion_mask=exclusion_mask)
# Creation of the MapDatasetOnOff
energy_axis_true = analysis.datasets[0].exposure.geom.axes["energy_true"]
stacked_on_off = MapDatasetOnOff.create(geom=geom_image,
energy_axis_true=energy_axis_true,
name="stacked")
for dataset in analysis.datasets:
# Ring extracting makes sense only for 2D analysis
dataset_on_off = ring_maker.run(dataset.to_image())
stacked_on_off.stack(dataset_on_off)
return stacked_on_off
def _create_background_maker(self):
"""Create the Background maker."""
log.info("Creating the background Maker.")
datasets_settings = self.config.datasets
bkg_maker_config = {}
if datasets_settings.background.exclusion:
path = make_path(datasets_settings.background.exclusion)
exclusion_mask = Map.read(path)
exclusion_mask.data = exclusion_mask.data.astype(bool)
bkg_maker_config["exclusion_mask"] = exclusion_mask
bkg_maker_config.update(datasets_settings.background.parameters)
bkg_method = datasets_settings.background.method
bkg_maker = None
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."
)
elif bkg_method == "reflected":
bkg_maker = ReflectedRegionsBackgroundMaker(**bkg_maker_config)
log.debug(
f"Creating ReflectedRegionsBackgroundMaker with arguments {bkg_maker_config}"
)
else:
log.warning("No background maker set. Check configuration.")
return bkg_maker
def extract_ring(datasets,
exclusion_mask,
r_in="1.0 deg",
width="0.3 deg"):
geom = datasets[0].counts.geom
energy_axis = datasets[0].counts.geom.axes["energy"]
geom_image = geom.to_image().to_cube([energy_axis.squash()])
ring_maker = RingBackgroundMaker(
r_in=r_in, width=width, exclusion_mask=exclusion_mask
)
energy_axis_true = datasets[0].exposure.geom.axes["energy_true"]
stacked_on_off = MapDatasetOnOff.create(
geom=geom_image, energy_axis_true=energy_axis_true, name="stacked"
)
for dataset in datasets:
dataset_on_off = ring_maker.run(dataset.to_image())
stacked_on_off.stack(dataset_on_off)
return stacked_on_off
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)