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')
