def rfstats(stats=None, event=None, station=None, stream=None,
phase='P', dist_range=None):
"""
Calculate ray specific values like slowness for given event and station.
:param stats: stats object with event and/or station attributes. Can be
None if both event and station are given.
:param event: ObsPy :class:`~obspy.core.event.Event` object
:param station: station object with attributes latitude, longitude and
elevation
:param stream: If a stream is given, stats has to be None. In this case
rfstats will be called for every stats object in the stream.
:param phase: string with phase to look for in result of
:func:`~obspy.taup.taup.getTravelTimes`. Usually this will be 'P' or
'S' for P and S receiver functions, respectively.
:type dist_range: tuple of length 2
:param dist_range: if epicentral of event is not in this intervall, None
is returned by this function,\n
if phase == 'P' defaults to (30, 90),\n
if phase == 'S' defaults to (50, 85)
:return: ``stats`` object with event and station attributes, distance,
back_azimuth, inclination, onset and slowness or None if epicentral
distance is not in the given intervall
"""
if stream is not None:
assert stats is None
for tr in stream:
rfstats(tr.stats, event, station, None, phase, dist_range)
return
phase = phase.upper()
if dist_range is None and phase in 'PS':
dist_range = (30, 90) if phase == 'P' else (50, 85)
if stats is None:
stats = AttribDict({})
stats.update(obj2stats(event=event, station=station))
dist, baz, _ = gps2DistAzimuth(stats.station_latitude,
stats.station_longitude,
stats.event_latitude,
stats.event_longitude)
dist = kilometer2degrees(dist / 1000)
if dist_range and not dist_range[0] <= dist <= dist_range[1]:
return
tts = getTravelTimes(dist, stats.event_depth)
tts2 = getTravelTimes(dist, 0)
tts = [tt for tt in tts if tt['phase_name'] == phase]
tts2 = [tt for tt in tts2 if tt['phase_name'] == phase]
if len(tts) == 0 or len(tts2) == 0:
raise Exception('Taup does not return phase %s at event distance %s' %
(phase, dist))
onset = stats.event_time + tts[0]['time']
inc = tts2[0]['take-off angle'] # approximation
v = 5.8 if 'P' in phase else 3.36 # iasp91
slowness = 6371. * sin(pi / 180. * inc) / v / 180 * pi
stats.update({'distance': dist, 'back_azimuth': baz, 'inclination': inc,
'onset': onset, 'slowness': slowness})
return stats
def test_getTravelTimesIASP91(self):
"""
Tests getTravelTimes method using model iasp91.
"""
# read output results from original program
filename = os.path.join(self.path, 'sample_ttimes_iasp91.lst')
with open(filename, 'rt') as fp:
data = fp.readlines()
#1
tt = getTravelTimes(delta=52.474, depth=611.0, model='iasp91')
lines = data[5:29]
self.assertEqual(len(tt), len(lines))
# check calculated tt against original
for i in range(len(lines)):
parts = lines[i][13:].split()
item = tt[i]
self.assertEqual(item['phase_name'], parts[0].strip())
self.assertAlmostEqual(item['time'], float(parts[1].strip()), 2)
self.assertAlmostEqual(item['take-off angle'],
float(parts[2].strip()), 2)
self.assertAlmostEqual(item['dT/dD'], float(parts[3].strip()), 2)
self.assertAlmostEqual(item['dT/dh'], float(parts[4].strip()), 2)
self.assertAlmostEqual(item['d2T/dD2'],
float(parts[5].strip()), 2)
#2
tt = getTravelTimes(delta=50.0, depth=300.0, model='iasp91')
lines = data[34:59]
self.assertEqual(len(tt), len(lines))
# check calculated tt against original
for i in range(len(lines)):
parts = lines[i][13:].split()
item = tt[i]
self.assertEqual(item['phase_name'], parts[0].strip())
self.assertAlmostEqual(item['time'], float(parts[1].strip()), 2)
self.assertAlmostEqual(item['take-off angle'],
float(parts[2].strip()), 2)
self.assertAlmostEqual(item['dT/dD'], float(parts[3].strip()), 2)
self.assertAlmostEqual(item['dT/dh'], float(parts[4].strip()), 2)
self.assertAlmostEqual(item['d2T/dD2'],
float(parts[5].strip()), 2)
#3
tt = getTravelTimes(delta=150.0, depth=300.0, model='iasp91')
lines = data[61:89]
self.assertEqual(len(tt), len(lines))
# check calculated tt against original
for i in range(len(lines)):
parts = lines[i][13:].split()
item = tt[i]
self.assertEqual(item['phase_name'], parts[0].strip())
self.assertAlmostEqual(item['time'], float(parts[1].strip()), 2)
self.assertAlmostEqual(item['take-off angle'],
float(parts[2].strip()), 2)
self.assertAlmostEqual(item['dT/dD'], float(parts[3].strip()), 2)
self.assertAlmostEqual(item['dT/dh'], float(parts[4].strip()), 2)
self.assertAlmostEqual(item['d2T/dD2'],
float(parts[5].strip()), 2)
def test_getTravelTimesIASP91(self):
"""
Tests getTravelTimes method using model iasp91.
"""
# read output results from original program
file = os.path.join(self.path, 'sample_ttimes_iasp91.lst')
data = open(file, 'rt').readlines()
#1
tt = getTravelTimes(delta=52.474, depth=611.0, model='iasp91')
lines = data[5:29]
self.assertEquals(len(tt), len(lines))
# check calculated tt against original
for i in range(len(lines)):
parts = lines[i][13:].split()
item = tt[i]
self.assertEquals(item['phase_name'], parts[0].strip())
self.assertAlmostEquals(item['time'], float(parts[1].strip()), 3)
self.assertAlmostEquals(item['take-off angle'],
float(parts[2].strip()), 2)
self.assertAlmostEquals(item['dT/dD'], float(parts[3].strip()), 3)
self.assertAlmostEquals(item['dT/dh'], float(parts[4].strip()), 3)
self.assertAlmostEquals(item['d2T/dD2'], float(parts[5].strip()),
3)
#2
tt = getTravelTimes(delta=50.0, depth=300.0, model='iasp91')
lines = data[34:59]
self.assertEquals(len(tt), len(lines))
# check calculated tt against original
for i in range(len(lines)):
parts = lines[i][13:].split()
item = tt[i]
self.assertEquals(item['phase_name'], parts[0].strip())
self.assertAlmostEquals(item['time'], float(parts[1].strip()), 3)
self.assertAlmostEquals(item['take-off angle'],
float(parts[2].strip()), 2)
self.assertAlmostEquals(item['dT/dD'], float(parts[3].strip()), 3)
self.assertAlmostEquals(item['dT/dh'], float(parts[4].strip()), 3)
self.assertAlmostEquals(item['d2T/dD2'], float(parts[5].strip()),
3)
#3
tt = getTravelTimes(delta=150.0, depth=300.0, model='iasp91')
lines = data[61:89]
self.assertEquals(len(tt), len(lines))
# check calculated tt against original
for i in range(len(lines)):
parts = lines[i][13:].split()
item = tt[i]
self.assertEquals(item['phase_name'], parts[0].strip())
self.assertAlmostEquals(item['time'], float(parts[1].strip()), 3)
self.assertAlmostEquals(item['take-off angle'],
float(parts[2].strip()), 3)
self.assertAlmostEquals(item['dT/dD'], float(parts[3].strip()), 3)
self.assertAlmostEquals(item['dT/dh'], float(parts[4].strip()), 3)
self.assertAlmostEquals(item['d2T/dD2'], float(parts[5].strip()),
2)
def test_unrealistic_origin_depth_kills_python(self):
"""
See #757
It should of course not kill python...
"""
# This just barely works.
getTravelTimes(10, 800, model="iasp91")
# This raises an error.
self.assertRaises(ValueError, getTravelTimes, 10, 801, model="iasp91")
# This just barely works.
getTravelTimes(10, 800, model="ak135")
# This raises an error.
self.assertRaises(ValueError, getTravelTimes, 10, 801, model="ak135")
def get_neries_info(starttime, endtime, streams):
events = []
arrivals = {}
try:
client = neries.Client()
events = client.getEvents(min_datetime=starttime - 20 * 60,
max_datetime=endtime,
format="list")
for ev in events[::-1]:
has_arrivals = False
origin_time = ev['datetime']
lon1 = ev['longitude']
lat1 = ev['latitude']
depth = abs(ev['depth'])
for st in streams:
sta = st[0].stats.station
lon2 = st[0].stats.coordinates['longitude']
lat2 = st[0].stats.coordinates['latitude']
dist = locations2degrees(lat1, lon1, lat2, lon2)
tts = getTravelTimes(dist, depth)
list_ = arrivals.setdefault(sta, [])
for tt in tts:
tt['time'] = origin_time + tt['time']
if starttime < tt['time'] < endtime:
has_arrivals = True
list_.append(tt)
if not has_arrivals:
events.remove(ev)
except Exception as e:
msg = ("Problem while determining theoretical phases using "
"neries/taup: %s: %s" % (e.__class__.__name__, str(e)))
return None, None, msg
return events, arrivals, None
def test_unrealistic_origin_depth_kills_python(self):
"""
See #757
It should of course not kill python...
"""
# This just barely works.
getTravelTimes(10, 800, model="iasp91")
# This raises an error.
self.assertRaises(ValueError, getTravelTimes, 10, 801,
model="iasp91")
# This just barely works.
getTravelTimes(10, 800, model="ak135")
# This raises an error.
self.assertRaises(ValueError, getTravelTimes, 10, 801,
model="ak135")
def traveltimes(MetaDict, Event):
logger.info('\033[31m Enter AUTOMATIC FILTER \033[0m')
T = []
Wdict = {}
SNR = {}
for i in MetaDict:
de = locations2degrees(float(Event.lat), float(Event.lon), float(i.lat), float(i.lon))
tt = getTravelTimes(delta=de, depth=float(Event.depth), model='ak135')
if tt[0]['phase_name'] == 'P':
ptime = tt[0]['time']
T.append(ptime)
logger.info('\033[31m \n\n+++++++++++++++++++++++++++++++++++++++++++++++++++ \033[0m')
print i.getName(), i.lat, i.lon, ptime
ttime = ptime
tw = calculateTimeWindows(ptime, Event)
w, snr = readWaveformsCross(i, tw, Event, ttime)
Wdict[i.getName()] = w
SNR[i.getName()] = snr
logger.info('\033[31m Exit AUTOMATIC FILTER \033[0m')
return Wdict, SNR
def get_dist_p_s(dist, evdp, model):
'''
function to get the p and s travel time for 3 different models
'''
p_time = []
s_time = []
if model not in ['ak135', 'iasp91', 'common']:
print 'model must be (1) iasp91, (2) ak135, (3) common'
print 'use model common'
for d in dist:
epi_val = d
if model == 'iasp91' or model == 'ak135':
delta = d / 111.1
tt = getTravelTimes(delta=delta, depth=evdp, model=model)
p_t = (item for item in tt if item["phase_name"] == "p").next()
s_t = (item for item in tt if item["phase_name"] == "s").next()
p_time.append(p_t['time'])
s_time.append(s_t['time'])
else:
model = 'common'
p_t, s_t = P_S_arrival_T_common(epi_val, evdp)
p_time.append(p_t)
s_time.append(s_t)
dist_p = dist
dist_s = dist
return dist_p, p_time, dist_s, s_time, model
def get_event_info(starttime, endtime, streams):
events = []
arrivals = {}
try:
client = FDSNClient("NERIES")
events = client.get_events(starttime=starttime - 20 * 60,
endtime=endtime)
for ev in events[::-1]:
has_arrivals = False
origin = ev.origins[0]
origin_time = origin.time
lon1 = origin.longitude
lat1 = origin.latitude
depth = abs(origin.depth / 1e3)
for st in streams:
sta = st[0].stats.station
lon2 = st[0].stats.coordinates['longitude']
lat2 = st[0].stats.coordinates['latitude']
dist = locations2degrees(lat1, lon1, lat2, lon2)
tts = getTravelTimes(dist, depth)
list_ = arrivals.setdefault(sta, [])
for tt in tts:
tt['time'] = origin_time + tt['time']
if starttime < tt['time'] < endtime:
has_arrivals = True
list_.append(tt)
if not has_arrivals:
events[:] = events[:-1]
except Exception as e:
msg = ("Problem while fetching events or determining theoretical "
"phases: %s: %s" % (e.__class__.__name__, str(e)))
return None, None, msg
return events, arrivals, None
def refTrigger(Waveform,Event,Meta):
print Event
name = ('%s.%s.%s.%s')%(Waveform[0].stats.network,Waveform[0].stats.station,Waveform[0].stats.location,Waveform[0].stats.channel)
i = searchMeta(name,Meta)
print i
de = locations2degrees(float(Event.lat), float(Event.lon), float(i.lat), float(i.lon))
tt = getTravelTimes(delta=de, depth=float(Event.depth), model='ak135')
ptime = 0
if tt[0]['phase_name'] == 'P':
ptime = tt[0]['time']
tw = calculateTimeWindows (ptime, Event)
stP = readWaveformsPicker (i, tw, Event, ptime)
trP = stP[0]
cft = recSTALTA(trP.data, int(1 * trP.stats.sampling_rate), int(10 * trP.stats.sampling_rate))
t = triggerOnset(cft,6,1.5)
print len(trP),t,type(t)
onset = t[0][0]/trP.stats.sampling_rate
print 'TRIGGER ',trP.stats.starttime+onset
print 'THEORETICAL: ',UTCDateTime(Event.time)+ptime
tdiff = (trP.stats.starttime+onset)-(UTCDateTime(Event.time)+ptime)
#plotTrigger(trP,cft,6,1.5)
print tdiff
return tdiff
def calculate_time_phase(event, sta):
"""
calculate arrival time of the requested phase to use in retrieving
waveforms.
:param event:
:param sta:
:return:
"""
ev_lat = event['latitude']
ev_lon = event['longitude']
ev_dp = abs(float(event['depth']))
sta_lat = float(sta[4])
sta_lon = float(sta[5])
delta = locations2degrees(ev_lat, ev_lon, sta_lat, sta_lon)
tt = taup.getTravelTimes(delta, ev_dp)
phase_list = ['P', 'Pdiff', 'PKIKP']
time_ph = 0
flag = False
for ph in phase_list:
for i in range(len(tt)):
if tt[i]['phase_name'] == ph:
flag = True
time_ph = tt[i]['time']
break
else:
continue
if flag:
print 'Phase: %s' % ph
break
t_start = event['t1'] + time_ph
t_end = event['t2'] + time_ph
return t_start, t_end
def get_event_info(starttime, endtime, streams):
events = []
arrivals = {}
try:
client = FDSNClient("NERIES")
events = client.get_events(starttime=starttime - 20 * 60,
endtime=endtime)
for ev in events[::-1]:
has_arrivals = False
origin = ev.origins[0]
origin_time = origin.time
lon1 = origin.longitude
lat1 = origin.latitude
depth = abs(origin.depth / 1e3)
for st in streams:
sta = st[0].stats.station
lon2 = st[0].stats.coordinates['longitude']
lat2 = st[0].stats.coordinates['latitude']
dist = locations2degrees(lat1, lon1, lat2, lon2)
tts = getTravelTimes(dist, depth)
list_ = arrivals.setdefault(sta, [])
for tt in tts:
tt['time'] = origin_time + tt['time']
if starttime < tt['time'] < endtime:
has_arrivals = True
list_.append(tt)
if not has_arrivals:
events[:] = events[:-1]
except Exception as e:
msg = ("Problem while fetching events or determining theoretical "
"phases: %s: %s" % (e.__class__.__name__, str(e)))
return None, None, msg
return events, arrivals, None
def arr_time(self, epi_dist, req_phase='Pdiff'):
tt = getTravelTimes(epi_dist, self.stats.sac.evdp, model=self.model)
t_phase = -12345.0
for tt_item in tt:
if tt_item['phase_name'] == req_phase:
t_phase = tt_item['time']
break
return (t_phase)
def test_issue_with_global_state(self):
"""
Minimal test case for an issue with global state that results in
different results for the same call to getTravelTimes() in some
circumstances.
See #728 for more details.
"""
tt_1 = getTravelTimes(delta=100, depth=0, model="ak135")
# Some other calculation in between.
getTravelTimes(delta=100, depth=200, model="ak135")
tt_2 = getTravelTimes(delta=100, depth=0, model="ak135")
# Both should be equal if everything is alright.
self.assertEqual(tt_1, tt_2)
def test_issue_with_global_state(self):
"""
Minimal test case for an issue with global state that results in
different results for the same call to getTravelTimes() in some
circumstances.
See #728 for more details.
"""
tt_1 = getTravelTimes(delta=100, depth=0, model="ak135")
# Some other calculation in between.
getTravelTimes(delta=100, depth=200, model="ak135")
tt_2 = getTravelTimes(delta=100, depth=0, model="ak135")
# Both should be equal if everything is alright.
self.assertEqual(tt_1, tt_2)
def on_stations_listWidget_currentItemChanged(self, current, previous):
if current is None:
return
wave = self.comm.query.get_matching_waveforms(
self.current_event, self.current_iteration, self.current_station)
event = self.comm.events.get(self.current_event)
great_circle_distance = locations2degrees(
event["latitude"], event["longitude"],
wave.coordinates["latitude"], wave.coordinates["longitude"])
tts = getTravelTimes(great_circle_distance, event["depth_in_km"],
model="ak135")
windows_for_station = \
self.current_window_manager.get_windows_for_station(
self.current_station)
self._reset_all_plots()
for component in ["Z", "N", "E"]:
plot_widget = getattr(self.ui, "%s_graph" % component.lower())
data_tr = [tr for tr in wave.data
if tr.stats.channel[-1].upper() == component]
if data_tr:
tr = data_tr[0]
plot_widget.data_id = tr.id
times = tr.times()
plot_widget.plot(times, tr.data, pen="k")
else:
plot_widget.data_id = None
synth_tr = [tr for tr in wave.synthetics
if tr.stats.channel[-1].upper() == component]
if synth_tr:
tr = synth_tr[0]
times = tr.times()
plot_widget.plot(times, tr.data, pen="r", )
if data_tr or synth_tr:
for tt in tts:
if tt["time"] >= times[-1]:
continue
if tt["phase_name"][0].lower() == "p":
pen = "#008c2866"
else:
pen = "#95000066"
plot_widget.addLine(x=tt["time"], pen=pen, z=-10)
plot_widget.autoRange()
window = [_i for _i in windows_for_station
if _i.channel_id[-1].upper() == component]
if window:
plot_widget.windows = window[0]
for win in window[0].windows:
WindowLinearRegionItem(win, event, parent=plot_widget)
def getTravelTimes2(self,distance,depth):
tt = taup.getTravelTimes(delta=1.5, depth=13.0, model='ak135')
ptimes = []
stimes = []
for time in tt:
if time['phase_name'].startswith('P'):
ptimes.append(time['time'])
if time['phase_name'].startswith('S'):
stimes.append(time['time'])
return (min(ptimes),min(stimes))
def event2stats(lat, lon, event, phase='P', dist_range=(30, 90)):
phase = phase.upper()
ori = event.origins[0]
dist, baz, _ = gps2DistAzimuth(lat, lon,
ori.latitude, ori.longitude)
dist = kilometer2degrees(dist / 1000)
if not dist_range[0] <= dist <= dist_range[1]:
return
tts = getTravelTimes(dist, ori.depth)
tts2 = getTravelTimes(dist, 0)
tts = [tt for tt in tts if tt['phase_name'] == phase]
tts2 = [tt for tt in tts2 if tt['phase_name'] == phase]
if len(tts) == 0 or len(tts2) == 0:
raise Exception('Taup does not return phase %s at event distance %s' %
(phase, dist))
onset = event.origins[0].time + tts[0]['time']
inc = tts2[0]['take-off angle'] # approximation
return AttribDict({'dist':dist, 'back_azimuth':baz, 'inclination': inc,
'onset':onset})
def getTravelTimes2(self, distance, depth):
tt = taup.getTravelTimes(delta=1.5, depth=13.0, model='ak135')
ptimes = []
stimes = []
for time in tt:
if time['phase_name'].startswith('P'):
ptimes.append(time['time'])
if time['phase_name'].startswith('S'):
stimes.append(time['time'])
return (min(ptimes), min(stimes))
def delay_and_sum(self,pds_depth=660.0):
'''
shift the time axis of a receiver function trace
to correct for the moveout of a given phase.
'''
#use a reference delta = 45
ref_deg = 45.0
travel_times = getTravelTimes(ref_deg, self.ses3d_seismogram.sz/1000.0,
phase_list=['P','P660s'])
P_minus_Pds_ref = travel_times[0]['time'] - travel_times[1]['time']
#find delta slowness here
travel_times = getTravelTimes(self.delta_deg, self.ses3d_seismogram.sz/1000.0,
phase_list=['P','P660s'])
P_minus_Pds_here = travel_times[0]['time'] - travel_times[1]['time']
time_shift = P_minus_Pds_ref - P_minus_Pds_here
index_shift = int(time_shift/self.ses3d_seismogram.dt)
shifted_trace = np.roll(self.prf,-1*index_shift)
self.prf = shifted_trace
print "trace shifted by ",time_shift, " seconds"
def delay_and_sum(self, pds_depth=660.0):
'''
shift the time axis of a receiver function trace
to correct for the moveout of a given phase.
'''
#use a reference delta = 45
ref_deg = 45.0
travel_times = getTravelTimes(ref_deg,
self.ses3d_seismogram.sz / 1000.0,
phase_list=['P', 'P660s'])
P_minus_Pds_ref = travel_times[0]['time'] - travel_times[1]['time']
#find delta slowness here
travel_times = getTravelTimes(self.delta_deg,
self.ses3d_seismogram.sz / 1000.0,
phase_list=['P', 'P660s'])
P_minus_Pds_here = travel_times[0]['time'] - travel_times[1]['time']
time_shift = P_minus_Pds_ref - P_minus_Pds_here
index_shift = int(time_shift / self.ses3d_seismogram.dt)
shifted_trace = np.roll(self.prf, -1 * index_shift)
self.prf = shifted_trace
print "trace shifted by ", time_shift, " seconds"
def test_get_travel_times_ak135(self):
"""
Tests getTravelTimes method using model ak135.
"""
# read output results from original program
filename = os.path.join(self.path, 'sample_ttimes_ak135.lst')
with open(filename, 'rt') as fp:
data = fp.readlines()
# 1
tt = getTravelTimes(delta=52.474, depth=611.0, model='ak135')[:16]
lines = data[5:21]
self.assertEqual(len(tt), len(lines))
# check calculated tt against original
for line, item in zip(lines, tt):
parts = line[13:].split()
self.assertEqual(item['phase_name'], parts[0].strip())
self.assertAlmostEqual(item['time'], float(parts[1]), 1)
# The takeoff angle is defined a bit differently in the new
# version.
if item["take-off angle"] < 0.0:
item["take-off angle"] += 180.0
self.assertAlmostEqual(item["take-off angle"], float(parts[2]), 0)
self.assertAlmostEqual(item['dT/dD'], float(parts[3]), 1)
# 2
tt = getTravelTimes(delta=50.0, depth=300.0, model='ak135')[:17]
lines = data[26:43]
self.assertEqual(len(tt), len(lines))
# check calculated tt against original
for line, item in zip(lines, tt):
parts = line[13:].split()
self.assertEqual(item['phase_name'], parts[0].strip())
self.assertAlmostEqual(item['time'], float(parts[1]), 1)
if item["take-off angle"] < 0.0:
item["take-off angle"] += 180.0
self.assertAlmostEqual(item['take-off angle'], float(parts[2]), 0)
self.assertAlmostEqual(item['dT/dD'], float(parts[3]), 1)
def test_getTravelTimesIASP91(self):
"""
Tests getTravelTimes method using model iasp91.
"""
# read output results from original program
filename = os.path.join(self.path, 'sample_ttimes_iasp91.lst')
with open(filename, 'rt') as fp:
data = fp.readlines()
# 1
tt = getTravelTimes(delta=52.474, depth=611.0, model='iasp91')[:16]
lines = data[5:21]
self.assertEqual(len(tt), len(lines))
# check calculated tt against original
for line, item in zip(lines, tt):
parts = line[13:].split()
self.assertEqual(item['phase_name'], parts[0].strip())
self.assertAlmostEqual(item['time'], float(parts[1].strip()), 1)
if item["take-off angle"] < 0.0:
item["take-off angle"] += 180.0
self.assertAlmostEqual(item['take-off angle'], float(parts[2]), 0)
self.assertAlmostEqual(item['dT/dD'], float(parts[3]), 1)
# 2
tt = getTravelTimes(delta=50.0, depth=300.0, model='iasp91')[:19]
lines = data[26:45]
self.assertEqual(len(tt), len(lines))
# check calculated tt against original
for line, item in zip(lines, tt):
parts = line[13:].split()
self.assertEqual(item['phase_name'], parts[0].strip())
self.assertAlmostEqual(item['time'], float(parts[1]), 1)
if item["take-off angle"] < 0.0:
item["take-off angle"] += 180.0
self.assertAlmostEqual(item['take-off angle'], float(parts[2]), 0)
self.assertAlmostEqual(item['dT/dD'], float(parts[3]), 1)
def test_util_trace3(self):
from obspy.taup.taup import getTravelTimes
iasp91 = Iasp91(5., 5000)
slat = np.array([-10, 0])
slon = np.array([-160, 10])
slowness = np.array([6.4, 3.2])
azi = np.array([13., 170.])
depth = np.array([200, 200])
rpier, plat, plon = iasp91.pspier(depth, slat, slon, slowness, azi, phase='S')
rpier2, plat2, plon2 = util.pspier(depth, slat, slon, slowness, azi)
np.testing.assert_array_almost_equal(rpier, rpier2, 0)
np.testing.assert_array_almost_equal(plat, plat2, 2)
np.testing.assert_array_almost_equal(plon, plon2, 2)
tp, rp, phip = iasp91.trace3(6.4, phase='P', till_turn=False)
taup = getTravelTimes(phip[-1] * 180 / np.pi, 0)
self.assertTrue(abs(tp[-1] - taup[0]['time']) < 2)
def plot_traveltimes(self):
great_circle_distance = locations2degrees(
self.event["latitude"], self.event["longitude"],
self.data["coordinates"]["latitude"],
self.data["coordinates"]["longitude"])
tts = getTravelTimes(great_circle_distance, self.event["depth_in_km"],
model="ak135")
for component in ["z", "n", "e"]:
axis = getattr(self, "plot_axis_%s" % component)
ymin, ymax = axis.get_ylim()
for phase in tts:
if phase["phase_name"].lower().startswith("p"):
color = "green"
else:
color = "red"
axis.axvline(x=phase["time"], ymin=-1, ymax=+1,
color=color, alpha=0.5)
axis.set_ylim(ymin, ymax)
def traveltimes(self):
logger.info('\033[31m Enter AUTOMATIC FILTER \033[0m')
T = []
Wdict = {}
SNR = {}
for i in self.StationMeta:
#de = locations2degrees (float(self.Origin.lat), float(self.Origin.lon), float(i.lat), float(i.lon))
de = loc2degrees(self.Origin, i)
tt = getTravelTimes(delta=de,
depth=float(self.Origin.depth),
model='ak135')
if tt[0]['phase_name'] == 'P':
ptime = tt[0]['time']
T.append(ptime)
logger.info(
'\033[31m \n\n+++++++++++++++++++++++++++++++++++++++++++++++++++ \033[0m'
)
print i.getName(), i.lat, i.lon, ptime
ttime = ptime
tw = self.calculateTimeWindows(ptime)
try:
w, snr = self.readWaveformsCross(i, tw, ttime)
Wdict[i.getName()] = w
SNR[i.getName()] = snr
except:
continue
logger.info('\033[31m Exit AUTOMATIC FILTER \033[0m')
return Wdict, SNR
def cc_core(ls_first, ls_second, identity_all, max_ts, print_sta):
"""
Perform the main part of the cross correlation and creating
the cc.txt file
"""
global input
try:
cc_open = open('./cc.txt', 'a')
tr1 = read(ls_first)[0]
if input['phase'] != 'N':
evsta_dist = util.locations2degrees(lat1 = tr1.stats.sac.evla, \
long1 = tr1.stats.sac.evlo, lat2 = tr1.stats.sac.stla, \
long2 = tr1.stats.sac.stlo)
taup_tt = taup.getTravelTimes(delta=evsta_dist,
depth=tr1.stats.sac.evdp)
phase_exist = 'N'
for tt_item in taup_tt:
if tt_item['phase_name'] == input['phase']:
print 'Requested phase:'
print input['phase']
print '------'
print tt_item['phase_name']
print 'exists in the waveform!'
print '-----------------------'
t_phase = tt_item['time']
phase_exist = 'Y'
break
if input['phase'] == 'N' or (input['phase'] != 'N'
and phase_exist == 'Y'):
# identity of the current waveform
identity = tr1.stats.network + '.' + tr1.stats.station + '.' + \
tr1.stats.location + '.' + tr1.stats.channel
# Keep the current identity in a new variable
id_name = identity
try:
tr2 = read(os.path.join(input['second_path'], identity))[0]
except Exception, error:
# if it is not possible to read the identity in the second path
# then change the network part of the identity based on
# correction unit
identity = input['corr_unit'] + '.' + tr1.stats.station + '.' + \
tr1.stats.location + '.' + tr1.stats.channel
tr2 = read(os.path.join(input['second_path'], identity))[0]
if input['resample'] != 'N':
print 'WARNING: you are using resample!!!'
tr1.resample(input['resample'])
tr2.resample(input['resample'])
if input['tw'] == 'Y':
t_cut_1 = tr1.stats.starttime + t_phase - input['preset']
t_cut_2 = tr1.stats.starttime + t_phase + input['offset']
tr1.trim(starttime=t_cut_1, endtime=t_cut_2)
t_cut_1 = tr2.stats.starttime + t_phase - input['preset']
t_cut_2 = tr2.stats.starttime + t_phase + input['offset']
tr2.trim(starttime=t_cut_1, endtime=t_cut_2)
if input['hlfilter'] == 'Y':
tr1.filter('lowpass', freq=input['hfreq'], corners=2)
tr2.filter('lowpass', freq=input['hfreq'], corners=2)
tr1.filter('highpass', freq=input['lfreq'], corners=2)
tr2.filter('highpass', freq=input['lfreq'], corners=2)
# normalization of all three waveforms to the
# max(max(tr1), max(tr2), max(tr3)) to keep the scales
#maxi = max(abs(tr1.data).max(), abs(tr2.data).max(), abs(tr3.data).max())
'''
maxi = max(abs(tr1.data).max(), abs(tr2.data).max())
tr1_data = tr1.data/abs(maxi)
tr2_data = tr2.data/abs(maxi)
tr3_data = tr3.data/abs(maxi)
'''
tr1.data = tr1.data / abs(max(tr1.data))
tr2.data = tr2.data / abs(max(tr2.data))
cc_np = tr1.stats.sampling_rate * max_ts
np_shift, coeff = cross_correlation.xcorr(tr1, tr2, int(cc_np))
t_shift = float(np_shift) / tr1.stats.sampling_rate
# scale_str shows whether the scale of the waveforms are the same or not
# if scale_str = 'Y' then the scale is correct.
scale_str = 'Y'
if abs(tr1.data).max() > 2.0 * abs(tr2.data).max():
label_tr1 = ls_first.split('/')[-2]
label_tr2 = ls_second[0].split('/')[-2]
print '#####################################################'
print "Scale is not correct! " + label_tr1 + '>' + label_tr2
print '#####################################################'
scale_str = 'N'
elif abs(tr2.data).max() >= 2.0 * abs(tr1.data).max():
label_tr1 = ls_first.split('/')[-2]
label_tr2 = ls_second[0].split('/')[-2]
print '#####################################################'
print "Scale is not correct! " + label_tr2 + '>' + label_tr1
print '#####################################################'
scale_str = 'N'
if not str(coeff) == 'nan':
cc_open.writelines(id_name + ',' + str(round(coeff, 4)) + ',' + str(t_shift) + \
',' + scale_str + ',' + '\n')
print "Cross Correlation:"
print id_name
print "Shift: " + str(t_shift)
print "Coefficient: " + str(coeff)
print print_sta
print '------------------'
cc_open.close()
cc_open.close()
except Exception, error:
print '##################'
print error
print '##################'
def single_comparison():
"""
one by one comparison of the waveforms in the first path with the second path.
"""
client = Client()
global input
# identity of the waveforms (first and second paths) to be compared with each other
identity_all = input['net'] + '.' + input['sta'] + '.' + \
input['loc'] + '.' + input['cha']
ls_first = glob.glob(os.path.join(input['first_path'], identity_all))
ls_second = glob.glob(os.path.join(input['second_path'], identity_all))
for i in range(0, len(ls_first)):
try:
tr1 = read(ls_first[i])[0]
if input['phase'] != 'N':
evsta_dist = util.locations2degrees(lat1 = tr1.stats.sac.evla, \
long1 = tr1.stats.sac.evlo, lat2 = tr1.stats.sac.stla, \
long2 = tr1.stats.sac.stlo)
taup_tt = taup.getTravelTimes(delta=evsta_dist,
depth=tr1.stats.sac.evdp)
phase_exist = 'N'
for tt_item in taup_tt:
if tt_item['phase_name'] == input['phase']:
print 'Requested phase:'
print input['phase']
print '------'
print tt_item['phase_name']
print 'exists in the waveform!'
print '-----------------------'
t_phase = tt_item['time']
phase_exist = 'Y'
break
if phase_exist != 'Y':
continue
# identity of the current waveform
identity = tr1.stats.network + '.' + tr1.stats.station + '.' + \
tr1.stats.location + '.' + tr1.stats.channel
# tr1: first path, tr2: second path, tr3: Raw data
#tr3 = read(os.path.join(input['first_path'], '..', 'BH_RAW', identity))[0]
if input['resp_paz'] == 'Y':
response_file = os.path.join(input['first_path'], '..',
'Resp/RESP.' + identity)
# Extract the PAZ info from response file
paz = readRESP(response_file, unit=input['corr_unit'])
poles = paz['poles']
zeros = paz['zeros']
scale_fac = paz['gain']
sensitivity = paz['sensitivity']
print paz
# Convert Poles and Zeros (PAZ) to frequency response.
h, f = pazToFreqResp(poles, zeros, scale_fac, \
1./tr1.stats.sampling_rate, tr1.stats.npts*2, freq=True)
# Use the evalresp library to extract
# instrument response information from a SEED RESP-file.
resp = invsim.evalresp(t_samp = 1./tr1.stats.sampling_rate, \
nfft = tr1.stats.npts*2, filename = response_file, \
date = tr1.stats.starttime, units = input['corr_unit'].upper())
# Keep the current identity in a new variable
id_name = identity
try:
tr2 = read(os.path.join(input['second_path'], identity))[0]
except Exception, error:
# if it is not possible to read the identity in the second path
# then change the network part of the identity based on
# correction unit
identity = input['corr_unit'] + '.' + tr1.stats.station + '.' + \
tr1.stats.location + '.' + tr1.stats.channel
tr2 = read(os.path.join(input['second_path'], identity))[0]
if input['resample'] != 'N':
print 'WARNING: you are using resample!!!'
tr1.resample(input['resample'])
tr2.resample(input['resample'])
if input['tw'] == 'Y':
t_cut_1 = tr1.stats.starttime + t_phase - input['preset']
t_cut_2 = tr1.stats.starttime + t_phase + input['offset']
tr1.trim(starttime=t_cut_1, endtime=t_cut_2)
t_cut_1 = tr2.stats.starttime + t_phase - input['preset']
t_cut_2 = tr2.stats.starttime + t_phase + input['offset']
tr2.trim(starttime=t_cut_1, endtime=t_cut_2)
if input['hlfilter'] == 'Y':
tr1.filter('lowpass', freq=input['hfreq'], corners=2)
tr2.filter('lowpass', freq=input['hfreq'], corners=2)
tr1.filter('highpass', freq=input['lfreq'], corners=2)
tr2.filter('highpass', freq=input['lfreq'], corners=2)
# normalization of all three waveforms to the
# max(max(tr1), max(tr2), max(tr3)) to keep the scales
#maxi = max(abs(tr1.data).max(), abs(tr2.data).max(), abs(tr3.data).max())
#maxi = max(abs(tr1.data).max(), abs(tr2.data).max())
#tr1_data = tr1.data/abs(maxi)
#tr2_data = tr2.data/abs(maxi)
#tr3_data = tr3.data/abs(maxi)
tr1_data = tr1.data / abs(max(tr1.data))
tr2_data = tr2.data / abs(max(tr2.data))
#tr1_data = tr1.data
#tr2_data = tr2.data*1e9
print max(tr1.data)
print max(tr2.data)
# create time arrays for tr1, tr2 and tr3
time_tr1 = np.arange(0, tr1.stats.npts/tr1.stats.sampling_rate, \
1./tr1.stats.sampling_rate)
time_tr2 = np.arange(0, tr2.stats.npts/tr2.stats.sampling_rate, \
1./tr2.stats.sampling_rate)
#time_tr3 = np.arange(0, tr3.stats.npts/tr3.stats.sampling_rate, \
# 1./tr3.stats.sampling_rate)
# label for plotting
label_tr1 = ls_first[i].split('/')[-2]
label_tr2 = ls_second[i].split('/')[-2]
label_tr3 = 'RAW'
if input['resp_paz'] == 'Y':
# start plotting
plt.figure()
plt.subplot2grid((3, 4), (0, 0), colspan=4, rowspan=2)
#plt.subplot(211)
plt.plot(time_tr1, tr1_data, color='blue', label=label_tr1, lw=3)
plt.plot(time_tr2, tr2_data, color='red', label=label_tr2, lw=3)
#plt.plot(time_tr3, tr3_data, color = 'black', ls = '--', label = label_tr3)
plt.xlabel('Time (sec)', fontsize='xx-large', weight='bold')
if input['corr_unit'] == 'dis':
ylabel_str = 'Relative Displacement'
elif input['corr_unit'] == 'vel':
ylabel_str = 'Relative Vel'
elif input['corr_unit'] == 'acc':
ylabel_str = 'Relative Acc'
plt.ylabel(ylabel_str, fontsize='xx-large', weight='bold')
plt.xticks(fontsize='xx-large', weight='bold')
plt.yticks(fontsize='xx-large', weight='bold')
plt.legend(loc=1, prop={'size': 20})
#-------------------Cross Correlation
# 5 seconds as total length of samples to shift for cross correlation.
cc_np = tr1.stats.sampling_rate * 3
np_shift, coeff = cross_correlation.xcorr(tr1, tr2, int(cc_np))
t_shift = float(np_shift) / tr1.stats.sampling_rate
print "Cross Correlation:"
print "Shift: " + str(t_shift)
print "Coefficient: " + str(coeff)
plt.title('Single Comparison' + '\n' + str(t_shift) + \
' sec , coeff: ' + str(round(coeff, 5)) + \
'\n' + id_name, \
fontsize = 'xx-large', weight = 'bold')
if input['resp_paz'] == 'Y':
# -----------------------
#plt.subplot(223)
plt.subplot2grid((3, 4), (2, 0), colspan=2)
'''
plt.plot(np.log10(f), np.log10(abs(resp)/(sensitivity*sensitivity)), \
color = 'blue', label = 'RESP', lw=3)
plt.plot(np.log10(f), np.log10(abs(h)/sensitivity), \
color = 'red', label = 'PAZ', lw=3)
'''
plt.loglog(f, abs(resp)/(sensitivity*sensitivity), \
color = 'blue', label = 'RESP', lw=3)
plt.loglog(f, abs(h)/sensitivity, \
color = 'red', label = 'PAZ', lw=3)
#for j in [0.008, 0.012, 0.025, 0.5, 1, 2, 3, 4]:
for j in [0]:
plt.axvline(np.log10(j), linestyle='--')
#plt.xlabel('Frequency [Hz]\n(power of 10)', fontsize = 'xx-large', weight = 'bold')
#plt.ylabel('Amplitude\n (power of 10)', fontsize = 'xx-large', weight = 'bold')
plt.xlabel('Frequency [Hz]',
fontsize='xx-large',
weight='bold')
plt.ylabel('Amplitude', fontsize='xx-large', weight='bold')
plt.xticks(fontsize='xx-large', weight='bold')
#plt.yticks = MaxNLocator(nbins=4)
plt.yticks(fontsize='xx-large', weight='bold')
plt.legend(loc=2, prop={'size': 20})
# -----------------------
#plt.subplot(224)
plt.subplot2grid((3, 4), (2, 2), colspan=2)
#take negative of imaginary part
phase_paz = np.unwrap(np.arctan2(h.imag, h.real))
phase_resp = np.unwrap(np.arctan2(resp.imag, resp.real))
#plt.plot(np.log10(f), phase_resp, color = 'blue', label = 'RESP', lw=3)
#plt.plot(np.log10(f), phase_paz, color = 'red', label = 'PAZ', lw=3)
plt.semilogx(f, phase_resp, color='blue', label='RESP', lw=3)
plt.semilogx(f, phase_paz, color='red', label='PAZ', lw=3)
#for j in [0.008, 0.012, 0.025, 0.5, 1, 2, 3, 4]:
for j in [0.0]:
plt.axvline(np.log10(j), linestyle='--')
#plt.xlabel('Frequency [Hz]\n(power of 10)', fontsize = 'xx-large', weight = 'bold')
plt.xlabel('Frequency [Hz]',
fontsize='xx-large',
weight='bold')
plt.ylabel('Phase [radian]',
fontsize='xx-large',
weight='bold')
plt.xticks(fontsize='xx-large', weight='bold')
plt.yticks(fontsize='xx-large', weight='bold')
plt.legend(loc=3, prop={'size': 20})
# title, centered above both subplots
# make more room in between subplots for the ylabel of right plot
plt.subplots_adjust(wspace=0.4, hspace=0.3)
"""
# -----------------------
plt.subplot(325)
plt.plot(np.log10(f), np.log10(abs(resp)/(sensitivity*sensitivity)) - \
np.log10(abs(h)/sensitivity), \
color = 'black', label = 'RESP - PAZ')
for j in [0.008, 0.012, 0.025, 0.5, 1, 2, 3, 4]:
plt.axvline(np.log10(j), linestyle = '--')
plt.xlabel('Frequency [Hz] (power of 10)')
plt.ylabel('Amplitude (power of 10)')
plt.legend()
# -----------------------
plt.subplot(326)
#take negative of imaginary part
phase_paz = np.unwrap(np.arctan2(h.imag, h.real))
phase_resp = np.unwrap(np.arctan2(resp.imag, resp.real))
plt.plot(np.log10(f), np.log10(phase_resp) - np.log10(phase_paz), \
color = 'black', label = 'RESP - PAZ')
for j in [0.008, 0.012, 0.025, 0.5, 1, 2, 3, 4]:
plt.axvline(np.log10(j), linestyle = '--')
plt.xlabel('Frequency [Hz] (power of 10)')
plt.ylabel('Phase [radian] (power of 10)')
plt.legend()
# title, centered above both subplots
# make more room in between subplots for the ylabel of right plot
plt.subplots_adjust(wspace=0.3)
"""
plt.show()
print str(i + 1) + '/' + str(len(ls_first))
print ls_first[i]
print '------------------'
wait = raw_input(id_name)
print '***************************'
except Exception, error:
print '##################'
print error
print '##################'
def core_inversion(
t_d,
cmtloc,
periods,
MRF,
observed_displacements,
trlen,
metadata,
trlist,
gfdir,
return_gfs=False,
residuals=False,
OnlyGetFullGF=False,
max_t_d=200,
):
'''
Perform the actual W-phase inversion.
:param float t_d: Time delay
:param tuple cmtloc: (lat, lon, depth) of the centroid's location.
:param tuple periods: (Ta,Tb), passband periods.
:param array MRF: Moment rate function.
:param array observed_displacements: Array containing concatenated traces of observed disp.
:param array trlen: Array containing the length of each trace.
:param dict metadata: Dictionary with the metadata of each station.
:param list trlist: List with the station id which will contribute to the inv.
:param gfdir: Path to the greens functions or a GreensFunctions instances.
:param bool hdf5_flag: *True* if the greens functions are stored in HDF5, *False* if they are in SAC.
:param bool return_gfs: *True* if the greens functions should be returned.
:param bool residuals: *True*, return the 'raw' misfit from the least squares inversion,
*False*, return the 'relative' misfit as a percentage: i.e. the 'raw' misfit divided by
the norm of the synthetics.
:param bool OnlyGetFullGF: *True*, return the greens function matrix for the maximum time delay (*max_t_d*)
without performing the inversion, *False*, perform the inversion for the time delay given
by *t_d*.
:param numeric max_t_d: Maximum time delay to consider if *OnlyGetFullGF = True*.
:return: What is returned depends on the values of the parameters as described below.
- If *OnlyGetFullGF = True*, then just the greens function matrix.
- Otherwise a tuple containing:
0. moment tensor components in Nm ['RR', 'PP', 'TT', 'TP', 'RT', 'RP']
#. misfit (percent L2 norm misfit error of the solution), and
If *return_gfs = True*
2. The greens function matrix also.
'''
logger.debug("core_inversion(t_d=%d, c=(%.2f, %.2f, %.2f), #tr=%d)", t_d, cmtloc[0], cmtloc[1], cmtloc[2], len(trlist))
if isinstance(gfdir, GreensFunctions):
greens = gfdir
else:
greens = GreensFunctions(gfdir)
delta = greens.delta
hyplat, hyplon, hypdep = cmtloc
Ta, Tb = periods
# Index of the first value that will be valid after convolution with MRF.
first_valid_time = int(len(MRF)/2.)
# the indices of the beginning and end of each trace in observed displacements
indexes = np.array(np.concatenate((np.array([0.]), np.cumsum(trlen))), dtype='int')
if OnlyGetFullGF:
max_t_d = int(max_t_d)
Nst = len(trlen)
GFmatrix = np.zeros((np.array(trlen, dtype=int).sum() + max_t_d*Nst, 5))
tb = 0
else:
GFmatrix = np.zeros((np.array(trlen, dtype=int).sum(), 5))
#### Inversion:
for i, trid in enumerate(trlist):
trmeta = metadata[trid]
trlat = trmeta['latitude']
trlon = trmeta['longitude']
try:
sta = trmeta['sta']
except KeyError:
sta = None
dist = locations2degrees(hyplat, hyplon, trlat, trlon)
distm, azi, bazi = gps2dist_azimuth(hyplat, hyplon, trlat, trlon)
t_p = trmeta.get('ptime')
if not t_p:
from obspy.taup.taup import getTravelTimes
t_p = getTravelTimes(dist,hypdep)[0]['time']
# Select greens function and perform moment tensor rotation in the azimuth
# DETAIL: The greens functions are stored for zero azimuth (which we can do
# because of "symetry properties of a sphere". Then to recover the correct
# moment tensor (or equivalently synthetic trace) we rotate them. For details
# see Kanamori and Rivera 2008.
azi_r = -azi*np.pi/180
synth = greens.select_rotated(trid[-1], dist, hypdep, azi_r)
##################################
# Extract W phase from synthetics.
# Use only what we think is noise to calculate and compensate the mean
synth -= np.mean(synth[..., :60], axis=-1)[:, None]
# Convolve with moment rate function
synth = ndimage.convolve1d(synth, MRF, axis=-1, mode='nearest')\
[:, first_valid_time-2:-first_valid_time]
# Pad data back to original length
fillvec1 = synth[:, 0, None] * np.ones(first_valid_time)
fillvec2 = synth[:, -1, None] * np.ones(first_valid_time)
synth = np.concatenate((fillvec1, synth, fillvec2), axis=-1)
synth -= np.mean(synth[:, :60], axis=-1)[:, None]
# Bandpass filter to extract W phase
def wphase_filter(trace):
return bandpassfilter(trace, delta, 4, 1./Tb, 1./Ta)
synth = np.apply_along_axis(wphase_filter, -1, synth)
if OnlyGetFullGF:
synth = ltrim(synth, t_p - max_t_d, delta)
synth = synth[:, :trlen[i] + max_t_d]
else:
synth = ltrim(synth, t_p - t_d, delta)
synth = synth[:, :trlen[i]]
if OnlyGetFullGF:
ta = tb
tb = ta + max_t_d + (indexes[i+1] - indexes[i])
else:
ta = indexes[i]
tb = indexes[i+1]
# the first of the following lines are due to constraint that volume does not change
GFmatrix[ta:tb, 0] = synth[0][:] - synth[1][:]
GFmatrix[ta:tb, 1] = synth[2][:] - synth[1][:]
GFmatrix[ta:tb, 2] = synth[4][:]
GFmatrix[ta:tb, 3] = synth[5][:]
GFmatrix[ta:tb, 4] = synth[3][:]
if OnlyGetFullGF:
return GFmatrix
# perform the inversion
inversion = lstsq(GFmatrix, observed_displacements, rcond=None)
M = inversion[0]
# construct the synthetics
syn = GFmatrix.dot(M)
# set the 'sixth' element of the moment tensor (corresponds to the
# constraint added 20 lines or so above)
M = np.insert(M, 2, -M[0]-M[1])
# extract the residuals and scale if required
if residuals:
misfit = float(inversion[1])
else:
misfit = 100.*np.sqrt(np.sum((syn-observed_displacements)**2)/np.sum(syn**2))
if return_gfs:
return M, misfit, GFmatrix
return M, misfit
def main(argv=sys.argv):
#Earth's parameters
#~ beta = 4.e3 #m/s
#~ rho = 3.e3 #kg/m^3
#~ mu = rho*beta*beta
PLotSt = [
"IU.TRQA.00.LHZ", "IU.LVC.00.LHZ", "II.NNA.00.LHZ", "IU.RAR.00.LHZ"
]
#PlotSubf = [143, 133, 123, 113, 103, 93,
# 83, 73, 63, 53]
PlotSubf = [6, 3]
#Set rup_vel = 0 to have a point source solution
RupVel = 2.1 #Chilean eq from Lay et al
t_h = 10. # Half duration for each sf
noiselevel = 0.0 # L1 norm level of noise
mu = 40e9
#W-Phase filter
corners = 4.
fmin = 0.001
fmax = 0.005
### Data from Chilean 2010 EQ (Same as W phase inv.)
strike = 18.
dip = 18.
rake = 104. # 109.
rakeA = rake + 45.
rakeB = rake - 45.
### Fault's grid parameters
nsx = 21 #Number of sf along strike
nsy = 11 #Number of sf along dip
flen = 600. #Fault's longitude [km] along strike
fwid = 300. #Fault's longitude [km] along dip
direc = 0 #Directivity 0 = bilateral
Min_h = 10. #Min depth of the fault
### Derivated parameters:
nsf = nsx * nsy
sflen = flen / float(nsx)
sfwid = fwid / float(nsy)
swp = [1, 0, 2] # useful to swap (lat,lon, depth)
mindist = flen * fwid # minimun dist to the hypcen (initializing)
###Chessboard
#weight = np.load("RealSol.npy")
weight = np.zeros(nsf)
weight[::2] = 1
#weight[::2] = 1
#~ weight[10]=15
#~ weight[5001]=10
#~ weight[3201]=2
## Setting dirs and reading files.
GFdir = "/home/roberto/data/GFS/"
workdir = os.path.abspath(".") + "/"
datadir = workdir + "DATA/"
tracesfilename = workdir + "goodtraces.dat"
tracesdir = workdir + "WPtraces/"
try:
reqfilename = glob.glob(workdir + '*.syn.req')[0]
except IndexError:
print "There is not *.syn.req file in the dir"
sys.exit()
basename = reqfilename.split("/")[-1][:-4]
if not os.path.exists(tracesfilename):
print tracesfilename, "does not exist."
exit()
if not os.path.exists(datadir):
os.makedirs(datadir)
if not os.path.exists(tracesdir):
os.makedirs(tracesdir)
tracesfile = open(tracesfilename)
reqfile = open(reqfilename)
trlist = readtraces(tracesfile)
eqdata = readreq(reqfile)
tracesfile.close()
reqfile.close()
####Hypocentre from
### http://earthquake.usgs.gov/earthquakes/eqinthenews/2010/us2010tfan/
cmteplat = -35.91 #-35.85#-36.03#-35.83
cmteplon = -72.73 #-72.72#-72.83# -72.67
cmtepdepth = 35.
eq_hyp = (cmteplat, cmteplon, cmtepdepth)
############
# Defining the sf system
grid, sblt = fault_grid('CL-2010',
cmteplat,
cmteplon,
cmtepdepth,
direc,
Min_h,
strike,
dip,
rake,
flen,
fwid,
nsx,
nsy,
Verbose=False,
ffi_io=True,
gmt_io=True)
print('CL-2010', cmteplat, cmteplon, cmtepdepth, direc, Min_h, strike, dip,
rake, flen, fwid, nsx, nsy)
print grid[0][1]
#sys.exit()
#This calculation is inside of the loop
#~ NP = [strike, dip, rake]
#~ M = np.array(NodalPlanetoMT(NP))
#~ Mp = np.sum(M**2)/np.sqrt(2)
#############################################################################
######Determining the sf closest to the hypocentre:
min_Dist_hyp_subf = flen * fwid
for subf in range(nsf):
sblat = grid[subf][1]
sblon = grid[subf][0]
sbdepth = grid[subf][2]
sf_hyp = (sblat, sblon, sbdepth)
Dist_hyp_subf = hypo2dist(eq_hyp, sf_hyp)
if Dist_hyp_subf < min_Dist_hyp_subf:
min_Dist_hyp_subf = Dist_hyp_subf
min_sb_hyp = sf_hyp
hyp_subf = subf
####Determining trimming times:
test_tr = read(GFdir + "H003.5/PP/GF.0001.SY.LHZ.SAC")[0]
t0 = test_tr.stats.starttime
TrimmingTimes = {} # Min. Distace from the fault to each station.
A = 0
for trid in trlist:
metafile = workdir + "DATA/" + "META." + trid + ".xml"
META = DU.getMetadataFromXML(metafile)[trid]
stlat = META['latitude']
stlon = META['longitude']
dist = locations2degrees(min_sb_hyp[0],min_sb_hyp[1],\
stlat,stlon)
parrivaltime = getTravelTimes(dist, min_sb_hyp[2])[0]['time']
ta = t0 + parrivaltime
tb = ta + round(15. * dist)
TrimmingTimes[trid] = (ta, tb)
###########################
DIST = []
# Ordering the stations in terms of distance
for trid in trlist:
metafile = workdir + "DATA/" + "META." + trid + ".xml"
META = DU.getMetadataFromXML(metafile)[trid]
lat = META['latitude']
lon = META['longitude']
trdist = locations2degrees(cmteplat, cmteplon, lat, lon)
DIST.append(trdist)
DistIndex = lstargsort(DIST)
trlist = [trlist[i] for i in DistIndex]
stdistribution = StDistandAzi(trlist, eq_hyp, workdir + "DATA/")
StDistributionPlot(stdistribution)
#exit()
#Main loop
for subf in range(nsf):
print subf
sflat = grid[subf][1]
sflon = grid[subf][0]
sfdepth = grid[subf][2]
#~ strike = grid[subf][3] #+ 360.
#~ dip = grid[subf][4]
#~ rake = grid[subf][5] #
NP = [strike, dip, rake]
NPA = [strike, dip, rakeA]
NPB = [strike, dip, rakeB]
M = np.array(NodalPlanetoMT(NP))
MA = np.array(NodalPlanetoMT(NPA))
MB = np.array(NodalPlanetoMT(NPB))
#Time delay is calculated as the time in which
#the rupture reach the subfault
sf_hyp = (sflat, sflon, sfdepth)
Dist_ep_subf = hypo2dist(eq_hyp, sf_hyp)
if Dist_ep_subf < mindist:
mindist = Dist_ep_subf
minsubf = subf
if RupVel == 0:
t_d = eqdata['time_shift']
else:
t_d = round(Dist_ep_subf / RupVel) #-59.
print sflat, sflon, sfdepth
# Looking for the best depth dir:
depth = []
depthdir = []
for file in os.listdir(GFdir):
if file[-2:] == ".5":
depthdir.append(file)
depth.append(float(file[1:-2]))
BestDirIndex = np.argsort(abs(sfdepth\
- np.array(depth)))[0]
hdir = GFdir + depthdir[BestDirIndex] + "/"
###
SYN = np.array([])
SYNA = np.array([])
SYNB = np.array([])
for trid in trlist:
metafile = workdir + "DATA/" + "META." + trid + ".xml"
META = DU.getMetadataFromXML(metafile)[trid]
lat = META['latitude']
lon = META['longitude']
#Subfault loop
#GFs Selection:
##Change to folloing loop
dist = locations2degrees(sflat, sflon, lat, lon)
azi = -np.pi / 180. * gps2DistAzimuth(lat, lon, sflat, sflon)[2]
trPPsy, trRRsy, trRTsy, trTTsy = \
GFSelectZ(hdir,dist)
trROT = MTrotationZ(azi, trPPsy, trRRsy, trRTsy, trTTsy)
orig = trROT[0].stats.starttime
dt = trROT[0].stats.delta
trianglen = 2. * int(t_h / dt) - 1.
FirstValid = int(trianglen / 2.) + 1 # to delete
window = triang(trianglen)
window /= np.sum(window)
#window = np.array([1.])
parrivaltime = getTravelTimes(dist, sfdepth)[0]['time']
t1 = TrimmingTimes[trid][0] - t_d
t2 = TrimmingTimes[trid][1] - t_d
for trR in trROT:
trR.data *= 10.**-21 ## To get M in Nm
trR.data -= trR.data[0]
AUX1 = len(trR)
trR.data = convolve(trR.data, window, mode='valid')
AUX2 = len(trR)
mean = np.mean(np.hstack((trR.data[0]*np.ones(FirstValid),\
trR.data[:60./trR.stats.delta*1.-FirstValid+1])))
#mean = np.mean(trR.data[:60])
trR.data -= mean
trR.data = bp.bandpassfilter(trR.data,len(trR), trR.stats.delta,\
corners , 1 , fmin, fmax)
t_l = dt * 0.5 * (AUX1 - AUX2)
trR.trim(t1 - t_l, t2 - t_l, pad=True, fill_value=trR.data[0]
) #We lost t_h due to the convolution
#~ for trR in trROT:
#~ trR.data *= 10.**-23 ## To get M in Nm
#~ trR.data -= trR.data[0]
#~ trR.data = convolve(trR.data,window,mode='same')
#~ #mean = np.mean(np.hstack((trR.data[0]*np.ones(FirstValid),\
#~ #trR.data[:60./trR.stats.delta*1.-FirstValid+1])))
#~ mean = np.mean(trR.data[:60])
#~ trR.data -= mean
#~ trR.data = bp.bandpassfilter(trR.data,len(trR), trR.stats.delta,\
#~ corners , 1 , fmin, fmax)
#~ trR.trim(t1,t2,pad=True, fill_value=trR.data[0])
trROT = np.array(trROT)
syn = np.dot(trROT.T, M)
synA = np.dot(trROT.T, MA)
synB = np.dot(trROT.T, MB)
SYN = np.append(SYN, syn)
SYNA = np.append(SYNA, synA)
SYNB = np.append(SYNB, synB)
print np.shape(A), np.shape(np.array([SYN]))
if subf == 0:
A = np.array([SYN])
AA = np.array([SYNA])
AB = np.array([SYNB])
else:
A = np.append(A, np.array([SYN]), 0)
AA = np.append(AA, np.array([SYNA]), 0)
AB = np.append(AB, np.array([SYNB]), 0)
AC = np.vstack((AA, AB))
print np.shape(AC)
print np.shape(weight)
B = np.dot(A.T, weight)
stsyn = Stream()
n = 0
Ntraces = {}
for trid in trlist:
spid = trid.split(".")
print trid
NMIN = 1. + (TrimmingTimes[trid][1] - TrimmingTimes[trid][0]) / dt
Ntraces[trid] = (n, NMIN + n)
trsyn = Trace(B[n:NMIN + n])
n += NMIN
trsyn.stats.network = spid[0]
trsyn.stats.station = spid[1]
trsyn.stats.location = spid[2]
trsyn.stats.channel = spid[3]
trsyn = AddNoise(trsyn, level=noiselevel)
#trsyn.stats.starttime =
stsyn.append(trsyn)
stsyn.write(workdir + "WPtraces/" + basename + ".decov.trim.mseed",
format="MSEED")
#####################################################
# Plotting:
#####################################################
#we are going to reflect the y axis later, so:
print minsubf
hypsbloc = [minsubf / nsy, -(minsubf % nsy) - 2]
#Creating the strike and dip axis:
StrikeAx = np.linspace(0, flen, nsx + 1)
DipAx = np.linspace(0, fwid, nsy + 1)
DepthAx = DipAx * np.sin(np.pi / 180. * dip) + Min_h
hlstrike = StrikeAx[hypsbloc[0]] + sflen * 0.5
hldip = DipAx[hypsbloc[1]] + sfwid * 0.5
hldepth = DepthAx[hypsbloc[1]] + sfwid * 0.5 * np.sin(np.pi / 180. * dip)
StrikeAx = StrikeAx - hlstrike
DipAx = DipAx - hldip
XX, YY = np.meshgrid(StrikeAx, DepthAx)
XX, ZZ = np.meshgrid(StrikeAx, DipAx)
sbarea = sflen * sfwid
SLIPS = weight.reshape(nsx, nsy).T #[::-1,:]
SLIPS /= mu * 1.e6 * sbarea
######Plot:#####################
plt.figure()
ax = host_subplot(111)
im = ax.pcolor(XX, YY, SLIPS, cmap="jet")
ax.set_ylabel('Depth [km]')
ax.set_ylim(DepthAx[-1], DepthAx[0])
# Creating a twin plot
ax2 = ax.twinx()
#im2 = ax2.pcolor(XX, ZZ, SLIPS[::-1,:], cmap="Greys")
im2 = ax2.pcolor(XX, ZZ, SLIPS[::-1, :], cmap="jet")
ax2.set_ylabel('Distance along the dip [km]')
ax2.set_xlabel('Distance along the strike [km]')
ax2.set_ylim(DipAx[0], DipAx[-1])
ax2.set_xlim(StrikeAx[0], StrikeAx[-1])
ax.axis["bottom"].major_ticklabels.set_visible(False)
ax2.axis["bottom"].major_ticklabels.set_visible(False)
ax2.axis["top"].set_visible(True)
ax2.axis["top"].label.set_visible(True)
divider = make_axes_locatable(ax)
cax = divider.append_axes("bottom", size="5%", pad=0.1)
cb = plt.colorbar(im, cax=cax, orientation="horizontal")
cb.set_label("Slip [m]")
ax2.plot([0], [0], '*', ms=225. / (nsy + 4))
ax2.set_xticks(ax2.get_xticks()[1:-1])
#ax.set_yticks(ax.get_yticks()[1:])
#ax2.set_yticks(ax2.get_yticks()[:-1])
#########Plotting the selected traces:
nsp = len(PLotSt) * len(PlotSubf)
plt.figure(figsize=(13, 11))
plt.title("Synthetics for rake = " + str(round(rake)))
mindis = []
maxdis = []
for i, trid in enumerate(PLotSt):
x = np.arange(0, Ntraces[trid][1] - Ntraces[trid][0], dt)
for j, subf in enumerate(PlotSubf):
y = A[subf, Ntraces[trid][0]:Ntraces[trid][1]]
if j == 0:
yy = y
else:
yy = np.vstack((yy, y))
maxdis.append(np.max(yy))
mindis.append(np.min(yy))
for i, trid in enumerate(PLotSt):
x = np.arange(0, Ntraces[trid][1] - Ntraces[trid][0], dt)
for j, subf in enumerate(PlotSubf):
y = A[subf, Ntraces[trid][0]:Ntraces[trid][1]]
plt.subplot2grid((len(PlotSubf), len(PLotSt)), (j, i))
plt.plot(x, y, linewidth=2.5)
if j == 0:
plt.title(trid)
fig = plt.gca()
fig.axes.get_yaxis().set_ticks([])
fig.set_ylabel(str(subf), rotation=0)
fig.set_xlim((x[0], x[-1]))
fig.set_ylim((mindis[i], maxdis[i]))
if subf != PlotSubf[-1]:
fig.axes.get_xaxis().set_ticks([])
plt.show()
C = S.select(component="E")
print(C)
Clist = []
for a in C[0].data.tolist():
if a > -9*10**9:
Clist.append(float(a))
else:
Clist.append(float('NaN'))
data['E'] = Clist
R = dict()
R['time_start']=datetime2matlabdn(S[0].stats.starttime.datetime)
R['time_end']=datetime2matlabdn(S[0].stats.endtime.datetime)
R['sampling_rate'] = S[0].stats.sampling_rate;
R['station'] = S[0].stats.station;
R['latitude'] = lat
R['longitude'] = lon
R['elevation'] = ele
R['data'] = data
if event:
event_params = event.split(',')
distance = locations2degrees(float(event_params[0]), float(event_params[1]), lat, lon)
tt = getTravelTimes(delta=distance, depth=float(event_params[0]))
R['first_arrival'] = datetime2matlabdn(datetime.strptime(event_params[3], "%Y-%m-%d %H:%M:%S") + timedelta(seconds=tt[0]['time']))
scipy.io.savemat(options.output, R)
print(S)
selv = stadic.get(net+"."+sta).get("elevation")
#print slat
#print slon
# Calculate gcarc, baz and az:
irisclient = iclient.Client()
gcbazaz = irisclient.distaz(stalat=slat, stalon=slon, evtlat=elat, evtlon=elon)
gcarc = gcbazaz.get('distance')
baz = gcbazaz.get('backazimuth')
az = gcbazaz.get('azimuth')
#print gcarc
#print baz
#print az
# Calculate Travel Time:
ttlist = getTravelTimes(delta=gcarc, depth=edep ,model='iasp91')
for num in range(len(ttlist)):
ttdic=ttlist[num]
phase=ttdic.get('phase_name')
if phase == 'P':
ptoa=ttdic.get('take-off angle')
ptime=ttdic.get('time')
elif phase == 'S':
stoa=ttdic.get('take-off angle')
stime=ttdic.get('time')
# print toa
# print ptime
# Fix date format:
syear=str(year)
def select_sta():
"""
Select required stations
"""
global input
map_proj = Basemap(projection='cyl', llcrnrlat=-90,urcrnrlat=90,\
llcrnrlon=-180,urcrnrlon=180, resolution='c')
ev_file = open(os.path.join(os.getcwd(), 'quake_req.txt'), 'r')
ev_add = ev_file.read().split('\n')[:-1]
select = open(os.path.join(os.getcwd(), input['file'] + '.dat'), 'w')
select.close()
for k in range(0, len(ev_add)):
'''
select = open(os.path.join(os.getcwd(), \
input['file'] + '-' + ev_add[k].split('/')[-1] + \
'.dat'), 'w')
'''
(quake_d, quake_t) = read_quake(ev_add[k])
list_sta = glob.glob(os.path.join(ev_add[k], 'BH', \
input['identity']))
for i in range(0, len(list_sta)):
try:
st = read(list_sta[i])
print '***************************************'
print str(i) + '/' + str(len(list_sta)) + ' -- ' + \
str(k) + '/' + str(len(ev_add))
print list_sta[i].split('/')[-1]
info_sac = st[0].stats['sac']
if input['all_sta'] == None:
dist = locations2degrees(lat1 = quake_d['lat'], \
long1 = quake_d['lon'], lat2 = info_sac['stla'], \
long2 = info_sac['stlo'])
tt = getTravelTimes(delta=dist, depth=quake_d['dp'], \
model=input['model'])
for m in range(0, len(tt)):
if tt[m]['phase_name'] in input['phase']:
try:
print '--------------------'
print list_sta[i].split('/')[-1] + ' has ' + \
tt[m]['phase_name'] + ' phase'
if input['freq'] != None:
st[0].decimate(int(round(\
st[0].stats['sampling_rate'])/input['freq']), \
no_filter=False)
if st[0].stats['sampling_rate'] != input['freq']:
print list_sta[i].split('/')[-1]
print st[0].stats['sampling_rate']
print '------------------------------------------'
'''
np_evt = round((events[0]['datetime'] - st[0].stats['starttime'])*st[0].stats['sampling_rate'])
np_pha = np_evt + round(tt[m]['time']*st[0].stats['sampling_rate'])
select = open(Address_events + '/' + events[l]['event_id'] + '/IRIS/info/' + name_select, 'a')
'''
if tt[m]['phase_name'] != 'Pdiff':
lat_1 = str(quake_d['lat'])
lon_1 = str(quake_d['lon'])
lat_2 = str(info_sac['stla'])
lon_2 = str(info_sac['stlo'])
elif tt[m]['phase_name'] == 'Pdiff':
dist_limit = 97.0
num_gcp = 1000
gcp = map_proj.gcpoints(quake_d['lon'], \
quake_d['lat'], info_sac['stlo'], \
info_sac['stla'], num_gcp)
if dist >= dist_limit:
diff_dist = dist - dist_limit
req_gcp = diff_dist*(float(num_gcp)/dist)
req_gcp = round(req_gcp)/2
mid_p = len(gcp[0])/2
#before = int(mid_p - req_gcp)
#after = int(mid_p + req_gcp)
before = mid_p - int(2.0 * len(gcp[0])/dist)
after = mid_p + int(2.0 * len(gcp[0])/dist)
x_p, y_p = gcp
lat_1 = y_p[before]
lat_2 = y_p[after]
lon_1 = x_p[before]
lon_2 = x_p[after]
ph_info = tt[m]['phase_name'] + ',' + \
str(dist) + ',' + \
str(tt[m]['time']) + ',' + \
str(st[0].stats['sampling_rate']) + ',' + \
st[0].stats['network'] + ',' + \
st[0].stats['station'] + \
',' + st[0].stats['location'] + ',' + \
st[0].stats['channel'] + ',' + \
str(info_sac['stla']) + ',' + \
str(info_sac['stlo']) + ',' + \
str(info_sac['stdp']) + ',' + \
str(info_sac['stel']) + ',' + \
str(quake_d['lat']) + ',' + \
str(quake_d['lon']) + ',' + \
str(quake_d['dp']) + ',' + \
'-----' + ',' + \
str(lat_1) + ',' + \
str(lon_1) + ',' + \
str(lat_2) + ',' + \
str(lon_2) + ',' + \
'-----' + ',' + \
ev_add[k].split('/')[-1] + ',' + \
list_sta[i] + '\n'
#select = open(os.path.join(os.getcwd(), \
# input['file'] + '-' + \
# ev_add[k].split('/')[-1] + '.dat'), 'a')
select = open(os.path.join(os.getcwd(), \
input['file'] + '.dat'), 'a')
select.writelines(ph_info)
select.close()
except Exception, e:
print e
elif input['all_sta'] != None:
ph_info = 'NA' + ',' + 'NA' + ',' + \
'NA' + ',' + \
str(st[0].stats['sampling_rate']) + ',' + \
st[0].stats['network'] + ',' + st[0].stats['station'] + \
',' + st[0].stats['location'] + ',' + \
st[0].stats['channel'] + ',' + \
str(info_sac['stla']) + ',' + \
str(info_sac['stlo']) + ',' + \
str(info_sac['stdp']) + ',' + \
str(info_sac['stel']) + ',' + \
str(quake_d['lat']) + ',' + str(quake_d['lon']) + ',' + \
str(quake_d['dp']) + ',' + \
ev_add[k].split('/')[-1] + ',' + \
list_sta[i] + '\n'
'''
select = open(os.path.join(os.getcwd(), \
input['file'] + '-' + \
ev_add[k].split('/')[-1] + '.dat'), 'a')
'''
select = open(os.path.join(os.getcwd(), \
input['file'] + '.dat'), 'a')
select.writelines(ph_info)
select.close()
except Exception, e:
print e
pass
def AXISEM_Phase():
"""
Create STATIONS file as an input for AXISEM
"""
global input
events, address_events = quake_info(input['address'], 'info')
for i in range(0, len(events)):
sta_ev_select = []
sta_ev = read_station_event(address_events[i])
for j in range(0, len(sta_ev[i])):
dist = locations2degrees(lat1 = float(sta_ev[i][j][9]), \
long1 = float(sta_ev[i][j][10]), lat2 = float(sta_ev[i][j][4]), \
long2 = float(sta_ev[i][j][5]))
tt = getTravelTimes(delta=dist, depth=float(sta_ev[i][j][11]), \
model=input['model'])
sta_ev[i][j][8] = sta_ev[i][j][0] + '_' + sta_ev[i][j][1]
for m in range(0, len(tt)):
if tt[m]['phase_name'] in input['phase']:
sta_ev_select.append(sta_ev[i][j])
sta_ev_req = list(unique_items(sta_ev_select))
if os.path.isfile(os.path.join(address_events[i],\
'info', 'receivers.dat')):
os.remove(os.path.join(address_events[i],\
'info', 'receivers.dat'))
if os.path.isfile(os.path.join(address_events[i],\
'info', 'STATIONS')):
os.remove(os.path.join(address_events[i],\
'info', 'STATIONS'))
receivers_file = open(os.path.join(address_events[i],\
'info', 'receivers.dat'), 'a+')
receivers_file.writelines(str(len(sta_ev_req)) + '\n')
for j in range(0, len(sta_ev_req)):
STATIONS_file = open(os.path.join(address_events[i],\
'info', 'STATIONS'), 'a+')
receivers_file = open(os.path.join(address_events[i],\
'info', 'receivers.dat'), 'a+')
STATIONS_file.writelines(sta_ev_req[j][1] + \
' '*(5 - len('%s' % sta_ev_req[j][0])) + '%s' \
% sta_ev_req[j][0] + \
' '*(9 - len('%.2f' % float(sta_ev_req[j][4]))) + '%.2f' \
% float(sta_ev_req[j][4]) + \
' '*(9 - len('%.2f' % float(sta_ev_req[j][5]))) + '%.2f' \
% float(sta_ev_req[j][5]) + \
' '*(15 - len('0.0000000E+00')) + \
'0.0000000E+00' + \
' '*(15 - len('0.0000000E+00')) + \
'0.0000000E+00' + '\n')
receivers_file.writelines( \
str(round(90.0 - float(sta_ev_req[j][4]), 1)) + ' ' + \
str(float(sta_ev_req[j][5])) + \
'\n')
def AXISEM_Phase():
"""
Create STATIONS file as an input for AXISEM
"""
global input
events, address_events = quake_info(input['address'], 'info')
for i in range(0, len(events)):
sta_ev_select = []
sta_ev = read_station_event(address_events[i])
for j in range(0, len(sta_ev[i])):
dist = locations2degrees(lat1 = float(sta_ev[i][j][9]), \
long1 = float(sta_ev[i][j][10]), lat2 = float(sta_ev[i][j][4]), \
long2 = float(sta_ev[i][j][5]))
tt = getTravelTimes(delta=dist, depth=float(sta_ev[i][j][11]), \
model=input['model'])
sta_ev[i][j][8] = sta_ev[i][j][0] + '_' + sta_ev[i][j][1]
for m in range(0, len(tt)):
if tt[m]['phase_name'] in input['phase']:
sta_ev_select.append(sta_ev[i][j])
sta_ev_req = list(unique_items(sta_ev_select))
if os.path.isfile(os.path.join(address_events[i],\
'info', 'receivers.dat')):
os.remove(os.path.join(address_events[i],\
'info', 'receivers.dat'))
if os.path.isfile(os.path.join(address_events[i],\
'info', 'STATIONS')):
os.remove(os.path.join(address_events[i],\
'info', 'STATIONS'))
receivers_file = open(os.path.join(address_events[i],\
'info', 'receivers.dat'), 'a+')
receivers_file.writelines(str(len(sta_ev_req)) + '\n')
for j in range(0, len(sta_ev_req)):
STATIONS_file = open(os.path.join(address_events[i],\
'info', 'STATIONS'), 'a+')
receivers_file = open(os.path.join(address_events[i],\
'info', 'receivers.dat'), 'a+')
STATIONS_file.writelines(sta_ev_req[j][1] + \
' '*(5 - len('%s' % sta_ev_req[j][0])) + '%s' \
% sta_ev_req[j][0] + \
' '*(9 - len('%.2f' % float(sta_ev_req[j][4]))) + '%.2f' \
% float(sta_ev_req[j][4]) + \
' '*(9 - len('%.2f' % float(sta_ev_req[j][5]))) + '%.2f' \
% float(sta_ev_req[j][5]) + \
' '*(15 - len('0.0000000E+00')) + \
'0.0000000E+00' + \
' '*(15 - len('0.0000000E+00')) + \
'0.0000000E+00' + '\n')
receivers_file.writelines( \
str(round(90.0 - float(sta_ev_req[j][4]), 1)) + ' ' + \
str(float(sta_ev_req[j][5])) + \
'\n')
def cc_core(ls_first, ls_second, identity_all, max_ts, print_sta):
"""
Perform the main part of the cross correlation and creating
the cc.txt file
"""
global input
try:
cc_open = open('./cc.txt', 'a')
tr1 = read(ls_first)[0]
if input['phase'] != 'N':
evsta_dist = util.locations2degrees(lat1 = tr1.stats.sac.evla, \
long1 = tr1.stats.sac.evlo, lat2 = tr1.stats.sac.stla, \
long2 = tr1.stats.sac.stlo)
taup_tt = taup.getTravelTimes(delta = evsta_dist, depth = tr1.stats.sac.evdp)
phase_exist = 'N'
for tt_item in taup_tt:
if tt_item['phase_name'] == input['phase']:
print 'Requested phase:'
print input['phase']
print '------'
print tt_item['phase_name']
print 'exists in the waveform!'
print '-----------------------'
t_phase = tt_item['time']
phase_exist = 'Y'
break
if input['phase'] == 'N' or (input['phase'] != 'N' and phase_exist == 'Y'):
# identity of the current waveform
identity = tr1.stats.network + '.' + tr1.stats.station + '.' + \
tr1.stats.location + '.' + tr1.stats.channel
# Keep the current identity in a new variable
id_name = identity
try:
tr2 = read(os.path.join(input['second_path'], identity))[0]
except Exception, error:
# if it is not possible to read the identity in the second path
# then change the network part of the identity based on
# correction unit
identity = input['corr_unit'] + '.' + tr1.stats.station + '.' + \
tr1.stats.location + '.' + tr1.stats.channel
tr2 = read(os.path.join(input['second_path'], identity))[0]
if input['resample'] != 'N':
print 'WARNING: you are using resample!!!'
tr1.resample(input['resample'])
tr2.resample(input['resample'])
if input['tw'] == 'Y':
t_cut_1 = tr1.stats.starttime + t_phase - input['preset']
t_cut_2 = tr1.stats.starttime + t_phase + input['offset']
tr1.trim(starttime = t_cut_1, endtime = t_cut_2)
t_cut_1 = tr2.stats.starttime + t_phase - input['preset']
t_cut_2 = tr2.stats.starttime + t_phase + input['offset']
tr2.trim(starttime = t_cut_1, endtime = t_cut_2)
if input['hlfilter'] == 'Y':
tr1.filter('lowpass', freq=input['hfreq'], corners=2)
tr2.filter('lowpass', freq=input['hfreq'], corners=2)
tr1.filter('highpass', freq=input['lfreq'], corners=2)
tr2.filter('highpass', freq=input['lfreq'], corners=2)
# normalization of all three waveforms to the
# max(max(tr1), max(tr2), max(tr3)) to keep the scales
#maxi = max(abs(tr1.data).max(), abs(tr2.data).max(), abs(tr3.data).max())
'''
maxi = max(abs(tr1.data).max(), abs(tr2.data).max())
tr1_data = tr1.data/abs(maxi)
tr2_data = tr2.data/abs(maxi)
tr3_data = tr3.data/abs(maxi)
'''
tr1.data = tr1.data/abs(max(tr1.data))
tr2.data = tr2.data/abs(max(tr2.data))
cc_np = tr1.stats.sampling_rate * max_ts
np_shift, coeff = cross_correlation.xcorr(tr1, tr2, int(cc_np))
t_shift = float(np_shift)/tr1.stats.sampling_rate
# scale_str shows whether the scale of the waveforms are the same or not
# if scale_str = 'Y' then the scale is correct.
scale_str = 'Y'
if abs(tr1.data).max() > 2.0 * abs(tr2.data).max():
label_tr1 = ls_first.split('/')[-2]
label_tr2 = ls_second[0].split('/')[-2]
print '#####################################################'
print "Scale is not correct! " + label_tr1 + '>' + label_tr2
print '#####################################################'
scale_str = 'N'
elif abs(tr2.data).max() >= 2.0 * abs(tr1.data).max():
label_tr1 = ls_first.split('/')[-2]
label_tr2 = ls_second[0].split('/')[-2]
print '#####################################################'
print "Scale is not correct! " + label_tr2 + '>' + label_tr1
print '#####################################################'
scale_str = 'N'
if not str(coeff) == 'nan':
cc_open.writelines(id_name + ',' + str(round(coeff, 4)) + ',' + str(t_shift) + \
',' + scale_str + ',' + '\n')
print "Cross Correlation:"
print id_name
print "Shift: " + str(t_shift)
print "Coefficient: " + str(coeff)
print print_sta
print '------------------'
cc_open.close()
cc_open.close()
except Exception, error:
print '##################'
print error
print '##################'
ax = fig.axes[0]
xmin, xmax = ax.get_xlim()
data = {}
min_degree = round(xmin)
max_degree = round(xmax)
npoints = max_degree - min_degree + 1
degrees = np.linspace(min_degree, max_degree, npoints)
# Loop over all degrees.
for degree in degrees:
with warnings.catch_warnings(record=True):
warnings.simplefilter('always')
tt = getTravelTimes(degree, depth, model, phase_list=phases)
# Mirror if necessary.
if degree > 180:
degree = 180 - (degree - 180)
for item in tt:
phase = item['phase_name']
if phase not in data:
data[phase] = [[], []]
data[phase][1].append(item['time'])
data[phase][0].append(degree)
# Plot and some formatting.
for key, value in data.items():
plt.plot(value[0], value[1], '.', label=key)
plt.grid()
plt.xlabel('Distance (degrees)')
plt.ylabel('Time (minutes)')
def processing(self):
from telef import *
from obspy.core.util.geodetics import gps2DistAzimuth, kilometer2degrees
from obspy.taup.taup import getTravelTimes
filename_out, ok = QtGui.QInputDialog.getText(QtGui.QWidget(),"Arquivo de saida", "Entre com o nome: ")
output = open(filename_out,'w')
oheader1 = ['Estacao', 'Dia', 'H.Chegada', 'H. Origem','Latitude', ' Longitude', 'H', ' Mag', 'Tipo','Dist. Az.', 'Residuo','Regiao'.ljust(30)]
oheader2 = [' ',' ', ' hh:mm:ss ','hh:mm:ss ', ' (graus)', ' (graus) ', ' km', ' ',' ',' (graus)', ' (s) ',' ' ]
output.write(self.lines_obsis[0][1:6])
output.write('\n\n\n')
line=oheader1
output.write('%7s %2s %7s %6s %6s %7s %3s %4s %2s %4s %3s %6s\n'%(line[0],line[1],line[2],line[3],line[4],line[5],line[6],
line[7],line[8],line[9],line[10],line[11]))
line=oheader2
output.write('%7s %2s %7s %6s %6s %7s %3s %4s %2s %4s %3s %6s\n'%(line[0],line[1],line[2],line[3],line[4],line[5],line[6],
line[7],line[8],line[9],line[10],line[11]))
output.write('\n')
cnt=0; lres=[]; lcnt=[]; elats=[]; elons=[]; emags=[]
stlats=[]; stlons=[]; edeps=[]
lines_usgs = open(self.filename_usgs, 'r').readlines()
for line_obsis in self.lines_obsis[1:]:
hdr_obsis=self.lines_obsis[0]
iOBSIS = getObSis(line_obsis,hdr_obsis)
coords = getCoord(self.filename_coord, iOBSIS[0])
stlats.append(coords[0])
stlons.append(coords[1])
for line in lines_usgs[1:]:
l = line.split(',')
otime = UTCDateTime(l[0])
ootime = l[0]
if otime < iOBSIS[6]:
elat = float(l[1])
elon = float(l[2])
if l[3] == "":
dep = 0.0
else:
dep = float(l[3])
mag = float(l[4])
magType = l[5]
net = l[10]
elats.append(elat)
elons.append(elon)
emags.append(mag)
edeps.append(dep)
place = [l[13],l[14]]
delta = gps2DistAzimuth(elat,elon,coords[0],coords[1])[0]
delta = kilometer2degrees(delta/1000.)
tt = getTravelTimes(delta, dep, model='iasp91')
text = "FIRST ARRIVAL\n"
first = tt[0]
if first['phase_name'] == 'P':
text += "%s: %.1f\n" % (first['phase_name'],first['time'])
arriv = UTCDateTime(otime) + first['time']
res = arriv-iOBSIS[6]
cnt += 1
lcnt.append(cnt)
lres.append(res)
hc=str(iOBSIS[2]).zfill(2)+':'+str(iOBSIS[3]).zfill(2)+':'+str(iOBSIS[4]).zfill(2)
ho=str(otime.time)
delta=str(delta)
res=str(res)
final = [iOBSIS[0],str(iOBSIS[1]).zfill(2),hc,ho[:10].zfill(8),str(elat).zfill(8),str(elon).zfill(9),str(dep).ljust(6),str(mag).ljust(3),str(magType).ljust(3),str(delta)[:5],res[:8].ljust(8),str(place).ljust(50)]
line=final
output.write('%7s %2s %7s %6s %6s %7s %3s %4s %2s %4s %3s %6s\n'%(line[0],line[1],line[2],line[3],line[4],line[5],line[6],line[7],line[8],line[9],line[10],line[11]))
temp = [elat, elon, mag, str(iOBSIS[0]), coords[0], coords[1]]
break
output.close()
ares = np.array(lres)
acnt = np.array(lcnt)
graphics2.scatter(acnt,ares)
if self.mapfull.checkState() == QtCore.Qt.Checked:
graphics2.plt_map_marble(elats,elons,emags,edeps,stlats,stlons)
else:
graphics2.plt_map(elats,elons,emags,edeps,stlats,stlons)
def receiver_functions(self,directory,nf=1,type='earth_model',migrate='False',equator='True'):
import seismograms as s
import receiver_functions as rf
import matplotlib.pylab as plt
from obspy.taup.taup import getTravelTimes
from obspy.core.util.geodetics import gps2DistAzimuth
from obspy.core.util.geodetics import kilometer2degrees
rec_lon = np.zeros(self.n_recs)
for i in range(0,self.n_recs):
a = s.ses3d_seismogram()
a.read(directory,self.recs[i],integrate=True)
b = rf.receiver_function(a)
#TODO for plotting fills
#where = [False]*(len(b.time))
if type == 'toy_model' :
prf = b.get_P_rf(-10.0,60.0,0.1,type='toy_model')
elif type == 'earth_model' :
prf = b.get_P_rf(-100.0,100.0,0.1,rotation_method='LQT',type='earth_model',decon_type='damped_lstsq')
rec_lon[i] = b.ses3d_seismogram.ry
#normalize max amplitude to equal nf
scale = nf/np.amax(b.prf)
#align on P410s arrival (i.e., moveout correction)
ref_delta = 45
#ref_slowness = 7.7595 #slowness for P wave at 45 degrees
#ref_d_slowness = 0.1042 #P - P410s slowness at 45 degrees
ref_slowness = 7.7595
ref_d_slowness = 0.2088
tt = getTravelTimes(delta=b.delta_deg,depth=b.ses3d_seismogram.sz/1000.0,
model='ak135',phase_list=['P','P660s'])
slowness_p = tt[0]['dT/dD']
slowness_p410s = tt[1]['dT/dD']
delta_slowness = slowness_p - slowness_p410s
d_delta_slowness = ref_d_slowness - delta_slowness
time_shift = b.delta_deg * d_delta_slowness
index_shift = int(time_shift/b.ses3d_seismogram.dt)
#print "delta_slowness = ", delta_slowness
#print "time_shift, index_shift = ", time_shift, index_shift
if migrate == 'False':
#If you want it aligned on P660s arrivval:
b.prf = np.roll(b.prf,index_shift)
if migrate =='True':
value,dep_m = b.migrate_1d()
plt.plot(value*scale+b.ses3d_seismogram.ry,dep_m,'k')
#plot
rf_scaled = (b.prf*scale)+(b.ses3d_seismogram.ry)
where = rf_scaled > b.ses3d_seismogram.ry
plt.figure(1)
plt.plot(rf_scaled, b.time,'k')
plt.fill_betweenx(b.time,b.ses3d_seismogram.ry,rf_scaled,where,color='k')
plt.gca().invert_yaxis()
plt.xlabel('distance (degrees)')
plt.ylabel('time after P(s)')
plt.ylim([0,100])
plt.gca().invert_yaxis()
plt.show()
def on_stations_listWidget_currentItemChanged(self, current, previous):
if current is None:
return
self._reset_all_plots()
try:
wave = self.comm.query.get_matching_waveforms(
self.current_event, self.current_iteration,
self.current_station)
except Exception as e:
for component in ["Z", "N", "E"]:
plot_widget = getattr(self.ui, "%s_graph" % component.lower())
plot_widget.addItem(
pg.TextItem(text=str(e),
anchor=(0.5, 0.5),
color=(200, 0, 0)))
return
event = self.comm.events.get(self.current_event)
great_circle_distance = locations2degrees(
event["latitude"], event["longitude"],
wave.coordinates["latitude"], wave.coordinates["longitude"])
tts = getTravelTimes(great_circle_distance,
event["depth_in_km"],
model="ak135")
windows_for_station = \
self.current_window_manager.get_windows_for_station(
self.current_station)
for component in ["Z", "N", "E"]:
plot_widget = getattr(self.ui, "%s_graph" % component.lower())
data_tr = [
tr for tr in wave.data
if tr.stats.channel[-1].upper() == component
]
if data_tr:
tr = data_tr[0]
plot_widget.data_id = tr.id
times = tr.times()
plot_widget.plot(times, tr.data, pen="k")
else:
plot_widget.data_id = None
synth_tr = [
_i for _i in wave.synthetics
if _i.stats.channel[-1].upper() == component
]
if synth_tr:
tr = synth_tr[0]
times = tr.times()
plot_widget.plot(
times,
tr.data,
pen="r",
)
if data_tr or synth_tr:
for tt in tts:
if tt["time"] >= times[-1]:
continue
if tt["phase_name"][0].lower() == "p":
pen = "#008c2866"
else:
pen = "#95000066"
plot_widget.addLine(x=tt["time"], pen=pen, z=-10)
plot_widget.autoRange()
window = [
_i for _i in windows_for_station
if _i.channel_id[-1].upper() == component
]
if window:
plot_widget.windows = window[0]
for win in window[0].windows:
WindowLinearRegionItem(win, event, parent=plot_widget)
self._update_raypath(wave.coordinates)
for k in range(len(earthquakes)):
event=earthquakes[k].split('/')[-1].split('.')[0]
print event
#Get hypocenter
hypo=genfromtxt(path+'event_info/'+event+'.hypo')
#Read station data
stanames=genfromtxt(earthquakes[k],usecols=0,dtype='S')
station_coords=genfromtxt(earthquakes[k],usecols=[1,2])
#initalize
tp=zeros(len(stanames))
delta=zeros(len(stanames))
for j in range(len(stanames)):
#Get event-station distance in degrees
delta[j]=locations2degrees(station_coords[j,1],station_coords[j,0],hypo[2],hypo[1])
#Get p-time to site
tt=getTravelTimes(delta[j],hypo[3])
tp[j]=float64(tt[0]['time'])
#Write to file
f=open(path+'travel_times/'+event+'.tt','w')
for j in range(len(tp)):
line='%s\t%8.2f\n' %(stanames[j],tp[j])
f.write(line)
f.close()
#Plot PGD computation as a function fo distance
if plot_pgd_dist:
for k in [0,1,2,3,4,5,6]:#range(len(earthquakes)):
event=earthquakes[k].split('/')[-1].split('.')[0]
print event
#Get stations and p-times
sta_epi = float(sta_read[i][-2])
calc_xcorr = float(sta_read[i][2])
calc_dt = float(sta_read[i][5])
# read the green's function
grf_tr = read(os.path.join(synthetic_add, ev_name, 'SAC_realName', 'grf.'+sta_name))[0]
#event_1:
#if not grf_tr.stats.station in ["109C", "AAK", "AAK", "ABKAR", "ACCN", "ADO", "AGMN", "AGRB", "AKGG", "AKUT", "ANMO", "ANWB", "BERG", "BESE", "BLO", "BLOW", "BMN", "BOAB", "BZN", "CCRK", "CMB", "DBO", "DLMT", "EUNU", "FACU", "FFD", "HDC", "HIA", "JSC", "LPAZ", "MGAN", "OBIP", "SC58", "SRU", "STD"]: continue
#event_2:
#if not grf_tr.stats.station in ["109C", "ACCN", "ACSO", "ADO", "ANMO", "ASCN", "ATE", "AUL", "BERG", "BESE", "BLO", "BLOW", "BMN", "BZN", "CCRK", "CMB", "CRAG", "DBIC", "DLMT", "DRLN", "DYA", "ESPZ", "FACU", "FFD", "GGNV", "LPW", "MTE", "PACT", "PESTR", "PPCWF", "PPTF", "RTC", "SC58", "SCO", "SRU", "STD"]: continue
#if not grf_tr.stats.station in ["AAK", "AAK", "AKTO", "ANTO", "APE", "AQU", "HGN", "IPM", "KHC", "LSA", "MUN", "PSI", "SENIN", "SSB", "VNDA"]: continue
#if grf_tr.stats.network in passed_nets: continue
if min_epi <= grf_tr.stats.sac.gcarc <= max_epi:
try:
tt_list = taup.getTravelTimes(grf_tr.stats.sac.gcarc, grf_tr.stats.sac.evdp, model='iasp91')
flag = 'searching'
for j in range(len(tt_list)):
if tt_list[j]['phase_name'] == phase:
phase_time = tt_list[j]['time']
#print '---------'
#print phase + ' is found and the arrival time:'
#print tt_list[j]['time']
#print '---------'
flag = 'found'
break
if flag == 'searching':
print 'Could not find ' + phase + ' in: ' + str(grf_tr.stats.sac.gcarc)
continue
sta_name_split = sta_name.split('.')
real_tr = read(os.path.join(real_add, ev_name, 'BH', 'dis.' + sta_name_split[1] + '.' +
def receiver_functions(self,
directory,
nf=1,
type='earth_model',
migrate='False',
equator='True'):
import seismograms as s
import receiver_functions as rf
import matplotlib.pylab as plt
from obspy.taup.taup import getTravelTimes
from obspy.core.util.geodetics import gps2DistAzimuth
from obspy.core.util.geodetics import kilometer2degrees
rec_lon = np.zeros(self.n_recs)
for i in range(0, self.n_recs):
a = s.ses3d_seismogram()
a.read(directory, self.recs[i], integrate=True)
b = rf.receiver_function(a)
#TODO for plotting fills
#where = [False]*(len(b.time))
if type == 'toy_model':
prf = b.get_P_rf(-10.0, 60.0, 0.1, type='toy_model')
elif type == 'earth_model':
prf = b.get_P_rf(-100.0,
100.0,
0.1,
rotation_method='LQT',
type='earth_model',
decon_type='damped_lstsq')
rec_lon[i] = b.ses3d_seismogram.ry
#normalize max amplitude to equal nf
scale = nf / np.amax(b.prf)
#align on P410s arrival (i.e., moveout correction)
ref_delta = 45
#ref_slowness = 7.7595 #slowness for P wave at 45 degrees
#ref_d_slowness = 0.1042 #P - P410s slowness at 45 degrees
ref_slowness = 7.7595
ref_d_slowness = 0.2088
tt = getTravelTimes(delta=b.delta_deg,
depth=b.ses3d_seismogram.sz / 1000.0,
model='ak135',
phase_list=['P', 'P660s'])
slowness_p = tt[0]['dT/dD']
slowness_p410s = tt[1]['dT/dD']
delta_slowness = slowness_p - slowness_p410s
d_delta_slowness = ref_d_slowness - delta_slowness
time_shift = b.delta_deg * d_delta_slowness
index_shift = int(time_shift / b.ses3d_seismogram.dt)
#print "delta_slowness = ", delta_slowness
#print "time_shift, index_shift = ", time_shift, index_shift
if migrate == 'False':
#If you want it aligned on P660s arrivval:
b.prf = np.roll(b.prf, index_shift)
if migrate == 'True':
value, dep_m = b.migrate_1d()
plt.plot(value * scale + b.ses3d_seismogram.ry, dep_m, 'k')
#plot
rf_scaled = (b.prf * scale) + (b.ses3d_seismogram.ry)
where = rf_scaled > b.ses3d_seismogram.ry
plt.figure(1)
plt.plot(rf_scaled, b.time, 'k')
plt.fill_betweenx(b.time,
b.ses3d_seismogram.ry,
rf_scaled,
where,
color='k')
plt.gca().invert_yaxis()
plt.xlabel('distance (degrees)')
plt.ylabel('time after P(s)')
plt.ylim([0, 100])
plt.gca().invert_yaxis()
plt.show()
def main(argv=sys.argv):
#Earth's parameters
#~ beta = 4.e3 #m/s
#~ rho = 3.e3 #kg/m^3
#~ mu = rho*beta*beta
PLotSt = ["IU.TRQA.00.LHZ",
"IU.LVC.00.LHZ",
"II.NNA.00.LHZ",
"IU.RAR.00.LHZ"]
#PlotSubf = [143, 133, 123, 113, 103, 93,
# 83, 73, 63, 53]
PlotSubf = [6,3]
#Set rup_vel = 0 to have a point source solution
RupVel = 2.1 #Chilean eq from Lay et al
t_h = 10. # Half duration for each sf
noiselevel = 0.0# L1 norm level of noise
mu =40e9
#W-Phase filter
corners = 4.
fmin = 0.001
fmax = 0.005
### Data from Chilean 2010 EQ (Same as W phase inv.)
strike = 18.
dip = 18.
rake = 104. # 109.
rakeA = rake + 45.
rakeB = rake - 45.
### Fault's grid parameters
nsx = 21 #Number of sf along strike
nsy = 11 #Number of sf along dip
flen = 600. #Fault's longitude [km] along strike
fwid = 300. #Fault's longitude [km] along dip
direc = 0 #Directivity 0 = bilateral
Min_h = 10. #Min depth of the fault
### Derivated parameters:
nsf = nsx*nsy
sflen = flen/float(nsx)
sfwid = fwid/float(nsy)
swp = [1, 0, 2] # useful to swap (lat,lon, depth)
mindist = flen*fwid # minimun dist to the hypcen (initializing)
###Chessboard
#weight = np.load("RealSol.npy")
weight = np.zeros(nsf)
weight[::2] = 1
#weight[::2] = 1
#~ weight[10]=15
#~ weight[5001]=10
#~ weight[3201]=2
## Setting dirs and reading files.
GFdir = "/home/roberto/data/GFS/"
workdir = os.path.abspath(".")+"/"
datadir = workdir + "DATA/"
tracesfilename = workdir + "goodtraces.dat"
tracesdir = workdir + "WPtraces/"
try:
reqfilename = glob.glob(workdir + '*.syn.req')[0]
except IndexError:
print "There is not *.syn.req file in the dir"
sys.exit()
basename = reqfilename.split("/")[-1][:-4]
if not os.path.exists(tracesfilename):
print tracesfilename, "does not exist."
exit()
if not os.path.exists(datadir):
os.makedirs(datadir)
if not os.path.exists(tracesdir):
os.makedirs(tracesdir)
tracesfile = open(tracesfilename)
reqfile = open(reqfilename)
trlist = readtraces(tracesfile)
eqdata = readreq(reqfile)
tracesfile.close()
reqfile.close()
####Hypocentre from
### http://earthquake.usgs.gov/earthquakes/eqinthenews/2010/us2010tfan/
cmteplat = -35.91#-35.85#-36.03#-35.83
cmteplon = -72.73#-72.72#-72.83# -72.67
cmtepdepth= 35.
eq_hyp = (cmteplat,cmteplon,cmtepdepth)
############
# Defining the sf system
grid, sblt = fault_grid('CL-2010',cmteplat,cmteplon,
cmtepdepth, direc,
Min_h, strike, dip, rake, flen,fwid ,nsx,nsy,
Verbose=False,ffi_io=True,gmt_io=True)
print ('CL-2010',cmteplat,cmteplon,
cmtepdepth, direc,
Min_h, strike, dip, rake, flen,fwid ,nsx,nsy)
print grid[0][1]
#sys.exit()
#This calculation is inside of the loop
#~ NP = [strike, dip, rake]
#~ M = np.array(NodalPlanetoMT(NP))
#~ Mp = np.sum(M**2)/np.sqrt(2)
#############################################################################
######Determining the sf closest to the hypocentre:
min_Dist_hyp_subf = flen *fwid
for subf in range(nsf):
sblat = grid[subf][1]
sblon = grid[subf][0]
sbdepth = grid[subf][2]
sf_hyp = (sblat,sblon, sbdepth)
Dist_hyp_subf = hypo2dist(eq_hyp,sf_hyp)
if Dist_hyp_subf < min_Dist_hyp_subf:
min_Dist_hyp_subf = Dist_hyp_subf
min_sb_hyp = sf_hyp
hyp_subf = subf
####Determining trimming times:
test_tr = read(GFdir + "H003.5/PP/GF.0001.SY.LHZ.SAC")[0]
t0 = test_tr.stats.starttime
TrimmingTimes = {} # Min. Distace from the fault to each station.
A =0
for trid in trlist:
metafile = workdir + "DATA/" + "META." + trid + ".xml"
META = DU.getMetadataFromXML(metafile)[trid]
stlat = META['latitude']
stlon = META['longitude']
dist = locations2degrees(min_sb_hyp[0],min_sb_hyp[1],\
stlat,stlon)
parrivaltime = getTravelTimes(dist,min_sb_hyp[2])[0]['time']
ta = t0 + parrivaltime
tb = ta + round(15.*dist)
TrimmingTimes[trid] = (ta, tb)
###########################
DIST = []
# Ordering the stations in terms of distance
for trid in trlist:
metafile = workdir + "DATA/" + "META." + trid + ".xml"
META = DU.getMetadataFromXML(metafile)[trid]
lat = META['latitude']
lon = META['longitude']
trdist = locations2degrees(cmteplat,
cmteplon,lat,lon)
DIST.append(trdist)
DistIndex = lstargsort(DIST)
trlist = [trlist[i] for i in DistIndex]
stdistribution = StDistandAzi(trlist, eq_hyp , workdir + "DATA/")
StDistributionPlot(stdistribution)
#exit()
#Main loop
for subf in range(nsf):
print subf
sflat = grid[subf][1]
sflon = grid[subf][0]
sfdepth = grid[subf][2]
#~ strike = grid[subf][3] #+ 360.
#~ dip = grid[subf][4]
#~ rake = grid[subf][5] #
NP = [strike, dip, rake]
NPA = [strike, dip, rakeA]
NPB = [strike, dip, rakeB]
M = np.array(NodalPlanetoMT(NP))
MA = np.array(NodalPlanetoMT(NPA))
MB = np.array(NodalPlanetoMT(NPB))
#Time delay is calculated as the time in which
#the rupture reach the subfault
sf_hyp = (sflat, sflon, sfdepth)
Dist_ep_subf = hypo2dist(eq_hyp,sf_hyp)
if Dist_ep_subf < mindist:
mindist = Dist_ep_subf
minsubf = subf
if RupVel == 0:
t_d = eqdata['time_shift']
else:
t_d = round(Dist_ep_subf/RupVel) #-59.
print sflat, sflon, sfdepth
# Looking for the best depth dir:
depth = []
depthdir = []
for file in os.listdir(GFdir):
if file[-2:] == ".5":
depthdir.append(file)
depth.append(float(file[1:-2]))
BestDirIndex = np.argsort(abs(sfdepth\
- np.array(depth)))[0]
hdir = GFdir + depthdir[BestDirIndex] + "/"
###
SYN = np.array([])
SYNA = np.array([])
SYNB = np.array([])
for trid in trlist:
metafile = workdir + "DATA/" + "META." + trid + ".xml"
META = DU.getMetadataFromXML(metafile)[trid]
lat = META['latitude']
lon = META['longitude']
#Subfault loop
#GFs Selection:
##Change to folloing loop
dist = locations2degrees(sflat,sflon,lat,lon)
azi = -np.pi/180.*gps2DistAzimuth(lat,lon,
sflat,sflon)[2]
trPPsy, trRRsy, trRTsy, trTTsy = \
GFSelectZ(hdir,dist)
trROT = MTrotationZ(azi, trPPsy, trRRsy, trRTsy, trTTsy)
orig = trROT[0].stats.starttime
dt = trROT[0].stats.delta
trianglen = 2.*int(t_h/dt)-1.
FirstValid = int(trianglen/2.) + 1 # to delete
window = triang(trianglen)
window /= np.sum(window)
#window = np.array([1.])
parrivaltime = getTravelTimes(dist,sfdepth)[0]['time']
t1 = TrimmingTimes[trid][0] - t_d
t2 = TrimmingTimes[trid][1] - t_d
for trR in trROT:
trR.data *= 10.**-21 ## To get M in Nm
trR.data -= trR.data[0]
AUX1 = len(trR)
trR.data = convolve(trR.data,window,mode='valid')
AUX2 = len(trR)
mean = np.mean(np.hstack((trR.data[0]*np.ones(FirstValid),\
trR.data[:60./trR.stats.delta*1.-FirstValid+1])))
#mean = np.mean(trR.data[:60])
trR.data -= mean
trR.data = bp.bandpassfilter(trR.data,len(trR), trR.stats.delta,\
corners , 1 , fmin, fmax)
t_l = dt*0.5*(AUX1 - AUX2)
trR.trim(t1-t_l,t2-t_l, pad=True, fill_value=trR.data[0]) #We lost t_h due to the convolution
#~ for trR in trROT:
#~ trR.data *= 10.**-23 ## To get M in Nm
#~ trR.data -= trR.data[0]
#~ trR.data = convolve(trR.data,window,mode='same')
#~ #mean = np.mean(np.hstack((trR.data[0]*np.ones(FirstValid),\
#~ #trR.data[:60./trR.stats.delta*1.-FirstValid+1])))
#~ mean = np.mean(trR.data[:60])
#~ trR.data -= mean
#~ trR.data = bp.bandpassfilter(trR.data,len(trR), trR.stats.delta,\
#~ corners , 1 , fmin, fmax)
#~ trR.trim(t1,t2,pad=True, fill_value=trR.data[0])
trROT = np.array(trROT)
syn = np.dot(trROT.T,M)
synA = np.dot(trROT.T,MA)
synB = np.dot(trROT.T,MB)
SYN = np.append(SYN,syn)
SYNA = np.append(SYNA,synA)
SYNB = np.append(SYNB,synB)
print np.shape(A), np.shape(np.array([SYN]))
if subf == 0:
A = np.array([SYN])
AA = np.array([SYNA])
AB = np.array([SYNB])
else:
A = np.append(A,np.array([SYN]),0)
AA = np.append(AA,np.array([SYNA]),0)
AB = np.append(AB,np.array([SYNB]),0)
AC = np.vstack((AA,AB))
print np.shape(AC)
print np.shape(weight)
B = np.dot(A.T,weight)
stsyn = Stream()
n = 0
Ntraces= {}
for trid in trlist:
spid = trid.split(".")
print trid
NMIN = 1. + (TrimmingTimes[trid][1] - TrimmingTimes[trid][0]) / dt
Ntraces[trid] = (n,NMIN + n)
trsyn = Trace(B[n:NMIN+n])
n += NMIN
trsyn.stats.network = spid[0]
trsyn.stats.station = spid[1]
trsyn.stats.location = spid[2]
trsyn.stats.channel = spid[3]
trsyn = AddNoise(trsyn,level = noiselevel)
#trsyn.stats.starttime =
stsyn.append(trsyn)
stsyn.write(workdir+"WPtraces/" + basename + ".decov.trim.mseed",
format="MSEED")
#####################################################
# Plotting:
#####################################################
#we are going to reflect the y axis later, so:
print minsubf
hypsbloc = [minsubf / nsy , -(minsubf % nsy) - 2]
#Creating the strike and dip axis:
StrikeAx= np.linspace(0,flen,nsx+1)
DipAx= np.linspace(0,fwid,nsy+1)
DepthAx = DipAx*np.sin(np.pi/180.*dip) + Min_h
hlstrike = StrikeAx[hypsbloc[0]] + sflen*0.5
hldip = DipAx[hypsbloc[1]] + sfwid*0.5
hldepth = DepthAx[hypsbloc[1]] + sfwid*0.5*np.sin(np.pi/180.*dip)
StrikeAx = StrikeAx - hlstrike
DipAx = DipAx - hldip
XX, YY = np.meshgrid(StrikeAx, DepthAx)
XX, ZZ = np.meshgrid(StrikeAx, DipAx )
sbarea = sflen*sfwid
SLIPS = weight.reshape(nsx,nsy).T#[::-1,:]
SLIPS /= mu*1.e6*sbarea
######Plot:#####################
plt.figure()
ax = host_subplot(111)
im = ax.pcolor(XX, YY, SLIPS, cmap="jet")
ax.set_ylabel('Depth [km]')
ax.set_ylim(DepthAx[-1],DepthAx[0])
# Creating a twin plot
ax2 = ax.twinx()
#im2 = ax2.pcolor(XX, ZZ, SLIPS[::-1,:], cmap="Greys")
im2 = ax2.pcolor(XX, ZZ, SLIPS[::-1,:], cmap="jet")
ax2.set_ylabel('Distance along the dip [km]')
ax2.set_xlabel('Distance along the strike [km]')
ax2.set_ylim(DipAx[0],DipAx[-1])
ax2.set_xlim(StrikeAx[0],StrikeAx[-1])
ax.axis["bottom"].major_ticklabels.set_visible(False)
ax2.axis["bottom"].major_ticklabels.set_visible(False)
ax2.axis["top"].set_visible(True)
ax2.axis["top"].label.set_visible(True)
divider = make_axes_locatable(ax)
cax = divider.append_axes("bottom", size="5%", pad=0.1)
cb = plt.colorbar(im, cax=cax, orientation="horizontal")
cb.set_label("Slip [m]")
ax2.plot([0], [0], '*', ms=225./(nsy+4))
ax2.set_xticks(ax2.get_xticks()[1:-1])
#ax.set_yticks(ax.get_yticks()[1:])
#ax2.set_yticks(ax2.get_yticks()[:-1])
#########Plotting the selected traces:
nsp = len(PLotSt) * len(PlotSubf)
plt.figure(figsize=(13,11))
plt.title("Synthetics for rake = " + str(round(rake)))
mindis = []
maxdis = []
for i, trid in enumerate(PLotSt):
x = np.arange(0,Ntraces[trid][1]-Ntraces[trid][0],
dt)
for j, subf in enumerate(PlotSubf):
y = A[subf, Ntraces[trid][0]:Ntraces[trid][1]]
if j == 0:
yy = y
else:
yy = np.vstack((yy,y))
maxdis.append(np.max(yy))
mindis.append(np.min(yy))
for i, trid in enumerate(PLotSt):
x = np.arange(0,Ntraces[trid][1]-Ntraces[trid][0],
dt)
for j, subf in enumerate(PlotSubf):
y = A[subf, Ntraces[trid][0]:Ntraces[trid][1]]
plt.subplot2grid((len(PlotSubf), len(PLotSt)),
(j, i))
plt.plot(x,y, linewidth=2.5)
if j == 0:
plt.title(trid)
fig = plt.gca()
fig.axes.get_yaxis().set_ticks([])
fig.set_ylabel(str(subf),rotation=0)
fig.set_xlim((x[0],x[-1]))
fig.set_ylim((mindis[i],maxdis[i]))
if subf != PlotSubf[-1]:
fig.axes.get_xaxis().set_ticks([])
plt.show()
def calcTTT(Config,StationList,Origin):
dimX = int(Config['dimX'])
dimY = int(Config['dimY'])
gridspacing = float(Config['gridspacing'])
o_lat = float(Origin['lat'])
o_lon = float(Origin['lon'])
o_depth = float(Origin['depth'])
logger.info(' BOUNDING BOX DIMX: %d DIMY: %d GRIDSPACING: %f \n'%(dimX,dimY,gridspacing))
oLator = o_lat + dimX/2
oLonor = o_lon + dimY/2
oLatul = 0
oLonul = 0
mint= 100000
maxt=-100000
TTTGridMap = {}
for station in StationList:
GridArray = {}
streamID = station.net+'.'+station.sta+'.'+station.loc+'.'+station.comp
sdelta = locations2degrees(float(o_lat), float(o_lon), float(station.lat), float(station.lon))
logger.info(' STATION: %s --> DELTA: %f'% (streamID,sdelta))
z=0
for i in xrange(dimX):
oLatul = o_lat -((dimX-1)/2)*gridspacing + i*gridspacing
if z == 0 and i == 0:
Latul = oLatul
o=0
for j in xrange (dimY):
oLonul = o_lon -((dimY-1)/2)*gridspacing + j*gridspacing
if o==0 and j==0:
Lonul = oLonul
de = locations2degrees(float(oLatul), float(oLonul), float(station.lat), float(station.lon))
tt = getTravelTimes(delta=de,depth=o_depth,model='ak135')
#print tt
if tt[0]['phase_name'] == Config['ttphase']:
time = tt[0]['time']
#print streamID,oLatul,oLonul,' --------> ' ,time , ' -> \n'
GridArray[(i,j)] = GridElem(oLatul, oLonul, o_depth,time,de)
if (mint > time):
mint = time
if (maxt < time):
maxt = time
TTTGridMap[streamID] = TTTGrid(o_depth,mint,maxt,Latul,Lonul,oLator,oLonor,GridArray)
logger.info('\033[31m MINT: %g MAXT: %f \033[0m'% (mint,maxt))
return mint, maxt,TTTGridMap
stanames=genfromtxt('/Users/dmelgar/Slip_inv/iquique_sm/data/station_info/gps.gflist',usecols=0,dtype='S')
coords=genfromtxt('/Users/dmelgar/Slip_inv/iquique_sm/data/station_info/gps.gflist',usecols=[1,2])
for k in range(len(stanames)):
sta=stanames[k]
print sta
n=read(path+'proc/'+sta+'.LXN.sac')
e=read(path+'proc/'+sta+'.LXE.sac')
u=read(path+'proc/'+sta+'.LXZ.sac')
#Low pass filter
n[0].data=lowpass(n[0].data,fcorner,1./n[0].stats.delta,10)
e[0].data=lowpass(e[0].data,fcorner,1./e[0].stats.delta,10)
u[0].data=lowpass(u[0].data,fcorner,1./u[0].stats.delta,10)
#Get station to hypocenter delta distance
delta=locations2degrees(coords[k,1],coords[k,0],epicenter[1],epicenter[0])
#Get p-time to site
tt=getTravelTimes(delta,epicenter[2])
tp=timedelta(seconds=float64(tt[0]['time']))
#Trim
n[0].trim(starttime=time_epi+tp-tmin,endtime=time_epi+tp+tmax)
e[0].trim(starttime=time_epi+tp-tmin,endtime=time_epi+tp+tmax)
u[0].trim(starttime=time_epi+tp-tmin,endtime=time_epi+tp+tmax)
#Remove first epoch
n[0].data=n[0].data-n[0].data[0]
e[0].data=e[0].data-e[0].data[0]
u[0].data=u[0].data-u[0].data[0]
#Write to file
n.write(path+'filt/'+sta+'.LXN.sac',format='SAC')
e.write(path+'filt/'+sta+'.LXE.sac',format='SAC')
u.write(path+'filt/'+sta+'.LXZ.sac',format='SAC')
if make_plots:
def travel_times(ref, deg=None, km=None, depth=0.):
"""
Get *approximate* relative travel time(s).
Parameters
----------
ref : list or tuple of strings and/or floats
Reference phase names or horizontal velocities [km/sec].
deg : float, optional
Degrees of arc between two points of interest (spherical earth).
km : float, optional
Horizontal kilometers between two points of interest (spherical earth).
depth : float, optional. default, 0.
Depth (positive down) of event, in kilometers.
Returns
-------
numpy.ndarray
Relative times, in seconds, same length as "ref". NaN if requested time
is undefined.
Examples
--------
Get relative P arrival and 2.7 km/sec surface wave arrival at 35 degrees
distance.
>>> times = travel_times(['P', 2.7], deg=35.0)
To get absolute window, add the origin time like:
>>> w1, w2 = times + epoch_origin_time
Notes
-----
Either deg or km must be indicated.
The user is responsible for adding/subtracting time (such as origin
time, pre-window noise time, etc.) from those predicted in order to define
a window.
Phase travel times use ak135.
"""
times = np.zeros(len(ref), dtype='float')
tt = None
for i, iref in enumerate(ref):
if isinstance(iref, str):
# phase time requested
if not tt:
if not deg:
deg = geod.kilometers2degrees(km)
tt = taup.getTravelTimes(deg, depth, model='ak135')
try:
idx = [ph['phase_name'] for ph in tt].index(iref)
itt = [ph['time'] for ph in tt][idx]
except ValueError:
# phase not found
itt = None
else:
# horizontal velocity
if not km:
km = deg*(2*math.pi/360.0)*6371.0
itt = km/iref
times[i] = itt
return times
def travel_times(ref, deg=None, km=None, depth=0.):
"""
Get *approximate* relative travel time(s).
Parameters
----------
ref : list or tuple of strings and/or floats
Reference phase names or horizontal velocities [km/sec].
deg : float, optional
Degrees of arc between two points of interest (spherical earth).
km : float, optional
Horizontal kilometers between two points of interest (spherical earth).
depth : float, optional. default, 0.
Depth (positive down) of event, in kilometers.
Returns
-------
numpy.ndarray
Relative times, in seconds, same length as "ref". NaN if requested time
is undefined.
Examples
--------
Get relative P arrival and 2.7 km/sec surface wave arrival at 35 degrees
distance.
>>> times = travel_times(['P', 2.7], deg=35.0)
To get absolute window, add the origin time like:
>>> w1, w2 = times + epoch_origin_time
Notes
-----
Either deg or km must be indicated.
The user is responsible for adding/subtracting time (such as origin
time, pre-window noise time, etc.) from those predicted in order to define
a window.
Phase travel times use ak135.
"""
times = np.zeros(len(ref), dtype='float')
tt = None
for i, iref in enumerate(ref):
if isinstance(iref, str):
# phase time requested
if not tt:
if not deg:
deg = geod.kilometers2degrees(km)
tt = taup.getTravelTimes(deg, depth, model='ak135')
try:
idx = [ph['phase_name'] for ph in tt].index(iref)
itt = [ph['time'] for ph in tt][idx]
except ValueError:
# phase not found
itt = None
else:
# horizontal velocity
if not km:
km = deg * (2 * math.pi / 360.0) * 6371.0
itt = km / iref
times[i] = itt
return times
def ProcessLoopS(filepath,stationnames):
'''File processing loop for S tomography: Take the components and convert to RTZ, and delte the E and N comps'''
p = os.getcwd()
for station in stationnames:
print 'Dealing with %s' %station
Rstream = obspy.Stream()
#Get all SAC files associated with that station
sacfiles = reversed(sorted(glob.glob('*.%s..*' %station)))
saccount = 0
for sacfile in sacfiles:
trace = read(sacfile)
#Only determine the distance and back-azimuth once: This is what the saccount variable is here for
if saccount == 0:
evlat = trace[0].stats.sac.evla
evlon = trace[0].stats.sac.evlo
evdep = trace[0].stats.sac.evdp
stlat = trace[0].stats.sac.stla
stlon = trace[0].stats.sac.stlo
dist = locations2degrees(evlat,evlon,stlat,stlon) #find distance from the quake to the station
arcs = IRISclient.distaz(stalat=stlat,stalon=stlon,evtlat=evlat,evtlon=evlon)
baz = arcs['backazimuth']
az = arcs['azimuth']
if evdep > 1e3:
evdep = evdep/1000.0;
traveltimes = getTravelTimes(dist,evdep, model='iasp91')
P = 0
S = 0
for element in traveltimes:
phaseinfo = element['phase_name']
if phaseinfo == 'P':
Ptime = element['time']
P = 1
if phaseinfo == 'S':
Stime = element['time']
S = 1
if (P==1 and S ==1):
break
try:
P = Ptime
except:
Ptime = 0
try:
S = Stime
except:
Stime = 0
#Set the P and S times, and other SAC header data
trace[0].stats.sac.az = float(az)
trace[0].stats.sac.baz = float(baz)
if Ptime > 0:
trace[0].stats.sac.t1 = Ptime
if Stime > 0:
trace[0].stats.sac.t2 = Stime
trace[0].stats.sac.evdp = evdep*1000 #dbpick wants depth to be in meters
trace[0].stats.sac.o = 0 #add origin time
#other operations - remove the mean and resample
trace[0].detrend('demean')
trace[0].resample(20)
if ('BHE' in sacfile) or ('BHN' in sacfile):
Rstream += trace
#to save disk space, delete the E and N components
os.system('rm %s' %sacfile)
else:
#Write the Z component directly (writes over the existing file)
trace.write(sacfile,format='SAC')
#print 'Appended arrivals to %s' %sacfile
saccount += 1
#Convert to radial and transverse components
try:
rotstream = Rstream.rotate(method='NE->RT',back_azimuth=baz)
for obj in rotstream:
nt = obj.stats.network
sta = obj.stats.station
channel = obj.stats.channel
name = "vel."+str(nt)+"."+str(station)+".."+str(channel)
obj.write(name,format="SAC")
#print 'Written new file %s' %name
except:
print 'Cannot rotate files in Rstream %s' %Rstream
#create antelope database - just for S waves, which are picked on the traverse.
os.system('rm *.01.*')
os.system('sac2db *.BHT T')
def YSPEC_Phase():
"""
Create input file (yspec.in) for YSPEC based on the selected Phase
"""
global input
events, address_events = quake_info(input['address'], 'info')
for i in range(0, len(events)):
sta_ev_select = []
sta_ev = read_station_event(address_events[i])
for j in range(0, len(sta_ev[i])):
dist = locations2degrees(lat1 = float(sta_ev[i][j][9]), \
long1 = float(sta_ev[i][j][10]), lat2 = float(sta_ev[i][j][4]), \
long2 = float(sta_ev[i][j][5]))
tt = getTravelTimes(delta=dist, depth=float(sta_ev[i][j][11]), \
model=input['model'])
sta_ev[i][j][8] = sta_ev[i][j][0] + '_' + sta_ev[i][j][1]
for m in range(0, len(tt)):
if tt[m]['phase_name'] in input['phase']:
sta_ev_select.append(sta_ev[i][j])
#import ipdb; ipdb.set_trace()
sta_ev_req = list(unique_items(sta_ev_select))
if os.path.isfile(os.path.join(address_events[i],\
'info', 'yspec.in')):
os.remove(os.path.join(address_events[i],\
'info', 'yspec.in'))
shutil.copy2('./yspec.in', os.path.join(address_events[i],\
'info', 'yspec.in'))
if os.path.isfile(os.path.join(address_events[i],\
'info', 'sta_yspec')):
os.remove(os.path.join(address_events[i],\
'info', 'sta_yspec'))
sta_yspec_open = open(os.path.join(address_events[i],\
'info', 'sta_yspec'), 'a+')
for j in range(0, len(sta_ev_req)):
sta_yspec_open.writelines(sta_ev_req[j][0] + ',' + \
sta_ev_req[j][1] + ',' + sta_ev_req[j][2] + ',' + \
sta_ev_req[j][3] + ',' + sta_ev_req[j][4] + ',' + \
sta_ev_req[j][5] + ',' + sta_ev_req[j][6] + ',' + \
sta_ev_req[j][7] + ',' + sta_ev_req[j][8] + ',' + \
sta_ev_req[j][9] + ',' + sta_ev_req[j][10] + ',' + \
sta_ev_req[j][11] + ',' + sta_ev_req[j][12] + ',\n')
sta_yspec_open.close()
receivers = []
receivers.append('\n')
for j in range(0, len(sta_ev_req)):
receivers.append( ' ' + \
str(round(float(sta_ev_req[j][4]), 2)) + ' ' + \
str(round(float(sta_ev_req[j][5]), 2)) + \
'\n')
yspecin_open = open(os.path.join(address_events[i],\
'info', 'yspec.in'), 'a+')
yspecin_file = yspecin_open.readlines()
search = '# source depth (km)'
for j in range(0, len(yspecin_file)):
if yspecin_file[j].find(search) != -1:
yspecin_file[j+1] = ' ' + \
str(round(float(sta_ev_req[0][11]), 2)) + '\n'
break
search = '# source latitude (deg)'
for j in range(0, len(yspecin_file)):
if yspecin_file[j].find(search) != -1:
yspecin_file[j+1] = ' ' + \
str(round(float(sta_ev_req[0][9]), 2)) + '\n'
break
search = '# source longitude (deg)'
for j in range(0, len(yspecin_file)):
if yspecin_file[j].find(search) != -1:
yspecin_file[j+1] = ' ' + \
str(round(float(sta_ev_req[0][10]), 2)) + '\n'
break
search = '# number of receivers'
for j in range(0, len(yspecin_file)):
if yspecin_file[j].find(search) != -1:
yspecin_file[j + 1] = ' ' + str(len(receivers) - 1) + '\n'
break
search = '# receiver latitudes and longitudes'
for j in range(0, len(yspecin_file)):
if yspecin_file[j].find(search) != -1:
yspecin_file[j + 1:] = receivers
break
yspecin_open.close()
os.remove(os.path.join(address_events[i], 'info', 'yspec.in'))
yspecin_open = open(os.path.join(address_events[i],\
'info', 'yspec.in'), 'a+')
for j in range(0, len(yspecin_file)):
yspecin_open.write(yspecin_file[j])
yspecin_open.close()
print '\n***************************************'
print 'Following Parameters have been changed:\n'
print 'source depth'
print 'source latitude'
print 'source longitude'
print 'number of receivers'
print 'receiver latitude and longitude\n'
print 'Please change the rest yourself!'
print '***************************************'
except:
print('Problem with verticals: ' + sta)
continue
# We want to get the distance of the event and of the station
# We also want the back-azimuth
lat,lon = getlatlon(cursta, eventtime, sp)
dist= gps2dist_azimuth(float(cmtlat), float(cmtlon), lat, lon)
bazi ="{0:.1f}".format(dist[2])
dist ="{0:.1f}".format( 0.0089932 * dist[0] / 1000)
if debug:
print 'Here is the distance:' + str(dist)
print 'Here is the depth:' + str(dep)
# Here is the travel time so we can do the final trim
# Should this be in a function to avoid it being in the main loop?
tt = getTravelTimes(delta=float(dist), depth=dep,model='ak135')
firstarrival = tt[0]['time']
for ttphase in tt:
phasename = ttphase['phase_name']
phasename = phasename[:1]
if phasename == 'S':
secondarrival = ttphase['time']
break
# Here we do the trim from the phases
if not parserval.trigger:
for trace in vertcomps:
newstime = trace.stats.starttime + firstarrival - bfarrival
newetime = trace.stats.starttime + secondarrival + afarrival
trace.trim(starttime=newstime,endtime=newetime)
def ProcessLoopP(filepath):
'''The file processing loop associated with P wave tomography: Just deal with the BHZ files to save time'''
sacfiles = glob.glob('*.BHZ')
#Check to see if there is more than one location for a given station
stationnames = []
for sacfile in sorted(sacfiles):
sacfilenameparts = sacfile.split('.')
stationname = sacfilenameparts[2]
if stationname not in stationnames:
stationnames.append(stationname)
trace = read(sacfile)
evlat = trace[0].stats.sac.evla
evlon = trace[0].stats.sac.evlo
evdep = trace[0].stats.sac.evdp
stlat = trace[0].stats.sac.stla
stlon = trace[0].stats.sac.stlo
dist = locations2degrees(evlat,evlon,stlat,stlon) #find distance from the quake to the station
arcs = IRISclient.distaz(stalat=stlat,stalon=stlon,evtlat=evlat,evtlon=evlon)
az = arcs['backazimuth']
baz = arcs['azimuth']
#If we're running this code twice in a row, need to correct the evdep accordingly. The evdep that comes from obspy will be in km, but needs
#to be in the SAC header in meters. If the depth is already in meters in the SACfile, then it will almost certainly be >1000. This if statement check for
#this, and converts to km if necessary
if evdep > 1e3:
evdep = evdep/1000.0
traveltimes = getTravelTimes(dist,evdep, model='iasp91')
P = 0
S = 0
for element in traveltimes:
phaseinfo = element['phase_name']
if phaseinfo == 'P':
Ptime = element['time']
P = 1
if phaseinfo == 'S':
Stime = element['time']
S = 1
if (P==1 and S==1):
break
try:
P = Ptime
except:
Ptime = 0
try:
S = Stime
except:
Stime = 0
#Set the P and S times
trace[0].stats.sac.az = float(az)
trace[0].stats.sac.baz = float(baz)
trace[0].stats.sac.o = 0.0 #add origin time
if Ptime > 0:
trace[0].stats.sac.t1 = Ptime
if Stime > 0:
trace[0].stats.sac.t2 = Stime
trace[0].stats.sac.evdp = evdep*1000 #dbpick wants depth to be in meters
#other operations
trace[0].detrend('demean')
#THE CROSS CORRELATION CODE ASSUMES A SAMPLING RATE OF 0.05 (20 SAMPLES/SECOND). IT WILL NOT WORK
#OTHERWISE!!!
trace[0].resample(20)
if results.autop:
tracestreamP = trace.copy()
df = tracestreamP[0].stats.sampling_rate
filter1 = 0.02
filter2 = 0.1
tracestreamP.filter("bandpass",freqmin=filter1,freqmax=filter2,corners=2)
tracestreamP.taper(max_percentage=0.05, type='cosine')
p_pick, phase_info = pkBaer(tracestreamP[0].data,df,10,2,2,10,20,6) #output from this is in samples.
autoPtime = p_pick/df
#Append the autopicker's time to the
if abs(Ptime-autoPtime) < 20:
print 'Autopick accepted!'
trace[0].stats.sac.t3 = autoPtime
#Important - must write to the SAC file!
trace.write(sacfile,format='SAC')
print 'Appended arrivals to %s' %sacfile
else:
print 'Found multiple instruments at station %s. Removing all but 1' %(stationname)
os.system('rm %s' %sacfile)
#create antelope database for P arrivals
os.system('sac2db *.BHZ Z')
def YSPEC_Phase():
"""
Create input file (yspec.in) for YSPEC based on the selected Phase
"""
global input
events, address_events = quake_info(input['address'], 'info')
for i in range(0, len(events)):
sta_ev_select = []
sta_ev = read_station_event(address_events[i])
for j in range(0, len(sta_ev[i])):
dist = locations2degrees(lat1 = float(sta_ev[i][j][9]), \
long1 = float(sta_ev[i][j][10]), lat2 = float(sta_ev[i][j][4]), \
long2 = float(sta_ev[i][j][5]))
tt = getTravelTimes(delta=dist, depth=float(sta_ev[i][j][11]), \
model=input['model'])
sta_ev[i][j][8] = sta_ev[i][j][0] + '_' + sta_ev[i][j][1]
for m in range(0, len(tt)):
if tt[m]['phase_name'] in input['phase']:
sta_ev_select.append(sta_ev[i][j])
#import ipdb; ipdb.set_trace()
sta_ev_req = list(unique_items(sta_ev_select))
if os.path.isfile(os.path.join(address_events[i],\
'info', 'yspec.in')):
os.remove(os.path.join(address_events[i],\
'info', 'yspec.in'))
shutil.copy2('./yspec.in', os.path.join(address_events[i],\
'info', 'yspec.in'))
if os.path.isfile(os.path.join(address_events[i],\
'info', 'sta_yspec')):
os.remove(os.path.join(address_events[i],\
'info', 'sta_yspec'))
sta_yspec_open = open(os.path.join(address_events[i],\
'info', 'sta_yspec'), 'a+')
for j in range(0, len(sta_ev_req)):
sta_yspec_open.writelines(sta_ev_req[j][0] + ',' + \
sta_ev_req[j][1] + ',' + sta_ev_req[j][2] + ',' + \
sta_ev_req[j][3] + ',' + sta_ev_req[j][4] + ',' + \
sta_ev_req[j][5] + ',' + sta_ev_req[j][6] + ',' + \
sta_ev_req[j][7] + ',' + sta_ev_req[j][8] + ',' + \
sta_ev_req[j][9] + ',' + sta_ev_req[j][10] + ',' + \
sta_ev_req[j][11] + ',' + sta_ev_req[j][12] + ',\n')
sta_yspec_open.close()
receivers = []
receivers.append('\n')
for j in range(0, len(sta_ev_req)):
receivers.append( ' ' + \
str(round(float(sta_ev_req[j][4]), 2)) + ' ' + \
str(round(float(sta_ev_req[j][5]), 2)) + \
'\n')
yspecin_open = open(os.path.join(address_events[i],\
'info', 'yspec.in'), 'a+')
yspecin_file = yspecin_open.readlines()
search = '# source depth (km)'
for j in range(0, len(yspecin_file)):
if yspecin_file[j].find(search) != -1:
yspecin_file[j+1] = ' ' + \
str(round(float(sta_ev_req[0][11]), 2)) + '\n'
break
search = '# source latitude (deg)'
for j in range(0, len(yspecin_file)):
if yspecin_file[j].find(search) != -1:
yspecin_file[j+1] = ' ' + \
str(round(float(sta_ev_req[0][9]), 2)) + '\n'
break
search = '# source longitude (deg)'
for j in range(0, len(yspecin_file)):
if yspecin_file[j].find(search) != -1:
yspecin_file[j+1] = ' ' + \
str(round(float(sta_ev_req[0][10]), 2)) + '\n'
break
search = '# number of receivers'
for j in range(0, len(yspecin_file)):
if yspecin_file[j].find(search) != -1:
yspecin_file[j+1] = ' ' + str(len(receivers)-1) + '\n'
break
search = '# receiver latitudes and longitudes'
for j in range(0, len(yspecin_file)):
if yspecin_file[j].find(search) != -1:
yspecin_file[j+1:] = receivers
break
yspecin_open.close()
os.remove(os.path.join(address_events[i], 'info', 'yspec.in'))
yspecin_open = open(os.path.join(address_events[i],\
'info', 'yspec.in'), 'a+')
for j in range(0, len(yspecin_file)):
yspecin_open.write(yspecin_file[j])
yspecin_open.close()
print '\n***************************************'
print 'Following Parameters have been changed:\n'
print 'source depth'
print 'source latitude'
print 'source longitude'
print 'number of receivers'
print 'receiver latitude and longitude\n'
print 'Please change the rest yourself!'
print '***************************************'
def single_comparison():
"""
one by one comparison of the waveforms in the first path with the second path.
"""
client = Client()
global input
# identity of the waveforms (first and second paths) to be compared with each other
identity_all = input['net'] + '.' + input['sta'] + '.' + \
input['loc'] + '.' + input['cha']
ls_first = glob.glob(os.path.join(input['first_path'], identity_all))
ls_second = glob.glob(os.path.join(input['second_path'], identity_all))
for i in range(0, len(ls_first)):
try:
tr1 = read(ls_first[i])[0]
if input['phase'] != 'N':
evsta_dist = util.locations2degrees(lat1 = tr1.stats.sac.evla, \
long1 = tr1.stats.sac.evlo, lat2 = tr1.stats.sac.stla, \
long2 = tr1.stats.sac.stlo)
taup_tt = taup.getTravelTimes(delta = evsta_dist, depth = tr1.stats.sac.evdp)
phase_exist = 'N'
for tt_item in taup_tt:
if tt_item['phase_name'] == input['phase']:
print 'Requested phase:'
print input['phase']
print '------'
print tt_item['phase_name']
print 'exists in the waveform!'
print '-----------------------'
t_phase = tt_item['time']
phase_exist = 'Y'
break
if phase_exist != 'Y':
continue
# identity of the current waveform
identity = tr1.stats.network + '.' + tr1.stats.station + '.' + \
tr1.stats.location + '.' + tr1.stats.channel
# tr1: first path, tr2: second path, tr3: Raw data
#tr3 = read(os.path.join(input['first_path'], '..', 'BH_RAW', identity))[0]
if input['resp_paz'] == 'Y':
response_file = os.path.join(input['first_path'], '..', 'Resp/RESP.' + identity)
# Extract the PAZ info from response file
paz = readRESP(response_file, unit = input['corr_unit'])
poles = paz['poles']
zeros = paz['zeros']
scale_fac = paz['gain']
sensitivity = paz['sensitivity']
print paz
# Convert Poles and Zeros (PAZ) to frequency response.
h, f = pazToFreqResp(poles, zeros, scale_fac, \
1./tr1.stats.sampling_rate, tr1.stats.npts*2, freq=True)
# Use the evalresp library to extract
# instrument response information from a SEED RESP-file.
resp = invsim.evalresp(t_samp = 1./tr1.stats.sampling_rate, \
nfft = tr1.stats.npts*2, filename = response_file, \
date = tr1.stats.starttime, units = input['corr_unit'].upper())
# Keep the current identity in a new variable
id_name = identity
try:
tr2 = read(os.path.join(input['second_path'], identity))[0]
except Exception, error:
# if it is not possible to read the identity in the second path
# then change the network part of the identity based on
# correction unit
identity = input['corr_unit'] + '.' + tr1.stats.station + '.' + \
tr1.stats.location + '.' + tr1.stats.channel
tr2 = read(os.path.join(input['second_path'], identity))[0]
if input['resample'] != 'N':
print 'WARNING: you are using resample!!!'
tr1.resample(input['resample'])
tr2.resample(input['resample'])
if input['tw'] == 'Y':
t_cut_1 = tr1.stats.starttime + t_phase - input['preset']
t_cut_2 = tr1.stats.starttime + t_phase + input['offset']
tr1.trim(starttime = t_cut_1, endtime = t_cut_2)
t_cut_1 = tr2.stats.starttime + t_phase - input['preset']
t_cut_2 = tr2.stats.starttime + t_phase + input['offset']
tr2.trim(starttime = t_cut_1, endtime = t_cut_2)
if input['hlfilter'] == 'Y':
tr1.filter('lowpass', freq=input['hfreq'], corners=2)
tr2.filter('lowpass', freq=input['hfreq'], corners=2)
tr1.filter('highpass', freq=input['lfreq'], corners=2)
tr2.filter('highpass', freq=input['lfreq'], corners=2)
# normalization of all three waveforms to the
# max(max(tr1), max(tr2), max(tr3)) to keep the scales
#maxi = max(abs(tr1.data).max(), abs(tr2.data).max(), abs(tr3.data).max())
#maxi = max(abs(tr1.data).max(), abs(tr2.data).max())
#tr1_data = tr1.data/abs(maxi)
#tr2_data = tr2.data/abs(maxi)
#tr3_data = tr3.data/abs(maxi)
tr1_data = tr1.data/abs(max(tr1.data))
tr2_data = tr2.data/abs(max(tr2.data))
#tr1_data = tr1.data
#tr2_data = tr2.data*1e9
print max(tr1.data)
print max(tr2.data)
# create time arrays for tr1, tr2 and tr3
time_tr1 = np.arange(0, tr1.stats.npts/tr1.stats.sampling_rate, \
1./tr1.stats.sampling_rate)
time_tr2 = np.arange(0, tr2.stats.npts/tr2.stats.sampling_rate, \
1./tr2.stats.sampling_rate)
#time_tr3 = np.arange(0, tr3.stats.npts/tr3.stats.sampling_rate, \
# 1./tr3.stats.sampling_rate)
# label for plotting
label_tr1 = ls_first[i].split('/')[-2]
label_tr2 = ls_second[i].split('/')[-2]
label_tr3 = 'RAW'
if input['resp_paz'] == 'Y':
# start plotting
plt.figure()
plt.subplot2grid((3,4), (0,0), colspan=4, rowspan=2)
#plt.subplot(211)
plt.plot(time_tr1, tr1_data, color = 'blue', label = label_tr1, lw=3)
plt.plot(time_tr2, tr2_data, color = 'red', label = label_tr2, lw=3)
#plt.plot(time_tr3, tr3_data, color = 'black', ls = '--', label = label_tr3)
plt.xlabel('Time (sec)', fontsize = 'xx-large', weight = 'bold')
if input['corr_unit'] == 'dis':
ylabel_str = 'Relative Displacement'
elif input['corr_unit'] == 'vel':
ylabel_str = 'Relative Vel'
elif input['corr_unit'] == 'acc':
ylabel_str = 'Relative Acc'
plt.ylabel(ylabel_str, fontsize = 'xx-large', weight = 'bold')
plt.xticks(fontsize = 'xx-large', weight = 'bold')
plt.yticks(fontsize = 'xx-large', weight = 'bold')
plt.legend(loc=1,prop={'size':20})
#-------------------Cross Correlation
# 5 seconds as total length of samples to shift for cross correlation.
cc_np = tr1.stats.sampling_rate * 3
np_shift, coeff = cross_correlation.xcorr(tr1, tr2, int(cc_np))
t_shift = float(np_shift)/tr1.stats.sampling_rate
print "Cross Correlation:"
print "Shift: " + str(t_shift)
print "Coefficient: " + str(coeff)
plt.title('Single Comparison' + '\n' + str(t_shift) + \
' sec , coeff: ' + str(round(coeff, 5)) + \
'\n' + id_name, \
fontsize = 'xx-large', weight = 'bold')
if input['resp_paz'] == 'Y':
# -----------------------
#plt.subplot(223)
plt.subplot2grid((3,4), (2,0), colspan=2)
'''
plt.plot(np.log10(f), np.log10(abs(resp)/(sensitivity*sensitivity)), \
color = 'blue', label = 'RESP', lw=3)
plt.plot(np.log10(f), np.log10(abs(h)/sensitivity), \
color = 'red', label = 'PAZ', lw=3)
'''
plt.loglog(f, abs(resp)/(sensitivity*sensitivity), \
color = 'blue', label = 'RESP', lw=3)
plt.loglog(f, abs(h)/sensitivity, \
color = 'red', label = 'PAZ', lw=3)
#for j in [0.008, 0.012, 0.025, 0.5, 1, 2, 3, 4]:
for j in [0]:
plt.axvline(np.log10(j), linestyle = '--')
#plt.xlabel('Frequency [Hz]\n(power of 10)', fontsize = 'xx-large', weight = 'bold')
#plt.ylabel('Amplitude\n (power of 10)', fontsize = 'xx-large', weight = 'bold')
plt.xlabel('Frequency [Hz]', fontsize = 'xx-large', weight = 'bold')
plt.ylabel('Amplitude', fontsize = 'xx-large', weight = 'bold')
plt.xticks(fontsize = 'xx-large', weight = 'bold')
#plt.yticks = MaxNLocator(nbins=4)
plt.yticks(fontsize = 'xx-large', weight = 'bold')
plt.legend(loc=2,prop={'size':20})
# -----------------------
#plt.subplot(224)
plt.subplot2grid((3,4), (2,2), colspan=2)
#take negative of imaginary part
phase_paz = np.unwrap(np.arctan2(h.imag, h.real))
phase_resp = np.unwrap(np.arctan2(resp.imag, resp.real))
#plt.plot(np.log10(f), phase_resp, color = 'blue', label = 'RESP', lw=3)
#plt.plot(np.log10(f), phase_paz, color = 'red', label = 'PAZ', lw=3)
plt.semilogx(f, phase_resp, color = 'blue', label = 'RESP', lw=3)
plt.semilogx(f, phase_paz, color = 'red', label = 'PAZ', lw=3)
#for j in [0.008, 0.012, 0.025, 0.5, 1, 2, 3, 4]:
for j in [0.0]:
plt.axvline(np.log10(j), linestyle = '--')
#plt.xlabel('Frequency [Hz]\n(power of 10)', fontsize = 'xx-large', weight = 'bold')
plt.xlabel('Frequency [Hz]', fontsize = 'xx-large', weight = 'bold')
plt.ylabel('Phase [radian]', fontsize = 'xx-large', weight = 'bold')
plt.xticks(fontsize = 'xx-large', weight = 'bold')
plt.yticks(fontsize = 'xx-large', weight = 'bold')
plt.legend(loc=3,prop={'size':20})
# title, centered above both subplots
# make more room in between subplots for the ylabel of right plot
plt.subplots_adjust(wspace=0.4, hspace=0.3)
"""
# -----------------------
plt.subplot(325)
plt.plot(np.log10(f), np.log10(abs(resp)/(sensitivity*sensitivity)) - \
np.log10(abs(h)/sensitivity), \
color = 'black', label = 'RESP - PAZ')
for j in [0.008, 0.012, 0.025, 0.5, 1, 2, 3, 4]:
plt.axvline(np.log10(j), linestyle = '--')
plt.xlabel('Frequency [Hz] (power of 10)')
plt.ylabel('Amplitude (power of 10)')
plt.legend()
# -----------------------
plt.subplot(326)
#take negative of imaginary part
phase_paz = np.unwrap(np.arctan2(h.imag, h.real))
phase_resp = np.unwrap(np.arctan2(resp.imag, resp.real))
plt.plot(np.log10(f), np.log10(phase_resp) - np.log10(phase_paz), \
color = 'black', label = 'RESP - PAZ')
for j in [0.008, 0.012, 0.025, 0.5, 1, 2, 3, 4]:
plt.axvline(np.log10(j), linestyle = '--')
plt.xlabel('Frequency [Hz] (power of 10)')
plt.ylabel('Phase [radian] (power of 10)')
plt.legend()
# title, centered above both subplots
# make more room in between subplots for the ylabel of right plot
plt.subplots_adjust(wspace=0.3)
"""
plt.show()
print str(i+1) + '/' + str(len(ls_first))
print ls_first[i]
print '------------------'
wait = raw_input(id_name)
print '***************************'
except Exception, error:
print '##################'
print error
print '##################'
except:
print('Problem with verticals: ' + sta)
continue
# We want to get the distance of the event and of the station
# We also want the back-azimuth
lat, lon = getlatlon(cursta, eventtime, sp)
dist = gps2dist_azimuth(float(cmtlat), float(cmtlon), lat, lon)
bazi = "{0:.1f}".format(dist[2])
dist = "{0:.1f}".format(0.0089932 * dist[0] / 1000)
if debug:
print 'Here is the distance:' + str(dist)
print 'Here is the depth:' + str(dep)
# Here is the travel time so we can do the final trim
# Should this be in a function to avoid it being in the main loop?
tt = getTravelTimes(delta=float(dist), depth=dep, model='ak135')
firstarrival = tt[0]['time']
for ttphase in tt:
phasename = ttphase['phase_name']
phasename = phasename[:1]
if phasename == 'S':
secondarrival = ttphase['time']
break
# Here we do the trim from the phases
if not parserval.trigger:
for trace in vertcomps:
newstime = trace.stats.starttime + firstarrival - bfarrival
newetime = trace.stats.starttime + secondarrival + afarrival
trace.trim(starttime=newstime, endtime=newetime)
if debug:
def update(self, autorange=False, force=False):
try:
self._plot_receiver()
self._plot_event()
except AttributeError:
return
if (not bool(self.ui.auto_update_check_box.checkState())
and self.ui.finsource_tab.currentIndex() == 1 and not force):
return
components = ["z", "n", "e"]
components_map = {0: ("Z", "N", "E"),
1: ("Z", "R", "T")}
components_choice = int(self.ui.components_combo.currentIndex())
label_map = {0: {"z": "vertical", "n": "east", "e": "north"},
1: {"z": "vertical", "n": "radial", "e": "transverse"}}
for component in components:
p = getattr(self.ui, "%s_graph" % component)
p.setTitle(label_map[components_choice][component].capitalize()
+ " component")
if self.ui.finsource_tab.currentIndex() == 0:
src_latitude = self.source.latitude
src_longitude = self.source.longitude
src_depth_in_m = self.source.depth_in_m
else:
src_latitude = self.finite_source.hypocenter_latitude
src_longitude = self.finite_source.hypocenter_longitude
src_depth_in_m = self.finite_source.hypocenter_depth_in_m
rec = self.receiver
try:
# Grab resampling settings from the UI.
if bool(self.ui.resample_check_box.checkState()):
dt = float(self.ui.resample_factor.value())
dt = self.instaseis_db.dt / dt
else:
dt = None
if self.ui.finsource_tab.currentIndex() == 0:
st = self.instaseis_db.get_seismograms(
source=self.source, receiver=self.receiver, dt=dt,
components=components_map[components_choice])
elif self.ui.finsource_tab.currentIndex() == 1:
st = self.instaseis_db.get_seismograms_finite_source(
sources=self.finite_source, receiver=self.receiver, dt=dt,
components=components_map[components_choice])
# check filter values from the UI
if bool(self.ui.lowpass_check_box.checkState()):
try:
freq = 1.0 / float(self.ui.lowpass_period.value())
st.filter('lowpass', freq=freq, zerophase=True)
except ZeroDivisionError:
# this happens when typing in the lowpass_period box
pass
if bool(self.ui.highpass_check_box.checkState()):
try:
freq = 1.0 / float(self.ui.highpass_period.value())
st.filter('highpass', freq=freq, zerophase=True)
except ZeroDivisionError:
# this happens when typing in the highpass_period box
pass
except AttributeError:
return
if bool(self.ui.tt_times.checkState()):
great_circle_distance = locations2degrees(
src_latitude, src_longitude,
rec.latitude, rec.longitude)
self.tts = getTravelTimes(great_circle_distance,
src_depth_in_m / 1000.0, model="ak135")
for ic, component in enumerate(components):
plot_widget = getattr(self.ui, "%s_graph" % component.lower())
plot_widget.clear()
tr = st.select(component=components_map[components_choice][ic])[0]
times = tr.times()
plot_widget.plot(times, tr.data, pen="k")
if bool(self.ui.tt_times.checkState()):
for tt in self.tts:
if tt["time"] >= times[-1]:
self.tts.remove(tt)
continue
if tt["phase_name"][0].lower() == "p":
pen = "#008c2866"
else:
pen = "#95000066"
plot_widget.addLine(x=tt["time"], pen=pen, z=-10)
if autorange:
plot_widget.autoRange()
