def testMisfitBox(self):
ydata = num.zeros(9)
ydata[3:6] = 1.0
deltat = 0.5
tr = trace.Trace(ydata=ydata, deltat=0.5, tmin=0.0)
tshiftmin = -(tr.tmax - tr.tmin) * 2
tshiftmax = (tr.tmax - tr.tmin) * 2
tshifts = num.linspace(
tshiftmin, tshiftmax,
int(round((tshiftmax - tshiftmin) / deltat)) + 1)
candidates = []
for tshift in tshifts:
trc = tr.copy()
trc.shift(tshift)
candidates.append(trc)
trace.MisfitSetup(norm=2,
taper=trace.CosTaper(tr.tmin, tr.tmin, tr.tmax,
tr.tmax),
domain='time_domain')
def testMisfitOfSameTracesZero(self):
y = num.random.random(10000)
y -= max(y) * 0.5
t1 = trace.Trace(tmin=0, ydata=y, deltat=0.01)
t2 = trace.Trace(tmin=0, ydata=y, deltat=0.01)
# ttraces = [t2]
fresponse = trace.FrequencyResponse()
taper = trace.CosFader(xfade=2.)
norms = [1, 2]
domains = ['time_domain', 'frequency_domain', 'envelope', 'absolute']
setups = [
trace.MisfitSetup(norm=n,
taper=taper,
domain=domain,
filter=fresponse) for domain in domains
for n in norms
]
for setup in setups:
m, n, tr, tc = t1.misfit(candidate=t2, setup=setup, debug=True)
if isinstance(tr, trace.Trace):
self.assertEqual(tr.tmin, tc.tmin)
self.assertTrue(all(tr.get_ydata() == tc.get_ydata()))
else:
self.assertTrue(all(tc == tr))
self.assertEqual(m, 0., 'misfit\'s m of equal traces is != 0')
def testMisfitOfSameTracesDtDifferentShifted(self):
"""
Tests:
Different length
Different delta t
Shifted
L2-Norm
L1-Norm
time- and frequency-domain
"""
test_file = os.path.join(os.path.dirname(__file__),
'../examples/1989.072.evt.mseed')
p = pile.make_pile(test_file, show_progress=False)
rt = p.all()[0]
tt = rt.copy()
# make downsampled, chopped copies:
deltats = [0.5, 1.0, 2.0]
tt.chop(tmin=rt.tmin + 10, tmax=rt.tmax - 15)
tts = [tt.copy() for i in range(len(deltats))]
[t.downsample_to(deltats[i]) for i, t in enumerate(tts)]
# shift traces:
t_shifts = [1.0, 0.49999, 0.5]
for ts in t_shifts:
tts_shifted = [t.copy() for t in tts]
map(lambda x: x.shift(ts), tts_shifted)
tts.extend(tts_shifted)
a = rt.tmin
d = rt.tmax
b = a + (d - a) / 10
c = d - (d - a) / 10
taper = trace.CosTaper(a, b, c, d)
fresponse = trace.FrequencyResponse()
norms = [1, 2]
domains = ['time_domain', 'frequency_domain', 'envelope', 'absolute']
setups = [
trace.MisfitSetup(norm=n,
taper=taper,
domain=domain,
filter=fresponse) for domain in domains
for n in norms
]
for cand in tts:
for setup in setups:
m, n = rt.misfit(candidate=cand, setup=setup)
self.assertNotEqual(m, None, 'misfit\'s m is None')
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)
def optimization(*params, **args):
counter = params[1]
Config = params[2]
Wdf = params[3]
FilterMeta = params[4]
mint = params[5]
maxt = params[6]
TTTGridMap = params[7]
Folder = params[8]
Origin = params[9]
ntimes = params[10]
switch = params[11]
ev = params[12]
arrayfolder = params[13]
syn_in = params[14]
data = params[15]
evpath = params[16]
XDict = params[17]
RefDict = params[18]
workdepth = params[19]
filterindex = params[20]
Wdfs = params[21]
networks = Config['networks'].split(',')
params = num.asarray(params)
parameter = num.ndarray.tolist(params)
ASL_syn = []
C = config.Config (evpath)
Config = C.parseConfig ('config')
cfg = ConfigObj (dict=Config)
if cfg.pyrocko_download() == True:
Meta = C.readpyrockostations()#
elif cfg.colesseo_input() == True:
scenario = guts.load(filename=cfg.colosseo_scenario_yml())
scenario_path = cfg.colosseo_scenario_yml()[:-12]
Meta = C.readcolosseostations(scenario_path)
else:
Meta = C.readMetaInfoFile()
l = 0
for i in networks:
arrayname = i
arrayfolder = os.path.join (Folder['semb'],arrayname)
network = Config[i].split('|')
FilterMeta = ttt.filterStations (Meta,Config,Origin,network)
if len(FilterMeta) < 3: continue
W = XDict[i]
refshift = RefDict[i]
FilterMeta = cmpFilterMetavsXCORR (W, FilterMeta)
Logfile.add ('BOUNDING BOX DIMX: %s DIMY: %s GRIDSPACING: %s \n'
% (Config['dimx'],Config['dimy'],Config['gridspacing']))
f = open('../tttgrid/tttgrid_%s_%s_%s.pkl' % (ev.time, arrayname, workdepth), 'rb')
TTTGridMap,mint,maxt = pickle.load(f)
f.close()
switch = filterindex
tw = times.calculateTimeWindows (mint,maxt,Config,ev, switch)
Wdf = Wdfs[l]
semb_syn = doCalc_syn (counter,Config,Wdf,FilterMeta,mint,maxt,TTTGridMap,
Folder,Origin,ntimes,switch, ev,arrayfolder, syn_in,
parameter[0])
ASL_syn.append(semb_syn)
counter += 1
l += 1
sembmax_syn = sembCalc.collectSemb(ASL_syn,Config,Origin,Folder,ntimes,len(networks),switch)
misfit_list = [] # init a list for a all the singular misfits
norm_list = [] # init a list for a all the singular normalizations
taper = trace.CosFader(xfade=2.0) # Cosine taper with fade in and out of 2s.
bw_filter = trace.ButterworthResponse(corner=0.000055, # in Hz
order=4,
type='high') # "low"pass or "high"pass
setup = trace.MisfitSetup(description='Misfit Setup',
norm=2, # L1 or L2 norm
taper=taper,
filter=bw_filter,
domain='time_domain')
nsamples = len(data)
tmin = util.str_to_time('2010-02-20 15:15:30.100')
tr = trace.Trace(station='TEST', channel='Z',
deltat=0.5, tmin=tmin, ydata=data)
syn = trace.Trace(station='TEST', channel='Z',
deltat=0.5, tmin=tmin, ydata=sembmax_syn)
misfit, norm = tr.misfit(candidate=syn, setup=setup) # calculate the misfit of a single observed trace with its synthetics
# with the setup from above
misfit_list.append(misfit), norm_list.append(norm) # append the misfit into a list
global_misfit_normed = num.sqrt(num.nansum((num.asarray(misfit_list))**2) / # sum all the misfits and normalize to get a single minimizable value
num.nansum((num.asarray(norm_list))**2))
return global_misfit_normed
def optimization(*params, **args):
counter = params[1]
Config = params[2]
Wdf = params[3]
FilterMeta = params[4]
mint = params[5]
maxt = params[6]
TTTGridMap = params[7]
Folder = params[8]
Origin = params[9]
ntimes = params[10]
switch = params[11]
ev = params[12]
arrayfolder = params[13]
syn_in = params[14]
data = params[15]
params = num.asarray(params)
parameter = num.ndarray.tolist(params)
# parameter = [val for sublist in parameter for val in sublist]
semb_syn = doCalc_syn(counter, Config, Wdf, FilterMeta, mint, maxt,
TTTGridMap, Folder, Origin, ntimes, switch, ev,
arrayfolder, syn_in, parameter[0])
misfit_list = [] # init a list for a all the singular misfits
norm_list = [] # init a list for a all the singular normalizations
taper = trace.CosFader(
xfade=2.0) # Cosine taper with fade in and out of 2s.
bw_filter = trace.ButterworthResponse(
corner=0.000055, # in Hz
order=4,
type='high') # "low"pass or "high"pass
setup = trace.MisfitSetup(
description='Misfit Setup',
norm=2, # L1 or L2 norm
taper=taper,
filter=bw_filter,
domain='time_domain')
for t_data, t_syn in zip(data, semb_syn):
nsamples = len(t_data)
tmin = util.str_to_time('2010-02-20 15:15:30.100')
tr = trace.Trace(station='TEST',
channel='Z',
deltat=0.5,
tmin=tmin,
ydata=t_data)
syn = trace.Trace(station='TEST',
channel='Z',
deltat=0.5,
tmin=tmin,
ydata=t_syn)
misfit, norm = tr.misfit(
candidate=syn, setup=setup
) # calculate the misfit of a single observed trace with its synthetics
# with the setup from above
misfit_list.append(misfit), norm_list.append(
norm) # append the misfit into a list
global_misfit_normed = num.sqrt(
num.nansum((num.asarray(misfit_list))**2)
/ # sum all the misfits and normalize to get a single minimizable value
num.nansum((num.asarray(norm_list))**2))
print global_misfit_normed
return global_misfit_normed
candidate1 = trace.Trace(station='TT1', ydata=ydata1)
candidate2 = trace.Trace(station='TT2', ydata=ydata2)
# Define a fader to apply before fft.
taper = trace.CosFader(xfade=5)
# Define a frequency response to apply before performing the inverse fft.
# This can be basically any funtion, as long as it contains a function called
# *evaluate*, which evaluates the frequency response function at a given list
# of frequencies.
# Please refer to the :py:class:`FrequencyResponse` class or its subclasses for
# examples.
# However, we are going to use a butterworth low-pass filter in this example.
bw_filter = trace.ButterworthResponse(corner=2, order=4, type='low')
# Combine all information in one misfit setup:
setup = trace.MisfitSetup(description='An Example Setup',
norm=2,
taper=taper,
filter=bw_filter,
domain='time_domain')
# Calculate misfits of each candidate against the reference trace:
for candidate in [candidate1, candidate2]:
misfit = rt.misfit(candidate=candidate, setup=setup)
print 'misfit: %s, normalization: %s' % misfit
# Finally, dump the misfit setup that has been used as a yaml file for later
# re-use:
setup.dump(filename='my_misfit_setup.txt')
def __init__(self,
network,
reduction,
wdir,
event,
weight=1.,
phase='P',
component='Z',
filter_corner=0.055,
filter_order=4,
filter_type='low',
misfit_norm=2,
taper_fade=2.0,
base=0,
sig_base=0,
extension='',
dist='Unif'):
self.network = network
self.reduction = reduction
self.wdir = wdir
self.event = event
self.phase = phase
self.component = component
self.filter_corner = filter_corner
self.filter_order = filter_order
self.filter_type = filter_type
self.misfit_norm = misfit_norm
self.taper_fade = taper_fade
self.sigmad = 1. / weight
self.base = base
self.sig_base = sig_base
self.Mbase = 1
self.extension = extension
self.dist = dist
self.taper = trace.CosFader(
xfade=self.taper_fade) # Cosine taper with fade in and out of 2s.
self.bw_filter = trace.ButterworthResponse(
corner=self.filter_corner, # in Hz
order=self.filter_order,
type=self.filter_type) # "low"pass or "high"pass
self.setup = trace.MisfitSetup(
description='Misfit Setup',
norm=2, # L1 or L2 norm
taper=self.taper,
filter=self.bw_filter,
domain='time_domain') # Possible domains are:
# time_domain, cc_max_norm (correlation)
# and frequency_domain
self.events = []
self.events.extend(model.load_events(filename=wdir + self.event))
origin = gf.Source(lat=np.float(self.events[0].lat),
lon=np.float(self.events[0].lon))
# print util.time_to_str(events[0].time)
self.base_source = gf.MTSource.from_pyrocko_event(self.events[0])
self.base_source.set_origin(origin.lat, origin.lon)
# print util.time_to_str(self.base_source.time), events[0].lon, events[0].lat
# sys.exit()
self.type = 'Waveform'
def plot_waveforms(traces, event, stations, savedir, picks, show=True):
fig = plt.figure(figsize=plot.mpl_papersize('a4', 'landscape'))
tap_color_annot = (0.35, 0.35, 0.25)
tap_color_edge = (0.85, 0.85, 0.80)
waveform_color = scolor('aluminium5')
misfit_color = scolor('scarletred1')
ncomps = 3
k = 0
nstations = len(stations)
ntraces = nstations * ncomps
i = 0
for st in stations:
for comp in st.channels:
for tr in traces:
if tr.station == st.station:
if comp.name == tr.channel:
# tr.downsample_to(0.05)
# tr.highpass(4, 0.01)
# tr.lowpass(4, 0.2)
dtrace = tr
i = i + 1
target = st
tmin_fit = dtrace.tmin
tmax_fit = dtrace.tmax
tfade_taper = 1. / 0.2
taper = trace.CosTaper(tmin_fit - 20, tmin_fit, tmax_fit,
tmax_fit + 30)
k = k + 1
axes2 = fig.add_subplot(nstations / 3, nstations / 3, k)
space = 0.5
space_factor = 1.0 + space
axes2.set_axis_off()
axes2.set_ylim(-1.05 * space_factor, 1.05)
axes = axes2.twinx()
axes.set_axis_off()
bw_filter = trace.ButterworthResponse(corner=2,
order=4,
type='low')
setup = trace.MisfitSetup(description='setup',
norm=2,
taper=taper,
filter=bw_filter,
domain='time_domain')
abs_tr = dtrace.copy()
abs_tr.set_ydata(abs(dtrace.get_ydata()))
plot_cc(axes2,
abs_tr,
space,
0.,
num.max(abs_tr.get_ydata()),
fc=light(misfit_color, 0.3),
ec=misfit_color,
zorder=4)
plot_trace(axes, dtrace, color=waveform_color, lw=0.5, zorder=5)
tmarks = [dtrace.tmin, dtrace.tmax]
for tmark in tmarks:
axes2.plot([tmark, tmark], [-0.9, 0.1], color=tap_color_annot)
for tmark, text, ha, va in [
(tmarks[0], '$\,$ ' + str_duration(tmarks[0]), 'left',
'bottom'),
(tmarks[1], '$\Delta$ ' + str_duration(tmarks[1] - tmarks[0]),
'right', 'bottom')
]:
axes2.annotate(text,
xy=(tmark, -0.9),
xycoords='data',
xytext=(fontsize * 0.4 * [-1, 1][ha == 'left'],
fontsize * 0.2),
textcoords='offset points',
ha=ha,
va=va,
color=tap_color_annot,
fontsize=fontsize,
zorder=10)
if picks is not None:
for stp in picks["phases"]:
phases_station = []
picks_station = []
if st.station == stp["station"]:
phases_station.append(str(stp["phase"]))
picks_station.append(event.time + float(stp["pick"]))
picks_station.append(event.time)
tmarks = picks_station
for tmark in tmarks:
axes2.plot([tmark, tmark], [-1, 1.], color="blue")
for tmark, text, ha, va in [(tmarks, phases_station,
'left', 'bottom')]:
try:
axes2.annotate(
text[0],
xy=(tmark[0], -1.2),
xycoords='data',
xytext=(8 * 0.4 * [-1, 1][ha == 'left'],
8 * 0.2),
textcoords='offset points',
ha=ha,
va=va,
color=tap_color_annot,
fontsize=8,
zorder=10)
except:
pass
infos = []
infos.append(target.network + "." + target.station + "." +
dtrace.channel)
dist = event.distance_to(target)
azi = event.azibazi_to(target)[0]
infos.append(str_dist(dist))
infos.append(u'%.0f\u00B0' % azi)
axes2.annotate('\n'.join(infos),
xy=(0., 1.),
xycoords='axes fraction',
xytext=(2., 2.),
textcoords='offset points',
ha='left',
va='top',
fontsize=fontsize,
fontstyle='normal')
if i / nstations == 1 or i / nstations == 2 or i / nstations == 3:
fig.savefig(savedir +
"waveforms_%s.png" % str(int(i / nstations)),
dpi=100)
if show is True:
plt.show()
else:
plt.close()
fig = plt.figure(figsize=plot.mpl_papersize('a4', 'landscape'))
k = 0
