def readNDK(fileName='gcmt_1996_2018.ndk'):
"""
A simple function to read in a ndk file and pharse data into a dataframe
For more detail see https://docs.obspy.org/master/_modules/obspy/io/ndk/core.html#_read_ndk
"""
ndkDf = pd.DataFrame()
with open(fileName, "rt") as fp:
data = fp.read()
def lines_iter():
prev_line = -1
while True:
next_line = data.find("\n", prev_line + 1)
if next_line < 0:
break
yield data[prev_line+1 : next_line]
prev_line = next_line
if len(data) > prev_line + 1:
yield data[prev_line+1 :]
for _i, lines in enumerate(zip_longest(*[lines_iter()] * 5)):
if None in lines:
msg = "Skipped last %i lines. Not a multiple of 5 lines."%(lines.count(None))
gpar.log(__name__, msg, level='warning', pri=True)
continue
try:
record = _read_lines(*lines)
ndkDf = ndkDf.append(record, ignore_index=True)
except:
msg = "Could not parse event %i. Will be skipped. Lines of the event:\n\t%s\n"%(_i+1, "\n\t".join(lines))
gpar.log(__name__,msg,level='warning', pri=True)
ndkDf = ndkDf.astype({"exp":int})
return ndkDf
def loadArray(fileName='ILAR.pkl'):
"""
Function to uses pandas.read_pickle to load a pickled array instance
"""
ar = pd.read_pickle(fileName)
if not isinstance(ar, gpar.arrayProcess.Array):
msg = ('%s is not a Array instance' % fileName)
gpar.log(__name__,msg,level='error',e='ValueError',pri=True)
return ar
def read(path): """ Function to read a file from a path. If IOError or TypeError simply try appending os.sep to start """ try: st = obspy.core.read(path) except (IOError, TypeError): try: st = obspy.core.read(os.path.join(os.path.sep,path)) except(IOError, TypeError): msg = 'Cannot read %s, the file may be corrupt, skipping it'%(path) gpar.log(__name__,msg,level='warn',pri=True) return None return st
def getStream(self, ar, df, stime, etime, net, staele, chan, verb,
loc='*', minlen=1500, mode='eq',channel='Z'):
if not isinstance(chan, (list, tuple)):
if not isinstance(chan, string_types):
msg = 'chan must be a string or list of string'
gpar.log(__name__, msg, level=error, pri=True)
chan = [chan]
if self.method == 'dir':
df, stadf = self._getStream(ar.NAME, df, mode,minlen,verb,channel)
else:
stadf = pd.DataFrame(columns=['STA','LAT','LON'])
client = self.client
stream = [''] * len(df)
for ind, row in df.iterrows():
time = UTCDateTime(row.TIME)
start = time - stime
end = time + etime
st = self._getStream(self, start, end, net, staele, chan, loc)
st = _checkData(st,minlen)
if st is None or len(st) < 1:
stream[ind] = pd.NaT
else:
nst = obspy.Stream()
for tr in st:
sta = tr.stats.station
station = client.get_stations(network=net, station=sta).networks[0].stations[0]
latitude = station.latitude
longitude = station.longitude
sac = AttribDict({'b':-stime, 'e':etime, 'o':0,
'evla':row.LAT, 'evlo': row.LON,
'delta': tr.stats.delta, 'npts': tr.stats.npts,
'stla': latitude, 'stlo':longitude,
'iztype': 11, 'lcalda': True, 'knetwk': net,
'kcmpnm':tr.stats.channel,'kstnm':sta,
'nzyear':time.year, 'nzjday':time.julday,
'nzhour':time.hour, 'nzmin':time.minute,
'nzsec':time.second, 'nzmsec': time.microsecond/1000})
tr.stats.sac = sac
nst.append(tr)
stadf = _checkSta(tr, stadf)
stream[ind] = nst
df['Stream'] = stream
return df, stadf
def readList(flist, list_type='array',sep='\s+'):
"""
Function to read a key files and performs checks for required columns parameters
Parameters:
flist: str or pandas dataframe
A path to the key file or DataFrame itself
list_type: str
"array" for array list, "event" for earthquake list, "coda" for coda strip or 'twoline' for twoline strip
sep: str
seperate symbol for file reading
"""
read_array = set(['NAME','LAT','LON','CODE'])
read_eq = set(['TIME','LAT','LON','DEP','Mw','DIS','Az','Baz','BB','Rayp','DIR'])
read_db = set(['DoubleID', 'DIR1', 'TIME1', 'LAT1', 'LON1', 'DEP1', 'M1', 'DIR2', 'TIME2', 'LAT2', 'LON2', 'DEP2', 'M2'])
read_coda = set(['TIME','LAT','LON','DEP','Mw','Del','Az','Baz','BB','Rayp','RES','lnA','B','C'])
read_two = set(['TIME','LAT','LON','DEP','Mw','Del','Az','Baz','BB','Rayp','RES','m1','b1','m2','b2'])
req_type = {'array':read_array,'event':read_eq,'coda':read_coda,'towline':read_two, 'doublet':read_db}
list_types = req_type.keys()
if list_type not in list_types:
msg = ('Not valid list type, choose from %s' % list_types)
gpar.log(__name__,msg,level='error',e='ValueError',pri=True)
if isinstance(flist, str):
if not os.path.exists(flist):
msg = ('%s does not exists' % flist)
gpar.log(__name__,msg,level='error',e=ValueError,pri=True)
else:
df = pd.read_csv(flist,sep=sep)
elif isinstance(flist, pd.DataFrame):
df = flist
else:
msg = ('Not supported data type for flist')
gpar.log(__name__,msg,level='error',pri=True)
if not req_type[list_type].issubset(df.columns):
msg = ('Required columns not in %s, required columns for %s key are %s'
% (df.columns, list_type, req_type[list_type]))
gpar.log(__name__,msg,level='error',e=ValueError,pri=True)
tdf = df.loc[:, list(req_type[list_type])]
condition = [all([x != '' for item, x in row.iteritems()])
for ind, row in tdf.iterrows()]
df = df[condition]
df.reset_index(drop=True, inplace=True)
return df
def _checkData(st, minlen):
if st is None or len(st)<1:
return None
sample_rates = []
for tr in st:
stats = tr.stats
lasttime = stats.npts * stats.delta
sample = stats.sampling_rate
if sample not in sample_rates:
sample_rates.append(sample)
if lasttime < minlen:
msg = ('Trace in station %s starting from %s is shrter than require, removing'%(stats.station, stats.starttime))
gpar.log(__name__, msg, level='info')
st.remove(tr)
mdata = np.max(np.abs(tr.data))
tmp_data = tr.data / mdata
if np.std(tmp_data) < 0.000001:
msg = ("Trace data for %s in station %s has std near 0, removing" % (stats.starttime, tr.stats.station))
st.remove(tr)
gpar.log(__name__,msg,level='warning',e=ValueError)
continue
if len(st) == 0:
st = None
if len(sample_rates) > 1 and st != None:
resample = np.min(sample_rates)
msg = ("Traces have different sampling rate %s\nnow resample them to the samllest sample %s"%(sample_rates, resample))
gpar.log(__name__, msg, level='info')
st.resample(resample)
return st
def getEqData(self, ar, timebefore=None, timeafter=None, phase=['PKiKP'], minlen=None, mode='eq',verb=False,**kwargs):
if timebefore is None:
timebefore = self.timeBeforeOrigin
if timeafter is None:
timeafter = self.timeAfterOrigin
if minlen is None:
minlen = self.minlen
net = ar.NETWORK
sta = ar.Station
chan = ar.Channel.split('-')
arDir = os.path.join(ar.NAME, 'Data')
if 'eqfile' in kwargs.keys():
eqlist = os.path.join(ar.NAME, kwargs['eqfile'])
else:
eqlist = os.path.join(ar.NAME, mode+'.'+ar.NAME+'.list')
if not os.path.exists(eqlist):
msg = ('Earthquake list for array %s is not exists, building from ndk file first' % ar.NAME)
gpar.log(__name__,msg,level='warning',pri=True)
if 'ndkfile' not in kwargs.keys():
msg = ('input the ndkfile and related parameters (see getdata.makeEventList) for building earthquake list')
gpar.log(__name__, msg, level='warning', pri=True)
return None
if not os.path.isfile(ndkfile):
msg = ('ndk file does not exist')
gpar.log(__name__,msg, level='warning', pri=True)
return None
if mode == 'eq':
eqdf = util.readList(eqlist,list_type='event', sep='\s+')
elif mode == 'db':
eqdf = util.readList(eqlist,list_type='doublet', sep='\s+')
ndf, stadf = self.getStream(ar, eqdf, timebefore, timeafter, net, sta, chan, verb=verb,
loc='*', minlen=minlen, mode=mode,channel=kwargs['channel'])
return ndf, stadf
def makeDataDirectory(arraylist='array.list', fetch='IRIS',
timeBeforeOrigin=0, timeAfterOrigin=3600,
buildArray=False, outsta=True, minlen=1500.0,
**kwargs):
ardf = util.readList(arraylist, list_type='array', sep='\s+')
if isinstance(fetch, gpar.getdata.DataFetcher):
fetcher = fetch
else:
fetcher = gpar.getdata.DataFetcher(fetch, timeBeforeOrigin=timeBeforeOrigin, timeAfterOrigin=timeAfterOrigin, minlen=minlen)
for ind, row in ardf.iterrows():
edf, stadf = fetcher.getEqData(row,channel='*',**kwargs)
edf.dropna(inplace=True)
edf.reset_index(drop=True, inplace=True)
arDir = os.path.join(row.NAME, 'Data')
if not os.path.isdir(arDir):
os.mkdir(arDir)
for ind, eve in edf.iterrows():
eDir = os.path.join(arDir, eve.DIR)
if not os.path.isdir(eDir):
os.mkdir(eDir)
_id = eve.DIR[:-6] + '.' + row.NETWORK
st = eve.Stream
for tr in st:
sacname = _id + '.' + tr.stats.station + '.' + tr.stats.channel + '.sac'
sacname = os.path.join(eDir, sacname)
tr.write(sacname, format='SAC')
if buildArray :
refpoint = [row.LAT, row.LON]
array = gpar.arrayProcess.Array(row.NAME, refpoint, edf, coordsys=kwargs['coordsys'], phase=kwargs['phase'])
msg = ('using default parameters sll_x=-15, sll_y=-15, sl_s=0.1,grdpts_x=301, grdpts_y=301, unit="deg" for time table')
gpar.log(__name__,msg,level='info',pri=True)
array.getTimeTable()
array.write()
if outsta:
stafile = os.path.join(row.NAME, row.NAME+'.sta')
stadf.to_csv(stafile, sep=str('\t'), index=False)
def _loadFromFDSN(fet, start, end, net, sta, chan, loc):
client = fet.client
if not isinstance(chan, string_types):
chan = ','.join(chan)
else:
if '-' in chan:
chan = ','.join(chan.split('-'))
if '-' in sta:
sta = ','.join(sta.split('-'))
try:
msg = ('downloaded data %s in channel %s from %s to %s loc %s' %
(net+'.'+sta, chan, start, end, loc))
gpar.log(__name__, msg, level='warning', pri=True)
st = client.get_waveforms(net, sta, loc, chan, start, end)
except:
msg = ('Could not fetch data on %s in channel %s from %s to %s loc %s' %
(net+'.'+sta, chan, start, end, loc))
gpar.log(__name__, msg, level='warning', pri=True)
st = None
return st
def createEqList(arrayList='array.list',
ndkfile='gcmt_1996_2017.ndk',
formats='ndk',
mindis=50.0,
maxdis=75,
mag=None,
model='ak135',
beamphase=['PKiKP'],
savefile='array.list.e'):
ardf = util.readList(arrayList, list_type='array', sep='\s+')
msg = ('reading ndk file %s' % ndkfile)
gpar.log(__name__, msg, level='info', pri=True)
# ndk = obspy.read_events(ndkfile)
if formats == 'ndk':
ndk = util.readNDK(ndkfile)
elif formats == 'csv':
ndk = pd.read_csv(ndkfile, delimiter='\s+')
else:
msg = ('Not a right format for %s\nchoose from ndk or csv' % ndkfile)
gpar.log(__name__, msg, level='error', pri=True)
eqnum = [''] * len(ardf)
for ind, row in ardf.iterrows():
name = row.NAME
if not os.path.isdir(name):
os.mkdir(name)
msg = ('Generating Eq list for array %s' % name)
gpar.log(__name__, msg, level='info', pri=True)
evedf = gpar.getdata.makeEventList(
ndk=ndk,
array=name,
Olat=row.LAT,
Olon=row.LON,
mindis=mindis,
maxdis=maxdis,
minmag=mag,
model=model,
phase=beamphase,
)
# evedf = evedf[evedf.time>= UTCDateTime(starttime)]
n = len(evedf)
eqnum[ind] = n
ardf['EQNUM'] = eqnum
ardf.to_csv(savefile, sep=str('\t'), index=False)
return ardf
def _checkInputs(self):
if self.arrayName is not None and isinstance(self.arrayName, string_types):
self.arrayName = self.arrayName.upper()
if not isinstance(self.method, string_types):
msg = 'method must be a string. options:\n%s'%self.supMethods
gpar.log(__name__,msg,level='error',e=ValueError)
self.method = self.method.lower()
if not self.method in DataFetcher.subMethods:
msg = 'method %s not support. Options:\n%s'%(self.method,self.supMethods)
gpar.log(__name__,msg,level='error',e=ValueError)
if self.method == 'dir':
dirPath = glob.glob(self.arrayName)
if len(dirPath) <1:
msg = ('directory %s not found make sure path is correct' % self.arrayName)
gpar.log(__name__,msg,level='error',e=IOError)
else:
self.directory = dirPath[0]
self._getStream = _loadDirectoryData
elif self.method == 'iris':
self.client = obspy.clients.fdsn.Client('IRIS')
self._getStream = _loadFromFDSN
def quickFetch(fetch_arg,**kwargs): """ Instantiate a DataFetcher using as little information as possible """ if isinstance(fetch_arg, DataFetcher): dat_fet = fetch_arg elif isinstance(fetch_arg, string_types): if fetch_arg in DataFetcher.subMethods: if fetch_arg == 'dir': msg = 'If using method dir, please pass a path to directory' gpar.log(__name__, msg, level='error', pri=True) dat_fet = DataFetcher(fetch_arg, **kwargs) else: if not os.path.exists(fetch_arg): msg = 'Directory %s does not exist' % fetch_arg gpar.log(__name__, msg, level='error', pri=True) dat_fet = DataFetcher(method='dir', arrayName=fetch_arg, **kwargs) else: msg = 'Input not understand' gpar.log(__name__, msg, level='error', pri=True) return dat_fet
def makeEventList(ndk='gcmt_1976_2017.ndk',array='ILAR',
Olat=64.7714,Olon=-146.8861,
mindis=50, maxdis=75, minmag=None,
model='ak135',phase=['PKiKP']):
"""
Function to generate a event list form gcmt.ndk
Parameters
-----------
ndkfile: str
The path or URL to the ndk file
array: str
The name for the array
Olat: float
Latitude for the reference point in the array processing
Olon: float
Longitude for the reference point in the array processing
model: str
model for calculate the ray parameter
Return
----------
catdf: DataFrame
Catalog informations
"""
pd.set_option('precision',3)
model = TauPyModel(model)
infocolumn = ['TIME','LAT','LON','DEP','Mw','mxx','mxy','mzx','myy','myz','mzz','DIR']
if isinstance(ndk, str):
evedf = util.readNDK(ndk)
elif isinstance(ndk, obspy.core.event.Catalog):
eves = ndk
msg = 'Building dataframe for array %s'%(array)
gpar.log(__name__, msg, level='info',pri=True)
for eve in eves:
origin = eve.origins[0]
focal = eve.focal_mechanisms[0]
tensor = focal.moment_tensor.tensor
mag = eve.magnitudes[0]
#event origin information
time = origin.time
lat = origin.latitude
lon = origin.longitude
dep = origin.depth/1000.0
Mw = mag.mag
# Event moment tensor
# original in RPT coordinate, transform to XYZ coordinate
mxx = tensor.m_tt
myy = tensor.m_pp
mxy = -tensor.m_tp
myz = -tensor.m_rp
mzx = tensor.m_rt
mzz = tensor.m_rr
newRow = {'TIME':time, 'LAT':lat,'LON':lon,'DEP':dep,
'Mw':Mw,'DIR':str(time),
'mxx':mxx,'mxy':mxy,'mzx':mzx,
'myy':myy,'myz':myz,'mzz':mzz}
evedf = evedf.append(newRow, ignore_index=True)
elif isinstance(ndk, pd.DataFrame):
evedf = ndk.copy()
else:
msg = 'Not a valid type of ndk, must be a path to a ndk file or a obspy Catalog instance'%(ndk)
gpar.log(__name__,msg,level='error',pri=True)
# Great circle distance from events to array
msg = 'Calculating distance for earthquakes to array %s'%(array)
gpar.log(__name__, msg, level='info',pri=True)
great_circle_distance_in_degree, azimuth, bakAzimuth = calc_Dist_Azi(evedf.LAT,evedf.LON,Olat,Olon)
evedf['DIS'] = np.around(great_circle_distance_in_degree, decimals=2)
evedf['Az'] = np.around(azimuth, decimals=2)
evedf['Baz'] = np.around(bakAzimuth, decimals=2)
msg = 'Selecting distance from %.2f to %.2f'%(mindis, maxdis)
gpar.log(__name__, msg, level='info',pri=True)
evedf = evedf[(evedf.DIS >= mindis) & (evedf.DIS <= maxdis)]
if minmag is not None:
msg = 'Selecting magnitude larger than %s'%(minmag)
gpar.log(__name__, msg, level='info',pri=True)
evedf = evedf[evedf.Mw > minmag]
# calculate ray parameters using obspy.taup
evedf.reset_index(drop=True, inplace=True)
ray = [' ']*len(evedf)
ray_radian = [' ']*len(evedf)
takeoff_angle = [' ']*len(evedf)
for ind, row in evedf.iterrows():
# print('getting travel time for %dth event in array %s'%(ind, array))
dep = row.DEP
dis = row.DIS
try:
arr = model.get_travel_times(source_depth_in_km=dep,distance_in_degree=dis,phase_list=phase)[0]
ray[ind] = float("{0:.3f}".format(arr.ray_param_sec_degree))
ray_radian[ind] = float("{0:.3f}".format(arr.ray_param))
takeoff_angle[ind] = float("{0:.3f}".format(arr.takeoff_angle))
except:
msg = ('Problem to calculate ray parameter for eve %s to array %s, set to -999'%(row.DIR, array))
gpar.log(__name__, msg, level='warning',pri=True)
ray[ind] = -999
ray_radian[ind] = -999
takeoff_angle[ind] = -999
evedf['Rayp'] = ray
evedf['Rayp_rad'] = ray_radian
evedf['Angle'] = takeoff_angle
# Calculater radiation pattern from moment tensor, ray parameter and takeoff angle
radiation_pattern = _calRadiation(evedf.mxx,evedf.myy,evedf.mzz,
evedf.mxy,evedf.myz,evedf.mzx,
evedf.Angle,evedf.Az)
evedf['BB'] = np.around(radiation_pattern, decimals=2)
#df = evedf.copy()
cols = ['TIME', 'LAT', 'LON', 'DEP', 'Mw', 'DIS', 'Az', 'Baz','Rayp', 'BB', 'Angle','DIR']
evedf.drop(columns=['mxx','mxy','mzx','myy','myz','mzz','Rayp_rad','exp'], inplace=True)
#df.reset_index(inplace=True)
name = 'eq.'+array + '.list'
name = os.path.join(array,name)
evedf.to_csv(name, sep=str('\t'), index=False)
return evedf
def _loadDirectoryData(arrayName, df, mode,minlen,verb,channel='Z'):
staDf = pd.DataFrame(columns=['STA', 'LAT', 'LON'])
if mode == 'eq':
stream = [''] * len(df)
numtr = [''] * len(df)
elif mode == 'db':
stream1 = [''] * len(df)
stream2 = [''] * len(df)
else:
msg = ('Not a valid option for earthquake type, choose eq or db')
gpar.log(__name__, msg, level='error', pri=True)
for ind, eve in df.iterrows():
if mode == 'eq':
_id = eve.DIR[:-6]
if verb:
print('loading data %s:%s'%(arrayName, eve.DIR))
sacfiles = os.path.join(arrayName, 'Data', eve.DIR, _id+'*'+channel+'.sac')
try:
st = read(sacfiles)
except:
msg = 'data from %s in array %s is not found, skipping' % (arrayName,eve.DIR)
gpar.log(__name__,msg,level='warning',pri=True)
stream[ind] = pd.NaT
continue
for tr in st:
if not hasattr(tr.stats, 'sac'):
msg = ("Trace for %s in station %s doesn's have SAC attributes, removing" % (eve, tr.stats.station))
st.remove(tr)
gpar.log(__name__,msg,level='warning',e=ValueError)
continue
if not hasattr(tr.stats.sac, 'stla') or not hasattr(tr.stats.sac, 'stlo'):
msg = ("Trace for %s in station %s doesn's have station information, removing" % (eve.DIR, tr.stats.station))
st.remove(tr)
gpar.log(__name__,msg,level='warning',e=ValueError)
continue
data = tr.data
if np.std(data) < 0.1:
msg = ("Trace data for %s in station %s has std smaller than 0.1, removing" % (eve.DIR, tr.stats.station))
st.remove(tr)
gpar.log(__name__,msg,level='warning',e=ValueError)
continue
staDf = _checkSta(tr, staDf)
if len(st) == 0:
msg = ("Waveforms for event %s have problem" % eve.DIR)
gpar.log(__name__,msg,level='warning')
st = None
st = _checkData(st,minlen)
stream[ind] = st
if st == None:
numtr[ind] = 0
else:
numtr[ind] = len(st)
elif mode == 'db':
if verb:
print('loading data %s: %s'%(arrayName, eve.DoubleID))
_id1 = eve.DIR1[:-6]
_id2 = eve.DIR2[:-6]
sacfile1 = os.path.join(arrayName, 'Data', eve.DIR1, _id1+'*'+channel+'.sac')
sacfile2 = os.path.join(arrayName, 'Data', eve.DIR2, _id2+'*'+channel+'.sac')
try:
st1 = read(sacfile1)
except:
msg = 'data from %s in array %s is not found, skipping' % (arrayName,eve.DIR1)
gpar.log(__name__,msg,level='warning',pri=True)
stream1[ind] = pd.NaT
continue
try:
st2 = read(sacfile2)
except:
msg = 'data from %s in array %s is not found, skipping' % (arrayName,eve.DIR2)
gpar.log(__name__,msg,level='warning',pri=True)
stream2[ind] = pd.NaT
continue
st1 = _checkData(st1,minlen)
st2 = _checkData(st2,minlen)
if st1 != None:
for tr in st1:
staDf = _checkSta(tr,staDf)
if st2 != None:
for tr in st2:
staDf = _checkSta(tr,staDf)
stream1[ind] = st1
stream2[ind] = st2
if mode == 'eq':
df['Stream'] = stream
df['NTR'] = numtr
elif mode == 'db':
df['ST1'] = stream1
df['ST2'] = stream2
df.dropna(inplace=True)
df.reset_index(drop=True, inplace=True)
return df, staDf
def createArray(arrayList='array.list',
savecarray=True,
fileName='array.pkl',
model='ak135',
channel='Z',
beamphase='PKiKP',
coordsys='lonlat',
calTime=False,
save=True,
saveName=False,
mode='eq',
minlen=1500,
tshift=5,
cut=5,
phase_list=['P', 'PP', 'PcP', 'ScP', 'PKiKP', 'SP', 'ScS'],
verb=False,
**kwargs):
"""
Function to create the Array instance
"""
arraydf = util.readList(arrayList, list_type='array', sep='\s+')
arDF = pd.DataFrame(columns=['NAME', 'ARRAY'])
for ind, row in arraydf.iterrows():
# eqlist = os.path.join(row.NAME,'eq.'+row.NAME+'.list')
# if not os.path.exists(eqlist):
# msg = ('Earthquake list for array %s is not exists, building from ndk file' % row.NAME)
# gpar.log(__name__,msg,level='warning',pri=True)
# if 'ndkfile' not in kwargs.keys():
# msg = ('input the ndkfile and related parameters (see getdata.makeEventList) for building earthquake list')
# gpar.log(__name__, msg, level='error', pri=True)
# if not os.path.isfile(ndkfile):
# msg = ('ndk file does not exist')
# gpar.log(__name__,msg, level='error', pri=True)
# ndkfile = kwargs['ndkfile']
# eqdf = gpar.getdata.makeEventList(ndkfile=ndkfile,array=row.NAME,Olat=row.LAT,Olon=row.LON,
# model=model,phase=phase)
# else:
# eqdf = util.readList(eqlist,list_type='event',sep='\s+')
refpoint = [row.LAT, row.LON]
fet = gpar.getdata.quickFetch(row.NAME)
# streams = [''] * len(eqdf)
# for num, eve in eqdf.iterrows():
# st = fet.getStream(eve.DIR)
# streams[num] = st
# eqdf['Stream'] = streams
eqdf, stadf = fet.getEqData(row,
phase=beamphase,
mode=mode,
minlen=minlen,
channel=channel,
verb=verb,
**kwargs)
if eqdf is None:
msg = 'Earthquake list for array %s is not existed, skipping' % (
row.NAME)
gpar.log(__name__, msg, level='warning', pri=True)
continue
if mode == 'eq':
eqdf = eqdf[eqdf.NTR >= cut]
eqdf.reset_index(drop=True, inplace=True)
array = gpar.arrayProcess.Array(row.NAME,
refpoint,
eqdf,
stadf,
coordsys,
beamphase,
isDoublet=False,
phase_list=phase_list)
if calTime:
msg = (
'Calculate time shift table for sliding window slowness beaforming for array %s'
% row.NAME)
gpar.log(__name__, msg, level='info', pri=True)
req_pa = set(
['sll_x', 'sll_y', 'sl_s', 'grdpts_x', 'grdpts_y', 'unit'])
if not req_pa.issubset(kwargs.keys()):
msg = (
'Required parameters %s for time shift table are missing\nusing default parameters sll_x=-15, sll_y=-15, sl_s=0.1,grdpts_x=301, grdpts_y=301, unit="deg"'
% req_pa)
gpar.log(__name__, msg, level='info', pri=True)
array.getTimeTable()
else:
sll_x = kwargs['sll_x']
sll_y = kwargs['sll_y']
sl_s = kwargs['sl_s']
grdpts_x = kwargs['grdpts_x']
grdpts_y = kwargs['grdpts_y']
unit = kwargs['unit']
array.getTimeTable(sll_x=sll_x,
sll_y=sll_y,
sl_s=sl_s,
grdpts_x=grdpts_x,
grdpts_y=grdpts_y,
unit=unit)
elif mode == 'db':
req_pa = set([
'rstime', 'retime', 'cstime', 'cetime', 'filt', 'domain',
'fittype', 'rphase'
])
if not req_pa.issubset(kwargs.keys()):
msg = ('Required parameters %s for doublets are missing' %
req_pa)
gpar.log(__name__, msg, level='error', pri=True)
array = gpar.arrayProcess.Array(row.NAME,
refpoint,
eqdf,
stadf,
coordsys,
beamphase,
phase_list=phase_list,
isDoublet=True,
rstime=kwargs['rstime'],
retime=kwargs['retime'],
cstime=kwargs['cstime'],
cetime=kwargs['cetime'],
rphase=kwargs['rphase'],
filt=kwargs['filt'],
domain=kwargs['domain'],
fittype=kwargs['fittype'],
threshold=kwargs['threshold'],
cut=cut,
tshift=tshift)
if save:
array.write()
newRow = {'NAME': row.NAME, 'ARRAY': array}
arDF = arDF.append(newRow, ignore_index=True)
if saveName:
arDF.to_pickle(saveName)
return arDF
def upDateArray(
array,
beamtype='beam',
filts={
'filt_1': [1, 2, 4, True],
'filt_2': [2, 4, 4, True],
'filt_3': [1, 3, 4, True]
},
starttime=0,
endtime=1800,
unit='deg',
stack='linear',
save=True,
write=True,
**kwargs):
"""
Function to undate array processing to the array instance
array: str or instance of gpar.arrayProcess.Array or DataFrame.
If it is DataFrame, array name is needed as input of arrayName
beamtype: str. Array processing that need to be done, avaliable now:
'beam': normal beamforming
'slide': sliding window beamforming.
'vespectrum': vespectrum for seleceted array. If choose, vary for slowness or back azimuth needs to be choose either. Default vary ="slowness"
"""
if isinstance(array, gpar.arrayProcess.Array):
ar = array
elif isinstance(array, str):
ar = util.loadArray(array)
elif isinstance(array, pd.DataFrame):
tmp = array[array.NAME == kwargs['arrayName']].iloc[0]
ar = tmp.ARRAY
else:
msg = (
'Not a valid array type, must be a path, Array instance or a DataFrame that has Array instance\nif is DataFrame, arrayName is needed'
)
gpar.log(__name__, msg, level='error', pri=True)
if beamtype == 'beam':
winlen = endtime - starttime
ar.beamforming(filts=filts,
starttime=starttime,
winlen=winlen,
stack=stack,
unit=unit,
write=write)
if save:
fileName = ar.name + '.beam.pkl'
ar.write(fileName)
elif beamtype == 'slide':
req_pa = set([
'sll_x', 'sll_y', 'sl_s', 'grdpts_x', 'grdpts_y', 'winlen',
'overlap', 'sflag', 'refine'
])
if not req_pa.issubset(kwargs.keys()):
msg = (
'Required parameters %s for sliding beamforming are missing' %
req_pa)
gpar.log(__name__, msg, level='error', pri=True)
sll_x = kwargs['sll_x']
sll_y = kwargs['sll_y']
sl_s = kwargs['sl_s']
grdpts_x = kwargs['grdpts_x']
grdpts_y = kwargs['grdpts_y']
ar.getTimeTable(sll_x=sll_x,
sll_y=sll_y,
sl_s=sl_s,
grdpts_x=grdpts_x,
grdpts_y=grdpts_y,
unit=unit)
ar.slideBeam(filts=filts,
stack=stack,
starttime=starttime,
endtime=endtime,
write=write,
**kwargs)
if save:
fileName = ar.name + '.slide.pkl'
ar.write(fileName)
elif beamtype == 'vespectrum':
req_pa = set(['sl_s', 'grdpts', 'vary', 'sll'])
if not req_pa.issubset(kwargs.keys()):
msg = ('Required parameters %s for vespectrum are missing' %
req_pa)
gpar.log(__name__, msg, level='error', pri=True)
ar.vespectrum(filts=filts,
stack=stack,
starttime=starttime,
endtime=endtime,
unit=unit,
**kwargs)
if save:
fileName = ar.name + '.veps.pkl'
ar.write(fileName)
elif beamtype == 'fk':
req_pa = set([
'sll_x', 'sll_y', 'sl_s', 'grdpts_x', 'grdpts_y', 'winlen',
'overlap', 'freqmin', 'freqmax', 'prewhiten', 'method'
])
if not req_pa.issubset(kwargs.keys()):
msg = ('Required parameters %s for FK are missing' % req_pa)
gpar.log(__name__, msg, level='error', pri=True)
ar.getTimeTable(sll_x=sll_x,
sll_y=sll_y,
sl_s=sl_s,
grdpts_x=grdpts_x,
grdpts_y=grdpts_y,
unit=unit)
ar.slideFK(starttime=starttime, endtime=endtime, write=write, **kwargs)
if save:
fileName = ar.name + 'fk.pkl'
ar.write(fileName)
else:
msg = (
'Not a valid array processing, choose from beam, slide or vespectrum'
)
gpar.log(__name__, msg, level='error', pri=True)
return ar
