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 test_gti_write(tmp_path):
gti = make_gti({"START": [5, 6, 1, 2], "STOP": [8, 7, 3, 4]})
gti.write(tmp_path / "tmp.fits")
new_gti = GTI.read(tmp_path / "tmp.fits")
assert_time_allclose(new_gti.time_start, gti.time_start)
assert_time_allclose(new_gti.time_stop, gti.time_stop)
assert new_gti.table.meta["MJDREFF"] == gti.table.meta["MJDREFF"]
def test_from_gti_time_axis():
filename = "$GAMMAPY_DATA/hess-dl3-dr1/data/hess_dl3_dr1_obs_id_020136.fits.gz"
filename = make_path(filename)
gti = GTI.read(filename)
axis = TimeMapAxis.from_gti(gti)
expected = Time(53090.123451203704, format="mjd", scale="tt")
assert_time_allclose(axis.time_min[0], expected)
assert axis.nbin == 1
def test_gti_write(tmpdir):
gti = make_gti({"START": [5, 6, 1, 2], "STOP": [8, 7, 3, 4]})
filename = tmpdir / "test.fits"
gti.write(filename, overwrite=True)
new_gti = GTI.read(filename)
assert_time_allclose(new_gti.time_start, gti.time_start)
assert_time_allclose(new_gti.time_stop, gti.time_stop)
assert new_gti.table.meta["MJDREFF"] == gti.table.meta["MJDREFF"]
def test_select_time(time_interval, expected_length, expected_times):
gti = GTI.read("$GAMMAPY_DATA/fermi-3fhl-gc/fermi-3fhl-gc-events.fits.gz")
gti_selected = gti.select_time(time_interval)
assert len(gti_selected.table) == expected_length
if expected_length != 0:
expected_times.format = "mjd"
assert_time_allclose(gti_selected.time_start[0], expected_times[0])
assert_time_allclose(gti_selected.time_stop[-1], expected_times[1])
def test_gti_fermi():
gti = GTI.read("$GAMMAPY_DATA/fermi-3fhl-gc/fermi-3fhl-gc-events.fits.gz")
assert "GTI" in str(gti)
assert len(gti.table) == 39042
assert gti.time_delta[0].unit == "s"
assert_allclose(gti.time_delta[0].value, 651.598893)
assert_allclose(gti.time_sum.value, 1.831396e08)
expected = Time(54682.65603794185, format="mjd", scale="tt")
assert_time_allclose(gti.time_start[0], expected)
expected = Time(54682.66357959571, format="mjd", scale="tt")
assert_time_allclose(gti.time_stop[0], expected)
def test_gti_hess():
gti = GTI.read("$GAMMAPY_DATA/hess-dl3-dr1/data/hess_dl3_dr1_obs_id_020136.fits.gz")
assert "GTI" in str(gti)
assert len(gti.table) == 1
assert gti.time_delta[0].unit == "s"
assert_allclose(gti.time_delta[0].value, 1682)
assert_allclose(gti.time_sum.value, 1682)
expected = Time(53090.123451203704, format="mjd", scale="tt")
assert_time_allclose(gti.time_start[0], expected)
expected = Time(53090.14291879629, format="mjd", scale="tt")
assert_time_allclose(gti.time_stop[0], expected)
def test_gti_hess():
filename = "$GAMMAPY_DATA/tests/unbundled/hess/run_0023037_hard_eventlist.fits.gz"
gti = GTI.read(filename)
assert "GTI" in str(gti)
assert len(gti.table) == 1
assert gti.time_delta[0].unit == "s"
assert_allclose(gti.time_delta[0].value, 1568.00000)
assert_allclose(gti.time_sum.value, 1568.00000)
expected = Time(53292.00592592593, format="mjd", scale="tt")
assert_time_allclose(gti.time_start[0], expected)
expected = Time(53292.02407407408, format="mjd", scale="tt")
assert_time_allclose(gti.time_stop[0], expected)
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}")
"""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,
)