Source code for

# Licensed under a 3-clause BSD style license - see LICENSE.rst
import numpy as np
from astropy.table import Table, vstack
from astropy.time import Time
from astropy.units import Quantity
from gammapy.utils.scripts import make_path
from gammapy.utils.time import (

__all__ = ["GTI"]

[docs]class GTI: """Good time intervals (GTI) `~astropy.table.Table`. Data format specification: :ref:`gadf:iact-gti` Note: at the moment dead-time and live-time is in the EVENTS header ... the GTI header just deals with observation times. Parameters ---------- table : `~astropy.table.Table` GTI table Examples -------- Load GTIs for a H.E.S.S. event list: >>> from import GTI >>> gti ='$GAMMAPY_DATA/hess-dl3-dr1//data/hess_dl3_dr1_obs_id_023523.fits.gz') >>> print(gti) GTI info: - Number of GTIs: 1 - Duration: 1687.0 s - Start: 53343.92234009259 MET - Start: 2004-12-04T22:08:10.184(TT) - Stop: 53343.94186555556 MET - Stop: 2004-12-04T22:36:17.184(TT) Load GTIs for a Fermi-LAT event list: >>> gti ="$GAMMAPY_DATA/fermi-3fhl-gc/fermi-3fhl-gc-events.fits.gz") >>> print(gti) GTI info: - Number of GTIs: 39042 - Duration: 183139597.9032163 s - Start: 54682.65603794185 MET - Start: 2008-08-04T15:44:41.678(TT) - Stop: 57236.96833546296 MET - Stop: 2015-08-02T23:14:24.184(TT) """ def __init__(self, table): self.table = table
[docs] def copy(self): return self.__class__(self.table)
[docs] @classmethod def create(cls, start, stop, reference_time="2000-01-01"): """Creates a GTI table from start and stop times. Parameters ---------- start : `~astropy.units.Quantity` start times w.r.t. reference time stop : `~astropy.units.Quantity` stop times w.r.t. reference time reference_time : `~astropy.time.Time` the reference time to use in GTI definition """ start = np.atleast_1d(Quantity(start)) stop = np.atleast_1d(Quantity(stop)) reference_time = Time(reference_time) meta = time_ref_to_dict(reference_time) table = Table({"START":"s"), "STOP":"s")}, meta=meta) return cls(table)
[docs] @classmethod def read(cls, filename, hdu="GTI"): """Read from FITS file. Parameters ---------- filename : `pathlib.Path`, str Filename hdu : str hdu name. Default GTI. """ filename = make_path(filename) table =, hdu=hdu) return cls(table)
[docs] def write(self, filename, **kwargs): """Write to file.""" self.table.write(make_path(filename), **kwargs)
def __str__(self): return ( "GTI info:\n" f"- Number of GTIs: {len(self.table)}\n" f"- Duration: {self.time_sum}\n" f"- Start: {self.time_start[0]} MET\n" f"- Start: {self.time_start[0].fits}\n" f"- Stop: {self.time_stop[-1]} MET\n" f"- Stop: {self.time_stop[-1].fits}\n" ) @property def time_delta(self): """GTI durations in seconds (`~astropy.units.Quantity`).""" start = self.table["START"].astype("float64") stop = self.table["STOP"].astype("float64") return Quantity(stop - start, "second") @property def time_ref(self): """Time reference (`~astropy.time.Time`).""" return time_ref_from_dict(self.table.meta) @property def time_sum(self): """Sum of GTIs in seconds (`~astropy.units.Quantity`).""" return self.time_delta.sum() @property def time_start(self): """GTI start times (`~astropy.time.Time`).""" met = Quantity(self.table["START"].astype("float64"), "second") return self.time_ref + met @property def time_stop(self): """GTI end times (`~astropy.time.Time`).""" met = Quantity(self.table["STOP"].astype("float64"), "second") return self.time_ref + met
[docs] def select_time(self, time_interval): """Select and crop GTIs in time interval. Parameters ---------- time_interval : `astropy.time.Time` Start and stop time for the selection. Returns ------- gti : `GTI` Copy of the GTI table with selection applied. """ # get GTIs that fall within the time_interval mask = self.time_start < time_interval[1] mask &= self.time_stop > time_interval[0] gti_within = self.table[mask] # crop the GTIs start_met = time_relative_to_ref(time_interval[0], self.table.meta) stop_met = time_relative_to_ref(time_interval[1], self.table.meta) np.clip( gti_within["START"], start_met.value, stop_met.value, out=gti_within["START"], ) np.clip( gti_within["STOP"], start_met.value, stop_met.value, out=gti_within["STOP"] ) return self.__class__(gti_within)
[docs] def stack(self, other): """Stack with another GTI. This simply changes the time reference of the second GTI table and stack the two tables. No logic is applied to the intervals. Parameters ---------- other : `` GTI to stack to self Returns ------- new_gti : `` New GTI """ start = (other.time_start - self.time_ref).sec end = (other.time_stop - self.time_ref).sec table = Table({"START": start, "STOP": end}, names=["START", "STOP"]) return self.__class__(vstack([self.table, table]))
[docs] def union(self): """Union of overlapping time intervals. Returns a new `` object. Intervals that touch will be merged, e.g. ``(1, 2)`` and ``(2, 3)`` will result in ``(1, 3)``. """ # Algorithm to merge overlapping intervals is well-known, # see e.g. table = self.table.copy() table.sort("START") # We use Python dict instead of astropy.table.Row objects, # because on some versions modifying Row entries doesn't behave as expected merged = [{"START": table[0]["START"], "STOP": table[0]["STOP"]}] for row in table[1:]: interval = {"START": row["START"], "STOP": row["STOP"]} if merged[-1]["STOP"] <= interval["START"]: merged.append(interval) else: merged[-1]["STOP"] = max(interval["STOP"], merged[-1]["STOP"]) merged = Table(rows=merged, names=["START", "STOP"], meta=self.table.meta) return self.__class__(merged)