pycbc.filter package¶
Submodules¶
pycbc.filter.autocorrelation module¶
This modules provides functions for calculating the autocorrelation function and length of a data series.

pycbc.filter.autocorrelation.
calculate_acf
(data, delta_t=1.0, unbiased=False)[source]¶ Calculates the onesided autocorrelation function.
Calculates the autocorrelation function (ACF) and returns the onesided ACF. The ACF is defined as the autocovariance divided by the variance. The ACF can be estimated using
\[\hat{R}(k) = \frac{1}{n \sigma^{2}} \sum_{t=1}^{nk} \left( X_{t}  \mu \right) \left( X_{t+k}  \mu \right)\]Where \(\hat{R}(k)\) is the ACF, \(X_{t}\) is the data series at time t, \(\mu\) is the mean of \(X_{t}\), and \(\sigma^{2}\) is the variance of \(X_{t}\).
Parameters:  data (TimeSeries or numpy.array) – A TimeSeries or numpy.array of data.
 delta_t (float) – The time step of the data series if it is not a TimeSeries instance.
 unbiased (bool) – If True the normalization of the autocovariance function is nk instead of n. This is called the unbiased estimation of the autocovariance. Note that this does not mean the ACF is unbiased.
Returns: acf – If data is a TimeSeries then acf will be a TimeSeries of the onesided ACF. Else acf is a numpy.array.
Return type: numpy.array

pycbc.filter.autocorrelation.
calculate_acl
(data, m=5, dtype=<class 'int'>)[source]¶ Calculates the autocorrelation length (ACL).
Given a normalized autocorrelation function \(\rho[i]\) (by normalized, we mean that \(\rho[0] = 1\)), the ACL \(\tau\) is:
\[\tau = 1 + 2 \sum_{i=1}^{K} \rho[i].\]The number of samples used \(K\) is found by using the first point such that:
\[m \tau[K] \leq K,\]where \(m\) is a tuneable parameter (default = 5). If no such point exists, then the given data set it too short to estimate the ACL; in this case
inf
is returned.This algorithm for computing the ACL is taken from:
 Madras and A.D. Sokal, J. Stat. Phys. 50, 109 (1988).
Parameters:  data (TimeSeries or array) – A TimeSeries of data.
 m (int) – The number of autocorrelation lengths to use for determining the window size \(K\) (see above).
 dtype (int or float) – The datatype of the output. If the dtype was set to int, then the ceiling is returned.
Returns: acl – The autocorrelation length. If the ACL cannot be estimated, returns
numpy.inf
.Return type:
pycbc.filter.matchedfilter module¶
This modules provides functions for matched filtering along with associated utilities.

pycbc.filter.matchedfilter.
match
(vec1, vec2, psd=None, low_frequency_cutoff=None, high_frequency_cutoff=None, v1_norm=None, v2_norm=None)[source]¶ Return the match between the two TimeSeries or FrequencySeries.
Return the match between two waveforms. This is equivalent to the overlap maximized over time and phase.
Parameters:  vec1 (TimeSeries or FrequencySeries) – The input vector containing a waveform.
 vec2 (TimeSeries or FrequencySeries) – The input vector containing a waveform.
 psd (Frequency Series) – A power spectral density to weight the overlap.
 low_frequency_cutoff ({None, float}, optional) – The frequency to begin the match.
 high_frequency_cutoff ({None, float}, optional) – The frequency to stop the match.
 v1_norm ({None, float}, optional) – The normalization of the first waveform. This is equivalent to its sigmasq value. If None, it is internally calculated.
 v2_norm ({None, float}, optional) – The normalization of the second waveform. This is equivalent to its sigmasq value. If None, it is internally calculated.
Returns:  match (float)
 index (int) – The number of samples to shift to get the match.

