def resp_spectrum(source, resp_file, downsamp_freq): ''' remove the instrument response with response spectrum from evalresp. the response spectrum is evaluated based on RESP/PZ files and then inverted using obspy function of invert_spectrum. ''' #--------resp_file is the inverted spectrum response--------- respz = np.load(resp_file) nrespz = respz[1][:] spec_freq = max(respz[0]) #-------on current trace---------- nfft = _npts2nfft(source.stats.npts) sps = source.stats.sample_rate #---------do the interpolation if needed-------- if spec_freq < 0.5 * sps: raise ValueError( 'spectrum file has peak freq smaller than the data, abort!') else: indx = np.where(respz[0] <= 0.5 * sps) nfreq = np.linspace(0, 0.5 * sps, nfft) nrespz = np.interp(nfreq, respz[0][indx], respz[1][indx]) #----do interpolation if necessary----- source_spect = np.fft.rfft(source.data, n=nfft) #-----nrespz is inversed (water-leveled) spectrum----- source_spect *= nrespz source.data = np.fft.irfft(source_spect)[0:source.stats.npts] return source
def convolve(trace, transfer_function, pre_filt=False): # write data to a numpy array data = trace.data npts = len(data) nfft = _npts2nfft(npts) # Transform data to frequency domain data = np.fft.rfft(data, n=nfft) # find the frequencies corresponding to each element of the fft delta = trace.stats.delta fy = 1. / (delta * 2.0) # start at zero to get zero for offset/ DC of fft frequencies = np.linspace(0, fy, nfft // 2 + 1) # pre-filter the data if pre_filt: freq_domain_taper = cosine_sac_taper(frequencies, flimit=pre_filt) data *= freq_domain_taper # perform the convolution data *= transfer_function(frequencies) data[-1] = abs(data[-1]) + 0.0j # transform data back into the time domain data = np.fft.irfft(data)[0:npts] # write data back into trace trace.data = data
def filter_synt(tr, pre_filt): """ Perform a frequency domain taper like during the response removal just without an actual response... :param tr: :param pre_filt: :return: """ data = tr.data.astype(np.float64) # smart calculation of nfft dodging large primes nfft = _npts2nfft(len(data)) fy = 1.0 / (tr.stats.delta * 2.0) freqs = np.linspace(0, fy, nfft // 2 + 1) # Transform data to Frequency domain data = np.fft.rfft(data, n=nfft) data *= c_sac_taper(freqs, flimit=pre_filt) data[-1] = abs(data[-1]) + 0.0j # transform data back into the time domain data = np.fft.irfft(data)[0 : len(data)] # assign processed data and store processing information tr.data = data
def filter_trace(tr, pre_filt): """ Perform a frequency domain taper mimicing the behavior during the response removal, without a actual response removal. :param tr: input trace :param pre_filt: frequency array(Hz) in ascending order, to define the four corners of filter, for example, [0.01, 0.1, 0.2, 0.5]. :type pre_filt: Numpy.array or list :return: filtered trace """ if type(tr) != obspy.Trace: raise ValueError("First Argument should be trace: %s" % type(tr)) if not check_array_order(pre_filt): raise ValueError("Frequency band should be in ascending order: %s" % pre_filt) data = tr.data.astype(np.float64) # smart calculation of nfft dodging large primes nfft = _npts2nfft(len(data)) fy = 1.0 / (tr.stats.delta * 2.0) freqs = np.linspace(0, fy, nfft // 2 + 1) # Transform data to Frequency domain data = np.fft.rfft(data, n=nfft) data *= c_sac_taper(freqs, flimit=pre_filt) data[-1] = abs(data[-1]) + 0.0j # transform data back into the time domain data = np.fft.irfft(data)[0:len(data)] # assign processed data and store processing information tr.data = data
def filter_trace(tr, pre_filt): """ Perform a frequency domain taper mimicing the behavior during the response removal, without a actual response removal. :param tr: input trace :param pre_filt: frequency array(Hz) in ascending order, to define the four corners of filter, for example, [0.01, 0.1, 0.2, 0.5]. :type pre_filt: Numpy.array or list :return: filtered trace """ if not isinstance(tr, Trace): raise TypeError("First Argument should be trace: %s" % type(tr)) if not check_array_order(pre_filt): raise ValueError("Frequency band should be in ascending order: %s" % pre_filt) data = tr.data.astype(np.float64) # smart calculation of nfft dodging large primes nfft = _npts2nfft(len(data)) fy = 1.0 / (tr.stats.delta * 2.0) freqs = np.linspace(0, fy, nfft // 2 + 1) # Transform data to Frequency domain data = np.fft.rfft(data, n=nfft) data *= c_sac_taper(freqs, flimit=pre_filt) data[-1] = abs(data[-1]) + 0.0j # transform data back into the time domain data = np.fft.irfft(data)[0:len(data)] # assign processed data and store processing information tr.data = data
def process_function(st, inv): st.detrend("linear") st.detrend("demean") st.taper(max_percentage=0.05, type="hann") # Perform a frequency domain taper like during the response removal # just without an actual response... for tr in st: data = tr.data.astype(np.float64) # smart calculation of nfft dodging large primes from obspy.signal.util import _npts2nfft nfft = _npts2nfft(len(data)) fy = 1.0 / (tr.stats.delta * 2.0) freqs = np.linspace(0, fy, nfft // 2 + 1) # Transform data to Frequency domain data = np.fft.rfft(data, n=nfft) data *= c_sac_taper(freqs, flimit=pre_filt) data[-1] = abs(data[-1]) + 0.0j # transform data back into the time domain data = np.fft.irfft(data)[0:len(data)] # assign processed data and store processing information tr.data = data st.detrend("linear") st.detrend("demean") st.taper(max_percentage=0.05, type="hann") st.interpolate(sampling_rate=sampling_rate, starttime=starttime, npts=npts) components = [tr.stats.channel[-1] for tr in st] if "N" in components and "E" in components: station_latitude = inv[0][0].latitude station_longitude = inv[0][0].longitude _, baz, _ = gps2DistAzimuth(station_latitude, station_longitude, event_latitude, event_longitude) st.rotate(method="NE->RT", back_azimuth=baz) # Convert to single precision to save space. for tr in st: tr.data = np.require(tr.data, dtype="float32") return st
def process_synthetics(self): lowpass_freq = 1 / 60. highpass_freq = 1 / 120. freqmin = highpass_freq freqmax = lowpass_freq f2 = highpass_freq f3 = lowpass_freq f1 = 0.8 * f2 f4 = 1.2 * f3 pre_filt = (f1, f2, f3, f4) self.tr.differentiate() # self.tr.data = convolve_stf(self.tr.data) self.tr.detrend("linear") self.tr.detrend("demean") self.tr.taper(max_percentage=0.05, type="hann") # Perform a frequency domain taper like during the response removal # just without an actual response... data = self.tr.data.astype(np.float64) orig_len = len(data) # smart calculation of nfft dodging large primes from obspy.signal.util import _npts2nfft from obspy.signal.invsim import c_sac_taper nfft = _npts2nfft(len(data)) fy = 1.0 / (self.tr.stats.delta * 2.0) freqs = np.linspace(0, fy, nfft // 2 + 1) # Transform data to Frequency domain data = np.fft.rfft(data, n=nfft) data *= c_sac_taper(freqs, flimit=pre_filt) data[-1] = abs(data[-1]) + 0.0j # transform data back into the time domain data = np.fft.irfft(data)[0:orig_len] # assign processed data and store processing information self.tr.data = data
def sync_remove_response(pre_filt, st): """ mimic obspy.remove_response, but only do the frequency taper """ for trace in st: data = trace.data.astype(np.float64) npts = len(data) nfft = _npts2nfft(npts) data = np.fft.rfft(data, n=nfft) t_samp = trace.stats.delta fy = 1 / (t_samp * 2.0) freqs = np.linspace(0, fy, nfft // 2 + 1).astype(np.float64) freq_domain_taper = obspy.signal.invsim.cosine_sac_taper( freqs, flimit=pre_filt) data *= freq_domain_taper data = np.fft.irfft(data)[0:npts] trace.data = data return st
def pre_filter(stream, pre_filt=(0.02, 0.05, 8.0, 10.0)): """ Applies the same filter as remove_response without actually removing the response. """ for tr in stream: data = tr.data.astype(np.float64) nfft = _npts2nfft(len(data)) fy = 1.0 / (tr.stats.delta * 2.0) freqs = np.linspace(0, fy, nfft // 2 + 1) # Transform data to Frequency domain data = np.fft.rfft(data, n=nfft) data *= c_sac_taper(freqs, flimit=pre_filt) data[-1] = abs(data[-1]) + 0.0j # transform data back into the time domain data = np.fft.irfft(data)[0:tr.stats.npts] # assign processed data and store processing information tr.data = data return stream
def pre_filter(stream, pre_filt=(0.02, 0.05, 8.0, 10.0)): """ Applies the same filter as remove_response without actually removing the response. """ for tr in stream: data = tr.data.astype(np.float64) nfft = _npts2nfft(len(data)) fy = 1.0 / (tr.stats.delta * 2.0) freqs = np.linspace(0, fy, nfft // 2 + 1) # Transform data to Frequency domain data = np.fft.rfft(data, n=nfft) data *= cosine_sac_taper(freqs, flimit=pre_filt) data[-1] = abs(data[-1]) + 0.0j # transform data back into the time domain data = np.fft.irfft(data)[0:len(data)] # assign processed data and store processing information tr.data = data return stream
def convolve(trace, func): from obspy.signal.util import _npts2nfft from obspy.signal.invsim import cosine_sac_taper data = trace.data delta = trace.stats.delta npts = len(data) nfft = _npts2nfft(npts) # Transform data to Frequency domain data = np.fft.rfft(data, n=nfft) fy = 1. / (delta * 2.0) # start at zero to get zero for offset/ DC of fft freqs = np.linspace(0, fy, nfft // 2 + 1) freq_response = func(freqs) if pre_filt: freq_domain_taper = cosine_sac_taper(freqs, flimit=pre_filt) data *= freq_domain_taper ''' if water_level is None: # No water level used, so just directly invert the response. # First entry is at zero frequency and value is zero, too. # Just do not invert the first value (and set to 0 to make sure). freq_response[0] = 0.0 freq_response[1:] = 1.0 / freq_response[1:] else: # Invert spectrum with specified water level. invert_spectrum(freq_response, water_level) ''' data *= freq_response data[-1] = abs(data[-1]) + 0.0j # transform data back into the time domain data = np.fft.irfft(data)[0:npts]
def filter_synt(tr, pre_filt): """ Perform a frequency domain taper like during the response removal just without an actual response... :param tr: :param pre_filt: :return: """ data = tr.data.astype(np.float64) # smart calculation of nfft dodging large primes nfft = _npts2nfft(len(data)) fy = 1.0 / (tr.stats.delta * 2.0) freqs = np.linspace(0, fy, nfft // 2 + 1) # Transform data to Frequency domain data = np.fft.rfft(data, n=nfft) data *= cosine_sac_taper(freqs, flimit=pre_filt) data[-1] = abs(data[-1]) + 0.0j # transform data back into the time domain data = np.fft.irfft(data)[0:len(data)] # assign processed data and store processing information tr.data = data
def convolve_stf(stf: np.array, data: np.array, nfft=None): # conv = np.convolve(stf, data, mode="same") from scipy import signal # recovered, remainder = signal.deconvolve(data, stf) from obspy.signal.util import _npts2nfft import math if nfft is None: nfft = _npts2nfft(npts=len(data)) stf_conv_f = np.fft.rfft(stf, n=nfft) # Apply a 5 percent, at least 5 samples taper at the end. # The first sample is guaranteed to be zero in any case. tlen = max(int(math.ceil(0.05 * len(data))), 5) taper = np.ones_like(data) taper[-tlen:] = signal.hann(tlen * 2)[tlen:] dataf = np.fft.rfft(taper * data, n=nfft) f = stf_conv_f recovered = np.fft.irfft(dataf * f)[:nfft] return recovered
def remove_response2(self, inventory=None, output="VEL", water_level=60, pre_filt=None, zero_mean=True, taper=True, taper_fraction=0.05, plot=False, fig=None, **kwargs): """ EDIT OF OBSPY'S REMOVE_RESPONSE FUNCTION Including titles etc. Deconvolve instrument response. Uses the adequate :class:`obspy.core.inventory.response.Response` from the provided :class:`obspy.core.inventory.inventory.Inventory` data. Raises an exception if the response is not present. Note that there are two ways to prevent overamplification while convolving the inverted instrument spectrum: One possibility is to specify a water level which represents a clipping of the inverse spectrum and limits amplification to a certain maximum cut-off value (`water_level` in dB). The other possibility is to taper the waveform data in the frequency domain prior to multiplying with the inverse spectrum, i.e. perform a pre-filtering in the frequency domain (specifying the four corner frequencies of the frequency taper as a tuple in `pre_filt`). .. note:: Any additional kwargs will be passed on to :meth:`obspy.core.inventory.response.Response.get_evalresp_response`, see documentation of that method for further customization (e.g. start/stop stage). .. note:: Using :meth:`~Trace.remove_response` is equivalent to using :meth:`~Trace.simulate` with the identical response provided as a (dataless) SEED or RESP file and when using the same `water_level` and `pre_filt` (and options `sacsim=True` and `pitsasim=False` which influence very minor details in detrending and tapering). .. rubric:: Example >>> from obspy import read, read_inventory >>> st = read() >>> tr = st[0].copy() >>> inv = read_inventory() >>> tr.remove_response(inventory=inv) # doctest: +ELLIPSIS <...Trace object at 0x...> >>> tr.plot() # doctest: +SKIP .. plot:: from obspy import read, read_inventory st = read() tr = st[0] inv = read_inventory() tr.remove_response(inventory=inv) tr.plot() Using the `plot` option it is possible to visualize the individual steps during response removal in the frequency domain to check the chosen `pre_filt` and `water_level` options to stabilize the deconvolution of the inverted instrument response spectrum: >>> from obspy import read, read_inventory >>> st = read("/path/to/IU_ULN_00_LH1_2015-07-18T02.mseed") >>> tr = st[0] >>> inv = read_inventory("/path/to/IU_ULN_00_LH1.xml") >>> pre_filt = [0.001, 0.005, 45, 50] >>> tr.remove_response(inventory=inv, pre_filt=pre_filt, output="DISP", ... water_level=60, plot=True) # doctest: +SKIP <...Trace object at 0x...> .. plot:: from obspy import read, read_inventory st = read("/path/to/IU_ULN_00_LH1_2015-07-18T02.mseed", "MSEED") tr = st[0] inv = read_inventory("/path/to/IU_ULN_00_LH1.xml", "STATIONXML") pre_filt = [0.001, 0.005, 45, 50] output = "DISP" tr.remove_response(inventory=inv, pre_filt=pre_filt, output=output, water_level=60, plot=True) :type inventory: :class:`~obspy.core.inventory.inventory.Inventory` or None. :param inventory: Station metadata to use in search for adequate response. If inventory parameter is not supplied, the response has to be attached to the trace with :meth:`Trace.attach_response` beforehand. :type output: str :param output: Output units. One of: ``"DISP"`` displacement, output unit is meters ``"VEL"`` velocity, output unit is meters/second ``"ACC"`` acceleration, output unit is meters/second**2 :type water_level: float :param water_level: Water level for deconvolution. :type pre_filt: list or tuple of four float :param pre_filt: Apply a bandpass filter in frequency domain to the data before deconvolution. The list or tuple defines the four corner frequencies `(f1, f2, f3, f4)` of a cosine taper which is one between `f2` and `f3` and tapers to zero for `f1 < f < f2` and `f3 < f < f4`. :type zero_mean: bool :param zero_mean: If `True`, the mean of the waveform data is subtracted in time domain prior to deconvolution. :type taper: bool :param taper: If `True`, a cosine taper is applied to the waveform data in time domain prior to deconvolution. :type taper_fraction: float :param taper_fraction: Taper fraction of cosine taper to use. :type plot: bool or str :param plot: If `True`, brings up a plot that illustrates how the data are processed in the frequency domain in three steps. First by `pre_filt` frequency domain tapering, then by inverting the instrument response spectrum with or without `water_level` and finally showing data with inverted instrument response multiplied on it in frequency domain. It also shows the comparison of raw/corrected data in time domain. If a `str` is provided then the plot is saved to file (filename must have a valid image suffix recognizable by matplotlib e.g. '.png'). """ # limit_numpy_fft_cache() from obspy.core.inventory import PolynomialResponseStage from obspy.signal.invsim import (cosine_taper, cosine_sac_taper, invert_spectrum) if plot: import matplotlib.pyplot as plt if (isinstance(inventory, (str, native_str)) and inventory.upper() in ("DISP", "VEL", "ACC")): from obspy.core.util.deprecation_helpers import ObsPyDeprecationWarning output = inventory inventory = None msg = ("The order of optional parameters in method " "remove_response has changed. 'output' is not accepted " "as first positional argument in the next release.") warnings.warn(msg, category=ObsPyDeprecationWarning, stacklevel=3) response = self._get_response(inventory) # polynomial response using blockette 62 stage 0 if not response.response_stages and response.instrument_polynomial: coefficients = response.instrument_polynomial.coefficients self.data = np.poly1d(coefficients[::-1])(self.data) return self # polynomial response using blockette 62 stage 1 and no other stages if len(response.response_stages) == 1 and isinstance(response.response_stages[0], PolynomialResponseStage): # check for gain if response.response_stages[0].stage_gain is None: msg = 'Stage gain not defined for %s - setting it to 1.0' warnings.warn(msg % self.id) gain = 1 else: gain = response.response_stages[0].stage_gain coefficients = response.response_stages[0].coefficients[:] for i in range(len(coefficients)): coefficients[i] /= math.pow(gain, i) self.data = np.poly1d(coefficients[::-1])(self.data) return self # use evalresp data = self.data.astype(np.float64) npts = len(data) # time domain pre-processing if zero_mean: data -= data.mean() if taper: data *= cosine_taper(npts, taper_fraction, sactaper=True, halfcosine=False) if plot: fontsz = 12 color1 = "blue" color2 = "red" bbox = dict(boxstyle="round", fc="w", alpha=1, ec="w") bbox1 = dict(boxstyle="round", fc="blue", alpha=0.15) bbox2 = dict(boxstyle="round", fc="red", alpha=0.15) if fig is None: fig = plt.figure(figsize=(14, 10)) fig.suptitle(str(self), fontsize=fontsz) ax1 = fig.add_subplot(321) ax1b = ax1.twinx() ax2 = fig.add_subplot(323, sharex=ax1) ax2b = ax2.twinx() ax3 = fig.add_subplot(325, sharex=ax1) ax3b = ax3.twinx() ax4 = fig.add_subplot(322) ax5 = fig.add_subplot(324, sharex=ax4) ax6 = fig.add_subplot(326, sharex=ax4) for ax_ in (ax1, ax2, ax3, ax4, ax5, ax6): ax_.grid(zorder=-10) if pre_filt is None: text = 'pre_filt: None' else: text = 'pre_filt: [{:.3g}, {:.3g}, {:.3g}, {:.3g}]'.format( *pre_filt) ax1.text(0.05, 0.1, text, ha="left", va="bottom", transform=ax1.transAxes, fontsize=fontsz, bbox=bbox, zorder=5) ax1.set_ylabel("Data spectrum, raw", bbox=bbox1, fontsize=fontsz) ax1b.set_ylabel("'pre_filt' taper fraction", bbox=bbox2, fontsize=fontsz) evalresp_info = "\n".join( ['output: %s' % output] + ['%s: %s' % (key, value) for key, value in kwargs.items()]) ax2.text(0.05, 0.1, evalresp_info, ha="left", va="bottom", transform=ax2.transAxes, zorder=5, bbox=bbox, fontsize=fontsz) ax2.set_ylabel("Data spectrum,\n" "'pre_filt' applied", bbox=bbox1, fontsize=fontsz) ax2b.set_ylabel("Instrument response", bbox=bbox2, fontsize=fontsz) ax3.text(0.05, 0.1, 'water_level: %s' % water_level, ha="left", va="bottom", transform=ax3.transAxes, fontsize=fontsz, zorder=5, bbox=bbox) ax3.set_ylabel("Data spectrum,\nmultiplied with inverted\n" "instrument response", bbox=bbox1, fontsize=fontsz) ax3b.set_ylabel("Inverted instrument response,\n" "water level applied", bbox=bbox2, fontsize=fontsz) ax3.set_xlabel("Frequency [Hz]", fontsize=fontsz) times = self.times() ax4.plot(times, self.data, color="k") ax4.set_ylabel("Raw", fontsize=fontsz) ax4.yaxis.set_ticks_position("right") ax4.yaxis.set_label_position("right") ax5.plot(times, data, color="k") ax5.set_ylabel("Raw, after time\ndomain pre-processing", fontsize=fontsz) ax5.yaxis.set_ticks_position("right") ax5.yaxis.set_label_position("right") ax6.set_ylabel("Response removed", fontsize=fontsz) ax6.set_xlabel("Time [s]", fontsize=fontsz) ax6.yaxis.set_ticks_position("right") ax6.yaxis.set_label_position("right") ax1.tick_params(labelsize=fontsz) ax1b.tick_params(labelsize=fontsz) ax2.tick_params(labelsize=fontsz) ax2b.tick_params(labelsize=fontsz) ax3.tick_params(labelsize=fontsz) ax3b.tick_params(labelsize=fontsz) ax4.tick_params(labelsize=fontsz) ax5.tick_params(labelsize=fontsz) ax6.tick_params(labelsize=fontsz) # smart calculation of nfft dodging large primes from obspy.signal.util import _npts2nfft nfft = _npts2nfft(npts) # Transform data to Frequency domain data = np.fft.rfft(data, n=nfft) # calculate and apply frequency response, # optionally prefilter in frequency domain and/or apply water level freq_response, freqs = response.get_evalresp_response(self.stats.delta, nfft, output=output, **kwargs) if plot: ax1.loglog(freqs, np.abs(data), color=color1, zorder=9, label= "Data") ax1.legend(loc = "upper left") # frequency domain pre-filtering of data spectrum # (apply cosine taper in frequency domain) if pre_filt: freq_domain_taper = cosine_sac_taper(freqs, flimit=pre_filt) data *= freq_domain_taper if plot: try: freq_domain_taper except NameError: freq_domain_taper = np.ones(len(freqs)) ax1b.semilogx(freqs, freq_domain_taper, color=color2, zorder=10) ax1b.set_ylim(-0.05, 1.05) ax2.loglog(freqs, np.abs(data), color=color1, zorder=9, label = "Data") ax2b.loglog(freqs, np.abs(freq_response), color=color2, zorder=10, label = "Filter") ax2b.legend(loc = "upper left") if water_level is None: # No water level used, so just directly invert the response. # First entry is at zero frequency and value is zero, too. # Just do not invert the first value (and set to 0 to make sure). freq_response[0] = 0.0 freq_response[1:] = 1.0 / freq_response[1:] else: # Invert spectrum with specified water level. invert_spectrum(freq_response, water_level) data *= freq_response data[-1] = abs(data[-1]) + 0.0j if plot: ax3.loglog(freqs, np.abs(data), color=color1, zorder=9, label = "Data") ax3b.loglog(freqs, np.abs(freq_response), color=color2, zorder=10, label = "Filter") # transform data back into the time domain data = np.fft.irfft(data)[0:npts] if plot: # Oftentimes raises NumPy warnings which we don't want to see. with np.errstate(all="ignore"): ax6.plot(times, data, color="k") plt.subplots_adjust(wspace=0.4) if plot is True and fig is None: plt.show() elif plot is True and fig is not None: pass else: plt.savefig(plot) plt.close(fig) # assign processed data and store processing information self.data = data return self, np.abs(freq_response)
def process_synt(datadir, station, event = None, stationxml_dir = None, period_band = None, npts=None, sampling_rate=None, output_dir=None, suffix=None): # ensemble the stream #station_list = generate_station_list(datadir) #for station in station_list: zdatafile = station[0] + "." + station[1] + ".MXZ.sem.sac" ndatafile = station[0] + "." + station[1] + ".MXN.sem.sac" edatafile = station[0] + "." + station[1] + ".MXE.sem.sac" zpath = os.path.join(datadir, zdatafile) npath = os.path.join(datadir, ndatafile) epath = os.path.join(datadir, edatafile) st = read(zpath) st2 = read(npath) st3 = read(epath) #print st #print st2 st.append(st2[0]) st.append(st3[0]) #print "\nProcessing file: %s" %filename # interpolation value #npts = 3630 #sampling_rate = 1.0 # Hz min_period = period_band[0] max_period = period_band[1] f2 = 1.0 / max_period f3 = 1.0 / min_period f1 = 0.8 * f2 f4 = 1.2 * f3 pre_filt = (f1, f2, f3, f4) # fetch event information event_name = get_event_name(event) short_event_name = adjust_event_name(event_name) origin = event.preferred_origin() or event.origins[0] event_latitude = origin.latitude event_longitude = origin.longitude event_time = origin.time event_depth = origin.depth starttime = event_time print "event_time:",event_time #output_path = os.path.join(output_dir, short_event_name) if not os.path.exists(output_dir): os.makedirs(output_dir) nrecords = len(st) # processing for i, tr in enumerate(st): #get component name cmpname = tr.stats.channel #print tr.stats #tr.interpolate(sampling_rate=sampling_rate, starttime=starttime, # npts=npts) #tr.decimate(4, strict_length=False,no_filter=True) print "Processing %d of total %d" %(i+1, nrecords) print "Detrend, Demean and Taper..." tr.detrend("linear") tr.detrend("demean") tr.taper(max_percentage=0.05, type="hann") #print "response show:" #print tr.stats.response # Perform a frequency domain taper like during the response removal # just without an actual response... #for tr in st: print "Filtering..." data = tr.data.astype(np.float64) # smart calculation of nfft dodging large primes from obspy.signal.util import _npts2nfft nfft = _npts2nfft(len(data)) fy = 1.0 / (tr.stats.delta * 2.0) freqs = np.linspace(0, fy, nfft // 2 + 1) # Transform data to Frequency domain data = np.fft.rfft(data, n=nfft) data *= c_sac_taper(freqs, flimit=pre_filt) data[-1] = abs(data[-1]) + 0.0j # transform data back into the time domain data = np.fft.irfft(data)[0:len(data)] # assign processed data and store processing information tr.data = data print "Detrend, Demean and Taper again..." tr.detrend("linear") tr.detrend("demean") tr.taper(max_percentage=0.05, type="hann") print "Interpolate..." try: tr.interpolate(sampling_rate=sampling_rate, starttime=starttime, npts=npts) except: print "Error" return # rotate station_latitude = st[0].stats.sac['stla'] station_longitude = st[0].stats.sac['stlo'] event_latitude = st[0].stats.sac['evla'] event_longitude = st[0].stats.sac['evlo'] #print station_latitude, station_longitude #print station_latitude, station_longitude _, baz, _ = gps2DistAzimuth(station_latitude, station_longitude, event_latitude, event_longitude) print st st.rotate(method="NE->RT", back_azimuth=baz) # write out print st for tr in st: comp = tr.stats.channel outfn = station[0] + "." + station[1] + "." + comp + ".sac" if suffix is not None and suffix != "": outfn = outfn + "." + suffix outpath = os.path.join(output_dir, outfn) print "file saved:", outpath tr.stats.sac['b'] = 0 tr.stats.sac['iztype'] = 9 tr.write(outpath, format="SAC")
#-----directory to station list and response files-------- #resp_dir = '/Users/chengxin/Documents/Harvard/Kanto_basin/instrument/resp_all' #locations = '/Users/chengxin/Documents/Harvard/Kanto_basin/code/KANTO/locations.txt' resp_dir = '/Users/chengxin/Documents/Harvard/Kanto_basin/code/KANTO/instrument/resp_4types' locations = '/Users/chengxin/Documents/Harvard/Kanto_basin/code/KANTO/instrument/resp_4types/station.lst' #-----common variables for extracting resp using evalresp function------ water_level = 60 prefilt = [0.04, 0.05, 2, 3] downsamp_freq = 20 dt = 1 / downsamp_freq cc_len = 3600 step = 1800 npts = cc_len * downsamp_freq * 24 Nfft = _npts2nfft(npts) tdate = obspy.UTCDateTime("2011-11-3T16:30:00.000") #-----read the station list------ locs = pd.read_csv(locations) nsta = len(locs) for ii in range(nsta): station = locs.iloc[ii]['station'] network = locs.iloc[ii]['network'] print('work on station ' + station) tfiles = glob.glob(os.path.join(resp_dir, 'RESP.' + station + '*')) if len(tfiles) == 0: print('cannot find resp files for station ' + station)
def _remove_response_trace(trace, inventory=None, output="VEL", pre_filt=None, zero_mean=True, taper=True, taper_fraction=0.05, **kwargs): response = trace._get_response(inventory) # polynomial response using blockette 62 stage 0 if not response.response_stages and response.instrument_polynomial: coefficients = response.instrument_polynomial.coefficients trace.data = np.poly1d(coefficients[::-1])(trace.data) return trace # polynomial response using blockette 62 stage 1 and no other stages if len(response.response_stages) == 1 and isinstance( response.response_stages[0], PolynomialResponseStage): # check for gain if response.response_stages[0].stage_gain is None: msg = 'Stage gain not defined for %s - setting it to 1.0' warnings.warn(msg % trace.id) gain = 1 else: gain = response.response_stages[0].stage_gain coefficients = response.response_stages[0].coefficients[:] for i in range(len(coefficients)): coefficients[i] /= np.pow(gain, i) trace.data = np.poly1d(coefficients[::-1])(trace.data) return trace # use evalresp data = trace.data.astype(np.float64) npts = len(data) # time domain pre-processing if zero_mean: data -= data.mean() if taper: data *= cosine_taper(npts, taper_fraction, sactaper=True, halfcosine=False) nfft = _npts2nfft(npts) # Transform data to Frequency domain data = np.fft.rfft(data, n=nfft) # calculate and apply frequency response, # optionally prefilter in frequency domain and/or apply water level freq_response, freqs = response.get_evalresp_response(trace.stats.delta, nfft, output=output, **kwargs) if pre_filt: freq_domain_taper = cosine_sac_taper(freqs, flimit=pre_filt) data *= freq_domain_taper freq_response[0] = 0.0 freq_response[1:] = 1.0 / freq_response[1:] data *= freq_response data[-1] = abs(data[-1]) + 0.0j # transform data back into the time domain data = np.fft.irfft(data)[0:npts] # assign processed data and store processing information trace.data = data return trace
trE.data=simulate_seismometer(trE.data, 100, paz_remove=None, paz_simulate=None, remove_sensitivity=True, simulate_sensitivity=True, water_level=wt, taper=True, taper_fraction=tpf, pre_filt=pre_filt, seedresp=seedrespN, nfft_pow2=False) #trE.simulate(paz_remove=None, pre_filt=pre_filt, seedresp=seedrespE) # trN.plot(outfile='espectros/Swave_%s_%s.png' % (units,trN.stats.station)) #trN.plot() #================================================================================================================== #========= #Calculando la transformada de fourier ============================================================== #================================================================================================================== #spectrum=mper(trN.data,200,np.size(trN.data)) n=np.size(trN.data) #dt=0.01 t=np.linspace(0,n-1,n)*dt df=1/(n*dt) freq=np.linspace(0,(n+1)/2,(n+1)/2)*df nfft = _npts2nfft(n) specN=np.fft.rfft(trN.data,n=nfft) specE=np.fft.rfft(trE.data,n=nfft) Hspec=np.sqrt((specN**2+specE**2)/2) smooth_Hspec=smooth(Hspec,smth) #Graficando log-espectro # plt.plot(np.log10(freq),np.log10(abs(smooth_Hspec)),'k') # plt.title('Espectro de desplazamiento onda S '+trN.stats.station) # plt.xlim(0,2) # plt.ylabel('log(A)') # plt.xlabel('log(frecuencia [Hz])') # plt.savefig("espectros/espectroH_SMOOTH10_%s.png" % (trN.stats.station)) #plt.show()
''' hfile = '/Users/chengxin/Documents/Harvard/Kanto_basin/code/KANTO/CCF_C3/2010_01_11.h5' with pyasdf.ASDFDataSet(hfile, mode='r') as ds: data_types = ds.auxiliary_data.list() #-----take the first data_type----- data_type = data_types[2] paths = ds.auxiliary_data[data_type].list() path = paths[2] data = ds.auxiliary_data[data_type][path].data[:] npts = len(data) #----do fft---- nfft2 = _npts2nfft(npts) nfft1 = int(next_fast_len(npts)) nfft3 = int(next_fast_len(npts * 2 + 1)) print('nfft1 and nfft2 %d %d' % (nfft1, nfft2)) t0 = time.time() spec1 = scipy.fftpack.fft(data, nfft1) wave1 = scipy.fftpack.ifft(spec1, nfft1) t1 = time.time() spec2 = np.fft.rfft(data, nfft2) wave2 = np.fft.irfft(spec2, nfft2) t2 = time.time() spec3 = scipy.fftpack.fft(data, nfft3) wave3 = scipy.fftpack.ifft(spec3, nfft3) t3 = time.time() print('fft and rfft takes %f s, %f s and %f s' %
def simulate_seismometer( data, samp_rate, paz_remove=None, paz_simulate=None, remove_sensitivity=True, simulate_sensitivity=True, water_level=600.0, zero_mean=True, taper=True, taper_fraction=0.05, pre_filt=None, seedresp=None, nfft_pow2=False, pitsasim=True, sacsim=False, shsim=False): """ Simulate/Correct seismometer. :type data: NumPy :class:`~numpy.ndarray` :param data: Seismogram, detrend before hand (e.g. zero mean) :type samp_rate: float :param samp_rate: Sample Rate of Seismogram :type paz_remove: dict, None :param paz_remove: Dictionary containing keys 'poles', 'zeros', 'gain' (A0 normalization factor). poles and zeros must be a list of complex floating point numbers, gain must be of type float. Poles and Zeros are assumed to correct to m/s, SEED convention. Use None for no inverse filtering. :type paz_simulate: dict, None :param paz_simulate: Dictionary containing keys 'poles', 'zeros', 'gain'. Poles and zeros must be a list of complex floating point numbers, gain must be of type float. Or None for no simulation. :type remove_sensitivity: bool :param remove_sensitivity: Determines if data is divided by `paz_remove['sensitivity']` to correct for overall sensitivity of recording instrument (seismometer/digitizer) during instrument correction. :type simulate_sensitivity: bool :param simulate_sensitivity: Determines if data is multiplied with `paz_simulate['sensitivity']` to simulate overall sensitivity of new instrument (seismometer/digitizer) during instrument simulation. :type water_level: float :param water_level: Water_Level for spectrum to simulate :type zero_mean: bool :param zero_mean: If true the mean of the data is subtracted :type taper: bool :param taper: If true a cosine taper is applied. :type taper_fraction: float :param taper_fraction: Taper fraction of cosine taper to use :type pre_filt: list or tuple of floats :param pre_filt: Apply a bandpass filter to the data trace before deconvolution. The list or tuple defines the four corner frequencies (f1,f2,f3,f4) of a cosine taper which is one between f2 and f3 and tapers to zero for f1 < f < f2 and f3 < f < f4. :type seedresp: dict, None :param seedresp: Dictionary contains keys 'filename', 'date', 'units'. 'filename' is the path to a RESP-file generated from a dataless SEED volume (or a file like object with RESP information); 'date' is a :class:`~obspy.core.utcdatetime.UTCDateTime` object for the date that the response function should be extracted for (can be omitted when calling simulate() on Trace/Stream. the Trace's starttime will then be used); 'units' defines the units of the response function. Can be either 'DIS', 'VEL' or 'ACC'. :type nfft_pow2: bool :param nfft_pow2: Number of frequency points to use for FFT. If True, the exact power of two is taken (default in PITSA). If False the data are not zero-padded to the next power of two which makes a slower FFT but is then much faster for e.g. evalresp which scales with the FFT points. :type pitsasim: bool :param pitsasim: Choose parameters to match instrument correction as done by PITSA. :type sacsim: bool :param sacsim: Choose parameters to match instrument correction as done by SAC. :type shsim: bool :param shsim: Choose parameters to match instrument correction as done by Seismic Handler. :return: The corrected data are returned as :class:`numpy.ndarray` float64 array. float64 is chosen to avoid numerical instabilities. This function works in the frequency domain, where nfft is the next power of len(data) to avoid wrap around effects during convolution. The inverse of the frequency response of the seismometer (``paz_remove``) is convolved with the spectrum of the data and with the frequency response of the seismometer to simulate (``paz_simulate``). A 5% cosine taper is taken before simulation. The data must be detrended (e.g.) zero mean beforehand. If paz_simulate=None only the instrument correction is done. In the latter case, a broadband filter can be applied to the data trace using pre_filt. This restricts the signal to the valid frequency band and thereby avoids artifacts due to amplification of frequencies outside of the instrument's passband (for a detailed discussion see *Of Poles and Zeros*, F. Scherbaum, Kluwer Academic Publishers). .. versionchanged:: 0.5.1 The default for `remove_sensitivity` and `simulate_sensitivity` has been changed to ``True``. Old deprecated keyword arguments `paz`, `inst_sim`, `no_inverse_filtering` have been removed. """ # Checking the types if not paz_remove and not paz_simulate and not seedresp: msg = "Neither inverse nor forward instrument simulation specified." raise TypeError(msg) for d in [paz_remove, paz_simulate]: if d is None: continue for key in ['poles', 'zeros', 'gain']: if key not in d: raise KeyError("Missing key: %s" % key) # Translated from PITSA: spr_resg.c delta = 1.0 / samp_rate # ndat = len(data) data = data.astype(np.float64) if zero_mean: data -= data.mean() if taper: if sacsim: data *= cosine_taper(ndat, taper_fraction, sactaper=sacsim, halfcosine=False) else: data *= cosine_taper(ndat, taper_fraction) # The number of points for the FFT has to be at least 2 * ndat (in # order to prohibit wrap around effects during convolution) cf. # Numerical Recipes p. 429 calculate next power of 2. if nfft_pow2: nfft = util.next_pow_2(2 * ndat) # evalresp scales directly with nfft, therefore taking the next power of # two has a greater negative performance impact than the slow down of a # not power of two in the FFT else: nfft = _npts2nfft(ndat) # Transform data in Fourier domain data = np.fft.rfft(data, n=nfft) # Inverse filtering = Instrument correction if paz_remove: freq_response, freqs = paz_to_freq_resp( paz_remove['poles'], paz_remove['zeros'], paz_remove['gain'], delta, nfft, freq=True) if seedresp: freq_response, freqs = evalresp(delta, nfft, seedresp['filename'], seedresp['date'], units=seedresp['units'], freq=True, network=seedresp['network'], station=seedresp['station'], locid=seedresp['location'], channel=seedresp['channel']) if not remove_sensitivity: msg = "remove_sensitivity is set to False, but since seedresp " + \ "is selected the overall sensitivity will be corrected " + \ " for anyway!" warnings.warn(msg) if paz_remove or seedresp: if pre_filt: # make cosine taper fl1, fl2, fl3, fl4 = pre_filt if sacsim: cos_win = cosine_sac_taper(freqs, flimit=(fl1, fl2, fl3, fl4)) else: cos_win = cosine_taper(freqs.size, freqs=freqs, flimit=(fl1, fl2, fl3, fl4)) data *= cos_win invert_spectrum(freq_response, water_level) data *= freq_response del freq_response # Forward filtering = Instrument simulation if paz_simulate: data *= paz_to_freq_resp(paz_simulate['poles'], paz_simulate['zeros'], paz_simulate['gain'], delta, nfft) data[-1] = abs(data[-1]) + 0.0j # transform data back into the time domain data = np.fft.irfft(data)[0:ndat] if pitsasim: # linear detrend data = simple_detrend(data) if shsim: # detrend using least squares data = scipy.signal.detrend(data, type="linear") # correct for involved overall sensitivities if paz_remove and remove_sensitivity and not seedresp: data /= paz_remove['sensitivity'] if paz_simulate and simulate_sensitivity: data *= paz_simulate['sensitivity'] return data
def remove_response(trace, inventory=None, output="VEL", water_level=60, pre_filt=None, zero_mean=True, taper=True, taper_fraction=0.05, plot=False, fig=None, return_spectra=False, **kwargs): """ Deconvolve instrument response. Based on a method on trace. It adds units, which are obviously dependent on the problem. axis ax5b is modified to show the pre-filtered trace instead of the time domain pre filter. Uses the adequate :class:`obspy.core.inventory.response.Response` from the provided :class:`obspy.core.inventory.inventory.Inventory` data. Raises an exception if the response is not present. Note that there are two ways to prevent overamplification while convolving the inverted instrument spectrum: One possibility is to specify a water level which represents a clipping of the inverse spectrum and limits amplification to a certain maximum cut-off value (`water_level` in dB). The other possibility is to taper the waveform data in the frequency domain prior to multiplying with the inverse spectrum, i.e. perform a pre-filtering in the frequency domain (specifying the four corner frequencies of the frequency taper as a tuple in `pre_filt`). .. note:: Any additional kwargs will be passed on to :meth:`obspy.core.inventory.response.Response.get_evalresp_response`, see documentation of that method for further customization (e.g. start/stop stage). .. note:: Using :meth:`~Trace.remove_response` is equivalent to using :meth:`~Trace.simulate` with the identical response provided as a (dataless) SEED or RESP file and when using the same `water_level` and `pre_filt` (and options `sacsim=True` and `pitsasim=False` which influence very minor details in detrending and tapering). .. rubric:: Example >>> from obspy import read, read_inventory >>> st = read() >>> tr = st[0].copy() >>> inv = read_inventory() >>> tr.remove_response(inventory=inv) # doctest: +ELLIPSIS <...Trace object at 0x...> >>> tr.plot() # doctest: +SKIP .. plot:: from obspy import read, read_inventory st = read() tr = st[0] inv = read_inventory() tr.remove_response(inventory=inv) tr.plot() Using the `plot` option it is possible to visualize the individual steps during response removal in the frequency domain to check the chosen `pre_filt` and `water_level` options to stabilize the deconvolution of the inverted instrument response spectrum: >>> from obspy import read, read_inventory >>> st = read("/path/to/IU_ULN_00_LH1_2015-07-18T02.mseed") >>> tr = st[0] >>> inv = read_inventory("/path/to/IU_ULN_00_LH1.xml") >>> pre_filt = [0.001, 0.005, 45, 50] >>> tr.remove_response(inventory=inv, pre_filt=pre_filt, output="DISP", ... water_level=60, plot=True) # doctest: +SKIP <...Trace object at 0x...> .. plot:: from obspy import read, read_inventory st = read("/path/to/IU_ULN_00_LH1_2015-07-18T02.mseed", "MSEED") tr = st[0] inv = read_inventory("/path/to/IU_ULN_00_LH1.xml", "STATIONXML") pre_filt = [0.001, 0.005, 45, 50] output = "DISP" tr.remove_response(inventory=inv, pre_filt=pre_filt, output=output, water_level=60, plot=True) :type inventory: :class:`~obspy.core.inventory.inventory.Inventory` or None. :param inventory: Station metadata to use in search for adequate response. If inventory parameter is not supplied, the response has to be attached to the trace with :meth:`Trace.attach_response` beforehand. :type output: str :param output: Output units. One of: ``"DISP"`` displacement, output unit is meters ``"VEL"`` velocity, output unit is meters/second ``"ACC"`` acceleration, output unit is meters/second**2 :type water_level: float :param water_level: Water level for deconvolution. :type pre_filt: list or tuple of four float :param pre_filt: Apply a bandpass filter in frequency domain to the data before deconvolution. The list or tuple defines the four corner frequencies `(f1, f2, f3, f4)` of a cosine taper which is one between `f2` and `f3` and tapers to zero for `f1 < f < f2` and `f3 < f < f4`. :type zero_mean: bool :param zero_mean: If `True`, the mean of the waveform data is subtracted in time domain prior to deconvolution. :type taper: bool :param taper: If `True`, a cosine taper is applied to the waveform data in time domain prior to deconvolution. :type taper_fraction: float :param taper_fraction: Taper fraction of cosine taper to use. :type plot: bool or str :param plot: If `True`, brings up a plot that illustrates how the data are processed in the frequency domain in three steps. First by `pre_filt` frequency domain tapering, then by inverting the instrument response spectrum with or without `water_level` and finally showing data with inverted instrument response multiplied on it in frequency domain. It also shows the comparison of raw/corrected data in time domain. If a `str` is provided then the plot is saved to file (filename must have a valid image suffix recognizable by matplotlib e.g. '.png'). """ limit_numpy_fft_cache() from obspy.core.inventory import PolynomialResponseStage from obspy.signal.invsim import (cosine_taper, cosine_sac_taper, invert_spectrum) if plot: import matplotlib.pyplot as plt if (isinstance(inventory, (str, native_str)) and inventory.upper() in ("DISP", "VEL", "ACC")): from obspy.core.util.deprecation_helpers import \ ObsPyDeprecationWarning output = inventory inventory = None msg = ("The order of optional parameters in method " "remove_response has changed. 'output' is not accepted " "as first positional argument in the next release.") warnings.warn(msg, category=ObsPyDeprecationWarning, stacklevel=3) response = trace._get_response(inventory) # polynomial response using blockette 62 stage 0 if not response.response_stages and response.instrument_polynomial: coefficients = response.instrument_polynomial.coefficients trace.data = np.poly1d(coefficients[::-1])(trace.data) return trace # polynomial response using blockette 62 stage 1 and no other stages if len(response.response_stages) == 1 and \ isinstance(response.response_stages[0], PolynomialResponseStage): # check for gain if response.response_stages[0].stage_gain is None: msg = 'Stage gain not defined for %s - setting it to 1.0' warnings.warn(msg % trace.id) gain = 1 else: gain = response.response_stages[0].stage_gain coefficients = response.response_stages[0].coefficients[:] for i in range(len(coefficients)): coefficients[i] /= math.pow(gain, i) trace.data = np.poly1d(coefficients[::-1])(trace.data) return trace # use evalresp data = trace.data.astype(np.float64) npts = len(data) # time domain pre-processing if zero_mean: data -= data.mean() if taper: data *= cosine_taper(npts, taper_fraction, sactaper=True, halfcosine=False) if plot: color1 = "blue" color2 = "red" bbox = dict(boxstyle="round", fc="w", alpha=1, ec="w") bbox1 = dict(boxstyle="round", fc="blue", alpha=0.15) bbox2 = dict(boxstyle="round", fc="red", alpha=0.15) if fig is None: fig = plt.figure(figsize=(14, 10)) fig.suptitle("{}:\nRemoving the Instrument Response".format( str(trace)), fontsize=16) ax1 = fig.add_subplot(321) ax1b = ax1.twinx() ax2 = fig.add_subplot(323, sharex=ax1) ax2b = ax2.twinx() ax3 = fig.add_subplot(325, sharex=ax1) ax3b = ax3.twinx() ax4 = fig.add_subplot(322) ax5 = fig.add_subplot(324, sharex=ax4) ax6 = fig.add_subplot(326, sharex=ax4) for ax_ in (ax1, ax2, ax3, ax4, ax5, ax6): ax_.grid(zorder=-10) ax4.set_title("Waveform") # if pre_filt is not None: # # text = 'pre_filt: None' # # else: output_dict = { 'DISP': 'Displacement', 'VEL': 'Velocity', 'ACC': 'Acceleration' } # labels - specific to Apollo data unit_dict = { 'DISP': 'DU/m', 'VEL': 'DU/(m/s)', 'ACC': r'DU/(m/s$\mathrm{^2}$)' } unit_inverse_dict = { 'DISP': 'm/DU', 'VEL': '(m/s)/DU', 'ACC': r'(m/s$\mathrm{^2}$)/DU' } unit_final_dict = { 'DISP': 'm', 'VEL': 'm/s', 'ACC': r'm/s$\mathrm{^2}$' } raw_unit = 'DU' ax1.set_ylabel("Raw [{}]".format(raw_unit), bbox=bbox1, fontsize=16) ax1.yaxis.set_label_coords(-0.13, 0.5) if pre_filt is not None: text = 'Pre-filter parameters:\n [{:.3g}, {:.3g}, {:.3g}, {:.3g}]'.format( *pre_filt) ax1.text(0.05, 0.1, text, ha="left", va="bottom", transform=ax1.transAxes, fontsize="large", bbox=bbox, zorder=5) ax1b.set_ylabel("Pre-filter", bbox=bbox2, fontsize=16) ax1b.yaxis.set_label_coords(1.14, 0.5) ax1.set_title("Spectrum", color='b') output_dict = { 'DISP': 'Displacement', 'VEL': 'Velocity', 'ACC': 'Acceleration' } evalresp_info = "\n".join( ['Output: %s' % output_dict[output]] + ['%s: %s' % (key, value) for key, value in kwargs.items()]) ax2.text(0.05, 0.1, evalresp_info, ha="left", va="bottom", transform=ax2.transAxes, fontsize="large", zorder=5, bbox=bbox) ax2.set_ylabel("Pre-processed [{}]".format(raw_unit), bbox=bbox1, fontsize=16) ax2.yaxis.set_label_coords(-0.13, 0.5) ax2b.set_ylabel("Instrument\nresponse [{}]".format(unit_dict[output]), bbox=bbox2, fontsize=16) ax2b.yaxis.set_label_coords(1.14, 0.5) if water_level is not None: ax3.text(0.05, 0.1, "Water Level: %s" % water_level, ha="left", va="bottom", transform=ax3.transAxes, fontsize="large", zorder=5, bbox=bbox) ax3.set_ylabel("Multiplied with inverted\n" "instrument response [{}]".format( unit_final_dict[output]), bbox=bbox1, fontsize=16) ax3.yaxis.set_label_coords(-0.13, 0.5) if water_level is not None: ax3b.set_ylabel("Inverted instrument response,\n" "water level applied [{}]".format( unit_inverse_dict[output]), bbox=bbox2, fontsize=16) else: ax3b.set_ylabel("Inverted instrument\nresponse [{}]".format( unit_inverse_dict[output]), bbox=bbox2, fontsize=16) ax3b.yaxis.set_label_coords(1.14, 0.5) # xlbl = ax3b.yaxis.get_label() # print(xlbl.get_position()) # # # xlbl = ax3b.yaxis.get_label() # print(xlbl.get_position()) ax3.set_xlabel("Frequency [Hz]") times = trace.times() ax4.plot(times, trace.data, color="k") ax4.set_ylabel("Raw [{}]".format(raw_unit), fontsize=16) ax4.yaxis.set_ticks_position("right") ax4.yaxis.set_label_position("right") ax4.yaxis.set_label_coords(1.14, 0.5) # Ceri # ax5.plot(times, data, color="k") ax5.set_ylabel("Pre-processed [{}]".format(raw_unit), fontsize=16) ax5.yaxis.set_ticks_position("right") ax5.yaxis.set_label_position("right") ax5.yaxis.set_label_coords(1.14, 0.5) ax6.set_ylabel("Response removed [{}]".format(unit_final_dict[output]), fontsize=16) ax6.set_xlabel("Time [s]") ax6.yaxis.set_ticks_position("right") ax6.yaxis.set_label_position("right") ax6.yaxis.set_label_coords(1.14, 0.5) # smart calculation of nfft dodging large primes from obspy.signal.util import _npts2nfft nfft = _npts2nfft(npts) # Transform data to Frequency domain data = np.fft.rfft(data, n=nfft) # calculate and apply frequency response, # optionally prefilter in frequency domain and/or apply water level freq_response, freqs = \ response.get_evalresp_response(trace.stats.delta, nfft, output=output, **kwargs) if plot: ax1.loglog(freqs, np.abs(data), color=color1, zorder=9) # frequency domain pre-filtering of data spectrum # (apply cosine taper in frequency domain) if pre_filt: freq_domain_taper = cosine_sac_taper(freqs, flimit=pre_filt) data *= freq_domain_taper if plot: try: freq_domain_taper except NameError: freq_domain_taper = np.ones(len(freqs)) if pre_filt is not None: ax1b.semilogx(freqs, freq_domain_taper, color=color2, zorder=10) ax1b.set_ylim(-0.05, 1.05) ax2.loglog(freqs, np.abs(data), color=color1, zorder=9) ax2b.loglog(freqs, np.abs(freq_response), color=color2, zorder=10) # Ceri - transform data back into the time domain - just to view it filt_data = np.fft.irfft(data)[0:npts] ax5.plot(times, filt_data, color="k") if water_level is None: # No water level used, so just directly invert the response. # First entry is at zero frequency and value is zero, too. # Just do not invert the first value (and set to 0 to make sure). freq_response[0] = 0.0 freq_response[1:] = 1.0 / freq_response[1:] else: # Invert spectrum with specified water level. invert_spectrum(freq_response, water_level) data *= freq_response data[-1] = abs(data[-1]) + 0.0j spectra = np.abs(data) if plot: ax3.loglog(freqs, np.abs(data), color=color1, zorder=9) ax3b.loglog(freqs, np.abs(freq_response), color=color2, zorder=10) # transform data back into the time domain data = np.fft.irfft(data)[0:npts] if plot: # Oftentimes raises NumPy warnings which we don't want to see. with np.errstate(all="ignore"): ax6.plot(times, data, color="k") plt.subplots_adjust(wspace=0.4) if plot is True and fig is None: plt.show() elif plot is True and fig is not None: # Ceri - changed this so that the graph does actually show plt.show() else: plt.savefig(plot) plt.close(fig) # assign processed data and store processing information trace.data = data if return_spectra: return trace, freqs, spectra else: return trace
if source.stats.npts != downsamp_freq * 24 * cc_len: print( 'Moving to next: extraced response file does not match the sac length' ) continue #-----load the instrument response nyc file----- resp_file = os.path.join(resp_dir, 'resp.' + station + '.npy') respz = np.load(resp_file) if not os.path.isfile(resp_file): print("no instrument response for " + station) continue #----------do fft now---------- nfft = _npts2nfft(source.stats.npts) source_spect = np.fft.rfft(source.data, n=nfft) fy = 1 / (dt * 2.0) freq = np.linspace(0, fy, nfft // 2 + 1) #-----apply a cosine taper to target freq----- #cos_win = cosine_sac_taper(freq, flimit=pre_filt) #source_spect *=cos_win source_spect *= respz source.data = np.fft.irfft( source_spect)[0:source.stats.npts] source.data = bandpass(source.data, freqmin, freqmax, downsamp_freq,
def simulate_seismometer(data, samp_rate, paz_remove=None, paz_simulate=None, remove_sensitivity=True, simulate_sensitivity=True, water_level=600.0, zero_mean=True, taper=True, taper_fraction=0.05, pre_filt=None, seedresp=None, nfft_pow2=False, pitsasim=True, sacsim=False, shsim=False): """ Simulate/Correct seismometer. :type data: NumPy :class:`~numpy.ndarray` :param data: Seismogram, detrend before hand (e.g. zero mean) :type samp_rate: float :param samp_rate: Sample Rate of Seismogram :type paz_remove: dict, None :param paz_remove: Dictionary containing keys 'poles', 'zeros', 'gain' (A0 normalization factor). poles and zeros must be a list of complex floating point numbers, gain must be of type float. Poles and Zeros are assumed to correct to m/s, SEED convention. Use None for no inverse filtering. :type paz_simulate: dict, None :param paz_simulate: Dictionary containing keys 'poles', 'zeros', 'gain'. Poles and zeros must be a list of complex floating point numbers, gain must be of type float. Or None for no simulation. :type remove_sensitivity: bool :param remove_sensitivity: Determines if data is divided by `paz_remove['sensitivity']` to correct for overall sensitivity of recording instrument (seismometer/digitizer) during instrument correction. :type simulate_sensitivity: bool :param simulate_sensitivity: Determines if data is multiplied with `paz_simulate['sensitivity']` to simulate overall sensitivity of new instrument (seismometer/digitizer) during instrument simulation. :type water_level: float :param water_level: Water_Level for spectrum to simulate :type zero_mean: bool :param zero_mean: If true the mean of the data is subtracted :type taper: bool :param taper: If true a cosine taper is applied. :type taper_fraction: float :param taper_fraction: Taper fraction of cosine taper to use :type pre_filt: list or tuple of floats :param pre_filt: Apply a bandpass filter to the data trace before deconvolution. The list or tuple defines the four corner frequencies (f1,f2,f3,f4) of a cosine taper which is one between f2 and f3 and tapers to zero for f1 < f < f2 and f3 < f < f4. :type seedresp: dict, None :param seedresp: Dictionary contains keys 'filename', 'date', 'units'. 'filename' is the path to a RESP-file generated from a dataless SEED volume (or a file like object with RESP information); 'date' is a :class:`~obspy.core.utcdatetime.UTCDateTime` object for the date that the response function should be extracted for (can be omitted when calling simulate() on Trace/Stream. the Trace's starttime will then be used); 'units' defines the units of the response function. Can be either 'DIS', 'VEL' or 'ACC'. :type nfft_pow2: bool :param nfft_pow2: Number of frequency points to use for FFT. If True, the exact power of two is taken (default in PITSA). If False the data are not zero-padded to the next power of two which makes a slower FFT but is then much faster for e.g. evalresp which scales with the FFT points. :type pitsasim: bool :param pitsasim: Choose parameters to match instrument correction as done by PITSA. :type sacsim: bool :param sacsim: Choose parameters to match instrument correction as done by SAC. :type shsim: bool :param shsim: Choose parameters to match instrument correction as done by Seismic Handler. :return: The corrected data are returned as :class:`numpy.ndarray` float64 array. float64 is chosen to avoid numerical instabilities. This function works in the frequency domain, where nfft is the next power of len(data) to avoid wrap around effects during convolution. The inverse of the frequency response of the seismometer (``paz_remove``) is convolved with the spectrum of the data and with the frequency response of the seismometer to simulate (``paz_simulate``). A 5% cosine taper is taken before simulation. The data must be detrended (e.g.) zero mean beforehand. If paz_simulate=None only the instrument correction is done. In the latter case, a broadband filter can be applied to the data trace using pre_filt. This restricts the signal to the valid frequency band and thereby avoids artifacts due to amplification of frequencies outside of the instrument's passband (for a detailed discussion see *Of Poles and Zeros*, F. Scherbaum, Kluwer Academic Publishers). .. versionchanged:: 0.5.1 The default for `remove_sensitivity` and `simulate_sensitivity` has been changed to ``True``. Old deprecated keyword arguments `paz`, `inst_sim`, `no_inverse_filtering` have been removed. """ # Checking the types if not paz_remove and not paz_simulate and not seedresp: msg = "Neither inverse nor forward instrument simulation specified." raise TypeError(msg) for d in [paz_remove, paz_simulate]: if d is None: continue for key in ['poles', 'zeros', 'gain']: if key not in d: raise KeyError("Missing key: %s" % key) # Translated from PITSA: spr_resg.c delta = 1.0 / samp_rate # ndat = len(data) data = data.astype(np.float64) if zero_mean: data -= data.mean() if taper: if sacsim: data *= cosine_taper(ndat, taper_fraction, sactaper=sacsim, halfcosine=False) else: data *= cosine_taper(ndat, taper_fraction) # The number of points for the FFT has to be at least 2 * ndat (in # order to prohibit wrap around effects during convolution) cf. # Numerical Recipes p. 429 calculate next power of 2. if nfft_pow2: nfft = util.next_pow_2(2 * ndat) # evalresp scales directly with nfft, therefore taking the next power of # two has a greater negative performance impact than the slow down of a # not power of two in the FFT else: nfft = _npts2nfft(ndat) # Transform data in Fourier domain data = np.fft.rfft(data, n=nfft) # Inverse filtering = Instrument correction if paz_remove: freq_response, freqs = paz_to_freq_resp(paz_remove['poles'], paz_remove['zeros'], paz_remove['gain'], delta, nfft, freq=True) if seedresp: freq_response, freqs = evalresp(delta, nfft, seedresp['filename'], seedresp['date'], units=seedresp['units'], freq=True, network=seedresp['network'], station=seedresp['station'], locid=seedresp['location'], channel=seedresp['channel']) if not remove_sensitivity: msg = "remove_sensitivity is set to False, but since seedresp " + \ "is selected the overall sensitivity will be corrected " + \ " for anyway!" warnings.warn(msg) if paz_remove or seedresp: if pre_filt: # make cosine taper fl1, fl2, fl3, fl4 = pre_filt if sacsim: cos_win = cosine_sac_taper(freqs, flimit=(fl1, fl2, fl3, fl4)) else: cos_win = cosine_taper(freqs.size, freqs=freqs, flimit=(fl1, fl2, fl3, fl4)) data *= cos_win invert_spectrum(freq_response, water_level) data *= freq_response del freq_response # Forward filtering = Instrument simulation if paz_simulate: data *= paz_to_freq_resp(paz_simulate['poles'], paz_simulate['zeros'], paz_simulate['gain'], delta, nfft) data[-1] = abs(data[-1]) + 0.0j # transform data back into the time domain data = np.fft.irfft(data)[0:ndat] if pitsasim: # linear detrend data = simple_detrend(data) if shsim: # detrend using least squares data = scipy.signal.detrend(data, type="linear") # correct for involved overall sensitivities if paz_remove and remove_sensitivity and not seedresp: data /= paz_remove['sensitivity'] if paz_simulate and simulate_sensitivity: data *= paz_simulate['sensitivity'] return data
def process_synthetics(st, freqmax, freqmin): f2 = 0.9 * freqmin f3 = 1.1 * freqmax f1 = 0.5 * f2 f4 = 2.0 * f3 pre_filt = (f1, f2, f3, f4) # Detrend and taper. st.detrend("linear") st.detrend("demean") st.taper(max_percentage=0.05, type="hann") # Perform a frequency domain taper like during the response removal # just without an actual response... # See function remove_response in trace.py from obspy. for tr in st: # Assuming displacement seismograms tr.differentiate() data = tr.data.astype(np.float64) orig_len = len(data) # smart calculation of nfft dodging large primes # noinspection PyProtectedMember from obspy.signal.util import _npts2nfft nfft = _npts2nfft(len(data)) fy = 1.0 / (tr.stats.delta * 2.0) freqs = np.linspace(0, fy, nfft // 2 + 1) # Transform data to Frequency domain data = np.fft.rfft(data, n=nfft) # noinspection PyTypeChecker data *= cosine_sac_taper(freqs, flimit=pre_filt) data[-1] = abs(data[-1]) + 0.0j # transform data back into the time domain data = np.fft.irfft(data)[0:orig_len] # assign processed data and store processing information tr.data = data tr.detrend("linear") tr.detrend("demean") tr.taper(0.05, type="cosine") tr.filter("bandpass", freqmin=freqmin, freqmax=freqmax, corners=3, zerophase=True) tr.detrend("linear") tr.detrend("demean") tr.taper(0.05, type="cosine") tr.filter("bandpass", freqmin=freqmin, freqmax=freqmax, corners=3, zerophase=True) return st