def test_plot_wrong_label_type(self): lc = Lightcurve(self.times, self.counts) with pytest.raises(TypeError): with warnings.catch_warnings(record=True) as w: lc.plot(labels=123) assert "must be either a list or tuple" in str(w[0].message)
def test_io_with_pickle(self): lc = Lightcurve(self.times, self.counts) lc.write('lc.pickle', format_='pickle') lc.read('lc.pickle',format_='pickle') assert np.all(lc.time == self.times) assert np.all(lc.counts == self.counts) os.remove('lc.pickle')
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_io_with_pickle(self): lc = Lightcurve(self.times, self.counts) lc.write("lc.pickle", format_="pickle") lc.read("lc.pickle", format_="pickle") assert np.all(lc.time == self.times) assert np.all(lc.counts == self.counts) assert np.all(lc.gti == self.gti) os.remove("lc.pickle")
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_analyze_lc_chunks(self): lc = Lightcurve(self.times, self.counts, gti=self.gti) def func(lc): return lc.time[0] start, stop, res = lc.analyze_lc_chunks(2, func) assert start[0] == 0.5 assert np.all(start + lc.dt / 2 == res)
def test_truncate_by_index(self): lc = Lightcurve(self.times, self.counts) lc1 = lc.truncate(start=1) assert np.all(lc1.time == np.array([2, 3, 4])) assert np.all(lc1.counts == np.array([2, 2, 2])) lc2 = lc.truncate(stop=2) assert np.all(lc2.time == np.array([1, 2])) assert np.all(lc2.counts == np.array([2, 2]))
def test_join_with_different_dt(self): _times = [5, 5.5, 6] _counts = [2, 2, 2] lc1 = Lightcurve(self.times, self.counts) lc2 = Lightcurve(_times, _counts) with warnings.catch_warnings(record=True) as w: lc1.join(lc2) assert "different bin widths" in str(w[0].message)
def test_lc_baseline(self): times = np.arange(0, 100, 0.01) counts = np.random.normal(100, 0.1, len(times)) + \ 0.001 * times gti = [[-0.005, 50.005], [59.005, 100.005]] good = create_gti_mask(times, gti) counts[np.logical_not(good)] = 0 lc = Lightcurve(times, counts, gti=gti) baseline = lc.baseline(10000, 0.01) assert np.all(lc.counts - baseline < 1)
def test_truncate_by_time(self): lc = Lightcurve(self.times, self.counts) lc1 = lc.truncate(start=1, method='time') assert np.all(lc1.time == np.array([1, 2, 3, 4])) assert np.all(lc1.counts == np.array([2, 2, 2, 2])) lc2 = lc.truncate(stop=3, method='time') assert np.all(lc2.time == np.array([1, 2])) assert np.all(lc2.counts == np.array([2, 2]))
def test_join_different_err_dist_disjoint_times(self): _times = [5 , 6, 7, 8] _counts =[2, 2, 2, 2] lc1 = Lightcurve(self.times, self.counts, err_dist = "poisson") lc2 = Lightcurve(_times, _counts, err_dist = "gauss") lc3 = lc1.join(lc2) assert np.all(lc3.counts_err[:len(self.times)] == lc1.counts_err) assert np.all(lc3.counts_err[len(self.times):] == np.zeros_like(lc2.counts))
def test_join_different_err_dist_overlapping_times(self): _times = [3, 4, 5, 6] _counts = [4, 4, 4, 4] lc1 = Lightcurve(self.times, self.counts, err_dist = "poisson") lc2 = Lightcurve(_times, _counts, err_dist = "gauss") with warnings.catch_warnings(record=True) as w: lc3 = lc1.join(lc2) assert "We are setting the errors to zero." in str(w[1].message) assert np.all(lc3.counts_err == np.zeros_like(lc3.time))
def test_join_disjoint_time_arrays(self): _times = [5, 6, 7, 8] _counts = [2, 2, 2, 2] lc1 = Lightcurve(self.times, self.counts) lc2 = Lightcurve(_times, _counts) lc = lc1.join(lc2) assert len(lc.counts) == len(lc.time) == 8 assert np.all(lc.counts == 2)
def test_plot_matplotlib_not_installed(self): try: import matplotlib.pyplot as plt except Exception as e: lc = Lightcurve(self.times, self.counts) try: lc.plot() except Exception as e: assert type(e) is ImportError assert str(e) == "Matplotlib required for plot()"
def test_lc_baseline_offset(self): times = np.arange(0, 100, 0.01) input_stdev = 0.1 counts = np.random.normal(100, input_stdev, len(times)) + \ 0.001 * times gti = [[-0.005, 50.005], [59.005, 100.005]] good = create_gti_mask(times, gti) counts[np.logical_not(good)] = 0 lc = Lightcurve(times, counts, gti=gti) baseline = lc.baseline(10000, 0.01, offset_correction=True) assert np.isclose(np.std(lc.counts - baseline), input_stdev, rtol=0.1)
def test_truncate_by_time(self): lc = Lightcurve(self.times, self.counts, gti=self.gti) lc1 = lc.truncate(start=1, method='time') assert np.all(lc1.time == np.array([1, 2, 3, 4])) assert np.all(lc1.counts == np.array([2, 2, 2, 2])) np.testing.assert_almost_equal(lc1.gti[0][0], 0.5) lc2 = lc.truncate(stop=3, method='time') assert np.all(lc2.time == np.array([1, 2])) assert np.all(lc2.counts == np.array([2, 2])) np.testing.assert_almost_equal(lc2.gti[-1][-1], 2.5)
def test_lc_baseline_offset_fewbins(self): times = np.arange(0, 4, 1) input_stdev = 0.1 counts = np.random.normal(100, input_stdev, len(times)) + \ 0.001 * times gti = [[-0.005, 4.005]] lc = Lightcurve(times, counts, gti=gti) with pytest.warns(UserWarning) as record: lc.baseline(10000, 0.01, offset_correction=True) assert np.any(["Too few bins to perform baseline offset correction" in r.message.args[0] for r in record])
def test_join_overlapping_time_arrays(self): _times = [3, 4, 5, 6] _counts = [4, 4, 4, 4] lc1 = Lightcurve(self.times, self.counts) lc2 = Lightcurve(_times, _counts) with warnings.catch_warnings(record=True) as w: lc = lc1.join(lc2) assert "overlapping time ranges" in str(w[0].message) assert len(lc.counts) == len(lc.time) == 6 assert np.all(lc.counts == np.array([2, 2, 3, 3, 4, 4]))
def test_sort(self): _times = [1, 2, 3, 4] _counts = [40, 10, 20, 5] lc = Lightcurve(_times, _counts) lc.sort() assert np.all(lc.counts == np.array([ 5, 10, 20, 40])) assert np.all(lc.time == np.array([4, 2, 3, 1])) lc.sort(reverse=True) assert np.all(lc.counts == np.array([40, 20, 10, 5])) assert np.all(lc.time == np.array([1, 3, 2, 4]))
def test_shift(self): times = [1, 2, 3, 4, 5, 6, 7, 8] counts = [1, 1, 1, 1, 2, 3, 3, 2] lc = Lightcurve(times, counts, input_counts=True) lc2 = lc.shift(1) assert np.all(lc2.time - 1 == times) lc2 = lc.shift(-1) assert np.all(lc2.time + 1 == times) assert np.all(lc2.counts == lc.counts) assert np.all(lc2.countrate == lc.countrate) lc = Lightcurve(times, counts, input_counts=False) lc2 = lc.shift(1) assert np.all(lc2.counts == lc.counts) assert np.all(lc2.countrate == lc.countrate)
def test_truncate_by_index(self): lc = Lightcurve(self.times, self.counts, gti=self.gti) lc1 = lc.truncate(start=1) assert np.all(lc1.time == np.array([2, 3, 4])) assert np.all(lc1.counts == np.array([2, 2, 2])) np.testing.assert_almost_equal(lc1.gti[0][0], 1.5) assert lc1.mjdref == lc.mjdref lc2 = lc.truncate(stop=2) assert np.all(lc2.time == np.array([1, 2])) assert np.all(lc2.counts == np.array([2, 2])) np.testing.assert_almost_equal(lc2.gti[-1][-1], 2.5) assert lc2.mjdref == lc.mjdref
def test_rebin_with_gtis(self): times = np.arange(0, 100, 0.1) counts = np.random.normal(100, 0.1, size=times.shape[0]) gti = [[0, 40], [60, 100]] good = create_gti_mask(times, gti) counts[np.logical_not(good)] = 0 lc = Lightcurve(times, counts, gti=gti) lc_rebin = lc.rebin(1.0) assert (lc_rebin.time[39] - lc_rebin.time[38]) > 1.0
def test_split_lc_by_gtis(self): times = [1, 2, 3, 4, 5, 6, 7, 8] counts = [1, 1, 1, 1, 2, 3, 3, 2] gti = [[0.5, 4.5], [5.5, 7.5]] lc = Lightcurve(times, counts, gti=gti) list_of_lcs = lc.split_by_gti() lc0 = list_of_lcs[0] lc1 = list_of_lcs[1] assert np.all(lc0.time == [1, 2, 3, 4]) assert np.all(lc1.time == [6, 7]) assert np.all(lc0.counts == [1, 1, 1, 1]) assert np.all(lc1.counts == [3, 3]) assert np.all(lc0.gti == [[0.5, 4.5]]) assert np.all(lc1.gti == [[5.5, 7.5]])
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 test_sort_counts(self): _times = [1, 2, 3, 4] _counts = [40, 10, 20, 5] lc = Lightcurve(_times, _counts, mjdref=57000) mjdref = lc.mjdref lc_new = lc.sort_counts() assert np.all(lc_new.counts == np.array([5, 10, 20, 40])) assert np.all(lc_new.time == np.array([4, 2, 3, 1])) assert lc_new.mjdref == mjdref lc_new = lc.sort_counts(reverse=True) assert np.all(lc_new.counts == np.array([40, 20, 10, 5])) assert np.all(lc_new.time == np.array([1, 3, 2, 4])) assert lc_new.mjdref == mjdref
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 setUp(self): #dt = 1.0 #n = 10 dt = 0.0001220703125 n = 1384132 mean_counts = 2.0 times = np.arange(dt/2, dt/2+n*dt, dt) counts= np.zeros_like(times)+mean_counts self.lc = Lightcurve(times, counts)
class TestLightcurveRebin(object): def setUp(self): #dt = 1.0 #n = 10 dt = 0.0001220703125 n = 1384132 mean_counts = 2.0 times = np.arange(dt/2, dt/2+n*dt, dt) counts= np.zeros_like(times)+mean_counts self.lc = Lightcurve(times, counts) def test_rebin_even(self): dt_new = 2.0 lc_binned = self.lc.rebin_lightcurve(dt_new) assert np.isclose(lc_binned.dt, dt_new) counts_test = np.zeros_like(lc_binned.time) + \ self.lc.counts[0]*dt_new/self.lc.dt assert np.allclose(lc_binned.counts, counts_test) def test_rebin_odd(self): dt_new = 1.5 lc_binned = self.lc.rebin_lightcurve(dt_new) assert np.isclose(lc_binned.dt, dt_new) counts_test = np.zeros_like(lc_binned.time) + \ self.lc.counts[0]*dt_new/self.lc.dt assert np.allclose(lc_binned.counts, counts_test) def rebin_several(self, dt): """ TODO: Not sure how to write tests for the rebin method! """ lc_binned = self.lc.rebin_lightcurve(dt) assert len(lc_binned.time) == len(lc_binned.counts) def test_rebin_equal_numbers(self): dt_all = [2, 3, np.pi, 5] for dt in dt_all: yield self.rebin_several, 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 _simulate_model_string(self, model_str, params): """ For generating a light curve from a pre-defined model Parameters ---------- model_str: string name of the pre-defined model params: list or dictionary parameters of the pre-defined model Returns ------- lightCurve: `LightCurve` object """ # Frequencies at which the PSD is to be computed # (only positive frequencies, since the signal is real) nbins = self.red_noise*self.N simfreq = np.fft.rfftfreq(nbins, d=self.dt)[1:] if model_str in dir(models): if isinstance(params, dict): model = eval('models.' + model_str + '(**params)') # Compute PSD from model simpsd = model(simfreq) elif isinstance(params, list): simpsd = eval('models.' + model_str + '(simfreq, params)') else: raise ValueError('Params should be list or dictionary!') fac = np.sqrt(simpsd/2.) pos_real = self.random_state.normal(size=nbins//2)*fac pos_imag = self.random_state.normal(size=nbins//2)*fac long_lc = self._find_inverse(pos_real, pos_imag) lc = Lightcurve(self.time, self._extract_and_scale(long_lc), err_dist='gauss', dt=self.dt) return lc else: raise ValueError('Model is not defined!')
def test_fractional_rms_in_frac_norm_is_consistent_averaged(self): time = np.arange(0, 400, 1) + 0.5 poisson_counts = np.random.poisson(100.0, size=time.shape[0]) lc = Lightcurve(time, counts=poisson_counts, dt=1, gti=[[0, 400]]) ps = AveragedPowerspectrum(lc, norm="leahy", segment_size=100, silent=True) rms_ps_l, rms_err_l = ps.compute_rms(min_freq=ps.freq[1], max_freq=ps.freq[-1], white_noise_offset=0) ps = AveragedPowerspectrum(lc, norm="frac", segment_size=100) rms_ps, rms_err = ps.compute_rms(min_freq=ps.freq[1], max_freq=ps.freq[-1], white_noise_offset=0) assert np.allclose(rms_ps, rms_ps_l, atol=0.01) assert np.allclose(rms_err, rms_err_l, atol=0.01)
def _simulate_power_spectrum(self, s): """ Generate a light curve from user-provided spectrum. Parameters ---------- s : array-like power spectrum Returns ------- lightCurve : `LightCurve` object """ # Cast spectrum as numpy array s = np.array(s) if self.nphot == 0: nphot = 1.0 else: nphot = self.nphot self.std = np.sqrt( (nphot / (self.N**2.)) * (np.sum(s[:-1]) + 0.5 * s[-1])) self.red_noise = 1 # Draw two set of 'N' guassian distributed numbers a1 = self.random_state.normal(size=len(s)) a2 = self.random_state.normal(size=len(s)) real = a1 * nphot * np.sqrt(s) / 4.0 imaginary = a2 * nphot * np.sqrt(s) / 4.0 lc = self._find_inverse(real, imaginary) lc = Lightcurve(self.time, self._extract_and_scale(lc), err=np.zeros_like(self.time) + np.sqrt(self.mean), err_dist='gauss', dt=self.dt, skip_checks=True) return lc
def _simulate_impulse_response(self, s, h, mode='same'): """ Generate LightCurve from impulse response. To get accurate results, binning intervals (dt) of variability signal 's' and impulse response 'h' must be equal. Parameters ---------- s : array-like Underlying variability signal h : array-like Impulse response mode : str mode can be 'same', 'filtered, or 'full'. 'same' indicates that the length of output light curve is same as that of input signal. 'filtered' means that length of output light curve is len(s) - lag_delay 'full' indicates that the length of output light curve is len(s) + len(h) -1 Returns ------- lightCurve : :class:`stingray.lightcurve.LightCurve` object """ lc = signal.fftconvolve(s, h) if mode == 'same': lc = lc[:-(len(h) - 1)] elif mode == 'filtered': lc = lc[(len(h) - 1):-(len(h) - 1)] time = self.dt * np.arange(0.5, len(lc)) + self.tstart err = np.zeros_like(time) return Lightcurve(time, lc, err_dist='gauss', dt=self.dt, err=err, skip_checks=True)
def test_leahy_correct_for_multiple(self, legacy, use_common_mean): n = 10 lc_all = [] for i in range(n): time = np.arange(0.0, 10.0, 10. / 10000) counts = np.random.poisson(1000, size=time.shape[0]) lc = Lightcurve(time, counts) lc_all.append(lc) ps = AveragedPowerspectrum(lc_all, 1.0, norm="leahy", legacy=legacy, use_common_mean=use_common_mean) assert np.isclose(np.mean(ps.power), 2.0, atol=1e-2, rtol=1e-2) assert np.isclose(np.std(ps.power), 2.0 / np.sqrt(n * 10), atol=0.1, rtol=0.1)
def test_list_of_light_curves(self): n_lcs = 10 tstart = 0.0 tend = 1.0 dt = 0.0001 time = np.linspace(tstart, tend, int((tend - tstart) / dt)) mean_count_rate = 1000.0 mean_counts = mean_count_rate * dt lc_all = [] for n in range(n_lcs): poisson_counts = np.random.poisson(mean_counts, size=len(time)) lc = Lightcurve(time, counts=poisson_counts) lc_all.append(lc) segment_size = 0.5 assert AveragedPowerspectrum(lc_all, segment_size)
def _simulate_model(self, model): """ For generating a light curve from a pre-defined model Parameters ---------- model: astropy.modeling.Model derived function the pre-defined model (library-based, available in astropy.modeling.models or custom-defined) Returns ------- lightCurve: `LightCurve` object """ # Frequencies at which the PSD is to be computed # (only positive frequencies, since the signal is real) nbins = self.red_noise * self.N simfreq = np.fft.rfftfreq(nbins, d=self.dt)[1:] # Compute PSD from model simpsd = model(simfreq) fac = np.sqrt(simpsd / 2.) pos_real = self.random_state.normal(size=nbins // 2) * fac pos_imag = self.random_state.normal(size=nbins // 2) * fac pos_freq_transform = pos_real + 1j * pos_imag # Simulate light curve from its Fourier transform arg = np.concatenate(([self.mean], pos_freq_transform)) # Inverse Fourier transform long_lc = np.fft.irfft(arg) lc = Lightcurve(self.time, self._extract_and_scale(long_lc), err_dist='gauss', dt=self.dt) return lc
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 test_fractional_rms_in_frac_norm_is_consistent(self): """ Copied from test_powerspectrum.py """ time = np.arange(0, 100, 1) + 0.5 poisson_counts = np.random.poisson(100.0, size=time.shape[0]) lc = Lightcurve(time, counts=poisson_counts, dt=1, gti=[[0, 100]]) mtp = Multitaper(lc, norm="leahy") rms_mtp_l, rms_err_l = mtp.compute_rms(min_freq=mtp.freq[1], max_freq=mtp.freq[-1], white_noise_offset=0) mtp = Multitaper(lc, norm="frac") rms_mtp, rms_err = mtp.compute_rms(min_freq=mtp.freq[1], max_freq=mtp.freq[-1], white_noise_offset=0) assert np.allclose(rms_mtp, rms_mtp_l, atol=0.01) assert np.allclose(rms_err, rms_err_l, atol=0.01)
def test_sort(self): _times = [1, 2, 3, 4] _counts = [40, 10, 20, 5] lc = Lightcurve(_times, _counts, mjdref=57000) mjdref = lc.mjdref lc.sort() assert np.all(lc.counts == np.array([5, 10, 20, 40])) assert np.all(lc.time == np.array([4, 2, 3, 1])) assert lc.mjdref == mjdref lc.sort(reverse=True) assert np.all(lc.counts == np.array([40, 20, 10, 5])) assert np.all(lc.time == np.array([1, 3, 2, 4])) assert lc.mjdref == mjdref
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 _simulate_model(self, mod, p): """ For generating a light curve from pre-defined model Parameters ---------- mod: str name of the pre-defined model p: list iterable model parameters. For details, see model definitions in model.py Returns ------- lightCurve: `LightCurve` object """ # Define frequencies at which to compute PSD w = np.fft.rfftfreq(self.red_noise * self.N, d=self.dt)[1:] if mod in dir(models): mod = 'models.' + mod s = eval(mod + '(w, p)') # Draw two set of 'N' guassian distributed numbers a1 = np.random.normal(size=len(s)) a2 = np.random.normal(size=len(s)) long_lc = self._find_inverse(a1 * s, a2 * s) lc = Lightcurve(self.time, self._extract_and_scale(long_lc)) return lc else: raise ValueError('Model is not defined!')
def test_multitaper_lombscargle(self): rng = np.random.default_rng() N = 1000 white_noise_irregular = rng.normal(loc=0.0, scale=7, size=N) start = 0.0 end = 9.0 # Generating uneven sampling times by adding white noise. Do tell a better way time_irregular = np.linspace(start, end, N) + rng.normal(loc=0.0, scale=(end-start)/(3*N), size=N) time_irregular = np.sort(time_irregular) with pytest.warns(UserWarning) as record: lc_nonuni = Lightcurve(time=time_irregular, counts=white_noise_irregular, err_dist="gauss", err=np.ones_like(time_irregular) + np.sqrt(0.)) # Zero mean assert np.any(["aren't equal" in r.message.args[0] for r in record]) mtls_white = Multitaper(lc_nonuni, lombscargle=True, low_bias=True, NW=4) assert mtls_white.norm == "frac" assert mtls_white.fullspec is False assert mtls_white.meancounts == lc_nonuni.meancounts assert mtls_white.nphots == np.float64(np.sum(lc_nonuni.counts)) assert mtls_white.err_dist == lc_nonuni.err_dist assert mtls_white.dt == lc_nonuni.dt assert mtls_white.n == lc_nonuni.time.shape[0] assert mtls_white.df == 1.0 / lc_nonuni.tseg assert mtls_white.m == 1 assert mtls_white.freq is not None assert mtls_white.multitaper_norm_power is not None assert mtls_white.power is not None assert mtls_white.power_err is not None assert mtls_white.jk_var_deg_freedom is None # Not supported yet assert len(mtls_white.eigvals) > 0
def test_list_with_nonsense_component(self): n_lcs = 10 tstart = 0.0 tend = 1.0 dt = 0.0001 time = np.linspace(tstart, tend, int((tend - tstart) / dt)) mean_count_rate = 1000.0 mean_counts = mean_count_rate * dt lc_all = [] for n in range(n_lcs): poisson_counts = np.random.poisson(mean_counts, size=len(time)) lc = Lightcurve(time, counts=poisson_counts) lc_all.append(lc) lc_all.append(1.0) segment_size = 0.5 with pytest.raises(TypeError): assert AveragedPowerspectrum(lc_all, segment_size)
def test_indexing(self): lc = Lightcurve(self.times, self.counts) assert lc[0] == lc[1] == lc[2] == lc[3] == 2
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)
def test_n(self): lc = Lightcurve(self.times, self.counts) assert lc.n == 4
def test_lightcurve_from_toa(self): lc = Lightcurve.make_lightcurve(self.times, self.dt)
def test_plot_title(self): lc = Lightcurve(self.times, self.counts) lc.plot(title="Test Lightcurve") assert plt.fignum_exists(1)
def test_io_with_ascii(self): lc = Lightcurve(self.times, self.counts) lc.write('ascii_lc.txt', format_='ascii') lc.read('ascii_lc.txt', format_='ascii') os.remove('ascii_lc.txt')
def test_plot_custom_filename(self): lc = Lightcurve(self.times, self.counts) lc.plot(save=True, filename='lc.png') assert os.path.isfile('lc.png') os.unlink('lc.png')
def test_plot_axis(self): lc = Lightcurve(self.times, self.counts) lc.plot(axis=[0, 1, 0, 100]) assert plt.fignum_exists(1)
def test_plot_labels_index_error(self): lc = Lightcurve(self.times, self.counts) with warnings.catch_warnings(record=True) as w: lc.plot(labels=('x')) assert "must have two labels" in str(w[0].message)
def test_plot_default_filename(self): lc = Lightcurve(self.times, self.counts) lc.plot(save=True) assert os.path.isfile('out.png') os.unlink('out.png')
def test_plot_simple(self): lc = Lightcurve(self.times, self.counts) lc.plot() assert plt.fignum_exists(1)
def test_truncate_fails_with_incorrect_method(self): lc = Lightcurve(self.times, self.counts) with pytest.raises(ValueError): lc1 = lc.truncate(start=1, method="wrong")
def test_truncate_by_time_stop_less_than_start(self): lc = Lightcurve(self.times, self.counts) with pytest.raises(ValueError): lc1 = lc.truncate(start=2, stop=1, method='time')
def test_create(self): """ Demonstrate that we can create a trivial Lightcurve object. """ lc = Lightcurve(self.times, self.counts)
def test_slicing_index_error(self): lc = Lightcurve(self.times, self.counts) with pytest.raises(StingrayError): lc_new = lc[1:2]