pycbc.filter.matchedfilter.
matched_filter
(template, data, psd=None, low_frequency_cutoff=None, high_frequency_cutoff=None, sigmasq=None)[source]¶ Return the complex snr.
Return the complex snr, along with its associated normalization of the template, matched filtered against the data.
Parameters:  template (TimeSeries or FrequencySeries) – The template waveform
 data (TimeSeries or FrequencySeries) – The strain data to be filtered.
 psd (FrequencySeries) – The noise weighting of the filter.
 low_frequency_cutoff ({None, float}, optional) – The frequency to begin the filter calculation. If None, begin at the first frequency after DC.
 high_frequency_cutoff ({None, float}, optional) – The frequency to stop the filter calculation. If None, continue to the the nyquist frequency.
 sigmasq ({None, float}, optional) – The template normalization. If none, this value is calculated internally.
Returns: snr – A time series containing the complex snr.
Return type:

pycbc.filter.matchedfilter.
sigmasq
(htilde, psd=None, low_frequency_cutoff=None, high_frequency_cutoff=None)[source]¶ Return the loudness of the waveform. This is defined (see Duncan Brown’s thesis) as the unnormalized matchedfilter of the input waveform, htilde, with itself. This quantity is usually referred to as (sigma)^2 and is then used to normalize matchedfilters with the data.
Parameters:  htilde (TimeSeries or FrequencySeries) – The input vector containing a waveform.
 psd ({None, FrequencySeries}, optional) – The psd used to weight the accumulated power.
 low_frequency_cutoff ({None, float}, optional) – The frequency to begin considering waveform power.
 high_frequency_cutoff ({None, float}, optional) – The frequency to stop considering waveform power.
Returns: sigmasq
Return type:

pycbc.filter.matchedfilter.
sigma
(htilde, psd=None, low_frequency_cutoff=None, high_frequency_cutoff=None)[source]¶ Return the sigma of the waveform. See sigmasq for more details.
Parameters:  htilde (TimeSeries or FrequencySeries) – The input vector containing a waveform.
 psd ({None, FrequencySeries}, optional) – The psd used to weight the accumulated power.
 low_frequency_cutoff ({None, float}, optional) – The frequency to begin considering waveform power.
 high_frequency_cutoff ({None, float}, optional) – The frequency to stop considering waveform power.
Returns: sigmasq
Return type:

pycbc.filter.matchedfilter.
get_cutoff_indices
(flow, fhigh, df, N)[source]¶ Gets the indices of a frequency series at which to stop an overlap calculation.
Parameters: Returns:  kmin (int)
 kmax (int)

pycbc.filter.matchedfilter.
sigmasq_series
(htilde, psd=None, low_frequency_cutoff=None, high_frequency_cutoff=None)[source]¶ Return a cumulative sigmasq frequency series.
Return a frequency series containing the accumulated power in the input up to that frequency.
Parameters:  htilde (TimeSeries or FrequencySeries) – The input vector
 psd ({None, FrequencySeries}, optional) – The psd used to weight the accumulated power.
 low_frequency_cutoff ({None, float}, optional) – The frequency to begin accumulating power. If None, start at the beginning of the vector.
 high_frequency_cutoff ({None, float}, optional) – The frequency to stop considering accumulated power. If None, continue until the end of the input vector.
Returns: Frequency Series – A frequency series containing the cumulative sigmasq.
Return type:

pycbc.filter.matchedfilter.
make_frequency_series
(vec)[source]¶ Return a frequency series of the input vector.
If the input is a frequency series it is returned, else if the input vector is a real time series it is fourier transformed and returned as a frequency series.
Parameters: vector (TimeSeries or FrequencySeries) – Returns: Frequency Series – A frequency domain version of the input vector. Return type: FrequencySeries

pycbc.filter.matchedfilter.
overlap
(vec1, vec2, psd=None, low_frequency_cutoff=None, high_frequency_cutoff=None, normalized=True)[source]¶ Return the overlap between the two TimeSeries or FrequencySeries.
Parameters:  vec1 (TimeSeries or FrequencySeries) – The input vector containing a waveform.
 vec2 (TimeSeries or FrequencySeries) – The input vector containing a waveform.
 psd (Frequency Series) – A power spectral density to weight the overlap.
 low_frequency_cutoff ({None, float}, optional) – The frequency to begin the overlap.
 high_frequency_cutoff ({None, float}, optional) – The frequency to stop the overlap.
 normalized ({True, boolean}, optional) – Set if the overlap is normalized. If true, it will range from 0 to 1.
