def select_sky_circle(self, center, radius, inverted=False):
"""Make an observation table, applying a cone selection.
Apply a selection based on the separation between the cone center
and the observation pointing stored in the table.
If the inverted flag is activated, the selection is applied to
keep all elements outside the selected range.
Parameters
----------
center : `~astropy.coordinate.SkyCoord`
Cone center coordinate.
radius : `~astropy.coordinate.Angle`
Cone opening angle. The maximal separation allowed between the center and the observation
pointing direction.
inverted : bool, optional
Invert selection: keep all entries outside the cone.
Returns
-------
obs_table : `~gammapy.data.ObservationTable`
Observation table after selection.
"""
region = SphericalCircleSkyRegion(center=center, radius=radius)
mask = region.contains(self.pointing_radec)
if inverted:
mask = np.invert(mask)
return self[mask]
def test_filter_events(observation):
custom_filter = {
"type": "custom",
"opts": {
"parameter": "ENERGY",
"band": Quantity([0.8 * u.TeV, 10.0 * u.TeV])
},
}
target_position = SkyCoord(ra=229.2, dec=-58.3, unit="deg", frame="icrs")
region_radius = Angle("0.2 deg")
region = SphericalCircleSkyRegion(center=target_position,
radius=region_radius)
region_filter = {"type": "sky_region", "opts": {"region": region}}
time_filter = Time([53090.12, 53090.13], format="mjd", scale="tt")
obs_filter = ObservationFilter(
event_filters=[custom_filter, region_filter], time_filter=time_filter)
events = observation.events
filtered_events = obs_filter.filter_events(events)
assert np.all((filtered_events.energy >= 0.8 * u.TeV)
& (filtered_events.energy < 10.0 * u.TeV))
assert np.all((filtered_events.time >= time_filter[0])
& (filtered_events.time < time_filter[1]))
assert np.all(
region.center.separation(filtered_events.radec) < region_radius)
class TestSphericalCircleSkyRegion:
def setup(self):
self.region = SphericalCircleSkyRegion(center=SkyCoord(
10 * u.deg, 20 * u.deg),
radius=10 * u.deg)
def test_contains(self):
coord = SkyCoord([20.1, 22] * u.deg, 20 * u.deg)
mask = self.region.contains(coord)
assert_equal(mask, [True, False])
def test_run(observations, phase_bkg_maker):
maker = SpectrumDatasetMaker()
e_reco = np.logspace(0, 2, 5) * u.TeV
e_true = np.logspace(-0.5, 2, 11) * u.TeV
pos = SkyCoord("08h35m20.65525s", "-45d10m35.1545s", frame="icrs")
radius = Angle(0.2, "deg")
region = SphericalCircleSkyRegion(pos, radius)
dataset_empty = SpectrumDataset.create(e_reco, e_true, region=region)
obs = observations["111630"]
dataset = maker.run(dataset_empty, obs)
dataset_on_off = phase_bkg_maker.run(dataset, obs)
assert_allclose(dataset_on_off.acceptance, 0.1)
assert_allclose(dataset_on_off.acceptance_off, 0.3)
assert_allclose(dataset_on_off.counts.data.sum(), 28)
assert_allclose(dataset_on_off.counts_off.data.sum(), 57)
def test_run(observations, phase_bkg_maker):
maker = SpectrumDatasetMaker()
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")
pos = SkyCoord("08h35m20.65525s", "-45d10m35.1545s", frame="icrs")
radius = Angle(0.2, "deg")
region = SphericalCircleSkyRegion(pos, radius)
geom = RegionGeom.create(region=region, axes=[e_reco])
dataset_empty = SpectrumDataset.create(geom=geom, energy_axis_true=e_true)
obs = observations["111630"]
dataset = maker.run(dataset_empty, obs)
dataset_on_off = phase_bkg_maker.run(dataset, obs)
assert_allclose(dataset_on_off.acceptance, 0.1)
assert_allclose(dataset_on_off.acceptance_off, 0.3)
assert_allclose(dataset_on_off.counts.data.sum(), 28)
assert_allclose(dataset_on_off.counts_off.data.sum(), 57)
def setup(self):
self.region = SphericalCircleSkyRegion(center=SkyCoord(
10 * u.deg, 20 * u.deg),
radius=10 * u.deg)
# In[ ]: id_obs_vela = [111630] obs_list_vela = data_store.get_observations(id_obs_vela) print(obs_list_vela[0].events) # Now that we have our observation, let's select the events in 0.2° radius around the pulsar position. # In[ ]: pos_target = SkyCoord(ra=128.836 * u.deg, dec=-45.176 * u.deg, frame="icrs") on_radius = 0.2 * u.deg on_region = SphericalCircleSkyRegion(pos_target, on_radius) # Apply angular selection events_vela = obs_list_vela[0].events.select_region(on_region) print(events_vela) # Let's load the phases of the selected events in a dedicated array. # In[ ]: phases = events_vela.table["PHASE"] # Let's take a look at the first 10 phases phases[:10]
def select_observations(self, selection=None):
"""Select subset of observations.
Returns a new observation table representing the subset.
There are 3 main kinds of selection criteria, according to the
value of the **type** keyword in the **selection** dictionary:
- sky regions
- time intervals (min, max)
- intervals (min, max) on any other parameter present in the
observation table, that can be casted into an
`~astropy.units.Quantity` object
Allowed selection criteria are interpreted using the following
keywords in the **selection** dictionary under the **type** key.
- ``sky_circle`` is a circular region centered in the coordinate
marked by the **lon** and **lat** keywords, and radius **radius**;
uses `~gammapy.catalog.select_sky_circle`
- ``time_box`` is a 1D selection criterion acting on the observation
start time (**TSTART**); the interval is set via the
**time_range** keyword; uses
`~gammapy.data.ObservationTable.select_time_range`
- ``par_box`` is a 1D selection criterion acting on any
parameter defined in the observation table that can be casted
into an `~astropy.units.Quantity` object; the parameter name
and interval can be specified using the keywords **variable** and
**value_range** respectively; min = max selects exact
values of the parameter; uses
`~gammapy.data.ObservationTable.select_range`
In all cases, the selection can be inverted by activating the
**inverted** flag, in which case, the selection is applied to keep all
elements outside the selected range.
A few examples of selection criteria are given below.
Parameters
----------
selection : dict
Dictionary with a few keywords for applying selection cuts.
Returns
-------
obs_table : `~gammapy.data.ObservationTable`
Observation table after selection.
Examples
--------
>>> selection = dict(type='sky_circle', frame='galactic',
... lon=Angle(0, 'deg'),
... lat=Angle(0, 'deg'),
... radius=Angle(5, 'deg'),
... border=Angle(2, 'deg'))
>>> selected_obs_table = obs_table.select_observations(selection)
>>> selection = dict(type='time_box',
... time_range=Time(['2012-01-01T01:00:00', '2012-01-01T02:00:00']))
>>> selected_obs_table = obs_table.select_observations(selection)
>>> selection = dict(type='par_box', variable='ALT',
... value_range=Angle([60., 70.], 'deg'))
>>> selected_obs_table = obs_table.select_observations(selection)
>>> selection = dict(type='par_box', variable='OBS_ID',
... value_range=[2, 5])
>>> selected_obs_table = obs_table.select_observations(selection)
>>> selection = dict(type='par_box', variable='N_TELS',
... value_range=[4, 4])
>>> selected_obs_table = obs_table.select_observations(selection)
"""
if "inverted" not in selection:
selection["inverted"] = False
if selection["type"] == "sky_circle":
lon = Angle(selection["lon"], "deg")
lat = Angle(selection["lat"], "deg")
radius = Angle(selection["radius"])
border = Angle(selection["border"])
region = SphericalCircleSkyRegion(
center=SkyCoord(lon, lat, frame=selection["frame"]),
radius=radius + border,
)
mask = region.contains(self.pointing_radec)
if selection["inverted"]:
mask = np.invert(mask)
return self[mask]
elif selection["type"] == "time_box":
return self.select_time_range("TSTART", selection["time_range"],
selection["inverted"])
elif selection["type"] == "par_box":
return self.select_range(selection["variable"],
selection["value_range"],
selection["inverted"])
else:
raise ValueError(f"Invalid selection type: {selection['type']}")
def on_region():
"""Example on_region for testing."""
pos = SkyCoord("08h35m20.65525s", "-45d10m35.1545s", frame="icrs")
radius = Angle(0.2, "deg")
return SphericalCircleSkyRegion(pos, radius)
events_3fhl.galactic
# events_3fhl.radec
# In[ ]:
events_3fhl.time
# In addition `EventList` provides convenience methods to filter the event lists. One possible use case is to find the highest energy event within a radius of 0.5 deg around the vela position:
# In[ ]:
# select all events within a radius of 0.5 deg around center
from gammapy.utils.regions import SphericalCircleSkyRegion
region = SphericalCircleSkyRegion(center, radius=0.5 * u.deg)
events_gc_3fhl = events_3fhl.select_region(region)
# sort events by energy
events_gc_3fhl.table.sort("ENERGY")
# and show highest energy photon
events_gc_3fhl.energy[-1].to("GeV")
# ### Exercises
#
# * Make a counts energy spectrum for the galactic center region, within a radius of 10 deg.
# In[ ]:
# ## Source catalogs
