def test_rebin_data_should_raise_error_when_method_is_different_than_allowed(self): dx_new = 2.0 try: utils.rebin_data(self.x, self.y, dx_new, method='not_allowed_method') except utils.UnrecognizedMethod: pass else: raise AssertionError("Expected exception does not occurred")
def test_rebin_data_should_raise_error_when_method_is_not_allowed(self): dx_new = 2.0 with pytest.raises(ValueError): utils.rebin_data(self.x, self.y, dx_new, self.yerr, method='not_allowed_method')
def test_rebin_data_should_raise_error_when_method_is_different_than_allowed( self): dx_new = 2.0 try: utils.rebin_data(self.x, self.y, dx_new, method='not_allowed_method') except utils.UnrecognizedMethod: pass else: raise AssertionError("Expected exception does not occurred")
def rebin(self, dt_new, method='sum'): """ Rebin the light curve to a new time resolution. While the new resolution need not be an integer multiple of the previous time resolution, be aware that if it is not, the last bin will be cut off by the fraction left over by the integer division. Parameters ---------- dt_new: float The new time resolution of the light curve. Must be larger than the time resolution of the old light curve! method: {"sum" | "mean" | "average"}, optional, default "sum" This keyword argument sets whether the counts in the new bins should be summed or averaged. Returns ------- lc_new: :class:`Lightcurve` object The :class:`Lightcurve` object with the new, binned light curve. """ if dt_new < self.dt: raise ValueError("New time resolution must be larger than " "old time resolution!") bin_time, bin_counts, _ = utils.rebin_data(self.time, self.counts, dt_new, method) lc_new = Lightcurve(bin_time, bin_counts) return lc_new
def rebin_frequency(self, df_new, method="sum"): """ Rebin the Dynamic Power Spectrum to a new frequency resolution. While the new resolution need not be an integer multiple of the previous frequency resolution, be aware that if it is not, the last bin will be cut off by the fraction left over by the integer division. Parameters ---------- df_new: float The new frequency resolution of the Dynamica Power Spectrum. Must be larger than the frequency resolution of the old Dynamical Power Spectrum! method: {"sum" | "mean" | "average"}, optional, default "sum" This keyword argument sets whether the counts in the new bins should be summed or averaged. """ dynspec_new = [] for data in self.dyn_ps.T: freq_new, bin_counts, bin_err, _ = \ utils.rebin_data(self.freq, data, dx_new=df_new, method=method) dynspec_new.append(bin_counts) self.freq = freq_new self.dyn_ps = np.array(dynspec_new).T self.df = df_new
def rebin(self, df, method="mean"): """ Rebin the cross spectrum to a new frequency resolution df. Parameters ---------- df: float The new frequency resolution Returns ------- bin_cs = Crossspectrum object The newly binned cross spectrum """ # rebin cross spectrum to new resolution binfreq, bincs, step_size = utils.rebin_data(self.freq[1:], self.power[1:], df, method=method) # make an empty cross spectrum object # note: syntax deliberate to work with subclass Powerspectrum bin_cs = self.__class__() # store the binned periodogram in the new object bin_cs.freq = np.hstack([binfreq[0]-self.df, binfreq]) bin_cs.power = np.hstack([self.power[0], bincs]) bin_cs.df = df bin_cs.n = self.n bin_cs.norm = self.norm bin_cs.nphots1 = self.nphots1 bin_cs.nphots2 = self.nphots2 bin_cs.m = int(step_size) return bin_cs
def rebin_frequency(self, df_new, method="sum"): """ Rebin the Dynamic Power Spectrum to a new frequency resolution. Rebinning is an in-place operation, i.e. will replace the existing ``dyn_ps`` attribute. While the new resolution need not be an integer multiple of the previous frequency resolution, be aware that if it is not, the last bin will be cut off by the fraction left over by the integer division. Parameters ---------- df_new: float The new frequency resolution of the Dynamical Power Spectrum. Must be larger than the frequency resolution of the old Dynamical Power Spectrum! method: {``sum`` | ``mean`` | ``average``}, optional, default ``sum`` This keyword argument sets whether the counts in the new bins should be summed or averaged. """ new_dynspec_object = copy.deepcopy(self) dynspec_new = [] for data in self.dyn_ps.T: freq_new, bin_counts, bin_err, _ = \ utils.rebin_data(self.freq, data, dx_new=df_new, method=method) dynspec_new.append(bin_counts) new_dynspec_object.freq = freq_new new_dynspec_object.dyn_ps = np.array(dynspec_new).T new_dynspec_object.df = df_new return new_dynspec_object
def rebin(self, df, method="mean"): """ Rebin the periodogram to a new frequency resolution df. Parameters ---------- df: float The new frequency resolution Returns ------- bin_ps = Periodogram object The newly binned periodogram """ ## rebin power spectrum to new resolution binfreq, binps, step_size = utils.rebin_data(self.freq[1:], self.ps[1:], df, method=method) ## make an empty periodogram object bin_ps = Powerspectrum() ## store the binned periodogram in the new object bin_ps.norm = self.norm bin_ps.freq = np.hstack([binfreq[0]-self.df, binfreq]) bin_ps.ps = np.hstack([self.ps[0], binps]) bin_ps.df = df bin_ps.n = self.n bin_ps.nphots = self.nphots bin_ps.m = int(step_size) return bin_ps
def rebin(self, df, method="mean"): """ Rebin the periodogram to a new frequency resolution df. Parameters ---------- df: float The new frequency resolution Returns ------- bin_ps = Periodogram object The newly binned periodogram """ ## rebin power spectrum to new resolution binfreq, binps, step_size = utils.rebin_data(self.freq[1:], self.ps[1:], df, method=method) ## make an empty periodogram object bin_ps = Powerspectrum() ## store the binned periodogram in the new object bin_ps.norm = self.norm bin_ps.freq = np.hstack([binfreq[0] - self.df, binfreq]) bin_ps.ps = np.hstack([self.ps[0], binps]) bin_ps.df = df bin_ps.n = self.n bin_ps.nphots = self.nphots bin_ps.m = int(step_size) return bin_ps
def test_binned_counts(self): dx_new = 2.0 xbin, ybin, step_size = utils.rebin_data(self.x, self.y, dx_new) ybin_test = np.zeros_like(xbin) + self.counts*dx_new/self.dx assert np.allclose(ybin, ybin_test)
def test_uneven_binned_counts(self): dx_new = 1.5 xbin, ybin, step_size = utils.rebin_data(self.x, self.y, dx_new) print(xbin) print(ybin) ybin_test = np.zeros_like(xbin) + self.counts*dx_new/self.dx assert np.allclose(ybin_test, ybin)
def test_uneven_binned_counts(self): dx_new = 1.5 xbin, ybin, step_size = utils.rebin_data(self.x, self.y, dx_new) print(xbin) print(ybin) ybin_test = np.zeros_like(xbin) + self.counts * dx_new / self.dx assert np.allclose(ybin_test, ybin)
def test_binned_counts(self): dx_new = 2.0 xbin, ybin, step_size = utils.rebin_data(self.x, self.y, dx_new) ybin_test = np.zeros_like(xbin) + self.counts * dx_new / self.dx assert np.allclose(ybin, ybin_test)
def rebin(self, dt_new=None, f=None, method='sum'): """ Rebin the light curve to a new time resolution. While the new resolution need not be an integer multiple of the previous time resolution, be aware that if it is not, the last bin will be cut off by the fraction left over by the integer division. Parameters ---------- dt_new: float The new time resolution of the light curve. Must be larger than the time resolution of the old light curve! method: {"sum" | "mean" | "average"}, optional, default "sum" This keyword argument sets whether the counts in the new bins should be summed or averaged. Other Parameters ---------------- f: float the rebin factor. If specified, it substitutes dt_new with f*self.dt Returns ------- lc_new: :class:`Lightcurve` object The :class:`Lightcurve` object with the new, binned light curve. """ if f is None and dt_new is None: raise ValueError('You need to specify at least one between f and ' 'dt_new') elif f is not None: dt_new = f * self.dt if dt_new < self.dt: raise ValueError("New time resolution must be larger than " "old time resolution!") bin_time, bin_counts, bin_err, _ = \ utils.rebin_data(self.time, self.counts, dt_new, yerr=self.counts_err, method=method) lc_new = Lightcurve(bin_time, bin_counts, err=bin_err, mjdref=self.mjdref, dt=dt_new) return lc_new
def test_rebin_variable_input_sampling(self): x1 = np.linspace(0, 10, 11) x2 = np.linspace(10.33, 20.0, 30) x3 = np.linspace(21, 30, 10) x = np.hstack([x1, x2, x3]) counts = 2.0 y = np.zeros_like(x) + counts yerr = np.sqrt(y) dx_new = 1.5 xbin, ybin, yerr_bin, step_size = utils.rebin_data(x, y, dx_new, yerr) assert np.allclose(ybin, counts * step_size) assert len(xbin) == 20
def rebin(self, df, method="mean"): """ Rebin the cross spectrum to a new frequency resolution df. Parameters ---------- df: float The new frequency resolution Returns ------- bin_cs = Crossspectrum object The newly binned cross spectrum """ # rebin cross spectrum to new resolution binfreq, bincs, binerr, step_size = \ rebin_data(self.freq, self.power, df, self.power_err, method=method) # make an empty cross spectrum object # note: syntax deliberate to work with subclass Powerspectrum bin_cs = self.__class__() # store the binned periodogram in the new object bin_cs.freq = binfreq bin_cs.power = bincs bin_cs.df = df bin_cs.n = self.n bin_cs.norm = self.norm bin_cs.nphots1 = self.nphots1 bin_cs.power_err = binerr try: bin_cs.nphots2 = self.nphots2 except AttributeError: if self.type == 'powerspectrum': pass else: raise AttributeError( 'Spectrum has no attribute named nphots2.') bin_cs.m = int(step_size) * self.m return bin_cs
def rebin_time(self, dt_new, method='sum'): """ Rebin the Dynamic Power Spectrum to a new time resolution. While the new resolution need not be an integer multiple of the previous time resolution, be aware that if it is not, the last bin will be cut off by the fraction left over by the integer division. Parameters ---------- dt_new: float The new time resolution of the Dynamical Power Spectrum. Must be larger than the time resolution of the old Dynamical Power Spectrum! method: {"sum" | "mean" | "average"}, optional, default "sum" This keyword argument sets whether the counts in the new bins should be summed or averaged. Returns ------- time_new: numpy.ndarray Time axis with new rebinned time resolution. dynspec_new: numpy.ndarray New rebinned Dynamical Power Spectrum. """ if dt_new < self.dt: raise ValueError("New time resolution must be larger than " "old time resolution!") new_dynspec_object = copy.deepcopy(self) dynspec_new = [] for data in self.dyn_ps: time_new, bin_counts, bin_err, _ = \ utils.rebin_data(self.time, data, dt_new, method=method) dynspec_new.append(bin_counts) new_dynspec_object.time = time_new new_dynspec_object.dyn_ps = np.array(dynspec_new) new_dynspec_object.dt = dt_new return new_dynspec_object
def rebin(self, df, method="mean"): """ Rebin the cross spectrum to a new frequency resolution df. Parameters ---------- df: float The new frequency resolution Returns ------- bin_cs = Crossspectrum object The newly binned cross spectrum """ # rebin cross spectrum to new resolution binfreq, bincs, step_size = utils.rebin_data(self.freq, self.power, df, method=method) # make an empty cross spectrum object # note: syntax deliberate to work with subclass Powerspectrum bin_cs = self.__class__() # store the binned periodogram in the new object bin_cs.freq = binfreq bin_cs.power = bincs bin_cs.df = df bin_cs.n = self.n bin_cs.norm = self.norm bin_cs.nphots1 = self.nphots1 try: bin_cs.nphots2 = self.nphots2 except AttributeError: if self.type == 'powerspectrum': pass else: raise AttributeError('Spectrum has no attribute named nphots2.') bin_cs.m = int(step_size)*self.m return bin_cs
def rebin_time(self, dt_new, method='sum'): """ Rebin the Dynamic Power Spectrum to a new time resolution. While the new resolution need not be an integer multiple of the previous time resolution, be aware that if it is not, the last bin will be cut off by the fraction left over by the integer division. Parameters ---------- dt_new: float The new time resolution of the Dynamica Power Spectrum. Must be larger than the time resolution of the old Dynamical Power Spectrum! method: {"sum" | "mean" | "average"}, optional, default "sum" This keyword argument sets whether the counts in the new bins should be summed or averaged. Returns ------- time_new: numpy.ndarray Time axis with new rebinned time resolution. dynspec_new: numpy.ndarray New rebinned Dynamical Power Spectrum. """ if dt_new < self.dt: raise ValueError("New time resolution must be larger than " "old time resolution!") dynspec_new = [] for data in self.dyn_ps: time_new, bin_counts, bin_err, _ = \ utils.rebin_data(self.time, data, dt_new, method=method) dynspec_new.append(bin_counts) self.time = time_new self.dyn_ps = np.array(dynspec_new) self.dt = dt_new
def rebin(self, df, method="mean"): """ Rebin the cross spectrum to a new frequency resolution df. Parameters ---------- df: float The new frequency resolution Returns ------- bin_cs = Crossspectrum object The newly binned cross spectrum """ # rebin cross spectrum to new resolution binfreq, bincs, step_size = utils.rebin_data(self.freq, self.power, df, method=method) # make an empty cross spectrum object # note: syntax deliberate to work with subclass Powerspectrum bin_cs = self.__class__() # store the binned periodogram in the new object bin_cs.freq = binfreq bin_cs.power = bincs bin_cs.df = df bin_cs.n = self.n bin_cs.norm = self.norm bin_cs.nphots1 = self.nphots1 bin_cs.nphots2 = self.nphots2 bin_cs.m = int(step_size) * self.m return bin_cs
def test_length_matches(self): dx_new = 2.0 xbin, ybin, step_size = utils.rebin_data(self.x, self.y, dx_new) assert xbin.shape[0] == ybin.shape[0]
def test_arrays(self): dx_new = 2.0 xbin, ybin, step_size = utils.rebin_data(self.x, self.y, dx_new) assert isinstance(xbin, np.ndarray) assert isinstance(ybin, np.ndarray)
def test_new_stepsize(self): dx_new = 2.0 xbin, ybin, step_size = utils.rebin_data(self.x, self.y, dx_new) assert step_size == dx_new/self.dx
def rebin(self, dt_new=None, f=None, method='sum'): """ Rebin the light curve to a new time resolution. While the new resolution need not be an integer multiple of the previous time resolution, be aware that if it is not, the last bin will be cut off by the fraction left over by the integer division. Parameters ---------- dt_new: float The new time resolution of the light curve. Must be larger than the time resolution of the old light curve! method: {``sum`` | ``mean`` | ``average``}, optional, default ``sum`` This keyword argument sets whether the counts in the new bins should be summed or averaged. Other Parameters ---------------- f: float the rebin factor. If specified, it substitutes ``dt_new`` with ``f*self.dt`` Returns ------- lc_new: :class:`Lightcurve` object The :class:`Lightcurve` object with the new, binned light curve. """ if f is None and dt_new is None: raise ValueError('You need to specify at least one between f and ' 'dt_new') elif f is not None: dt_new = f * self.dt if dt_new < self.dt: raise ValueError("New time resolution must be larger than " "old time resolution!") if self.gti is None: bin_time, bin_counts, bin_err, _ = \ utils.rebin_data(self.time, self.counts, dt_new, yerr=self.counts_err, method=method) else: bin_time, bin_counts, bin_err = [], [], [] gti_new = [] for g in self.gti: if g[1] - g[0] < dt_new: continue else: # find start and end of GTI segment in data start_ind = self.time.searchsorted(g[0]) end_ind = self.time.searchsorted(g[1]) t_temp = self.time[start_ind:end_ind] c_temp = self.counts[start_ind:end_ind] e_temp = self.counts_err[start_ind:end_ind] bin_t, bin_c, bin_e, _ = \ utils.rebin_data(t_temp, c_temp, dt_new, yerr=e_temp, method=method) bin_time.extend(bin_t) bin_counts.extend(bin_c) bin_err.extend(bin_e) gti_new.append(g) lc_new = Lightcurve(bin_time, bin_counts, err=bin_err, mjdref=self.mjdref, dt=dt_new, gti=gti_new) return lc_new
def test_uneven_bins(self): dx_new = 1.5 xbin, ybin, yerr, step_size = utils.rebin_data(self.x, self.y, dx_new, self.yerr) assert np.isclose(xbin[1]-xbin[0], dx_new)
def test_length_matches(self): dx_new = 2.0 xbin, ybin, yerr, step_size = utils.rebin_data(self.x, self.y, dx_new, self.yerr) assert xbin.shape[0] == ybin.shape[0]
def test_arrays(self): dx_new = 2.0 xbin, ybin, yerr, step_size = utils.rebin_data(self.x, self.y, dx_new, self.yerr) assert isinstance(xbin, np.ndarray) assert isinstance(ybin, np.ndarray)
def test_new_stepsize(self): dx_new = 2.0 xbin, ybin, yerr, step_size = utils.rebin_data(self.x, self.y, dx_new, self.yerr) assert step_size == dx_new/self.dx
def test_uneven_bins(self): dx_new = 1.5 xbin, ybin, step_size = utils.rebin_data(self.x, self.y, dx_new) assert np.isclose(xbin[1]-xbin[0], dx_new)
def rebin(self, df=None, f=None, method="mean"): """ Rebin the cross spectrum to a new frequency resolution df. Parameters ---------- df: float The new frequency resolution Other Parameters ---------------- f: float the rebin factor. If specified, it substitutes df with f*self.df Returns ------- bin_cs = Crossspectrum (or one of its subclasses) object The newly binned cross spectrum or power spectrum. Note: this object will be of the same type as the object that called this method. For example, if this method is called from `AveragedPowerspectrum`, it will return an object of class `AveragedPowerspectrum`, too. """ if f is None and df is None: raise ValueError('You need to specify at least one between f and ' 'df') elif f is not None: df = f * self.df # rebin cross spectrum to new resolution binfreq, bincs, binerr, step_size = \ rebin_data(self.freq, self.power, df, self.power_err, method=method, dx=self.df) # make an empty cross spectrum object # note: syntax deliberate to work with subclass Powerspectrum bin_cs = copy.copy(self) # store the binned periodogram in the new object bin_cs.freq = binfreq bin_cs.power = bincs bin_cs.df = df bin_cs.n = self.n bin_cs.norm = self.norm bin_cs.nphots1 = self.nphots1 bin_cs.power_err = binerr if hasattr(self, 'unnorm_power'): _, binpower_unnorm, _, _ = \ rebin_data(self.freq, self.unnorm_power, df, method=method, dx=self.df) bin_cs.unnorm_power = binpower_unnorm if hasattr(self, 'cs_all'): cs_all = [] for c in self.cs_all: cs_all.append(c.rebin(df=df, f=f, method=method)) bin_cs.cs_all = cs_all if hasattr(self, 'pds1'): bin_cs.pds1 = self.pds1.rebin(df=df, f=f, method=method) if hasattr(self, 'pds2'): bin_cs.pds2 = self.pds2.rebin(df=df, f=f, method=method) try: bin_cs.nphots2 = self.nphots2 except AttributeError: if self.type == 'powerspectrum': pass else: raise AttributeError('Spectrum has no attribute named nphots2.') bin_cs.m = np.rint(step_size * self.m) return bin_cs
def rebin(self, df=None, f=None, method="mean"): """ Rebin the cross spectrum to a new frequency resolution ``df``. Parameters ---------- df: float The new frequency resolution Other Parameters ---------------- f: float the rebin factor. If specified, it substitutes df with ``f*self.df`` Returns ------- bin_cs = :class:`Crossspectrum` (or one of its subclasses) object The newly binned cross spectrum or power spectrum. Note: this object will be of the same type as the object that called this method. For example, if this method is called from :class:`AveragedPowerspectrum`, it will return an object of class :class:`AveragedPowerspectrum`, too. """ if f is None and df is None: raise ValueError('You need to specify at least one between f and ' 'df') elif f is not None: df = f * self.df # rebin cross spectrum to new resolution binfreq, bincs, binerr, step_size = \ rebin_data(self.freq, self.power, df, self.power_err, method=method, dx=self.df) # make an empty cross spectrum object # note: syntax deliberate to work with subclass Powerspectrum bin_cs = copy.copy(self) # store the binned periodogram in the new object bin_cs.freq = binfreq bin_cs.power = bincs bin_cs.df = df bin_cs.n = self.n bin_cs.norm = self.norm bin_cs.nphots1 = self.nphots1 bin_cs.power_err = binerr if hasattr(self, 'unnorm_power'): _, binpower_unnorm, _, _ = \ rebin_data(self.freq, self.unnorm_power, df, method=method, dx=self.df) bin_cs.unnorm_power = binpower_unnorm if hasattr(self, 'cs_all'): cs_all = [] for c in self.cs_all: cs_all.append(c.rebin(df=df, f=f, method=method)) bin_cs.cs_all = cs_all if hasattr(self, 'pds1'): bin_cs.pds1 = self.pds1.rebin(df=df, f=f, method=method) if hasattr(self, 'pds2'): bin_cs.pds2 = self.pds2.rebin(df=df, f=f, method=method) try: bin_cs.nphots2 = self.nphots2 except AttributeError: if self.type == 'powerspectrum': pass else: raise AttributeError( 'Spectrum has no attribute named nphots2.') bin_cs.m = np.rint(step_size * self.m) return bin_cs
def test_rebin_data_should_raise_error_when_method_is_different_than_allowed(self): dx_new = 2.0 with pytest.raises(ValueError): utils.rebin_data(self.x, self.y, dx_new, method='not_allowed_method')