Returns: overlap
Return type:

pycbc.filter.matchedfilter.
overlap_cplx
(vec1, vec2, psd=None, low_frequency_cutoff=None, high_frequency_cutoff=None, normalized=True)[source]¶ Return the complex overlap between the two TimeSeries or FrequencySeries.
Parameters:  vec1 (TimeSeries or FrequencySeries) – The input vector containing a waveform.
 vec2 (TimeSeries or FrequencySeries) – The input vector containing a waveform.
 psd (Frequency Series) – A power spectral density to weight the overlap.
 low_frequency_cutoff ({None, float}, optional) – The frequency to begin the overlap.
 high_frequency_cutoff ({None, float}, optional) – The frequency to stop the overlap.
 normalized ({True, boolean}, optional) – Set if the overlap is normalized. If true, it will range from 0 to 1.
Returns: overlap
Return type:

pycbc.filter.matchedfilter.
matched_filter_core
(template, data, psd=None, low_frequency_cutoff=None, high_frequency_cutoff=None, h_norm=None, out=None, corr_out=None)[source]¶ Return the complex snr and normalization.
Return the complex snr, along with its associated normalization of the template, matched filtered against the data.
Parameters:  template (TimeSeries or FrequencySeries) – The template waveform
 data (TimeSeries or FrequencySeries) – The strain data to be filtered.
 psd ({FrequencySeries}, optional) – The noise weighting of the filter.
 low_frequency_cutoff ({None, float}, optional) – The frequency to begin the filter calculation. If None, begin at the first frequency after DC.
 high_frequency_cutoff ({None, float}, optional) – The frequency to stop the filter calculation. If None, continue to the the nyquist frequency.
 h_norm ({None, float}, optional) – The template normalization. If none, this value is calculated internally.
 out ({None, Array}, optional) – An array to use as memory for snr storage. If None, memory is allocated internally.
 corr_out ({None, Array}, optional) – An array to use as memory for correlation storage. If None, memory is allocated internally. If provided, management of the vector is handled externally by the caller. No zero’ing is done internally.
Returns:  snr (TimeSeries) – A time series containing the complex snr.
 corrrelation (FrequencySeries) – A frequency series containing the correlation vector.
 norm (float) – The normalization of the complex snr.

class
pycbc.filter.matchedfilter.
MatchedFilterControl
(low_frequency_cutoff, high_frequency_cutoff, snr_threshold, tlen, delta_f, dtype, segment_list, template_output, use_cluster, downsample_factor=1, upsample_threshold=1, upsample_method='pruned_fft', gpu_callback_method='none', cluster_function='symmetric')[source]¶ Bases:
object

full_matched_filter_and_cluster_fc
(segnum, template_norm, window, epoch=None)[source]¶ Returns the complex snr timeseries, normalization of the complex snr, the correlation vector frequency series, the list of indices of the triggers, and the snr values at the trigger locations. Returns empty lists for these for points that are not above the threshold.
Calculated the matched filter, threshold, and cluster.
Parameters: Returns:  snr (TimeSeries) – A time series containing the complex snr.
 norm (float) – The normalization of the complex snr.
 corrrelation (FrequencySeries) – A frequency series containing the correlation vector.
 idx (Array) – List of indices of the triggers.
 snrv (Array) – The snr values at the trigger locations.

full_matched_filter_and_cluster_symm
(segnum, template_norm, window, epoch=None)[source]¶ Returns the complex snr timeseries, normalization of the complex snr, the correlation vector frequency series, the list of indices of the triggers, and the snr values at the trigger locations. Returns empty lists for these for points that are not above the threshold.
Calculated the matched filter, threshold, and cluster.
Parameters: Returns:  snr (TimeSeries) – A time series containing the complex snr.
 norm (float) – The normalization of the complex snr.
 corrrelation (FrequencySeries) – A frequency series containing the correlation vector.
 idx (Array) – List of indices of the triggers.
 snrv (Array) – The snr values at the trigger locations.

