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)