def lightcurve(self):
"""Lightcurve (`~gammapy.time.LightCurve`)."""
flux = self.data["Flux_History"]
# Flux error is given as asymmetric high/low
flux_errn = -self.data["Unc_Flux_History"][:, 0]
flux_errp = self.data["Unc_Flux_History"][:, 1]
# Really the time binning is stored in a separate HDU in the FITS
# catalog file called `Hist_Start`, with a single column `Hist_Start`
# giving the time binning in MET (mission elapsed time)
# This is not available here for now.
# TODO: read that info in `SourceCatalog3FGL` and pass it down to the
# `SourceCatalogObject3FGL` object somehow.
# For now, we just hard-code the start and stop time and assume
# equally-spaced time intervals. This is roughly correct,
# for plotting the difference doesn't matter, only for analysis
time_start = Time("2008-08-02T00:33:19")
time_end = Time("2012-07-31T22:45:47")
n_points = len(flux)
time_step = (time_end - time_start) / n_points
time_bounds = time_start + np.arange(n_points + 1) * time_step
table = Table([
Column(time_bounds[:-1].utc.mjd, "time_min"),
Column(time_bounds[1:].utc.mjd, "time_max"),
Column(flux, "flux"),
Column(flux_errp, "flux_errp"),
Column(flux_errn, "flux_errn"),
])
return LightCurve(table)
def test_lightcurve_read_write(tmp_path, lc, format):
lc.write(tmp_path / "tmp", format=format)
lc = LightCurve.read(tmp_path / "tmp", format=format)
# Check if time-related info round-trips
time = lc.time
assert time.scale == "utc"
assert time.format == "mjd"
assert_allclose(time.mjd, [55198, 55202.5])
def test_2():
from astropy.table import Table
from gammapy.time import LightCurve
url = 'https://github.com/gammapy/gamma-cat/raw/master/input/data/2006/2006A%2526A...460..743A/tev-000119-lc.ecsv'
table = Table.read(url, format='ascii.ecsv')
lc = LightCurve(table)
print(lc.time_min[:2].iso)
import matplotlib.pyplot as plt
lc.plot()
plt.show()
def test_lightcurve_read_write(tmpdir, lc, format):
filename = str(tmpdir / "spam")
lc.write(filename, format=format)
lc = LightCurve.read(filename, format=format)
# Check if time-related info round-trips
time = lc.time
assert time.scale == "utc"
assert time.format == "mjd"
assert_allclose(time.mjd, [55198, 55202.5])
def lc():
meta = dict(TIMESYS="utc")
table = Table(
meta=meta,
data=[
Column(Time(["2010-01-01", "2010-01-03"]).mjd, "time_min"),
Column(Time(["2010-01-03", "2010-01-10"]).mjd, "time_max"),
Column([1e-11, 3e-11], "flux", unit="cm-2 s-1"),
Column([0.1e-11, 0.3e-11], "flux_err", unit="cm-2 s-1"),
Column([np.nan, 3.6e-11], "flux_ul", unit="cm-2 s-1"),
Column([False, True], "is_ul"),
],
)
return LightCurve(table=table)
def run(self, e_ref, e_min, e_max, steps="all"):
"""Run light curve extraction.
Normalize integral and energy flux between emin and emax.
Parameters
----------
e_ref : `~astropy.unit.Quantity`
reference energy of dnde flux normalization
e_min : `~astropy.unit.Quantity`
minimum energy of integral and energy flux normalization interval
e_max : `~astropy.unit.Quantity`
minimum energy of integral and energy flux normalization interval
steps : list of str
Which steps to execute. Available options are:
* "err": estimate symmetric error.
* "errn-errp": estimate asymmetric errors.
* "ul": estimate upper limits.
* "ts": estimate ts and sqrt(ts) values.
* "norm-scan": estimate likelihood profiles.
By default all steps are executed.
Returns
-------
lightcurve : `~gammapy.time.LightCurve`
the Light Curve object
"""
self.e_ref = e_ref
self.e_min = e_min
self.e_max = e_max
rows = []
for dataset in self.datasets.datasets:
row = {
"time_min": dataset.counts.meta["t_start"].mjd,
"time_max": dataset.counts.meta["t_stop"].mjd,
}
row.update(self.estimate_time_bin_flux(dataset, steps))
rows.append(row)
meta = OrderedDict([("SED_TYPE", "likelihood")])
table = table_from_row_data(rows=rows, meta=meta)
table = FluxPoints(table).to_sed_type("flux").table
return LightCurve(table)
def run(self, e_ref, e_min, e_max, steps="all", atol="1e-6 s"):
"""Run light curve extraction.
Normalize integral and energy flux between emin and emax.
Parameters
----------
e_ref : `~astropy.units.Quantity`
reference energy of dnde flux normalization
e_min : `~astropy.units.Quantity`
minimum energy of integral and energy flux normalization interval
e_max : `~astropy.units.Quantity`
minimum energy of integral and energy flux normalization interval
steps : list of str
Which steps to execute. Available options are:
* "err": estimate symmetric error.
* "errn-errp": estimate asymmetric errors.
* "ul": estimate upper limits.
* "ts": estimate ts and sqrt(ts) values.
* "norm-scan": estimate fit statistic profiles.
By default all steps are executed.
atol : `~astropy.units.Quantity`
Tolerance value for time comparison with different scale. Default 1e-6 sec.
Returns
-------
lightcurve : `~gammapy.time.LightCurve`
the Light Curve object
"""
atol = u.Quantity(atol)
self.e_ref = e_ref
self.e_min = e_min
self.e_max = e_max
rows = []
self.group_table_info = group_datasets_in_time_interval(
datasets=self.datasets,
time_intervals=self.time_intervals,
atol=atol)
if np.all(self.group_table_info["Group_ID"] == -1):
raise ValueError(
"LightCurveEstimator: No datasets in time intervals")
for igroup, time_interval in enumerate(self.time_intervals):
index_dataset = np.where(
self.group_table_info["Group_ID"] == igroup)[0]
if len(index_dataset) == 0:
log.debug("No Dataset for the time interval " + str(igroup))
continue
row = {
"time_min": time_interval[0].mjd,
"time_max": time_interval[1].mjd
}
interval_list_dataset = Datasets(
[self.datasets[int(_)].copy() for _ in index_dataset])
self._set_scale_model(interval_list_dataset)
row.update(
self.estimate_time_bin_flux(interval_list_dataset,
time_interval, steps))
rows.append(row)
table = table_from_row_data(rows=rows, meta={"SED_TYPE": "likelihood"})
table = FluxPoints(table).to_sed_type("flux").table
return LightCurve(table)
from gammapy.time import LightCurve lc = LightCurve.simulate_example() lc.plot()
"""
Using the Lightcurve class
"""
from gammapy.time import LightCurve
lc = LightCurve.simulate_example()
print('the mean flux is {}'.format(lc['FLUX'].mean()))
print('the std dev of the flux is {}'.format(lc['FLUX'].std()))
lc.lc_plot()