full_matched_filter_thresh_only
(segnum, template_norm, window=None, epoch=None)[source]¶ Returns the complex snr timeseries, normalization of the complex snr, the correlation vector frequency series, the list of indices of the triggers, and the snr values at the trigger locations. Returns empty lists for these for points that are not above the threshold.
Calculated the matched filter, threshold, and cluster.
Parameters:  segnum (int) – Index into the list of segments at MatchedFilterControl construction against which to filter.
 template_norm (float) – The htilde, template normalization factor.
 window (int) – Size of the window over which to cluster triggers, in samples. This is IGNORED by this function, and provided only for API compatibility.
Returns:  snr (TimeSeries) – A time series containing the complex snr.
 norm (float) – The normalization of the complex snr.
 corrrelation (FrequencySeries) – A frequency series containing the correlation vector.
 idx (Array) – List of indices of the triggers.
 snrv (Array) – The snr values at the trigger locations.

heirarchical_matched_filter_and_cluster
(segnum, template_norm, window)[source]¶ Returns the complex snr timeseries, normalization of the complex snr, the correlation vector frequency series, the list of indices of the triggers, and the snr values at the trigger locations. Returns empty lists for these for points that are not above the threshold.
Calculated the matched filter, threshold, and cluster.
Parameters: Returns:  snr (TimeSeries) – A time series containing the complex snr at the reduced sample rate.
 norm (float) – The normalization of the complex snr.
 corrrelation (FrequencySeries) – A frequency series containing the correlation vector.
 idx (Array) – List of indices of the triggers.
 snrv (Array) – The snr values at the trigger locations.


class
pycbc.filter.matchedfilter.
LiveBatchMatchedFilter
(templates, snr_threshold, chisq_bins, sg_chisq, maxelements=134217728, snr_abort_threshold=None, newsnr_threshold=None, max_triggers_in_batch=None)[source]¶ Bases:
object
Calculate SNR and signal consistency tests in a batched progression

class
pycbc.filter.matchedfilter.
MatchedFilterSkyMaxControl
(low_frequency_cutoff, high_frequency_cutoff, snr_threshold, tlen, delta_f, dtype)[source]¶ Bases:
object

full_matched_filter_and_cluster
(hplus, hcross, hplus_norm, hcross_norm, psd, stilde, window)[source]¶ Return the complex snr and normalization.
Calculated the matched filter, threshold, and cluster.
Parameters:  h_quantities (Various) – FILL ME IN
 stilde (FrequencySeries) – The strain data to be filtered.
 window (int) – The size of the cluster window in samples.
Returns:  snr (TimeSeries) – A time series containing the complex snr.
 norm (float) – The normalization of the complex snr.
 correlation (FrequencySeries) – A frequency series containing the correlation vector.
 idx (Array) – List of indices of the triggers.
 snrv (Array) – The snr values at the trigger locations.


class
pycbc.filter.matchedfilter.
MatchedFilterSkyMaxControlNoPhase
(low_frequency_cutoff, high_frequency_cutoff, snr_threshold, tlen, delta_f, dtype)[source]¶ Bases:
pycbc.filter.matchedfilter.MatchedFilterSkyMaxControl

pycbc.filter.matchedfilter.
compute_max_snr_over_sky_loc_stat_no_phase
(hplus, hcross, hphccorr, hpnorm=None, hcnorm=None, out=None, thresh=0, analyse_slice=None)[source]¶ Compute the match maximized over polarization phase.
In contrast to compute_max_snr_over_sky_loc_stat_no_phase this function performs no maximization over orbital phase, treating that as an intrinsic parameter. In the case of alignedspin 2,2mode only waveforms, this collapses to the normal statistic (at twice the computational cost!)
Parameters:  hplus (TimeSeries) – This is the IFFTed complex SNR time series of (h+, data). If not normalized, supply the normalization factor so this can be done! It is recommended to normalize this before sending through this function
 hcross (TimeSeries) – This is the IFFTed complex SNR time series of (hx, data). If not normalized, supply the normalization factor so this can be done!
 hphccorr (float) – The real component of the overlap between the two polarizations Re[(h+, hx)]. Note that the imaginary component does not enter the detection statistic. This must be normalized and is signsensitive.
 thresh (float) – Used for optimization. If we do not care about the value of SNR values below thresh we can calculate a quick statistic that will always overestimate SNR and then only calculate the proper, more expensive, statistic at points where the quick SNR is above thresh.
 hpsigmasq (float) – The normalization factor (h+, h+). Default = None (=1, already normalized)
 hcsigmasq (float) – The normalization factor (hx, hx). Default = None (=1, already normalized)
 out (TimeSeries (optional, default=None)) – If given, use this array to store the output.
