def test_lightcurve(self):
lc = self.source.lightcurve()
table = lc.to_table(format="lightcurve", sed_type="flux")
assert len(table) == 48
assert table.colnames == [
"time_min",
"time_max",
"e_ref",
"e_min",
"e_max",
"flux",
"flux_errp",
"flux_errn",
"flux_ul",
"is_ul",
]
expected = Time(54680.02313657408, format="mjd", scale="utc")
axis = lc.geom.axes["time"]
assert_time_allclose(axis.time_min[0].utc, expected)
expected = Time(54710.46295139, format="mjd", scale="utc")
assert_time_allclose(axis.time_max[0].utc, expected)
assert table["flux"].unit == "cm-2 s-1"
assert_allclose(table["flux"][0], 2.384e-06, rtol=1e-3)
assert table["flux_errp"].unit == "cm-2 s-1"
assert_allclose(table["flux_errp"][0], 8.071e-08, rtol=1e-3)
assert table["flux_errn"].unit == "cm-2 s-1"
assert_allclose(table["flux_errn"][0], 8.071e-08, rtol=1e-3)
def test_lightcurve(self):
lc = self.source.lightcurve
table = lc.table
assert len(table) == 48
assert table.colnames == [
"time_min",
"time_max",
"flux",
"flux_errp",
"flux_errn",
]
expected = Time(54680.02313657408, format="mjd", scale="utc")
assert_time_allclose(lc.time_min[0], expected)
expected = Time(54710.43824797454, format="mjd", scale="utc")
assert_time_allclose(lc.time_max[0], expected)
assert table["flux"].unit == "cm-2 s-1"
assert_allclose(table["flux"][0], 2.384e-06, rtol=1e-3)
assert table["flux_errp"].unit == "cm-2 s-1"
assert_allclose(table["flux_errp"][0], 8.071e-08, rtol=1e-3)
assert table["flux_errn"].unit == "cm-2 s-1"
assert_allclose(table["flux_errn"][0], 8.071e-08, rtol=1e-3)
def test_lightcurve(self):
lc = self.source.lightcurve
table = lc.table
assert len(table) == 8
assert table.colnames == [
"time_min",
"time_max",
"flux",
"flux_errp",
"flux_errn",
]
expected = Time(54682.655277777776, format="mjd", scale="utc")
assert_time_allclose(lc.time_min[0], expected)
expected = Time(55047.603239293836, format="mjd", scale="utc")
assert_time_allclose(lc.time_max[0], expected)
assert table["flux"].unit == "cm-2 s-1"
assert_allclose(table["flux"][0], 2.2122326e-06, rtol=1e-3)
assert table["flux_errp"].unit == "cm-2 s-1"
assert_allclose(table["flux_errp"][0], 2.3099371e-08, rtol=1e-3)
assert table["flux_errn"].unit == "cm-2 s-1"
assert_allclose(table["flux_errn"][0], 2.3099371e-08, rtol=1e-3)
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_gti_stack():
time_ref = Time("2010-01-01")
gti1 = make_gti({"START": [0, 2], "STOP": [1, 3]}, time_ref=time_ref)
gti2 = make_gti({"START": [4], "STOP": [5]}, time_ref=time_ref + 10 * u.s)
gti = gti1.stack(gti2)
assert_time_allclose(gti.time_ref, gti1.time_ref)
assert_allclose(gti.table["START"], [0, 2, 14])
assert_allclose(gti.table["STOP"], [1, 3, 15])
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_filter_gti(observation):
time_filter = Time([53090.125, 53090.130], format="mjd", scale="tt")
obs_filter = ObservationFilter(time_filter=time_filter)
gti = observation.gti
filtered_gti = obs_filter.filter_gti(gti)
assert isinstance(filtered_gti, GTI)
assert_time_allclose(filtered_gti.time_start, time_filter[0])
assert_time_allclose(filtered_gti.time_stop, time_filter[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_data_store_observation(data_store):
"""Test DataStoreObservation class"""
obs = data_store.obs(23523)
assert_time_allclose(obs.tstart, Time(53343.92234009259, scale="tt", format="mjd"))
assert_time_allclose(obs.tstop, Time(53343.94186555556, scale="tt", format="mjd"))
c = SkyCoord(83.63333129882812, 21.51444435119629, unit="deg")
assert_skycoord_allclose(obs.pointing_radec, c)
c = SkyCoord(22.481705, 41.38979, unit="deg")
assert_skycoord_allclose(obs.pointing_altaz, c)
c = SkyCoord(83.63333129882812, 22.01444435119629, unit="deg")
assert_skycoord_allclose(obs.target_radec, c)
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 test_lightcurve_dr1(self):
lc = self.source.lightcurve(interval="1-year")
table = lc.to_table(format="lightcurve", sed_type="flux")
assert len(table) == 8
assert table.colnames == [
"time_min",
"time_max",
"e_ref",
"e_min",
"e_max",
"flux",
"flux_errp",
"flux_errn",
"flux_ul",
"ts",
"sqrt_ts",
"is_ul",
]
axis = lc.geom.axes["time"]
expected = Time(54682.6552835, format="mjd", scale="utc")
assert_time_allclose(axis.time_min[0].utc, expected)
expected = Time(55045.30090278, format="mjd", scale="utc")
assert_time_allclose(axis.time_max[0].utc, expected)
assert table["flux"].unit == "cm-2 s-1"
assert_allclose(table["flux"][0], 2.2122326e-06, rtol=1e-3)
assert table["flux_errp"].unit == "cm-2 s-1"
assert_allclose(table["flux_errp"][0], 2.3099371e-08, rtol=1e-3)
assert table["flux_errn"].unit == "cm-2 s-1"
assert_allclose(table["flux_errn"][0], 2.3099371e-08, rtol=1e-3)
table = self.source.lightcurve(interval="2-month").to_table(
format="lightcurve", sed_type="flux"
)
assert len(table) == 48 # (12 month/year / 2month) * 8 years
assert table["flux"].unit == "cm-2 s-1"
assert_allclose(table["flux"][0], 2.238483e-6, rtol=1e-3)
assert table["flux_errp"].unit == "cm-2 s-1"
assert_allclose(table["flux_errp"][0], 4.437058e-8, rtol=1e-3)
assert table["flux_errn"].unit == "cm-2 s-1"
assert_allclose(table["flux_errn"][0], 4.437058e-8, rtol=1e-3)
def test_from_time_edges_time_axis():
t0 = Time("2020-03-19")
t_min = t0 + np.linspace(0, 10, 20) * u.d
t_max = t_min + 1 * u.h
axis = TimeMapAxis.from_time_edges(t_min, t_max)
axis_h = TimeMapAxis.from_time_edges(t_min, t_max, unit="h")
assert axis.nbin == 20
assert axis.name == "time"
assert_time_allclose(axis.reference_time, t0)
assert_allclose(axis.time_delta.to_value("min"), 60)
assert_allclose(axis.time_mid[0].mjd, 58927.020833333336)
assert_allclose(axis_h.time_delta.to_value("h"), 1)
assert_allclose(axis_h.time_mid[0].mjd, 58927.020833333336)
assert axis == axis_h
def test_to_from_ogip_files(self, tmp_path):
dataset = self.dataset.copy(name="test")
dataset.to_ogip_files(outdir=tmp_path)
newdataset = SpectrumDatasetOnOff.from_ogip_files(tmp_path / "pha_obstest.fits")
expected_regions = compound_region_to_list(self.off_counts.geom.region)
regions = compound_region_to_list(newdataset.counts_off.geom.region)
assert_allclose(self.on_counts.data, newdataset.counts.data)
assert_allclose(self.off_counts.data, newdataset.counts_off.data)
assert_allclose(self.edisp.pdf_matrix, newdataset.edisp.pdf_matrix)
assert_time_allclose(newdataset.gti.time_start, dataset.gti.time_start)
assert len(regions) == len(expected_regions)
assert regions[0].center.is_equivalent_frame(expected_regions[0].center)
assert_allclose(regions[1].angle, expected_regions[1].angle)
def test_observation_select_time(data_store, time_interval, expected_times):
obs = data_store.obs(23523)
new_obs = obs.select_time(time_interval)
if expected_times:
expected_times.format = "mjd"
assert np.all(
(new_obs.events.time >= expected_times[0])
& (new_obs.events.time < expected_times[1])
)
assert_time_allclose(new_obs.gti.time_start[0], expected_times[0], atol=0.01)
assert_time_allclose(new_obs.gti.time_stop[-1], expected_times[1], atol=0.01)
else:
assert len(new_obs.events.table) == 0
assert len(new_obs.gti.table) == 0
def test_observations_select_time(data_store, time_interval, expected_times,
expected_nr_of_obs):
obs_ids = data_store.obs_table["OBS_ID"][:8]
obss = data_store.get_observations(obs_ids)
new_obss = obss.select_time(time_interval)
assert len(new_obss) == expected_nr_of_obs
if expected_nr_of_obs > 0:
assert new_obss[0].events.time[0] >= expected_times[0]
assert new_obss[-1].events.time[-1] < expected_times[1]
assert_time_allclose(new_obss[0].gti.time_start[0],
expected_times[0],
atol=0.01)
assert_time_allclose(new_obss[-1].gti.time_stop[-1],
expected_times[1],
atol=0.01)
def test_to_from_ogip_files(self, tmp_path):
dataset = self.dataset.copy(name="test")
dataset.write(tmp_path / "test.fits")
newdataset = SpectrumDatasetOnOff.read(tmp_path / "test.fits")
expected_regions = compound_region_to_list(self.off_counts.geom.region)
regions = compound_region_to_list(newdataset.counts_off.geom.region)
assert newdataset.counts.meta["RESPFILE"] == "test_rmf.fits"
assert newdataset.counts.meta["BACKFILE"] == "test_bkg.fits"
assert newdataset.counts.meta["ANCRFILE"] == "test_arf.fits"
assert_allclose(self.on_counts.data, newdataset.counts.data)
assert_allclose(self.off_counts.data, newdataset.counts_off.data)
assert_allclose(self.edisp.edisp_map.data, newdataset.edisp.edisp_map.data)
assert_time_allclose(newdataset.gti.time_start, dataset.gti.time_start)
assert len(regions) == len(expected_regions)
assert regions[0].center.is_equivalent_frame(expected_regions[0].center)
assert_allclose(regions[1].angle, expected_regions[1].angle)
def test_to_from_ogip_files(self, tmp_path):
dataset = SpectrumDatasetOnOff(
counts=self.on_counts,
counts_off=self.off_counts,
aeff=self.aeff,
edisp=self.edisp,
livetime=self.livetime,
mask_safe=np.ones(self.on_counts.energy.nbin, dtype=bool),
acceptance=1,
acceptance_off=10,
name="test",
gti=self.gti,
)
dataset.to_ogip_files(outdir=tmp_path)
newdataset = SpectrumDatasetOnOff.from_ogip_files(tmp_path /
"pha_obstest.fits")
assert_allclose(self.on_counts.data, newdataset.counts.data)
assert_allclose(self.off_counts.data, newdataset.counts_off.data)
assert_allclose(self.edisp.pdf_matrix, newdataset.edisp.pdf_matrix)
assert_time_allclose(newdataset.gti.time_start, dataset.gti.time_start)
def test_create_gti():
date_start = Time("2012-01-01T00:30:00")
date_end = Time("2012-01-01T02:30:00")
random_state = np.random.RandomState(seed=0)
obs_table = make_test_observation_table(n_obs=1,
date_range=(date_start, date_end),
random_state=random_state)
gti = obs_table.create_gti(obs_id=1)
met_ref = time_ref_from_dict(obs_table.meta)
time_start = met_ref + Quantity(obs_table[0]["TSTART"].astype("float64"),
"second")
time_stop = met_ref + Quantity(obs_table[0]["TSTOP"].astype("float64"),
"second")
assert isinstance(gti, GTI)
assert_time_allclose(gti.time_start, time_start)
assert_time_allclose(gti.time_stop, time_stop)
assert_quantity_allclose(
gti.time_sum,
Quantity(obs_table[0]["ONTIME"].astype("float64"), "second"))
def test_lightcurve_dr1(self):
lc = self.source.lightcurve(interval="1-year")
table = lc.table
assert len(table) == 8
assert table.colnames == [
"time_min",
"time_max",
"flux",
"flux_errp",
"flux_errn",
]
expected = Time(54682.655277777776, format="mjd", scale="utc")
assert_time_allclose(lc.time_min[0], expected)
expected = Time(55047.603239293836, format="mjd", scale="utc")
assert_time_allclose(lc.time_max[0], expected)
assert table["flux"].unit == "cm-2 s-1"
assert_allclose(table["flux"][0], 2.2122326e-06, rtol=1e-3)
assert table["flux_errp"].unit == "cm-2 s-1"
assert_allclose(table["flux_errp"][0], 2.3099371e-08, rtol=1e-3)
assert table["flux_errn"].unit == "cm-2 s-1"
assert_allclose(table["flux_errn"][0], 2.3099371e-08, rtol=1e-3)
table = self.source.lightcurve(interval="2-month").table
assert len(table) == 48 # (12 month/year / 2month) * 8 years
assert table["flux"].unit == "cm-2 s-1"
assert_allclose(table["flux"][0], 2.238483e-6, rtol=1e-3)
assert table["flux_errp"].unit == "cm-2 s-1"
assert_allclose(table["flux_errp"][0], 4.437058e-8, rtol=1e-3)
assert table["flux_errn"].unit == "cm-2 s-1"
assert_allclose(table["flux_errn"][0], 4.437058e-8, rtol=1e-3)
def test_observations_select_time_time_intervals_list(data_store):
obs_ids = data_store.obs_table["OBS_ID"][:8]
obss = data_store.get_observations(obs_ids)
# third time interval is out of the observations time range
time_intervals = [
Time([53090.130, 53090.140], format="mjd", scale="tt"),
Time([53110.011, 53110.019], format="mjd", scale="tt"),
Time([53112.345, 53112.42], format="mjd", scale="tt"),
]
new_obss = obss.select_time(time_intervals)
assert len(new_obss) == 2
assert new_obss[0].events.time[0] >= time_intervals[0][0]
assert new_obss[0].events.time[-1] < time_intervals[0][1]
assert new_obss[1].events.time[0] >= time_intervals[1][0]
assert new_obss[1].events.time[-1] < time_intervals[1][1]
assert_time_allclose(new_obss[0].gti.time_start[0], time_intervals[0][0])
assert_time_allclose(new_obss[0].gti.time_stop[-1], time_intervals[0][1])
assert_time_allclose(new_obss[1].gti.time_start[0], time_intervals[1][0])
assert_time_allclose(new_obss[1].gti.time_stop[-1], time_intervals[1][1])
def test_time(self):
time = self.pointing_info.time
assert len(time) == 100
expected = Time(53025.826414166666, format="mjd", scale="tt")
assert_time_allclose(time[0], expected)
def test_time_ref(self):
expected = Time(51910.00074287037, format="mjd", scale="tt")
assert_time_allclose(self.pointing_info.time_ref, expected)
def test_time_stop(self):
time = self.fpi.time_stop
expected = Time(53025.844770648146, format="mjd", scale="tt")
assert_time_allclose(time, expected)
def test_time_start(self):
time = self.fpi.time_start
expected = Time(53025.826414166666, format="mjd", scale="tt")
assert_time_allclose(time, expected)
