如何从python中的带通滤波器频率扫描数据中找到中断频率/3dB点？

Question

The data that i have is stored in a 2D list where one column represents a frequency and the other column is its corresponding dB. I would like to programmatically identify the frequency of the 3db points on either end of the passband. I have two ideas on how to do this but they both have drawbacks.

1. Find maximum point then the average of points in the passband then find points about 3dB lower
2. Use the sympy library to perform numerical differentiation and identify the critical points/inflection points
3. use a histogram/bin function to find the amplitude of the passband.

drawbacks

1. sensitive to spikes, not quite sure how to do this
2. i don't under stand the math involved and the data is noisy which could lead to a lot of false positives
3. correlating the amplitude values with list index values could be tricky

Can you think of better ideas and/or ways to implement what I have described?

Answer 1

Assuming that you've loaded multiple readings of the PSD from the signal analyzer, try averaging them before attempting to find the bandedges. If the signal isn't changing too dramatically, the averaging process might smooth away any peaks and valleys and noise within the passband, making it easier to find the edges. This is what many spectrum analyzers can do to make for a smoother PSD.

In case that wasn't clear, assume that each reading gives you 128 tuples of the frequency and power and that you capture 100 of these buffers of data. Now average the 100 samples from bin 0, then samples from 1, 2, ..., 128. Now try and locate the bandpass on this data. It should be easier than on any single buffer. Note I used 100 as an example. If your data is very noisy, it may require more. If there isn't much noise, fewer.

Be careful when doing the averaging. Your data is in dB. To add the samples together in order to find an average, you must first convert the dB data back to decimal, do the adds, do the divide to find the average, and then convert the averaged power back into dB.

Answer 2

Ok it seems this has to be solved by data analysis. I would propose these steps:

Preprocess you data if you suspect it to bee too noisy. I'd suggest either moving-average filter ( sp.convolve(data, sp.ones(n)/n, "same") ) or better a savitzky-golay-filter ( sp.signal.savgol_filter(data, n, polyorder=3) ) because you will be interested in extrema of the data, which will be unnecessarily distorted by the ma filter. You might also want to get rid of artifacts like 60Hz noise at this stage.

If the signal you are interested in lives in a narrow band, the spectrum will be a single pronounced peak. In that case you could just fit a curve to your data, a gaussian would be appropriate in that case.

import scipy as sp
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit

freq, pow = read_in_your_data_here()
freq, pow = sp.asarray(freq), sp.asarray(pow)

def gauss(x, a, mu, sig):
    return a**sp.exp(-(x-mu)**2/(2.*sig**2))

(a, mu, sig), _ = curve_fit(gauss, freq, pow)
fitted_curve = gauss(freq, a, mu, sig)

plt.plot(freq, pow)
plt.plot(freq, fitted_curve)
plt.vlines(mu, min(pow)-2, max(pow)+2)
plt.show()

center_idx = sp.absolute(freq-mu).argmin()
pow_center = pow[center_idx]
pow_3db = pow_center - 3.

def interv_from_binvec(data):
    indicator = sp.convolve(data, [-1,1], "same")
    return indicator.argmin(), indicator.argmax()

passband_idx = interv_from_binvec(pow > pow_3db)
passband = freq[passband_idx[0]], freq[passband_idx[1]]

This is more an example than a solution, and relies heavily on the assumption the you are searching and finding a high SNR signal with a narrow band. It could be extended to handle more than one signal by use of a mixture model.

Answer 3

You can use scipy's UnivariateSpline and leastsq methods:

1. Create a spline of y-(np.max(y)-3)
2. Find the roots of it.
3. Calculate the difference between the two roots.

from scipy.interpolate import UnivariateSpline
from scipy.optimize import leastsq

x = df["Wavelength / nm"]
y = df["Power / dBm"]

#create spline
spline = UnivariateSpline(x, y-(np.max(y)-3), s=0)

# find the roots
r1, r2 = spline.roots()

# calculate the difference
threedB_bandwidth = abs(r2-r1)