def test_evalresp(self, plot=False): resp_fpath = common.test_data_file('test2.resp') freqs = num.logspace(num.log10(0.001), num.log10(10.), num=1000) transfer = evalresp.evalresp( sta_list='BSEG', cha_list='BHZ', net_code='GR', locid='', instant=util.str_to_time('2012-01-01 00:00:00'), freqs=freqs, units='DIS', file=resp_fpath, rtype='CS')[0][4] pz_fpath = common.test_data_file('test2.sacpz') zeros, poles, constant = pz.read_sac_zpk(pz_fpath) resp = trace.PoleZeroResponse(zeros, poles, constant) transfer2 = resp.evaluate(freqs) if plot: plot_tfs(freqs, [transfer, transfer2]) assert numeq(transfer, transfer2, 1e-4)
def test_dump_load(self): r = trace.FrequencyResponse() r = trace.PoleZeroResponse([0j, 0j], [1j, 2j, 1 + 3j, 1 - 3j], 1.0) r.regularize() r2 = guts.load_string(r.dump()) assert cnumeq(r.poles, r2.poles, 1e-6) assert cnumeq(r.zeros, r2.zeros, 1e-6) assert numeq(r.constant, r2.constant) r = trace.SampledResponse([0., 1., 5., 10.], [0., 1., 1., 0.]) r.regularize() r2 = guts.load_string(r.dump()) assert numeq(r.frequencies, r2.frequencies, 1e-6) assert cnumeq(r.values, r2.values, 1e-6) r = trace.IntegrationResponse(2, 5.0) r2 = guts.load_string(r.dump()) assert numeq(r.n, r2.n) assert numeq(r.gain, r2.gain, 1e-6) r = trace.DifferentiationResponse(2, 5.0) r2 = guts.load_string(r.dump()) assert numeq(r.n, r2.n) assert numeq(r.gain, r2.gain, 1e-6) r = trace.AnalogFilterResponse(a=[1.0, 2.0, 3.0], b=[2.0, 3.0]) r2 = guts.load_string(r.dump()) assert numeq(r.a, r2.a, 1e-6) assert numeq(r.b, r2.b, 1e-6)
def get_restitution(self, tr, allowed_methods): if 'polezero' in allowed_methods: try: zeros, poles, constant = self._get_polezero(tr) zeros.append(0.0j) # for displacement return trace.PoleZeroResponse( poles, zeros, 1./constant ) except FileNotFound: pass if 'sampled' in allowed_methods: try: freqs, values = self._get_sampledresponse(tr) return trace.SampledResponse( freqs, 1.0/values ) except FileNotFound: pass if 'integration' in allowed_methods: try: cha = self.get_channel(tr) if cha is None: raise eventdata.NoRestitution('No gain information available') if cha.gain == 0.0: raise eventdata.NoRestitution('Gain is zero') return trace.IntegrationResponse(1./cha.gain) except FileNotFound, e: raise eventdata.NoRestitution(e)
def get_pyrocko_response(self): if self.pz_transfer_function_type not in ('LAPLACE (RADIANS/SECOND)', 'LAPLACE (HERTZ)'): raise NoResponseInformation( 'cannot convert PoleZero response of type %s' % self.pz_transfer_function_type) factor = 1.0 cfactor = 1.0 if self.pz_transfer_function_type == 'LAPLACE (HERTZ)': factor = 2. * math.pi cfactor = (2. * math.pi)**(len(self.pole_list) - len(self.zero_list)) resp = trace.PoleZeroResponse( constant=self.normalization_factor * cfactor, zeros=[z.value() * factor for z in self.zero_list], poles=[p.value() * factor for p in self.pole_list]) computed_normalization_factor = self.normalization_factor / abs( resp.evaluate(num.array([self.normalization_frequency.value]))[0]) perc = abs(computed_normalization_factor / self.normalization_factor - 1.0) * 100 if perc > 2.0: logger.warn( 'computed and reported normalization factors differ by ' '%.1f%%: computed: %g, reported: %g' % (perc, computed_normalization_factor, self.normalization_factor)) return resp
def get_pyrocko_response(self, nslc, fake_input_units=None): responses = [] for stage in self.stage_list: responses.extend(stage.get_pyrocko_response(nslc)) if not self.stage_list and self.instrument_sensitivity: responses.append( trace.PoleZeroResponse( constant=self.instrument_sensitivity.value)) if fake_input_units is not None: if not self.instrument_sensitivity or \ self.instrument_sensitivity.input_units is None: raise NoResponseInformation('no input units given') input_units = self.instrument_sensitivity.input_units.name try: conresp = conversion[fake_input_units.upper(), input_units.upper()] except KeyError: raise NoResponseInformation( 'cannot convert between units: %s, %s' % (fake_input_units, input_units)) if conresp is not None: responses.append(conresp) return trace.MultiplyResponse(responses)
def get_pyrocko_response(self, nslc): responses = [] for pzs in self.poles_zeros_list: if pzs.pz_transfer_function_type != 'LAPLACE (RADIANS/SECOND)': logger.debug('unhandled response at stage %i' % self.number) continue pz = pzs.get_pyrocko_response() responses.append(pz) if len(self.poles_zeros_list) > 1: logger.warn( 'multiple poles and zeros records in single response stage ' '(%s.%s.%s.%s)' % nslc) if (self.coefficients_list or self.response_list or self.fir or self.polynomial): logger.debug('unhandled response at stage %i' % self.number) if self.stage_gain: responses.append( trace.PoleZeroResponse(constant=self.stage_gain.value)) return responses
def iload_fh(f): zeros, poles, constant, comments = pz.read_sac_zpk(file=f, get_comments=True) d = {} for line in comments: toks = line.split(':', 1) if len(toks) == 2: temp = toks[0].strip('* \t') for k in ('network', 'station', 'location', 'channel', 'start', 'end', 'latitude', 'longitude', 'depth', 'elevation', 'dip', 'azimuth', 'input unit', 'output unit'): if temp.lower().startswith(k): d[k] = toks[1].strip() response = trace.PoleZeroResponse(zeros, poles, constant) try: yield EnhancedSacPzResponse( codes=(d['network'], d['station'], d['location'], d['channel']), tmin=util.str_to_time(d['start'], format='%Y-%m-%dT%H:%M:%S'), tmax=dummy_aware_str_to_time(d['end']), lat=float(d['latitude']), lon=float(d['longitude']), elevation=float(d['elevation']), depth=float(d['depth']), dip=float(d['dip']), azimuth=float(d['azimuth']), input_unit=d['input unit'], output_unit=d['output unit'], response=response) except: raise EnhancedSacPzError('cannot get all required information')
def test_conversions(self): from pyrocko import model from pyrocko.fdsn import station, resp, enhanced_sacpz t = util.str_to_time('2014-01-01 00:00:00') codes = 'GE', 'EIL', '', 'BHZ' resp_fpath = common.test_data_file('test1.resp') stations = [ model.Station(*codes[:3], lat=29.669901, lon=34.951199, elevation=210.0, depth=0.0) ] sx_resp = resp.make_stationxml(stations, resp.iload_filename(resp_fpath)) pr_sx_resp = sx_resp.get_pyrocko_response(codes, time=t, fake_input_units='M/S') pr_evresp = trace.Evalresp(resp_fpath, nslc_id=codes, target='vel', time=t) sacpz_fpath = common.test_data_file('test1.sacpz') sx_sacpz = enhanced_sacpz.make_stationxml( enhanced_sacpz.iload_filename(sacpz_fpath)) pr_sx_sacpz = sx_sacpz.get_pyrocko_response(codes, time=t, fake_input_units='M/S') pr_sacpz = trace.PoleZeroResponse(*pz.read_sac_zpk(sacpz_fpath)) try: pr_sacpz.zeros.remove(0.0j) except ValueError: pr_sacpz.poles.append(0.0j) sxml_geofon_fpath = common.test_data_file('test1.stationxml') sx_geofon = station.load_xml(filename=sxml_geofon_fpath) pr_sx_geofon = sx_geofon.get_pyrocko_response(codes, time=t, fake_input_units='M/S') sxml_iris_fpath = common.test_data_file('test2.stationxml') sx_iris = station.load_xml(filename=sxml_iris_fpath) pr_sx_iris = sx_iris.get_pyrocko_response(codes, time=t, fake_input_units='M/S') freqs = num.logspace(num.log10(0.001), num.log10(1.0), num=1000) tf_ref = pr_evresp.evaluate(freqs) for pr in [ pr_sx_resp, pr_sx_sacpz, pr_sacpz, pr_sx_geofon, pr_sx_iris ]: tf = pr.evaluate(freqs) # plot_tfs(freqs, [tf_ref, tf]) assert cnumeqrel(tf_ref, tf, 0.01)
def evaluate(zeros, poles, constant, fmin=0.001, fmax=100., nf=100): logfmin = math.log(fmin) logfmax = math.log(fmax) logf = num.linspace(logfmin, logfmax, nf) f = num.exp(logf) trans = trace.PoleZeroResponse(zeros, poles, constant) return f, trans.evaluate(f)
def testValidateFrequencyResponses(self): ttrace = trace.Trace(ydata=num.random.random(1000)) inverse_eval = trace.InverseEvalresp(respfile='test.txt', trace=ttrace, target='vel') inverse_eval.validate() pzk_response = trace.PoleZeroResponse(zeros=[0 + 0j, 0 + 0j], poles=[1 + 0j, 2 + 0j], constant=10.) pzk_response.regularize()
def read_to_pyrocko_response(filename=None, file=None, string=None): ''' Read SAC pole-zero file into Pyrocko response object. :returns: Response as a :py:class:~pyrocko.trace.PoleZeroResponse` object. ''' from pyrocko import trace zeros, poles, constant = read_sac_zpk(filename=filename, file=file, string=string) return trace.PoleZeroResponse(zeros, poles, constant)
def get_pyrocko_response(self, nslc): if self.pz_transfer_function_type == 'DIGITAL (Z-TRANSFORM)': logger.warn( 'unhandled pole-zero response of type "DIGITAL (Z-TRANSFORM)" ' '(%s)' % '.'.join(nslc)) return [] if self.pz_transfer_function_type not in ('LAPLACE (RADIANS/SECOND)', 'LAPLACE (HERTZ)'): raise NoResponseInformation( 'cannot convert PoleZero response of type %s (%s)' % (self.pz_transfer_function_type, '.'.join(nslc))) factor = 1.0 cfactor = 1.0 if self.pz_transfer_function_type == 'LAPLACE (HERTZ)': factor = 2. * math.pi cfactor = (2. * math.pi)**(len(self.pole_list) - len(self.zero_list)) resp = trace.PoleZeroResponse( constant=self.normalization_factor * cfactor, zeros=[z.value() * factor for z in self.zero_list], poles=[p.value() * factor for p in self.pole_list]) if not self.normalization_frequency.value \ or not self.normalization_factor: logger.warn('cannot check pole-zero normalization factor (%s)' % '.'.join(nslc)) else: computed_normalization_factor = self.normalization_factor / abs( resp.evaluate(num.array([self.normalization_frequency.value ]))[0]) db = 20.0 * num.log10( computed_normalization_factor / self.normalization_factor) if abs(db) > 0.17: logger.warn( 'computed and reported normalization factors differ by ' '%g dB: computed: %g, reported: %g (%s)' % (db, computed_normalization_factor, self.normalization_factor, '.'.join(nslc))) return [resp]
def get_pyrocko_response(self, nslc, fake_input_units=None): responses = [] for stage in self.stage_list: responses.extend(stage.get_pyrocko_response(nslc)) if not self.stage_list and self.instrument_sensitivity: responses.append( trace.PoleZeroResponse( constant=self.instrument_sensitivity.value)) if self.instrument_sensitivity: trial = trace.MultiplyResponse(responses) sval = self.instrument_sensitivity.value sfreq = self.instrument_sensitivity.frequency try: check_resp( trial, sval, sfreq, 0.1, prelude='Instrument sensitivity value inconsistent with ' 'sensitivity computed from complete response\n' ' channel: %s' % '.'.join(nslc)) except InconsistentResponseInformation as e: logger.warn(str(e)) if fake_input_units is not None: if not self.instrument_sensitivity or \ self.instrument_sensitivity.input_units is None: raise NoResponseInformation('no input units given') input_units = self.instrument_sensitivity.input_units.name try: conresp = conversion[fake_input_units.upper(), input_units.upper()] except KeyError: raise NoResponseInformation( 'cannot convert between units: %s, %s' % (fake_input_units, input_units)) if conresp is not None: responses.append(conresp) return trace.MultiplyResponse(responses)
def get_pyrocko_response(self, nslc): responses = [] for pzs in self.poles_zeros_list: responses.extend(pzs.get_pyrocko_response(nslc)) if len(self.poles_zeros_list) > 1: logger.warn( 'multiple poles and zeros records in single response stage ' '(%s.%s.%s.%s)' % nslc) if (self.coefficients_list or self.response_list or self.fir or self.polynomial): logger.debug('unhandled response at stage %i' % self.number) if self.stage_gain: responses.append( trace.PoleZeroResponse(constant=self.stage_gain.value)) return responses
def get_pyrocko_response(self, nslc): responses = [] if len(self.poles_zeros_list) == 1: pz = self.poles_zeros_list[0].get_pyrocko_response() responses.append(pz) elif len(self.poles_zeros_list) > 1: logger.warn( 'multiple poles and zeros records in single response stage ' '(%s.%s.%s.%s)' % nslc) for poles_zeros in self.poles_zeros_list: logger.warn('%s' % poles_zeros) elif (self.coefficients_list or self.response_list or self.fir or self.polynomial): pass # print 'unhandled response at stage %i' % self.number if self.stage_gain: responses.append( trace.PoleZeroResponse(constant=self.stage_gain.value)) return responses
def load_response_information(filename, format, nslc_patterns=None, fake_input_units=None): from pyrocko import pz, trace from pyrocko.fdsn import resp as fresp resps = [] labels = [] if format == 'sacpz': if fake_input_units is not None: raise Exception( 'cannot guess true input units from plain SAC PZ files') zeros, poles, constant = pz.read_sac_zpk(filename) resp = trace.PoleZeroResponse(zeros=zeros, poles=poles, constant=constant) resps.append(resp) labels.append(filename) elif format == 'resp': for resp in list(fresp.iload_filename(filename)): if nslc_patterns is not None and not util.match_nslc( nslc_patterns, resp.codes): continue units = '' if resp.response.instrument_sensitivity: s = resp.response.instrument_sensitivity if s.input_units and s.output_units: units = ', %s -> %s' % (fake_input_units or s.input_units.name, s.output_units.name) resps.append( resp.response.get_pyrocko_response( resp.codes, fake_input_units=fake_input_units)) labels.append('%s (%s.%s.%s.%s, %s - %s%s)' % ((filename, ) + resp.codes + (tts(resp.start_date), tts(resp.end_date), units))) elif format == 'stationxml': from pyrocko.fdsn import station as fs sx = fs.load_xml(filename=filename) for network in sx.network_list: for station in network.station_list: for channel in station.channel_list: nslc = (network.code, station.code, channel.location_code, channel.code) if nslc_patterns is not None and not util.match_nslc( nslc_patterns, nslc): continue units = '' if channel.response.instrument_sensitivity: s = channel.response.instrument_sensitivity if s.input_units and s.output_units: units = ', %s -> %s' % (fake_input_units or s.input_units.name, s.output_units.name) resps.append( channel.response.get_pyrocko_response( nslc, fake_input_units=fake_input_units)) labels.append('%s (%s.%s.%s.%s, %s - %s%s)' % ((filename, ) + nslc + (tts(channel.start_date), tts(channel.end_date), units))) return resps, labels
def __init__(self, markers, stations=None): # Targets================================================ store_id = 'castor' if store_id=='local1': phase_ids_start = 'p|P|Pv20p|Pv35p' phase_ids_end = 's|S|Sv20s|Sv35s' if store_id=='very_local': phase_ids_start = 'p|P|Pv3p|Pv8p|Pv20p|Pv35p' phase_ids_end = 's|S|Sv3s|Sv8s|Sv20s|Sv35s' if store_id=='very_local_20Hz': phase_ids_start = 'begin_fallback|p|P|Pv1p|Pv3p|Pv8p|Pv20p|Pv35p' phase_ids_end = 's|S|Sv1s|Sv3s|Sv8s|Sv20s|Sv35s' if store_id=='very_local_20Hz': phase_ids_start = 'begin_fallback|p|P|Pv1p|Pv3p|Pv8p|Pv20p|Pv35p' phase_ids_end = 's|S|Sv1s|Sv3s|Sv8s|Sv20s|Sv35s' if store_id=='castor': # bug?! bei Pv1.5p gibt's bei nahen Entfernungen ein index ot of # bounds phase_ids_start = 'p|P|Pv12.5p|Pv2.5p|Pv18.5p|Pv20p|Pv35p' phase_ids_end= 's|S|Sv12.5s|Sv2.5s|Sv18.5s|Sv20s|Sv35s' # Event================================================== event = filter(lambda x: isinstance(x, gui_util.EventMarker), markers) assert len(event) == 1 event = event[0].get_event() event.magnitude = 4.3 event.moment_tensor = moment_tensor.MomentTensor( m=num.array([[0.0, 0.0, 1.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]])) # generate stations from olat, olon: if not stations: print 'Generating station distribution.' stations = du.station_distribution((event.lat,event.lon), [[10000., 4], [130000., 8]], rotate={3000.:45, 130000.:0}) targets = stations2targets(stations, store_id) derec_home = os.environ["DEREC_HOME"] store_dirs = [derec_home + '/fomostos'] engine = LocalEngine(store_superdirs=store_dirs) model = get_earthmodel_from_engine(engine, store_id) #TESTSOURCES=============================================== offset = 3*km zoffset= 1000. ref_source = event2source(event, 'DC', strike=37.3, dip=30, rake=-3) center_lat = ref_source.lat center_lon = ref_source.lon negative_lat_offset, negative_lon_offset = du.lat_lon_relative_shift( center_lat, center_lon, -offset, -offset) positive_lat_offset, positive_lon_offset = du.lat_lon_relative_shift( center_lat, center_lon, offset, offset) lats=num.linspace(negative_lat_offset, positive_lat_offset, 3) #lats = [ref_source.lat] lons=num.linspace(negative_lon_offset, positive_lon_offset, 3) #lons = [ref_source.lon] depths=num.linspace(ref_source.depth-zoffset, ref_source.depth+zoffset, 3) depths = [ref_source.depth] #strikes = num.linspace(ref_source.strike-90, ref_source.strike+90, 25) strikes = [ref_source.strike] #dips = num.linspace(ref_source.dip-45, ref_source.dip+45, 25) dips = [ref_source.dip] #rakes = num.linspace(ref_source.rake-180, ref_source.rake+180, 25) rakes = [ref_source.rake] print lats, '<- lats' print lons, '<- lons' print depths, '<- depths' print ref_source.lat, '<- event lat' print ref_source.lon, '<- event lon' print ref_source.depth, '<- event depth' print ref_source.strike, ref_source.dip, ref_source.rake, '<- event S D R' location_test_sources = [DCSource(lat=lat, lon=lon, depth=depth, time=event.time, strike=strike, dip=dip, rake=rake, magnitude=event.magnitude) for strike in strikes for dip in dips for rake in rakes for lat in lats for lon in lons for depth in depths] for s in location_test_sources: s.regularize() #========================================================== test_case = TestCase(location_test_sources, targets, engine, store_id, test_parameters={'lat':lats, 'lon':lons, 'depth':depths}) test_case.ref_source = ref_source test_case.request_data() print 'source location: ', test_case.ref_source reference_seismograms = make_reference_trace(test_case.ref_source, test_case.targets, engine) extended_ref_marker = du.chop_ranges(test_case.ref_source, test_case.targets, test_case.store, phase_ids_start, phase_ids_end) print('test data marker....') extended_test_marker = du.chop_ranges(test_case.sources, test_case.targets, test_case.store, phase_ids_start, phase_ids_end) test_case.test_markers = extended_test_marker test_case.ref_markers = extended_ref_marker print('chopping ref....') test_case.references = du.chop_using_markers( reference_seismograms.iter_results(), extended_ref_marker, t_shift_frac=0.1) print('chopping cand....') test_case.seismograms = du.chop_using_markers( test_case.response.iter_results(), extended_test_marker, t_shift_frac=0.1) norm = 2. #taper = trace.CosFader(xfade=4) # Seconds or samples? taper = trace.CosFader(xfrac=0.1) z, p, k = butter(4, (2.*num.pi*2. ,0.4*num.pi*2.) , 'bandpass', analog=True, output='zpk') z = num.array(z, dtype=complex) p = num.array(p, dtype=complex) k = num.complex(k) fresponse = trace.PoleZeroResponse(z,p,k) fresponse.regularize() setup = trace.MisfitSetup(norm=norm, taper=taper, domain='envelope', filter=fresponse) test_case.set_misfit_setup(setup) du.calculate_misfit(test_case) #test_case.yaml_dump() # Display results=================================================== #test_case.plot1d(order, event.lon) #test_case.contourf(xkey='lon', ykey='lat') test_case.check_plot({'lat':ref_source.lat, 'depth':ref_source.depth}) optics = OpticBase(test_case) #optics.plot_1d(fix_parameters={'lat':event.lat, 'lon':event.lon}) optics.gmt_map(stations=True, events=True)
from pyrocko import pz, io, trace # read poles and zeros from SAC format pole-zero file zeros, poles, constant = pz.read_sac_zpk('STS2-Generic.polezero.txt') # one more zero to convert from velocity->counts to displacement->counts zeros.append(0.0j) rest_sts2 = trace.PoleZeroResponse(zeros=zeros, poles=poles, constant=constant) traces = io.load('test.mseed') out_traces = list(traces) for tr in traces: displacement = tr.transfer( 1000., # rise and fall of time window taper in [s] (0.001, 0.002, 5., 10.), # frequency domain taper in [Hz] transfer_function=rest_sts2, invert=True) # to change to (counts->displacement) # change channel id, so we can distinguish the traces in a trace viewer. displacement.set_codes(channel='D' + tr.channel[-1]) out_traces.append(displacement) io.save(out_traces, 'displacement.mseed')
def test_conversions(self): from pyrocko import model from pyrocko.io import resp, enhanced_sacpz from pyrocko.io import stationxml t = util.str_to_time('2014-01-01 00:00:00') codes = 'GE', 'EIL', '', 'BHZ' resp_fpath = common.test_data_file('test1.resp') stations = [model.Station( *codes[:3], lat=29.669901, lon=34.951199, elevation=210.0, depth=0.0)] sx_resp = resp.make_stationxml( stations, resp.iload_filename(resp_fpath)) sx_resp.validate() assert sx_resp.network_list[0].station_list[0].channel_list[0] \ .dip is None stations[0].set_channels_by_name('BHE', 'BHN', 'BHZ') sx_resp2 = resp.make_stationxml( stations, resp.iload_filename(resp_fpath)) sx_resp2.validate() assert sx_resp2.network_list[0].station_list[0].channel_list[0] \ .dip.value == -90.0 pr_sx_resp = sx_resp.get_pyrocko_response( codes, time=t, fake_input_units='M/S') pr_evresp = trace.Evalresp( resp_fpath, nslc_id=codes, target='vel', time=t) sacpz_fpath = common.test_data_file('test1.sacpz') sx_sacpz = enhanced_sacpz.make_stationxml( enhanced_sacpz.iload_filename(sacpz_fpath)) pr_sx_sacpz = sx_sacpz.get_pyrocko_response( codes, time=t, fake_input_units='M/S') pr_sacpz = trace.PoleZeroResponse(*pz.read_sac_zpk(sacpz_fpath)) try: pr_sacpz.zeros.remove(0.0j) except ValueError: pr_sacpz.poles.append(0.0j) sx_sacpz_resp = \ sx_sacpz.network_list[0].station_list[0].channel_list[0].response sx_sacpz_resp2 = pz.read_to_stationxml_response( input_unit=sx_sacpz_resp.instrument_sensitivity.input_units.name, output_unit=sx_sacpz_resp.instrument_sensitivity.output_units.name, normalization_frequency=10., filename=sacpz_fpath) pr_sx_sacpz2 = sx_sacpz_resp2.get_pyrocko_response(codes) try: pr_sx_sacpz2.responses[0].zeros.remove(0.0j) except ValueError: pr_sx_sacpz2.responses[0].poles.append(0.0j) sxml_geofon_fpath = common.test_data_file('test1.stationxml') sx_geofon = stationxml.load_xml(filename=sxml_geofon_fpath) pr_sx_geofon = sx_geofon.get_pyrocko_response( codes, time=t, fake_input_units='M/S') sxml_iris_fpath = common.test_data_file('test2.stationxml') sx_iris = stationxml.load_xml(filename=sxml_iris_fpath) pr_sx_iris = sx_iris.get_pyrocko_response( codes, time=t, fake_input_units='M/S') freqs = num.logspace(num.log10(0.001), num.log10(1.0), num=1000) tf_ref = pr_evresp.evaluate(freqs) for pr in [pr_sx_resp, pr_sx_sacpz, pr_sacpz, pr_sx_geofon, pr_sx_iris, pr_sx_sacpz2]: tf = pr.evaluate(freqs) # plot_tfs(freqs, [tf_ref, tf]) assert cnumeqrel(tf_ref, tf, 0.01)
from __future__ import print_function from builtins import str import os import copy import numpy as num from collections import defaultdict from pyrocko.gui.snuffling import Snuffling, Param, PhaseMarker, Switch, Choice, \ EventMarker from pyrocko import guts, orthodrome, trace, pile, model from pyrocko.gui.util import to01 from pyrocko.plot import graph_colors from matplotlib import pyplot as plt km = 1000. wood_anderson_response = trace.PoleZeroResponse(zeros=[0., 0.], poles=[(-5.49779 - 5.60886j), (-5.49779 + 5.60886j)], constant=1.) vmin = 1500. vmax = 6000. ''' Local Magnitude Estimation -------------------------- Main Control High- and Lowpass filters are applied to the data before simulating the Wood-Anderson receiver. The suggested default values for the geometrical spreading, anelastic attenuation and static magnification are those recommended by IASPEI. For correct estimates these values have to be calibrated for the region
import numpy as num from pyrocko import gf, trace from pyrocko.guts import Object, Float, StringChoice, List, String from pyrocko.gui import marker guts_prefix = 'grond' response_wwssn_lp = trace.PoleZeroResponse(poles=[ -0.2513 + 0.3351J, -0.2513 - 0.3351J, -0.0628 + 0.0304J, -0.0628 - 0.0304J ], zeros=[0., 0., 0.], constant=383.6) response_wwssn_lp_2 = trace.PoleZeroResponse( poles=[-0.40180 + 0.08559J, -0.40180 - 0.08559J, -0.04841, -0.08816], zeros=[0., 0., 0.]) response_wa = trace.PoleZeroResponse( poles=[-5.49779 - 5.60886J, -5.49779 + 5.60886J], zeros=[0., 0.]) class NamedResponse(StringChoice): choices = ['wood-anderson', 'wwssn-lp'] map = {'wood-anderson': response_wa, 'wwssn-lp': response_wwssn_lp} class BruneResponse(trace.FrequencyResponse): duration = Float.T()
from pyrocko import pz, io, trace # read poles and zeros from SAC format pole-zero file zeros, poles, constant = pz.read_sac_zpk('STS2-Generic.polezero.txt') zeros.append(0.0j) # one more for displacement # create pole-zero response function object for restitution, so poles and zeros # from the response file are swapped here. rest_sts2 = trace.PoleZeroResponse(poles, zeros, 1./constant) traces = io.load('test.mseed') out_traces = [] for tr in traces: displacement = tr.transfer( 1000., # rise and fall of time domain taper in [s] (0.001, 0.002, 5., 10.), # frequency domain taper in [Hz] transfer_function=rest_sts2) # change channel id, so we can distinguish the traces in a trace viewer. displacement.set_codes(channel='D'+tr.channel[-1]) out_traces.append(displacement) io.save(out_traces, 'displacement.mseed')