def get_line_parallels(pts, rngkm):
from obspy.core.util.geodetics import gps2DistAzimuth
from oq_tools import reckon
# set outputs
posazpts = []
negazpts = []
for j, pt in enumerate(pts):
# if 1st point
if j == 0:
rngm, az, baz = gps2DistAzimuth(pts[j][1], pts[j][0], \
pts[j+1][1], pts[j+1][0])
# if last point
elif j == len(pts) - 1:
rngm, az, baz = gps2DistAzimuth(pts[j-1][1], pts[j-1][0], \
pts[j][1], pts[j][0])
# use points either side (assumes evenly spaced)
else:
rngm, az, baz = gps2DistAzimuth(pts[j-1][1], pts[j-1][0], \
pts[j+1][1], pts[j+1][0])
# get azimuth for new points
azpos = az + 90.
azneg = az - 90.
# get points
posazpts.append(reckon(pts[j][1], pts[j][0], rngkm, azpos))
negazpts.append(reckon(pts[j][1], pts[j][0], rngkm, azneg))
return posazpts, negazpts
def get_line_parallels(pts, rngkm):
from obspy.core.util.geodetics import gps2DistAzimuth
from mapping_tools import reckon
'''
pts are an N x [lon, lat] matrix, i.e.:
[[lon1, lat1],
[lon2, lat2]]
'''
# set outputs
posazpts = []
negazpts = []
for j, pt in enumerate(pts):
# if 1st point
if j == 0:
rngm, az, baz = gps2DistAzimuth(pts[j][1], pts[j][0], \
pts[j+1][1], pts[j+1][0])
# if last point
elif j == len(pts) - 1:
rngm, az, baz = gps2DistAzimuth(pts[j-1][1], pts[j-1][0], \
pts[j][1], pts[j][0])
# use points either side (assumes evenly spaced)
else:
rngm, az, baz = gps2DistAzimuth(pts[j-1][1], pts[j-1][0], \
pts[j+1][1], pts[j+1][0])
# get azimuth for new points
azpos = az + 90.
azneg = az - 90.
# get points
posazpts.append(reckon(pts[j][1], pts[j][0], rngkm, azpos))
negazpts.append(reckon(pts[j][1], pts[j][0], rngkm, azneg))
'''
# for testing only
x=[]
y=[]
xx=[]
yy=[]
xxx=[]
yyy=[]
for j, pt in enumerate(pts):
x.append(pt[0])
y.append(pt[1])
xx.append(posazpts[j][0])
yy.append(posazpts[j][1])
xxx.append(negazpts[j][0])
yyy.append(negazpts[j][1])
plt.plot(x,y,'b-')
plt.plot(xx,yy,'r-')
plt.plot(xxx,yyy,'g-')
plt.show()
'''
return posazpts, negazpts
def process_function(st, inv):
st.detrend("linear")
st.detrend("demean")
st.taper(max_percentage=0.05, type="hann")
st.attach_response(inv)
st.remove_response(output="DISP", pre_filt=pre_filt, zero_mean=False,
taper=False)
st.detrend("linear")
st.detrend("demean")
st.taper(max_percentage=0.05, type="hann")
st.interpolate(sampling_rate=sampling_rate, starttime=starttime,
npts=npts)
station_latitude = inv[0][0].latitude
station_longitude = inv[0][0].longitude
_, baz, _ = gps2DistAzimuth(station_latitude, station_longitude,
event_latitude, event_longitude)
components = [tr.stats.channel[-1] for tr in st]
if "N" in components and "E" in components:
st.rotate(method="NE->RT", back_azimuth=baz)
# Convert to single precision to save space.
for tr in st:
tr.data = np.require(tr.data, dtype="float32")
return st
def StDistandAzi(traces, hyp, dir):
'''
Given a list with st ids, a tuple with
(lat, lon, depth) of the hypocentre and
thw directory with the xml metafiles; it returns
dictionary with the distance and the azimuth of
each station
'''
Stdistribution = {}
for trid in traces:
metafile = dir + "META." + trid + ".xml"
META = DU.getMetadataFromXML(metafile)[trid]
lat = META['latitude']
lon = META['longitude']
dist = locations2degrees(hyp[0],hyp[1],lat,lon)
azi = -np.pi/180.*gps2DistAzimuth(lat,lon,
hyp[0],hyp[1])[2]
Stdistribution[trid] = {'azi' : azi, 'dist' : dist}
#~ fig = plt.figure()
#~ plt.rc('grid', color='#316931', linewidth=1, linestyle='-')
#~ plt.show()
return Stdistribution
def test_issue_375(self):
"""
Test for #375.
"""
_, azim, bazim = gps2DistAzimuth(50, 10, 50 + 1, 10 + 1)
self.assertEqual(round(azim, 0), 32)
self.assertEqual(round(bazim, 0), 213)
_, azim, bazim = gps2DistAzimuth(50, 10, 50 + 1, 10 - 1)
self.assertEqual(round(azim, 0), 328)
self.assertEqual(round(bazim, 0), 147)
_, azim, bazim = gps2DistAzimuth(50, 10, 50 - 1, 10 + 1)
self.assertEqual(round(azim, 0), 147)
self.assertEqual(round(bazim, 0), 327)
_, azim, bazim = gps2DistAzimuth(50, 10, 50 - 1, 10 - 1)
self.assertEqual(round(azim, 0), 213)
self.assertEqual(round(bazim, 0), 33)
def StDistandAzi(traces, hyp, dir):
'''
Given a list with st ids, a tuple with
(lat, lon, depth) of the hypocentre and
thw directory with the xml metafiles; it returns
dictionary with the distance and the azimuth of
each station
'''
Stdistribution = {}
for trid in traces:
metafile = dir + "META." + trid + ".xml"
META = DU.getMetadataFromXML(metafile)[trid]
lat = META['latitude']
lon = META['longitude']
dist = locations2degrees(hyp[0], hyp[1], lat, lon)
azi = -np.pi / 180. * gps2DistAzimuth(lat, lon, hyp[0], hyp[1])[2]
Stdistribution[trid] = {'azi': azi, 'dist': dist}
#~ fig = plt.figure()
#~ plt.rc('grid', color='#316931', linewidth=1, linestyle='-')
#~ plt.show()
return Stdistribution
def test_issue_375(self):
"""
Test for #375.
"""
_, azim, bazim = gps2DistAzimuth(50, 10, 50 + 1, 10 + 1)
self.assertEqual(round(azim, 0), 32)
self.assertEqual(round(bazim, 0), 213)
_, azim, bazim = gps2DistAzimuth(50, 10, 50 + 1, 10 - 1)
self.assertEqual(round(azim, 0), 328)
self.assertEqual(round(bazim, 0), 147)
_, azim, bazim = gps2DistAzimuth(50, 10, 50 - 1, 10 + 1)
self.assertEqual(round(azim, 0), 147)
self.assertEqual(round(bazim, 0), 327)
_, azim, bazim = gps2DistAzimuth(50, 10, 50 - 1, 10 - 1)
self.assertEqual(round(azim, 0), 213)
self.assertEqual(round(bazim, 0), 33)
def src2sta(station_file,source):
'''
Compute cartesian source to station distances and azimuths for all station/source pairs.
IN:
station_file: Path to station file
source: numpy 1d array with source info read from file
coord_type: =0 if coordinates are cartesian, =1 if they are lat/lon
OUT:
d - sorted distances vector in km
az - azimuth from source to station in degrees
'''
from numpy import genfromtxt,zeros,array
from obspy.core.util.geodetics import gps2DistAzimuth
#Read station file
#staname=genfromtxt(home+station_file,dtype="S6",usecols=0)
x=genfromtxt(station_file,dtype="f8",usecols=1)
y=genfromtxt(station_file,dtype="f8",usecols=2)
if x.shape==() or y.shape==(): #Single station file
x=array([x])
y=array([y])
d=zeros(x.shape)
az=zeros(x.shape)
baz=zeros(x.shape)
xs=source[1]
ys=source[2]
for k in range(len(x)):
d[k],az[k],baz[k]=gps2DistAzimuth(ys,xs,y[k],x[k])
d=d/1000
return d,az
def rotate_stream(st, event_latitude, event_longitude,
station_latitude=None, station_longitude=None,
inventory=None, mode="ALL"):
"""
Rotate a stream to radial and transverse components based on the
station information and event information
:param st: input stream
:type st: obspy.Stream
:param event_latitude: event latitude
:type event_latitude: float
:param event_longitude: event longitude
:type event_longitude: float
:param station_latitude: station latitude. If not provided, extract
information from inventory
:type station_latitude: float
:param station_longitude: station longitude. If not provided, extrace
information from inventory
:type station_longitude: float
:param inv: station inventory information. If you want to rotate
"12" components, you need to provide inventory since only station
and station_longitude is not enough.
:type inv: obspy.Inventory
:param mode: rotation mode, could be one of:
1) "NE": rotate only North and East channel to RT
2) "12": rotate only 1 and 2 channel, like "BH1" and "BH2" to RT
3) "all": rotate all components to RT
:return: rotated stream(obspy.Stream)
"""
if station_longitude is None or station_latitude is None:
station_latitude = float(inventory[0][0].latitude)
station_longitude = float(inventory[0][0].longitude)
mode = mode.upper()
if mode not in ["NE", "ALL", "12"]:
raise ValueError("rotate_stream supports mode: 1) 12; 2) NE; 3) ALL")
if mode == "12" and inventory is None:
raise ValueError("Mode '12' required inventory(stationxml) "
"information provided")
_, baz, _ = gps2DistAzimuth(station_latitude, station_longitude,
event_latitude, event_longitude)
components = [tr.stats.channel[-1] for tr in st]
if mode in ["NE", "ALL"]:
if "N" in components and "E" in components:
try:
st.rotate(method="NE->RT", back_azimuth=baz)
except Exception as e:
print e
if mode in ["12", "ALL"]:
if "1" in components and "2" in components:
try:
rotate_12_RT_func(st, inventory, back_azimuth=baz)
except Exception as e:
print e
def distance(lat1, lon1, lat2, lon2):
from obspy.core.util.geodetics import gps2DistAzimuth
rngm, az, baz = gps2DistAzimuth(lat1, lon1, lat2, lon2)
rngkm = rngm / 1000.
return rngkm, az, baz
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_issue_375(self):
"""
Test for #375.
"""
if not HAS_GEOGRAPHICLIB:
return
dist, azim, bazim = gps2DistAzimuth(50, 10, 50 + 1, 10 + 1)
self.assertEqual(round(azim, 0), 32)
self.assertEqual(round(bazim, 0), 213)
dist, azim, bazim = gps2DistAzimuth(50, 10, 50 + 1, 10 - 1)
self.assertEqual(round(azim, 0), 328)
self.assertEqual(round(bazim, 0), 147)
dist, azim, bazim = gps2DistAzimuth(50, 10, 50 - 1, 10 + 1)
self.assertEqual(round(azim, 0), 147)
self.assertEqual(round(bazim, 0), 327)
dist, azim, bazim = gps2DistAzimuth(50, 10, 50 - 1, 10 - 1)
self.assertEqual(round(azim, 0), 213)
self.assertEqual(round(bazim, 0), 33)
def test_issue_375(self):
"""
Test for #375.
"""
if not HAS_GEOGRAPHICLIB:
return
dist, azim, bazim = gps2DistAzimuth(50, 10, 50 + 1, 10 + 1)
self.assertEqual(round(azim, 0), 32)
self.assertEqual(round(bazim, 0), 213)
dist, azim, bazim = gps2DistAzimuth(50, 10, 50 + 1, 10 - 1)
self.assertEqual(round(azim, 0), 328)
self.assertEqual(round(bazim, 0), 147)
dist, azim, bazim = gps2DistAzimuth(50, 10, 50 - 1, 10 + 1)
self.assertEqual(round(azim, 0), 147)
self.assertEqual(round(bazim, 0), 327)
dist, azim, bazim = gps2DistAzimuth(50, 10, 50 - 1, 10 - 1)
self.assertEqual(round(azim, 0), 213)
self.assertEqual(round(bazim, 0), 33)
def rotate_subs(st, stationxmldir, event_loc):
# event info
event_latitude = event_loc[0]
event_longitude = event_loc[1]
# station info
nw = st[0].stats.network
sta = st[0].stats.station
stationxmlfile = os.path.join(stationxmldir, "%s.%s.xml" % (nw, sta))
inv = read_inventory(stationxmlfile)
station_latitude = float(inv[0][0].latitude)
station_longitude = float(inv[0][0].longitude)
_, baz, _ = gps2DistAzimuth(station_latitude, station_longitude, event_latitude, event_longitude)
components = [tr.stats.channel[-1] for tr in st]
print "components:", components
if "N" in components and "E" in components:
_, baz, _ = gps2DistAzimuth(station_latitude, station_longitude, event_latitude, event_longitude)
st.rotate(method="NE->RT", back_azimuth=baz)
def az3(sfile):
azDic = {}
evtlat,evtlon = evcor(sfile) #Obteniendo las coordenadas del evento del sfile en decimal
print evtlat, evtlon
infile = open(sfile,'rU') #Entrando al sfile
for line in infile:
if line[9:11] == 'ES':
#print 'Dentro del if'
station_name = line[1:6].split(' ')[0]
Baz = gps2DistAzimuth(lat1=stacor('corstations.txt')[station_name][0], lon1=stacor('corstations.txt')[station_name][1], lat2=evtlat, lon2=evtlon)
azDic[station_name] = Baz[1]
return azDic
def plot_transect(path,N,tsunlims,dlims,dt,xyannot):
'''
Plot snapshots along a transect
'''
from obspy.core.util.geodetics import gps2DistAzimuth
from string import rjust
from numpy import genfromtxt,zeros
from matplotlib import pyplot as plt
import matplotlib
font = {'family' : 'normal','size' : 14}
matplotlib.rc('font', **font)
trench_index=395 #Where is trench
cut_index=160 #Where is land
trench_index=trench_index-cut_index
fig, axarr = plt.subplots(N, 1)
for k in range(N):
time=k*dt
trackname='AA.f'+rjust(str(k+1),4,'0')+'.track'
t=genfromtxt(path+trackname)
t=t[cut_index:,:]
lon1=t[trench_index,0]
lat1=t[trench_index,1]
d=zeros(len(t))
for n in range(len(t)):
d[n],Az,BAz=gps2DistAzimuth(lat1,lon1,t[n,1],t[n,0])
d=d/1000
d[0:trench_index]=-d[0:trench_index]
tstring=str(time)+'s'
#Plot
ax=axarr[k]
ax.plot(d,t[:,2],'r',lw=2)
ax.set_ylim(tsunlims)
ax.set_xlim(dlims)
ax.grid(which='both')
ax.yaxis.set_ticklabels(['',0,'',10,'',20,''])
if k!=N-1:
ax.xaxis.set_ticklabels([])
ax.annotate(tstring,xy=xyannot,fontsize=14)
if k==N-1:
ax.xaxis.set_label('Distance from trench (km)')
print t[0,0]
print t[-1,0]
print t[0,1]
print t[-1,1]
plt.subplots_adjust(left=0.2, bottom=0.1, right=0.8, top=0.9, wspace=0, hspace=0)
def plot_transect(path, N, tsunlims, dlims, dt, xyannot):
'''
Plot snapshots along a transect
'''
from obspy.core.util.geodetics import gps2DistAzimuth
from numpy import genfromtxt, zeros
from matplotlib import pyplot as plt
import matplotlib
font = {'family': 'normal', 'size': 14}
matplotlib.rc('font', **font)
trench_index = 395 #Where is trench
cut_index = 160 #Where is land
trench_index = trench_index - cut_index
fig, axarr = plt.subplots(N, 1)
for k in range(N):
time = k * dt
trackname = 'AA.f' + str(k + 1).rjust(4, '0') + '.track'
t = genfromtxt(path + trackname)
t = t[cut_index:, :]
lon1 = t[trench_index, 0]
lat1 = t[trench_index, 1]
d = zeros(len(t))
for n in range(len(t)):
d[n], Az, BAz = gps2DistAzimuth(lat1, lon1, t[n, 1], t[n, 0])
d = d / 1000
d[0:trench_index] = -d[0:trench_index]
tstring = str(time) + 's'
#Plot
ax = axarr[k]
ax.plot(d, t[:, 2], 'r', lw=2)
ax.set_ylim(tsunlims)
ax.set_xlim(dlims)
ax.grid(which='both')
ax.yaxis.set_ticklabels(['', 0, '', 10, '', 20, ''])
if k != N - 1:
ax.xaxis.set_ticklabels([])
ax.annotate(tstring, xy=xyannot, fontsize=14)
if k == N - 1:
ax.xaxis.set_label('Distance from trench (km)')
print(t[0, 0])
print(t[-1, 0])
print(t[0, 1])
print(t[-1, 1])
plt.subplots_adjust(left=0.2,
bottom=0.1,
right=0.8,
top=0.9,
wspace=0,
hspace=0)
def calculate_local_magnitude(eventLat, eventLon, sta_lat, sta_lon, ampl):
#print "Try"
epi_dist, az, baz = gps2DistAzimuth(eventLat, eventLon, float(sta_lat), float(sta_lon))
epi_dist = epi_dist / 1000
#print "Azi dist", epi_dist
if epi_dist > 60:
a = 0.0037
b = 3.02
else:
a = 0.018
b = 2.17
ml = log10(ampl * 1000) + a * epi_dist + b
#print 'magnitude', ml
return ml
def calculate_baz(elat, elon, slat, slon):
"""
Calculate back azimuth
:param elat: event latitude
:param elon: event longitude
:param slat: station latitude
:param slon: station longitude
:return: back azimuth
"""
_, _, baz = gps2DistAzimuth(elat, elon, slat, slon)
return baz
def calculate_baz(elat, elon, slat, slon):
"""
Calculate back azimuth
:param elat: event latitude
:param elon: event longitude
:param slat: station latitude
:param slon: station longitude
:return: back azimuth
"""
_, baz, _ = gps2DistAzimuth(elat, elon, slat, slon)
return baz
def get_location_info(self, cmtsource):
"""
calculating azimuth and distance, and then store it
:param cmtsource: cmt source
:return:
"""
self.event_latitude = cmtsource.latitude
self.event_longitude = cmtsource.longitude
# calculate location
dist_in_m, az, baz = gps2DistAzimuth(
self.event_latitude, self.event_longitude,
self.latitude, self.longitude)
self.dist_in_km = dist_in_m / 1000.0
self.azimuth = az
def inrange(center_lat, center_lon, event_lat, event_lon, dist_range):
"""
Checks if event location is inside the range (in km) from the
center location defined by the user
"""
dist = obspy_geo.gps2DistAzimuth(center_lat, center_lon, event_lat,
event_lon)
dist = float(dist[0] / 1000.0)
if dist <= dist_range:
return True
else:
return False
def test_gps2DistAzimuthWithGeographiclib(self):
"""
Testing gps2DistAzimuth function using the module geographiclib.
"""
# nearly antipodal points
result = gps2DistAzimuth(15.26804251, 2.93007342, -14.80522806,
-177.2299081)
self.assertAlmostEqual(result[0], 19951425.048688546)
self.assertAlmostEqual(result[1], 8.65553241932755)
self.assertAlmostEqual(result[2], 351.36325485132306)
# out of bounds
self.assertRaises(ValueError, gps2DistAzimuth, 91, 0, 0, 0)
self.assertRaises(ValueError, gps2DistAzimuth, -91, 0, 0, 0)
self.assertRaises(ValueError, gps2DistAzimuth, 0, 0, 91, 0)
self.assertRaises(ValueError, gps2DistAzimuth, 0, 0, -91, 0)
def calculate_local_magnitude(eventLat, eventLon, sta_lat, sta_lon, ampl):
#print "Try"
epi_dist, az, baz = gps2DistAzimuth(eventLat, eventLon, float(sta_lat),
float(sta_lon))
epi_dist = epi_dist / 1000
#print "Azi dist", epi_dist
if epi_dist > 60:
a = 0.0037
b = 3.02
else:
a = 0.018
b = 2.17
ml = log10(ampl * 1000) + a * epi_dist + b
#print 'magnitude', ml
return ml
def test_gps2DistAzimuthWithGeographiclib(self):
"""
Testing gps2DistAzimuth function using the module geographiclib.
"""
# nearly antipodal points
result = gps2DistAzimuth(15.26804251, 2.93007342, -14.80522806,
-177.2299081)
self.assertAlmostEqual(result[0], 19951425.048688546)
self.assertAlmostEqual(result[1], 8.65553241932755)
self.assertAlmostEqual(result[2], 351.36325485132306)
# out of bounds
self.assertRaises(ValueError, gps2DistAzimuth, 91, 0, 0, 0)
self.assertRaises(ValueError, gps2DistAzimuth, -91, 0, 0, 0)
self.assertRaises(ValueError, gps2DistAzimuth, 0, 0, 91, 0)
self.assertRaises(ValueError, gps2DistAzimuth, 0, 0, -91, 0)
def process_function(st, inv):
st.detrend("linear")
st.detrend("demean")
st.taper(max_percentage=0.05, type="hann")
# Perform a frequency domain taper like during the response removal
# just without an actual response...
for tr in st:
data = tr.data.astype(np.float64)
# smart calculation of nfft dodging large primes
from obspy.signal.util import _npts2nfft
nfft = _npts2nfft(len(data))
fy = 1.0 / (tr.stats.delta * 2.0)
freqs = np.linspace(0, fy, nfft // 2 + 1)
# Transform data to Frequency domain
data = np.fft.rfft(data, n=nfft)
data *= c_sac_taper(freqs, flimit=pre_filt)
data[-1] = abs(data[-1]) + 0.0j
# transform data back into the time domain
data = np.fft.irfft(data)[0:len(data)]
# assign processed data and store processing information
tr.data = data
st.detrend("linear")
st.detrend("demean")
st.taper(max_percentage=0.05, type="hann")
st.interpolate(sampling_rate=sampling_rate,
starttime=starttime,
npts=npts)
components = [tr.stats.channel[-1] for tr in st]
if "N" in components and "E" in components:
station_latitude = inv[0][0].latitude
station_longitude = inv[0][0].longitude
_, baz, _ = gps2DistAzimuth(station_latitude, station_longitude,
event_latitude, event_longitude)
st.rotate(method="NE->RT", back_azimuth=baz)
# Convert to single precision to save space.
for tr in st:
tr.data = np.require(tr.data, dtype="float32")
return st
def process_function(st, inv):
st.detrend("linear")
st.detrend("demean")
st.taper(max_percentage=0.05, type="hann")
# Perform a frequency domain taper like during the response removal
# just without an actual response...
for tr in st:
data = tr.data.astype(np.float64)
# smart calculation of nfft dodging large primes
from obspy.signal.util import _npts2nfft
nfft = _npts2nfft(len(data))
fy = 1.0 / (tr.stats.delta * 2.0)
freqs = np.linspace(0, fy, nfft // 2 + 1)
# Transform data to Frequency domain
data = np.fft.rfft(data, n=nfft)
data *= c_sac_taper(freqs, flimit=pre_filt)
data[-1] = abs(data[-1]) + 0.0j
# transform data back into the time domain
data = np.fft.irfft(data)[0:len(data)]
# assign processed data and store processing information
tr.data = data
st.detrend("linear")
st.detrend("demean")
st.taper(max_percentage=0.05, type="hann")
st.interpolate(sampling_rate=sampling_rate, starttime=starttime,
npts=npts)
components = [tr.stats.channel[-1] for tr in st]
if "N" in components and "E" in components:
station_latitude = inv[0][0].latitude
station_longitude = inv[0][0].longitude
_, baz, _ = gps2DistAzimuth(station_latitude, station_longitude,
event_latitude, event_longitude)
st.rotate(method="NE->RT", back_azimuth=baz)
# Convert to single precision to save space.
for tr in st:
tr.data = np.require(tr.data, dtype="float32")
return st
def rotate_one_station_stream(st,
event_latitude,
event_longitude,
station_latitude=None,
station_longitude=None,
inventory=None,
mode="ALL->RT"):
mode = mode.upper()
mode_options = ["NE->RT", "ALL->RT", "12->RT", "RT->NE"]
if mode not in mode_options:
raise ValueError("rotate_stream mode(%s) should be within %s" %
(mode, mode_options))
if station_latitude is None or station_longitude is None:
nw = st[0].stats.network
station = st[0].stats.station
_inv = inventory.select(network=nw, station=station)
try:
station_latitude = float(_inv[0][0].latitude)
station_longitude = float(_inv[0][0].longitude)
except Exception as err:
print("Error extracting station('%s.%s') info:%s" %
(nw, station, err))
return
_, _, baz = gps2DistAzimuth(event_latitude, event_longitude,
station_latitude, station_longitude)
components = [tr.stats.channel[-1] for tr in st]
if mode in ["NE->RT", "ALL->RT"]:
if "N" in components and "E" in components:
try:
st.rotate(method="NE->RT", back_azimuth=baz)
except Exception as e:
print("Error rotating NE->RT:%s" % e)
if mode in ["12->RT", "ALL->RT"]:
if "1" in components and "2" in components:
try:
rotate_12_RT_func(st, inventory, back_azimuth=baz)
except Exception as e:
print("Error rotating 12->RT:%s" % e)
if mode in ["RT->NE"]:
st.rotate(method="RT->NE", back_azimuth=baz)
def getMatchingEvent(self, xmldata, utctime, lat, lon, timewindow,
distwindow):
root = minidom.parseString(xmldata)
table = root.getElementsByTagName('table')[0]
events = []
matchingEvent = None
for tr in table.childNodes:
if tr.nodeName != 'tr':
continue
#now we're in an event
colidx = 0
event = {}
for td in tr.childNodes:
if td.nodeName != 'td':
continue
if colidx == 1:
anchor = td.getElementsByTagName('a')[0]
event['href'] = anchor.getAttribute('href')
event['id'] = anchor.firstChild.data
if colidx == 2:
datestr = td.firstChild.data
if colidx == 3:
timestr = td.firstChild.data[0:8]
event['time'] = datetime.strptime(datestr + ' ' + timestr,
TIMEFMT)
if colidx == 4:
event['lat'] = float(td.firstChild.data)
if colidx == 5:
event['lon'] = float(td.firstChild.data)
if colidx == 7:
event['mag'] = float(td.firstChild.data)
break
colidx += 1
if event['time'] > utctime:
dt = event['time'] - utctime
else:
dt = utctime - event['time']
dtsecs = dt.days * 86400 + dt.seconds
dd, az1, az2 = gps2DistAzimuth(lat, lon, event['lat'],
event['lon'])
dd = dd / 1000.0
if dtsecs < timewindow and dd < distwindow:
print 'The most likely matching event is %s' % event['id']
matchingEvent = event.copy()
break
return matchingEvent
def get_station_info(self, datalist):
"""
Using the event location and station information to
calculate azimuth and distance
!!! Obsolete, not used any more !!!
:param datalist: data dictionary(referred to pycmt3d.Window.datalist)
:return:
"""
# this might be related to datafile type(sac, mseed or asdf)
event_lat = self.cmtsource.latitude
event_lon = self.cmtsource.longitude
# station location from synthetic file
sta_lat = datalist['synt'].stats.sac['stla']
sta_lon = datalist['synt'].stats.sac['stlo']
dist_in_m, az, baz = \
gps2DistAzimuth(event_lat, event_lon, sta_lat, sta_lon)
return [dist_in_m / 1000.0, az]
def calculateDistAzm(station_list, origin):
"""
Calculates the distance and the azimuth between stream and origin
stream_list = list of objects of class stream
origin = object of class origin
"""
for station in station_list:
_result = obspy_geo.gps2DistAzimuth(origin.latitude, origin.longitude,
station.latitude,
station.longitude)
if _result:
station.distance_by_origin = float(_result[0] / 1000.0)
station.azimuth_by_origin = _result[1]
# removes stations with no streams
return station_list
def rotate_one_station_stream(st, event_latitude, event_longitude,
station_latitude=None, station_longitude=None,
inventory=None, mode="ALL->RT"):
mode = mode.upper()
mode_options = ["NE->RT", "ALL->RT", "12->RT", "RT->NE"]
if mode not in mode_options:
raise ValueError("rotate_stream mode(%s) should be within %s"
% (mode, mode_options))
if station_latitude is None or station_longitude is None:
nw = st[0].stats.network
station = st[0].stats.station
_inv = inventory.select(network=nw, station=station)
try:
station_latitude = float(_inv[0][0].latitude)
station_longitude = float(_inv[0][0].longitude)
except Exception as err:
print("Error extracting station('%s.%s') info:%s"
% (nw, station, err))
return
_, _, baz = gps2DistAzimuth(event_latitude, event_longitude,
station_latitude, station_longitude)
components = [tr.stats.channel[-1] for tr in st]
if mode in ["NE->RT", "ALL->RT"]:
if "N" in components and "E" in components:
try:
st.rotate(method="NE->RT", back_azimuth=baz)
except Exception as e:
print("Error rotating NE->RT:%s" % e)
if mode in ["12->RT", "ALL->RT"]:
if "1" in components and "2" in components:
try:
rotate_12_RT_func(st, inventory, back_azimuth=baz)
except Exception as e:
print("Error rotating 12->RT:%s" % e)
if mode in ["RT->NE"]:
st.rotate(method="RT->NE", back_azimuth=baz)
def getMatchingEvent(self,xmldata,utctime,lat,lon,timewindow,distwindow):
root = minidom.parseString(xmldata)
table = root.getElementsByTagName('table')[0]
events = []
matchingEvent = None
for tr in table.childNodes:
if tr.nodeName != 'tr':
continue
#now we're in an event
colidx = 0
event = {}
for td in tr.childNodes:
if td.nodeName != 'td':
continue
if colidx == 1:
anchor = td.getElementsByTagName('a')[0]
event['href'] = anchor.getAttribute('href')
event['id'] = anchor.firstChild.data
if colidx == 2:
datestr = td.firstChild.data
if colidx == 3:
timestr = td.firstChild.data[0:8]
event['time'] = datetime.strptime(datestr + ' '+timestr,TIMEFMT)
if colidx == 4:
event['lat'] = float(td.firstChild.data)
if colidx == 5:
event['lon'] = float(td.firstChild.data)
if colidx == 7:
event['mag'] = float(td.firstChild.data)
break
colidx += 1
if event['time'] > utctime:
dt = event['time'] - utctime
else:
dt = utctime - event['time']
dtsecs = dt.days*86400 + dt.seconds
dd,az1,az2 = gps2DistAzimuth(lat,lon,event['lat'],event['lon'])
dd = dd/1000.0
if dtsecs < timewindow and dd < distwindow:
print 'The most likely matching event is %s' % event['id']
matchingEvent = event.copy()
break
return matchingEvent
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 checkCatalog(self,time,lat,lon,timewindow,distwindow):
stime = time - timedelta(seconds=NZCATWINDOW)
etime = time + timedelta(seconds=NZCATWINDOW)
url = CATBASE.replace('[START]',stime.strftime(TIMEFMT))
url = url.replace('[END]',etime.strftime(TIMEFMT))
try:
fh = urllib.request.urlopen(url)
data = fh.read().decode('utf-8')
fh.close()
lines = data.split('\n')
vectors = []
eidlist = []
etimelist = []
for line in lines[1:]:
if not len(line.strip()):
break
#time is column 2, longitude is column 4, latitude is column 5
parts = line.split(',')
eid = parts[0]
etime = datetime.strptime(parts[2][0:19],TIMEFMT)
elat = float(parts[5])
elon = float(parts[4])
if etime > time:
dt = etime - time
else:
dt = time - etime
nsecs = dt.days*86400 + dt.seconds
dd,az1,az2 = gps2DistAzimuth(lat,lon,elat,elon)
dd = dd/1000.0
if nsecs <= timewindow and dd < distwindow:
vectors.append(np.sqrt(nsecs**2+dd**2))
eidlist.append(eid)
etimelist.append(etime)
if len(vectors):
idx = vectors.index(min(vectors))
return (eidlist[idx],etimelist[idx])
except Exception as msg:
raise Exception('Could not access the GeoNet website - got error "%s"' % str(msg))
return (None,None)
def plot_all(self, directory, sf=1e5, component='x'):
import seismograms as s
import matplotlib.pylab as plt
from obspy.core.util.geodetics import gps2DistAzimuth
from obspy.core.util.geodetics import kilometer2degrees
for i in range(0, self.n_recs):
a = s.ses3d_seismogram()
a.read(directory, self.recs[i])
#determine epicentral distance
dist_az = gps2DistAzimuth((90.0 - a.rx), a.ry, (90.0 - a.sx), a.sy)
back_az = dist_az[1]
delta_deg = kilometer2degrees(dist_az[0] / 1000.0)
if (component == 'x'):
plt.plot(a.trace_x * sf + delta_deg, a.t, 'k')
elif (component == 'y'):
plt.plot(a.trace_y * sf + delta_deg, a.t, 'k')
elif (component == 'z'):
plt.plot(a.trace_z * sf + delta_deg, a.t, 'k')
plt.show()
def write2sac(d, header, evla, evlo, evdp, mag, output):
sacio = SacIO()
sacio.fromarray(d)
# set the date to today
sacio.SetHvalue('nzyear',header['nzyear'])
sacio.SetHvalue('nzjday',header['nzjday'])
sacio.SetHvalue('delta',0.02)
sacio.SetHvalue('nzhour',header['nzhour'])
sacio.SetHvalue('nzmin',header['nzmin'])
sacio.SetHvalue('nzsec',header['nzsec'])
sacio.SetHvalue('nzmsec',header['nzmsec'])
sacio.SetHvalue('kstnm',header['stnm'])
sacio.SetHvalue('stla',header['stla'])
sacio.SetHvalue('stlo',header['stlo'])
sacio.SetHvalue('kcmpnm',header['comp'])
sacio.SetHvalue('evla',evla)
sacio.SetHvalue('evlo',evlo)
sacio.SetHvalue('evdp',evdp)
sacio.SetHvalue('mag',mag)
#dist = sacio.GetHvalue('dist')
#print dist
dist = gps2DistAzimuth(stla, stlo, evla, evlo)[0] /1000.
sacio.SetHvalue('dist',dist)
#sacio.SetHvalue('knetwk','phones')
#sacio.SetHvalue('kstnm',phone)
#sacio.SetHvalue('kcmpnm',comp)
#sacio.SetHvalue('kevnm',loc)
#sacio.SetHvalue('kuser0',test + ' test')
#sacio.SetHvalue('kuser0',version)
#sacio.SetHvalue('kuser1',brand)
#set the type of the dependent variable as acceleration nm/sec/sec
#sacio.SetHvalue('idep',8)
sacio.WriteSacBinary(output)
def plot_all(self,directory,sf=1e5,component='x'):
import seismograms as s
import matplotlib.pylab as plt
from obspy.core.util.geodetics import gps2DistAzimuth
from obspy.core.util.geodetics import kilometer2degrees
for i in range(0,self.n_recs):
a = s.ses3d_seismogram()
a.read(directory,self.recs[i])
#determine epicentral distance
dist_az = gps2DistAzimuth((90.0-a.rx),a.ry,(90.0-a.sx),a.sy)
back_az = dist_az[1]
delta_deg = kilometer2degrees(dist_az[0]/1000.0)
if (component == 'x'):
plt.plot(a.trace_x*sf + delta_deg, a.t,'k')
elif (component == 'y'):
plt.plot(a.trace_y*sf + delta_deg, a.t,'k')
elif (component == 'z'):
plt.plot(a.trace_z*sf + delta_deg, a.t,'k')
plt.show()
def write2sac(d, header, evla, evlo, evdp, mag, output):
sacio = SacIO()
sacio.fromarray(d)
# set the date to today
sacio.SetHvalue('nzyear', header['nzyear'])
sacio.SetHvalue('nzjday', header['nzjday'])
sacio.SetHvalue('delta', 0.02)
sacio.SetHvalue('nzhour', header['nzhour'])
sacio.SetHvalue('nzmin', header['nzmin'])
sacio.SetHvalue('nzsec', header['nzsec'])
sacio.SetHvalue('nzmsec', header['nzmsec'])
sacio.SetHvalue('kstnm', header['stnm'])
sacio.SetHvalue('stla', header['stla'])
sacio.SetHvalue('stlo', header['stlo'])
sacio.SetHvalue('kcmpnm', header['comp'])
sacio.SetHvalue('evla', evla)
sacio.SetHvalue('evlo', evlo)
sacio.SetHvalue('evdp', evdp)
sacio.SetHvalue('mag', mag)
#dist = sacio.GetHvalue('dist')
#print dist
dist = gps2DistAzimuth(stla, stlo, evla, evlo)[0] / 1000.
sacio.SetHvalue('dist', dist)
#sacio.SetHvalue('knetwk','phones')
#sacio.SetHvalue('kstnm',phone)
#sacio.SetHvalue('kcmpnm',comp)
#sacio.SetHvalue('kevnm',loc)
#sacio.SetHvalue('kuser0',test + ' test')
#sacio.SetHvalue('kuser0',version)
#sacio.SetHvalue('kuser1',brand)
#set the type of the dependent variable as acceleration nm/sec/sec
#sacio.SetHvalue('idep',8)
sacio.WriteSacBinary(output)
def main(args,config):
eventid = args.eventID
shakehome = config.get('SHAKEMAP','shakehome')
xmlfile = os.path.join(shakehome,'data',eventid,'input',args.dataFile)
gridfile = os.path.join(shakehome,'data',eventid,'output','grid.xml')
#list of grid.xml variable names and corresponding data file variable names
variables = [('PGA','acc'),('PGV','vel'),('PSA03','psa03'),('PSA10','psa10'),('PSA30','psa30')]
shakemap = ShakeGrid(gridfile,variable='MMI') #doesn't matter
gdict = shakemap.getGeoDict()
atts = shakemap.getAttributes()
location = atts['event']['event_description']
etime = atts['event']['event_timestamp']
epilat = atts['event']['lat']
epilon = atts['event']['lon']
nrows = gdict['nrows']
ncols = gdict['ncols']
root = minidom.parse(xmlfile)
f = plt.figure(figsize=(8.5,11))
pnum = 1
pgaobs = []
pgaexp = []
pgadist = []
for vartuple in variables:
gridvar,stationvar = vartuple
shakemap = ShakeGrid(gridfile,variable=gridvar)
stations = root.getElementsByTagName('station')
observed = []
expected = []
for i in range(0,len(stations)):
station = stations[i]
lat = float(station.getAttribute('lat'))
lon = float(station.getAttribute('lon'))
row,col = shakemap.getRowCol(lat,lon)
if row < 0 or row > nrows or col < 0 or col > ncols:
continue
pgael = station.getElementsByTagName('comp')[0].getElementsByTagName(stationvar)[0]
pga = float(pgael.getAttribute('value'))
gridpga = shakemap.getValue(lat,lon)
observed.append(pga)
expected.append(gridpga)
if gridvar == 'PGA':
pgaobs.append(pga)
pgaexp.append(gridpga)
distance,az1,az2 = gps2DistAzimuth(epilat,epilon,lat,lon)
pgadist.append(distance/1000.0)
observed = np.array(observed)
expected = np.array(expected)
xmax = observed.max()
ymax = expected.max()
dmax = max(xmax,ymax) * 1.05
v = [0,dmax,0,dmax]
plt.subplot(3,2,pnum)
plt.plot(observed,expected,'b.')
plt.xlabel('Observed %s' % gridvar)
plt.ylabel('Modeled %s' % gridvar)
plt.axis(v)
pnum += 1
#Add in one final plot - pga differences vs distance, just to see if that's a factor
pgaobs = np.array(pgaobs)
pgaexp = np.array(pgaexp)
pgadist = np.array(pgadist)
pgadiff = np.power((pgaobs-pgaexp),2)
mdiff = np.mean(pgadiff)
stddiff = np.std(pgadiff)
ymax = mdiff + 2*stddiff
plt.subplot(3,2,6)
plt.plot(pgadist,pgadiff,'b.')
plt.ylabel('pga diff (squared)')
plt.xlabel('Distance (km)')
plt.axis([0,pgadist.max(),0,ymax])
f.suptitle('Event %s %s - %s' % (eventid,etime.strftime('%Y-%m-%d %H:%M:%S'),location))
plt.savefig('%s_qa.pdf' % eventid)
xi=linspace(Plon[kP][0],Plon[kP][1],1000)
yi=interp(xi, array([Plon[kP][0],Plon[kP][1]]), array([Plat[kP][0],Plat[kP][1]]))
savetxt(table,c_[xi,yi],fmt='%.6f\t%.6f')
#run gmt slicing
run='/Users/dmelgar/code/GMT/coquimbo/slice_slip.gmt'
run=split(run)
p=subprocess.Popen(run)
p.communicate()
#get the slab
slab=genfromtxt('/Users/dmelgar/code/GMT/coquimbo/slab.txt')
distance=zeros(len(slab))
#Convert to distance
for k in range(len(slab)):
distance[k],az,baz=gps2DistAzimuth(slab[0,1],slab[0,0],slab[k,1],slab[k,0])
distance=distance/1000
#Get the topo/bathy
topo=genfromtxt('/Users/dmelgar/code/GMT/coquimbo/topo.txt')
distance_topo=zeros(len(topo))
#Convert to distance
for k in range(len(topo)):
distance_topo[k],az,baz=gps2DistAzimuth(slab[0,1],slab[0,0],topo[k,1],topo[k,0])
if az>baz:
distance_topo[k]=-distance_topo[k]
distance_topo=distance_topo/1000
topo=topo[:,2]/1000
#get the slip
paz_wa = {
'sensitivity': 2800,
'zeros': [0j],
'gain': 1,
'poles': [-6.2832 - 4.7124j, -6.2832 + 4.7124j]
}
st.simulate(paz_remove=paz_le3d5s, paz_simulate=paz_wa, water_level=10)
t = UTCDateTime("2012-04-03T02:45:03")
st.trim(t, t + 50)
tr_n = st.select(component="N")[0]
ampl_n = max(abs(tr_n.data))
tr_e = st.select(component="E")[0]
ampl_e = max(abs(tr_e.data))
ampl = max(ampl_n, ampl_e)
sta_lat = 46.38703
sta_lon = 7.62714
event_lat = 46.218
event_lon = 7.706
epi_dist, az, baz = gps2DistAzimuth(event_lat, event_lon, sta_lat, sta_lon)
epi_dist = epi_dist / 1000
a = 0.018
b = 2.17
ml = log10(ampl * 1000) + a * epi_dist + b
print ml
fout = '/Users/dmelgar/Lefkada2015/scripts/total_up.dtopo'
dt = 1.0
vs = 3300.
epi = array([20.6002, 38.6655])
#load data
d = genfromtxt(f)
lonlat = d[:, 0:2] #lon and lat
d = d[:, 2] #Actual displacememnt
#Compute distance from hypocenter to all points
dist = zeros(len(d))
for k in range(len(d)):
if k % 100 == 0:
print str(k) + '/' + str(len(d))
dist[k], az, baz = gps2DistAzimuth(epi[1], epi[0], lonlat[k, 1], lonlat[k,
0])
#Form full length dtopo vector
tmax = dist.max() / vs
tvec = arange(0, tmax + dt, dt)
t = array([])
#Form time vectopr
for k in range(len(tvec)):
t = r_[t, ones(len(d)) * tvec[k]]
#Form coordinate and dispalcememnt vector
dout = array([])
for k in range(len(tvec)):
dmax = tvec[k] * vs
print dmax
i = where(dist < dmax)[0]
mask = zeros(len(d))
mask[i] = 1
from numpy import genfromtxt, zeros, sin, cos, deg2rad
from mpl_toolkits.mplot3d import Axes3D
from obspy.core.util.geodetics import gps2DistAzimuth
a = genfromtxt('/Users/dmelgar/Lefkada2015/afters/aftershocks_NOA.txt')
f = genfromtxt(
'/Users/dmelgar/Slip_inv/Lefkada70/data/model_info/lefkada65.fault')
lon = a[:, 5]
lat = a[:, 4]
depth = -a[:, 6]
hypo = [20.6002, 38.6655]
x = zeros(len(lon))
y = zeros(len(lon))
for k in range(len(lon)):
dist, az, baz = gps2DistAzimuth(lat[k], lon[k], hypo[1], hypo[0])
x[k] = dist * sin(deg2rad(baz)) / 1000
y[k] = dist * cos(deg2rad(baz)) / 1000
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.scatter(lon, lat, depth)
ax.set_xlabel('lon')
ax.set_ylabel('lat')
ax.set_zlabel('depth (km)')
ax.view_init(azim=-90, elev=90.)
ax.scatter(f[:, 1], f[:, 2], -f[:, 3], c='r', s=100)
ax.set_zlim([0, -20])
ax.set_xlim([20, 21])
ax.set_ylim([38, 39])
st+=read(path+sta[k]+'.HNN.sac')
st2+=read(path+sta[k]+'.HNE.sac')
st3+=read(path+sta[k]+'.HNE.sac')
if st[k].data.max>max_ampl:
max_ampl=st[k].data.max()
st[k].trim(starttime=time_epi,endtime=time_epi+timedelta(seconds=200))
st[k].data=st[k].data-mean(st[k].data[0:50])
st2[k].trim(starttime=time_epi,endtime=time_epi+timedelta(seconds=200))
st2[k].data=st2[k].data-mean(st2[k].data[0:50])
st3[k].trim(starttime=time_epi,endtime=time_epi+timedelta(seconds=200))
st3[k].data=st3[k].data-mean(st3[k].data[0:50])
#Get PGA
aabs=max((st[k].data**2+st2[k].data**2+st3[k].data**2)**0.5)/9.81*100
print sta[k]+', PGA = '+str(aabs)+'%g'
#st[k].data=lowpass(st[k].data,corner,1./st[k].stats.delta,2)
d[k],az,baz=gps2DistAzimuth(epicenter[1],epicenter[0],lonlat[k,1],lonlat[k,0])
d[k]=d[k]/1000
if lonlat[k,1]<epicenter[1]: #It south
d[k]=-d[k]
#Write to file
tout=array([])
aout=array([])
f=open(outfile,'w')
for k in range(len(sta)):
t=st[k].times()
t=(t*t_adjust)+lonlat[k,0]
offset=lonlat[k,1]
a=((st[k].data/1.0)/ampl_adjust)+offset
f.write('>\n')
for kdat in range(len(t)):
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()
except:
pass
if not line:
break
#Compute distances
i = where((pbo_lat < 42) & (pbo_lat > 35))[0]
pbo_lon = pbo_lon[i]
pbo_lat = pbo_lat[i]
f1 = open(fout1, 'w')
f2 = open(fout2, 'w')
for kpbo in range(len(pbo_lon)):
print kpbo
for kseis in range(len(sm_lon)):
d, az, baz = gps2DistAzimuth(pbo_lat[kpbo], pbo_lon[kpbo],
sm_lat[kseis], sm_lon[kseis])
if d < dist_filter:
print 'Found collocation! ' + pbo_sta[i[kpbo]] + ' and ' + sm_sta[
kseis] + ' are ' + str(d) + 'm apart'
out = '%s\t%12.6f\t%12.6f\t%s\t%12.6f\t%12.6f\t%7.1f\n' % (
pbo_sta[i[kpbo]], pbo_lon[kpbo], pbo_lat[kpbo], sm_sta[kseis],
sm_lon[kseis], sm_lat[kseis], d)
f1.write(out)
for kseis in range(len(bb_sm_lon)):
d, az, baz = gps2DistAzimuth(pbo_lat[kpbo], pbo_lon[kpbo],
bb_sm_lat[kseis], bb_sm_lon[kseis])
if d < dist_filter:
print 'Found collocation! ' + pbo_sta[
i[kpbo]] + ' and ' + bb_sm_sta[kseis] + ' are ' + str(
d) + 'm apart'
out = '%s\t%12.6f\t%12.6f\t%s\t%12.6f\t%12.6f\t%7.1f\n' % (
def tr2assoc(tr, pickmap=None):
"""
Takes a sac header dictionary, and produces a list of up to 10
Assoc instances. Header->phase mappings follow SAC2000, i.e.:
* t0: P
* t1: Pn
* t2: Pg
* t3: S
* t4: Sn
* t5: Sg
* t6: Lg
* t7: LR
* t8: Rg
* t9: pP
An alternate mapping for some or all picks can be supplied, however,
as a dictionary of strings in the above form.
Note: arid values will not be filled in, so do:
>>> for assoc in kbio.tables['assoc']:
assoc.arid = lastarid+1
lastarid += 1
"""
pick2phase = {'t0': 'P', 't1': 'Pn', 't2': 'Pg', 't3': 'S',
't4': 'Sn', 't5': 'Sg', 't6': 'Lg', 't7': 'LR', 't8': 'Rg',
't9': 'pP'}
#overwrite defaults with supplied map
if pickmap:
pick2phase.update(pickmap)
#geographic relations
# obspy.read tries to calculate these values if lcalca is True and needed
#header info is there, so we only need to try to if lcalca is False.
#XXX: I just calculate it if no values are currently filled in.
assocdict = {}
try:
assocdict.update(_map_header({'az': 'esaz', 'baz': 'seaz',
'gcarc': 'delta'}, tr.stats.sac,
SACDEFAULT))
except AttributeError:
# no tr.stats.sac
pass
#overwrite if any are None
if not assocdict:
try:
delta = geod.locations2degrees(tr.stats.sac.stla, tr.stats.sac.stlo,
tr.stats.sac.evla, tr.stats.sac.evlo)
m, seaz, esaz = geod.gps2DistAzimuth(tr.stats.sac.stla,
tr.stats.sac.stlo, tr.stats.sac.evla, tr.stats.sac.evlo)
assocdict['esaz'] = esaz
assocdict['seaz'] = seaz
assocdict['delta'] = delta
except (AttributeError, TypeError):
#some sac header values are None
pass
if tr.stats.station:
assocdict['sta'] = tr.stats.station
assocdict.update(_map_header({'norid': 'orid'}, tr.stats.sac, SACDEFAULT))
#now, do the phase arrival mappings
#for each pick in hdr, make a separate dictionary containing assocdict plus
#the new phase info.
assocs = []
for key in pick2phase:
kkey = 'k' + key
#if there's a value in t[0-9]
if tr.stats.sac[key] != SACDEFAULT[key]:
#if the phase name kt[0-9] is null
if tr.stats.sac[kkey] == SACDEFAULT[kkey]:
#take it from the map
iassoc = {'phase': pick2phase[key]}
else:
#take it directly
iassoc = {'phase': tr.stats.sac[kkey]}
iassoc.update(assocdict)
assocs.append(iassoc)
return [Assoc(**assoc) for assoc in assocs]
def main(args, config):
eventid = args.eventID
shakehome = config.get('SHAKEMAP', 'shakehome')
xmlfile = os.path.join(shakehome, 'data', eventid, 'input', args.dataFile)
gridfile = os.path.join(shakehome, 'data', eventid, 'output', 'grid.xml')
#list of grid.xml variable names and corresponding data file variable names
variables = [('PGA', 'acc'), ('PGV', 'vel'), ('PSA03', 'psa03'),
('PSA10', 'psa10'), ('PSA30', 'psa30')]
shakemap = ShakeGrid(gridfile, variable='MMI') #doesn't matter
gdict = shakemap.getGeoDict()
atts = shakemap.getAttributes()
location = atts['event']['event_description']
etime = atts['event']['event_timestamp']
epilat = atts['event']['lat']
epilon = atts['event']['lon']
nrows = gdict['nrows']
ncols = gdict['ncols']
root = minidom.parse(xmlfile)
f = plt.figure(figsize=(8.5, 11))
pnum = 1
pgaobs = []
pgaexp = []
pgadist = []
for vartuple in variables:
gridvar, stationvar = vartuple
shakemap = ShakeGrid(gridfile, variable=gridvar)
stations = root.getElementsByTagName('station')
observed = []
expected = []
for i in range(0, len(stations)):
station = stations[i]
lat = float(station.getAttribute('lat'))
lon = float(station.getAttribute('lon'))
row, col = shakemap.getRowCol(lat, lon)
if row < 0 or row > nrows or col < 0 or col > ncols:
continue
pgael = station.getElementsByTagName(
'comp')[0].getElementsByTagName(stationvar)[0]
pga = float(pgael.getAttribute('value'))
gridpga = shakemap.getValue(lat, lon)
observed.append(pga)
expected.append(gridpga)
if gridvar == 'PGA':
pgaobs.append(pga)
pgaexp.append(gridpga)
distance, az1, az2 = gps2DistAzimuth(epilat, epilon, lat, lon)
pgadist.append(distance / 1000.0)
observed = np.array(observed)
expected = np.array(expected)
xmax = observed.max()
ymax = expected.max()
dmax = max(xmax, ymax) * 1.05
v = [0, dmax, 0, dmax]
plt.subplot(3, 2, pnum)
plt.plot(observed, expected, 'b.')
plt.xlabel('Observed %s' % gridvar)
plt.ylabel('Modeled %s' % gridvar)
plt.axis(v)
pnum += 1
#Add in one final plot - pga differences vs distance, just to see if that's a factor
pgaobs = np.array(pgaobs)
pgaexp = np.array(pgaexp)
pgadist = np.array(pgadist)
pgadiff = np.power((pgaobs - pgaexp), 2)
mdiff = np.mean(pgadiff)
stddiff = np.std(pgadiff)
ymax = mdiff + 2 * stddiff
plt.subplot(3, 2, 6)
plt.plot(pgadist, pgadiff, 'b.')
plt.ylabel('pga diff (squared)')
plt.xlabel('Distance (km)')
plt.axis([0, pgadist.max(), 0, ymax])
f.suptitle('Event %s %s - %s' %
(eventid, etime.strftime('%Y-%m-%d %H:%M:%S'), location))
plt.savefig('%s_qa.pdf' % eventid)
paz_wa = {'sensitivity': 2800, 'zeros': [0j], 'gain': 1,
'poles': [-6.2832-4.7124j, -6.2832+4.7124j]}
client = Client(user="******")
t = st[0].stats.starttime
paz_le3d5s = client.getPAZ("CH", "LKBD", "", "EHZ", t)
st.simulate(paz_remove=paz_le3d5s, paz_simulate=paz_wa, water_level=10)
t = UTCDateTime("2012-04-03T02:45:03")
st.trim(t, t + 50)
tr_n = st.select(component="N")[0]
ampl_n = max(abs(tr_n.data))
tr_e = st.select(component="E")[0]
ampl_e = max(abs(tr_e.data))
ampl = max(ampl_n, ampl_e)
sta_lat = 46.38703
sta_lon = 7.62714
event_lat = 46.218
event_lon = 7.706
epi_dist, az, baz = gps2DistAzimuth(event_lat, event_lon, sta_lat, sta_lon)
epi_dist = epi_dist / 1000
a = 0.018
b = 2.17
ml = log10(ampl * 1000) + a * epi_dist + b
print ml
def distaz_query(records, deg=None, km=None, swath=None):
"""
Out-of-database subset based on distances and/or azimuths.
Parameters
----------
records : iterable of objects with lat, lon attribute floats
Target of the subset.
deg : list or tuple of numbers, optional
(centerlat, centerlon, minr, maxr)
minr, maxr in degrees or None for unconstrained.
km : list or tuple of numbers, optional
(centerlat, centerlon, minr, maxr)
minr, maxr in km or None for unconstrained.
swath : list or tuple of numbers, optional
(lat, lon, azimuth, tolerance)
Azimuth (from North) +/-tolerance from lat,lon point in degrees.
Returns
-------
list
Subset of supplied records.
"""
#initial True array to propagate through multiple logical AND comparisons
mask0 = np.ones(len(records), dtype=np.bool)
if deg:
dgen = (geod.locations2degrees(irec.lat, irec.lon, deg[0], deg[1]) \
for irec in records)
degrees = np.fromiter(dgen, dtype=float)
if deg[2] is not None:
mask0 = np.logical_and(mask0, deg[2] <= degrees)
if deg[3] is not None:
mask0 = np.logical_and(mask0, deg[3] >= degrees)
#mask0 = np.logical_and(mask0, mask)
if km:
#???: this may be backwards
mgen = (geod.gps2DistAzimuth(irec.lat, irec.lon, km[0], km[1])[0] \
for irec in records)
kilometers = np.fromiter(mgen, dtype=float)/1e3
#meters, azs, bazs = zip(*valgen)
#kilometers = np.array(meters)/1e3
if km[2] is not None:
mask0 = np.logical_and(mask0, km[2] <= kilometers)
if km[3] is not None:
mask0 = np.logical_and(mask0, km[3] >= kilometers)
#mask0 = np.logical_and(mask0, mask)
if swath is not None:
minaz = swath[2] - swath[3]
maxaz = swath[2] + swath[3]
#???: this may be backwards
azgen = (geod.gps2DistAzimuth(irec.lat, irec.lon, km[0], km[1])[1] \
for irec in records)
azimuths = np.fromiter(azgen, dtype=float)
mask0 = np.logical_and(mask0, azimuths >= minaz)
mask0 = np.logical_and(mask0, azimuths <= maxaz)
#idx = np.nonzero(np.atleast_1d(mask0))[0] ???
idx = np.nonzero(mask0)[0]
recs = [records[i] for i in idx]
return recs
station_coords=genfromtxt(path+'station_info/melinka.sta',usecols=[1,2])
#Now loop over station data at each epoch
for ksta in range(len(stanames)):
print '... fetching PGD for '+stanames[ksta]
try:
n=read(data_path+'/'+stanames[ksta]+'.LXN.sac')
e=read(data_path+'/'+stanames[ksta]+'.LXE.sac')
u=read(data_path+'/'+stanames[ksta]+'.LXZ.sac')
if n[0].stats.npts>0:
#Trim to times of interest
n.trim(starttime=hypo_time,endtime=hypo_time+tmax,pad=True)
e.trim(starttime=hypo_time,endtime=hypo_time+tmax,pad=True)
u.trim(starttime=hypo_time,endtime=hypo_time+tmax,pad=True)
#Remove mean of first ten seconds
#Get station-event distance
d,az,baz=gps2DistAzimuth(station_coords[ksta,1],station_coords[ksta,0],hypo[1],hypo[0])
hypo_dist=((d/1000)**2+hypo[2]**2)**0.5
#Now get PGD at that site
pgd_all_out=0
pgd_nov_out=0
time_to_all=0
time_to_nov=0
f=open(path+'PGD/Melinka2016/'+stanames[ksta]+'.pgd','w')
f.write('# Seconds after OT , no horiz PGD [m] , all PGD [m] , seconds to horiz , seconds to all , hypo_dist [km]\n')
for kt in range(len(n[0].times())):
#print kt
pgd_all=(n[0].data[kt]**2+e[0].data[kt]**2+u[0].data[kt]**2)**0.5
pgd_nov=(n[0].data[kt]**2+e[0].data[kt]**2)**0.5
if pgd_all>pgd_all_out:
pgd_all_out=pgd_all
time_to_all=kt
def process_synt(datadir, station, event = None, stationxml_dir = None, period_band = None, npts=None,
sampling_rate=None, output_dir=None, suffix=None):
# ensemble the stream
#station_list = generate_station_list(datadir)
#for station in station_list:
zdatafile = station[0] + "." + station[1] + ".MXZ.sem.sac"
ndatafile = station[0] + "." + station[1] + ".MXN.sem.sac"
edatafile = station[0] + "." + station[1] + ".MXE.sem.sac"
zpath = os.path.join(datadir, zdatafile)
npath = os.path.join(datadir, ndatafile)
epath = os.path.join(datadir, edatafile)
st = read(zpath)
st2 = read(npath)
st3 = read(epath)
#print st
#print st2
st.append(st2[0])
st.append(st3[0])
#print "\nProcessing file: %s" %filename
# interpolation value
#npts = 3630
#sampling_rate = 1.0 # Hz
min_period = period_band[0]
max_period = period_band[1]
f2 = 1.0 / max_period
f3 = 1.0 / min_period
f1 = 0.8 * f2
f4 = 1.2 * f3
pre_filt = (f1, f2, f3, f4)
# fetch event information
event_name = get_event_name(event)
short_event_name = adjust_event_name(event_name)
origin = event.preferred_origin() or event.origins[0]
event_latitude = origin.latitude
event_longitude = origin.longitude
event_time = origin.time
event_depth = origin.depth
starttime = event_time
print "event_time:",event_time
#output_path = os.path.join(output_dir, short_event_name)
if not os.path.exists(output_dir):
os.makedirs(output_dir)
nrecords = len(st)
# processing
for i, tr in enumerate(st):
#get component name
cmpname = tr.stats.channel
#print tr.stats
#tr.interpolate(sampling_rate=sampling_rate, starttime=starttime,
# npts=npts)
#tr.decimate(4, strict_length=False,no_filter=True)
print "Processing %d of total %d" %(i+1, nrecords)
print "Detrend, Demean and Taper..."
tr.detrend("linear")
tr.detrend("demean")
tr.taper(max_percentage=0.05, type="hann")
#print "response show:"
#print tr.stats.response
# Perform a frequency domain taper like during the response removal
# just without an actual response...
#for tr in st:
print "Filtering..."
data = tr.data.astype(np.float64)
# smart calculation of nfft dodging large primes
from obspy.signal.util import _npts2nfft
nfft = _npts2nfft(len(data))
fy = 1.0 / (tr.stats.delta * 2.0)
freqs = np.linspace(0, fy, nfft // 2 + 1)
# Transform data to Frequency domain
data = np.fft.rfft(data, n=nfft)
data *= c_sac_taper(freqs, flimit=pre_filt)
data[-1] = abs(data[-1]) + 0.0j
# transform data back into the time domain
data = np.fft.irfft(data)[0:len(data)]
# assign processed data and store processing information
tr.data = data
print "Detrend, Demean and Taper again..."
tr.detrend("linear")
tr.detrend("demean")
tr.taper(max_percentage=0.05, type="hann")
print "Interpolate..."
try:
tr.interpolate(sampling_rate=sampling_rate, starttime=starttime,
npts=npts)
except:
print "Error"
return
# rotate
station_latitude = st[0].stats.sac['stla']
station_longitude = st[0].stats.sac['stlo']
event_latitude = st[0].stats.sac['evla']
event_longitude = st[0].stats.sac['evlo']
#print station_latitude, station_longitude
#print station_latitude, station_longitude
_, baz, _ = gps2DistAzimuth(station_latitude, station_longitude,
event_latitude, event_longitude)
print st
st.rotate(method="NE->RT", back_azimuth=baz)
# write out
print st
for tr in st:
comp = tr.stats.channel
outfn = station[0] + "." + station[1] + "." + comp + ".sac"
if suffix is not None and suffix != "":
outfn = outfn + "." + suffix
outpath = os.path.join(output_dir, outfn)
print "file saved:", outpath
tr.stats.sac['b'] = 0
tr.stats.sac['iztype'] = 9
tr.write(outpath, format="SAC")
def update(self, 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 and
self.st_copy is None):
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": "north", "e": "east"},
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.info.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 (not bool(self.ui.auto_update_check_box.checkState()) and
self.ui.finsource_tab.currentIndex() == 1 and
not force):
st = self.st_copy.copy()
else:
prog_diag = QtGui.QProgressDialog(
"Calculating", "Cancel", 0, len(self.finite_source), self)
prog_diag.setWindowModality(QtCore.Qt.WindowModal)
prog_diag.setMinimumDuration(0)
def get_prog_fct():
def set_value(value, count):
prog_diag.setValue(value)
if prog_diag.wasCanceled():
return True
return set_value
prog_diag.setValue(0)
st = self.instaseis_db.get_seismograms_finite_source(
sources=self.finite_source, receiver=self.receiver, dt=dt,
components=('Z', 'N', 'E'),
progress_callback=get_prog_fct())
prog_diag.setValue(len(self.finite_source))
if not st:
return
baz = geodetics.gps2DistAzimuth(
self.finite_source.CMT.latitude,
self.finite_source.CMT.longitude,
rec.latitude, rec.longitude)[2]
self.st_copy = st.copy()
st.rotate('NE->RT', baz)
st += self.st_copy
self.st_copy = st.copy()
if self.ui.finsource_tab.currentIndex() == 1 \
and bool(self.ui.plot_CMT_check_box.checkState()):
st_cmt = self.instaseis_db.get_seismograms(
source=self.finite_source.CMT, receiver=self.receiver,
dt=dt, components=components_map[components_choice],
reconvolve_stf=True)
else:
st_cmt = None
# check filter values from the UI
zp = bool(self.ui.zero_phase_check_box.checkState())
if bool(self.ui.lowpass_check_box.checkState()):
try:
freq = 1.0 / float(self.ui.lowpass_period.value())
st.filter('lowpass', freq=freq, zerophase=zp)
if st_cmt is not None:
st_cmt.filter('lowpass', freq=freq, zerophase=zp)
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=zp)
if st_cmt is not None:
st_cmt.filter('highpass', freq=freq, zerophase=zp)
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 = geodetics.locations2degrees(
src_latitude, src_longitude,
rec.latitude, rec.longitude)
self.tts = tau_model.get_travel_times(
source_depth_in_km=src_depth_in_m / 1000.0,
distance_in_degree=great_circle_distance)
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")
plot_widget.ptp = tr.data.ptp()
if st_cmt is not None:
tr = st_cmt.select(
component=components_map[components_choice][ic])[0]
times = tr.times()
plot_widget.plot(times, tr.data, pen="r")
if bool(self.ui.tt_times.checkState()):
tts = []
for tt in self.tts:
if tt.time >= times[-1]:
continue
tts.append(tt)
if tt.name[0].lower() == "p":
pen = "#008c2866"
else:
pen = "#95000066"
plot_widget.addLine(x=tt.time, pen=pen, z=-10)
self.tts = tts
self.set_info()
def vespagram(stream, ev, inv, method, frqlow, frqhigh, baz, scale, nthroot=4,
filter=True, static3D=False, vel_corr=4.8, sl=(0.0, 10.0, 0.5),
align=False, align_phase=['P', 'Pdiff'], plot_trace=True):
"""
vespagram wrapper routine for MESS 2014.
:param stream: Waveforms for the array processing.
:type stream: :class:`obspy.core.stream.Stream`
:param inventory: Station metadata for waveforms
:type inventory: :class:`obspy.station.inventory.Inventory`
:param method: Method used for the array analysis
(one of "DLS": Delay and Sum, "PWS": Phase Weighted Stack).
:type method: str
:param frqlow: Low corner of frequency range for array analysis
:type frqlow: float
:param frqhigh: High corner of frequency range for array analysis
:type frqhigh: float
:param baz: pre-defined (theoretical or calculated) backazimuth used for calculation
:type baz_plot: float
:param scale: scale for plotting
:type scale: float
:param nthroot: estimating the nthroot for calculation of the beam
:type nthroot: int
:param filter: Whether to bandpass data to selected frequency range
:type filter: bool
:param static3D: static correction of topography using `vel_corr` as
velocity (slow!)
:type static3D: bool
:param vel_corr: Correction velocity for static topography correction in
km/s.
:type vel_corr: float
:param sl: Min/Max and stepwidthslowness for analysis
:type sl: (float, float,float)
:param align: whether to align the vespagram to a certain phase
:type align: bool
:param align_phase: phase to be aligned with (might be a list if simulateneous arivials are expected (P,PcP,Pdif)
:type align: str
:param plot_trace: if True plot the vespagram as wiggle plot, if False as density map
:type align: bool
"""
starttime = max([tr.stats.starttime for tr in stream])
endtime = min([tr.stats.endtime for tr in stream])
stream.trim(starttime, endtime)
org = ev.preferred_origin() or ev.origins[0]
ev_lat = org.latitude
ev_lon = org.longitude
ev_depth = org.depth/1000. # in km
ev_otime = org.time
sll, slm, sls = sl
sll /= KM_PER_DEG
slm /= KM_PER_DEG
sls /= KM_PER_DEG
center_lon = 0.
center_lat = 0.
center_elv = 0.
seismo = stream
seismo.attach_response(inv)
seismo.merge()
sz = Stream()
i = 0
for tr in seismo:
for station in inv[0].stations:
if tr.stats.station == station.code:
tr.stats.coordinates = \
AttribDict({'latitude': station.latitude,
'longitude': station.longitude,
'elevation': station.elevation})
center_lon += station.longitude
center_lat += station.latitude
center_elv += station.elevation
i += 1
sz.append(tr)
center_lon /= float(i)
center_lat /= float(i)
center_elv /= float(i)
starttime = max([tr.stats.starttime for tr in stream])
stt = starttime
endtime = min([tr.stats.endtime for tr in stream])
e = endtime
stream.trim(starttime, endtime)
#nut = 0
max_amp = 0.
sz.trim(stt, e)
sz.detrend('simple')
print sz
fl, fh = frqlow, frqhigh
if filter:
sz.filter('bandpass', freqmin=fl, freqmax=fh, zerophase=True)
if align:
deg = []
shift = []
res = gps2DistAzimuth(center_lat, center_lon, ev_lat, ev_lon)
deg.append(kilometer2degrees(res[0]/1000.))
tt = getTravelTimes(deg[0], ev_depth, model='ak135')
for item in tt:
phase = item['phase_name']
if phase in align_phase:
try:
travel = item['time']
travel = ev_otime.timestamp + travel
dtime = travel - stt.timestamp
shift.append(dtime)
except:
break
for i, tr in enumerate(sz):
res = gps2DistAzimuth(tr.stats.coordinates['latitude'],
tr.stats.coordinates['longitude'],
ev_lat, ev_lon)
deg.append(kilometer2degrees(res[0]/1000.))
tt = getTravelTimes(deg[i+1], ev_depth, model='ak135')
for item in tt:
phase = item['phase_name']
if phase in align_phase:
try:
travel = item['time']
travel = ev_otime.timestamp + travel
dtime = travel - stt.timestamp
shift.append(dtime)
except:
break
shift = np.asarray(shift)
shift -= shift[0]
AA.shifttrace_freq(sz, -shift)
baz += 180.
nbeam = int((slm - sll)/sls + 0.5) + 1
kwargs = dict(
# slowness grid: X min, X max, Y min, Y max, Slow Step
sll=sll, slm=slm, sls=sls, baz=baz, stime=stt, method=method,
nthroot=nthroot, etime=e, correct_3dplane=False, static_3D=static3D,
vel_cor=vel_corr)
start = UTCDateTime()
slow, beams, max_beam, beam_max = AA.vespagram_baz(sz, **kwargs)
print "Total time in routine: %f\n" % (UTCDateTime() - start)
df = sz[0].stats.sampling_rate
# Plot the seismograms
npts = len(beams[0])
print npts
T = np.arange(0, npts/df, 1/df)
sll *= KM_PER_DEG
slm *= KM_PER_DEG
sls *= KM_PER_DEG
slow = np.arange(sll, slm, sls)
max_amp = np.max(beams[:, :])
#min_amp = np.min(beams[:, :])
scale *= sls
fig = plt.figure(figsize=(12, 8))
if plot_trace:
ax1 = fig.add_axes([0.1, 0.1, 0.85, 0.85])
for i in xrange(nbeam):
if i == max_beam:
ax1.plot(T, sll + scale*beams[i]/max_amp + i*sls, 'r',
zorder=1)
else:
ax1.plot(T, sll + scale*beams[i]/max_amp + i*sls, 'k',
zorder=-1)
ax1.set_xlabel('Time [s]')
ax1.set_ylabel('slowness [s/deg]')
ax1.set_xlim(T[0], T[-1])
data_minmax = ax1.yaxis.get_data_interval()
minmax = [min(slow[0], data_minmax[0]), max(slow[-1], data_minmax[1])]
ax1.set_ylim(*minmax)
#####
else:
#step = (max_amp - min_amp)/100.
#level = np.arange(min_amp, max_amp, step)
#beams = beams.transpose()
#cmap = cm.hot_r
cmap = cm.rainbow
ax1 = fig.add_axes([0.1, 0.1, 0.85, 0.85])
#ax1.contour(slow,T,beams,level)
#extent = (slow[0], slow[-1], \
# T[0], T[-1])
extent = (T[0], T[-1], slow[0] - sls * 0.5, slow[-1] + sls * 0.5)
ax1.set_ylabel('slowness [s/deg]')
ax1.set_xlabel('T [s]')
beams = np.flipud(beams)
ax1.imshow(beams, cmap=cmap, interpolation="nearest",
extent=extent, aspect='auto')
####
result = "BAZ: %.2f Time %s" % (baz-180., stt)
ax1.set_title(result)
plt.show()
return slow, beams, max_beam, beam_max
def hilbert(params, segment):
"""@calculates hilbert transform for given segment.
@param params
seismon params dictionary
@param segment
[start,end] gps
"""
from obspy.core.util.geodetics import gps2DistAzimuth
ifo = seismon.utils.getIfo(params)
ifolat, ifolon = seismon.utils.getLatLon(params)
gpsStart = segment[0]
gpsEnd = segment[1]
# set the times
duration = np.ceil(gpsEnd - gpsStart)
dataAll = []
print("Loading data...")
for channel in params["channels"]:
# make timeseries
dataFull = seismon.utils.retrieve_timeseries(params, channel, segment)
if dataFull == []:
continue
dataFull = dataFull / channel.calibration
indexes = np.where(np.isnan(dataFull.data))[0]
meanSamples = np.mean(
np.ma.masked_array(dataFull.data, np.isnan(dataFull.data)))
for index in indexes:
dataFull[index] = meanSamples
dataFull -= np.mean(dataFull.data)
if np.mean(dataFull.data) == 0.0:
print("data only zeroes... continuing\n")
continue
if len(dataFull.data) < 2 * channel.samplef:
print("timeseries too short for analysis... continuing\n")
continue
#cutoff = 0.01
#dataFull = dataFull.lowpass(cutoff, amplitude=0.9, order=3, method='scipy')
dataAll.append(dataFull)
if len(dataAll) == 0:
print("No data... returning")
return
if params["doEarthquakes"]:
earthquakesDirectory = os.path.join(params["path"], "earthquakes")
earthquakesXMLFile = os.path.join(earthquakesDirectory,
"earthquakes.xml")
attributeDics = seismon.utils.read_eqmons(earthquakesXMLFile)
else:
attributeDics = []
print("Performing Hilbert transform")
for attributeDic in attributeDics:
if params["ifo"] == "IRIS":
attributeDic = seismon.eqmon.ifotraveltimes(
attributeDic, "IRIS", channel.latitude, channel.longitude)
traveltimes = attributeDic["traveltimes"]["IRIS"]
else:
traveltimes = attributeDic["traveltimes"][ifo]
doTilt = 0
for dataFull in dataAll:
if "_X_" in dataFull.channel.name or "E" == dataFull.channel.name[
-1]:
tsx = dataFull.data
if "_Y_" in dataFull.channel.name or "N" == dataFull.channel.name[
-1]:
tsy = dataFull.data
if "_Z_" in dataFull.channel.name:
tsz = dataFull.data
if "_RY_" in dataFull.channel.name:
tttilt = np.array(dataFull.times)
tstilt = dataFull.data
doTilt = 1
tt = np.array(dataAll[0].times)
fs = 1.0 / (tt[1] - tt[0])
if doTilt:
tstilt = np.interp(tt, tttilt, tstilt)
Ptime = max(traveltimes["Ptimes"])
Stime = max(traveltimes["Stimes"])
Rtwotime = max(traveltimes["Rtwotimes"])
RthreePointFivetime = max(traveltimes["RthreePointFivetimes"])
Rfivetime = max(traveltimes["Rfivetimes"])
distance = max(traveltimes["Distances"])
indexes = np.intersect1d(
np.where(tt >= Rfivetime)[0],
np.where(tt <= Rtwotime)[0])
indexes = np.intersect1d(
np.where(tt >= tt[0])[0],
np.where(tt <= tt[-1])[0])
if len(indexes) == 0:
continue
indexMin = np.min(indexes)
indexMax = np.max(indexes)
tt = tt[indexes]
tsx = tsx[indexes]
tsy = tsy[indexes]
tsz = tsz[indexes]
if doTilt:
tstilt = tstilt[indexes]
cutoff_high = 0.01 # 10 MHz
cutoff_low = 0.3
n = 3
worN = 16384
B_low, A_low = scipy.signal.butter(n,
cutoff_low / (fs / 2.0),
btype='lowpass')
#w_low, h_low = scipy.signal.freqz(B_low,A_low)
w_low, h_low = scipy.signal.freqz(B_low, A_low, worN=worN)
B_high, A_high = scipy.signal.butter(n,
cutoff_high / (fs / 2.0),
btype='highpass')
w_high, h_high = scipy.signal.freqz(B_high, A_high, worN=worN)
dataLowpass = scipy.signal.lfilter(B_low, A_low, tstilt,
axis=0).view(dataFull.__class__)
dataHighpass = scipy.signal.lfilter(
B_high, A_high, tstilt, axis=0).view(dataFull.__class__)
dataTilt = dataHighpass.view(dataHighpass.__class__)
#dataTilt = tstilt.view(tstilt.__class__)
dataTilt = gwpy.timeseries.TimeSeries(dataTilt)
dataTilt.sample_rate = dataFull.sample_rate
dataTilt.epoch = Rfivetime
tszhilbert = scipy.signal.hilbert(tsz).imag
tszhilbert = -tszhilbert
dataHilbert = tszhilbert.view(tsz.__class__)
dataHilbert = gwpy.timeseries.TimeSeries(dataHilbert)
dataHilbert.sample_rate = dataFull.sample_rate
dataHilbert.epoch = Rfivetime
distance, fwd, back = gps2DistAzimuth(attributeDic["Latitude"],
attributeDic["Longitude"],
ifolat, ifolon)
xazimuth, yazimuth = seismon.utils.getAzimuth(params)
angle1 = fwd
rot1 = np.array([[np.cos(angle1), -np.sin(angle1)],
[np.sin(angle1), np.cos(angle1)]])
angle2 = xazimuth * (np.pi / 180.0)
rot2 = np.array([[np.cos(angle2), -np.sin(angle2)],
[np.sin(angle2), np.cos(angle2)]])
angleEQ = np.mod(angle1 + angle2, 2 * np.pi)
rot = np.array([[np.cos(angleEQ), -np.sin(angleEQ)],
[np.sin(angleEQ), np.cos(angleEQ)]])
twodarray = np.vstack([tsx, tsy])
z = rot.dot(twodarray)
tsxy = np.sum(z.T, axis=1)
dataXY = tsxy.view(tsz.__class__)
dataXY = gwpy.timeseries.TimeSeries(tsxy)
dataXY.sample_rate = dataFull.sample_rate
dataXY.epoch = Rfivetime
dataHilbert = dataHilbert.resample(16)
dataXY = dataXY.resample(16)
if doTilt:
dataTilt = dataTilt.resample(16)
if params["doPlots"]:
plotDirectory = params["path"] + "/Hilbert"
seismon.utils.mkdir(plotDirectory)
dataHilbert *= 1e6
dataXY *= 1e6
pngFile = os.path.join(plotDirectory,
"%s.png" % (attributeDic["eventName"]))
plot = gwpy.plotter.TimeSeriesPlot(figsize=[14, 8])
kwargs = {"linestyle": "-", "color": "b"}
plot.add_timeseries(dataHilbert, label="Hilbert", **kwargs)
kwargs = {"linestyle": "-", "color": "g"}
plot.add_timeseries(dataXY, label="XY", **kwargs)
plot.ylabel = r"Velocity [$\mu$m/s]"
plot.add_legend(loc=1, prop={'size': 10})
plot.save(pngFile)
plot.close()
dataHilbert = tszhilbert.view(tsz.__class__)
dataHilbert = gwpy.timeseries.TimeSeries(dataHilbert)
dataHilbert.sample_rate = dataFull.sample_rate
dataHilbert.epoch = Rfivetime
dataHilbert = dataHilbert.resample(16)
angles = np.linspace(0, 2 * np.pi, 10)
xcorrs = []
for angle in angles:
rot = np.array([[np.cos(angle), -np.sin(angle)],
[np.sin(angle), np.cos(angle)]])
twodarray = np.vstack([tsx, tsy])
z = rot.dot(twodarray)
tsxy = np.sum(z.T, axis=1)
dataXY = tsxy.view(tsz.__class__)
dataXY = gwpy.timeseries.TimeSeries(tsxy)
dataXY.sample_rate = dataFull.sample_rate
dataXY.epoch = Rfivetime
dataXY = dataXY.resample(16)
xcorr, lags = seismon.utils.xcorr(dataHilbert.data,
dataXY.data,
maxlags=1)
xcorrs.append(xcorr[1])
xcorrs = np.array(xcorrs)
angleMax = angles[np.argmax(xcorrs)]
rot = np.array([[np.cos(angleMax), -np.sin(angleMax)],
[np.sin(angleMax), np.cos(angleMax)]])
twodarray = np.vstack([tsx, tsy])
z = rot.dot(twodarray)
tsxy = np.sum(z.T, axis=1)
dataXY = tsxy.view(tsz.__class__)
dataXY = gwpy.timeseries.TimeSeries(tsxy)
dataXY.sample_rate = dataFull.sample_rate
dataXY.epoch = Rfivetime
dataXY = dataXY.resample(16)
if params["doPlots"]:
plotDirectory = params["path"] + "/Hilbert"
seismon.utils.mkdir(plotDirectory)
dataHilbert *= 1e6
dataXY *= 1e6
if doTilt:
dataTilt *= 1e6 * (9.81) / (2 * np.pi * 0.01)
pngFile = os.path.join(plotDirectory,
"%s-max.png" % (attributeDic["eventName"]))
plot = gwpy.plotter.TimeSeriesPlot(figsize=[14, 8])
kwargs = {"linestyle": "-", "color": "b"}
plot.add_timeseries(dataHilbert, label="Hilbert", **kwargs)
kwargs = {"linestyle": "-", "color": "g"}
plot.add_timeseries(dataXY, label="XY", **kwargs)
plot.ylabel = r"Velocity [$\mu$m/s]"
plot.add_legend(loc=1, prop={'size': 10})
plot.save(pngFile)
plot.close()
pngFile = os.path.join(plotDirectory,
"%s-rot.png" % (attributeDic["eventName"]))
plot = gwpy.plotter.Plot(figsize=[14, 8])
kwargs = {"linestyle": "-", "color": "b"}
plot.add_line(angles, xcorrs, label="Xcorrs", **kwargs)
ylim = [plot.ylim[0], plot.ylim[1]]
kwargs = {"linestyle": "--", "color": "r"}
plot.add_line([angleEQ, angleEQ], ylim, label="EQ", **kwargs)
plot.ylabel = r"XCorr"
plot.xlabel = r"Angle [rad]"
plot.add_legend(loc=1, prop={'size': 10})
plot.save(pngFile)
plot.close()
dataHilbert = dataHilbert.resample(1.0)
dataXY = dataXY.resample(1.0)
if doTilt:
dataTilt = dataTilt.resample(1.0)
dataHilbertAbs = np.absolute(dataHilbert)
dataXYAbs = np.absolute(dataXY)
dataRatio = dataXYAbs / dataHilbertAbs
meanValue = np.median(np.absolute(dataRatio))
dataXYScale = dataXY / meanValue
dataXYScale = gwpy.timeseries.TimeSeries(dataXYScale)
dataXYScale.sample_rate = dataXY.sample_rate
dataXYScale.epoch = dataXY.epoch
if params["doPlots"]:
plotDirectory = params["path"] + "/Hilbert"
seismon.utils.mkdir(plotDirectory)
pngFile = os.path.join(
plotDirectory, "%s-max-abs.png" % (attributeDic["eventName"]))
plot = gwpy.plotter.TimeSeriesPlot(figsize=[14, 8])
kwargs = {"linestyle": "-", "color": "b"}
plot.add_timeseries(dataHilbertAbs, label="Hilbert", **kwargs)
kwargs = {"linestyle": "-", "color": "g"}
plot.add_timeseries(dataXYAbs, label="XY", **kwargs)
plot.ylabel = r"Velocity [$\mu$m/s]"
plot.add_legend(loc=1, prop={'size': 10})
plot.save(pngFile)
plot.close()
pngFile = os.path.join(
plotDirectory,
"%s-max-scale.png" % (attributeDic["eventName"]))
plot = gwpy.plotter.TimeSeriesPlot(figsize=[14, 8])
kwargs = {"linestyle": "-", "color": "b"}
plot.add_timeseries(dataHilbert, label="Hilbert", **kwargs)
kwargs = {"linestyle": "-", "color": "g"}
plot.add_timeseries(dataXYScale, label="XY Scaled", **kwargs)
plot.ylabel = r"Velocity [$\mu$m/s]"
plot.add_legend(loc=1, prop={'size': 10})
plot.save(pngFile)
plot.close()
pngFile = os.path.join(
plotDirectory, "%s-ratio.png" % (attributeDic["eventName"]))
plot = gwpy.plotter.TimeSeriesPlot(figsize=[14, 8])
kwargs = {"linestyle": "-", "color": "k"}
plot.add_timeseries(np.absolute(dataRatio),
label="Ratio",
**kwargs)
plot.ylabel = r"Ratio [XY / Hilbert(Z)]"
xlim = [plot.xlim[0], plot.xlim[1]]
kwargs = {"linestyle": "-", "color": "r"}
plot.add_line(xlim, [0.78, 0.78], label="PREM", **kwargs)
plot.title = "Median Ratio: %.3f" % (meanValue)
#plot.ylim = [0,100]
plot.axes[0].set_yscale("log")
plot.add_legend(loc=1, prop={'size': 10})
plot.save(pngFile)
plot.close()
if doTilt:
pngFile = os.path.join(
plotDirectory,
"%s-max-scale-tilt.png" % (attributeDic["eventName"]))
plot = gwpy.plotter.TimeSeriesPlot(figsize=[14, 8])
kwargs = {"linestyle": "-", "color": "b"}
plot.add_timeseries(dataHilbert, label="Hilbert", **kwargs)
kwargs = {"linestyle": "-", "color": "g"}
plot.add_timeseries(dataXYScale, label="XY Scaled", **kwargs)
kwargs = {"linestyle": "-", "color": "k"}
plot.add_timeseries(dataTilt, label="Tiltmeter", **kwargs)
plot.ylabel = r"Velocity [$\mu$m/s]"
plot.add_legend(loc=1, prop={'size': 10})
plot.save(pngFile)
plot.close()
kkn4_Re = R[:, 1]
kkn4_Ru = R[:, 2]
R = genfromtxt(u'/Users/dmelgar/Nepal2015/Response_Spectra/NAST.vel.resp',
usecols=[1, 2, 3])
nast_Rn = R[:, 0]
nast_Re = R[:, 1]
nast_Ru = R[:, 2]
R = genfromtxt(u'/Users/dmelgar/Nepal2015/Response_Spectra/KATNP.vel.resp',
usecols=[1, 2, 3])
katnp_Rn = R[:, 0]
katnp_Re = R[:, 1]
katnp_Ru = R[:, 2]
#Get distances
[d_nast, a, b] = gps2DistAzimuth(nast_n[0].stats['sac']['stla'],
nast_n[0].stats['sac']['stlo'], epicenter[1],
epicenter[0])
d_nast = int(d_nast / 1000)
[d_kkn4, a, b] = gps2DistAzimuth(kkn4_n[0].stats['sac']['stla'],
kkn4_n[0].stats['sac']['stlo'], epicenter[1],
epicenter[0])
d_kkn4 = int(d_kkn4 / 1000)
[d_katnp, a, b] = gps2DistAzimuth(katnp_n[0].stats['sac']['stla'],
katnp_n[0].stats['sac']['stlo'],
epicenter[1], epicenter[0])
d_katnp = int(d_katnp / 1000)
kkn4_n.trim(starttime=time_epi)
kkn4_e.trim(starttime=time_epi)
kkn4_u.trim(starttime=time_epi)
nast_n.trim(starttime=time_epi)