def test_lightcurve_from_toa(self):
lc = Lightcurve.make_lightcurve(self.times, self.dt, use_hist=True,
tstart=0.5)
lc2 = Lightcurve.make_lightcurve(self.times, self.dt, use_hist=False,
tstart=0.5)
assert np.allclose(lc.time, lc2.time)
assert np.all(lc.counts == lc2.counts)
def test_lightcurve_from_toa(self):
lc = Lightcurve.make_lightcurve(self.times, self.dt, use_hist=True,
tstart=0.5)
lc2 = Lightcurve.make_lightcurve(self.times, self.dt, use_hist=False,
tstart=0.5)
assert np.allclose(lc.time, lc2.time)
assert np.all(lc.counts == lc2.counts)
def test_fad_power_spectrum_equal_ev_lc(ctrate):
dt = 0.1
deadtime = 2.5e-3
length = 25600
gti = [[0, length]]
segment_size = 256.
ncounts = int(ctrate * length)
ev1 = filter_for_deadtime(generate_events(length, ncounts), deadtime)
ev2 = filter_for_deadtime(generate_events(length, ncounts), deadtime)
lc1 = Lightcurve.make_lightcurve(ev1,
dt=dt,
gti=gti,
tstart=0,
tseg=length)
lc2 = Lightcurve.make_lightcurve(ev2,
dt=dt,
gti=gti,
tstart=0,
tseg=length)
ev1 = EventList(ev1, gti=gti)
ev2 = EventList(ev2, gti=gti)
results_out_ev = \
FAD(ev1, ev2, segment_size, dt=dt, plot=True,
strict=True, verbose=True,
tolerance=0.05, norm="leahy")
results_out_lc = \
calculate_FAD_correction(lc1, lc2, segment_size, plot=True,
strict=True, verbose=True,
tolerance=0.05, norm="leahy")
for attr in ['pds1', 'pds2', 'cs', 'ptot']:
assert np.allclose(results_out_ev[attr], results_out_lc[attr])
def _make_reference_bands_from_event_data(self, data, bounds=None):
"""
Helper method constructing reference bands for each band of interest, and constructing
light curves from these reference bands. This operates only if the data given to
:class:`Covariancespectrum` is event list data (i.e. photon arrival times and energies).
Parameters
----------
data : numpy.ndarray
Array of shape ``(N, 2)``, where N is the number of photons. First column contains the
times of arrivals, second column the corresponding photon energies.
bounds : iterable
The energy bounds to use for the reference band. Must be of type ``(elow, ehigh)``.
Returns
-------
lc_all: list of :class:`stingray.Lightcurve` objects.
The list of `:class:`stingray.Lightcurve` objects containing all reference
bands, between the values given in ``bounds``.
"""
if not bounds:
bounds = [np.min(data[:, 1]), np.max(data[:, 1])]
if bounds[1] <= np.min(self.band_interest[:, 0]) or \
bounds[0] >= np.max(self.band_interest[:, 1]):
elow = bounds[0]
ehigh = bounds[1]
toa = data[np.logical_and(data[:, 1] >= elow, data[:, 1] <= ehigh)]
lc_all = Lightcurve.make_lightcurve(toa,
self.dt,
tstart=self.tstart,
tseg=self.tseg)
else:
lc_all = []
for i, b in enumerate(self.band_interest):
elow = b[0]
ehigh = b[1]
emask1 = data[np.logical_and(data[:, 1] <= elow,
data[:, 1] >= bounds[0])]
emask2 = data[np.logical_and(data[:, 1] <= bounds[1],
data[:, 1] >= ehigh)]
toa = np.vstack([emask1, emask2])
lc = Lightcurve.make_lightcurve(toa,
self.dt,
tstart=self.tstart,
tseg=self.tseg)
lc_all.append(lc)
return lc_all
def test_lightcurve_from_toa_random_nums(self):
times = np.random.uniform(0, 10, 1000)
lc = Lightcurve.make_lightcurve(times, self.dt, use_hist=True,
tstart=0.5)
lc2 = Lightcurve.make_lightcurve(times, self.dt, use_hist=False,
tstart=0.5)
assert np.allclose(lc.time, lc2.time)
assert np.all(lc.counts == lc2.counts)
def test_lightcurve_from_toa_random_nums(self):
times = np.random.uniform(0, 10, 1000)
lc = Lightcurve.make_lightcurve(times, self.dt, use_hist=True,
tstart=0.5)
lc2 = Lightcurve.make_lightcurve(times, self.dt, use_hist=False,
tstart=0.5)
assert np.allclose(lc.time, lc2.time)
assert np.all(lc.counts == lc2.counts)
def test_lightcurve_from_toa_Time(self):
mjdref = 56789
mjds = Time(self.times / 86400 + mjdref, format='mjd')
lc = Lightcurve.make_lightcurve(mjds,
self.dt,
mjdref=mjdref,
use_hist=True,
tstart=0.5)
lc2 = Lightcurve.make_lightcurve(self.times,
self.dt,
use_hist=False,
tstart=0.5,
mjdref=mjdref)
assert np.allclose(lc.time, lc2.time)
assert np.allclose(lc.counts, lc2.counts)
def test_tseg(self):
tstart = 0.0
tseg = 5.0
lc = Lightcurve.make_lightcurve(self.times, self.dt, tseg=tseg, tstart=tstart)
assert lc.tseg == tseg
assert lc.time[-1] - lc.time[0] == tseg - self.dt
def generate_deadtime_lc(ev, dt, tstart=0, tseg=None, deadtime=2.5e-3):
ev = filter_for_deadtime(ev, deadtime)
return Lightcurve.make_lightcurve(ev,
dt=dt,
tstart=tstart,
tseg=tseg,
gti=np.array([[tstart, tseg]]))
def test_tseg(self):
tstart = 0.0
tseg = 5.0
lc = Lightcurve.make_lightcurve(self.times, self.dt,
tseg=tseg, tstart=tstart)
assert lc.tseg == tseg
assert lc.time[-1] - lc.time[0] == tseg - self.dt
def setup_class(cls):
photon_arrivals = np.sort(np.random.uniform(0,1000, size=10000))
cls.lc = Lightcurve.make_lightcurve(photon_arrivals, dt=1.0)
cls.ps = Powerspectrum(cls.lc, norm="frac")
pl = models.PowerLaw1D()
pl.x_0.fixed = True
cls.lpost = PSDPosterior(cls.ps.freq, cls.ps.power, pl, m=cls.ps.m)
def setup_class(cls):
photon_arrivals = np.sort(np.random.uniform(0, 1000, size=10000))
cls.lc = Lightcurve.make_lightcurve(photon_arrivals, dt=1.0)
cls.ps = Powerspectrum(cls.lc, norm="frac")
pl = models.PowerLaw1D()
pl.x_0.fixed = True
cls.lpost = PSDPosterior(cls.ps.freq, cls.ps.power, pl, m=cls.ps.m)
def test_nondivisble_tseg(self):
"""
If the light curve length input is not divisible by the time
resolution, the last (fractional) time bin will be dropped.
"""
tstart = 0.0
tseg = 5.5
lc = Lightcurve.make_lightcurve(self.times, self.dt, tseg=tseg, tstart=tstart)
assert lc.tseg == int(tseg / self.dt)
def test_nondivisble_tseg(self):
"""
If the light curve length input is not divisible by the time
resolution, the last (fractional) time bin will be dropped.
"""
tstart = 0.0
tseg = 5.5
lc = Lightcurve.make_lightcurve(self.times, self.dt,
tseg=tseg, tstart=tstart)
assert lc.tseg == int(tseg/self.dt)
def test_bin_correctly(self):
ncounts = np.array([2, 1, 0, 3])
tstart = 0.0
tseg = 4.0
toa = np.hstack([np.random.uniform(i, i + 1, size=n) for i, n in enumerate(ncounts)])
dt = 1.0
lc = Lightcurve.make_lightcurve(toa, dt, tseg=tseg, tstart=tstart)
assert np.allclose(lc.counts, ncounts)
def test_bin_correctly(self):
ncounts = np.array([2, 1, 0, 3])
tstart = 0.0
tseg = 4.0
toa = np.hstack([np.random.uniform(i, i+1, size=n)
for i, n in enumerate(ncounts)])
dt = 1.0
lc = Lightcurve.make_lightcurve(toa, dt, tseg=tseg, tstart=tstart)
assert np.allclose(lc.counts, ncounts)
def _make_reference_bands_from_event_data(self, data, bounds=None):
if not bounds:
bounds = [np.min(data[:, 1]), np.max(data[:, 1])]
print("Band interest: " + str(self.band_interest))
print("Bounds: " + str(bounds))
if bounds[1] <= np.min(self.band_interest[:, 0]) or \
bounds[0] >= np.max(self.band_interest[:, 1]):
elow = bounds[0]
ehigh = bounds[1]
toa = data[np.logical_and(data[:, 1] >= elow, data[:, 1] <= ehigh)]
lc_all = Lightcurve.make_lightcurve(toa,
self.dt,
tstart=self.tstart,
tseg=self.tseg)
else:
lc_all = []
for i, b in enumerate(self.band_interest):
elow = b[0]
ehigh = b[1]
emask1 = data[np.logical_and(data[:, 1] <= elow,
data[:, 1] >= bounds[0])]
emask2 = data[np.logical_and(data[:, 1] <= bounds[1],
data[:, 1] >= ehigh)]
toa = np.vstack([emask1, emask2])
lc = Lightcurve.make_lightcurve(toa,
self.dt,
tstart=self.tstart,
tseg=self.tseg)
lc_all.append(lc)
return lc_all
def _make_reference_bands_from_event_data(self, data, bounds=None):
if not bounds:
bounds = [np.min(data[:, 1]), np.max(data[:, 1])]
if bounds[1] <= np.min(self.band_interest[:, 0]) or \
bounds[0] >= np.max(self.band_interest[:, 1]):
elow = bounds[0]
ehigh = bounds[1]
toa = data[np.logical_and(
data[:, 1] >= elow,
data[:, 1] <= ehigh)]
lc_all = Lightcurve.make_lightcurve(toa, self.dt,
tstart=self.tstart,
tseg=self.tseg)
else:
lc_all = []
for i, b in enumerate(self.band_interest):
elow = b[0]
ehigh = b[1]
emask1 = data[np.logical_and(
data[:, 1] <= elow,
data[:, 1] >= bounds[0])]
emask2 = data[np.logical_and(
data[:, 1] <= bounds[1],
data[:, 1] >= ehigh)]
toa = np.vstack([emask1, emask2])
lc = Lightcurve.make_lightcurve(toa, self.dt,
tstart=self.tstart,
tseg=self.tseg)
lc_all.append(lc)
return lc_all
def _create_lc_and_lc_ref(self, energy, energy_events):
lc = Lightcurve.make_lightcurve(
energy_events[energy], self.dt, tstart=self.min_time,
tseg=self.max_time - self.min_time)
# Calculating timestamps for lc_ref
toa_ref = []
for key, value in energy_events.items():
if key >= self.ref_band_interest[0] and \
key <= self.ref_band_interest[1]:
if key != energy:
toa_ref.extend(value)
toa_ref = np.array(sorted(toa_ref))
lc_ref = Lightcurve.make_lightcurve(
toa_ref, self.dt, tstart=self.min_time,
tseg=self.max_time - self.min_time)
assert len(lc.time) == len(lc_ref.time)
return lc, lc_ref
def _create_lc_and_lc_ref(self, energy, energy_events):
lc = Lightcurve.make_lightcurve(energy_events[energy],
self.dt,
tstart=self.min_time,
tseg=self.max_time - self.min_time)
# Calculating timestamps for lc_ref
toa_ref = []
for key, value in energy_events.items():
if key >= self.ref_band_interest[0] and \
key <= self.ref_band_interest[1]:
if key != energy:
toa_ref.extend(value)
toa_ref = np.array(sorted(toa_ref))
lc_ref = Lightcurve.make_lightcurve(toa_ref,
self.dt,
tstart=self.min_time,
tseg=self.max_time - self.min_time)
assert len(lc.time) == len(lc_ref.time)
return lc, lc_ref
def _make_lightcurves(self, data):
self.tstart = np.min(data[:, 0])
self.tend = np.max(data[:, 0])
self.tseg = self.tend - self.tstart
lc_all = []
for i, b in enumerate(self.band_interest):
elow = b[0]
ehigh = b[1]
toa = data[np.logical_and(
data[:, 1] >= elow,
data[:, 1] <= ehigh)]
lc = Lightcurve.make_lightcurve(toa, self.dt, tstart=self.tstart,
tseg=self.tseg)
lc_all.append(lc)
return lc_all
def _make_lightcurves(self, data):
self.tstart = np.min(data[:, 0])
self.tend = np.max(data[:, 0])
self.tseg = self.tend - self.tstart
lc_all = []
for i, b in enumerate(self.band_interest):
elow = b[0]
ehigh = b[1]
toa = data[np.logical_and(data[:, 1] >= elow, data[:, 1] <= ehigh)]
lc = Lightcurve.make_lightcurve(toa,
self.dt,
tstart=self.tstart,
tseg=self.tseg)
lc_all.append(lc)
return lc_all
def _make_lightcurves(self, data):
"""
Create light curves for all bands of interest from ``data``. Takes the information the
``band_interest`` attribute and event data in ``data``, and produces a list of
:class:`stingray.Lightcurve` objects.
Parameters
----------
data : numpy.ndarray
Array of shape ``(N, 2)``, where ``N`` is the number of photons. First column contains the
times of arrivals, second column the corresponding photon energies.
Returns
-------
lc_all : iterable of :class:`stingray.Lightcurve` objects
A list of :class:`stingray.Lightcurve` objects of all bands of interest.
"""
self.tstart = np.min(data[:, 0])
self.tend = np.max(data[:, 0])
self.tseg = self.tend - self.tstart
lc_all = []
for i, b in enumerate(self.band_interest):
elow = b[0]
ehigh = b[1]
toa = data[np.logical_and(data[:, 1] >= elow, data[:, 1] <= ehigh)]
lc = Lightcurve.make_lightcurve(toa,
self.dt,
tstart=self.tstart,
tseg=self.tseg)
lc_all.append(lc)
return lc_all
def _make_lightcurves(self, data):
"""
Create light curves for all bands of interest from ``data``. Takes the information the
``band_interest`` attribute and event data in ``data``, and produces a list of
:class:`stingray.Lightcurve` objects.
Parameters
----------
data : numpy.ndarray
Array of shape ``(N, 2)``, where ``N`` is the number of photons. First column contains the
times of arrivals, second column the corresponding photon energies.
Returns
-------
lc_all : iterable of :class:`stingray.Lightcurve` objects
A list of :class:`stingray.Lightcurve` objects of all bands of interest.
"""
self.tstart = np.min(data[:, 0])
self.tend = np.max(data[:, 0])
self.tseg = self.tend - self.tstart
lc_all = []
for i, b in enumerate(self.band_interest):
elow = b[0]
ehigh = b[1]
toa = data[np.logical_and(
data[:, 1] >= elow,
data[:, 1] <= ehigh)]
lc = Lightcurve.make_lightcurve(toa, self.dt, tstart=self.tstart,
tseg=self.tseg)
lc_all.append(lc)
return lc_all
def makeLCFunc(times):
Lightcurve.make_lightcurve(times, dt=1.0)
def test_correct_timeresolution(self):
lc = Lightcurve.make_lightcurve(self.times, self.dt)
assert np.isclose(lc.dt, self.dt)
def test_tstart(self):
tstart = 0.0
lc = Lightcurve.make_lightcurve(self.times, self.dt, tstart=0.0)
assert lc.tstart == tstart
assert lc.time[0] == tstart + 0.5 * self.dt
def test_lightcurve_from_toa(self):
lc = Lightcurve.make_lightcurve(self.times, self.dt)
def test_lightcurve_from_toa(self):
lc = Lightcurve.make_lightcurve(self.times, self.dt)
def _make_reference_bands_from_event_data(self, data, bounds=None):
"""
Helper method constructing reference bands for each band of interest, and constructing
light curves from these reference bands. This operates only if the data given to
:class:`Covariancespectrum` is event list data (i.e. photon arrival times and energies).
Parameters
----------
data : numpy.ndarray
Array of shape ``(N, 2)``, where N is the number of photons. First column contains the
times of arrivals, second column the corresponding photon energies.
bounds : iterable
The energy bounds to use for the reference band. Must be of type ``(elow, ehigh)``.
Returns
-------
lc_all: list of :class:`stingray.Lightcurve` objects.
The list of `:class:`stingray.Lightcurve` objects containing all reference
bands, between the values given in ``bounds``.
"""
if not bounds:
bounds = [np.min(data[:, 1]), np.max(data[:, 1])]
if bounds[1] <= np.min(self.band_interest[:, 0]) or \
bounds[0] >= np.max(self.band_interest[:, 1]):
elow = bounds[0]
ehigh = bounds[1]
toa = data[np.logical_and(
data[:, 1] >= elow,
data[:, 1] <= ehigh)]
lc_all = Lightcurve.make_lightcurve(toa, self.dt,
tstart=self.tstart,
tseg=self.tseg)
else:
lc_all = []
for i, b in enumerate(self.band_interest):
elow = b[0]
ehigh = b[1]
emask1 = data[np.logical_and(
data[:, 1] <= elow,
data[:, 1] >= bounds[0])]
emask2 = data[np.logical_and(
data[:, 1] <= bounds[1],
data[:, 1] >= ehigh)]
toa = np.vstack([emask1, emask2])
lc = Lightcurve.make_lightcurve(toa, self.dt,
tstart=self.tstart,
tseg=self.tseg)
lc_all.append(lc)
return lc_all
def test_tstart(self):
tstart = 0.0
lc = Lightcurve.make_lightcurve(self.times, self.dt, tstart=0.0)
assert lc.tstart == tstart
assert lc.time[0] == tstart + 0.5*self.dt
def test_correct_timeresolution(self):
lc = Lightcurve.make_lightcurve(self.times, self.dt)
assert np.isclose(lc.dt, self.dt)