def data_engine_pgd(eq_lat, eq_lon, eq_dep, to, sta_lat, sta_lon, sta_alt,
nbuff, ebuff, ubuff, tbuff, runtime, Tlatency):
disp = numpy.sqrt(
numpy.power(nbuff, 2) + numpy.power(ebuff, 2) + numpy.power(ubuff, 2))
(x1, y1) = ll2utm(eq_lon, eq_lat, -71)
x1 = x1 - 68000
y1 = y1 + 109000
print utm2ll(x1, y1, -71)
(x2, y2) = ll2utm(sta_lon, sta_lat, -71)
hypodist = numpy.sqrt(
numpy.power(x1 - x2, 2) + numpy.power(y1 - y2, 2) +
numpy.power(eq_dep * 1000 - sta_alt, 2))
epidist = numpy.sqrt(numpy.power(x1 - x2, 2) + numpy.power(y1 - y2, 2))
effhypodist = hypodist / 1000 + Tlatency * 3
a1 = numpy.where(effhypodist < (runtime - to) * 3)[0]
a1 = numpy.array(a1)
if len(a1) > 3:
Dnew = disp[a1, 0:runtime * 5]
mpgd_vr = numpy.zeros([100, 1])
mpgd = numpy.zeros([100, 1])
maxD = numpy.zeros([len(a1), 1])
#maxD = numpy.amax(Dnew,axis=1,out=maxD)
maxD = numpy.nanmax(Dnew, axis=1, out=maxD, keepdims=True)
dep = 1
while dep < 101:
hypoupdate = numpy.sqrt(
numpy.power(x1 - x2[a1], 2) + numpy.power(y1 - y2[a1], 2) +
numpy.power(dep * 1000 - sta_alt[a1], 2))
[MPGD, VR_PGD] = PGD(100 * maxD, hypoupdate / 1000,
epidist[a1] / 1000)
mpgd[dep - 1] = MPGD
mpgd_vr[dep - 1] = VR_PGD
dep = dep + 1
else:
mpgd_vr = numpy.zeros([100, 1])
mpgd = numpy.zeros([100, 1])
return (mpgd, mpgd_vr, len(a1))
def rtokada(sta_lat, sta_lon, sta_alt, n, e, u, fault_lat, fault_lon,
fault_alt, strike, dip, LEN, WID, nstr, ndip):
l1 = len(sta_lat)
l2 = len(fault_lat)
LEN = LEN * 1000
WID = WID * 1000
xrs = numpy.zeros([l2, l1])
yrs = numpy.zeros([l2, l1])
zrs = numpy.zeros([l2, l1])
for i in range(0, l2):
for j in range(0, l1):
(x1, y1) = ll2utm(sta_lon[j], sta_lat[j], -123.0)
(x2, y2) = ll2utm(fault_lon[i], fault_lat[i], -123.0)
xrs[i, j] = (x1 - x2)
yrs[i, j] = (y1 - y2)
zrs[i, j] = sta_alt[j] + fault_alt[i] * 1000
G = okadagreen.greenF(xrs, yrs, zrs, strike, dip, WID,
LEN) #Compute Green's functions
#Regularization Matrix creation
T = numpy.zeros([(2 * ndip * nstr) + 2 * (2 * nstr + 2 * (ndip - 2)),
2 * l2]) #Prefill matrix with zeros
TU = numpy.zeros(
[(2 * ndip * nstr) + 2 * (2 * nstr + 2 * (ndip - 2)), 1]
) #Appended to observation vector. This minimizes the difference between adjacent slip cells
k = 0
for j in range(0, ndip):
for i in range(0, nstr):
for m in range(0, 2):
index1 = j * nstr + i
index2 = j * nstr + i - 1
index3 = j * nstr + i + 1
index4 = (j - 1) * nstr + i
index5 = (j + 1) * nstr + i
if (index1 >= 0 and index1 < l2):
T[k, 2 * index1 + m] = -2.0 / LEN[0] / LEN[
0] * 1000 * 1000 - 2.0 / WID[0] / WID[0] * 1000 * 1000
if (index2 >= 0 and index2 < l2):
T[k, 2 * index2 + m] = 1.0 / LEN[0] / LEN[0] * 1000 * 1000
if (index3 >= 0 and index3 < l2):
T[k, 2 * index3 + m] = 1.0 / LEN[0] / LEN[0] * 1000 * 1000
if (index4 >= 0 and index4 < l2):
T[k, 2 * index4 + m] = 1.0 / WID[0] / WID[0] * 1000 * 1000
if (index5 >= 0 and index5 < l2):
T[k, 2 * index5 + m] = 1.0 / WID[0] / WID[0] * 1000 * 1000
k = k + 1
for j in range(0, ndip):
for i in range(0, nstr):
for m in range(0, 2):
index1 = j * nstr + i
if (j == 0 or j == ndip - 1 or i == 0 or i == nstr - 1):
T[k, 2 * index1 + m] = 5 / WID[0] / LEN[0] * 1000 * 1000
k = k + 1
U = numpy.zeros([3 * l1, 1]) #Create data vector
for i in range(0, l1):
U[3 * i, 0] = e[i]
U[3 * i + 1, 0] = n[i]
U[3 * i + 2, 0] = u[i]
UD = numpy.vstack((U, TU))
lampred = 1.0 / math.pow(l2 * 2, 2) / numpy.mean(numpy.absolute(G)) / 20
T2 = T * lampred
G2 = numpy.vstack((G, T2))
S = numpy.linalg.lstsq(G2, UD)[0]
UP = numpy.dot(G, S) #Forward model for model fits
VR = (1 - numpy.linalg.norm(UP - U)**2 /
numpy.linalg.norm(U)**2) * 100 #variance reduction
SSLIP = numpy.zeros([l2, 1])
DSLIP = numpy.zeros([l2, 1])
for i in range(0, l2):
SSLIP[i, 0] = S[2 * i, 0]
DSLIP[i, 0] = S[2 * i + 1, 0]
EN = numpy.zeros([l1, 1])
NN = numpy.zeros([l1, 1])
UN = numpy.zeros([l1, 1])
for i in range(0, l1):
EN[i, 0] = UP[3 * i, 0]
NN[i, 0] = UP[3 * i + 1, 0]
UN[i, 0] = UP[3 * i + 2, 0]
ST = numpy.sqrt(SSLIP**2 + DSLIP**2)
Mo = numpy.sum(3.0e10 * ST * LEN * WID)
if (Mo > 0):
MW = 2.0 / 3.0 * math.log10(Mo / 1.0e-7) - 10.7
else:
MW = 0
return (SSLIP, DSLIP, MW, EN, NN, UN, VR)
def moment_tensor(sta_lat, sta_lon, sta_alt, n, e, u, eq_lat, eq_lon, eq_alt,timer,effhypodist,repi):
l1=len(sta_lat)
l2=1
xrs = numpy.zeros([l1,1])
yrs = numpy.zeros([l1,1])
zrs = numpy.zeros([l1,1])
azi = numpy.zeros([l1,1])
backazi = numpy.zeros([l1,1])
theta = numpy.zeros([l1,1])
for j in range (0, l1):
(x1,y1) = ll2utm(sta_lon[j],sta_lat[j], -71)
(x2,y2) = ll2utm(eq_lon,eq_lat, -71)
result = gps2DistAzimuth(sta_lat[j],sta_lon[j],eq_lat,eq_lon)
backazi[j,0]=result[1]
azi[j,0]=result[2]
theta[j,0] = 90 - backazi[j,0] + 180
xrs[j,0] = (x1-x2)
yrs[j,0] = (y1-y2)
zrs[j,0] = (sta_alt[j]+eq_alt*1000)
U = numpy.zeros([3*l1,1])
for i in range (0, l1):
efftime = math.ceil(effhypodist[i])
NN = n[i,efftime:efftime+10]
EE = e[i,efftime:efftime+10]
UU = u[i,efftime:efftime+10]
a1 = numpy.where(n[i,efftime:efftime+10] > -999)[0]
a1 = numpy.array(a1)
if (len(a1) > 1):
N = numpy.nanmean(NN[a1])
E = numpy.nanmean(EE[a1])
Z = numpy.nanmean(UU[a1])
U[3*i,0]= N
U[3*i+1,0]= E
U[3*i+2,0]= -Z
else:
U[3*i,0]= 0
U[3*i+1,0]= 0
U[3*i+2,0]= 0
G = okadapoint.greenF(yrs, xrs, -zrs) #Compute Green's function
S = numpy.linalg.lstsq(G,U)[0]
M12 = S[0,0]
M13 = S[1,0]
M33 = S[2,0]
M23 = S[4,0]
M11 = S[3,0]-0.5*S[2,0]
M22 = -S[3,0]-0.5*S[2,0]
M_devi = numpy.array([[M11,M12,M13],[M12,M22,M23],[M13,M23,M33]])
eigenwtot, eigenvtot = numpy.linalg.eig(M_devi)
eigenw1, eigenv1 = numpy.linalg.eig(M_devi)
eigenw = numpy.real(numpy.take(eigenw1, numpy.argsort(abs(eigenwtot))))
eigenv = numpy.real(numpy.take(eigenv1, numpy.argsort(abs(eigenwtot)), 1))
eigenw_devi = numpy.real(numpy.take(eigenw1, numpy.argsort(abs(eigenw1))))
eigenv_devi = numpy.real(numpy.take(eigenv1, numpy.argsort(abs(eigenw1)), 1))
M0_devi = max(abs(eigenw_devi))
F = -eigenw_devi[0] / eigenw_devi[2]
M_DC_percentage = (1 - 2 * abs(F)) * 100
Mo = math.pow(math.pow(M11,2)+math.pow(M22,2)+math.pow(M33,2)+2*math.pow(M12,2)+2*math.pow(M13,2)+2*math.pow(M23,2),0.5)/math.pow(2,0.5)
if (Mo == 0):
Mw = 0
else:
Mw = 2*math.log10(Mo)/3-6.03
UP = numpy.dot(G,S)
dms = U-UP
VR = (1-numpy.sum(numpy.sqrt(numpy.power(dms,2)))/numpy.sum(numpy.sqrt(numpy.power(U,2))))*M_DC_percentage
#VR = numpy.linalg.norm(dms)/M_DC_percentage*1000
mt = obspy.imaging.beachball.MomentTensor(M33,M11,M22,M13,-M23,-M12,26)
axes = obspy.imaging.beachball.MT2Axes(mt)
plane1 = obspy.imaging.beachball.MT2Plane(mt)
plane2 = obspy.imaging.beachball.AuxPlane(plane1.strike,plane1.dip,plane1.rake)
T = {'azimuth':axes[0].strike,'plunge':axes[0].dip}
N = {'azimuth':axes[1].strike,'plunge':axes[1].dip}
P = {'azimuth':axes[2].strike,'plunge':axes[2].dip}
NP1 = {'strike':plane1.strike,'dip':plane1.dip,'rake':plane1.rake}
NP2 = {'strike':plane2[0],'dip':plane2[1],'rake':plane2[2]}
return(S, VR, Mw, NP1, NP2)
def fault_CMT(lat, lon, depth, M, strikeF, dipF, nstr, ndip):
[x0, y0] = coord_tools.ll2utm(lon, lat, -71)
x0 = x0 / 1000
y0 = y0 / 1000
fault_alt = numpy.zeros([nstr * ndip, 1])
fault_lon = numpy.zeros([nstr * ndip, 1])
fault_lat = numpy.zeros([nstr * ndip, 1])
fault_lon1 = numpy.zeros([nstr * ndip, 1])
fault_lat1 = numpy.zeros([nstr * ndip, 1])
fault_lon2 = numpy.zeros([nstr * ndip, 1])
fault_lat2 = numpy.zeros([nstr * ndip, 1])
fault_lon3 = numpy.zeros([nstr * ndip, 1])
fault_lat3 = numpy.zeros([nstr * ndip, 1])
fault_lon4 = numpy.zeros([nstr * ndip, 1])
fault_lat4 = numpy.zeros([nstr * ndip, 1])
strike = strikeF * numpy.ones([nstr * ndip, 1])
dip = dipF * numpy.ones([nstr * ndip, 1])
AREA = math.pow(10, -3.49 +
0.91 * M) #Area of fault from Dreger and Kaverina, 2000
LEN = math.pow(10, -2.44 +
0.59 * M) #Length of fault from Dreger and Kaverina, 2000
WID = AREA / LEN * 3 #Fault width is area divided by length
LEN = LEN + 0.1 * LEN #fault dimensions with 10% safety factor added
WID = WID + 0.2 * WID
if (
WID / 2 * math.sin(dipF * math.pi / 180) > depth
): #sets the initial top depth - either depth-width/2*sin(dip) or 0 depending on how wide and close to surface fault is
z0 = 0
x0 = x0 - LEN / 2 * math.sin(
strikeF * math.pi / 180) - depth * math.cos(
dipF * math.pi / 180) * math.sin(
(strikeF + 90) * math.pi / 180)
y0 = y0 - LEN / 2 * math.cos(
strikeF * math.pi / 180) - depth * math.cos(
dipF * math.pi / 180) * math.cos(
(strikeF + 90) * math.pi / 180)
else:
z0 = depth - WID / 2 * math.sin(dipF * math.pi / 180)
x0 = x0 - LEN / 2 * math.sin(
strikeF * math.pi / 180) - WID / 2 * math.cos(
dipF * math.pi / 180) * math.sin(
(strikeF + 90) * math.pi / 180)
y0 = y0 - LEN / 2 * math.cos(
strikeF * math.pi / 180) - WID / 2 * math.cos(
dipF * math.pi / 180) * math.cos(
(strikeF + 90) * math.pi / 180)
DLEN = LEN / nstr
DWID = WID / ndip
xdoff = DWID * math.cos(dipF * math.pi / 180) * math.sin(
(strikeF + 90) * math.pi / 180)
ydoff = DWID * math.cos(dipF * math.pi / 180) * math.cos(
(strikeF + 90) * math.pi / 180)
xsoff = DLEN * math.sin(strikeF * math.pi / 180)
ysoff = DLEN * math.cos(strikeF * math.pi / 180)
k = 0
for j in range(0, ndip):
for i in range(0, nstr):
fault_X = x0 + (0.5 + i) * xsoff + (0.5 + j) * xdoff
fault_Y = y0 + (0.5 + i) * ysoff + (0.5 + j) * ydoff
fault_X1 = x0 + (i) * xsoff + (j) * xdoff
fault_Y1 = y0 + (i) * ysoff + (j) * ydoff
fault_X2 = x0 + (i + 1) * xsoff + (j) * xdoff
fault_Y2 = y0 + (i + 1) * ysoff + (j) * ydoff
fault_X3 = x0 + (i + 1) * xsoff + (j + 1) * xdoff
fault_Y3 = y0 + (i + 1) * ysoff + (j + 1) * ydoff
fault_X4 = x0 + (i) * xsoff + (j + 1) * xdoff
fault_Y4 = y0 + (i) * ysoff + (j + 1) * ydoff
fault_alt[k] = z0 + (0.5 + j) * DWID * math.sin(
dipF * math.pi / 180)
(fault_lon[k],
fault_lat[k]) = coord_tools.utm2ll(fault_X * 1000, fault_Y * 1000,
-71)
(fault_lon1[k],
fault_lat1[k]) = coord_tools.utm2ll(fault_X1 * 1000,
fault_Y1 * 1000, -71)
(fault_lon2[k],
fault_lat2[k]) = coord_tools.utm2ll(fault_X2 * 1000,
fault_Y2 * 1000, -71)
(fault_lon3[k],
fault_lat3[k]) = coord_tools.utm2ll(fault_X3 * 1000,
fault_Y3 * 1000, -71)
(fault_lon4[k],
fault_lat4[k]) = coord_tools.utm2ll(fault_X4 * 1000,
fault_Y4 * 1000, -71)
k = k + 1
return (fault_lon, fault_lat, fault_alt, strike, dip, DLEN *
numpy.ones([nstr * ndip, 1]), DWID * numpy.ones([nstr * ndip, 1]),
fault_lon1, fault_lat1, fault_lon2, fault_lat2, fault_lon3,
fault_lat3, fault_lon4, fault_lat4)
def data_engine_cmt(eq_lat, eq_lon, eq_dep, to, sta_lat, sta_lon, sta_alt,
nbuff, ebuff, ubuff, tbuff, runtime, Tlatency):
#fid = open('gsearch_cmt.txt','w')
(x1, y1) = ll2utm(eq_lon, eq_lat, -71)
(x2, y2) = ll2utm(sta_lon, sta_lat, -71)
hypodist = numpy.sqrt(
numpy.power(x1 - x2, 2) + numpy.power(y1 - y2, 2) +
numpy.power(eq_dep * 1000 - sta_alt, 2))
epidist = numpy.sqrt(numpy.power(x1 - x2, 2) + numpy.power(y1 - y2, 2))
effhypodist = hypodist / 1000 + Tlatency * 1
a1 = numpy.where(effhypodist < (runtime - to) * 2 + 10 * 1)[0]
a1 = numpy.array(a1)
if len(a1) > 3:
VARRED = numpy.zeros([100, 1])
S1 = numpy.zeros([100, 1])
S2 = numpy.zeros([100, 1])
S3 = numpy.zeros([100, 1])
S4 = numpy.zeros([100, 1])
S5 = numpy.zeros([100, 1])
S6 = numpy.zeros([100, 1])
STR1 = numpy.zeros([100, 1])
STR2 = numpy.zeros([100, 1])
DIP1 = numpy.zeros([100, 1])
DIP2 = numpy.zeros([100, 1])
RAK1 = numpy.zeros([100, 1])
RAK2 = numpy.zeros([100, 1])
MW = numpy.zeros([100, 1])
#lons = 1
#while lons < 21:
# lats = 1
# while lats < 21:
# dep = 1
# while dep < 101:
# dlat = (lats - 10)*0.1
# dlon = (lons - 10)*0.1
# [S,VR,Mw,NP1,NP2] = moment_tensor(sta_lat[a1],sta_lon[a1],sta_alt[a1],nbuff[a1,:],ebuff[a1,:],ubuff[a1,:],eq_lat-dlat,eq_lon-dlon,dep,runtime,effhypodist[a1],epidist[a1])
# latnew = "{0:.6f}".format(float(eq_lat-dlat))
# lonnew = "{0:.6f}".format(float(eq_lon-dlon))
# depnew = "{0:.2f}".format(float(dep))
# vrnew = "{0:.2f}".format(float(VR))
# fid.write(latnew+' '+lonnew+' '+depnew+' '+vrnew+'\n')
# dep = dep+1
# lats = lats+1
# lons = lons+1
dep = 1
while dep < 101:
[S, VR, Mw, NP1,
NP2] = moment_tensor(sta_lat[a1], sta_lon[a1], sta_alt[a1],
nbuff[a1, :], ebuff[a1, :], ubuff[a1, :],
eq_lat, eq_lon, dep, runtime,
effhypodist[a1], epidist[a1])
VARRED[dep - 1, 0] = VR
S1[dep - 1, 0] = S[0]
S2[dep - 1, 0] = S[1]
S3[dep - 1, 0] = S[2]
S4[dep - 1, 0] = S[3]
S5[dep - 1, 0] = S[4]
#S6[dep-1,0] = S[5]
STR1[dep - 1, 0] = NP1['strike']
STR2[dep - 1, 0] = NP2['strike']
DIP1[dep - 1, 0] = NP1['dip']
DIP2[dep - 1, 0] = NP2['dip']
RAK1[dep - 1, 0] = NP1['rake']
RAK2[dep - 1, 0] = NP2['rake']
MW[dep - 1, 0] = Mw
dep = dep + 1
else:
VARRED = numpy.zeros([100, 1])
S1 = numpy.zeros([100, 1])
S2 = numpy.zeros([100, 1])
S3 = numpy.zeros([100, 1])
S4 = numpy.zeros([100, 1])
S5 = numpy.zeros([100, 1])
S6 = numpy.zeros([100, 1])
STR1 = numpy.zeros([100, 1])
STR2 = numpy.zeros([100, 1])
DIP1 = numpy.zeros([100, 1])
DIP2 = numpy.zeros([100, 1])
RAK1 = numpy.zeros([100, 1])
RAK2 = numpy.zeros([100, 1])
MW = numpy.zeros([100, 1])
return (MW, S1, S2, S3, S4, S5, S6, STR1, STR2, DIP1, DIP2, RAK1, RAK2,
VARRED, len(a1))
def data_engine_ff(eq_lat, eq_lon, eq_dep, MCMT, STR1, STR2, DIP1, DIP2, nstr,
ndip, to, sta_lat, sta_lon, sta_alt, nbuff, ebuff, ubuff,
tbuff, runtime, Tlatency):
(x1, y1) = ll2utm(eq_lon, eq_lat, -71)
(x2, y2) = ll2utm(sta_lon, sta_lat, -71)
hypodist = numpy.sqrt(
numpy.power(x1 - x2, 2) + numpy.power(y1 - y2, 2) +
numpy.power(eq_dep * 1000 - sta_alt, 2))
effhypodist = hypodist / 1000 + Tlatency * 1
a1 = numpy.where(effhypodist < (runtime - to) * 2 + 10 * 1)[0]
a1 = numpy.array(a1)
if len(a1) > 3:
[
fault_lon1, fault_lat1, fault_alt1, strike1, dip1, dl1, dw1, lon11,
lat11, lon12, lat12, lon13, lat13, lon14, lat14
] = fault_CMT(eq_lat, eq_lon, eq_dep, MCMT, STR1, DIP1, nstr, ndip)
[SSLIP1, DSLIP1, MW1, EN1, NN1, UN1, VR1, Einp, Ninp,
Uinp] = rtokada(sta_lat[a1], sta_lon[a1], sta_alt[a1], nbuff[a1, :],
ebuff[a1, :], ubuff[a1, :], fault_lat1, fault_lon1,
fault_alt1, strike1, dip1, dl1, dw1, nstr, ndip,
runtime, effhypodist[a1])
[
fault_lon2, fault_lat2, fault_alt2, strike2, dip2, dl2, dw2, lon21,
lat21, lon22, lat22, lon23, lat23, lon24, lat24
] = fault_CMT(eq_lat, eq_lon, eq_dep, MCMT, STR2, DIP2, nstr, ndip)
[SSLIP2, DSLIP2, MW2, EN2, NN2, UN2, VR2, Einp2, Ninp2,
Uinp2] = rtokada(sta_lat[a1], sta_lon[a1], sta_alt[a1], nbuff[a1, :],
ebuff[a1, :], ubuff[a1, :], fault_lat2, fault_lon2,
fault_alt2, strike2, dip2, dl2, dw2, nstr, ndip,
runtime, effhypodist[a1])
if (VR1 >= VR2):
FaultPlane = 1
SSLIP = SSLIP1
DSLIP = DSLIP1
MFF = MW1
EN = EN1
NN = NN1
UN = UN1
VR = VR1
STR = STR1
DIP = DIP1
FAULT_LAT = fault_lat1
FAULT_LON = fault_lon1
FAULT_ALT = fault_alt1
FLAT1 = lat11
FLON1 = lon11
FLAT2 = lat12
FLON2 = lon12
FLAT3 = lat13
FLON3 = lon13
FLAT4 = lat14
FLON4 = lon14
else:
FaultPlane = 2
SSLIP = SSLIP2
DSLIP = DSLIP2
MFF = MW2
EN = EN2
NN = NN2
UN = UN2
VR = VR2
STR = STR2
DIP = DIP2
FAULT_LAT = fault_lat2
FAULT_LON = fault_lon2
FAULT_ALT = fault_alt2
FLAT1 = lat21
FLON1 = lon21
FLAT2 = lat22
FLON2 = lon22
FLAT3 = lat23
FLON3 = lon23
FLAT4 = lat24
FLON4 = lon24
return (SSLIP, DSLIP, MFF, Einp, Ninp, Uinp, EN, NN, UN, sta_lat[a1],
sta_lon[a1], FAULT_LAT, FAULT_LON, FAULT_ALT, VR1, VR2, FaultPlane,
FLAT1, FLON1, FLAT2, FLON2, FLAT3, FLON3, FLAT4, FLON4)