def FK(self, st, inv, stime, etime, fmin, fmax, slim, sres, win_len, win_frac): n = len(st) for i in range(n): coords = inv.get_coordinates(st[i].id) st[i].stats.coordinates = AttribDict({ 'latitude': coords['latitude'], 'elevation': coords['elevation'], 'longitude': coords['longitude'] }) kwargs = dict( # slowness grid: X min, X max, Y min, Y max, Slow Step sll_x=-1 * slim, slm_x=slim, sll_y=-1 * slim, slm_y=slim, sl_s=sres, # sliding open_main_window properties win_len=win_len, win_frac=win_frac, # frequency properties frqlow=fmin, frqhigh=fmax, prewhiten=0, # restrict output semb_thres=-1e9, vel_thres=-1e9, timestamp='mlabday', stime=stime + 0.1, etime=etime - 0.1) try: out = array_processing(st, **kwargs) T = out[:, 0] relpower = out[:, 1] abspower = out[:, 2] AZ = out[:, 3] AZ[AZ < 0.0] += 360 Slowness = out[:, 4] except: print("Check Parameters and Starttime/Endtime") relpower = [] abspower = [] AZ = [] Slowness = [] T = [] return relpower, abspower, AZ, Slowness, T
def _colormap_plot_beamforming_time(cmaps): """ Plot for illustrating colormaps: beamforming. :param cmaps: list of :class:`~matplotlib.colors.Colormap` :rtype: None """ import matplotlib.pyplot as plt import matplotlib.dates as mdates from obspy import UTCDateTime from obspy.signal.array_analysis import array_processing # Execute array_processing stime = UTCDateTime("20080217110515") etime = UTCDateTime("20080217110545") kwargs = dict( # slowness grid: X min, X max, Y min, Y max, Slow Step sll_x=-3.0, slm_x=3.0, sll_y=-3.0, slm_y=3.0, sl_s=0.03, # sliding window properties win_len=1.0, win_frac=0.05, # frequency properties frqlow=1.0, frqhigh=8.0, prewhiten=0, # restrict output semb_thres=-1e9, vel_thres=-1e9, timestamp='mlabday', stime=stime, etime=etime ) st = _get_beamforming_example_stream() out = array_processing(st, **kwargs) # Plot labels = ['rel.power', 'abs.power', 'baz', 'slow'] xlocator = mdates.AutoDateLocator() for cmap in cmaps: fig = plt.figure() for i, lab in enumerate(labels): ax = fig.add_subplot(4, 1, i + 1) 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_major_locator(xlocator) ax.xaxis.set_major_formatter(mdates.AutoDateFormatter(xlocator)) fig.suptitle('AGFA skyscraper blasting in Munich %s' % ( stime.strftime('%Y-%m-%d'), )) fig.autofmt_xdate() fig.subplots_adjust(left=0.15, top=0.95, right=0.95, bottom=0.2, hspace=0) plt.show()
def beamform_spherical(st, slim, sstep, freqlow, freqhigh, win_len, minbeampow, percdiv, stepdiv, Dmin, Dmax, Dstep, stime=None, etime=None, win_frac=0.05, outfolder=None, coordsys='xy', verbose=False): """ Uses plane wave beamforming to approximate answer, then searches in finer grid around answer from that for spherical wave best solution Almendros et al 1999 methods """ if outfolder is None: outfolder = os.getcwd() def dump(pow_map, apow_map, i): """Example function to use with `store` kwarg in :func:`~obspy.signal.array_analysis.array_processing`. """ np.savez(outfolder+'/pow_map_%d.npz' % i, pow_map) if stime is None: stime = st[0].stats.starttime if etime is None: etime = st[0].stats.endtime kwargs = dict( # slowness grid: X min, X max, Y min, Y max, Slow Step sll_x=-slim, slm_x=slim, sll_y=-slim, slm_y=slim, sl_s=sstep, # sliding window properties win_len=win_len, win_frac=win_frac, # frequency properties frqlow=freqlow, frqhigh=freqhigh, prewhiten=0, # restrict output semb_thres=-1e9, vel_thres=-1e9, stime=stime, etime=etime, coordsys=coordsys, store=None) t, rel_power, abs_power, baz, slow = array_processing(st, **kwargs) # Will need this for next step geometry = get_geometry(st, coordsys=coordsys) # Initiate zero result matrix for entire possible area (sparse?) - Will be # Generate time shift table for entire area for all stations (This would be 4D) # Filter seismograms to freqlims # Pull out just the data from the stream into an array for i, t1 in enumerate(t): pass
# Execute array_processing stime = obspy.UTCDateTime("20080217110515") etime = obspy.UTCDateTime("20080217110545") kwargs = dict( # slowness grid: X min, X max, Y min, Y max, Slow Step sll_x=-3.0, slm_x=3.0, sll_y=-3.0, slm_y=3.0, sl_s=0.03, # sliding window properties win_len=1.0, win_frac=0.05, # frequency properties frqlow=1.0, frqhigh=8.0, prewhiten=0, # restrict output semb_thres=-1e9, vel_thres=-1e9, timestamp='mlabday', stime=stime, etime=etime ) out = array_processing(st, **kwargs) # Plot labels = ['rel.power', 'abs.power', 'baz', 'slow'] xlocator = mdates.AutoDateLocator() fig = plt.figure() for i, lab in enumerate(labels): ax = fig.add_subplot(4, 1, i + 1) ax.scatter(out[:, 0], out[:, i + 1], c=out[:, 1], alpha=0.6, edgecolors='none', cmap=obspy_sequential) 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_major_locator(xlocator) ax.xaxis.set_major_formatter(mdates.AutoDateFormatter(xlocator))
def arrayProcessing(self, prewhiten, method): np.random.seed(2348) geometry = np.array([[0.0, 0.0, 0.0], [-5.0, 7.0, 0.0], [5.0, 7.0, 0.0], [10.0, 0.0, 0.0], [5.0, -7.0, 0.0], [-5.0, -7.0, 0.0], [-10.0, 0.0, 0.0]]) geometry /= 100 # in km slowness = 1.3 # in s/km baz_degree = 20.0 # 0.0 > source in x direction baz = baz_degree * np.pi / 180. df = 100 # samplerate # SNR = 100. # signal to noise ratio amp = .00001 # amplitude of coherent wave length = 500 # signal length in samples coherent_wave = amp * np.random.randn(length) # time offsets in samples dt = df * slowness * (np.cos(baz) * geometry[:, 1] + np.sin(baz) * geometry[:, 0]) dt = np.round(dt) dt = dt.astype('int32') max_dt = np.max(dt) + 1 min_dt = np.min(dt) - 1 trl = list() for i in xrange(len(geometry)): tr = Trace(coherent_wave[-min_dt + dt[i]:-max_dt + dt[i]].copy()) # + amp / SNR * \ # np.random.randn(length - abs(min_dt) - abs(max_dt))) tr.stats.sampling_rate = df tr.stats.coordinates = AttribDict() tr.stats.coordinates.x = geometry[i, 0] tr.stats.coordinates.y = geometry[i, 1] tr.stats.coordinates.elevation = geometry[i, 2] # lowpass random signal to f_nyquist / 2 tr.filter("lowpass", freq=df / 4.) trl.append(tr) st = Stream(trl) stime = UTCDateTime(1970, 1, 1, 0, 0) etime = UTCDateTime(1970, 1, 1, 0, 0) + \ (length - abs(min_dt) - abs(max_dt)) / df win_len = 2. step_frac = 0.2 sll_x = -3.0 slm_x = 3.0 sll_y = -3.0 slm_y = 3.0 sl_s = 0.1 frqlow = 1.0 frqhigh = 8.0 semb_thres = -1e99 vel_thres = -1e99 args = (st, win_len, step_frac, sll_x, slm_x, sll_y, slm_y, sl_s, semb_thres, vel_thres, frqlow, frqhigh, stime, etime) kwargs = dict(prewhiten=prewhiten, coordsys='xy', verbose=False, method=method) out = array_processing(*args, **kwargs) if 0: # 1 for debugging print '\n', out[:, 1:] return out
sll_y=-3.0, slm_y=3.0, sl_s=0.03, # sliding window properties win_len=1.0, win_frac=0.05, # frequency properties frqlow=1.0, frqhigh=8.0, prewhiten=0, # restrict output semb_thres=-1e9, vel_thres=-1e9, stime=obspy.UTCDateTime("20080217110515"), etime=obspy.UTCDateTime("20080217110545")) out = array_processing(st, **kwargs) # Plot cmap = obspy_sequential # 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 = 36 N2 = 30 abins = np.arange(N + 1) * 360. / N sbins = np.linspace(0, 3, N2 + 1)
def array_processing(self, prewhiten, method): np.random.seed(2348) geometry = np.array([[0.0, 0.0, 0.0], [-5.0, 7.0, 0.0], [5.0, 7.0, 0.0], [10.0, 0.0, 0.0], [5.0, -7.0, 0.0], [-5.0, -7.0, 0.0], [-10.0, 0.0, 0.0]]) geometry /= 100 # in km slowness = 1.3 # in s/km baz_degree = 20.0 # 0.0 > source in x direction baz = baz_degree * np.pi / 180. df = 100 # samplerate # SNR = 100. # signal to noise ratio amp = .00001 # amplitude of coherent wave length = 500 # signal length in samples coherent_wave = amp * np.random.randn(length) # time offsets in samples dt = df * slowness * (np.cos(baz) * geometry[:, 1] + np.sin(baz) * geometry[:, 0]) dt = np.round(dt) dt = dt.astype(np.int32) max_dt = np.max(dt) + 1 min_dt = np.min(dt) - 1 trl = list() for i in range(len(geometry)): tr = Trace(coherent_wave[-min_dt + dt[i]:-max_dt + dt[i]].copy()) # + amp / SNR * \ # np.random.randn(length - abs(min_dt) - abs(max_dt))) tr.stats.sampling_rate = df tr.stats.coordinates = AttribDict() tr.stats.coordinates.x = geometry[i, 0] tr.stats.coordinates.y = geometry[i, 1] tr.stats.coordinates.elevation = geometry[i, 2] # lowpass random signal to f_nyquist / 2 tr.filter("lowpass", freq=df / 4.) trl.append(tr) st = Stream(trl) stime = UTCDateTime(1970, 1, 1, 0, 0) etime = UTCDateTime(1970, 1, 1, 0, 0) + 4.0 # TODO: check why this does not work any more # (length - abs(min_dt) - abs(max_dt)) / df win_len = 2. step_frac = 0.2 sll_x = -3.0 slm_x = 3.0 sll_y = -3.0 slm_y = 3.0 sl_s = 0.1 frqlow = 1.0 frqhigh = 8.0 semb_thres = -1e99 vel_thres = -1e99 args = (st, win_len, step_frac, sll_x, slm_x, sll_y, slm_y, sl_s, semb_thres, vel_thres, frqlow, frqhigh, stime, etime) kwargs = dict(prewhiten=prewhiten, coordsys='xy', verbose=False, method=method) out = array_processing(*args, **kwargs) if False: # 1 for debugging print('\n', out[:, 1:]) return out
def _colormap_plot_beamforming_polar(cmaps): """ Plot for illustrating colormaps: beamforming. :param cmaps: list of :class:`~matplotlib.colors.Colormap` :rtype: None """ import matplotlib.pyplot as plt from matplotlib.colorbar import ColorbarBase from matplotlib.colors import Normalize from obspy import UTCDateTime from obspy.signal.array_analysis import array_processing # Execute array_processing kwargs = dict( # slowness grid: X min, X max, Y min, Y max, Slow Step sll_x=-3.0, slm_x=3.0, sll_y=-3.0, slm_y=3.0, sl_s=0.03, # sliding window properties win_len=1.0, win_frac=0.05, # frequency properties frqlow=1.0, frqhigh=8.0, prewhiten=0, # restrict output semb_thres=-1e9, vel_thres=-1e9, stime=UTCDateTime("20080217110515"), etime=UTCDateTime("20080217110545") ) st = _get_beamforming_example_stream() out = array_processing(st, **kwargs) # 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!) num = 36 num2 = 30 abins = np.arange(num + 1) * 360. / num sbins = np.linspace(0, 3, num2 + 1) # sum rel power in bins given by abins and sbins hist, baz_edges, sl_edges = \ np.histogram2d(baz, slow, bins=[abins, sbins], weights=rel_power) # transform to radian baz_edges = np.radians(baz_edges) dh = abs(sl_edges[1] - sl_edges[0]) dw = abs(baz_edges[1] - baz_edges[0]) for cmap in cmaps: # add polar and colorbar axes fig = plt.figure(figsize=(8, 8)) 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.set_theta_direction(-1) ax.set_theta_zero_location("N") # circle through backazimuth for i, row in enumerate(hist): ax.bar(left=(i * dw) * np.ones(num2), height=dh * np.ones(num2), width=dw, bottom=dh * np.arange(num2), color=cmap(row / hist.max())) ax.set_xticks(np.linspace(0, 2 * np.pi, 4, endpoint=False)) ax.set_xticklabels(['N', 'E', 'S', 'W']) # set slowness limits ax.set_ylim(0, 3) [i.set_color('grey') for i in ax.get_yticklabels()] ColorbarBase(cax, cmap=cmap, norm=Normalize(vmin=hist.min(), vmax=hist.max())) plt.show()
def beamform_plane(st, sll_x, slm_x, sll_y, slm_y, sstep, freqlow, freqhigh, win_len, stime=None, etime=None, win_frac=0.05, coordsys='xy', outfolder=None, movie=True, savemovieimg=False, plottype='slowaz', showplots=True, saveplots=False, plotlabel=''): """ MAKE CHOICE TO USE Sx Sy or S A in PLOTTING plotype = 'slowaz' or 'wavenum' NEED ffmpeg for movie making to work, otherwise will just get the images """ if outfolder is None: outfolder = os.getcwd() def dump(pow_map, apow_map, i): """Example function to use with `store` kwarg in :func:`~obspy.signal.array_analysis.array_processing`. """ np.savez(outfolder+'/pow_map_%d.npz' % i, pow_map) if stime is None: stime = st[0].stats.starttime if etime is None: etime = st[0].stats.endtime if movie: store = dump else: store = None kwargs = dict( # slowness grid: X min, X max, Y min, Y max, Slow Step sll_x=sll_x, slm_x=slm_x, sll_y=sll_y, slm_y=slm_y, sl_s=sstep, # sliding window properties win_len=win_len, win_frac=win_frac, # frequency properties frqlow=freqlow, frqhigh=freqhigh, prewhiten=0, # restrict output semb_thres=-1e9, vel_thres=-1e9, stime=stime, etime=etime, coordsys=coordsys, store=store) out = array_processing(st, **kwargs) # 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 # Plot 1 labels = ['rel.power', 'abs.power', 'baz', 'slow'] xlocator = mdates.AutoDateLocator() fig1 = plt.figure() for i, lab in enumerate(labels): ax = fig1.add_subplot(4, 1, i + 1) ax.scatter(out[:, 0], out[:, i + 1], c=out[:, 1], alpha=0.6, edgecolors='none') 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_major_locator(xlocator) ax.xaxis.set_major_formatter(mdates.AutoDateFormatter(xlocator)) fig1.autofmt_xdate() fig1.subplots_adjust(left=0.15, top=0.95, right=0.95, bottom=0.2, hspace=0) # Plot 2 cmap = cm.hot_r # choose number of fractions in plot (desirably 360 degree/N is an integer!) N = 36 N2 = 30 abins = np.arange(N + 1) * 360. / N sbins = np.linspace(0, np.sqrt(slm_x**2 + slm_y**2), N2 + 1) # sum rel power in bins given by abins and sbins hist, baz_edges, sl_edges = np.histogram2d(baz, slow, bins=[abins, sbins], weights=rel_power) # transform to radian baz_edges = np.radians(baz_edges) # add polar and colorbar axes fig2 = plt.figure(figsize=(8, 8)) cax = fig2.add_axes([0.85, 0.2, 0.05, 0.5]) ax = fig2.add_axes([0.10, 0.1, 0.70, 0.7], polar=True) ax.set_theta_direction(-1) ax.set_theta_zero_location('N') 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): bars = ax.bar(left=(i * dw) * np.ones(N2), height=dh * np.ones(N2), width=dw, bottom=dh * np.arange(N2), color=cmap(row / hist.max())) ax.set_xticks(np.linspace(0, 2 * np.pi, np.sqrt(slm_x**2 + slm_y**2), endpoint=False)) ax.set_xticklabels(['N', 'E', 'S', 'W']) # set slowness limits ax.set_ylim(0, np.sqrt(slm_x**2 + slm_y**2)) [i.set_color('grey') for i in ax.get_yticklabels()] ColorbarBase(cax, cmap=cmap, norm=Normalize(vmin=hist.min(), vmax=hist.max())) if showplots is True: plt.show() if saveplots is True: fig1.savefig('%s/%s-%s.png' % (outfolder, 'timeplot', plotlabel)) fig2.savefig('%s/%s-%s.png' % (outfolder, 'overallplot', plotlabel)) if movie: cmap = cm.RdYlBu xgrid = np.arange(sll_x, slm_x+sstep, sstep) ygrid = np.arange(sll_y, slm_y+sstep, sstep) slow2 = np.empty((len(xgrid), len(ygrid))) baz2 = slow2.copy() for i in np.arange(len(xgrid)): for j in np.arange(len(ygrid)): # compute baz, slow slow_x = xgrid[i] slow_y = ygrid[j] slow2[i, j] = np.sqrt(slow_x ** 2 + slow_y ** 2) if slow2[i, j] < 1e-8: slow2[i, j] = 1e-8 azimut = 180 * math.atan2(slow_x, slow_y) / math.pi baz2[i, j] = azimut % -360 + 180 baz2[baz2 < 0.0] += 360 # transform to radian baz2 = np.radians(baz2) x, y = np.meshgrid(xgrid, ygrid) #pow_map_mean = np.array((x, y)) findind = 0 stfilt = st.copy() stfilt.filter('bandpass', freqmin=freqlow, freqmax=freqhigh) stfilt.trim(stime-5., etime+5., pad=True, fill_value=0.) for i, t1 in enumerate(t): filen = glob.glob(outfolder+'/pow_map_%i.npz' % findind) f = np.load(filen[0]) pow_map = f['arr_0'] fig = plt.figure(figsize=(18, 6)) ax = fig.add_axes([0.05, 0.05, 0.25, 0.9], polar=True) ax.pcolormesh(baz2, slow2, pow_map, vmin=0., vmax=1., cmap=cmap) ax.set_theta_direction(-1) ax.set_theta_zero_location('N') #ax.set_ylim(0, np.sqrt(slm_x**2 + slm_y**2)) ax.set_ylim(0, np.max([slm_x, slm_y])) ix, iy = np.unravel_index(pow_map.argmax(), pow_map.shape) az = 180 * math.atan2(xgrid[ix], ygrid[iy]) / math.pi bazimut = az % -360 + 180 if bazimut < 0.0: bazimut += 360 slow1 = np.sqrt(xgrid[ix]**2 + ygrid[iy]**2) ax.plot(np.radians(bazimut), slow1, 'xk') ax.text(np.radians(bazimut), slow1, ' %1.1f km/s\\n %1.0f deg' % (1./slow1, bazimut)) ax.grid() plt.draw() cax = fig.add_axes([0.32, 0.15, 0.01, 0.7]) ColorbarBase(cax, cmap=cmap, norm=Normalize(vmin=0.0, vmax=1.)) ax1 = fig.add_axes([0.37, 0.05, 0.58, 0.9]) tvec = sigproc.maketvec(stfilt[0]) #import pdb; pdb.set_trace() ax1.plot(tvec, stfilt[0].data/max(stfilt[0].data), 'k', label=stfilt[0].stats.station) ax1.plot(tvec, stfilt[1].data/max(stfilt[1].data) + 1.5, 'k', label=stfilt[1].stats.station) ax1.plot(tvec, stfilt[2].data/max(stfilt[2].data) + 3., 'k', label=stfilt[2].stats.station) sec = UTCDateTime(mdates.num2date(t1))-stfilt[0].stats.starttime ax1.vlines(sec, -1, 4, color='r') ax1.vlines(sec + win_len, -1, 4, color='r') plt.title('Max at %3.0f degrees, speed of %1.1f km/s - tstart %1.0f' % (baz[i], 1/slow[i], sec)) ax1.set_ylim(-1, 4) plt.savefig(('%s/img%03d.png') % (outfolder, i)) findind += int(win_len*st[0].stats.sampling_rate*win_frac) #plt.draw() plt.show() plt.close(fig) #turn into mpg origdir = os.getcwd() os.chdir(outfolder) os.system('ffmpeg -f image2 -start_number 0 -r 4 -i img%03d.png -y -c:v libx264 -vf "format=yuv420p" beammovie.mp4') # Clean up delfiles = glob.glob(outfolder+'/pow_map_*.npz') for df in delfiles: os.remove(df) if savemovieimg is False: delfiles = glob.glob(outfolder+'/img*png') for df in delfiles: os.remove(df) os.chdir(origdir) return t, rel_power, abs_power, baz, slow
def array_analysis_helper(stream, inventory, method, frqlow, frqhigh, filter=True, baz_plot=True, static3D=False, vel_corr=4.8, wlen=-1, slx=(-10, 10), sly=(-10, 10), sls=0.5, array_response=True): """ Array analysis wrapper routine for MESS 2014. :param stream: Waveforms for the array processing. :type stream: :class:`obspy.core.stream.Stream` :param inventory: Station metadata for waveforms :type inventory: :class:`obspy.station.inventory.Inventory` :param method: Method used for the array analysis (one of "FK": Frequnecy Wavenumber, "DLS": Delay and Sum, "PWS": Phase Weighted Stack, "SWP": Slowness Whitened Power). :type method: str :param filter: Whether to bandpass data to selected frequency range :type filter: bool :param frqlow: Low corner of frequency range for array analysis :type frqlow: float :param frqhigh: High corner of frequency range for array analysis :type frqhigh: float :param baz_plot: Whether to show backazimuth-slowness map (True) or slowness x-y map (False). :type baz_plot: str :param static3D: static correction of topography using `vel_corr` as velocity (slow!) :type static3D: bool :param vel_corr: Correction velocity for static topography correction in km/s. :type vel_corr: float :param wlen: sliding window for analysis in seconds, use -1 to use the whole trace without windowing. :type wlen: float :param slx: Min/Max slowness for analysis in x direction. :type slx: (float, float) :param sly: Min/Max slowness for analysis in y direction. :type sly: (float, float) :param sls: step width of slowness grid :type sls: float :param array_response: superimpose array reponse function in plot (slow!) :type array_response: bool """ if method not in ("FK", "DLS", "PWS", "SWP"): raise ValueError("Invalid method: ''" % method) sllx, slmx = slx slly, slmy = sly starttime = max([tr.stats.starttime for tr in stream]) endtime = min([tr.stats.endtime for tr in stream]) stream.trim(starttime, endtime) #stream.attach_response(inventory) stream.merge() for tr in stream: for station in inventory[0].stations: if tr.stats.station == station.code: tr.stats.coordinates = \ AttribDict(dict(latitude=station.latitude, longitude=station.longitude, elevation=station.elevation)) break if filter: stream.filter('bandpass', freqmin=frqlow, freqmax=frqhigh, zerophase=True) print stream spl = stream.copy() tmpdir = tempfile.mkdtemp(prefix="obspy-") filename_patterns = (os.path.join(tmpdir, 'pow_map_%03d.npy'), os.path.join(tmpdir, 'apow_map_%03d.npy')) def dump(pow_map, apow_map, i): np.save(filename_patterns[0] % i, pow_map) np.save(filename_patterns[1] % i, apow_map) try: # next step would be needed if the correction velocity needs to be # estimated # sllx /= KM_PER_DEG slmx /= KM_PER_DEG slly /= KM_PER_DEG slmy /= KM_PER_DEG sls /= KM_PER_DEG vc = vel_corr if method == 'FK': kwargs = dict( #slowness grid: X min, X max, Y min, Y max, Slow Step sll_x=sllx, slm_x=slmx, sll_y=slly, slm_y=slmy, sl_s=sls, # sliding window properties win_len=wlen, win_frac=0.8, # frequency properties frqlow=frqlow, frqhigh=frqhigh, prewhiten=0, # restrict output store=dump, semb_thres=-1e9, vel_thres=-1e9, verbose=False, timestamp='julsec', stime=starttime, etime=endtime, method=0, correct_3dplane=False, vel_cor=vc, static_3D=static3D) # here we do the array processing start = UTCDateTime() out = AA.array_processing(stream, **kwargs) print "Total time in routine: %f\n" % (UTCDateTime() - start) # make output human readable, adjust backazimuth to values # between 0 and 360 t, rel_power, abs_power, baz, slow = out.T else: kwargs = dict( # slowness grid: X min, X max, Y min, Y max, Slow Step sll_x=sllx, slm_x=slmx, sll_y=slly, slm_y=slmy, sl_s=sls, # sliding window properties # frequency properties frqlow=frqlow, frqhigh=frqhigh, # restrict output store=dump, win_len=wlen, win_frac=0.5, nthroot=4, method=method, verbose=False, timestamp='julsec', stime=starttime, etime=endtime, vel_cor=vc, static_3D=False) # here we do the array processing start = UTCDateTime() out = AA.beamforming(stream, **kwargs) print "Total time in routine: %f\n" % (UTCDateTime() - start) # make output human readable, adjust backazimuth to values # between 0 and 360 trace = [] t, rel_power, baz, slow_x, slow_y, slow = out.T # calculating array response if array_response: stepsfreq = (frqhigh - frqlow) / 10. tf_slx = sllx tf_smx = slmx tf_sly = slly tf_smy = slmy transff = AA.array_transff_freqslowness( stream, (tf_slx, tf_smx, tf_sly, tf_smy), sls, frqlow, frqhigh, stepsfreq, coordsys='lonlat', correct_3dplane=False, static_3D=False, vel_cor=vc) # now let's do the plotting cmap = cm.rainbow # # we will plot everything in s/deg slow *= KM_PER_DEG sllx *= KM_PER_DEG slmx *= KM_PER_DEG slly *= KM_PER_DEG slmy *= KM_PER_DEG sls *= KM_PER_DEG numslice = len(t) powmap = [] slx = np.arange(sllx-sls, slmx, sls) sly = np.arange(slly-sls, slmy, sls) if baz_plot: maxslowg = np.sqrt(slmx*slmx + slmy*slmy) bzs = np.arctan2(sls, np.sqrt(slmx*slmx + slmy*slmy))*180/np.pi xi = np.arange(0., maxslowg, sls) yi = np.arange(-180., 180., bzs) grid_x, grid_y = np.meshgrid(xi, yi) # reading in the rel-power maps for i in xrange(numslice): powmap.append(np.load(filename_patterns[0] % i)) if method != 'FK': trace.append(np.load(filename_patterns[1] % i)) npts = stream[0].stats.npts df = stream[0].stats.sampling_rate T = np.arange(0, npts / df, 1 / df) # if we choose windowlen > 0. we now move through our slices for i in xrange(numslice): slow_x = np.sin((baz[i]+180.)*np.pi/180.)*slow[i] slow_y = np.cos((baz[i]+180.)*np.pi/180.)*slow[i] st = UTCDateTime(t[i]) - starttime if wlen <= 0: en = endtime else: en = st + wlen print UTCDateTime(t[i]) # add polar and colorbar axes fig = plt.figure(figsize=(12, 12)) ax1 = fig.add_axes([0.1, 0.87, 0.7, 0.10]) # here we plot the first trace on top of the slowness map # and indicate the possibiton of the lsiding window as green box if method == 'FK': ax1.plot(T, spl[0].data, 'k') if wlen > 0.: try: ax1.axvspan(st, en, facecolor='g', alpha=0.3) except IndexError: pass else: T = np.arange(0, len(trace[i])/df, 1 / df) ax1.plot(T, trace[i], 'k') ax1.yaxis.set_major_locator(MaxNLocator(3)) ax = fig.add_axes([0.10, 0.1, 0.70, 0.7]) # if we have chosen the baz_plot option a re-griding # of the sx,sy slowness map is needed if baz_plot: slowgrid = [] transgrid = [] pow = np.asarray(powmap[i]) for ix, sx in enumerate(slx): for iy, sy in enumerate(sly): bbaz = np.arctan2(sx, sy)*180/np.pi+180. if bbaz > 180.: bbaz = -180. + (bbaz-180.) slowgrid.append((np.sqrt(sx*sx+sy*sy), bbaz, pow[ix, iy])) if array_response: tslow = (np.sqrt((sx+slow_x) * (sx+slow_x)+(sy+slow_y) * (sy+slow_y))) tbaz = (np.arctan2(sx+slow_x, sy+slow_y) * 180 / np.pi + 180.) if tbaz > 180.: tbaz = -180. + (tbaz-180.) transgrid.append((tslow, tbaz, transff[ix, iy])) slowgrid = np.asarray(slowgrid) sl = slowgrid[:, 0] bz = slowgrid[:, 1] slowg = slowgrid[:, 2] grid = spi.griddata((sl, bz), slowg, (grid_x, grid_y), method='nearest') ax.pcolormesh(xi, yi, grid, cmap=cmap) if array_response: level = np.arange(0.1, 0.5, 0.1) transgrid = np.asarray(transgrid) tsl = transgrid[:, 0] tbz = transgrid[:, 1] transg = transgrid[:, 2] trans = spi.griddata((tsl, tbz), transg, (grid_x, grid_y), method='nearest') ax.contour(xi, yi, trans, level, colors='k', linewidth=0.2) ax.set_xlabel('slowness [s/deg]') ax.set_ylabel('backazimuth [deg]') ax.set_xlim(xi[0], xi[-1]) ax.set_ylim(yi[0], yi[-1]) else: ax.set_xlabel('slowness [s/deg]') ax.set_ylabel('slowness [s/deg]') slow_x = np.cos((baz[i]+180.)*np.pi/180.)*slow[i] slow_y = np.sin((baz[i]+180.)*np.pi/180.)*slow[i] ax.pcolormesh(slx, sly, powmap[i].T) ax.arrow(0, 0, slow_y, slow_x, head_width=0.005, head_length=0.01, fc='k', ec='k') if array_response: tslx = np.arange(sllx+slow_x, slmx+slow_x+sls, sls) tsly = np.arange(slly+slow_y, slmy+slow_y+sls, sls) try: ax.contour(tsly, tslx, transff.T, 5, colors='k', linewidth=0.5) except: pass ax.set_ylim(slx[0], slx[-1]) ax.set_xlim(sly[0], sly[-1]) new_time = t[i] result = "BAZ: %.2f, Slow: %.2f s/deg, Time %s" % ( baz[i], slow[i], UTCDateTime(new_time)) ax.set_title(result) plt.show() finally: shutil.rmtree(tmpdir)
def beamform_spherical(st, slim, sstep, freqlow, freqhigh, win_len, minbeampow, percdiv, stepdiv, Dmin, Dmax, Dstep, stime=None, etime=None, win_frac=0.05, outfolder=None, coordsys='xy', verbose=False): """ Uses plane wave beamforming to approximate answer, then searches in finer grid around answer from that for spherical wave best solution Almendros et al 1999 methods """ if outfolder is None: outfolder = os.getcwd() def dump(pow_map, apow_map, i): """Example function to use with `store` kwarg in :func:`~obspy.signal.array_analysis.array_processing`. """ np.savez(outfolder + '/pow_map_%d.npz' % i, pow_map) if stime is None: stime = st[0].stats.starttime if etime is None: etime = st[0].stats.endtime kwargs = dict( # slowness grid: X min, X max, Y min, Y max, Slow Step sll_x=-slim, slm_x=slim, sll_y=-slim, slm_y=slim, sl_s=sstep, # sliding window properties win_len=win_len, win_frac=win_frac, # frequency properties frqlow=freqlow, frqhigh=freqhigh, prewhiten=0, # restrict output semb_thres=-1e9, vel_thres=-1e9, stime=stime, etime=etime, coordsys=coordsys, store=None) t, rel_power, abs_power, baz, slow = array_processing(st, **kwargs) # Will need this for next step geometry = get_geometry(st, coordsys=coordsys) # Initiate zero result matrix for entire possible area (sparse?) - Will be # Generate time shift table for entire area for all stations (This would be 4D) # Filter seismograms to freqlims # Pull out just the data from the stream into an array for i, t1 in enumerate(t): pass
def beamform_plane(st, sll_x, slm_x, sll_y, slm_y, sstep, freqlow, freqhigh, win_len, stime=None, etime=None, win_frac=0.05, coordsys='xy', outfolder=None, movie=True, savemovieimg=False, plottype='slowaz', showplots=True, saveplots=False, plotlabel=''): """ MAKE CHOICE TO USE Sx Sy or S A in PLOTTING plotype = 'slowaz' or 'wavenum' NEED ffmpeg for movie making to work, otherwise will just get the images """ if outfolder is None: outfolder = os.getcwd() def dump(pow_map, apow_map, i): """Example function to use with `store` kwarg in :func:`~obspy.signal.array_analysis.array_processing`. """ np.savez(outfolder + '/pow_map_%d.npz' % i, pow_map) if stime is None: stime = st[0].stats.starttime if etime is None: etime = st[0].stats.endtime if movie: store = dump else: store = None kwargs = dict( # slowness grid: X min, X max, Y min, Y max, Slow Step sll_x=sll_x, slm_x=slm_x, sll_y=sll_y, slm_y=slm_y, sl_s=sstep, # sliding window properties win_len=win_len, win_frac=win_frac, # frequency properties frqlow=freqlow, frqhigh=freqhigh, prewhiten=0, # restrict output semb_thres=-1e9, vel_thres=-1e9, stime=stime, etime=etime, coordsys=coordsys, store=store) out = array_processing(st, **kwargs) # 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 # Plot 1 labels = ['rel.power', 'abs.power', 'baz', 'slow'] xlocator = mdates.AutoDateLocator() fig1 = plt.figure() for i, lab in enumerate(labels): ax = fig1.add_subplot(4, 1, i + 1) ax.scatter(out[:, 0], out[:, i + 1], c=out[:, 1], alpha=0.6, edgecolors='none') 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_major_locator(xlocator) ax.xaxis.set_major_formatter(mdates.AutoDateFormatter(xlocator)) fig1.autofmt_xdate() fig1.subplots_adjust(left=0.15, top=0.95, right=0.95, bottom=0.2, hspace=0) # Plot 2 cmap = cm.hot_r # choose number of fractions in plot (desirably 360 degree/N is an integer!) N = 36 N2 = 30 abins = np.arange(N + 1) * 360. / N sbins = np.linspace(0, np.sqrt(slm_x**2 + slm_y**2), N2 + 1) # sum rel power in bins given by abins and sbins hist, baz_edges, sl_edges = np.histogram2d(baz, slow, bins=[abins, sbins], weights=rel_power) # transform to radian baz_edges = np.radians(baz_edges) # add polar and colorbar axes fig2 = plt.figure(figsize=(8, 8)) cax = fig2.add_axes([0.85, 0.2, 0.05, 0.5]) ax = fig2.add_axes([0.10, 0.1, 0.70, 0.7], polar=True) ax.set_theta_direction(-1) ax.set_theta_zero_location('N') 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): bars = ax.bar(left=(i * dw) * np.ones(N2), height=dh * np.ones(N2), width=dw, bottom=dh * np.arange(N2), color=cmap(row / hist.max())) ax.set_xticks( np.linspace(0, 2 * np.pi, np.sqrt(slm_x**2 + slm_y**2), endpoint=False)) ax.set_xticklabels(['N', 'E', 'S', 'W']) # set slowness limits ax.set_ylim(0, np.sqrt(slm_x**2 + slm_y**2)) [i.set_color('grey') for i in ax.get_yticklabels()] ColorbarBase(cax, cmap=cmap, norm=Normalize(vmin=hist.min(), vmax=hist.max())) if showplots is True: plt.show() if saveplots is True: fig1.savefig('%s/%s-%s.png' % (outfolder, 'timeplot', plotlabel)) fig2.savefig('%s/%s-%s.png' % (outfolder, 'overallplot', plotlabel)) if movie: cmap = cm.RdYlBu xgrid = np.arange(sll_x, slm_x + sstep, sstep) ygrid = np.arange(sll_y, slm_y + sstep, sstep) slow2 = np.empty((len(xgrid), len(ygrid))) baz2 = slow2.copy() for i in np.arange(len(xgrid)): for j in np.arange(len(ygrid)): # compute baz, slow slow_x = xgrid[i] slow_y = ygrid[j] slow2[i, j] = np.sqrt(slow_x**2 + slow_y**2) if slow2[i, j] < 1e-8: slow2[i, j] = 1e-8 azimut = 180 * math.atan2(slow_x, slow_y) / math.pi baz2[i, j] = azimut % -360 + 180 baz2[baz2 < 0.0] += 360 # transform to radian baz2 = np.radians(baz2) x, y = np.meshgrid(xgrid, ygrid) #pow_map_mean = np.array((x, y)) findind = 0 stfilt = st.copy() stfilt.filter('bandpass', freqmin=freqlow, freqmax=freqhigh) stfilt.trim(stime - 5., etime + 5., pad=True, fill_value=0.) for i, t1 in enumerate(t): filen = glob.glob(outfolder + '/pow_map_%i.npz' % findind) f = np.load(filen[0]) pow_map = f['arr_0'] fig = plt.figure(figsize=(18, 6)) ax = fig.add_axes([0.05, 0.05, 0.25, 0.9], polar=True) ax.pcolormesh(baz2, slow2, pow_map, vmin=0., vmax=1., cmap=cmap) ax.set_theta_direction(-1) ax.set_theta_zero_location('N') #ax.set_ylim(0, np.sqrt(slm_x**2 + slm_y**2)) ax.set_ylim(0, np.max([slm_x, slm_y])) ix, iy = np.unravel_index(pow_map.argmax(), pow_map.shape) az = 180 * math.atan2(xgrid[ix], ygrid[iy]) / math.pi bazimut = az % -360 + 180 if bazimut < 0.0: bazimut += 360 slow1 = np.sqrt(xgrid[ix]**2 + ygrid[iy]**2) ax.plot(np.radians(bazimut), slow1, 'xk') ax.text(np.radians(bazimut), slow1, ' %1.1f km/s\\n %1.0f deg' % (1. / slow1, bazimut)) ax.grid() plt.draw() cax = fig.add_axes([0.32, 0.15, 0.01, 0.7]) ColorbarBase(cax, cmap=cmap, norm=Normalize(vmin=0.0, vmax=1.)) ax1 = fig.add_axes([0.37, 0.05, 0.58, 0.9]) tvec = sigproc.maketvec(stfilt[0]) #import pdb; pdb.set_trace() ax1.plot(tvec, stfilt[0].data / max(stfilt[0].data), 'k', label=stfilt[0].stats.station) ax1.plot(tvec, stfilt[1].data / max(stfilt[1].data) + 1.5, 'k', label=stfilt[1].stats.station) ax1.plot(tvec, stfilt[2].data / max(stfilt[2].data) + 3., 'k', label=stfilt[2].stats.station) sec = UTCDateTime(mdates.num2date(t1)) - stfilt[0].stats.starttime ax1.vlines(sec, -1, 4, color='r') ax1.vlines(sec + win_len, -1, 4, color='r') plt.title( 'Max at %3.0f degrees, speed of %1.1f km/s - tstart %1.0f' % (baz[i], 1 / slow[i], sec)) ax1.set_ylim(-1, 4) plt.savefig(('%s/img%03d.png') % (outfolder, i)) findind += int(win_len * st[0].stats.sampling_rate * win_frac) #plt.draw() plt.show() plt.close(fig) #turn into mpg origdir = os.getcwd() os.chdir(outfolder) os.system( 'ffmpeg -f image2 -start_number 0 -r 4 -i img%03d.png -y -c:v libx264 -vf "format=yuv420p" beammovie.mp4' ) # Clean up delfiles = glob.glob(outfolder + '/pow_map_*.npz') for df in delfiles: os.remove(df) if savemovieimg is False: delfiles = glob.glob(outfolder + '/img*png') for df in delfiles: os.remove(df) os.chdir(origdir) return t, rel_power, abs_power, baz, slow
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 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 call(self): 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.downsample_to(1/20.) tr.lowpass(4, viewer.lowpass) tr.highpass(4, viewer.highpass) traces.extend(trs) if not traces: self.fail('no traces selected') tmin, tmax = trace.minmaxtime(traces, key=lambda x: None)[None] 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) smax = 0.5 # Execute sonic kwargs = dict( # slowness grid: X min, X max, Y min, Y max, Slow Step sll_x=-smax, slm_x=smax, sll_y=-smax, slm_y=smax, sl_s=smax/20., # sliding window properties win_len=5.0, win_frac=0.1, # frequency properties frqlow=viewer.highpass, frqhigh=viewer.lowpass, prewhiten=0, # restrict output semb_thres=-1.0e9, vel_thres=-1.0e9, verbose=True, timestamp='mlabday', stime=UTCDateTime(tmin), etime=UTCDateTime(tmax) ) #out = sonic(st, **kwargs) out = array_analysis.array_processing(st, **kwargs) cmap = cm.hot_r pi = np.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 = np.arange(N + 1) * 360. / N sbins = np.linspace(0., smax, N + 1) # sum rel power in bins given by abins and sbins hist, baz_edges, sl_edges = np.histogram2d(baz, slow, bins=[abins, sbins], weights=rel_power) # transform to gradient baz_edges = baz_edges / 180 * np.pi # add polar and colorbar axes 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) 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): bars = ax.bar(left=(pi / 2 - (i + 1) * dw) * np.ones(N), height=dh * np.ones(N), width=dw, bottom=dh * np.arange(N), color=cmap(row / hist.max())) ax.set_xticks([pi / 2, 0, 3. / 2 * pi, pi]) ax.set_xticklabels(['N', 'E', 'S', 'W']) # set slowness limits ax.set_ylim(0., smax) ColorbarBase(cax, cmap=cmap, norm=Normalize(vmin=hist.min(), vmax=hist.max()))