Gravitational-wave detectors are time-domain instruments, attempting to record gravitational-wave amplitude as a differential change in the lengths of each of the interferometer arms. The primary output of these detectors is a single time-stream of gravitational-wave strain.
Alongside these data, thousands of auxiliary instrumental control and error signals and environmental monitors are recorded in real-time and recorded to disk and archived for off-line study.
The data are archived in .gwf
files, a custom binary format that efficiently stores the time streams and all necessary metadata, for more details about this particular data format, take a look at the specification document LIGO-T970130.
GWpy provides ways to download these data, one for authorised collaborators, and another for public data releases:
Method | Restricted? | Description |
---|---|---|
TimeSeries.get |
LIGO.ORG | Fetch data via NDS2 or gw_data_find |
TimeSeries.fetch_open_data |
public | Fetch data from LIGO Open Science Center (LOSC) |
For example, to fetch 32 seconds of strain data around event GW150914:
from gwpy.timeseries import TimeSeries
data = TimeSeries.fetch_open_data('L1', 1126259446, 1126259478)
Here the 'L1'
refers to the LIGO Livingston Observatory ('H1'
would be the LIGO Hanford Observatory), and the two 10-digit numbers are GPS times (for more details on GPS timing, see Times and timestamps). You could just as easily use a more readable format:
data = TimeSeries.fetch_open_data('L1', 'Sep 14 2015 09:50:29', 'Sep 14 2015 09:51:01')
Note
These data are part of small snippet of LIGO data provided by the LIGO Open Science Center, and are freely available to the public, see the LOSC website for full details on which data are available.
If you have LIGO.ORG credentials, meaning you’re a member of the LIGO Scientific Collaboration or the Virgo Collaboration, you need to specify the exact name of the channel you want:
data = TimeSeries.get('H1:GDS-CALIB_STRAIN', 1126259446, 1126259478)
With authenticated access, you also have access to the thousands of auxiliary channels mentioned above, if you run.:
gnd = TimeSeries.get('L1:ISI-GND_STS_ITMY_Z_DQ', 'Jan 1 2016', 'Jan 1 2016 01:00')
you’ll get back one hour of data from the vertical-ground-motion seismometer located near the ITMY vacuum enclosure at LIGO Livingston.
The TimeSeries.get
method tries direct file access (using glue.datafind
for file discovery) first, then falls back to using the Network Data Server (NDS2) for remote access. If you want to manually use NDS2 for remote access you can instead use the TimeSeries.fetch
method.
If you have direct access to one or more files of data, either on the LIGO Data Grid (where the gwf
files are stored) or you have some files of your own, you can use the TimeSeries.read
method:
This method is an example of the unified input/output system provided by astropy, so should respond in the same way whether you give it a gwf
file, or an ''hdf5''
file, or a simple ''txt''
file.:
data = TimeSeries.read(‘mydata.gwf’, ‘L1:GDS-CALIB_STRAIN’)
Note
The input options to TimeSeries.read
depend on what format the source data are in, please refer to the function documentation for details and examples
If you are on the LIGO Data Grid, but you don’t know where the files are, you can use the TimeSeries.find
method to automatically locate and read data for a given channel:
data = TimeSeries.find('L1:ISI-GND_STS_ITMY_Z_DQ', 'Jan 1 2016', 'Jan 1 2016 01:00')
Because typically each gwf
file contains data for a large number of channels, it is inefficient to ask for data for each channel in turn, since that would meaning opening, decoding, and closing each file every time.
Instead you can read all of the data you want in a single step, using the TimeSeriesDict
object, either for remote access:
from gwpy.timeseries import TimeSeriesDict
alldata = TimeSeriesDict.fetch(['H1:ISI-GND_STS_ITMX_X_DQ', 'H1:SUS-ITMX_L2_WIT_L_DQ', 'Feb 1 09:00', 'Feb 1 09:15')
or from gwf
files:
alldata = TimeSeriesDict.get(['H1:PSL-PWR_PMC_TRANS_OUT16','H1:IMC-PWR_IN_OUT16'], 'Feb 1 00:00', 'Feb 1 02:00') # fetch the data via NDS
[These two channels represent the power generated by the Pre-Stabilized Laser at the input to interferometer, and the power actually entering the Input Mode Cleaner.]
TimeSeries
¶The TimeSeries
object comes with its own plot()
method, which will quickly construct a TimeSeriesPlot
.
In the following example, we download ten seconds of gravitational-wave strain data from the LIGO Hanford Observatory, and display it:
(Source code, png)
And similarly for the TimeSeriesDict
(using plot
):
(Source code, png)
The gwpy.timeseries
module provides the following class
objects for handling instrumental data:
TimeSeries |
A time-domain data array |
TimeSeriesList |
Ordered key-value mapping of named TimeSeries objects |
TimeSeriesDict |
Ordered key-value mapping of named TimeSeries objects |
gwpy.timeseries.
TimeSeries
[source]¶Bases: gwpy.timeseries.core.TimeSeriesBase
A time-domain data array
Parameters: | value : array-like
unit :
epoch :
sample_rate :
times :
name :
dtype :
copy :
subok :
|
---|
Examples
Any regular array, i.e. any iterable collection of data, can be
easily converted into a TimeSeries
:
>>> data = numpy.asarray([1,2,3])
>>> series = TimeSeries(data)
The necessary metadata to reconstruct timing information are recorded
in the epoch
and sample_rate
attributes. This time-stamps can be
returned via the times
property.
All comparison operations performed on a TimeSeries
will return a
StateTimeSeries
- a boolean array
with metadata copied from the starting TimeSeries
.
Key Methods
fetch (*args, **kwargs) |
Fetch data from NDS into a TimeSeries . |
read (*args, **kwargs) |
Read data into a TimeSeries |
write (data, *args, **kwargs) |
Write this TimeSeries to a file |
plot (**kwargs) |
Plot the data for this TimeSeries. |
Attributes Summary
T |
Same as self.transpose(), except that self is returned if self.ndim < 2. |
base |
Base object if memory is from some other object. |
cgs |
Returns a copy of the current Quantity instance with CGS units. |
channel |
Instrumental channel associated with these data |
ctypes |
An object to simplify the interaction of the array with the ctypes module. |
data |
|
dt |
X-axis sample separation |
dtype |
Data-type of the array’s elements. |
duration |
Duration of this series in seconds |
dx |
X-axis sample separation |
epoch |
GPS epoch for these data. |
equivalencies |
A list of equivalencies that will be applied by default during unit conversions. |
flags |
Information about the memory layout of the array. |
flat |
A 1-D iterator over the Quantity array. |
imag |
The imaginary part of the array. |
info |
Container for meta information like name, description, format. |
isscalar |
True if the value of this quantity is a scalar, or False if it is an array-like object. |
itemsize |
Length of one array element in bytes. |
name |
Name for this data set |
nbytes |
Total bytes consumed by the elements of the array. |
ndim |
Number of array dimensions. |
real |
The real part of the array. |
sample_rate |
Data rate for this TimeSeries in samples per second (Hertz). |
shape |
Tuple of array dimensions. |
si |
Returns a copy of the current Quantity instance with SI units. |
size |
Number of elements in the array. |
span |
X-axis [low, high) segment encompassed by these data |
strides |
Tuple of bytes to step in each dimension when traversing an array. |
times |
Series of GPS times for each sample |
unit |
The physical unit of these data |
value |
The numerical value of this quantity. |
x0 |
X-axis value of the first data point |
xindex |
Positions of the data on the x-axis |
xspan |
X-axis [low, high) segment encompassed by these data |
xunit |
Unit of x-axis index |
Methods Summary
all ([axis, out, keepdims]) |
Returns True if all elements evaluate to True. |
any ([axis, out, keepdims]) |
Returns True if any of the elements of a evaluate to True. |
append (other[, gap, inplace, pad, resize]) |
Connect another series onto the end of the current one. |
argmax ([axis, out]) |
Return indices of the maximum values along the given axis. |
argmin ([axis, out]) |
Return indices of the minimum values along the given axis of a . |
argpartition (kth[, axis, kind, order]) |
Returns the indices that would partition this array. |
argsort ([axis, kind, order]) |
Returns the indices that would sort this array. |
asd ([fftlength, overlap, method]) |
Calculate the ASD FrequencySeries of this TimeSeries . |
astype (dtype[, order, casting, subok, copy]) |
Copy of the array, cast to a specified type. |
auto_coherence (dt[, fftlength, overlap, window]) |
Calculate the frequency-coherence between this TimeSeries and a time-shifted copy of itself. |
average_fft ([fftlength, overlap, window]) |
Compute the averaged one-dimensional DFT of this TimeSeries . |
bandpass (flow, fhigh[, gpass, gstop, stops]) |
Filter this TimeSeries by applying low- and high-pass filters. |
byteswap (inplace) |
Swap the bytes of the array elements |
choose (choices[, out, mode]) |
Use an index array to construct a new array from a set of choices. |
clip ([min, max, out]) |
Return an array whose values are limited to [min, max] . |
coherence (other[, fftlength, overlap, window]) |
Calculate the frequency-coherence between this TimeSeries and another. |
coherence_spectrogram (other, stride[, ...]) |
Calculate the coherence spectrogram between this TimeSeries and other. |
compress (condition[, axis, out]) |
Return selected slices of this array along given axis. |
conj () |
Complex-conjugate all elements. |
conjugate () |
Return the complex conjugate, element-wise. |
copy ([order]) |
Return a copy of the array. |
copy_metadata () |
Return a deepcopy of the metadata for this array |
crop ([start, end, copy]) |
Crop this series to the given x-axis extent. |
csd (other[, fftlength, overlap]) |
Calculate the CSD FrequencySeries for two TimeSeries |
csd_spectrogram (other, stride[, fftlength, ...]) |
Calculate the cross spectral density spectrogram of this TimeSeries with ‘other’. |
cumprod ([axis, dtype, out]) |
Return the cumulative product of the elements along the given axis. |
cumsum ([axis, dtype, out]) |
Return the cumulative sum of the elements along the given axis. |
decompose ([bases]) |
Generates a new Quantity with the units decomposed. |
detrend ([detrend]) |
Remove the trend from this TimeSeries |
diagonal ([offset, axis1, axis2]) |
Return specified diagonals. |
diff ([n, axis]) |
Calculate the n-th discrete difference along given axis. |
dot (b[, out]) |
Dot product of two arrays. |
dump (file) |
Dump a pickle of the array to the specified file. |
dumps () |
Returns the pickle of the array as a string. |
ediff1d ([to_end, to_begin]) |
|
fetch (*args, **kwargs) |
Fetch data from NDS into a TimeSeries . |
fetch_open_data (ifo, start, end[, name, ...]) |
Fetch open-access data from the LIGO Open Science Center |
fft ([nfft]) |
Compute the one-dimensional discrete Fourier transform of this TimeSeries . |
fftgram (stride) |
Calculate the Fourier-gram of this TimeSeries . |
fill (value) |
Fill the array with a scalar value. |
filter (*filt) |
Apply the given filter to this TimeSeries . |
find (channel, start, end[, frametype, pad, ...]) |
Find and read data from frames for a channel |
flatten ([order]) |
Return a copy of the array collapsed into one dimension. |
from_hdf5 (*args, **kwargs) |
Read an array from the given HDF file. |
from_lal (*args, **kwargs) |
Generate a new TimeSeries from a LAL TimeSeries of any type. |
from_nds2_buffer (*args, **kwargs) |
Construct a new TimeSeries from an nds2.buffer object |
from_pycbc (ts) |
Convert a pycbc.types.timeseries.TimeSeries into a TimeSeries |
get (channel, start, end[, pad, dtype, verbose]) |
Get data for this channel from frames or NDS |
getfield (dtype[, offset]) |
Returns a field of the given array as a certain type. |
highpass (frequency[, gpass, gstop, stop]) |
Filter this TimeSeries with a Butterworth high-pass filter. |
insert (obj, values[, axis]) |
Insert values along the given axis before the given indices and return a new Quantity object. |
is_compatible (other) |
Check whether this series and other have compatible metadata |
is_contiguous (other[, tol]) |
Check whether other is contiguous with self. |
item (*args) |
Copy an element of an array to a standard Python scalar and return it. |
itemset (*args) |
Insert scalar into an array (scalar is cast to array’s dtype, if possible) |
lowpass (frequency[, gpass, gstop, stop]) |
Filter this TimeSeries with a Butterworth low-pass filter. |
max ([axis, out]) |
Return the maximum along a given axis. |
mean ([axis, dtype, out, keepdims]) |
Returns the average of the array elements along given axis. |
median ([axis]) |
Compute the median along the specified axis. |
min ([axis, out, keepdims]) |
Return the minimum along a given axis. |
nansum ([axis, out, keepdims]) |
|
newbyteorder ([new_order]) |
Return the array with the same data viewed with a different byte order. |
nonzero () |
Return the indices of the elements that are non-zero. |
notch (frequency[, type]) |
Notch out a frequency in a TimeSeries |
override_unit (unit[, parse_strict]) |
Forcefully reset the unit of these data |
pad (pad_width, **kwargs) |
Pad this series to a new size |
partition (kth[, axis, kind, order]) |
Rearranges the elements in the array in such a way that value of the element in kth position is in the position it would be in a sorted array. |
plot (**kwargs) |
Plot the data for this TimeSeries. |
prepend (other[, gap, inplace, pad, resize]) |
Connect another series onto the start of the current one. |
prod ([axis, dtype, out, keepdims]) |
Return the product of the array elements over the given axis |
psd ([fftlength, overlap, method]) |
Calculate the PSD FrequencySeries for this TimeSeries . |
ptp ([axis, out]) |
Peak to peak (maximum - minimum) value along a given axis. |
put (indices, values[, mode]) |
Set a.flat[n] = values[n] for all n in indices. |
q_transform ([qrange, frange, gps, search, ...]) |
Scan a TimeSeries using a multi-Q transform |
ravel ([order]) |
Return a flattened array. |
rayleigh_spectrogram (stride[, fftlength, ...]) |
Calculate the Rayleigh statistic spectrogram of this TimeSeries |
rayleigh_spectrum ([fftlength, overlap]) |
Calculate the Rayleigh FrequencySeries for this TimeSeries . |
read (*args, **kwargs) |
Read data into a TimeSeries |
repeat (repeats[, axis]) |
Repeat elements of an array. |
resample (rate[, window, numtaps]) |
Resample this Series to a new rate |
reshape (shape[, order]) |
Returns an array containing the same data with a new shape. |
resize (new_shape[, refcheck]) |
Change shape and size of array in-place. |
rms ([stride]) |
Calculate the root-mean-square value of this TimeSeries once per stride. |
round ([decimals, out]) |
Return a with each element rounded to the given number of decimals. |
searchsorted (v[, side, sorter]) |
Find indices where elements of v should be inserted in a to maintain order. |
setfield (val, dtype[, offset]) |
Put a value into a specified place in a field defined by a data-type. |
setflags ([write, align, uic]) |
Set array flags WRITEABLE, ALIGNED, and UPDATEIFCOPY, respectively. |
sort ([axis, kind, order]) |
Sort an array, in-place. |
spectral_variance (stride[, fftlength, ...]) |
Calculate the SpectralVariance of this TimeSeries . |
spectrogram (stride[, fftlength, overlap, ...]) |
Calculate the average power spectrogram of this TimeSeries using the specified average spectrum method. |
spectrogram2 (fftlength[, overlap, window, ...]) |
Calculate the non-averaged power Spectrogram of this TimeSeries |
squeeze ([axis]) |
Remove single-dimensional entries from the shape of a . |
std ([axis, dtype, out, ddof, keepdims]) |
Returns the standard deviation of the array elements along given axis. |
sum ([axis, dtype, out, keepdims]) |
Return the sum of the array elements over the given axis. |
swapaxes (axis1, axis2) |
Return a view of the array with axis1 and axis2 interchanged. |
take (indices[, axis, out, mode]) |
Return an array formed from the elements of a at the given indices. |
to (unit[, equivalencies]) |
Returns a new Quantity object with the specified units. |
to_hdf5 (*args, **kwargs) |
Convert this array to a h5py.Dataset . |
to_lal (*args, **kwargs) |
Convert this TimeSeries into a LAL TimeSeries. |
to_pycbc (*args, **kwargs) |
Convert this TimeSeries into a PyCBC |
tobytes ([order]) |
Construct Python bytes containing the raw data bytes in the array. |
tofile (fid[, sep, format]) |
Write array to a file as text or binary (default). |
tolist () |
Return the array as a (possibly nested) list. |
tostring ([order]) |
Construct Python bytes containing the raw data bytes in the array. |
trace ([offset, axis1, axis2, dtype, out]) |
Return the sum along diagonals of the array. |
transpose (*axes) |
Returns a view of the array with axes transposed. |
update (other[, inplace]) |
Update this series by appending new data from an other and dropping the same amount of data off the start. |
value_at (x) |
Return the value of this Series at the given xindex value |
var ([axis, dtype, out, ddof, keepdims]) |
Returns the variance of the array elements, along given axis. |
view ([dtype, type]) |
New view of array with the same data. |
whiten (fftlength[, overlap, method, window, ...]) |
White this TimeSeries against its own ASD |
write (data, *args, **kwargs) |
Write this TimeSeries to a file |
zip () |
Zip the xindex and value arrays of this Series |
zpk (zeros, poles, gain[, digital, unit]) |
Filter this TimeSeries by applying a zero-pole-gain filter |
Attributes Documentation
T
¶Same as self.transpose(), except that self is returned if self.ndim < 2.
Examples
>>> x = np.array([[1.,2.],[3.,4.]])
>>> x
array([[ 1., 2.],
[ 3., 4.]])
>>> x.T
array([[ 1., 3.],
[ 2., 4.]])
>>> x = np.array([1.,2.,3.,4.])
>>> x
array([ 1., 2., 3., 4.])
>>> x.T
array([ 1., 2., 3., 4.])
base
¶Base object if memory is from some other object.
Examples
The base of an array that owns its memory is None:
>>> x = np.array([1,2,3,4])
>>> x.base is None
True
Slicing creates a view, whose memory is shared with x:
>>> y = x[2:]
>>> y.base is x
True
cgs
¶Returns a copy of the current Quantity
instance with CGS units. The
value of the resulting object will be scaled.
ctypes
¶An object to simplify the interaction of the array with the ctypes module.
This attribute creates an object that makes it easier to use arrays when calling shared libraries with the ctypes module. The returned object has, among others, data, shape, and strides attributes (see Notes below) which themselves return ctypes objects that can be used as arguments to a shared library.
Parameters: | None : |
---|---|
Returns: | c : Python object
|
See also
numpy.ctypeslib
Notes
Below are the public attributes of this object which were documented in “Guide to NumPy” (we have omitted undocumented public attributes, as well as documented private attributes):
Be careful using the ctypes attribute - especially on temporary
arrays or arrays constructed on the fly. For example, calling
(a+b).ctypes.data_as(ctypes.c_void_p)
returns a pointer to memory
that is invalid because the array created as (a+b) is deallocated
before the next Python statement. You can avoid this problem using
either c=a+b
or ct=(a+b).ctypes
. In the latter case, ct will
hold a reference to the array until ct is deleted or re-assigned.
If the ctypes module is not available, then the ctypes attribute of array objects still returns something useful, but ctypes objects are not returned and errors may be raised instead. In particular, the object will still have the as parameter attribute which will return an integer equal to the data attribute.
Examples
>>> import ctypes
>>> x
array([[0, 1],
[2, 3]])
>>> x.ctypes.data
30439712
>>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long))
<ctypes.LP_c_long object at 0x01F01300>
>>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long)).contents
c_long(0)
>>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_longlong)).contents
c_longlong(4294967296L)
>>> x.ctypes.shape
<numpy.core._internal.c_long_Array_2 object at 0x01FFD580>
>>> x.ctypes.shape_as(ctypes.c_long)
<numpy.core._internal.c_long_Array_2 object at 0x01FCE620>
>>> x.ctypes.strides
<numpy.core._internal.c_long_Array_2 object at 0x01FCE620>
>>> x.ctypes.strides_as(ctypes.c_longlong)
<numpy.core._internal.c_longlong_Array_2 object at 0x01F01300>
data
¶dtype
¶Data-type of the array’s elements.
Parameters: | None : |
---|---|
Returns: | d : numpy dtype object |
See also
Examples
>>> x
array([[0, 1],
[2, 3]])
>>> x.dtype
dtype('int32')
>>> type(x.dtype)
<type 'numpy.dtype'>
duration
¶Duration of this series in seconds
equivalencies
¶A list of equivalencies that will be applied by default during unit conversions.
flags
¶Information about the memory layout of the array.
Notes
The flags
object can be accessed dictionary-like (as in a.flags['WRITEABLE']
),
or by using lowercased attribute names (as in a.flags.writeable
). Short flag
names are only supported in dictionary access.
Only the UPDATEIFCOPY, WRITEABLE, and ALIGNED flags can be changed by
the user, via direct assignment to the attribute or dictionary entry,
or by calling ndarray.setflags
.
The array flags cannot be set arbitrarily:
False
.True
if the data is truly aligned.True
if the array owns its own memory
or the ultimate owner of the memory exposes a writeable buffer
interface or is a string.Arrays can be both C-style and Fortran-style contiguous simultaneously. This is clear for 1-dimensional arrays, but can also be true for higher dimensional arrays.
Even for contiguous arrays a stride for a given dimension
arr.strides[dim]
may be arbitrary if arr.shape[dim] == 1
or the array has no elements.
It does not generally hold that self.strides[-1] == self.itemsize
for C-style contiguous arrays or self.strides[0] == self.itemsize
for
Fortran-style contiguous arrays is true.
Attributes
flat
¶A 1-D iterator over the Quantity array.
This returns a QuantityIterator
instance, which behaves the same
as the flatiter
instance returned by flat
,
and is similar to, but not a subclass of, Python’s built-in iterator
object.
imag
¶The imaginary part of the array.
Examples
>>> x = np.sqrt([1+0j, 0+1j])
>>> x.imag
array([ 0. , 0.70710678])
>>> x.imag.dtype
dtype('float64')
info
¶Container for meta information like name, description, format. This is required when the object is used as a mixin column within a table, but can be used as a general way to store meta information.
isscalar
¶True if the value
of this quantity is a scalar, or False if it
is an array-like object.
Note
This is subtly different from numpy.isscalar
in that
numpy.isscalar
returns False for a zero-dimensional array
(e.g. np.array(1)
), while this is True for quantities,
since quantities cannot represent true numpy scalars.
itemsize
¶Length of one array element in bytes.
Examples
>>> x = np.array([1,2,3], dtype=np.float64)
>>> x.itemsize
8
>>> x = np.array([1,2,3], dtype=np.complex128)
>>> x.itemsize
16
nbytes
¶Total bytes consumed by the elements of the array.
Notes
Does not include memory consumed by non-element attributes of the array object.
Examples
>>> x = np.zeros((3,5,2), dtype=np.complex128)
>>> x.nbytes
480
>>> np.prod(x.shape) * x.itemsize
480
ndim
¶Number of array dimensions.
Examples
>>> x = np.array([1, 2, 3])
>>> x.ndim
1
>>> y = np.zeros((2, 3, 4))
>>> y.ndim
3
real
¶The real part of the array.
See also
numpy.real
Examples
>>> x = np.sqrt([1+0j, 0+1j])
>>> x.real
array([ 1. , 0.70710678])
>>> x.real.dtype
dtype('float64')
sample_rate
¶Data rate for this TimeSeries
in samples per second (Hertz).
This attribute is stored internally by the dx
attribute
Type: | Quantity scalar |
---|
shape
¶Tuple of array dimensions.
Notes
May be used to “reshape” the array, as long as this would not require a change in the total number of elements
Examples
>>> x = np.array([1, 2, 3, 4])
>>> x.shape
(4,)
>>> y = np.zeros((2, 3, 4))
>>> y.shape
(2, 3, 4)
>>> y.shape = (3, 8)
>>> y
array([[ 0., 0., 0., 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0., 0., 0., 0.]])
>>> y.shape = (3, 6)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: total size of new array must be unchanged
si
¶Returns a copy of the current Quantity
instance with SI units. The
value of the resulting object will be scaled.
size
¶Number of elements in the array.
Equivalent to np.prod(a.shape)
, i.e., the product of the array’s
dimensions.
Examples
>>> x = np.zeros((3, 5, 2), dtype=np.complex128)
>>> x.size
30
>>> np.prod(x.shape)
30
strides
¶Tuple of bytes to step in each dimension when traversing an array.
The byte offset of element (i[0], i[1], ..., i[n])
in an array a
is:
offset = sum(np.array(i) * a.strides)
A more detailed explanation of strides can be found in the “ndarray.rst” file in the NumPy reference guide.
See also
numpy.lib.stride_tricks.as_strided
Notes
Imagine an array of 32-bit integers (each 4 bytes):
x = np.array([[0, 1, 2, 3, 4],
[5, 6, 7, 8, 9]], dtype=np.int32)
This array is stored in memory as 40 bytes, one after the other
(known as a contiguous block of memory). The strides of an array tell
us how many bytes we have to skip in memory to move to the next position
along a certain axis. For example, we have to skip 4 bytes (1 value) to
move to the next column, but 20 bytes (5 values) to get to the same
position in the next row. As such, the strides for the array x
will be
(20, 4)
.
Examples
>>> y = np.reshape(np.arange(2*3*4), (2,3,4))
>>> y
array([[[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]],
[[12, 13, 14, 15],
[16, 17, 18, 19],
[20, 21, 22, 23]]])
>>> y.strides
(48, 16, 4)
>>> y[1,1,1]
17
>>> offset=sum(y.strides * np.array((1,1,1)))
>>> offset/y.itemsize
17
>>> x = np.reshape(np.arange(5*6*7*8), (5,6,7,8)).transpose(2,3,1,0)
>>> x.strides
(32, 4, 224, 1344)
>>> i = np.array([3,5,2,2])
>>> offset = sum(i * x.strides)
>>> x[3,5,2,2]
813
>>> offset / x.itemsize
813
times
¶Series of GPS times for each sample
value
¶The numerical value of this quantity.
Methods Documentation
all
(axis=None, out=None, keepdims=False)¶Returns True if all elements evaluate to True.
Refer to numpy.all
for full documentation.
See also
numpy.all
any
(axis=None, out=None, keepdims=False)¶Returns True if any of the elements of a
evaluate to True.
Refer to numpy.any
for full documentation.
See also
numpy.any
append
(other, gap='raise', inplace=True, pad=0.0, resize=True)[source]¶Connect another series onto the end of the current one.
Parameters: | other :
gap :
inplace :
pad :
resize :
|
---|---|
Returns: | series :
|
argmax
(axis=None, out=None)¶Return indices of the maximum values along the given axis.
Refer to numpy.argmax
for full documentation.
See also
numpy.argmax
argmin
(axis=None, out=None)¶Return indices of the minimum values along the given axis of a
.
Refer to numpy.argmin
for detailed documentation.
See also
numpy.argmin
argpartition
(kth, axis=-1, kind='introselect', order=None)¶Returns the indices that would partition this array.
Refer to numpy.argpartition
for full documentation.
New in version 1.8.0.
See also
numpy.argpartition
argsort
(axis=-1, kind='quicksort', order=None)¶Returns the indices that would sort this array.
Refer to numpy.argsort
for full documentation.
See also
numpy.argsort
asd
(fftlength=None, overlap=None, method='welch', **kwargs)[source]¶Calculate the ASD FrequencySeries
of this TimeSeries
.
Parameters: | method :
fftlength :
overlap :
window :
plan : REAL8FFTPlan, optional
|
---|---|
Returns: | psd :
|
Notes
The available methods are:
gwpy.frequencyseries.scipy_.welch()
gwpy.frequencyseries.scipy_.bartlett()
gwpy.frequencyseries.scipy_.rayleigh()
gwpy.frequencyseries.scipy_.csd()
gwpy.frequencyseries.lal_._spectrum()
gwpy.frequencyseries.lal_._spectrum()
gwpy.frequencyseries.lal_._spectrum()
gwpy.frequencyseries.lal_._spectrum()
astype
(dtype, order='K', casting='unsafe', subok=True, copy=True)¶Copy of the array, cast to a specified type.
Parameters: | dtype : str or dtype
order : {‘C’, ‘F’, ‘A’, ‘K’}, optional
casting : {‘no’, ‘equiv’, ‘safe’, ‘same_kind’, ‘unsafe’}, optional
subok : bool, optional
copy : bool, optional
|
---|---|
Returns: | arr_t : ndarray |
Raises: | ComplexWarning :
|
Notes
Starting in NumPy 1.9, astype method now returns an error if the string dtype to cast to is not long enough in ‘safe’ casting mode to hold the max value of integer/float array that is being casted. Previously the casting was allowed even if the result was truncated.
Examples
>>> x = np.array([1, 2, 2.5])
>>> x
array([ 1. , 2. , 2.5])
>>> x.astype(int)
array([1, 2, 2])
auto_coherence
(dt, fftlength=None, overlap=None, window=None, **kwargs)[source]¶Calculate the frequency-coherence between this TimeSeries
and a time-shifted copy of itself.
The standard TimeSeries.coherence()
is calculated between
the input TimeSeries
and a cropped
copy of itself. Since the cropped version will be shorter, the
input series will be shortened to match.
Parameters: | dt :
fftlength :
overlap :
window :
**kwargs :
|
---|---|
Returns: | coherence :
|
See also
matplotlib.mlab.cohere()
Notes
The TimeSeries.auto_coherence()
will perform best when
dt
is approximately fftlength / 2
.
average_fft
(fftlength=None, overlap=0, window=None)[source]¶Compute the averaged one-dimensional DFT of this TimeSeries
.
This method computes a number of FFTs of duration fftlength
and overlap
(both given in seconds), and returns the mean
average. This method is analogous to the Welch average method
for power spectra.
Parameters: | fftlength :
overlap :
window :
|
---|---|
Returns: | out : complex-valued
|
See also
scipy.fftpack
, used.
bandpass
(flow, fhigh, gpass=2, gstop=30, stops=(None, None))[source]¶Filter this TimeSeries
by applying low- and high-pass filters.
Parameters: | flow :
fhigh :
gpass :
gstop :
stops: 2-`tuple` of `float` :
|
---|---|
Returns: | bpseries :
|
See also
scipy.signal.butter
TimeSeries.filter
scipy < 0.16.0
some higher-order filters may be unstable. With scipy >= 0.16.0
higher-order filters are decomposed into second-order-sections, and so are much more stable.byteswap
(inplace)¶Swap the bytes of the array elements
Toggle between low-endian and big-endian data representation by returning a byteswapped array, optionally swapped in-place.
Parameters: | inplace : bool, optional
|
---|---|
Returns: | out : ndarray
|
Examples
>>> A = np.array([1, 256, 8755], dtype=np.int16)
>>> map(hex, A)
['0x1', '0x100', '0x2233']
>>> A.byteswap(True)
array([ 256, 1, 13090], dtype=int16)
>>> map(hex, A)
['0x100', '0x1', '0x3322']
Arrays of strings are not swapped
>>> A = np.array(['ceg', 'fac'])
>>> A.byteswap()
array(['ceg', 'fac'],
dtype='|S3')
choose
(choices, out=None, mode='raise')¶Use an index array to construct a new array from a set of choices.
Refer to numpy.choose
for full documentation.
See also
numpy.choose
clip
(min=None, max=None, out=None)¶Return an array whose values are limited to [min, max]
.
One of max or min must be given.
Refer to numpy.clip
for full documentation.
See also
numpy.clip
coherence
(other, fftlength=None, overlap=None, window=None, **kwargs)[source]¶Calculate the frequency-coherence between this TimeSeries
and another.
Parameters: | other :
fftlength :
overlap :
window :
**kwargs :
|
---|---|
Returns: | coherence :
|
See also
matplotlib.mlab.cohere()
Notes
If self
and other
have difference
TimeSeries.sample_rate
values, the higher sampled
TimeSeries
will be down-sampled to match the lower.
coherence_spectrogram
(other, stride, fftlength=None, overlap=None, window=None, nproc=1)[source]¶Calculate the coherence spectrogram between this TimeSeries
and other.
Parameters: | stride :
fftlength :
overlap :
window :
nproc :
|
---|---|
Returns: | spectrogram :
|
compress
(condition, axis=None, out=None)¶Return selected slices of this array along given axis.
Refer to numpy.compress
for full documentation.
See also
numpy.compress
conj
()¶Complex-conjugate all elements.
Refer to numpy.conjugate
for full documentation.
See also
numpy.conjugate
conjugate
()¶Return the complex conjugate, element-wise.
Refer to numpy.conjugate
for full documentation.
See also
numpy.conjugate
copy
(order='C')[source]¶Return a copy of the array.
Parameters: | order : {‘C’, ‘F’, ‘A’, ‘K’}, optional
|
---|
See also
Examples
>>> x = np.array([[1,2,3],[4,5,6]], order='F')
>>> y = x.copy()
>>> x.fill(0)
>>> x
array([[0, 0, 0],
[0, 0, 0]])
>>> y
array([[1, 2, 3],
[4, 5, 6]])
>>> y.flags['C_CONTIGUOUS']
True
crop
(start=None, end=None, copy=False)[source]¶Crop this series to the given x-axis extent.
Parameters: | start :
end :
copy :
|
---|---|
Returns: | series :
|
Notes
If either start
or end
are outside of the original
Series
span, warnings will be printed and the limits will
be restricted to the xspan
csd
(other, fftlength=None, overlap=None, **kwargs)[source]¶Calculate the CSD FrequencySeries
for two TimeSeries
Parameters: | fftlength :
overlap :
window :
plan : REAL8FFTPlan, optional
|
---|---|
Returns: | csd :
|
csd_spectrogram
(other, stride, fftlength=None, overlap=0, window=None, nproc=1, **kwargs)[source]¶TimeSeries
with ‘other’.Parameters: | timeseries :
other :
stride :
fftlength :
overlap :
window :
plan : REAL8FFTPlan, optional
nproc :
|
---|---|
Returns: | spectrogram :
|
cumprod
(axis=None, dtype=None, out=None)¶Return the cumulative product of the elements along the given axis.
Refer to numpy.cumprod
for full documentation.
See also
numpy.cumprod
cumsum
(axis=None, dtype=None, out=None)¶Return the cumulative sum of the elements along the given axis.
Refer to numpy.cumsum
for full documentation.
See also
numpy.cumsum
decompose
(bases=[])¶Generates a new Quantity
with the units
decomposed. Decomposed units have only irreducible units in
them (see astropy.units.UnitBase.decompose
).
Parameters: | bases : sequence of UnitBase, optional
|
---|---|
Returns: | newq :
|
detrend
(detrend='constant')[source]¶Remove the trend from this TimeSeries
This method just wraps scipy.signal.detrend()
to return
an object of the same type as the input.
Parameters: | detrend :
|
---|---|
Returns: | detrended :
|
See also
scipy.signal.detrend
detrend
argument, and how the operation is donediagonal
(offset=0, axis1=0, axis2=1)¶Return specified diagonals. In NumPy 1.9 the returned array is a read-only view instead of a copy as in previous NumPy versions. In a future version the read-only restriction will be removed.
Refer to numpy.diagonal()
for full documentation.
See also
numpy.diagonal
diff
(n=1, axis=-1)[source]¶Calculate the n-th discrete difference along given axis.
The first difference is given by
out[n] = a[n+1] - a[n]
along the given axis, higher differences are calculated by usingdiff
recursively.
Parameters: | a : array_like
|
---|---|
Returns: | diff : ndarray
. : |
Examples
>>> x = np.array([1, 2, 4, 7, 0])
>>> np.diff(x)
array([ 1, 2, 3, -7])
>>> np.diff(x, n=2)
array([ 1, 1, -10])
>>> x = np.array([[1, 3, 6, 10], [0, 5, 6, 8]])
>>> np.diff(x)
array([[2, 3, 4],
[5, 1, 2]])
>>> np.diff(x, axis=0)
array([[-1, 2, 0, -2]])
dot
(b, out=None)¶Dot product of two arrays.
Refer to numpy.dot
for full documentation.
See also
numpy.dot
Examples
>>> a = np.eye(2)
>>> b = np.ones((2, 2)) * 2
>>> a.dot(b)
array([[ 2., 2.],
[ 2., 2.]])
This array method can be conveniently chained:
>>> a.dot(b).dot(b)
array([[ 8., 8.],
[ 8., 8.]])
dump
(file)¶Dump a pickle of the array to the specified file. The array can be read back with pickle.load or numpy.load.
Parameters: | file : str
|
---|
dumps
()[source]¶Returns the pickle of the array as a string. pickle.loads or numpy.loads will convert the string back to an array.
Parameters: | None : |
---|
ediff1d
(to_end=None, to_begin=None)¶fetch
(*args, **kwargs)[source]¶Fetch data from NDS into a TimeSeries
.
Parameters: |
start :
end :
host :
port :
verify :
connection :
verbose :
type :
dtype :
|
---|
fetch_open_data
(ifo, start, end, name='strain/Strain', sample_rate=4096, host='https://losc.ligo.org')[source]¶Fetch open-access data from the LIGO Open Science Center
Parameters: | ifo :
start :
end :
name :
sample_rate :
host :
|
---|
fft
(nfft=None)[source]¶Compute the one-dimensional discrete Fourier transform of
this TimeSeries
.
Parameters: | nfft :
|
---|---|
Returns: | out :
|
See also
scipy.fftpack
, used.
Notes
This method, in constrast to the numpy.fft.rfft()
method
it calls, applies the necessary normalisation such that the
amplitude of the output FrequencySeries
is
correct.
fftgram
(stride)[source]¶Calculate the Fourier-gram of this TimeSeries
.
At every stride
, a single, complex FFT is calculated.
Parameters: | stride :
|
---|---|
Returns: | fftgram :
|
fill
(value)¶Fill the array with a scalar value.
Parameters: | value : scalar
|
---|
Examples
>>> a = np.array([1, 2])
>>> a.fill(0)
>>> a
array([0, 0])
>>> a = np.empty(2)
>>> a.fill(1)
>>> a
array([ 1., 1.])
filter
(*filt)[source]¶Apply the given filter to this TimeSeries
.
All recognised filter arguments are converted either into cascading
second-order sections (if scipy >= 0.16 is installed), or into the
(numerator, denominator)
representation before being applied
to this TimeSeries
.
Note
All filters are presumed to be digital (Z-domain), if you have
an analog ZPK (in Hertz or in rad/s) you should be using
TimeSeries.zpk
instead.
Note
When using scipy
< 0.16 some higher-order filters may be
unstable. With scipy
>= 0.16 higher-order filters are
decomposed into second-order-sections, and so are much more stable.
Parameters: | *filt :
|
---|---|
Returns: | result :
|
Raises: | ValueError :
|
See also
TimeSeries.zpk
scipy.signal.sosfilter
scipy
>= 0.16 only)scipy.signal.lfilter
find
(channel, start, end, frametype=None, pad=None, dtype=None, nproc=1, verbose=False, **readargs)[source]¶Find and read data from frames for a channel
Parameters: |
start :
end :
frametype :
pad :
nproc :
dtype : verbose :
**readargs :
|
---|
flatten
(order='C')¶Return a copy of the array collapsed into one dimension.
Parameters: | order : {‘C’, ‘F’, ‘A’, ‘K’}, optional
|
---|---|
Returns: | y : ndarray
|
Examples
>>> a = np.array([[1,2], [3,4]])
>>> a.flatten()
array([1, 2, 3, 4])
>>> a.flatten('F')
array([1, 3, 2, 4])
from_hdf5
(*args, **kwargs)[source]¶Read an array from the given HDF file.
This method has been deprecated in favour of the unified I/O method:
Class.write(..., format=’hdf5’)
from_nds2_buffer
(*args, **kwargs)[source]¶Construct a new TimeSeries
from an nds2.buffer
object
Parameters: | buffer_ :
**metadata :
|
---|---|
Returns: | timeseries :
|
Notes
This classmethod requires the nds2-client package
from_pycbc
(ts)[source]¶Convert a pycbc.types.timeseries.TimeSeries
into a TimeSeries
Parameters: | ts :
|
---|---|
Returns: | timeseries :
|
get
(channel, start, end, pad=None, dtype=None, verbose=False, **kwargs)[source]¶Get data for this channel from frames or NDS
This method dynamically accesses either frames on disk, or a remote NDS2 server to find and return data for the given interval
Parameters: |
start :
end :
pad :
dtype : nproc :
verbose :
**kwargs other keyword arguments to pass to either : |
---|
See also
TimeSeries.fetch
TimeSeries.find
getfield
(dtype, offset=0)¶Returns a field of the given array as a certain type.
A field is a view of the array data with a given data-type. The values in the view are determined by the given type and the offset into the current array in bytes. The offset needs to be such that the view dtype fits in the array dtype; for example an array of dtype complex128 has 16-byte elements. If taking a view with a 32-bit integer (4 bytes), the offset needs to be between 0 and 12 bytes.
Parameters: | dtype : str or dtype
offset : int
|
---|
Examples
>>> x = np.diag([1.+1.j]*2)
>>> x[1, 1] = 2 + 4.j
>>> x
array([[ 1.+1.j, 0.+0.j],
[ 0.+0.j, 2.+4.j]])
>>> x.getfield(np.float64)
array([[ 1., 0.],
[ 0., 2.]])
By choosing an offset of 8 bytes we can select the complex part of the array for our view:
>>> x.getfield(np.float64, offset=8)
array([[ 1., 0.],
[ 0., 4.]])
highpass
(frequency, gpass=2, gstop=30, stop=None)[source]¶Filter this TimeSeries
with a Butterworth high-pass filter.
Parameters: | frequency :
gpass :
gstop :
stop :
|
---|---|
Returns: | hpseries :
|
See also
scipy.signal.butter
TimeSeries.filter
scipy < 0.16.0
some higher-order filters may be unstable. With scipy >= 0.16.0
higher-order filters are decomposed into second-order-sections, and so are much more stable.insert
(obj, values, axis=None)¶Insert values along the given axis before the given indices and return
a new Quantity
object.
This is a thin wrapper around the numpy.insert
function.
Parameters: | obj : int, slice or sequence of ints
values : array-like
axis : int, optional
|
---|---|
Returns: | out :
|
Examples
>>> import astropy.units as u
>>> q = [1, 2] * u.m
>>> q.insert(0, 50 * u.cm)
<Quantity [ 0.5, 1., 2.] m>
>>> q = [[1, 2], [3, 4]] * u.m
>>> q.insert(1, [10, 20] * u.m, axis=0)
<Quantity [[ 1., 2.],
[ 10., 20.],
[ 3., 4.]] m>
>>> q.insert(1, 10 * u.m, axis=1)
<Quantity [[ 1., 10., 2.],
[ 3., 10., 4.]] m>
is_compatible
(other)[source]¶Check whether this series and other have compatible metadata
This method tests that the sample size
, and the
unit
match.
is_contiguous
(other, tol=3.814697265625e-06)[source]¶Check whether other is contiguous with self.
Parameters: | other :
tol :
|
---|---|
Returns: | 1 :
-1 :
0 :
|
Notes
if a raw numpy.ndarray
is passed as other, with no metadata, then
the contiguity check will always pass
item
(*args)¶Copy an element of an array to a standard Python scalar and return it.
Parameters: | *args : Arguments (variable number and type)
|
---|---|
Returns: | z : Standard Python scalar object
|
Notes
When the data type of a
is longdouble or clongdouble, item() returns
a scalar array object because there is no available Python scalar that
would not lose information. Void arrays return a buffer object for item(),
unless fields are defined, in which case a tuple is returned.
item
is very similar to a[args], except, instead of an array scalar,
a standard Python scalar is returned. This can be useful for speeding up
access to elements of the array and doing arithmetic on elements of the
array using Python’s optimized math.
Examples
>>> x = np.random.randint(9, size=(3, 3))
>>> x
array([[3, 1, 7],
[2, 8, 3],
[8, 5, 3]])
>>> x.item(3)
2
>>> x.item(7)
5
>>> x.item((0, 1))
1
>>> x.item((2, 2))
3
itemset
(*args)¶Insert scalar into an array (scalar is cast to array’s dtype, if possible)
There must be at least 1 argument, and define the last argument
as item. Then, a.itemset(*args)
is equivalent to but faster
than a[args] = item
. The item should be a scalar value and args
must select a single item in the array a
.
Parameters: | *args : Arguments
|
---|
Notes
Compared to indexing syntax, itemset
provides some speed increase
for placing a scalar into a particular location in an ndarray
,
if you must do this. However, generally this is discouraged:
among other problems, it complicates the appearance of the code.
Also, when using itemset
(and item
) inside a loop, be sure
to assign the methods to a local variable to avoid the attribute
look-up at each loop iteration.
Examples
>>> x = np.random.randint(9, size=(3, 3))
>>> x
array([[3, 1, 7],
[2, 8, 3],
[8, 5, 3]])
>>> x.itemset(4, 0)
>>> x.itemset((2, 2), 9)
>>> x
array([[3, 1, 7],
[2, 0, 3],
[8, 5, 9]])
lowpass
(frequency, gpass=2, gstop=30, stop=None)[source]¶Filter this TimeSeries
with a Butterworth low-pass filter.
Parameters: | frequency :
gpass :
gstop :
stop: `float` :
|
---|---|
Returns: | lpseries :
|
See also
scipy.signal.butter
TimeSeries.filter
scipy < 0.16.0
some higher-order filters may be unstable. With scipy >= 0.16.0
higher-order filters are decomposed into second-order-sections, and so are much more stable.max
(axis=None, out=None)¶Return the maximum along a given axis.
Refer to numpy.amax
for full documentation.
See also
numpy.amax
mean
(axis=None, dtype=None, out=None, keepdims=False)¶Returns the average of the array elements along given axis.
Refer to numpy.mean
for full documentation.
See also
numpy.mean
median
(axis=None, **kwargs)[source]¶Compute the median along the specified axis.
Returns the median of the array elements.
Parameters: | a : array_like
axis : {int, sequence of int, None}, optional
out : ndarray, optional
overwrite_input : bool, optional
keepdims : bool, optional
|
---|---|
Returns: | median : ndarray
|
See also
mean
, percentile
Notes
Given a vector V
of length N
, the median of V
is the
middle value of a sorted copy of V
, V_sorted
- i
e., V_sorted[(N-1)/2]
, when N
is odd, and the average of the
two middle values of V_sorted
when N
is even.
Examples
>>> a = np.array([[10, 7, 4], [3, 2, 1]])
>>> a
array([[10, 7, 4],
[ 3, 2, 1]])
>>> np.median(a)
3.5
>>> np.median(a, axis=0)
array([ 6.5, 4.5, 2.5])
>>> np.median(a, axis=1)
array([ 7., 2.])
>>> m = np.median(a, axis=0)
>>> out = np.zeros_like(m)
>>> np.median(a, axis=0, out=m)
array([ 6.5, 4.5, 2.5])
>>> m
array([ 6.5, 4.5, 2.5])
>>> b = a.copy()
>>> np.median(b, axis=1, overwrite_input=True)
array([ 7., 2.])
>>> assert not np.all(a==b)
>>> b = a.copy()
>>> np.median(b, axis=None, overwrite_input=True)
3.5
>>> assert not np.all(a==b)
min
(axis=None, out=None, keepdims=False)¶Return the minimum along a given axis.
Refer to numpy.amin
for full documentation.
See also
numpy.amin
nansum
(axis=None, out=None, keepdims=False)¶newbyteorder
(new_order='S')¶Return the array with the same data viewed with a different byte order.
Equivalent to:
arr.view(arr.dtype.newbytorder(new_order))
Changes are also made in all fields and sub-arrays of the array data type.
Parameters: | new_order : string, optional
|
---|---|
Returns: | new_arr : array
|
nonzero
()¶Return the indices of the elements that are non-zero.
Refer to numpy.nonzero
for full documentation.
See also
numpy.nonzero
notch
(frequency, type='iir', **kwargs)[source]¶Notch out a frequency in a TimeSeries
Parameters: |
type :
**kwargs :
|
---|---|
Returns: | notched :
|
See also
TimeSeries.filter
scipy.signal.iirdesign
override_unit
(unit, parse_strict='raise')[source]¶Forcefully reset the unit of these data
Use of this method is discouraged in favour of to()
,
which performs accurate conversions from one unit to another.
The method should really only be used when the original unit of the
array is plain wrong.
Parameters: |
|
---|---|
Raises: | ValueError :
|
pad
(pad_width, **kwargs)[source]¶Pad this series to a new size
Parameters: | pad_width :
**kwargs :
|
---|---|
Returns: | series :
|
See also
numpy.pad
partition
(kth, axis=-1, kind='introselect', order=None)¶Rearranges the elements in the array in such a way that value of the element in kth position is in the position it would be in a sorted array. All elements smaller than the kth element are moved before this element and all equal or greater are moved behind it. The ordering of the elements in the two partitions is undefined.
New in version 1.8.0.
Parameters: | kth : int or sequence of ints
axis : int, optional
kind : {‘introselect’}, optional
order : str or list of str, optional
|
---|
See also
numpy.partition
argpartition
sort
Notes
See np.partition
for notes on the different algorithms.
Examples
>>> a = np.array([3, 4, 2, 1])
>>> a.partition(a, 3)
>>> a
array([2, 1, 3, 4])
>>> a.partition((1, 3))
array([1, 2, 3, 4])
prepend
(other, gap='raise', inplace=True, pad=0.0, resize=True)[source]¶Connect another series onto the start of the current one.
Parameters: | other :
gap :
inplace :
pad :
|
---|---|
Returns: | series :
|
prod
(axis=None, dtype=None, out=None, keepdims=False)¶Return the product of the array elements over the given axis
Refer to numpy.prod
for full documentation.
See also
numpy.prod
psd
(fftlength=None, overlap=None, method='welch', **kwargs)[source]¶Calculate the PSD FrequencySeries
for this TimeSeries
.
Parameters: | method :
fftlength :
overlap :
window :
plan : REAL8FFTPlan, optional
|
---|---|
Returns: | psd :
|
Notes
The available methods are:
gwpy.frequencyseries.scipy_.welch()
gwpy.frequencyseries.scipy_.bartlett()
gwpy.frequencyseries.scipy_.rayleigh()
gwpy.frequencyseries.scipy_.csd()
gwpy.frequencyseries.lal_._spectrum()
gwpy.frequencyseries.lal_._spectrum()
gwpy.frequencyseries.lal_._spectrum()
gwpy.frequencyseries.lal_._spectrum()
ptp
(axis=None, out=None)¶Peak to peak (maximum - minimum) value along a given axis.
Refer to numpy.ptp
for full documentation.
See also
numpy.ptp
put
(indices, values, mode='raise')¶Set a.flat[n] = values[n]
for all n
in indices.
Refer to numpy.put
for full documentation.
See also
numpy.put
q_transform
(qrange=(4, 64), frange=(0, inf), gps=None, search=0.5, tres=0.001, fres=0.5, outseg=None, **psdkwargs)[source]¶Scan a TimeSeries
using a multi-Q transform
Parameters: | qrange :
frange :
gps :
search :
tres :
outseg :
**psdkwargs :
|
---|---|
Returns: | specgram :
|
See also
TimeSeries.psd
**psdkwargs
TimeSeries.whiten
gwpy.signal.qtransform
scipy.interpolate
InterpolatedUnivariateSpline
to cast all frequency rows to the same time-axis, and then interpd
to apply the desired frequency resolution across the band.Notes
It is highly recommended to use the outseg
keyword argument when
only a small window around a given GPS time is of interest. This
will speed up this method a little, but can greatly speed up
rendering the resulting Spectrogram
using
pcolormesh
.
If you aren’t going to use pcolormesh
in the end, don’t worry.
ravel
([order])¶Return a flattened array.
Refer to numpy.ravel
for full documentation.
See also
numpy.ravel
ndarray.flat
rayleigh_spectrogram
(stride, fftlength=None, overlap=0, window=None, nproc=1, **kwargs)[source]¶Calculate the Rayleigh statistic spectrogram of this TimeSeries
Parameters: | timeseries :
stride :
fftlength :
overlap :
window :
plan : REAL8FFTPlan, optional
nproc :
|
---|---|
Returns: | spectrogram :
|
rayleigh_spectrum
(fftlength=None, overlap=None, **kwargs)[source]¶Calculate the Rayleigh FrequencySeries
for this TimeSeries
.
Parameters: | fftlength :
overlap :
window :
plan : REAL8FFTPlan, optional
|
---|---|
Returns: | psd :
|
Notes
The available methods are:
read
(*args, **kwargs)¶Read data into a TimeSeries
Parameters: |
start :
end :
format :
nproc :
gap :
pad :
|
---|
Notes
The available built-in formats are:
Format | Read | Write | Auto-identify |
---|---|---|---|
csv | Yes | Yes | Yes |
framecpp | Yes | Yes | No |
gwf | Yes | No | Yes |
hdf | Yes | Yes | No |
hdf5 | Yes | Yes | Yes |
lalframe | Yes | No | No |
losc | Yes | No | No |
txt | Yes | Yes | Yes |
repeat
(repeats, axis=None)¶Repeat elements of an array.
Refer to numpy.repeat
for full documentation.
See also
numpy.repeat
resample
(rate, window='hamming', numtaps=61)[source]¶Resample this Series to a new rate
Parameters: | rate :
window : array_like, callable, string, float, or tuple, optional
numtaps :
|
---|---|
Returns: | Series :
|
reshape
(shape, order='C')¶Returns an array containing the same data with a new shape.
Refer to numpy.reshape
for full documentation.
See also
numpy.reshape
resize
(new_shape, refcheck=True)¶Change shape and size of array in-place.
Parameters: | new_shape : tuple of ints, or
refcheck : bool, optional
|
---|---|
Returns: | None : |
Raises: | ValueError :
SystemError :
|
See also
resize
Notes
This reallocates space for the data area if necessary.
Only contiguous arrays (data elements consecutive in memory) can be resized.
The purpose of the reference count check is to make sure you
do not use this array as a buffer for another Python object and then
reallocate the memory. However, reference counts can increase in
other ways so if you are sure that you have not shared the memory
for this array with another Python object, then you may safely set
refcheck
to False.
Examples
Shrinking an array: array is flattened (in the order that the data are stored in memory), resized, and reshaped:
>>> a = np.array([[0, 1], [2, 3]], order='C')
>>> a.resize((2, 1))
>>> a
array([[0],
[1]])
>>> a = np.array([[0, 1], [2, 3]], order='F')
>>> a.resize((2, 1))
>>> a
array([[0],
[2]])
Enlarging an array: as above, but missing entries are filled with zeros:
>>> b = np.array([[0, 1], [2, 3]])
>>> b.resize(2, 3) # new_shape parameter doesn't have to be a tuple
>>> b
array([[0, 1, 2],
[3, 0, 0]])
Referencing an array prevents resizing...
>>> c = a
>>> a.resize((1, 1))
Traceback (most recent call last):
...
ValueError: cannot resize an array that has been referenced ...
Unless refcheck
is False:
>>> a.resize((1, 1), refcheck=False)
>>> a
array([[0]])
>>> c
array([[0]])
rms
(stride=1)[source]¶Calculate the root-mean-square value of this TimeSeries
once per stride.
Parameters: | stride :
|
---|---|
Returns: | rms :
|
round
(decimals=0, out=None)¶Return a
with each element rounded to the given number of decimals.
Refer to numpy.around
for full documentation.
See also
numpy.around
searchsorted
(v, side='left', sorter=None)¶Find indices where elements of v should be inserted in a to maintain order.
For full documentation, see numpy.searchsorted
See also
numpy.searchsorted
setfield
(val, dtype, offset=0)¶Put a value into a specified place in a field defined by a data-type.
Place val
into a
‘s field defined by dtype
and beginning offset
bytes into the field.
Parameters: | val : object
dtype : dtype object
offset : int, optional
|
---|---|
Returns: | None : |
See also
Examples
>>> x = np.eye(3)
>>> x.getfield(np.float64)
array([[ 1., 0., 0.],
[ 0., 1., 0.],
[ 0., 0., 1.]])
>>> x.setfield(3, np.int32)
>>> x.getfield(np.int32)
array([[3, 3, 3],
[3, 3, 3],
[3, 3, 3]])
>>> x
array([[ 1.00000000e+000, 1.48219694e-323, 1.48219694e-323],
[ 1.48219694e-323, 1.00000000e+000, 1.48219694e-323],
[ 1.48219694e-323, 1.48219694e-323, 1.00000000e+000]])
>>> x.setfield(np.eye(3), np.int32)
>>> x
array([[ 1., 0., 0.],
[ 0., 1., 0.],
[ 0., 0., 1.]])
setflags
(write=None, align=None, uic=None)¶Set array flags WRITEABLE, ALIGNED, and UPDATEIFCOPY, respectively.
These Boolean-valued flags affect how numpy interprets the memory
area used by a
(see Notes below). The ALIGNED flag can only
be set to True if the data is actually aligned according to the type.
The UPDATEIFCOPY flag can never be set to True. The flag WRITEABLE
can only be set to True if the array owns its own memory, or the
ultimate owner of the memory exposes a writeable buffer interface,
or is a string. (The exception for string is made so that unpickling
can be done without copying memory.)
Parameters: | write : bool, optional
align : bool, optional
uic : bool, optional
|
---|
Notes
Array flags provide information about how the memory area used for the array is to be interpreted. There are 6 Boolean flags in use, only three of which can be changed by the user: UPDATEIFCOPY, WRITEABLE, and ALIGNED.
WRITEABLE (W) the data area can be written to;
ALIGNED (A) the data and strides are aligned appropriately for the hardware (as determined by the compiler);
UPDATEIFCOPY (U) this array is a copy of some other array (referenced by .base). When this array is deallocated, the base array will be updated with the contents of this array.
All flags can be accessed using their first (upper case) letter as well as the full name.
Examples
>>> y
array([[3, 1, 7],
[2, 0, 0],
[8, 5, 9]])
>>> y.flags
C_CONTIGUOUS : True
F_CONTIGUOUS : False
OWNDATA : True
WRITEABLE : True
ALIGNED : True
UPDATEIFCOPY : False
>>> y.setflags(write=0, align=0)
>>> y.flags
C_CONTIGUOUS : True
F_CONTIGUOUS : False
OWNDATA : True
WRITEABLE : False
ALIGNED : False
UPDATEIFCOPY : False
>>> y.setflags(uic=1)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: cannot set UPDATEIFCOPY flag to True
sort
(axis=-1, kind='quicksort', order=None)¶Sort an array, in-place.
Parameters: | axis : int, optional
kind : {‘quicksort’, ‘mergesort’, ‘heapsort’}, optional
order : str or list of str, optional
|
---|
See also
numpy.sort
argsort
lexsort
searchsorted
partition
Notes
See sort
for notes on the different sorting algorithms.
Examples
>>> a = np.array([[1,4], [3,1]])
>>> a.sort(axis=1)
>>> a
array([[1, 4],
[1, 3]])
>>> a.sort(axis=0)
>>> a
array([[1, 3],
[1, 4]])
Use the order
keyword to specify a field to use when sorting a
structured array:
>>> a = np.array([('a', 2), ('c', 1)], dtype=[('x', 'S1'), ('y', int)])
>>> a.sort(order='y')
>>> a
array([('c', 1), ('a', 2)],
dtype=[('x', '|S1'), ('y', '<i4')])
spectral_variance
(stride, fftlength=None, overlap=None, method='welch', window=None, nproc=1, filter=None, bins=None, low=None, high=None, nbins=500, log=False, norm=False, density=False)[source]¶Calculate the SpectralVariance
of this TimeSeries
.
Parameters: | stride :
fftlength :
method :
overlap :
window :
nproc :
bins :
low :
high :
nbins :
log :
norm :
density :
|
---|---|
Returns: | specvar :
|
See also
numpy.histogram()
spectrogram
(stride, fftlength=None, overlap=0, method='welch', window=None, nproc=1, **kwargs)[source]¶Calculate the average power spectrogram of this TimeSeries
using the specified average spectrum method.
Each time-bin of the output Spectrogram
is calculated by taking
a chunk of the TimeSeries
in the segment
[t - overlap/2., t + stride + overlap/2.)
and calculating the
psd()
of those data.
As a result, each time-bin is calculated using stride + overlap
seconds of data.
Parameters: | timeseries :
stride :
fftlength :
overlap :
method :
window :
plan : REAL8FFTPlan, optional
nproc :
cross :
|
---|---|
Returns: | spectrogram :
|
spectrogram2
(fftlength, overlap=0, window='hanning', scaling='density', **kwargs)[source]¶Calculate the non-averaged power Spectrogram
of this TimeSeries
Parameters: | fftlength :
overlap :
window :
scaling : [ ‘density’ | ‘spectrum’ ], optional
**kwargs :
|
---|---|
Returns: | spectrogram: `~gwpy.spectrogram.Spectrogram` :
|
See also
scipy.signal.periodogram
Notes
This method calculates overlapping periodograms for all possible
chunks of data entirely containing within the span of the input
TimeSeries
, then normalises the power in overlapping chunks using
a triangular window centred on that chunk which most overlaps the
given Spectrogram
time sample.
squeeze
(axis=None)¶Remove single-dimensional entries from the shape of a
.
Refer to numpy.squeeze
for full documentation.
See also
numpy.squeeze
std
(axis=None, dtype=None, out=None, ddof=0, keepdims=False)¶Returns the standard deviation of the array elements along given axis.
Refer to numpy.std
for full documentation.
See also
numpy.std
sum
(axis=None, dtype=None, out=None, keepdims=False)¶Return the sum of the array elements over the given axis.
Refer to numpy.sum
for full documentation.
See also
numpy.sum
swapaxes
(axis1, axis2)¶Return a view of the array with axis1
and axis2
interchanged.
Refer to numpy.swapaxes
for full documentation.
See also
numpy.swapaxes
take
(indices, axis=None, out=None, mode='raise')¶Return an array formed from the elements of a
at the given indices.
Refer to numpy.take
for full documentation.
See also
numpy.take
to
(unit, equivalencies=[])¶Returns a new Quantity
object with the specified
units.
Parameters: | unit : equivalencies : list of equivalence pairs, optional
|
---|
to_hdf5
(*args, **kwargs)[source]¶Convert this array to a h5py.Dataset
.
This method has been deprecated in favour of the unified I/O method:
Class.write(..., format=’hdf5’)
to_lal
(*args, **kwargs)[source]¶Convert this TimeSeries
into a LAL TimeSeries.
to_pycbc
(*args, **kwargs)[source]¶Convert this TimeSeries
into a PyCBC
TimeSeries
Parameters: | copy :
|
---|---|
Returns: | timeseries :
|
tobytes
(order='C')¶Construct Python bytes containing the raw data bytes in the array.
Constructs Python bytes showing a copy of the raw contents of data memory. The bytes object can be produced in either ‘C’ or ‘Fortran’, or ‘Any’ order (the default is ‘C’-order). ‘Any’ order means C-order unless the F_CONTIGUOUS flag in the array is set, in which case it means ‘Fortran’ order.
New in version 1.9.0.
Parameters: | order : {‘C’, ‘F’, None}, optional
|
---|---|
Returns: | s : bytes
|
Examples
>>> x = np.array([[0, 1], [2, 3]])
>>> x.tobytes()
b'\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00'
>>> x.tobytes('C') == x.tobytes()
True
>>> x.tobytes('F')
b'\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x03\x00\x00\x00'
tofile
(fid, sep="", format="%s")¶Write array to a file as text or binary (default).
Data is always written in ‘C’ order, independent of the order of a
.
The data produced by this method can be recovered using the function
fromfile().
Parameters: | fid : file or str
sep : str
format : str
|
---|
Notes
This is a convenience function for quick storage of array data. Information on endianness and precision is lost, so this method is not a good choice for files intended to archive data or transport data between machines with different endianness. Some of these problems can be overcome by outputting the data as text files, at the expense of speed and file size.
tolist
()¶Return the array as a (possibly nested) list.
Return a copy of the array data as a (nested) Python list. Data items are converted to the nearest compatible Python type.
Parameters: | none : |
---|---|
Returns: | y : list
|
Notes
The array may be recreated, a = np.array(a.tolist())
.
Examples
>>> a = np.array([1, 2])
>>> a.tolist()
[1, 2]
>>> a = np.array([[1, 2], [3, 4]])
>>> list(a)
[array([1, 2]), array([3, 4])]
>>> a.tolist()
[[1, 2], [3, 4]]
tostring
(order='C')[source]¶Construct Python bytes containing the raw data bytes in the array.
Constructs Python bytes showing a copy of the raw contents of data memory. The bytes object can be produced in either ‘C’ or ‘Fortran’, or ‘Any’ order (the default is ‘C’-order). ‘Any’ order means C-order unless the F_CONTIGUOUS flag in the array is set, in which case it means ‘Fortran’ order.
This function is a compatibility alias for tobytes. Despite its name it returns bytes not strings.
Parameters: | order : {‘C’, ‘F’, None}, optional
|
---|---|
Returns: | s : bytes
|
Examples
>>> x = np.array([[0, 1], [2, 3]])
>>> x.tobytes()
b'\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00'
>>> x.tobytes('C') == x.tobytes()
True
>>> x.tobytes('F')
b'\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x03\x00\x00\x00'
trace
(offset=0, axis1=0, axis2=1, dtype=None, out=None)¶Return the sum along diagonals of the array.
Refer to numpy.trace
for full documentation.
See also
numpy.trace
transpose
(*axes)¶Returns a view of the array with axes transposed.
For a 1-D array, this has no effect. (To change between column and
row vectors, first cast the 1-D array into a matrix object.)
For a 2-D array, this is the usual matrix transpose.
For an n-D array, if axes are given, their order indicates how the
axes are permuted (see Examples). If axes are not provided and
a.shape = (i[0], i[1], ... i[n-2], i[n-1])
, then
a.transpose().shape = (i[n-1], i[n-2], ... i[1], i[0])
.
Parameters: | axes : None, tuple of ints, or
|
---|---|
Returns: | out : ndarray
|
See also
ndarray.T
Examples
>>> a = np.array([[1, 2], [3, 4]])
>>> a
array([[1, 2],
[3, 4]])
>>> a.transpose()
array([[1, 3],
[2, 4]])
>>> a.transpose((1, 0))
array([[1, 3],
[2, 4]])
>>> a.transpose(1, 0)
array([[1, 3],
[2, 4]])
update
(other, inplace=True)[source]¶Update this series by appending new data from an other and dropping the same amount of data off the start.
This is a convenience method that just calls append
with
resize=False
.
value_at
(x)[source]¶Return the value of this Series
at the given xindex
value
Parameters: |
|
---|---|
Returns: | y :
|
var
(axis=None, dtype=None, out=None, ddof=0, keepdims=False)¶Returns the variance of the array elements, along given axis.
Refer to numpy.var
for full documentation.
See also
numpy.var
view
(dtype=None, type=None)¶New view of array with the same data.
Parameters: | dtype : data-type or ndarray sub-class, optional
type : Python type, optional
|
---|
Notes
a.view()
is used two different ways:
a.view(some_dtype)
or a.view(dtype=some_dtype)
constructs a view
of the array’s memory with a different data-type. This can cause a
reinterpretation of the bytes of memory.
a.view(ndarray_subclass)
or a.view(type=ndarray_subclass)
just
returns an instance of ndarray_subclass
that looks at the same array
(same shape, dtype, etc.) This does not cause a reinterpretation of the
memory.
For a.view(some_dtype)
, if some_dtype
has a different number of
bytes per entry than the previous dtype (for example, converting a
regular array to a structured array), then the behavior of the view
cannot be predicted just from the superficial appearance of a
(shown
by print(a)
). It also depends on exactly how a
is stored in
memory. Therefore if a
is C-ordered versus fortran-ordered, versus
defined as a slice or transpose, etc., the view may give different
results.
Examples
>>> x = np.array([(1, 2)], dtype=[('a', np.int8), ('b', np.int8)])
Viewing array data using a different type and dtype:
>>> y = x.view(dtype=np.int16, type=np.matrix)
>>> y
matrix([[513]], dtype=int16)
>>> print(type(y))
<class 'numpy.matrixlib.defmatrix.matrix'>
Creating a view on a structured array so it can be used in calculations
>>> x = np.array([(1, 2),(3,4)], dtype=[('a', np.int8), ('b', np.int8)])
>>> xv = x.view(dtype=np.int8).reshape(-1,2)
>>> xv
array([[1, 2],
[3, 4]], dtype=int8)
>>> xv.mean(0)
array([ 2., 3.])
Making changes to the view changes the underlying array
>>> xv[0,1] = 20
>>> print(x)
[(1, 20) (3, 4)]
Using a view to convert an array to a recarray:
>>> z = x.view(np.recarray)
>>> z.a
array([1], dtype=int8)
Views share data:
>>> x[0] = (9, 10)
>>> z[0]
(9, 10)
Views that change the dtype size (bytes per entry) should normally be avoided on arrays defined by slices, transposes, fortran-ordering, etc.:
>>> x = np.array([[1,2,3],[4,5,6]], dtype=np.int16)
>>> y = x[:, 0:2]
>>> y
array([[1, 2],
[4, 5]], dtype=int16)
>>> y.view(dtype=[('width', np.int16), ('length', np.int16)])
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: new type not compatible with array.
>>> z = y.copy()
>>> z.view(dtype=[('width', np.int16), ('length', np.int16)])
array([[(1, 2)],
[(4, 5)]], dtype=[('width', '<i2'), ('length', '<i2')])
whiten
(fftlength, overlap=0, method='welch', window='hanning', detrend='constant', asd=None, **kwargs)[source]¶White this TimeSeries
against its own ASD
Parameters: | fftlength :
overlap :
method :
window :
asd :
**kwargs :
|
---|---|
Returns: | out :
|
See also
TimeSeries.asd
numpy.fft
write
(data, *args, **kwargs)¶Write this TimeSeries
to a file
Parameters: | outfile :
|
---|
Notes
The available built-in formats are:
Format | Read | Write | Auto-identify |
---|---|---|---|
csv | Yes | Yes | Yes |
framecpp | Yes | Yes | No |
hdf | Yes | Yes | No |
hdf5 | Yes | Yes | Yes |
txt | Yes | Yes | Yes |
zip
()[source]¶Zip the xindex
and value
arrays of this Series
Returns: | stacked : 2-d |
---|
Examples
>>> a = Series([0, 2, 4, 6, 8], xindex=[-5, -4, -3, -2, -1])
>>> a.zip()
array([[-5., 0.],
[-4., 2.],
[-3., 4.],
[-2., 6.],
[-1., 8.]])
zpk
(zeros, poles, gain, digital=False, unit='Hz')[source]¶Filter this TimeSeries
by applying a zero-pole-gain filter
Parameters: | zeros :
poles :
gain :
digital :
unit :
|
---|---|
Returns: | timeseries :
|
See also
TimeSeries.filter
Examples
To apply a zpk filter with file poles at 100 Hz, and five zeros at 1 Hz (giving an overall DC gain of 1e-10):
>>> data2 = data.zpk([100]*5, [1]*5, 1e-10)
gwpy.timeseries.
TimeSeriesList
(*items)[source]¶Bases: gwpy.timeseries.core.TimeSeriesBaseList
Ordered key-value mapping of named TimeSeries
objects
This object is designed to hold data for many different sources (channels) for a single time span.
The main entry points for this object are the
read()
and fetch()
data access methods.
gwpy.timeseries.
TimeSeriesDict
(*args, **kwds)[source]¶Bases: gwpy.timeseries.core.TimeSeriesBaseDict
Ordered key-value mapping of named TimeSeries
objects
This object is designed to hold data for many different sources (channels) for a single time span.
The main entry points for this object are the
read()
and fetch()
data access methods.
Methods Summary
read (*args, **kwargs) |
Read data into a TimeSeriesBaseDict . |
Methods Documentation
read
(*args, **kwargs)¶Read data into a TimeSeriesBaseDict
.
Parameters: |
channels :
start :
end :
format :
nproc :
gap :
pad :
|
---|---|
Returns: | dict :
|
Raises: | Exception :
|
Notes
The available built-in formats are:
Format | Read | Write | Auto-identify |
---|---|---|---|
framecpp | Yes | No | No |
gwf | Yes | No | Yes |
lalframe | Yes | No | No |