def from_eventlist(cls, event_list, bins):
"""Create CountsSpectrum from fits 'EVENTS' extension (`CountsSpectrum`).
Subsets of the event list should be chosen via the appropriate methods
in `~gammapy.data.EventList`.
Parameters
----------
event_list : `~astropy.io.fits.BinTableHDU, `gammapy.data.EventListDataSet`,
`gammapy.data.EventList`, str (filename)
bins : `gammapy.spectrum.energy.EnergyBounds`
Energy bin edges
"""
if isinstance(event_list, fits.BinTableHDU):
event_list = EventList.read(event_list)
elif isinstance(event_list, EventListDataset):
event_list = event_list.event_list
elif isinstance(event_list, str):
event_list = EventList.read(event_list, hdu='EVENTS')
energy = Energy(event_list.energy).to(bins.unit)
val, dummy = np.histogram(energy, bins.value)
livetime = event_list.observation_live_time_duration
return cls(val, bins, livetime)
def test_write(self):
# Without GTI
self.events.write("test.fits", overwrite=True)
read_again = EventList.read("test.fits")
# the meta dictionaries match because the input one
# already has the EXTNAME keyword
assert self.events.table.meta == read_again.table.meta
assert (self.events.table == read_again.table).all()
dummy_events = EventList(Table())
dummy_events.write("test.fits", overwrite=True)
read_again = EventList.read("test.fits")
assert read_again.table.meta['EXTNAME'] == "EVENTS"
assert read_again.table.meta['HDUCLASS'] == "GADF"
assert read_again.table.meta['HDUCLAS1'] == "EVENTS"
# With GTI
gti = GTI.read(
"$GAMMAPY_DATA/hess-dl3-dr1/data/hess_dl3_dr1_obs_id_020136.fits.gz"
)
self.events.write("test.fits", overwrite=True, gti=gti)
read_again_ev = EventList.read("test.fits")
read_again_gti = GTI.read("test.fits")
assert self.events.table.meta == read_again_ev.table.meta
assert (self.events.table == read_again_ev.table).all()
assert gti.table.meta == read_again_gti.table.meta
assert (gti.table == read_again_gti.table).all()
# test that it won't work if gti is not a GTI
with pytest.raises(TypeError):
self.events.write("test.fits", overwrite=True, gti=gti.table)
# test that it won't work if format is not "gadf"
with pytest.raises(ValueError):
self.events.write("test.fits", overwrite=True, format='something')
# test that it won't work if the basic headers are wrong
with pytest.raises(ValueError):
dummy_events = EventList(Table())
dummy_events.table.meta['HDUCLAS1'] = 'response'
dummy_events.write("test.fits", overwrite=True)
with pytest.raises(ValueError):
dummy_events = EventList(Table())
dummy_events.table.meta['HDUCLASS'] = "ogip"
dummy_events.write("test.fits", overwrite=True)
# test that it works when the srings are right but lowercase
dummy_events = EventList(Table())
dummy_events.table.meta['HDUCLASS'] = "gadf"
dummy_events.table.meta['HDUCLAS1'] = "events"
dummy_events.write("test.fits", overwrite=True)
def load(self):
"""Load HDU as appropriate class.
TODO: this should probably go via an extensible registry.
"""
from gammapy.irf import IRF_REGISTRY
hdu_class = self.hdu_class
filename = self.path()
hdu = self.hdu_name
if hdu_class == "events":
from gammapy.data import EventList
return EventList.read(filename, hdu=hdu)
elif hdu_class == "gti":
from gammapy.data import GTI
return GTI.read(filename, hdu=hdu)
elif hdu_class == "map":
from gammapy.maps import Map
return Map.read(filename, hdu=hdu, format=self.format)
else:
cls = IRF_REGISTRY.get_cls(hdu_class)
return cls.read(filename, hdu=hdu)
def main(input_files, verbose, output):
setup_logging(verbose=verbose)
eventlist_list = []
for f in input_files:
eventlist_list.append(EventList.read(f))
events = eventlist_list[0]
for e in eventlist_list[1:]:
events.stack(e)
figures = []
figures.append(plt.figure())
ax = figures[-1].add_subplot(1, 1, 1)
events.plot_energy(ax=ax)
figures.append(plt.figure())
ax = figures[-1].add_subplot(1, 1, 1)
events.plot_energy_offset(ax=ax)
figures.append(plt.figure())
ax = figures[-1].add_subplot(1, 1, 1)
events.plot_offset2_distribution(ax=ax)
figures.append(plt.figure())
ax = figures[-1].add_subplot(1, 1, 1)
events.plot_time(ax=ax)
if output is None:
plt.show()
else:
with PdfPages(output) as pdf:
for fig in figures:
fig.tight_layout(pad=0, h_pad=1.08, w_pad=1.08)
pdf.savefig(fig)
def extract_spectra_fermi(target_position, on_radius):
"""Extract 1d spectra for Fermi-LAT"""
log.info("Extracting 1d spectra for Fermi-LAT")
events = EventList.read("data/fermi/events.fits.gz")
exposure = HpxNDMap.read("data/fermi/exposure_cube.fits.gz")
psf = EnergyDependentTablePSF.read("data/fermi/psf.fits.gz")
valid_range = (config.energy_bins >= 30 * u.GeV) * (config.energy_bins <=
2 * u.TeV)
energy = config.energy_bins[valid_range]
bkg_estimate = ring_background_estimate(
pos=target_position,
on_radius=on_radius,
inner_radius=1 * u.deg,
outer_radius=2 * u.deg,
events=events,
)
extract = SpectrumExtractionFermi1D(
events=events,
exposure=exposure,
psf=psf,
bkg_estimate=bkg_estimate,
target_position=target_position,
on_radius=on_radius,
energy=energy,
)
obs = extract.run()
path = "results/spectra/fermi"
log.info(f"Writing to {path}")
obs.write(path, use_sherpa=True, overwrite=True)
def test_region_nd_map_fill_events(region_map):
filename = "$GAMMAPY_DATA/hess-dl3-dr1/data/hess_dl3_dr1_obs_id_023523.fits.gz"
events = EventList.read(filename)
region_map = Map.from_geom(region_map.geom)
region_map.fill_events(events)
assert_allclose(region_map.data.sum(), 665)
def extract_spectra_fermi(target_position, on_radius):
"""Extract 1d spectra for Fermi-LAT"""
log.info("Extracting 1d spectra for Fermi-LAT")
events = EventList.read("data/fermi/events.fits.gz")
exposure = HpxNDMap.read("data/fermi/exposure_cube.fits.gz")
psf = EnergyDependentTablePSF.read("data/fermi/psf.fits.gz")
emin, emax, dex = 0.03, 2, 0.1
num = int(np.log10(emax / emin) / dex)
energy = np.logspace(start=np.log10(emin), stop=np.log10(emax),
num=num) * u.TeV
bkg_estimate = fermi_ring_background_extract(events, target_position,
on_radius)
extract = SpectrumExtractionFermi1D(
events=events,
exposure=exposure,
psf=psf,
bkg_estimate=bkg_estimate,
target_position=target_position,
on_radius=on_radius,
energy=energy,
containment_correction=True,
)
obs = extract.run()
path = f"{config.repo_path}/results/spectra/fermi"
log.info(f"Writing to {path}")
obs.write(path, use_sherpa=True, overwrite=True)
def __init__(self,
evt_file="$JOINT_CRAB/data/fermi/events.fits.gz",
exp_file="$JOINT_CRAB/data/fermi/exposure_cube.fits.gz",
psf_file="$JOINT_CRAB/data/fermi/psf.fits.gz",
max_psf_radius='0.5 deg'):
# Read data
self.events = EventList.read(evt_file)
self.exposure = HpxNDMap.read(exp_file)
self.exposure.unit = u.Unit('cm2s') # no unit stored on map...
self.psf = EnergyDependentTablePSF.read(psf_file)
def __init__(
self,
evt_file="../data/joint-crab/fermi/events.fits.gz",
exp_file="../data/joint-crab/fermi/exposure_cube.fits.gz",
psf_file="../data/joint-crab/fermi/psf.fits.gz",
):
# Read data
self.events = EventList.read(evt_file)
self.exposure = HpxNDMap.read(exp_file)
self.exposure.unit = u.Unit("cm2s") # no unit stored on map...
self.psf = PSFMap.read(psf_file, format="gtpsf")
def read_dataset(filename_dataset, filename_model, obs_id):
log.info(f"Reading {filename_dataset}")
dataset = MapDataset.read(filename_dataset)
filename_events = get_filename_events(filename_dataset, filename_model, obs_id)
log.info(f"Reading {filename_events}")
events = EventList.read(filename_events)
counts = Map.from_geom(WCS_GEOM)
counts.fill_events(events)
dataset.counts = counts
return dataset
def __init__(
self,
evt_file="../data/joint-crab/fermi/events.fits.gz",
exp_file="../data/joint-crab/fermi/exposure_cube.fits.gz",
psf_file="../data/joint-crab/fermi/psf.fits.gz",
max_psf_radius="0.5 deg",
):
# Read data
self.events = EventList.read(evt_file)
self.exposure = HpxNDMap.read(exp_file)
self.exposure.unit = u.Unit("cm2s") # no unit stored on map...
self.psf = EnergyDependentTablePSF.read(psf_file)
def image_bin(event_file,
reference_file,
out_file,
overwrite):
"""Bin events into an image."""
log.info('Reading {}'.format(event_file))
events = EventList.read(event_file)
reference_image = fits.open(reference_file)[0]
out_image = bin_events_in_image(events, reference_image)
log.info('Writing {}'.format(out_file))
out_image.writeto(out_file, clobber=overwrite)
def load(self):
"""Load HDU as appropriate class.
TODO: this should probably go via an extensible registry.
"""
hdu_class = self.hdu_class
filename = self.path()
hdu = self.hdu_name
if hdu_class == "events":
from gammapy.data import EventList
return EventList.read(filename, hdu=hdu)
elif hdu_class == "gti":
from gammapy.data import GTI
return GTI.read(filename, hdu=hdu)
elif hdu_class == "aeff_2d":
from gammapy.irf import EffectiveAreaTable2D
return EffectiveAreaTable2D.read(filename, hdu=hdu)
elif hdu_class == "edisp_2d":
from gammapy.irf import EnergyDispersion2D
return EnergyDispersion2D.read(filename, hdu=hdu)
elif hdu_class == "psf_table":
from gammapy.irf import PSF3D
return PSF3D.read(filename, hdu=hdu)
elif hdu_class == "psf_3gauss":
from gammapy.irf import EnergyDependentMultiGaussPSF
return EnergyDependentMultiGaussPSF.read(filename, hdu=hdu)
elif hdu_class == "psf_king":
from gammapy.irf import PSFKing
return PSFKing.read(filename, hdu=hdu)
elif hdu_class == "bkg_2d":
from gammapy.irf import Background2D
return Background2D.read(filename, hdu=hdu)
elif hdu_class == "bkg_3d":
from gammapy.irf import Background3D
return Background3D.read(filename, hdu=hdu)
else:
raise ValueError(f"Invalid hdu_class: {hdu_class}")
def make_counts_image(energy_band):
"""Apply event selections and bin event positions into a counts image."""
event_list = EventList.read(TOTAL_EVENTS_FILE)
n_events = len(event_list)
print('Number of events: {}'.format(n_events))
print('Applying energy band selection: {}'.format(energy_band))
event_list = event_list.select_energy(energy_band)
n_events_selected = len(event_list)
fraction = 100 * n_events_selected / n_events
print('Number of events: {}. Fraction: {:.1f}%'.format(n_events_selected, fraction))
print('Filling counts image ...')
header = fits.getheader(REF_IMAGE)
image = event_list.fill_counts_header(header)
print('Writing {}'.format(COUNTS_IMAGE))
image.writeto(COUNTS_IMAGE, clobber=True)
def cli_image_bin(event_file, reference_file, out_file, overwrite):
"""Bin events into an image.
You have to give the event, reference and out FITS filename.
"""
log.info("Executing cli_image_bin")
log.info("Reading {}".format(event_file))
events = EventList.read(event_file)
log.info("Reading {}".format(reference_file))
m_ref = Map.read(reference_file)
counts_map = Map.from_geom(m_ref.geom)
fill_map_counts(counts_map, events)
log.info("Writing {}".format(out_file))
counts_map.write(out_file, overwrite=overwrite)
from gammapy.data import EventList
from gammapy.irf import EnergyDependentTablePSF, EnergyDispersion
from gammapy.maps import Map, MapAxis, WcsNDMap, WcsGeom
from gammapy.spectrum.models import TableModel, PowerLaw
from gammapy.image.models import SkyPointSource, SkyDiffuseConstant
from gammapy.cube.models import SkyModel, SkyDiffuseCube, BackgroundModel
from gammapy.cube import MapDataset, PSFKernel
from gammapy.utils.fitting import Fit
# ## Events
#
# To load up the Fermi-LAT event list, use the [gammapy.data.EventList](https://docs.gammapy.org/0.12/api/gammapy.data.EventList.html) class:
# In[ ]:
events = EventList.read(
"$GAMMAPY_DATA/fermi_3fhl/fermi_3fhl_events_selected.fits.gz")
print(events)
# The event data is stored in a [astropy.table.Table](http://docs.astropy.org/en/stable/api/astropy.table.Table.html) object. In case of the Fermi-LAT event list this contains all the additional information on positon, zenith angle, earth azimuth angle, event class, event type etc.
# In[ ]:
events.table.colnames
# In[ ]:
events.table[:5][["ENERGY", "RA", "DEC"]]
# In[ ]:
print(events.time[0].iso)
def setup(self):
filename = (
"$GAMMAPY_DATA/tests/unbundled/hess/run_0023037_hard_eventlist.fits.gz"
)
self.events = EventList.read(filename)
def make_healpix_image(events, nside, sigma):
theta = np.deg2rad(90 - events['B'])
phi = np.deg2rad(events['L'])
bins = np.arange(hp.nside2npix(nside) + 1) - 0.5
data = hp.ang2pix(nside, theta, phi)
counts, _ = np.histogram(data, bins)
counts = hp.smoothing(counts, sigma=sigma)
return counts
if __name__ == '__main__':
filename = '/Users/deil/code/fhee/data/2fhl_events.fits.gz'
events = EventList.read(filename)
events.meta['EUNIT'] = 'GeV'
counts = make_healpix_image(events, nside=256, sigma=0.001)
filename = '2fhl_counts_healpix.fits.gz'
print('Writing {}'.format(filename))
hp.write_map(filename, m=counts)
# import matplotlib.pyplot as plt
# hp.mollview(counts, title="Mollview image RING")
# plt.show()
# m = np.arange(hp.nside2npix(NSIDE))
# zeros = np.zeros(hp.nside2npix(NSIDE))
# hp.mollview(m, title="Mollview image RING")
# print (len(counts) == hp.nside2npix(NSIDE))
# ## EVENT data
#
# First, the EVENT data (RA, DEC, ENERGY, TIME of each photon or hadronic background event) is in the `data` folder, with one observation per file. The "baseline" refers to the assumed CTA array that was used to simulate the observations. The number in the filename is the observation identifier `OBS_ID` of the observation. Observations are ~ 30 minutes, pointing at a fixed location on the sky.
# In[ ]:
get_ipython().system('ls -1 $GAMMAPY_DATA/cta-1dc/data/baseline/gps')
# Let's open up the first event list using the Gammapy `EventList` class, which contains the ``EVENTS`` table data via the ``table`` attribute as an Astropy `Table` object.
# In[ ]:
from gammapy.data import EventList
path = "$GAMMAPY_DATA/cta-1dc/data/baseline/gps/gps_baseline_110380.fits"
events = EventList.read(path)
# In[ ]:
type(events)
# In[ ]:
type(events.table)
# In[ ]:
# First event (using [] for "indexing")
events.table[0]
# In[ ]:
# In[8]:
get_ipython().system('ls $CTADATA/data/baseline/gps | head -n3')
# In[9]:
# There's 3270 observations and 11 GB of event data for the gps dataset
get_ipython().system('ls $CTADATA/data/baseline/gps | wc -l')
get_ipython().system('du -hs $CTADATA/data/baseline/gps')
# Let's open up the first event list using the Gammapy `EventList` class, which contains the ``EVENTS`` table data via the ``table`` attribute as an Astropy `Table` object.
# In[10]:
from gammapy.data import EventList
events = EventList.read('$CTADATA/data/baseline/gps/gps_baseline_110000.fits')
print(type(events))
print(type(events.table))
# In[11]:
# First event (using [] for "indexing")
events.table[0]
# In[12]:
# First few events (using [] for "slicing")
events.table[:2]
# In[13]:
# coding: utf-8 from gammapy.data import EventList filename = '$GAMMAPY_EXTRA/test_datasets/unbundled/hess/run_0023037_hard_eventlist.fits.gz' events=EventList.read(filename) events filename = '$GAMMAPY_EXTRA/datasets/fermi_2fhl/2fhl_events.fits.gz' events.observation_live_time_duration print(events.observation_live_time_duration) print(events.observation_dead_time_fraction) print(events.observation_time_duration) events.observation_time_duration * events.observation_dead_time_fraction 1577.0 s - 56.39856698736619 s 1577.0 - 56.39856698736619 1.0-0.0357632003725 0.9642367996275 * events.observation_time_duration
#
# * Read event lists from FITS files
# * Access and work with the `EventList` attributes such as `.table` and `.energy`
# * Filter events lists using convenience methods
#
# Let's start with the import from the [gammapy.data](http://docs.gammapy.org/dev/data/index.html) submodule:
# In[17]:
from gammapy.data import EventList
# Very similar to the `SkyImage` class an event list can be created, by passing a filename to the `.read()` method:
# In[18]:
events_2fhl = EventList.read(
'$GAMMAPY_EXTRA/datasets/fermi_2fhl/2fhl_events.fits.gz')
# This time the actual data is stored as an [astropy.table.Table](http://docs.astropy.org/en/stable/api/astropy.table.Table.html#astropy.table.Table) object. It can be accessed with `.table` attribute:
# In[19]:
events_2fhl.table
# Let's try to find the total number of events contained int the list. This doesn't work:
#
# In[20]:
print('Total number of events: {}'.format(len(events_2fhl.table)))
# Because Gammapy objects don't redefine properties, that are accessible from the underlying Astropy of Numpy data object.
def __init__(self, selection="short", savefig=True):
self.datadir = "$GAMMAPY_DATA"
self.resdir = "./res"
self.savefig = savefig
# event list
self.events = EventList.read(
self.datadir + "/fermi_3fhl/fermi_3fhl_events_selected.fits.gz")
# psf
self.psf = EnergyDependentTablePSF.read(
self.datadir + "/fermi_3fhl/fermi_3fhl_psf_gc.fits.gz")
# mask margin
psf_r99max = self.psf.containment_radius(10 * u.GeV, fraction=0.99)
self.psf_margin = np.ceil(psf_r99max.value[0] * 10) / 10.0
# energies
self.dlb = 1 / 8.0
El_extra = 10**np.arange(3.8, 6.51, 0.1) # MeV
self.logEc_extra = (np.log10(El_extra)[1:] +
np.log10(El_extra)[:-1]) / 2.0
self.El_flux = [10.0, 20.0, 50.0, 150.0, 500.0, 2000.0]
El_fit = 10**np.arange(1, 3.31, 0.1)
self.energy_axis = MapAxis.from_edges(El_fit,
name="energy",
unit="GeV",
interp="log")
# background iso
infile = Path(self.datadir + "/fermi_3fhl/iso_P8R2_SOURCE_V6_v06.txt")
outfile = Path(self.resdir + "/iso_P8R2_SOURCE_V6_v06_extra.txt")
self.model_iso = extrapolate_iso(infile, outfile, self.logEc_extra)
# regions selection
file3fhl = self.datadir + "/catalogs/fermi/gll_psch_v13.fit.gz"
self.FHL3 = SourceCatalog3FHL(file3fhl)
hdulist = fits.open(make_path(file3fhl))
self.ROIs = hdulist["ROIs"].data
Scat = hdulist[1].data
order = np.argsort(Scat.Signif_Avg)[::-1]
ROIs_ord = Scat.ROI_num[order]
if selection == "short":
self.ROIs_sel = [430, 135, 118, 212, 277, 42, 272, 495]
# Crab, Vela, high-lat, +some fast regions
elif selection == "long":
# get small regions with few sources among the most significant
indexes = np.unique(ROIs_ord, return_index=True)[1]
ROIs_ord = [ROIs_ord[index] for index in sorted(indexes)]
self.ROIs_sel = [
kr for kr in ROIs_ord
if sum(Scat.ROI_num == kr) <= 4 and self.ROIs.RADIUS[kr] < 6
][:100]
elif selection == "debug":
self.ROIs_sel = [135] # Vela region
# fit options
self.optimize_opts = {
"backend": "minuit",
"tol": 10.0,
"strategy": 2,
}
# calculate flux points only for sources significant above this threshold
self.sig_cut = 8.0
# diagnostics stored to produce plots and outputs
self.diags = {
"message": [],
"stat": [],
"params": {},
"errel": {},
"compatibility": {},
"cat_fp_sel": [],
}
self.diags["errel"]["flux_points"] = []
keys = [
"PL_tags",
"PL_index",
"PL_amplitude",
"LP_tags",
"LP_alpha",
"LP_beta",
"LP_amplitude",
]
for key in keys:
self.diags["params"][key] = []
def setup_class(self):
self.events = EventList.read(
"$GAMMAPY_DATA/fermi-3fhl-gc/fermi-3fhl-gc-events.fits.gz")
"""Example of how to create an ObservationCTA from CTA's 1DC"""
from gammapy.data import ObservationCTA, EventList, GTI
from gammapy.irf import (
EnergyDependentMultiGaussPSF,
EffectiveAreaTable2D,
EnergyDispersion2D,
Background3D,
)
filename = "$GAMMAPY_DATA/cta-1dc/data/baseline/gps/gps_baseline_110380.fits"
event_list = EventList.read(filename)
gti = GTI.read(filename)
filename = "$GAMMAPY_DATA/cta-1dc/caldb/data/cta/1dc/bcf/South_z20_50h/irf_file.fits"
aeff = EffectiveAreaTable2D.read(filename)
bkg = Background3D.read(filename)
edisp = EnergyDispersion2D.read(filename, hdu="Energy Dispersion")
psf = EnergyDependentMultiGaussPSF.read(filename, hdu="Point Spread Function")
obs = ObservationCTA(
obs_id=event_list.table.meta["OBS_ID"],
events=event_list,
gti=gti,
psf=psf,
aeff=aeff,
edisp=edisp,
bkg=bkg,
pointing_radec=event_list.pointing_radec,
observation_live_time_duration=event_list.observation_live_time_duration,
observation_dead_time_fraction=event_list.observation_dead_time_fraction,
)
# The quick-look `events.peek()` plot below shows that CTA has a field of view of a few degrees, and two energy thresholds, one significantly below 100 GeV where the CTA large-size telescopes (LSTs) detect events, and a second one near 100 GeV where teh mid-sized telescopes (MSTs) start to detect events.
#
# Note that most events are "hadronic background" due to cosmic ray showers in the atmosphere that pass the gamma-hadron selection cuts for this analysis configuration. Since this is simulated data, column `MC_ID` is available that gives an emission component identifier code, and the EVENTS header in `events.table.meta` can be used to look up which `MC_ID` corresponds to which emission component.
# In[ ]:
events = observation.events
events
# In[ ]:
events = EventList.read(
"$GAMMAPY_DATA/cta-1dc/data/baseline/gps/gps_baseline_110380.fits"
)
events
# In[ ]:
events.table[:5]
# In[ ]:
events.peek()
def __init__(self, selection="short", savefig=True):
log.info("Executing __init__()")
self.resdir = BASE_PATH / "results"
self.savefig = savefig
# event list
self.events = EventList.read(
"$GAMMAPY_DATA/fermi_3fhl/fermi_3fhl_events_selected.fits.gz"
)
# psf
self.psf = EnergyDependentTablePSF.read(
"$GAMMAPY_DATA/fermi_3fhl/fermi_3fhl_psf_gc.fits.gz"
)
# mask margin
psf_r99max = self.psf.containment_radius(10 * u.GeV, fraction=0.99)
self.psf_margin = np.ceil(psf_r99max.value[0] * 10) / 10.0
# energies
self.El_flux = [10.0, 20.0, 50.0, 150.0, 500.0, 2000.0]
El_fit = 10 ** np.arange(1, 3.31, 0.1)
self.energy_axis = MapAxis.from_edges(
El_fit, name="energy", unit="GeV", interp="log"
)
# iso norm=0.92 see paper appendix A
self.model_iso = create_fermi_isotropic_diffuse_model(
filename="data/iso_P8R2_SOURCE_V6_v06_extrapolated.txt",
norm=0.92,
interp_kwargs={"fill_value": None},
)
# regions selection
file3fhl = "$GAMMAPY_DATA/catalogs/fermi/gll_psch_v13.fit.gz"
self.FHL3 = SourceCatalog3FHL(file3fhl)
hdulist = fits.open(make_path(file3fhl))
self.ROIs = hdulist["ROIs"].data
Scat = hdulist[1].data
order = np.argsort(Scat.Signif_Avg)[::-1]
ROIs_ord = Scat.ROI_num[order]
if selection == "short":
self.ROIs_sel = [430, 135, 118, 212, 277, 42, 272, 495]
# Crab, Vela, high-lat, +some fast regions
elif selection == "long":
# get small regions with few sources among the most significant
indexes = np.unique(ROIs_ord, return_index=True)[1]
ROIs_ord = [ROIs_ord[index] for index in sorted(indexes)]
self.ROIs_sel = [
kr
for kr in ROIs_ord
if sum(Scat.ROI_num == kr) <= 4 and self.ROIs.RADIUS[kr] < 6
][:100]
elif selection == "debug":
self.ROIs_sel = [135] # Vela region
else:
raise ValueError(f"Invalid selection: {selection!r}")
# fit options
self.optimize_opts = {
"backend": "minuit",
"optimize_opts": {"tol": 10.0, "strategy": 2},
}
# calculate flux points only for sources significant above this threshold
self.sig_cut = 8.0
# diagnostics stored to produce plots and outputs
self.diags = {
"message": [],
"stat": [],
"params": {},
"errel": {},
"compatibility": {},
"cat_fp_sel": [],
}
self.diags["errel"]["flux_points"] = []
keys = [
"PL_tags",
"PL_index",
"PL_amplitude",
"LP_tags",
"LP_alpha",
"LP_beta",
"LP_amplitude",
]
for key in keys:
self.diags["params"][key] = []
def counts_skyimage_2fhl(**kwargs):
log.info('Computing counts map.')
events = EventList.read('2fhl_events.fits.gz')
counts = SkyMap.empty('Counts', **kwargs)
counts.fill(events)
return counts
def setup_class(self):
self.events = EventList.read(
"$GAMMAPY_DATA/hess-dl3-dr1/data/hess_dl3_dr1_obs_id_020136.fits.gz"
)
def counts_skyimage_2fhl(**kwargs):
log.info("Computing counts map.")
events = EventList.read("2fhl_events.fits.gz")
counts = SkyMap.empty("Counts", **kwargs)
counts.fill(events)
return counts
from gammapy.maps import Map, MapAxis, WcsNDMap, WcsGeom
from gammapy.spectrum.models import TableModel, PowerLaw, ConstantModel
from gammapy.image.models import SkyPointSource, SkyDiffuseConstant
from gammapy.cube.models import SkyModel, SkyDiffuseCube
from gammapy.cube import MapEvaluator, MapFit, PSFKernel
# ## Events
#
# To load up the Fermi-LAT event list, use the [gammapy.data.EventList](http://docs.gammapy.org/dev/api/gammapy.data.EventList.html) class:
# In[ ]:
events = EventList.read(
"$GAMMAPY_FERMI_LAT_DATA/3fhl/allsky/fermi_3fhl_events_selected.fits.gz"
)
print(events)
# The event data is stored in a [astropy.table.Table](http://docs.astropy.org/en/stable/api/astropy.table.Table.html) object. In case of the Fermi-LAT event list this contains all the additional information on positon, zenith angle, earth azimuth angle, event class, event type etc.
# In[ ]:
events.table.colnames
# In[ ]:
def setup(self):
self.event_list = EventList.read(
"$GAMMAPY_DATA/cta-1dc/data/baseline/gps/gps_baseline_111140.fits")
#
# * Read event lists from FITS files
# * Access and work with the `EventList` attributes such as `.table` and `.energy`
# * Filter events lists using convenience methods
#
# Let's start with the import from the [gammapy.data](http://docs.gammapy.org/dev/data/index.html) submodule:
# In[ ]:
from gammapy.data import EventList
# Very similar to the sky map class an event list can be created, by passing a filename to the `.read()` method:
# In[ ]:
events_2fhl = EventList.read("$GAMMAPY_DATA/fermi_2fhl/2fhl_events.fits.gz")
# This time the actual data is stored as an [astropy.table.Table](http://docs.astropy.org/en/stable/api/astropy.table.Table.html#astropy.table.Table) object. It can be accessed with `.table` attribute:
# In[ ]:
events_2fhl.table
# Let's try to find the total number of events contained int the list. This doesn't work:
#
# In[ ]:
print("Total number of events: {}".format(len(events_2fhl.table)))
# Because Gammapy objects don't redefine properties, that are accessible from the underlying Astropy of Numpy data object.
#
# * Read event lists from FITS files
# * Access and work with the `EventList` attributes such as `.table` and `.energy`
# * Filter events lists using convenience methods
#
# Let's start with the import from the `~gammapy.data` submodule:
# In[ ]:
from gammapy.data import EventList
# Very similar to the sky map class an event list can be created, by passing a filename to the `~gammapy.data.EventList.read()` method:
# In[ ]:
events_3fhl = EventList.read(
"$GAMMAPY_DATA/fermi-3fhl-gc/fermi-3fhl-gc-events.fits.gz")
# This time the actual data is stored as an [astropy.table.Table](http://docs.astropy.org/en/stable/api/astropy.table.Table.html) object. It can be accessed with `.table` attribute:
# In[ ]:
events_3fhl.table
# You can do *len* over event_3fhl.table to find the total number of events.
# In[ ]:
len(events_3fhl.table)
# And we can access any other attribute of the `Table` object as well:
"""Make a counts image with Gammapy."""
from gammapy.data import EventList
from gammapy.image import SkyImage
events = EventList.read('events.fits')
image = SkyImage.empty(
nxpix=400,
nypix=400,
binsz=0.02,
xref=83.6,
yref=22.0,
coordsys='CEL',
proj='TAN',
)
image.fill_events(events)
image.write('counts.fits')