Returns: det_stat – The SNR maximized over sky location
Return type:

pycbc.filter.matchedfilter.
compute_max_snr_over_sky_loc_stat
(hplus, hcross, hphccorr, hpnorm=None, hcnorm=None, out=None, thresh=0, analyse_slice=None)[source]¶ Compute the maximized over sky location statistic.
Parameters:  hplus (TimeSeries) – This is the IFFTed complex SNR time series of (h+, data). If not normalized, supply the normalization factor so this can be done! It is recommended to normalize this before sending through this function
 hcross (TimeSeries) – This is the IFFTed complex SNR time series of (hx, data). If not normalized, supply the normalization factor so this can be done!
 hphccorr (float) – The real component of the overlap between the two polarizations Re[(h+, hx)]. Note that the imaginary component does not enter the detection statistic. This must be normalized and is signsensitive.
 thresh (float) – Used for optimization. If we do not care about the value of SNR values below thresh we can calculate a quick statistic that will always overestimate SNR and then only calculate the proper, more expensive, statistic at points where the quick SNR is above thresh.
 hpsigmasq (float) – The normalization factor (h+, h+). Default = None (=1, already normalized)
 hcsigmasq (float) – The normalization factor (hx, hx). Default = None (=1, already normalized)
 out (TimeSeries (optional, default=None)) – If given, use this array to store the output.
Returns: det_stat – The SNR maximized over sky location
Return type:

pycbc.filter.matchedfilter.
compute_followup_snr_series
(data_reader, htilde, trig_time, duration=0.095, check_state=True, coinc_window=0.05)[source]¶ Given a StrainBuffer, a template frequency series and a trigger time, compute a portion of the SNR time series centered on the trigger for its rapid sky localization and followup.
If the trigger time is too close to the boundary of the valid data segment the SNR series is calculated anyway and might be slightly contaminated by filter and wraparound effects. For reasonable durations this will only affect a small fraction of the triggers and probably in a negligible way.
Parameters:  data_reader (StrainBuffer) – The StrainBuffer object to read strain data from.
 htilde (FrequencySeries) – The frequency series containing the template waveform.
 trig_time ({float, lal.LIGOTimeGPS}) – The trigger time.
 duration (float (optional)) – Duration of the computed SNR series in seconds. If omitted, it defaults to twice the Earth light travel time plus 10 ms of timing uncertainty.
 check_state (boolean) – If True, and the detector was offline or flagged for bad data quality at any point during the inspiral, then return (None, None) instead.
 coinc_window (float (optional)) – Maximum possible time between coincident triggers at different detectors. This is needed to properly determine data padding.
Returns: snr – The portion of SNR around the trigger. None if the detector is offline or has bad data quality, and check_state is True.
Return type:

pycbc.filter.matchedfilter.
compute_u_val_for_sky_loc_stat_no_phase
(hplus, hcross, hphccorr, hpnorm=None, hcnorm=None, indices=None)[source]¶ The maxoversky location (no phase) detection statistic maximizes over an amplitude and the ratio of F+ and Fx, encoded in a variable called u. Here we return the value of u for the given indices.

pycbc.filter.matchedfilter.
compute_u_val_for_sky_loc_stat
(hplus, hcross, hphccorr, hpnorm=None, hcnorm=None, indices=None)[source]¶ The maxoversky location detection statistic maximizes over a phase, an amplitude and the ratio of F+ and Fx, encoded in a variable called u. Here we return the value of u for the given indices.
pycbc.filter.matchedfilter_cpu module¶

class
pycbc.filter.matchedfilter_cpu.
CPUCorrelator
¶ Bases:
pycbc.filter.matchedfilter._BaseCorrelator

