本文整理汇总了Python中stingray.utils.rebin_data函数的典型用法代码示例。如果您正苦于以下问题：Python rebin_data函数的具体用法？Python rebin_data怎么用？Python rebin_data使用的例子？那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了rebin_data函数的15个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: test_rebin_data_should_raise_error_when_method_is_different_than_allowed
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")示例2: test_binned_counts
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)示例3: rebin
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示例4: rebin
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示例5: rebin_frequency
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示例6: rebin
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示例7: test_uneven_binned_counts
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)示例8: rebin
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示例9: rebin_time
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示例10: rebin
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示例11: rebin
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示例12: test_rebin_data_should_raise_error_when_method_is_different_than_allowed
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')示例13: test_uneven_bins
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)示例14: rebin
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示例15: test_length_matches
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]