def co_downsample(q, n=None, ftype='fir'): '''Successively downsample broken continuous trace data (Pump). Create coroutine which takes :py:class:`Trace` objects, downsamples their data and yields new :py:class:`Trace` objects containing the downsampled data. This is useful, if one wants to downsample a long continuous time series, which is split into many successive traces without producing filter artifacts and gaps at trace boundaries. Filter states are kept *per channel*, specifically, for each (network, station, location, channel) combination occuring in the input traces, a separate state is created and maintained. This makes it possible to filter multichannel or multistation data with only one :py:func:`co_lfilter` instance. Filter state is reset, when gaps occur. The sampling instances are choosen so that they occur at (or as close as possible) to even multiples of the sampling interval of the downsampled trace (based on system time).''' b, a, n = util.decimate_coeffs(q, n, ftype) anti = co_lfilter(b, a) newtr = None states = States() try: while True: tr = yield newtr tr = anti.send(tr) newdeltat = q * tr.deltat ioffset = states.get(tr) if ioffset is None: # for fir filter, the first n samples are pulluted by boundary effects; cut it off. # for iir this may be (much) more, we do not correct for that. # put sample instances to a time which is a multiple of the new sampling interval. newtmin_want = math.ceil( (tr.tmin + (n + 1) * tr.deltat) / newdeltat) * newdeltat - ( n / 2 * tr.deltat) ioffset = int(round((newtmin_want - tr.tmin) / tr.deltat)) if ioffset < 0: ioffset = ioffset % q newtmin_have = tr.tmin + ioffset * tr.deltat newtr = tr.copy(data=False) newtr.deltat = newdeltat newtr.tmin = newtmin_have - ( n / 2 * tr.deltat ) # because the fir kernel shifts data by n/2 samples newtr.set_ydata(tr.get_ydata()[ioffset::q].copy()) states.set(tr, (ioffset % q - tr.data_len() % q) % q) except GeneratorExit: anti.close()
def co_downsample(q, n=None, ftype='fir'): '''Successively downsample broken continuous trace data (Pump). Create coroutine which takes :py:class:`Trace` objects, downsamples their data and yields new :py:class:`Trace` objects containing the downsampled data. This is useful, if one wants to downsample a long continuous time series, which is split into many successive traces without producing filter artifacts and gaps at trace boundaries. Filter states are kept *per channel*, specifically, for each (network, station, location, channel) combination occuring in the input traces, a separate state is created and maintained. This makes it possible to filter multichannel or multistation data with only one :py:func:`co_lfilter` instance. Filter state is reset, when gaps occur. The sampling instances are choosen so that they occur at (or as close as possible) to even multiples of the sampling interval of the downsampled trace (based on system time).''' b,a,n = util.decimate_coeffs(q,n,ftype) anti = co_lfilter(b,a) newtr = None states = States() try: while True: tr = yield newtr tr = anti.send(tr) newdeltat = q * tr.deltat ioffset = states.get(tr) if ioffset is None: # for fir filter, the first n samples are pulluted by boundary effects; cut it off. # for iir this may be (much) more, we do not correct for that. # put sample instances to a time which is a multiple of the new sampling interval. newtmin_want = math.ceil((tr.tmin+(n+1)*tr.deltat)/newdeltat) * newdeltat - (n/2*tr.deltat) ioffset = int(round((newtmin_want - tr.tmin)/tr.deltat)) if ioffset < 0: ioffset = ioffset % q newtmin_have = tr.tmin + ioffset * tr.deltat newtr = tr.copy(data=False) newtr.deltat = newdeltat newtr.tmin = newtmin_have - (n/2*tr.deltat) # because the fir kernel shifts data by n/2 samples newtr.set_ydata(tr.get_ydata()[ioffset::q].copy()) states.set(tr, (ioffset % q - tr.data_len() % q ) % q) except GeneratorExit: anti.close()
def co_downsample(target, q, n=None, ftype='fir'): '''Successively downsample broken continuous trace data (coroutine). Create coroutine which takes :py:class:`Trace` objects, downsamples their data and sends new :py:class:`Trace` objects containing the downsampled data to target. This is useful, if one wants to downsample a long continuous time series, which is split into many successive traces without producing filter artifacts and gaps at trace boundaries. Filter states are kept *per channel*, specifically, for each (network, station, location, channel) combination occuring in the input traces, a separate state is created and maintained. This makes it possible to filter multichannel or multistation data with only one :py:func:`co_lfilter` instance. Filter state is reset, when gaps occur. The sampling instances are choosen so that they occur at (or as close as possible) to even multiples of the sampling interval of the downsampled trace (based on system time).''' b, a, n = util.decimate_coeffs(q, n, ftype) return co_antialias(co_dropsamples(target, q, n), q, n, ftype)
def co_downsample(target, q, n=None, ftype='fir'): '''Successively downsample broken continuous trace data (coroutine). Create coroutine which takes :py:class:`Trace` objects, downsamples their data and sends new :py:class:`Trace` objects containing the downsampled data to target. This is useful, if one wants to downsample a long continuous time series, which is split into many successive traces without producing filter artifacts and gaps at trace boundaries. Filter states are kept *per channel*, specifically, for each (network, station, location, channel) combination occuring in the input traces, a separate state is created and maintained. This makes it possible to filter multichannel or multistation data with only one :py:func:`co_lfilter` instance. Filter state is reset, when gaps occur. The sampling instances are choosen so that they occur at (or as close as possible) to even multiples of the sampling interval of the downsampled trace (based on system time).''' b,a,n = util.decimate_coeffs(q,n,ftype) return co_antialias(co_dropsamples(target,q,n), q,n,ftype)
def co_antialias(target, q, n=None, ftype='fir'): b, a, n = util.decimate_coeffs(q, n, ftype) anti = co_lfilter(target, b, a) return anti
def co_antialias(target, q, n=None, ftype='fir'): b,a,n = util.decimate_coeffs(q,n,ftype) anti = co_lfilter(target, b,a) return anti