correlate
¶


pycbc.filter.matchedfilter_cpu.
batch_correlate_execute
(self, y)¶

pycbc.filter.matchedfilter_cpu.
correlate
(x, y, z)¶

pycbc.filter.matchedfilter_cpu.
correlate_numpy
(x, y, z)¶
pycbc.filter.matchedfilter_numpy module¶
pycbc.filter.qtransform module¶
This module retrives a timeseries and then calculates the qtransform of that time series

pycbc.filter.qtransform.
deltam_f
(mismatch)[source]¶ Fractional mismatch between neighbouring tiles
Parameters: mismatch ('float') – percentage of desired fractional mismatch Returns: Return type: type: ‘float’

pycbc.filter.qtransform.
qplane
(qplane_tile_dict, fseries, return_complex=False)[source]¶  Performs qtransform on each tile for each qplane and selects
 tile with the maximum energy. Qtransform can then be interpolated to a desired frequency and time resolution.
Parameters:  qplane_tile_dict – Dictionary containing a list of qtile tupples for each qplane
 fseries ('pycbc FrequencySeries') – frequencyseries data set
 return_complex ({False, bool}) – Return the raw complex series instead of the normalized power.
Returns:  q (float) – The q of the maximum q plane
 times (numpy.ndarray) – The time that the qtransform is sampled.
 freqs (numpy.ndarray) – The frequencies that the qtransform is samled.
 qplane (numpy.ndarray (2d)) – The two dimensional interpolated qtransform of this time series.

pycbc.filter.qtransform.
qseries
(fseries, Q, f0, return_complex=False)[source]¶ Calculate the energy ‘TimeSeries’ for the given fseries
Parameters:  fseries ('pycbc FrequencySeries') – frequencyseries data set
 Q – q value
 f0 – central frequency
 return_complex ({False, bool}) – Return the raw complex series instead of the normalized power.
Returns: energy – A ‘TimeSeries’ of the normalized energy from the Qtransform of this tile against the data.
Return type: ‘~pycbc.types.TimeSeries’

pycbc.filter.qtransform.
qtiling
(fseries, qrange, frange, mismatch=0.2)[source]¶ Iterable constructor of QTile tuples
Parameters:  fseries ('pycbc FrequencySeries') – frequencyseries data set
 qrange – upper and lower bounds of q range
 frange – upper and lower bounds of frequency range
 mismatch – percentage of desired fractional mismatch
Returns: qplane_tile_dict – dictionary containing Qtile tuples for a set of Qplanes
Return type: ‘dict’
pycbc.filter.resample module¶

pycbc.filter.resample.
resample_to_delta_t
(timeseries, delta_t, method='butterworth')[source]¶ Resmple the time_series to delta_t
Resamples the TimeSeries instance time_series to the given time step, delta_t. Only powers of two and real valued time series are supported at this time. Additional restrictions may apply to particular filter methods.
Parameters:  time_series (TimeSeries) – The time series to be resampled
 delta_t (float) – The desired time step
Returns: Time Series – A TimeSeries that has been resampled to delta_t.
Return type: Raises:  TypeError: – time_series is not an instance of TimeSeries.
 TypeError: – time_series is not real valued
Examples
>>> h_plus_sampled = resample_to_delta_t(h_plus, 1.0/2048)

pycbc.filter.resample.
highpass
(timeseries, frequency, filter_order=8, attenuation=0.1)[source]¶ Return a new timeseries that is highpassed.
Return a new time series that is highpassed above the frequency.
Parameters:  Series (Time) – The time series to be highpassed.
 frequency (float) – The frequency below which is suppressed.
 filter_order ({8, int}, optional) – The order of the filter to use when highpassing the time series.
 attenuation ({0.1, float}, optional) – The attenuation of the filter.
Returns: Time Series – A new TimeSeries that has been highpassed.
Return type: Raises:  TypeError: – time_series is not an instance of TimeSeries.
 TypeError: – time_series is not real valued

