def produceStream(self, filepath): time, data = numpy.loadtxt(filepath, unpack=True) head, tail = os.path.split(filepath) tr = trace.Trace(data) try: #assuming that the information are in the filename following the usual convention tr.stats['network'] = tail.split('.')[1] tr.stats['station'] = tail.split('.')[0] tr.stats['channel'] = tail.split('.')[2] try: doc = etree.parse(StringIO(open(self.stationsFile).read())) ns = {"ns": "http://www.fdsn.org/xml/station/1"} tr.stats['latitude'] = self.num( doc.xpath("//ns:Station[@code='" + tr.stats['station'] + "']/ns:Latitude/text()", namespaces=ns)[0]) tr.stats['longitude'] = self.num( doc.xpath("//ns:Station[@code='" + tr.stats['station'] + "']/ns:Longitude/text()", namespaces=ns)[0]) except: with open(self.stationsFile) as f: k = False for line in f: if (k == False): k = True else: station = {} l = line.strip().split(" ") if (tr.stats['station'] == l[0]): tr.stats['latitude'] = float(l[3]) tr.stats['longitude'] = float(l[2]) except: print traceback.format_exc() # tr.stats['network']=self.parameters["network"] # tr.stats['station']=self.parameters["station"] # tr.stats['channel']=self.parameters["channel"] tr.stats['starttime'] = time[0] delta = time[1] - time[0] tr.stats['delta'] = delta #maybe decimal here tr.stats['sampling_rate'] = round(1. / delta, 1) #maybe decimal here if filepath.endswith('.semv'): tr.stats['type'] = "velocity" if filepath.endswith('.sema'): tr.stats['type'] = 'acceleration' if filepath.endswith('.semd'): tr.stats['type'] = 'displacement' st = stream.Stream() st += stream.Stream(tr) return st
def acorr(seismic_signal, **kwargs): """ Calculate phase auto-correlation for each signal in seismic_stream :param seismic_signal: :param kwargs: :return: """ # if seismic signal is a trace object, we pack it to a stream if isinstance(seismic_signal, _tr.Trace): sources = _st.Stream([seismic_signal]) else: sources = seismic_signal if not isinstance(sources, _st.Stream): raise TypeError('seismic_stream is not a Stream nor Trace object') return _st.Stream([_acorr_trace(tr, **kwargs) for tr in sources])
def array2stream(array, sampling_rate, stream_info): nchans = array.shape[0] npts = array.shape[1] traces = [] for c in range(nchans): traces.append(trace.Trace(data=array[c, :], header={'sampling_rate': sampling_rate, 'station': stream_info['station'], 'network': stream_info['network'], 'channel': stream_info['channels'][c]})) return stream.Stream(traces)
def reFormatSAC(self, paths, year, jday, newRate=5.0, channel='Z'): newSAC = stream.Stream() try: oldSAC = read(paths) except: oldSAC = stream.Stream() for nm in paths: try: aSAC = read(nm) except: print('Error reading ' + nm) else: for tr in aSAC: if channel in tr.stats.channel: oldSAC.append(tr) for tr in oldSAC: oldRate = tr.stats.sampling_rate mul = int(oldRate / newRate) if mul > 0: tr.decimate(mul, strict_length=False, no_filter=True) tr.stats.sampling_rate = newRate newSAC.append(tr) if newSAC.count() > 0: newSAC.merge(method=0, fill_value="interpolate") newSAC.detrend() tB = UTCDateTime(year=year, julday=jday, hour=0, minute=0, second=0, microsecond=0) tE = tB + 3600 * 24 new = newSAC.trim(starttime=tB, endtime=tE, pad=True, fill_value=0, nearest_sample=False) return new else: return newSAC
def xcorr(seismic_signal, wavelet, **kwargs): """ Calculate phase cross correlation (pcc) between signal and wavelet foreach signal in seismic For this purpose wavelet is shifted in time and compared to corresponding portion in each signals :param seismic_signal: seismic stream, may contain multiple traces :param wavelet: seismic trace, or stream containing single trace :param kwargs: :return: cross-correlation as stream """ # if seismic signal is a trace object, we pack it to a stream if isinstance(seismic_signal, _tr.Trace): sources = _st.Stream([seismic_signal]) else: sources = seismic_signal if not isinstance(sources, _st.Stream): raise TypeError('seismic signal is not a Stream nor Trace object') # if wavelet is a stream, we take the first trace if isinstance(wavelet, _st.Stream): ref = wavelet[0] if wavelet.count() > 1: _warning.warn( 'wavelet contains multiple traces. Using the first trace as wavelet' ) else: ref = wavelet if not isinstance(ref, _tr.Trace): raise TypeError('wavelet is not a Stream nor Trace object') return _st.Stream([_xcorr_trace(tr, ref, **kwargs) for tr in sources])
def getDataByFileName(sacFileNamesL, delta0=0.02, freq=[-1, -1], \ filterName='bandpass', corners=4, zerophase=True,maxA=1e5): if not checkSacFile(sacFileNamesL): return Data(np.zeros(0), -999, -999, 0, [-1 - 1]) sacs = stream.Stream() #time0=time.time() for sacFileNames in sacFileNamesL: tmp=mergeSacByName(sacFileNames, delta0=delta0,freq=freq,\ filterName=filterName,corners=corners,zerophase=zerophase,maxA=maxA) if tmp == None: print('False') return Data(np.zeros(0), -999, -999, 0, [-1 - 1]) else: sacs.append(tmp) time1 = time.time() dataL = sac2data(sacs, delta0=delta0) time2 = time.time() #print('read',time1-time0,'dec',time2-time1) return Data(dataL[0], dataL[1], dataL[2], dataL[3], freq)
def removeGapped(station_list): """ Remove data with gaps """ for station in station_list: # temp copy of station's stream list _stream_list = list(station.stream_list) for stream in station.stream_list: try: _st = obspy_stream.Stream() _st.append(stream.data) _gaps = _st.getGaps() if _gaps: _stream_list.remove(stream) except: _stream_list.remove(stream) # make new stream list as station's stream list station.stream_list = list(_stream_list) return removeEmptyStations(station_list)
def doCalc_syn (flag,Config,WaveformDict,FilterMetaData,Gmint,Gmaxt,TTTGridMap, Folder,Origin, ntimes, switch, ev,arrayfolder, syn_in, parameter): ''' method for calculating semblance of one station array ''' Logfile.add ('PROCESS %d %s' % (flag,' Enters Semblance Calculation') ) Logfile.add ('MINT : %f MAXT: %f Traveltime' % (Gmint,Gmaxt)) cfg = ConfigObj (dict=Config) dimX = cfg.dimX() # ('dimx') dimY = cfg.dimY() # ('dimy') winlen = cfg.winlen () # ('winlen') step = cfg.step() # ('step') new_frequence = cfg.newFrequency() #('new_frequence') forerun= cfg.Int('forerun') duration= cfg.Int('duration') gridspacing = cfg.Float('gridspacing') nostat = len (WaveformDict) traveltimes = {} recordstarttime = '' minSampleCount = 999999999 if cfg.UInt ('forerun')>0: ntimes = int ((cfg.UInt ('forerun') + cfg.UInt ('duration') ) / cfg.UInt ('step') ) else: ntimes = int ((cfg.UInt ('duration') ) / cfg.UInt ('step') ) nsamp = int (winlen * new_frequence) nstep = int (step * new_frequence) from pyrocko import obspy_compat from pyrocko import orthodrome, model obspy_compat.plant() ############################################################################ calcStreamMap = WaveformDict stations = [] py_trs = [] for trace in calcStreamMap.keys(): py_tr = obspy_compat.to_pyrocko_trace(calcStreamMap[trace]) py_trs.append(py_tr) for il in FilterMetaData: if str(il) == str(trace): szo = model.Station(lat=il.lat, lon=il.lon, station=il.sta, network=il.net, channels=py_tr.channel, elevation=il.ele, location=il.loc) stations.append(szo) #right number of stations? store_id = syn_in.store() engine = LocalEngine(store_superdirs=[syn_in.store_superdirs()]) targets = [] for st in stations: target = Target( lat=st.lat, lon=st.lon, store_id=store_id, codes=(st.network, st.station, st.location, 'BHZ'), tmin=-1900, tmax=3900, interpolation='multilinear', quantity=cfg.quantity()) targets.append(target) if syn_in.nsources() == 1: if syn_in.use_specific_stf() is True: stf = syn_in.stf() exec(stf) else: stf = STF() if syn_in.source() == 'RectangularSource': source = RectangularSource( lat=float(syn_in.lat_0()), lon=float(syn_in.lon_0()), depth=syn_in.depth_syn_0()*1000., strike=syn_in.strike_0(), dip=syn_in.dip_0(), rake=syn_in.rake_0(), width=syn_in.width_0()*1000., length=syn_in.length_0()*1000., nucleation_x=syn_in.nucleation_x_0(), slip=syn_in.slip_0(), nucleation_y=syn_in.nucleation_y_0(), stf=stf, time=util.str_to_time(syn_in.time_0())) if syn_in.source() == 'DCSource': source = DCSource( lat=float(syn_in.lat_0()), lon=float(syn_in.lon_0()), depth=syn_in.depth_syn_0()*1000., strike=syn_in.strike_0(), dip=syn_in.dip_0(), rake=syn_in.rake_0(), stf=stf, time=util.str_to_time(syn_in.time_0()), magnitude=syn_in.magnitude_0()) else: sources = [] for i in range(syn_in.nsources()): if syn_in.use_specific_stf() is True: stf = syn_in.stf() exec(stf) else: stf = STF() if syn_in.source() == 'RectangularSource': sources.append(RectangularSource( lat=float(syn_in.lat_1(i)), lon=float(syn_in.lon_1(i)), depth=syn_in.depth_syn_1(i)*1000., strike=syn_in.strike_1(i), dip=syn_in.dip_1(i), rake=syn_in.rake_1(i), width=syn_in.width_1(i)*1000., length=syn_in.length_1(i)*1000., nucleation_x=syn_in.nucleation_x_1(i), slip=syn_in.slip_1(i), nucleation_y=syn_in.nucleation_y_1(i), stf=stf, time=util.str_to_time(syn_in.time_1(i)))) if syn_in.source() == 'DCSource': sources.append(DCSource( lat=float(syn_in.lat_1(i)), lon=float(syn_in.lon_1(i)), depth=syn_in.depth_1(i)*1000., strike=syn_in.strike_1(i), dip=syn_in.dip_1(i), rake=syn_in.rake_1(i), stf=stf, time=util.str_to_time(syn_in.time_1(i)), magnitude=syn_in.magnitude_1(i))) source = CombiSource(subsources=sources) response = engine.process(source, targets) synthetic_traces = response.pyrocko_traces() if cfg.Bool('synthetic_test_add_noise') is True: from noise_addition import add_noise trs_orgs = [] calcStreamMapsyn = calcStreamMap.copy() #from pyrocko import trace for tracex in calcStreamMapsyn.keys(): for trl in synthetic_traces: if str(trl.name()[4:12]) == str(tracex[4:]): tr_org = obspy_compat.to_pyrocko_trace(calcStreamMapsyn[tracex]) tr_org.downsample_to(2.0) trs_orgs.append(tr_org) store_id = syn_in.store() engine = LocalEngine(store_superdirs=[syn_in.store_superdirs()]) synthetic_traces = add_noise(trs_orgs, engine, source.pyrocko_event(), stations, store_id, phase_def='P') trs_org = [] trs_orgs = [] fobj = os.path.join(arrayfolder, 'shift.dat') xy = num.loadtxt(fobj, usecols=1, delimiter=',') calcStreamMapsyn = calcStreamMap.copy() #from pyrocko import trace for tracex in calcStreamMapsyn.keys(): for trl in synthetic_traces: if str(trl.name()[4:12])== str(tracex[4:]): mod = trl recordstarttime = calcStreamMapsyn[tracex].stats.starttime.timestamp recordendtime = calcStreamMapsyn[tracex].stats.endtime.timestamp tr_org = obspy_compat.to_pyrocko_trace(calcStreamMapsyn[tracex]) trs_orgs.append(tr_org) tr_org_add = mod.chop(recordstarttime, recordendtime, inplace=False) synthetic_obs_tr = obspy_compat.to_obspy_trace(tr_org_add) calcStreamMapsyn[tracex] = synthetic_obs_tr trs_org.append(tr_org_add) calcStreamMap = calcStreamMapsyn if cfg.Bool('shift_by_phase_pws') == True: calcStreamMapshifted= calcStreamMap.copy() from obspy.core import stream stream = stream.Stream() for trace in calcStreamMapshifted.keys(): stream.append(calcStreamMapshifted[trace]) pws_stack = PWS_stack([stream], weight=2, normalize=True) for tr in pws_stack: for trace in calcStreamMapshifted.keys(): calcStreamMapshifted[trace]=tr calcStreamMap = calcStreamMapshifted if cfg.Bool('shift_by_phase_onset') == True: pjoin = os.path.join timeev = util.str_to_time(ev.time) trs_orgs= [] calcStreamMapshifted= calcStreamMap.copy() for trace in calcStreamMapshifted.keys(): tr_org = obspy_compat.to_pyrocko_trace(calcStreamMapshifted[trace]) trs_orgs.append(tr_org) timing = CakeTiming( phase_selection='first(p|P|PP|P(cmb)P(icb)P(icb)p(cmb)p)-20', fallback_time=100.) traces = trs_orgs event = model.Event(lat=float(ev.lat), lon=float(ev.lon), depth=ev.depth*1000., time=timeev) directory = arrayfolder bf = BeamForming(stations, traces, normalize=True) shifted_traces = bf.process(event=event, timing=timing, fn_dump_center=pjoin(directory, 'array_center.pf'), fn_beam=pjoin(directory, 'beam.mseed')) i = 0 store_id = syn_in.store() engine = LocalEngine(store_superdirs=[syn_in.store_superdirs()]) for trace in calcStreamMapshifted.keys(): recordstarttime = calcStreamMapshifted[trace].stats.starttime.timestamp recordendtime = calcStreamMapshifted[trace].stats.endtime.timestamp mod = shifted_traces[i] extracted = mod.chop(recordstarttime, recordendtime, inplace=False) shifted_obs_tr = obspy_compat.to_obspy_trace(extracted) calcStreamMapshifted[trace]=shifted_obs_tr i = i+1 calcStreamMap = calcStreamMapshifted weight = 0. if cfg.Bool('weight_by_noise') == True: from noise_analyser import analyse pjoin = os.path.join timeev = util.str_to_time(ev.time) trs_orgs= [] calcStreamMapshifted= calcStreamMap.copy() for trace in calcStreamMapshifted.keys(): tr_org = obspy_compat.to_pyrocko_trace(calcStreamMapshifted[trace]) trs_orgs.append(tr_org) timing = CakeTiming( phase_selection='first(p|P|PP|P(cmb)P(icb)P(icb)p(cmb)p)-20', fallback_time=100.) traces = trs_orgs event = model.Event(lat=float(ev.lat), lon=float(ev.lon), depth=ev.depth*1000., time=timeev) directory = arrayfolder bf = BeamForming(stations, traces, normalize=True) shifted_traces = bf.process(event=event, timing=timing, fn_dump_center=pjoin(directory, 'array_center.pf'), fn_beam=pjoin(directory, 'beam.mseed')) i = 0 store_id = syn_in.store() engine = LocalEngine(store_superdirs=[syn_in.store_superdirs()]) weight = analyse(shifted_traces, engine, event, stations, 100., store_id, nwindows=1, check_events=True, phase_def='P') for trace in calcStreamMap.keys(): recordstarttime = calcStreamMap[trace].stats.starttime d = calcStreamMap[trace].stats.starttime d = d.timestamp if calcStreamMap[trace].stats.npts < minSampleCount: minSampleCount = calcStreamMap[trace].stats.npts ############################################################################ traces = num.ndarray (shape=(len(calcStreamMap), minSampleCount), dtype=float) traveltime = num.ndarray (shape=(len(calcStreamMap), dimX*dimY), dtype=float) latv = num.ndarray (dimX*dimY, dtype=float) lonv = num.ndarray (dimX*dimY, dtype=float) ############################################################################ c=0 streamCounter = 0 for key in calcStreamMap.keys(): streamID = key c2 = 0 for o in calcStreamMap[key]: if c2 < minSampleCount: traces[c][c2] = o c2 += 1 for key in TTTGridMap.keys(): if streamID == key: traveltimes[streamCounter] = TTTGridMap[key] else: "NEIN", streamID, key if not streamCounter in traveltimes : continue #hs : thread crashed before g = traveltimes[streamCounter] dimZ = g.dimZ mint = g.mint maxt = g.maxt Latul = g.Latul Lonul = g.Lonul Lator = g.Lator Lonor = g.Lonor gridElem = g.GridArray for x in range(dimX): for y in range(dimY): elem = gridElem[x, y] traveltime [c][x * dimY + y] = elem.tt latv [x * dimY + y] = elem.lat lonv [x * dimY + y] = elem.lon #endfor c += 1 streamCounter += 1 #endfor ############################## CALCULATE PARAMETER FOR SEMBLANCE CALCULATION ################## nsamp = winlen * new_frequence nstep = int (step*new_frequence) migpoints = dimX * dimY dimZ = 0 new_frequence = cfg.newFrequency () # ['new_frequence'] maxp = int (Config['ncore']) Logfile.add ('PROCESS %d NTIMES: %d' % (flag,ntimes)) if False : print ('nostat ',nostat,type(nostat)) print ('nsamp ',nsamp,type(nsamp)) print ('ntimes ',ntimes,type(ntimes)) print ('nstep ',nstep,type(nstep)) print ('dimX ',dimX,type(dimX)) print ('dimY ',dimY,type(dimY)) print ('mint ',Gmint,type(mint)) print ('new_freq ',new_frequence,type(new_frequence)) print ('minSampleCount ',minSampleCount,type(minSampleCount)) print ('latv ',latv,type(latv)) print ('traces',traces,type(traces)) print ('traveltime',traveltime,type(traveltime)) #==================================semblance calculation======================================== t1 = time.time() traces = traces.reshape (1,nostat*minSampleCount) traveltime = traveltime.reshape (1,nostat*dimX*dimY) USE_C_CODE = True try: if USE_C_CODE : import Cm import CTrig start_time = time.time() k = Cm.otest (maxp,nostat,nsamp,ntimes,nstep,dimX,dimY,Gmint,new_frequence, minSampleCount,latv,lonv,traveltime,traces) print("--- %s seconds ---" % (time.time() - start_time)) else : start_time = time.time() k = otest (maxp,nostat,nsamp,ntimes,nstep,dimX,dimY,Gmint,new_frequence, minSampleCount,latv,lonv,traveltime,traces) #hs print("--- %s seconds ---" % (time.time() - start_time)) except: print("loaded tttgrid has probably wrong dimensions or stations, delete\ ttgrid or exchange") t2 = time.time() partSemb = k partSemb_syn = partSemb.reshape (ntimes,migpoints) return partSemb_syn
def doCalc (flag,Config,WaveformDict,FilterMetaData,Gmint,Gmaxt,TTTGridMap,Folder,Origin, ntimes, switch, ev,arrayfolder, syn_in): ''' method for calculating semblance of one station array ''' Logfile.add ('PROCESS %d %s' % (flag,' Enters Semblance Calculation') ) Logfile.add ('MINT : %f MAXT: %f Traveltime' % (Gmint,Gmaxt)) cfg = ConfigObj (dict=Config) dimX = cfg.dimX() # ('dimx') dimY = cfg.dimY() # ('dimy') winlen = cfg.winlen () # ('winlen') step = cfg.step() # ('step') new_frequence = cfg.newFrequency() #('new_frequence') forerun= cfg.Int('forerun') duration= cfg.Int('duration') gridspacing = cfg.Float('gridspacing') nostat = len (WaveformDict) traveltimes = {} recordstarttime = '' minSampleCount = 999999999 if cfg.UInt ('forerun')>0: ntimes = int ((cfg.UInt ('forerun') + cfg.UInt ('duration') ) / cfg.UInt ('step') ) else: ntimes = int ((cfg.UInt ('duration') ) / cfg.UInt ('step') ) nsamp = int (winlen * new_frequence) nstep = int (step * new_frequence) from pyrocko import obspy_compat from pyrocko import orthodrome, model obspy_compat.plant() ############################################################################ calcStreamMap = WaveformDict stations = [] py_trs = [] for trace in calcStreamMap.keys(): py_tr = obspy_compat.to_pyrocko_trace(calcStreamMap[trace]) py_trs.append(py_tr) for il in FilterMetaData: if str(il) == str(trace): szo = model.Station(lat=il.lat, lon=il.lon, station=il.sta, network=il.net, channels=py_tr.channel, elevation=il.ele, location=il.loc) stations.append(szo) #right number of stations? #==================================synthetic BeamForming======================================= if cfg.Bool('shift_by_phase_pws') == True: calcStreamMapshifted= calcStreamMap.copy() from obspy.core import stream stream = stream.Stream() for trace in calcStreamMapshifted.keys(): stream.append(calcStreamMapshifted[trace]) pws_stack = PWS_stack([stream], weight=2, normalize=True) for tr in pws_stack: for trace in calcStreamMapshifted.keys(): calcStreamMapshifted[trace]=tr calcStreamMap = calcStreamMapshifted if cfg.Bool('shift_by_phase_onset') == True: pjoin = os.path.join timeev = util.str_to_time(ev.time) trs_orgs= [] calcStreamMapshifted= calcStreamMap.copy() for trace in calcStreamMapshifted.keys(): tr_org = obspy_compat.to_pyrocko_trace(calcStreamMapshifted[trace]) trs_orgs.append(tr_org) timing = CakeTiming( phase_selection='first(p|P|PP|P(cmb)P(icb)P(icb)p(cmb)p)-20', fallback_time=100.) traces = trs_orgs event = model.Event(lat=float(ev.lat), lon=float(ev.lon), depth=ev.depth*1000., time=timeev) directory = arrayfolder bf = BeamForming(stations, traces, normalize=True) shifted_traces = bf.process(event=event, timing=timing, fn_dump_center=pjoin(directory, 'array_center.pf'), fn_beam=pjoin(directory, 'beam.mseed')) i = 0 store_id = syn_in.store() engine = LocalEngine(store_superdirs=[syn_in.store_superdirs()]) for trace in calcStreamMapshifted.keys(): recordstarttime = calcStreamMapshifted[trace].stats.starttime.timestamp recordendtime = calcStreamMapshifted[trace].stats.endtime.timestamp mod = shifted_traces[i] extracted = mod.chop(recordstarttime, recordendtime, inplace=False) shifted_obs_tr = obspy_compat.to_obspy_trace(extracted) calcStreamMapshifted[trace]=shifted_obs_tr i = i+1 calcStreamMap = calcStreamMapshifted weight = 0. if cfg.Bool('weight_by_noise') == True: from noise_analyser import analyse pjoin = os.path.join timeev = util.str_to_time(ev.time) trs_orgs= [] calcStreamMapshifted= calcStreamMap.copy() for trace in calcStreamMapshifted.keys(): tr_org = obspy_compat.to_pyrocko_trace(calcStreamMapshifted[trace]) trs_orgs.append(tr_org) timing = CakeTiming( phase_selection='first(p|P|PP|P(cmb)P(icb)P(icb)p(cmb)p)-20', fallback_time=100.) traces = trs_orgs event = model.Event(lat=float(ev.lat), lon=float(ev.lon), depth=ev.depth*1000., time=timeev) directory = arrayfolder bf = BeamForming(stations, traces, normalize=True) shifted_traces = bf.process(event=event, timing=timing, fn_dump_center=pjoin(directory, 'array_center.pf'), fn_beam=pjoin(directory, 'beam.mseed')) i = 0 store_id = syn_in.store() engine = LocalEngine(store_superdirs=[syn_in.store_superdirs()]) weight = analyse(shifted_traces, engine, event, stations, 100., store_id, nwindows=1, check_events=True, phase_def='P') for trace in calcStreamMap.keys(): recordstarttime = calcStreamMap[trace].stats.starttime d = calcStreamMap[trace].stats.starttime d = d.timestamp if calcStreamMap[trace].stats.npts < minSampleCount: minSampleCount = calcStreamMap[trace].stats.npts ############################################################################ traces = num.ndarray (shape=(len(calcStreamMap), minSampleCount), dtype=float) traveltime = num.ndarray (shape=(len(calcStreamMap), dimX*dimY), dtype=float) latv = num.ndarray (dimX*dimY, dtype=float) lonv = num.ndarray (dimX*dimY, dtype=float) ############################################################################ c=0 streamCounter = 0 for key in calcStreamMap.keys(): streamID = key c2 = 0 for o in calcStreamMap[key]: if c2 < minSampleCount: traces[c][c2] = o c2 += 1 for key in TTTGridMap.keys(): if streamID == key: traveltimes[streamCounter] = TTTGridMap[key] else: "NEIN", streamID, key if not streamCounter in traveltimes : continue #hs : thread crashed before g = traveltimes[streamCounter] dimZ = g.dimZ mint = g.mint maxt = g.maxt Latul = g.Latul Lonul = g.Lonul Lator = g.Lator Lonor = g.Lonor gridElem = g.GridArray for x in range(dimX): for y in range(dimY): elem = gridElem[x, y] traveltime [c][x * dimY + y] = elem.tt latv [x * dimY + y] = elem.lat lonv [x * dimY + y] = elem.lon #endfor c += 1 streamCounter += 1 #endfor # ==================================semblance calculation======= t1 = time.time() traces = traces.reshape(1, nostat*minSampleCount) traveltimes = traveltime.reshape(1, nostat*dimX*dimY) TTTGrid = True manual_shift = False if manual_shift: pjoin = os.path.join timeev = util.str_to_time(ev.time) trs_orgs = [] calcStreamMapshifted = calcStreamMap.copy() for trace in calcStreamMapshifted.keys(): tr_org = obspy_compat.to_pyrocko_trace( calcStreamMapshifted[trace]) trs_orgs.append(tr_org) timing = CakeTiming( phase_selection='first(p|P|PP|P(cmb)P(icb)P(icb)p(cmb)p)-20', fallback_time=100.) traces = trs_orgs backSemb = num.ndarray(shape=(ntimes, dimX*dimY), dtype=float) bf = BeamForming(stations, traces, normalize=True) for i in range(ntimes): sembmax = 0 sembmaxX = 0 sembmaxY = 0 for j in range(dimX * dimY): event = model.Event(lat=float(latv[j]), lon=float(lonv[j]), depth=ev.depth*1000., time=timeev) directory = arrayfolder shifted_traces, stack = bf.process(event=event, timing=timing, fn_dump_center=pjoin( directory, 'array_center.pf'), fn_beam=pjoin(directory, 'beam.mseed')) tmin = stack.tmin+(i*nstep)+20 tmax = stack.tmin+(i*nstep)+60 stack.chop(tmin, tmax) backSemb[i][j] = abs(sum(stack.ydata)) k = backSemb TTTGrid = False if TTTGrid: start_time = time.time() if cfg.UInt('forerun') > 0: ntimes = int((cfg.UInt('forerun') + cfg.UInt('duration'))/step) else: ntimes = int((cfg.UInt('duration')) / step) nsamp = int(winlen) nstep = int(step) Gmint = cfg.Int('forerun') k = semblance(maxp, nostat, nsamp, ntimes, nstep, dimX, dimY, Gmint, new_frequence, minSampleCount, latv, lonv, traveltimes, traces, calcStreamMap, timeev, Config, Origin) print("--- %s seconds ---" % (time.time() - start_time)) t2 = time.time() Logfile.add('%s took %0.3f s' % ('CALC:',(t2-t1))) partSemb = k partSemb = partSemb.reshape(ntimes, migpoints) return partSemb
def _rotate_corr_stream(st): """ Rotate traces in stream from the EE-EN-EZ-NE-NN-NZ-ZE-ZN-ZZ system to the RR-RT-RZ-TR-TT-TZ-ZR-ZT-ZZ system. The letters give the component order in the input and output streams. Input traces are assumed to be of same length and simultaneously sampled. """ # rotation angles # phi1 : counter clockwise angle between E and R(towards second station) # the leading -1 accounts fact that we rotate the coordinate system, not a vector phi1 = -np.pi / 180 * (90 - st[0].stats['sac']['az']) # phi2 : counter clockwise angle between E and R(away from first station) phi2 = -np.pi / 180 * (90 - st[0].stats['sac']['baz'] + 180) c1 = np.cos(phi1) s1 = np.sin(phi1) c2 = np.cos(phi2) s2 = np.sin(phi2) rtz = stream.Stream() RR = st[0].copy() RR.data = c1 * c2 * st[0].data - c1 * s2 * st[1].data - s1 * c2 * st[ 3].data + s1 * s2 * st[4].data tcha = list(RR.stats['channel']) tcha[2] = 'R' tcha[6] = 'R' RR.stats['channel'] = ''.join(tcha) rtz.append(RR) RT = st[0].copy() RT.data = c1 * s2 * st[0].data + c1 * c2 * st[1].data - s1 * s2 * st[ 3].data - s1 * c2 * st[4].data tcha = list(RT.stats['channel']) tcha[2] = 'R' tcha[6] = 'T' RT.stats['channel'] = ''.join(tcha) rtz.append(RT) RZ = st[0].copy() RZ.data = c1 * st[2].data - s1 * st[5].data tcha = list(RZ.stats['channel']) tcha[2] = 'R' tcha[6] = 'Z' RZ.stats['channel'] = ''.join(tcha) rtz.append(RZ) TR = st[0].copy() TR.data = s1 * c2 * st[0].data - s1 * s2 * st[1].data + c1 * c2 * st[ 3].data - c1 * s2 * st[4].data tcha = list(TR.stats['channel']) tcha[2] = 'T' tcha[6] = 'R' TR.stats['channel'] = ''.join(tcha) rtz.append(TR) TT = st[0].copy() TT.data = s1 * s2 * st[0].data + s1 * c2 * st[1].data + c1 * s2 * st[ 3].data + c1 * c2 * st[4].data tcha = list(TT.stats['channel']) tcha[2] = 'T' tcha[6] = 'T' TT.stats['channel'] = ''.join(tcha) rtz.append(TT) TZ = st[0].copy() TZ.data = s1 * st[2].data + c1 * st[5].data tcha = list(TZ.stats['channel']) tcha[2] = 'T' tcha[6] = 'Z' TZ.stats['channel'] = ''.join(tcha) rtz.append(TZ) ZR = st[0].copy() ZR.data = c2 * st[6].data - s2 * st[7].data tcha = list(ZR.stats['channel']) tcha[2] = 'Z' tcha[6] = 'R' ZR.stats['channel'] = ''.join(tcha) rtz.append(ZR) ZT = st[0].copy() ZT.data = s2 * st[6].data + c2 * st[7].data tcha = list(ZT.stats['channel']) tcha[2] = 'Z' tcha[6] = 'T' ZT.stats['channel'] = ''.join(tcha) rtz.append(ZT) rtz.append(st[8].copy()) return rtz
def rotate_multi_corr_stream(st): """Rotate a stream with full Greens tensor from ENZ to RTZ Take a stream with numerous correlation traces and rotate the combinations of ENZ components into combinations of RTZ components in case all nine components of the Green's tensor are present. If not all nine components are present no trace for this station combination is returned. :type st: obspy.stream :param st: stream with data in ENZ system :rtype: obspy.stream :return: stream in the RTZ system """ out_st = stream.Stream() while st: tl = range(9) tst = st.select(network=st[0].stats['network'], station=st[0].stats['station']) cnt = 0 for ttr in tst: if ttr.stats['channel'][2] == 'E': if ttr.stats['channel'][6] == 'E': tl[0] = ttr cnt += 1 elif ttr.stats['channel'][6] == 'N': tl[1] = ttr cnt += 2 elif ttr.stats['channel'][6] == 'Z': tl[2] = ttr cnt += 4 elif ttr.stats['channel'][2] == 'N': if ttr.stats['channel'][6] == 'E': tl[3] = ttr cnt += 8 elif ttr.stats['channel'][6] == 'N': tl[4] = ttr cnt += 16 elif ttr.stats['channel'][6] == 'Z': tl[5] = ttr cnt += 32 elif ttr.stats['channel'][2] == 'Z': if ttr.stats['channel'][6] == 'E': tl[6] = ttr cnt += 64 elif ttr.stats['channel'][6] == 'N': tl[7] = ttr cnt += 128 elif ttr.stats['channel'][6] == 'Z': tl[8] = ttr cnt += 256 if cnt == 2**9 - 1: st0 = stream.Stream() for t in tl: st0.append(t) st1 = _rotate_corr_stream(st0) out_st += st1 for ttr in tst: for ind, tr in enumerate(st): if ttr.id == tr.id: st.pop(ind) return out_st
def stream_pxcorr(st, options, comm=None): """ Preprocess and correlate traces in a stream This is the central function of this module. It takes an obspy.stram input stream applies and: - applies time domain preprocesing - Fourier transforms the data - applies frequency domain preprocessing - multiplies the conjugate spectra (correlation) - transforms back into time domain - returns a stream with the correlated data All this can be done in parallel on different CPU communicating via the `mpi4py` implementation of MPI. Control the different processing steps are controlled with the dictionary `options`. The following keys are required in `options`: - combinations: list of tuples that identify the combinations of the\\ traces in `st` to be correlated - lengthToSave: length of the correlated traces in s to return - normalize_correlation: Boolean. If True the correaltion is\\ normalized. If False the pure product of the spectra is returned - center_correlation: Boolean. If True th location of zero lag time\\ is in the center of the returned trace. If False the position of\\ zero lag time is determined by the start times of the traces. If\\ they are identical it is in the center anyway. If the difference \\ in start times is larger the zero lag time is offset. - TDpreProcessing: list controlling the time domain preprocessing - FDpreProcessing: list controlling the frequency domain preprocessing The item in the list `TDpreProcessing` and `FDpreProcessing` are dictionaries with two keys: `function` containing the function to apply and `args` being a dictionary with the arguments for this function. The functions in `TDpreProcessing` are applied in their order before the Fourier transformation and those in FDpreProcessing` are applied in their order Fourier domain. :Example: ``options = {'TDpreProcessing':[{'function':detrend, 'args':{'type':'linear'}}, {'function':taper, 'args':{'type':'cosTaper', 'p':0.01}}, {'function':TDfilter, 'args':{'type':'bandpass', 'freqmin':1., 'freqmax':3.}}, {'function':TDnormalization, 'args':{'filter':{'type':'bandpass', 'freqmin':0.5, 'freqmax':2.}, 'windowLength':1.}}, {'function':signBitNormalization, 'args':{}} ], 'FDpreProcessing':[{'function':spectralWhitening, 'args':{}}, {'function':FDfilter, 'args':{'flimit':[0.5, 1., 5., 7.]}}], 'lengthToSave':20, 'center_correlation':True, 'normalize_correlation':True, 'combinations':[(0,0),(0,1),(0,2),(1,2)]}`` `comm` is a mpi4py communicator that can be passed if already initialized otherwise it is created here. :type st: obspy.stream :param st: stream with traces to be correlated :type options: dictionary :param options: controll dictionary as described above :type comm: mpi4py communicator :param comm: communicator if initialized externally """ # initialize MPI if not comm: comm = MPI.COMM_WORLD rank = comm.Get_rank() # get parameters of the data if rank == 0: starttime = [] npts = [] for tr in st: starttime.append(tr.stats['starttime']) npts.append(tr.stats['npts']) npts = np.max(np.array(npts)) else: starttime = None npts = None starttime = comm.bcast(starttime, root=0) npts = comm.bcast(npts, root=0) # fill matrix with noise data A = np.zeros([npts, len(st)]) if rank == 0: for ii in range(len(st)): A[0:st[ii].stats['npts'], ii] = st[ii].data comm.Bcast([A, MPI.DOUBLE], root=0) options.update({ 'starttime': starttime, 'sampling_rate': st[0].stats['sampling_rate'] }) # call pxcorr_for correlation A, starttime = pxcorr(comm, A, **options) npts = A.shape[0] # put trace into a stream cst = stream.Stream() for ii in range(len(options['combinations'])): cstats = combine_stats(st[options['combinations'][ii][0]], st[options['combinations'][ii][1]]) cstats['starttime'] = starttime[ii] cstats['npts'] = npts cst.append(trace.Trace(data=A[:, ii], header=cstats)) cst[-1].stats_tr1 = st[options['combinations'][ii][0]].stats cst[-1].stats_tr2 = st[options['combinations'][ii][1]].stats return cst
def call(self): try: from obspy.core import UTCDateTime, stream from obspy.signal import array_analysis from obspy.imaging.cm import obspy_sequential as cmap except ImportError as _import_error: self.fail('ImportError:\n%s' % _import_error) from matplotlib.colorbar import ColorbarBase from matplotlib.colors import Normalize import matplotlib.dates as mdates self.cleanup() viewer = self.get_viewer() if viewer.lowpass is None or viewer.highpass is None: self.fail('highpass and lowpass in viewer must be set!') traces = [] for trs in self.chopper_selected_traces(fallback=True): for tr in trs: tr.lowpass(2, viewer.lowpass) tr.highpass(2, viewer.highpass) traces.extend(trs) if not traces: self.fail('no traces selected') if self.downresample == 'resample': dt_want = min([t.deltat for t in traces]) for t in traces: t.resample(dt_want) elif self.downresample == 'downsample': dt_want = max([t.deltat for t in traces]) for t in traces: t.downsample_to(dt_want) elif self.downresample == 'downsample to "target dt"': for t in traces: t.downsample_to(float(self.target_dt)) tmin = max([t.tmin for t in traces]) tmax = min([t.tmax for t in traces]) try: obspy_traces = [ p2o_trace(tr, viewer.get_station(viewer.station_key(tr))) for tr in traces ] except KeyError: self.fail('station information missing') st = stream.Stream(traces=obspy_traces) center = array_analysis.get_geometry(st, return_center=True) center_lon, center_lat, center_ele = center[len(center) - 1] # Execute sonic kwargs = dict(sll_x=-self.smax, slm_x=self.smax, sll_y=-self.smax, slm_y=self.smax, sl_s=self.smax / self.divisor, win_len=self.window_lenth, win_frac=self.win_frac, frqlow=viewer.highpass, frqhigh=viewer.lowpass, prewhiten=0, semb_thres=-1.0e9, vel_thres=-1.0e9, verbose=True, timestamp='mlabday', stime=UTCDateTime(tmin), etime=UTCDateTime(tmax)) try: out = array_analysis.array_processing(st, **kwargs) except AttributeError: from obspy.signal.array_analysis import sonic out = sonic(st, **kwargs) pi = num.pi # make output human readable, adjust backazimuth to values between 0 # and 360 t, rel_power, abs_power, baz, slow = out.T baz[baz < 0.0] += 360. # choose number of fractions in plot (desirably 360 degree/N is an # integer!) N = int(self.numberOfFraction) abins = num.arange(N + 1) * 360. / N sbins = num.linspace(0., self.smax, N + 1) # sum rel power in bins given by abins and sbins hist, baz_edges, sl_edges = num.histogram2d(baz, slow, bins=[abins, sbins], weights=rel_power) # transform to gradient baz_edges = baz_edges / 180. * pi fig = self.pylab(get='figure') cax = fig.add_axes([0.85, 0.2, 0.05, 0.5]) ax = fig.add_axes([0.10, 0.1, 0.70, 0.7], polar=True) ax.grid(False) dh = abs(sl_edges[1] - sl_edges[0]) dw = abs(baz_edges[1] - baz_edges[0]) # circle through backazimuth for i, row in enumerate(hist): ax.bar(left=(pi / 2 - (i + 1) * dw) * num.ones(N), height=dh * num.ones(N), width=dw, bottom=dh * num.arange(N), color=cmap(row / hist.max())) ax.set_xticks([pi / 2, 0, 3. / 2 * pi, pi]) ax.set_xticklabels(['N', 'E', 'S', 'W']) ax.set_ylim(0., self.smax) ColorbarBase(cax, cmap=cmap, norm=Normalize(vmin=hist.min(), vmax=hist.max())) fig2 = self.pylab(get='figure') labels = ['rel.power', 'abs.power', 'baz', 'slow'] xlocator = mdates.AutoDateLocator() ax = None for i, lab in enumerate(labels): ax = fig2.add_subplot(4, 1, i + 1, sharex=ax) ax.scatter(out[:, 0], out[:, i + 1], c=out[:, 1], alpha=0.6, edgecolors='none', cmap=cmap) ax.set_ylabel(lab) ax.set_xlim(out[0, 0], out[-1, 0]) ax.set_ylim(out[:, i + 1].min(), out[:, i + 1].max()) ax.xaxis.set_tick_params(which='both', direction='in') ax.xaxis.set_major_locator(xlocator) ax.xaxis.set_major_formatter(mdates.AutoDateFormatter(xlocator)) if i != 3: ax.set_xticklabels([]) fig2.subplots_adjust(hspace=0.) fig2.canvas.draw() fig.canvas.draw() print('Center of Array at latitude %s and longitude %s' % (center_lat, center_lon))
def doCalc(flag, Config, WaveformDict, FilterMetaData, Gmint, Gmaxt, TTTGridMap, Folder, Origin, ntimes, switch, ev, arrayfolder, syn_in): ''' method for calculating semblance of one station array ''' Logfile.add('PROCESS %d %s' % (flag, ' Enters Semblance Calculation')) Logfile.add('MINT : %f MAXT: %f Traveltime' % (Gmint, Gmaxt)) cfg = ConfigObj(dict=Config) cfg_f = FilterCfg(Config) timeev = util.str_to_time(ev.time) dimX = cfg.dimX() #('dimx') dimY = cfg.dimY() #('dimy') winlen = cfg.winlen() #('winlen') step = cfg.step() #('step') new_frequence = cfg.newFrequency() #('new_frequence') forerun = cfg.Int('forerun') duration = cfg.Int('duration') nostat = len(WaveformDict) traveltimes = {} recordstarttime = '' minSampleCount = 999999999 ntimes = int((forerun + duration) / step) nsamp = int(winlen * new_frequence) nstep = int(step * new_frequence) from pyrocko import obspy_compat from pyrocko import model obspy_compat.plant() ############################################################################ calcStreamMap = WaveformDict stations = [] py_trs = [] lats = [] lons = [] for trace in calcStreamMap.iterkeys(): py_tr = obspy_compat.to_pyrocko_trace(calcStreamMap[trace]) py_trs.append(py_tr) for il in FilterMetaData: if str(il) == str(trace): szo = model.Station(lat=float(il.lat), lon=float(il.lon), station=il.sta, network=il.net, channels=py_tr.channel, elevation=il.ele, location=il.loc) stations.append(szo) lats.append(float(il.lat)) lons.append(float(il.lon)) array_center = [num.mean(lats), num.mean(lons)] #==================================synthetic BeamForming====================== if cfg.Bool('synthetic_test') is True: store_id = syn_in.store() engine = LocalEngine(store_superdirs=[syn_in.store_superdirs()]) recordstarttimes = [] for tracex in calcStreamMap.iterkeys(): recordstarttimes.append( calcStreamMap[tracex].stats.starttime.timestamp) tr_org = obspy_compat.to_pyrocko_trace(calcStreamMap[tracex]) tmin = tr_org.tmin #tmin= num.min(recordstarttimes) targets = [] sources = [] for st in stations: target = Target(lat=st.lat, lon=st.lon, store_id=store_id, codes=(st.network, st.station, st.location, 'BHZ'), tmin=-6900, tmax=6900, interpolation='multilinear', quantity=cfg.quantity()) targets.append(target) if syn_in.nsources() == 1: if syn_in.use_specific_stf() is True: stf = syn_in.stf() exec(stf) else: stf = STF() if syn_in.source() == 'RectangularSource': sources.append( RectangularSource( lat=float(syn_in.lat_0()), lon=float(syn_in.lon_0()), east_shift=float(syn_in.east_shift_0()) * 1000., north_shift=float(syn_in.north_shift_0()) * 1000., depth=syn_in.depth_syn_0() * 1000., strike=syn_in.strike_0(), dip=syn_in.dip_0(), rake=syn_in.rake_0(), width=syn_in.width_0() * 1000., length=syn_in.length_0() * 1000., nucleation_x=syn_in.nucleation_x_0(), slip=syn_in.slip_0(), nucleation_y=syn_in.nucleation_y_0(), stf=stf, time=util.str_to_time(syn_in.time_0()))) if syn_in.source() == 'DCSource': sources.append( DCSource(lat=float(syn_in.lat_0()), lon=float(syn_in.lon_0()), east_shift=float(syn_in.east_shift_0()) * 1000., north_shift=float(syn_in.north_shift_0()) * 1000., depth=syn_in.depth_syn_0() * 1000., strike=syn_in.strike_0(), dip=syn_in.dip_0(), rake=syn_in.rake_0(), stf=stf, time=util.str_to_time(syn_in.time_0()), magnitude=syn_in.magnitude_0())) else: for i in range(syn_in.nsources()): if syn_in.use_specific_stf() is True: stf = syn_in.stf() exec(stf) else: stf = STF() if syn_in.source() == 'RectangularSource': sources.append( RectangularSource( lat=float(syn_in.lat_1(i)), lon=float(syn_in.lon_1(i)), east_shift=float(syn_in.east_shift_1(i)) * 1000., north_shift=float(syn_in.north_shift_1(i)) * 1000., depth=syn_in.depth_syn_1(i) * 1000., strike=syn_in.strike_1(i), dip=syn_in.dip_1(i), rake=syn_in.rake_1(i), width=syn_in.width_1(i) * 1000., length=syn_in.length_1(i) * 1000., nucleation_x=syn_in.nucleation_x_1(i), slip=syn_in.slip_1(i), nucleation_y=syn_in.nucleation_y_1(i), stf=stf, time=util.str_to_time(syn_in.time_1(i)))) if syn_in.source() == 'DCSource': sources.append( DCSource( lat=float(syn_in.lat_1(i)), lon=float(syn_in.lon_1(i)), east_shift=float(syn_in.east_shift_1(i)) * 1000., north_shift=float(syn_in.north_shift_1(i)) * 1000., depth=syn_in.depth_syn_1(i) * 1000., strike=syn_in.strike_1(i), dip=syn_in.dip_1(i), rake=syn_in.rake_1(i), stf=stf, time=util.str_to_time(syn_in.time_1(i)), magnitude=syn_in.magnitude_1(i))) #source = CombiSource(subsources=sources) synthetic_traces = [] for source in sources: response = engine.process(source, targets) synthetic_traces_source = response.pyrocko_traces() if not synthetic_traces: synthetic_traces = synthetic_traces_source else: for trsource, tr in zip(synthetic_traces_source, synthetic_traces): tr.add(trsource) from pyrocko import trace as trld #trld.snuffle(synthetic_traces) timeev = util.str_to_time(syn_in.time_0()) if cfg.Bool('synthetic_test_add_noise') is True: from noise_addition import add_noise trs_orgs = [] calcStreamMapsyn = calcStreamMap.copy() #from pyrocko import trace for tracex in calcStreamMapsyn.iterkeys(): for trl in synthetic_traces: if str(trl.name()[4:12]) == str(tracex[4:]) or str( trl.name()[3:13]) == str(tracex[3:]) or str( trl.name()[3:11]) == str(tracex[3:]) or str( trl.name()[3:14]) == str(tracex[3:]): tr_org = obspy_compat.to_pyrocko_trace( calcStreamMapsyn[tracex]) tr_org.downsample_to(2.0) trs_orgs.append(tr_org) store_id = syn_in.store() engine = LocalEngine(store_superdirs=[syn_in.store_superdirs()]) synthetic_traces = add_noise(trs_orgs, engine, source.pyrocko_event(), stations, store_id, phase_def='P') trs_org = [] trs_orgs = [] from pyrocko import trace fobj = os.path.join(arrayfolder, 'shift.dat') calcStreamMapsyn = calcStreamMap.copy() for tracex in calcStreamMapsyn.iterkeys(): for trl in synthetic_traces: if str(trl.name()[4:12]) == str(tracex[4:]) or str( trl.name()[3:13]) == str(tracex[3:]) or str( trl.name()[3:11]) == str(tracex[3:]) or str( trl.name()[3:14]) == str(tracex[3:]): mod = trl recordstarttime = calcStreamMapsyn[ tracex].stats.starttime.timestamp recordendtime = calcStreamMapsyn[ tracex].stats.endtime.timestamp tr_org = obspy_compat.to_pyrocko_trace( calcStreamMapsyn[tracex]) if switch == 0: tr_org.bandpass(4, cfg_f.flo(), cfg_f.fhi()) elif switch == 1: tr_org.bandpass(4, cfg_f.flo2(), cfg_f.fhi2()) trs_orgs.append(tr_org) tr_org_add = mod.chop(recordstarttime, recordendtime, inplace=False) synthetic_obs_tr = obspy_compat.to_obspy_trace(tr_org_add) calcStreamMapsyn[tracex] = synthetic_obs_tr trs_org.append(tr_org_add) calcStreamMap = calcStreamMapsyn if cfg.Bool('shift_by_phase_pws') == True: calcStreamMapshifted = calcStreamMap.copy() from obspy.core import stream stream = stream.Stream() for trace in calcStreamMapshifted.iterkeys(): stream.append(calcStreamMapshifted[trace]) pws_stack = PWS_stack([stream], weight=2, normalize=True) for tr in pws_stack: for trace in calcStreamMapshifted.iterkeys(): calcStreamMapshifted[trace] = tr calcStreamMap = calcStreamMapshifted if cfg.Bool('shift_by_phase_cc') is True: from stacking import align_traces calcStreamMapshifted = calcStreamMap.copy() list_tr = [] for trace in calcStreamMapshifted.iterkeys(): tr_org = calcStreamMapshifted[trace] list_tr.append(tr_org) shifts, ccs = align_traces(list_tr, 10, master=False) for shift in shifts: for trace in calcStreamMapshifted.iterkeys(): tr_org = obspy_compat.to_pyrocko_trace( calcStreamMapshifted[trace]) tr_org.shift(shift) shifted = obspy_compat.to_obspy_trace(tr_org) calcStreamMapshifted[trace] = shifted calcStreamMap = calcStreamMapshifted if cfg.Bool('shift_by_phase_onset') is True: pjoin = os.path.join timeev = util.str_to_time(ev.time) trs_orgs = [] calcStreamMapshifted = calcStreamMap.copy() for trace in calcStreamMapshifted.iterkeys(): tr_org = obspy_compat.to_pyrocko_trace(calcStreamMapshifted[trace]) trs_orgs.append(tr_org) timing = CakeTiming( phase_selection='first(p|P|PP|P(cmb)P(icb)P(icb)p(cmb)p)-20', fallback_time=100.) traces = trs_orgs event = model.Event(lat=float(ev.lat), lon=float(ev.lon), depth=ev.depth * 1000., time=timeev) directory = arrayfolder bf = BeamForming(stations, traces, normalize=True) shifted_traces = bf.process(event=event, timing=timing, fn_dump_center=pjoin( directory, 'array_center.pf'), fn_beam=pjoin(directory, 'beam.mseed')) i = 0 store_id = syn_in.store() engine = LocalEngine(store_superdirs=[syn_in.store_superdirs()]) for tracex in calcStreamMapshifted.iterkeys(): for trl in shifted_traces: if str(trl.name()[4:12]) == str(tracex[4:]) or str( trl.name()[3:13]) == str(tracex[3:]) or str( trl.name()[3:11]) == str(tracex[3:]) or str( trl.name()[3:14]) == str(tracex[3:]): mod = trl recordstarttime = calcStreamMapshifted[ tracex].stats.starttime.timestamp recordendtime = calcStreamMapshifted[ tracex].stats.endtime.timestamp tr_org = obspy_compat.to_pyrocko_trace( calcStreamMapshifted[tracex]) tr_org_add = mod.chop(recordstarttime, recordendtime, inplace=False) shifted_obs_tr = obspy_compat.to_obspy_trace(tr_org_add) calcStreamMapshifted[tracex] = shifted_obs_tr calcStreamMap = calcStreamMapshifted weight = 1. if cfg.Bool('weight_by_noise') is True: from noise_analyser import analyse pjoin = os.path.join timeev = util.str_to_time(ev.time) trs_orgs = [] calcStreamMapshifted = calcStreamMap.copy() for trace in calcStreamMapshifted.iterkeys(): tr_org = obspy_compat.to_pyrocko_trace(calcStreamMapshifted[trace]) trs_orgs.append(tr_org) timing = CakeTiming( phase_selection='first(p|P|PP|P(cmb)P(icb)P(icb)p(cmb)p)-20', fallback_time=100.) traces = trs_orgs event = model.Event(lat=float(ev.lat), lon=float(ev.lon), depth=ev.depth * 1000., time=timeev) directory = arrayfolder bf = BeamForming(stations, traces, normalize=True) shifted_traces = bf.process(event=event, timing=timing, fn_dump_center=pjoin( directory, 'array_center.pf'), fn_beam=pjoin(directory, 'beam.mseed')) i = 0 store_id = syn_in.store() engine = LocalEngine(store_superdirs=[syn_in.store_superdirs()]) weight = analyse(shifted_traces, engine, event, stations, 100., store_id, nwindows=1, check_events=True, phase_def='P') if cfg.Bool('array_response') is True: from obspy.signal import array_analysis from obspy.core import stream ntimesr = int((forerun + duration) / step) nsampr = int(winlen) nstepr = int(step) sll_x = -3.0 slm_x = 3.0 sll_y = -3.0 slm_y = 3.0 sl_s = 0.03, # sliding window properties # frequency properties frqlow = 1.0, frqhigh = 8.0 prewhiten = 0 # restrict output semb_thres = -1e9 vel_thres = -1e9 stime = stime etime = etime stream_arr = stream.Stream() for trace in calcStreamMapshifted.iterkeys(): stream_arr.append(calcStreamMapshifted[trace]) results = array_analysis.array_processing(stream_arr, nsamp, nstep,\ sll_x, slm_x, sll_y, slm_y,\ sl_s, semb_thres, vel_thres, \ frqlow, frqhigh, stime, \ etime, prewhiten) timestemp = results[0] relative_relpow = results[1] absolute_relpow = results[2] for trace in calcStreamMap.iterkeys(): recordstarttime = calcStreamMap[trace].stats.starttime d = calcStreamMap[trace].stats.starttime d = d.timestamp if calcStreamMap[trace].stats.npts < minSampleCount: minSampleCount = calcStreamMap[trace].stats.npts ########################################################################### traces = num.ndarray(shape=(len(calcStreamMap), minSampleCount), dtype=float) traveltime = num.ndarray(shape=(len(calcStreamMap), dimX * dimY), dtype=float) latv = num.ndarray(dimX * dimY, dtype=float) lonv = num.ndarray(dimX * dimY, dtype=float) ########################################################################### c = 0 streamCounter = 0 for key in calcStreamMap.iterkeys(): streamID = key c2 = 0 for o in calcStreamMap[key]: if c2 < minSampleCount: traces[c][c2] = o c2 += 1 for key in TTTGridMap.iterkeys(): if streamID == key: traveltimes[streamCounter] = TTTGridMap[key] else: "NEIN", streamID, key if not streamCounter in traveltimes: continue #hs : thread crashed before g = traveltimes[streamCounter] dimZ = g.dimZ mint = g.mint gridElem = g.GridArray for x in range(dimX): for y in range(dimY): elem = gridElem[x, y] traveltime[c][x * dimY + y] = elem.tt latv[x * dimY + y] = elem.lat lonv[x * dimY + y] = elem.lon #endfor c += 1 streamCounter += 1 #endfor ################ CALCULATE PARAMETER FOR SEMBLANCE CALCULATION ######## nsamp = winlen * new_frequence nstep = step * new_frequence migpoints = dimX * dimY dimZ = 0 maxp = int(Config['ncore']) Logfile.add('PROCESS %d NTIMES: %d' % (flag, ntimes)) if False: print('nostat ', nostat, type(nostat)) print('nsamp ', nsamp, type(nsamp)) print('ntimes ', ntimes, type(ntimes)) print('nstep ', nstep, type(nstep)) print('dimX ', dimX, type(dimX)) print('dimY ', dimY, type(dimY)) print('mint ', Gmint, type(mint)) print('new_freq ', new_frequence, type(new_frequence)) print('minSampleCount ', minSampleCount, type(minSampleCount)) print('latv ', latv, type(latv)) print('traces', traces, type(traces)) #===================compressed sensing================================= try: cs = cfg.cs() except: cs = 0 if cs == 1: csmaxvaluev = num.ndarray(ntimes, dtype=float) csmaxlatv = num.ndarray(ntimes, dtype=float) csmaxlonv = num.ndarray(ntimes, dtype=float) folder = Folder['semb'] fobjcsmax = open(os.path.join(folder, 'csmax_%s.txt' % (switch)), 'w') traveltimes = traveltime.reshape(1, nostat * dimX * dimY) traveltime2 = toMatrix(traveltimes, dimX * dimY) # for relstart traveltime = traveltime.reshape(dimX * dimY, nostat) import matplotlib as mpl import scipy.optimize as spopt import scipy.fftpack as spfft import scipy.ndimage as spimg import cvxpy as cvx import matplotlib.pyplot as plt A = spfft.idct(traveltime, norm='ortho', axis=0) n = (nostat * dimX * dimY) vx = cvx.Variable(dimX * dimY) res = cvx.Variable(1) objective = cvx.Minimize(cvx.norm(res, 1)) back2 = num.zeros([dimX, dimY]) l = int(nsamp) fobj = open( os.path.join(folder, '%s-%s_%03d.cs' % (switch, Origin['depth'], l)), 'w') for i in range(ntimes): ydata = [] try: for tr in traces: relstart = int((dimX * dimY - mint) * new_frequence + 0.5) + i * nstep tr = spfft.idct(tr[relstart + i:relstart + i + dimX * dimY], norm='ortho', axis=0) ydata.append(tr) ydata = num.asarray(ydata) ydata = ydata.reshape(dimX * dimY, nostat) constraints = [ res == cvx.sum_entries(0 + num.sum([ ydata[:, x] - A[:, x] * vx for x in range(nostat) ])) ] prob = cvx.Problem(objective, constraints) result = prob.solve(verbose=False, max_iters=200) x = num.array(vx.value) x = num.squeeze(x) back1 = x.reshape(dimX, dimY) sig = spfft.idct(x, norm='ortho', axis=0) back2 = back2 + back1 xs = num.array(res.value) xs = num.squeeze(xs) max_cs = num.max(back1) idx = num.where(back1 == back1.max()) csmaxvaluev[i] = max_cs csmaxlatv[i] = latv[idx[0]] csmaxlonv[i] = lonv[idx[1]] fobj.write('%.5f %.5f %.20f\n' % (latv[idx[0]], lonv[idx[1]], max_cs)) fobjcsmax.write('%.5f %.5f %.20f\n' % (latv[idx[0]], lonv[idx[1]], max_cs)) fobj.close() fobjcsmax.close() except: pass #==================================semblance calculation======================================== t1 = time.time() traces = traces.reshape(1, nostat * minSampleCount) traveltimes = traveltime.reshape(1, nostat * dimX * dimY) USE_C_CODE = False #try: if USE_C_CODE: import Cm import CTrig start_time = time.time() k = Cm.otest(maxp, nostat, nsamp, ntimes, nstep, dimX, dimY, Gmint, new_frequence, minSampleCount, latv, lonv, traveltimes, traces) print("--- %s seconds ---" % (time.time() - start_time)) else: start_time = time.time() ntimes = int((forerun + duration) / step) nsamp = int(winlen) nstep = int(step) Gmint = cfg.Int('forerun') k = otest(maxp, nostat, nsamp, ntimes, nstep, dimX, dimY, Gmint, new_frequence, minSampleCount, latv, lonv, traveltimes, traces, calcStreamMap, timeev) print("--- %s seconds ---" % (time.time() - start_time)) #except ValueError: # k = Cm.otest(maxp,nostat,nsamp,ntimes,nstep,dimX,dimY,Gmint,new_frequence, # minSampleCount,latv,lonv,traveltimes,traces) # print "loaded tttgrid has probably wrong dimensions or stations,\ # delete ttgrid or exchange is recommended" t2 = time.time() Logfile.add('%s took %0.3f s' % ('CALC:', (t2 - t1))) partSemb = k partSemb = partSemb.reshape(ntimes, migpoints) return partSemb, weight, array_center
def doCalc (flag,Config,WaveformDict,FilterMetaData,Gmint,Gmaxt,TTTGridMap,Folder,Origin, ntimes, switch, ev,arrayfolder, syn_in): ''' method for calculating semblance of one station array ''' Logfile.add ('PROCESS %d %s' % (flag,' Enters Semblance Calculation') ) Logfile.add ('MINT : %f MAXT: %f Traveltime' % (Gmint,Gmaxt)) cfg = ConfigObj (dict=Config) dimX = cfg.dimX() # ('dimx') dimY = cfg.dimY() # ('dimy') winlen = cfg.winlen () # ('winlen') step = cfg.step() # ('step') new_frequence = cfg.newFrequency() #('new_frequence') forerun= cfg.Int('forerun') duration= cfg.Int('duration') gridspacing = cfg.Float('gridspacing') nostat = len (WaveformDict) traveltimes = {} recordstarttime = '' minSampleCount = 999999999 ntimes = int ((forerun + duration)/step) nsamp = int (winlen * new_frequence) nstep = int (step * new_frequence) from pyrocko import obspy_compat from pyrocko import orthodrome, model obspy_compat.plant() ############################################################################ calcStreamMap = WaveformDict stations = [] py_trs = [] for trace in calcStreamMap.iterkeys(): py_tr = obspy_compat.to_pyrocko_trace(calcStreamMap[trace]) py_trs.append(py_tr) for il in FilterMetaData: if str(il) == str(trace): szo = model.Station(lat=il.lat, lon=il.lon, station=il.sta, network=il.net, channels=py_tr.channel, elevation=il.ele, location=il.loc) stations.append(szo) #right number of stations? #==================================synthetic BeamForming======================================= if cfg.Bool('shift_by_phase_pws') == True: calcStreamMapshifted= calcStreamMap.copy() from obspy.core import stream stream = stream.Stream() for trace in calcStreamMapshifted.iterkeys(): stream.append(calcStreamMapshifted[trace]) pws_stack = PWS_stack([stream], weight=2, normalize=True) for tr in pws_stack: for trace in calcStreamMapshifted.iterkeys(): calcStreamMapshifted[trace]=tr calcStreamMap = calcStreamMapshifted if cfg.Bool('shift_by_phase_onset') == True: pjoin = os.path.join timeev = util.str_to_time(ev.time) trs_orgs= [] calcStreamMapshifted= calcStreamMap.copy() for trace in calcStreamMapshifted.iterkeys(): tr_org = obspy_compat.to_pyrocko_trace(calcStreamMapshifted[trace]) trs_orgs.append(tr_org) timing = CakeTiming( phase_selection='first(p|P|PP|P(cmb)P(icb)P(icb)p(cmb)p)-20', fallback_time=100.) traces = trs_orgs event = model.Event(lat=float(ev.lat), lon=float(ev.lon), depth=ev.depth*1000., time=timeev) directory = arrayfolder bf = BeamForming(stations, traces, normalize=True) shifted_traces = bf.process(event=event, timing=timing, fn_dump_center=pjoin(directory, 'array_center.pf'), fn_beam=pjoin(directory, 'beam.mseed')) i = 0 store_id = syn_in.store() engine = LocalEngine(store_superdirs=[syn_in.store_superdirs()]) for trace in calcStreamMapshifted.iterkeys(): recordstarttime = calcStreamMapshifted[trace].stats.starttime.timestamp recordendtime = calcStreamMapshifted[trace].stats.endtime.timestamp mod = shifted_traces[i] extracted = mod.chop(recordstarttime, recordendtime, inplace=False) shifted_obs_tr = obspy_compat.to_obspy_trace(extracted) calcStreamMapshifted[trace]=shifted_obs_tr i = i+1 calcStreamMap = calcStreamMapshifted weight = 0. if cfg.Bool('weight_by_noise') == True: from noise_analyser import analyse pjoin = os.path.join timeev = util.str_to_time(ev.time) trs_orgs= [] calcStreamMapshifted= calcStreamMap.copy() for trace in calcStreamMapshifted.iterkeys(): tr_org = obspy_compat.to_pyrocko_trace(calcStreamMapshifted[trace]) trs_orgs.append(tr_org) timing = CakeTiming( phase_selection='first(p|P|PP|P(cmb)P(icb)P(icb)p(cmb)p)-20', fallback_time=100.) traces = trs_orgs event = model.Event(lat=float(ev.lat), lon=float(ev.lon), depth=ev.depth*1000., time=timeev) directory = arrayfolder bf = BeamForming(stations, traces, normalize=True) shifted_traces = bf.process(event=event, timing=timing, fn_dump_center=pjoin(directory, 'array_center.pf'), fn_beam=pjoin(directory, 'beam.mseed')) i = 0 store_id = syn_in.store() engine = LocalEngine(store_superdirs=[syn_in.store_superdirs()]) weight = analyse(shifted_traces, engine, event, stations, 100., store_id, nwindows=1, check_events=True, phase_def='P') for trace in calcStreamMap.iterkeys(): recordstarttime = calcStreamMap[trace].stats.starttime d = calcStreamMap[trace].stats.starttime d = d.timestamp if calcStreamMap[trace].stats.npts < minSampleCount: minSampleCount = calcStreamMap[trace].stats.npts ############################################################################ traces = num.ndarray (shape=(len(calcStreamMap), minSampleCount), dtype=float) traveltime = num.ndarray (shape=(len(calcStreamMap), dimX*dimY), dtype=float) latv = num.ndarray (dimX*dimY, dtype=float) lonv = num.ndarray (dimX*dimY, dtype=float) ############################################################################ c=0 streamCounter = 0 for key in calcStreamMap.iterkeys(): streamID = key c2 = 0 for o in calcStreamMap[key]: if c2 < minSampleCount: traces[c][c2] = o c2 += 1 for key in TTTGridMap.iterkeys(): if streamID == key: traveltimes[streamCounter] = TTTGridMap[key] else: "NEIN", streamID, key if not streamCounter in traveltimes : continue #hs : thread crashed before g = traveltimes[streamCounter] dimZ = g.dimZ mint = g.mint maxt = g.maxt Latul = g.Latul Lonul = g.Lonul Lator = g.Lator Lonor = g.Lonor gridElem = g.GridArray for x in range(dimX): for y in range(dimY): elem = gridElem[x, y] traveltime [c][x * dimY + y] = elem.tt latv [x * dimY + y] = elem.lat lonv [x * dimY + y] = elem.lon #endfor c += 1 streamCounter += 1 #endfor ############################## CALCULATE PARAMETER FOR SEMBLANCE CALCULATION ################## nsamp = winlen * new_frequence nstep = int (step*new_frequence) migpoints = dimX * dimY dimZ = 0 new_frequence = cfg.newFrequency () # ['new_frequence'] maxp = int (Config['ncore']) Logfile.add ('PROCESS %d NTIMES: %d' % (flag,ntimes)) if False : print ('nostat ',nostat,type(nostat)) print ('nsamp ',nsamp,type(nsamp)) print ('ntimes ',ntimes,type(ntimes)) print ('nstep ',nstep,type(nstep)) print ('dimX ',dimX,type(dimX)) print ('dimY ',dimY,type(dimY)) print ('mint ',Gmint,type(mint)) print ('new_freq ',new_frequence,type(new_frequence)) print ('minSampleCount ',minSampleCount,type(minSampleCount)) print ('latv ',latv,type(latv)) print ('traces',traces,type(traces)) print ('traveltime',traveltime,type(traveltime)) t1 = time.time() traces_org = traces.reshape (1,nostat*minSampleCount) traveltime_org = traveltime.reshape (1,nostat*dimX*dimY) USE_C_CODE = True try: if USE_C_CODE : import Cm import CTrig start_time = time.time() k = Cm.otest (maxp,nostat,nsamp,ntimes,nstep,dimX,dimY,Gmint,new_frequence, minSampleCount,latv,lonv,traveltime_org,traces_org) print("--- %s seconds ---" % (time.time() - start_time)) else : start_time = time.time() k = otest (maxp,nostat,nsamp,ntimes,nstep,dimX,dimY,Gmint,new_frequence, minSampleCount,latv,lonv,traveltime_org,traces_org) #hs print("--- %s seconds ---" % (time.time() - start_time)) except: print "loaded tttgrid has probably wrong dimensions or stations, delete\ ttgrid or exchange" t2 = time.time() partSemb = k partSemb_data = partSemb.reshape (ntimes,migpoints) return partSemb_data
recordstarttime = calcStreamMapsyn[tracex].stats.starttime.timestamp recordendtime = calcStreamMapsyn[tracex].stats.endtime.timestamp tr_org = obspy_compat.to_pyrocko_trace(calcStreamMapsyn[tracex]) trs_orgs.append(tr_org) tr_org_add = mod.chop(recordstarttime, recordendtime, inplace=False) synthetic_obs_tr = obspy_compat.to_obspy_trace(tr_org_add) calcStreamMapsyn[tracex] = synthetic_obs_tr trs_org.append(tr_org_add) calcStreamMap = calcStreamMapsyn if cfg.Bool('shift_by_phase_pws') == True: calcStreamMapshifted= calcStreamMap.copy() from obspy.core import stream stream = stream.Stream() for trace in calcStreamMapshifted.iterkeys(): stream.append(calcStreamMapshifted[trace]) pws_stack = PWS_stack([stream], weight=2, normalize=True) for tr in pws_stack: for trace in calcStreamMapshifted.iterkeys(): calcStreamMapshifted[trace]=tr calcStreamMap = calcStreamMapshifted if cfg.Bool('shift_by_phase_onset') == True: pjoin = os.path.join timeev = util.str_to_time(ev.time) trs_orgs= [] calcStreamMapshifted= calcStreamMap.copy() for trace in calcStreamMapshifted.iterkeys():