def kiksyn(nt,dt,ib,ic,str,dip,rak,z,az,p,g,t12, velmod_filename=None,pad=False,verbose=False): """ Wrapper for Kikuchi body wave synthetic routine Input: nt,dt length and sampling of output time series ib,ic ib=1 for P; ic=1,2,3 for Z,NS,EW, resp. ib=2 for SV; ic=1,2 for Z,radial, resp. ib=3 for SH; (ic ignored) p, g slowness and geometrical spreading (from raypgeom) z, az event depth and source-to-recever azimuth str,dip,rak fault geometry t12 half-duration of symmetrical trangle stf velmod_filename velocity model file name Output syn real array of length nt """ # From Hong Kie's ffi program: # read(5,*) ms,t1,t2 # read(1,*) az(js),az2(js),del(js),p(js),g(js),ix0(js) # read(1,*) im(js),ib(js),ic(js) # -- read velocity model -------------------------------------------- # read(2,'(a40)') dsn # read(2,*) tqp,tqs,nl,(vp(l),vs(l),den(l),dep(l),l=1,nl) # read(2,*) nl1,(vp1(l),vs1(l),den1(l),dep1(l),l=1,nl1) # read(2,*) nl2,(vp2(l),vs2(l),den2(l),dep2(l),l=1,nl2) if velmod_filename != None: lines = open(velmod_filename,'r').readlines() buf = [] for line in lines[1:]: buf.extend(line.split()) tqp,tqs = [float(x) for x in buf[0:2]] # Pack velocity model nl = int(buf[2]) nl1 = int(buf[nl*4+3]) nl2 = int(buf[(nl+nl1+1)*4]) vmod=np.zeros((4,(nl+nl1+nl2))) vmod[0:4, 0:nl ] = np.array([float(x) for x in buf[3:nl*4+3]]).reshape((nl,4)).transpose() vmod[0:4, nl:nl+nl1 ] = np.array([float(x) for x in buf[4*(nl+1):4*(nl+nl1+1)]]).reshape((nl1,4)).transpose() vmod[0:4,nl+nl1:nl+nl1+nl2] = np.array([float(x) for x in buf[4*(nl+nl1+1)+1:4*(nl+nl1+nl2+1)+1]]).reshape((nl2,4)).transpose() else: tqp = 0. tqs = 0. vmod = [] nl = 0 nl1 = 0 nl2 = 0 # Pad nt to power of 2 if needed if mt.log(nt,2) % 1 != 0.: nt1 = int(mt.pow(2,int(mt.log(nt,2))+1)) if verbose: print 'nt=%d raised to next power of two (%d)' % (nt,nt1) else: nt1 = nt if pad: nt1 *=2 # Now call synthetic generating routine syn = kiklib.kiksyn(nt1,dt,ib,ic,az,p,g,str,dip,rak,z,t12, tqp,tqs,vmod,[nl,nl1,nl2],velmod_filename!=None) return syn[0:nt]
def kiksyn(nt,dt,ib,ic,str,dip,rak,z,az,p,g,t12,velmod,\ set_velmod=True,pad=False,verbose=False): """ Wrapper for Kikuchi body wave synthetic routine Input: nt,dt length and sampling of output time series ib,ic ib=1 for P; ic=1,2,3 for Z,NS,EW, resp. ib=2 for SV; ic=1,2 for Z,radial, resp. ib=3 for SH; (ic ignored) p, g slowness and geometrical spreading (from raypgeom) z, az event depth and source-to-recever azimuth str,dip,rak fault geometry t12 half-duration of symmetrical trangle stf velmod velocity model dictionary returned by read_velmod Output syn real array of length nt """ # From Hong Kie's ffi program: # read(5,*) ms,t1,t2 # read(1,*) az(js),az2(js),del(js),p(js),g(js),ix0(js) # read(1,*) im(js),ib(js),ic(js) # -- read velocity model -------------------------------------------- # read(2,'(a40)') dsn # read(2,*) tqp,tqs,nl,(vp(l),vs(l),den(l),dep(l),l=1,nl) # read(2,*) nl1,(vp1(l),vs1(l),den1(l),dep1(l),l=1,nl1) # read(2,*) nl2,(vp2(l),vs2(l),den2(l),dep2(l),l=1,nl2) # Pad nt to power of 2 if needed if mt.log(nt,2) % 1 != 0.: nt1 = int(mt.pow(2,int(mt.log(nt,2))+1)) if verbose: print 'nt=%d raised to next power of two (%d)' % (nt,nt1) else: nt1 = nt if pad: nt1 *=2 # Now call synthetic generating routine tqp = velmod['tqp'] tqs = velmod['tqs'] ns = velmod['ns'] vmod = velmod['vmod'] syn = kiklib.kiksyn(nt1,dt,ib,ic,az,p,g,str,dip,rak,z,t12, tqp,tqs,vmod,ns,set_velmod) return syn[0:nt]
def kiksyn(nt,dt,ib,ic,str,dip,rak,z,az,p,g,t12,velmod,\ set_velmod=True,pad=False,verbose=False): """ Wrapper for Kikuchi body wave synthetic routine Input: nt,dt length and sampling of output time series ib,ic ib=1 for P; ic=1,2,3 for Z,NS,EW, resp. ib=2 for SV; ic=1,2 for Z,radial, resp. ib=3 for SH; (ic ignored) p, g slowness and geometrical spreading (from raypgeom) z, az event depth and source-to-recever azimuth str,dip,rak fault geometry t12 half-duration of symmetrical trangle stf velmod velocity model dictionary returned by read_velmod Output syn real array of length nt """ # From Hong Kie's ffi program: # read(5,*) ms,t1,t2 # read(1,*) az(js),az2(js),del(js),p(js),g(js),ix0(js) # read(1,*) im(js),ib(js),ic(js) # -- read velocity model -------------------------------------------- # read(2,'(a40)') dsn # read(2,*) tqp,tqs,nl,(vp(l),vs(l),den(l),dep(l),l=1,nl) # read(2,*) nl1,(vp1(l),vs1(l),den1(l),dep1(l),l=1,nl1) # read(2,*) nl2,(vp2(l),vs2(l),den2(l),dep2(l),l=1,nl2) # Pad nt to power of 2 if needed if mt.log(nt, 2) % 1 != 0.: nt1 = int(mt.pow(2, int(mt.log(nt, 2)) + 1)) if verbose: print 'nt=%d raised to next power of two (%d)' % (nt, nt1) else: nt1 = nt if pad: nt1 *= 2 # Now call synthetic generating routine tqp = velmod['tqp'] tqs = velmod['tqs'] ns = velmod['ns'] vmod = velmod['vmod'] syn = kiklib.kiksyn(nt1, dt, ib, ic, az, p, g, str, dip, rak, z, t12, tqp, tqs, vmod, ns, set_velmod) return syn[0:nt]
def kiksyn(nt, dt, ib, ic, str, dip, rak, z, az, p, g, t12, velmod_filename=None, pad=False, verbose=False): """ Wrapper for Kikuchi body wave synthetic routine Input: nt,dt length and sampling of output time series ib,ic ib=1 for P; ic=1,2,3 for Z,NS,EW, resp. ib=2 for SV; ic=1,2 for Z,radial, resp. ib=3 for SH; (ic ignored) p, g slowness and geometrical spreading (from raypgeom) z, az event depth and source-to-recever azimuth str,dip,rak fault geometry t12 half-duration of symmetrical trangle stf velmod_filename velocity model file name Output syn real array of length nt """ # From Hong Kie's ffi program: # read(5,*) ms,t1,t2 # read(1,*) az(js),az2(js),del(js),p(js),g(js),ix0(js) # read(1,*) im(js),ib(js),ic(js) # -- read velocity model -------------------------------------------- # read(2,'(a40)') dsn # read(2,*) tqp,tqs,nl,(vp(l),vs(l),den(l),dep(l),l=1,nl) # read(2,*) nl1,(vp1(l),vs1(l),den1(l),dep1(l),l=1,nl1) # read(2,*) nl2,(vp2(l),vs2(l),den2(l),dep2(l),l=1,nl2) if velmod_filename != None: lines = open(velmod_filename, 'r').readlines() buf = [] for line in lines[1:]: buf.extend(line.split()) tqp, tqs = [float(x) for x in buf[0:2]] # Pack velocity model nl = int(buf[2]) nl1 = int(buf[nl * 4 + 3]) nl2 = int(buf[(nl + nl1 + 1) * 4]) vmod = np.zeros((4, (nl + nl1 + nl2))) vmod[0:4, 0:nl] = np.array([float(x) for x in buf[3:nl * 4 + 3]]).reshape( (nl, 4)).transpose() vmod[0:4, nl:nl + nl1] = np.array( [float(x) for x in buf[4 * (nl + 1):4 * (nl + nl1 + 1)]]).reshape( (nl1, 4)).transpose() vmod[0:4, nl + nl1:nl + nl1 + nl2] = np.array([ float(x) for x in buf[4 * (nl + nl1 + 1) + 1:4 * (nl + nl1 + nl2 + 1) + 1] ]).reshape((nl2, 4)).transpose() else: tqp = 0. tqs = 0. vmod = [] nl = 0 nl1 = 0 nl2 = 0 # Pad nt to power of 2 if needed if mt.log(nt, 2) % 1 != 0.: nt1 = int(mt.pow(2, int(mt.log(nt, 2)) + 1)) if verbose: print 'nt=%d raised to next power of two (%d)' % (nt, nt1) else: nt1 = nt if pad: nt1 *= 2 # Now call synthetic generating routine syn = kiklib.kiksyn(nt1, dt, ib, ic, az, p, g, str, dip, rak, z, t12, tqp, tqs, vmod, [nl, nl1, nl2], velmod_filename != None) return syn[0:nt]
def kiksyn(nt, dt, ib, ic, strike, dip, rak, z, az, p, g, trise, tdur, istype=3, velmod=None, set_velmod=True, pad=False, verbose=False, frq4=None): """ Wrapper for Kikuchi body wave synthetic routine Input: nt,dt length and sampling of output time series ib,ic ib=1 for P; ic=1,2,3 for Z,NS,EW, resp. ib=2 for SV; ic=1,2 for Z,radial, resp. ib=3 for SH; (ic ignored) p, g slowness and geometrical spreading (from raypgeom) z, az event depth and source-to-recever azimuth str,dip,rak fault geometry trise,tdur rise time and total duration, resp. istype sets the source time funciton, according to: istype=0 : Impulsive time function =1 : Ramp function if tdur < trise Symmetric trapezoid if tdur >= trise =2 : Ramp function with cosine taper if tdur < trise Symmetric trapezoid if tdur >= trise =3 : Triangle velmod velocity model dictionary returned by read_velmod Output syn real array of length nt """ # From Hong Kie's ffi program: # read(5,*) ms,t1,t2 # read(1,*) az(js),az2(js),del(js),p(js),g(js),ix0(js) # read(1,*) im(js),ib(js),ic(js) # -- read velocity model -------------------------------------------- # read(2,'(a40)') dsn # read(2,*) tqp,tqs,nl,(vp(l),vs(l),den(l),dep(l),l=1,nl) # read(2,*) nl1,(vp1(l),vs1(l),den1(l),dep1(l),l=1,nl1) # read(2,*) nl2,(vp2(l),vs2(l),den2(l),dep2(l),l=1,nl2) # Pad nt to power of 2 if needed if mt.log(nt, 2) % 1 != 0.: nt1 = int(mt.pow(2, int(mt.log(nt, 2)) + 1)) if verbose: print 'nt=%d raised to next power of two (%d)' % (nt, nt1) else: nt1 = nt if pad: nt1 *= 4 # Now call synthetic generating routine tqp = velmod['tqp'] tqs = velmod['tqs'] ns = velmod['ns'] vmod = velmod['vmod'] if frq4 is None: frq4 = -1. * np.ones(4) syn = kiklib.kiksyn(nt1, dt, ib, ic, az, p, g, strike, dip, rak, z, trise, tdur, istype, tqp, tqs, vmod, ns, set_velmod, frq4) return syn[0:nt]