pycbc.filter.resample.
interpolate_complex_frequency
(series, delta_f, zeros_offset=0, side='right')[source]¶ Interpolate complex frequency series to desired delta_f.
Return a new complex frequency series that has been interpolated to the desired delta_f.
Parameters:  series (FrequencySeries) – Frequency series to be interpolated.
 delta_f (float) – The desired delta_f of the output
 zeros_offset (optional, {0, int}) – Number of sample to delay the start of the zero padding
 side (optional, {'right', str}) – The side of the vector to zero pad
Returns: interpolated series – A new FrequencySeries that has been interpolated.
Return type:

pycbc.filter.resample.
highpass_fir
(timeseries, frequency, order, beta=5.0)[source]¶ Highpass filter the time series using an FIR filtered generated from the ideal response passed through a kaiser window (beta = 5.0)
Parameters:

pycbc.filter.resample.
lowpass_fir
(timeseries, frequency, order, beta=5.0)[source]¶ Lowpass filter the time series using an FIR filtered generated from the ideal response passed through a kaiser window (beta = 5.0)
Parameters:

pycbc.filter.resample.
notch_fir
(timeseries, f1, f2, order, beta=5.0)[source]¶ notch filter the time series using an FIR filtered generated from the ideal response passed through a timedomain kaiser window (beta = 5.0)
The suppression of the notch filter is related to the bandwidth and the number of samples in the filter length. For a few Hz bandwidth, a length corresponding to a few seconds is typically required to create significant suppression in the notched band. To achieve frequency resolution df at sampling frequency fs, order should be at least fs/df.
Parameters:  Series (Time) – The time series to be notched.
 f1 (float) – The start of the frequency suppression.
 f2 (float) – The end of the frequency suppression.
 order (int) – Number of corrupted samples on each side of the time series (Extent of the filter on either side of zero)
 beta (float) – Beta parameter of the kaiser window that sets the side lobe attenuation.

pycbc.filter.resample.
fir_zero_filter
(coeff, timeseries)[source]¶ Filter the timeseries with a set of FIR coefficients
Parameters:  coeff (numpy.ndarray) – FIR coefficients. Should be and odd length and symmetric.
 timeseries (pycbc.types.TimeSeries) – Time series to be filtered.
Returns:  filtered_series (pycbc.types.TimeSeries) – Return the filtered timeseries, which has been properly shifted to account
 for the FIR filter delay and the corrupted regions zeroed out.
pycbc.filter.simd_correlate module¶
pycbc.filter.simd_correlate_cython module¶

pycbc.filter.simd_correlate_cython.
ccorrf_parallel
()¶

pycbc.filter.simd_correlate_cython.
ccorrf_simd
()¶
pycbc.filter.zpk module¶

pycbc.filter.zpk.
filter_zpk
(timeseries, z, p, k)[source]¶ Return a new timeseries that was filtered with a zeropolegain filter. The transfer function in the sdomain looks like: .. math:: frac{H(s) = (s  s_1) * (s  s_3) * … * (s  s_n)}{(s  s_2) * (s  s_4) * … * (s  s_m)}, m >= n
The zeroes, and poles entered in Hz are converted to angular frequency, along the imaginary axis in the sdomain s=i*omega. Then the zeroes, and poles are bilinearly transformed via: .. math:: z(s) = frac{(1 + s*T/2)}{(1  s*T/2)}
Where z is the zdomain value, s is the sdomain value, and T is the sampling period. After the poles and zeroes have been bilinearly transformed, then the secondorder sections are found and filter the data using scipy.
Parameters:  timeseries (TimeSeries) – The TimeSeries instance to be filtered.
 z (array) – Array of zeros to include in zeropolegain filter design. In units of Hz.
 p (array) – Array of poles to include in zeropolegain filter design. In units of Hz.
 k (float) – Gain to include in zeropolegain filter design. This gain is a constant multiplied to the transfer function.
Returns: Time Series – A new TimeSeries that has been filtered.
Return type: Examples
To apply a 5 zeroes at 100Hz, 5 poles at 1Hz, and a gain of 1e10 filter to a TimeSeries instance, do: >>> filtered_data = zpk_filter(timeseries, [100]*5, [1]*5, 1e10)