def from_time_intervals(cls, time_intervals, reference_time="2000-01-01"):
"""From list of time intervals
Parameters
----------
time_intervals : list of `~astropy.time.Time` objects
Time intervals
reference_time : `~astropy.time.Time`
Reference time to use in GTI definition
Returns
-------
gti : `GTI`
GTI table.
"""
reference_time = Time(reference_time)
start = Time([_[0] for _ in time_intervals]) - reference_time
stop = Time([_[1] for _ in time_intervals]) - reference_time
meta = time_ref_to_dict(reference_time)
table = Table({
"START": start.to("s"),
"STOP": stop.to("s")
},
meta=meta)
return cls(table=table)
def create(cls, start, stop, reference_time="2000-01-01"):
"""Creates a GTI table from start and stop times.
Parameters
----------
start : `~astropy.time.Time` or `~astropy.units.Quantity`
Start times, if a quantity then w.r.t. reference time
stop : `~astropy.time.Time` or `~astropy.units.Quantity`
Stop times, if a quantity then w.r.t. reference time
reference_time : `~astropy.time.Time`
the reference time to use in GTI definition
"""
reference_time = Time(reference_time)
if isinstance(start, Time):
start = (start - reference_time).to(u.s)
if isinstance(stop, Time):
stop = (stop - reference_time).to(u.s)
start = Quantity(start, ndmin=1)
stop = Quantity(stop, ndmin=1)
meta = time_ref_to_dict(reference_time)
table = Table({
"START": start.to("s"),
"STOP": stop.to("s")
},
meta=meta)
return cls(table)
def test_time_ref_to_dict():
time = Time("2001-01-01T00:00:00")
d = time_ref_to_dict(time)
assert set(d) == {"MJDREFI", "MJDREFF", "TIMESYS"}
assert d["MJDREFI"] == 51910
assert_allclose(d["MJDREFF"], 0.00074287036841269583)
assert d["TIMESYS"] == "tt"
def test_from_table_time_axis():
t0 = Time("2006-02-12", scale="utc")
t_min = np.linspace(0, 10, 10) * u.d
t_max = t_min + 12 * u.h
table = Table()
table["TIME_MIN"] = t_min
table["TIME_MAX"] = t_max
table.meta.update(time_ref_to_dict(t0))
table.meta["AXCOLS1"] = "TIME_MIN,TIME_MAX"
axis = TimeMapAxis.from_table(table, format="gadf")
assert axis.nbin == 10
assert_allclose(axis.time_mid[0].mjd, 53778.25)
def test_fixed_pointing_info_fixed_altaz():
location = observatory_locations["cta_south"]
start = Time("2020-11-01T03:00:00")
stop = Time("2020-11-01T03:15:00")
ref = Time("2020-11-01T00:00:00")
pointing_icrs = SkyCoord(ra=83.28 * u.deg, dec=21.78 * u.deg)
pointing_altaz = pointing_icrs.transform_to(
AltAz(obstime=start, location=location))
meta = time_ref_to_dict(ref)
meta['TSTART'] = time_relative_to_ref(start, meta).to_value(u.s)
meta['TSTOP'] = time_relative_to_ref(stop, meta).to_value(u.s)
meta.update(earth_location_to_dict(location))
meta["OBS_MODE"] = "DRIFT"
meta["ALT_PNT"] = pointing_altaz.alt.deg
meta["AZ_PNT"] = pointing_altaz.az.deg
pointing = FixedPointingInfo(meta=meta)
# not given, but assumed if missing
assert pointing.mode == PointingMode.DRIFT
assert pointing.fixed_icrs is None
assert u.isclose(pointing.fixed_altaz.alt, pointing_altaz.alt)
assert u.isclose(pointing.fixed_altaz.az, pointing_altaz.az)
icrs = pointing.get_icrs(start)
assert icrs.obstime == start
assert isinstance(icrs.frame, ICRS)
back_trafo = icrs.transform_to(pointing_altaz.frame)
assert u.isclose(back_trafo.alt, pointing_altaz.alt)
assert u.isclose(back_trafo.az, pointing_altaz.az)
times = start + np.linspace(0, 1, 50) * (stop - start)
icrs = pointing.get_icrs(times)
assert len(icrs) == len(times)
assert np.all(icrs.obstime == times)
assert isinstance(icrs.frame, ICRS)
back_trafo = icrs.transform_to(AltAz(location=location, obstime=times))
assert u.isclose(back_trafo.alt, pointing_altaz.alt).all()
assert u.isclose(back_trafo.az, pointing_altaz.az).all()
assert np.all(u.isclose(pointing_altaz.alt, pointing.get_altaz(times).alt))
assert np.all(u.isclose(pointing_altaz.az, pointing.get_altaz(times).az))
def _get_obs_info(pointing, deadtime_fraction, time_start, time_stop,
reference_time, location):
"""Create obs info dict from in memory data"""
obs_info = {
"RA_PNT": pointing.icrs.ra.deg,
"DEC_PNT": pointing.icrs.dec.deg,
"DEADC": 1 - deadtime_fraction,
}
obs_info.update(time_ref_to_dict(reference_time))
obs_info['TSTART'] = time_relative_to_ref(time_start,
obs_info).to_value(u.s)
obs_info['TSTOP'] = time_relative_to_ref(time_stop,
obs_info).to_value(u.s)
if location is not None:
obs_info.update(earth_location_to_dict(location))
return obs_info
def test_fixed_pointing_info_fixed_icrs():
location = observatory_locations["cta_south"]
start = Time("2020-11-01T03:00:00")
stop = Time("2020-11-01T03:15:00")
ref = Time("2020-11-01T00:00:00")
pointing_icrs = SkyCoord(ra=83.28 * u.deg, dec=21.78 * u.deg)
meta = time_ref_to_dict(ref)
meta['TSTART'] = time_relative_to_ref(start, meta).to_value(u.s)
meta['TSTOP'] = time_relative_to_ref(stop, meta).to_value(u.s)
meta.update(earth_location_to_dict(location))
meta["RA_PNT"] = pointing_icrs.ra.deg
meta["DEC_PNT"] = pointing_icrs.dec.deg
pointing = FixedPointingInfo(meta=meta)
# not given, but assumed if missing
assert pointing.mode == PointingMode.POINTING
assert pointing.fixed_icrs == pointing_icrs
assert pointing.fixed_altaz is None
altaz = pointing.get_altaz(start)
assert altaz.obstime == start
assert isinstance(altaz.frame, AltAz)
assert np.all(u.isclose(pointing_icrs.ra, pointing.get_icrs(start).ra))
back_trafo = altaz.transform_to("icrs")
assert u.isclose(back_trafo.ra, pointing_icrs.ra)
assert u.isclose(back_trafo.dec, pointing_icrs.dec)
times = start + np.linspace(0, 1, 50) * (stop - start)
altaz = pointing.get_altaz(times)
assert len(altaz) == len(times)
assert np.all(altaz.obstime == times)
assert isinstance(altaz.frame, AltAz)
back_trafo = altaz.transform_to("icrs")
assert u.isclose(back_trafo.ra, pointing_icrs.ra).all()
assert u.isclose(back_trafo.dec, pointing_icrs.dec).all()
assert np.all(u.isclose(pointing_icrs.ra, pointing.get_icrs(times).ra))
def setup_class(self):
table = Table()
table["RA"] = [0.0, 0.0, 0.0, 0.0, 10.0] * u.deg
table["DEC"] = [0.0, 0.05, 0.9, 10.0, 10.0] * u.deg
table["ENERGY"] = [1.0, 1.0, 1.5, 1.5, 10.0] * u.TeV
table["OFFSET"] = [0.1, 0.1, 0.5, 1.0, 1.5] * u.deg
table.meta["RA_PNT"] = 0 * u.deg
table.meta["DEC_PNT"] = 0.5 * u.deg
meta_obs = dict()
meta_obs["RA_PNT"] = 0 * u.deg
meta_obs["DEC_PNT"] = 0.5 * u.deg
meta_obs["DEADC"] = 1
meta = time_ref_to_dict("2010-01-01")
gti_table = Table({"START": [1], "STOP": [3]}, meta=meta)
gti = GTI(gti_table)
self.observation = Observation(
events=EventList(table), obs_info=meta_obs, gti=gti
)
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": start.to("s"),
"STOP": stop.to("s")
},
meta=meta)
return cls(table)
def setup_class(self):
self.observations = []
for sign in [-1, 1]:
events = Table()
events["RA"] = [0.0, 0.0, 0.0, 0.0, 10.0] * u.deg
events["DEC"] = sign * ([0.0, 0.05, 0.9, 10.0, 10.0] * u.deg)
events["ENERGY"] = [1.0, 1.0, 1.5, 1.5, 10.0] * u.TeV
events["OFFSET"] = [0.1, 0.1, 0.5, 1.0, 1.5] * u.deg
obs_info = dict(
RA_PNT=0 * u.deg,
DEC_PNT=sign * 0.5 * u.deg,
DEADC=1,
)
events.meta.update(obs_info)
meta = time_ref_to_dict("2010-01-01")
gti_table = Table({"START": [1], "STOP": [3]}, meta=meta)
gti = GTI(gti_table)
self.observations.append(Observation(
events=EventList(events), obs_info=obs_info, gti=gti
))
def make_gti(times, time_ref="2010-01-01"):
meta = time_ref_to_dict(time_ref)
table = Table(times, meta=meta)
return GTI(table)
