/
safe.py
380 lines (310 loc) · 13.2 KB
/
safe.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
# Licensed under a 3-clause BSD style license - see LICENSE.rst
import logging
import numpy as np
from astropy import units as u
from astropy.coordinates import Angle
from gammapy.irf import EDispKernelMap
from gammapy.maps import Map
from gammapy.modeling.models import TemplateSpectralModel
from .core import Maker
__all__ = ["SafeMaskMaker"]
log = logging.getLogger(__name__)
class SafeMaskMaker(Maker):
"""Make safe data range mask for a given observation.
.. warning::
Currently some methods computing a safe energy range ("aeff-default",
"aeff-max" and "edisp-bias") determine a true energy range and apply
it to reconstructed energy, effectively neglecting the energy dispersion.
Parameters
----------
methods : {"aeff-default", "aeff-max", "edisp-bias", "offset-max", "bkg-peak"}
Method to use for the safe energy range. Can be a
list with a combination of those. Resulting masks
are combined with logical `and`. "aeff-default"
uses the energy ranged specified in the DL3 data
files, if available.
aeff_percent : float
Percentage of the maximal effective area to be used
as lower energy threshold for method "aeff-max".
bias_percent : float
Percentage of the energy bias to be used as lower
energy threshold for method "edisp-bias".
position : `~astropy.coordinates.SkyCoord`
Position at which the `aeff_percent` or `bias_percent` are computed.
fixed_offset : `~astropy.coordinates.Angle`
Offset, calculated from the pointing position, at which
the `aeff_percent` or `bias_percent` are computed.
If neither the position nor fixed_offset is specified,
it uses the position of the center of the map by default.
offset_max : str or `~astropy.units.Quantity`
Maximum offset cut.
irfs : {"DL4", "DL3"}
Whether to use reprojected ("DL4") or raw ("DL3") irfs.
Default is "DL4".
"""
tag = "SafeMaskMaker"
available_methods = {
"aeff-default",
"aeff-max",
"edisp-bias",
"offset-max",
"bkg-peak",
}
def __init__(
self,
methods=("aeff-default",),
aeff_percent=10,
bias_percent=10,
position=None,
fixed_offset=None,
offset_max="3 deg",
irfs="DL4",
):
methods = set(methods)
if not methods.issubset(self.available_methods):
difference = methods.difference(self.available_methods)
raise ValueError(f"{difference} is not a valid method.")
self.methods = methods
self.aeff_percent = aeff_percent
self.bias_percent = bias_percent
self.position = position
self.fixed_offset = fixed_offset
self.offset_max = Angle(offset_max)
if self.position and self.fixed_offset:
raise ValueError(
"`position` and `fixed_offset` attributes are mutually exclusive"
)
if irfs not in ["DL3", "DL4"]:
ValueError(
"Invalid option for irfs: expected 'DL3' or 'DL4', got {irfs} instead."
)
self.irfs = irfs
def make_mask_offset_max(self, dataset, observation):
"""Make maximum offset mask.
Parameters
----------
dataset : `~gammapy.datasets.MapDataset` or `~gammapy.datasets.SpectrumDataset`
Dataset to compute mask for.
observation : `~gammapy.data.Observation`
Observation to compute mask for.
Returns
-------
mask_safe : `~numpy.ndarray`
Maximum offset mask.
"""
if observation is None:
raise ValueError("Method 'offset-max' requires an observation object.")
separation = dataset._geom.separation(
observation.get_pointing_icrs(observation.tmid)
)
return separation < self.offset_max
@staticmethod
def make_mask_energy_aeff_default(dataset, observation):
"""Make safe energy mask from aeff default.
Parameters
----------
dataset : `~gammapy.datasets.MapDataset` or `~gammapy.datasets.SpectrumDataset`
Dataset to compute mask for.
observation : `~gammapy.data.Observation`
Observation to compute mask for.
Returns
-------
mask_safe : `~numpy.ndarray`
Safe data range mask.
"""
if observation is None:
raise ValueError("Method 'aeff-default' requires an observation object.")
energy_max = observation.aeff.meta.get("HI_THRES", None)
if energy_max:
energy_max = energy_max * u.TeV
else:
log.warning(
f"No default upper safe energy threshold defined for obs {observation.obs_id}"
)
energy_min = observation.aeff.meta.get("LO_THRES", None)
if energy_min:
energy_min = energy_min * u.TeV
else:
log.warning(
f"No default lower safe energy threshold defined for obs {observation.obs_id}"
)
return dataset._geom.energy_mask(energy_min=energy_min, energy_max=energy_max)
def _get_offset(self, observation):
offset = self.fixed_offset
if offset is None:
if self.position:
offset = observation.get_pointing_icrs(observation.tmid).separation(
self.position
)
else:
offset = 0.0 * u.deg
return offset
def _get_position(self, observation, geom):
if self.fixed_offset is not None and observation is not None:
pointing = observation.get_pointing_icrs(observation.tmid)
return pointing.directional_offset_by(
position_angle=0 * u.deg, separation=self.fixed_offset
)
elif self.position is not None:
return self.position
else:
return geom.center_skydir
def make_mask_energy_aeff_max(self, dataset, observation=None):
"""Make safe energy mask from effective area maximum value.
Parameters
----------
dataset : `~gammapy.datasets.MapDataset` or `~gammapy.datasets.SpectrumDataset`
Dataset to compute mask for.
observation : `~gammapy.data.Observation`
Observation to compute mask for. It is a mandatory argument when fixed_offset is set.
Returns
-------
mask_safe : `~numpy.ndarray`
Safe data range mask.
"""
if self.fixed_offset is not None and observation is None:
raise ValueError(
f"{observation} argument is mandatory with {self.fixed_offset}"
)
geom, exposure = dataset._geom, dataset.exposure
if self.irfs == "DL3":
offset = self._get_offset(observation)
values = observation.aeff.evaluate(
offset=offset, energy_true=observation.aeff.axes["energy_true"].edges
)
valid = observation.aeff.axes["energy_true"].edges[
values > self.aeff_percent * np.max(values) / 100
]
energy_min = np.min(valid)
else:
position = self._get_position(observation, geom)
aeff = exposure.get_spectrum(position) / exposure.meta["livetime"]
if not np.any(aeff.data > 0.0):
log.warning(
f"Effective area is all zero at [{position.to_string('dms')}]. "
f"No safe energy band can be defined for the dataset '{dataset.name}': "
"setting `mask_safe` to all False."
)
return Map.from_geom(geom, data=False, dtype="bool")
model = TemplateSpectralModel.from_region_map(aeff)
energy_true = model.energy
energy_min = energy_true[np.where(model.values > 0)[0][0]]
energy_max = energy_true[-1]
aeff_thres = (self.aeff_percent / 100) * aeff.quantity.max()
inversion = model.inverse(
aeff_thres, energy_min=energy_min, energy_max=energy_max
)
if not np.isnan(inversion[0]):
energy_min = inversion[0]
return geom.energy_mask(energy_min=energy_min)
def make_mask_energy_edisp_bias(self, dataset, observation=None):
"""Make safe energy mask from energy dispersion bias.
Parameters
----------
dataset : `~gammapy.datasets.MapDataset` or `~gammapy.datasets.SpectrumDataset`
Dataset to compute mask for.
observation : `~gammapy.data.Observation`
Observation to compute mask for. It is a mandatory argument when fixed_offset is set.
Returns
-------
mask_safe : `~numpy.ndarray`
Safe data range mask.
"""
if self.fixed_offset is not None and observation is None:
raise ValueError(
f"{observation} argument is mandatory with {self.fixed_offset}"
)
edisp, geom = dataset.edisp, dataset._geom
if self.irfs == "DL3":
offset = self._get_offset(observation)
edisp = observation.edisp.to_edisp_kernel(offset)
else:
kwargs = dict()
kwargs["position"] = self._get_position(observation, geom)
if not isinstance(edisp, EDispKernelMap):
kwargs["energy_axis"] = dataset._geom.axes["energy"]
edisp = edisp.get_edisp_kernel(**kwargs)
energy_min = edisp.get_bias_energy(self.bias_percent / 100)[0]
return geom.energy_mask(energy_min=energy_min)
def make_mask_energy_bkg_peak(self, dataset, observation=None):
"""Make safe energy mask based on the binned background.
The energy threshold is defined as the lower edge of the energy
bin with the highest predicted background rate. This is to ensure analysis in
a region where a Powerlaw approximation to the background spectrum is valid.
The is motivated by its use in the HESS DL3
validation paper: https://arxiv.org/pdf/1910.08088.pdf
Parameters
----------
dataset : `~gammapy.datasets.MapDataset` or `~gammapy.datasets.SpectrumDataset`
Dataset to compute mask for.
observation: `~gammapy.data.Observation`
Observation to compute mask for. It is a mandatory argument when DL3 irfs are used.
Returns
-------
mask_safe : `~numpy.ndarray`
Safe data range mask.
"""
geom = dataset._geom
if self.irfs == "DL3":
bkg = observation.bkg.to_2d()
background_spectrum = np.ravel(
bkg.integral(axis_name="offset", offset=bkg.axes["offset"].bounds[1])
)
energy_axis = bkg.axes["energy"]
else:
background_spectrum = dataset.npred_background().get_spectrum()
energy_axis = geom.axes["energy"]
idx = np.argmax(background_spectrum.data, axis=0)
return geom.energy_mask(energy_min=energy_axis.edges[idx])
@staticmethod
def make_mask_bkg_invalid(dataset):
"""Mask non-finite values and zeros values in background maps.
Parameters
----------
dataset : `~gammapy.datasets.MapDataset` or `~gammapy.datasets.SpectrumDataset`
Dataset to compute mask for.
Returns
-------
mask_safe : `~numpy.ndarray`
Safe data range mask.
"""
bkg = dataset.background.data
mask = np.isfinite(bkg)
if not dataset.stat_type == "wstat":
mask &= bkg > 0.0
return mask
def run(self, dataset, observation=None):
"""Make safe data range mask.
Parameters
----------
dataset : `~gammapy.datasets.MapDataset` or `~gammapy.datasets.SpectrumDataset`
Dataset to compute mask for.
observation : `~gammapy.data.Observation`
Observation to compute mask for.
Returns
-------
dataset : `Dataset`
Dataset with defined safe range mask.
"""
if self.irfs == "DL3":
if observation is None:
raise ValueError("observation argument is mandatory with DL3 irfs")
if dataset.mask_safe:
mask_safe = dataset.mask_safe.data
else:
mask_safe = np.ones(dataset._geom.data_shape, dtype=bool)
if dataset.background is not None:
# apply it first so only clipped values are removed for "bkg-peak"
mask_safe &= self.make_mask_bkg_invalid(dataset)
if "offset-max" in self.methods:
mask_safe &= self.make_mask_offset_max(dataset, observation)
if "aeff-default" in self.methods:
mask_safe &= self.make_mask_energy_aeff_default(dataset, observation)
if "aeff-max" in self.methods:
mask_safe &= self.make_mask_energy_aeff_max(dataset, observation)
if "edisp-bias" in self.methods:
mask_safe &= self.make_mask_energy_edisp_bias(dataset, observation)
if "bkg-peak" in self.methods:
mask_safe &= self.make_mask_energy_bkg_peak(dataset, observation)
dataset.mask_safe = Map.from_geom(dataset._geom, data=mask_safe, dtype=bool)
return dataset