def plot_corr_vs_dist(stream, fname, figsize=(10, 5), ext='png', dpi=None, components='ZZ', line_style='k', scale=1, dist_unit='km', xlim=None, ylim=None, time_period=None): """ Plot stacked correlations versus inter-station distance .. image:: _static/corr_vs_dist.png :width: 30% This plot can be created from the command line with ``--plottype vs_dist``. :param components: component combination to plot :param scale: scale wiggles (default 1) :param dist_unit: one of ``('km', 'm', 'deg')`` :time_period: use correlations only from this time span (tuple of dates) """ # scale relative to axis traces = [ tr for tr in stream if _corr_id(tr).split('-')[0][-1] + _corr_id(tr)[-1] == components ] stream.traces = traces _trim_time_period(stream, time_period) stack = yam.stack.stack(stream) if len(stack) == 0: msg = 'Not plotting anything. No traces in stack with components %s' warn(msg % components) return fig = plt.figure(figsize=figsize) ax = fig.add_subplot(111) dist_scale = (1 if dist_unit == 'm' else 1000 * 111.2 if dist_unit == 'deg' else 1000) max_dist = max(tr.stats.dist / dist_scale for tr in stack) for tr in stack: lag_times = _trim(tr, xlim) scaled_data = tr.stats.dist / dist_scale + tr.data * max_dist * scale ax.plot(lag_times, scaled_data, line_style) fname = '%s_%s' % (fname, components) label = os.path.basename(fname) ax.set_ylim(ylim) ax.annotate(label, (0, 1), (10, 10), 'axes fraction', 'offset points', annotation_clip=False, va='bottom') ax.set_ylabel('distance (%s)' % dist_unit) ax.set_xlabel('time (s)') fig.savefig(fname + '.' + ext, dpi=dpi)
def plot_corr_vs_time_wiggle(stream, fname=None, figsize=(10, 5), ext='png', dpi=None, xlim=None, ylim=None, scale=20, plot_kw={}): """ Plot correlation wiggles versus time .. image:: _static/corr_vs_time_wiggle.png :width: 30% .. image:: _static/corr_vs_time_wiggle2.png :width: 40% This plot can be created from the command line with ``--plottype wiggle``. :param scale: scale of wiggles (default 20) """ plot_kw = plot_kw.copy() plot_kw.setdefault('lw', 0.5) plot_kw.setdefault('color', 'black') # scale relative to neighboring wiggles ids = {_corr_id(tr) for tr in stream} if len(ids) != 1: warn('Different ids in stream: %s' % ids) stream.sort(['starttime']) _trim_time_period(stream, ylim) times = [tr.stats.starttime.matplotlib_date for tr in stream] dt = np.median(np.diff(times)) fig = plt.figure(figsize=figsize) ax = fig.add_subplot(111) for tr in stream: lag_times = _trim(tr, xlim) scaled_data = tr.stats.starttime.matplotlib_date + tr.data * dt * scale ax.plot(lag_times, scaled_data, **plot_kw) label = '' if fname is None else os.path.basename(fname) ax.annotate(label, (0, 1), (10, 10), 'axes fraction', 'offset points', annotation_clip=False, va='bottom') ax.set_ylabel('date') ax.set_xlabel('time (s)') ax.yaxis_date() if fname is not None: fig.savefig(fname + '.' + ext, dpi=dpi)
def stretch(stream, max_stretch, num_stretch, tw, tw_relative=None, reftr=None, sides='both', max_lag=None, time_period=None): """ Stretch traces in stream and return dictionary with results See e.g. Richter et al. (2015) for a description of the procedure. :param stream: |Stream| object with correlations :param float max_stretch: stretching range in percent :param int num_stretch: number of values in stretching vector :param tw: definition of the time window in the correlation -- tuple of length 2 with start and end time in seconds (positive) :param tw_relative: time windows can be defined relative to a velocity, default None or 0 -- time windows relative to zero lag time, otherwise velocity is given in km/s :param reftr: reference trace, by default the stack of stream is used as reference :param sides: one of left, right, both :param max_lag: max lag time in seconds, stream is trimmed to ``(-max_lag, max_lag)`` before stretching :param time_period: use correlations only from this time span (tuple of dates) """ if len(stream) <= 1: log.warning('For stretch the stream must have a minimum length of 2') return ids = {_corr_id(tr) for tr in stream} if None in ids: ids.discard(None) stream.traces = [tr for tr in stream if _corr_id(tr) is not None] if len(ids) != 1: warn('Different ids in stream: %s' % ids) _trim_time_period(stream, time_period) stream.sort() tr0 = stream[0] if max_lag is not None: for tr in stream: _trim(tr, (-max_lag, max_lag)) rel = 0 if tw_relative is None else tr0.stats.dist / 1000 / tw_relative twabs = rel + np.array(tw) starttime = tr0.stats.starttime mid = starttime + (tr0.stats.endtime - starttime) / 2 times = tr0.times(reftime=mid) data = np.array([tr.data for tr in stream]) data[np.isnan(data)] = 0 # bug fix data[np.isinf(data)] = 0 if reftr is None: reftr = yam.stack.stack(stream)[0] stretch_vector_perc = np.linspace(-max_stretch, max_stretch, num_stretch) stretch_factor = 1 + stretch_vector_perc / 100 # MIIC approximation: #stretch_factor = np.exp(stretch_vector_percent / 100) mask1 = np.logical_and(times >= twabs[0], times <= twabs[1]) mask2 = np.logical_and(times <= -twabs[0], times >= -twabs[1]) if sides == 'left': mask = mask1 elif sides == 'right': mask = mask2 elif sides == 'both': mask = np.logical_or(mask1, mask2) else: raise ValueError('sides = %s not a valid option' % sides) sim_mat = _stretch_helper(data, reftr.data, mask, stretch_factor) times = np.array([str(tr.stats.starttime)[:19] for tr in stream], dtype='S19') result = { 'sim_mat': sim_mat, 'velchange_values': stretch_vector_perc, 'times': times, 'tw': twabs, 'attrs': { 'num_stretch': num_stretch, 'max_stretch': max_stretch, 'sides': sides, 'starttime': stream[0].stats.starttime, 'endtime': stream[-1].stats.starttime } } _update_result(result) for k in ('network1', 'network2', 'station1', 'station2', 'location1', 'location2', 'channel1', 'channel2', 'sampling_rate', 'dist', 'azi', 'baz'): if k in tr0.stats: result['attrs'][k] = tr0.stats[k] return result
def stretch(stream, reftr=None, str_range=10, nstr=100, time_windows=None, time_windows_relative=None, sides='right', max_lag=None, time_period=None ): """ Stretch traces in stream and return dictionary with results See e.g. Richter et al. (2015) for a description of the procedure. :param stream: |Stream| object with correlations :param reftr: reference trace -- not implemented yet, the reference is the stack of the stream :param float str_range: stretching range in percent :param int nstr: number of values in stretching vector :param time_windows: definition of time windows in the correlation -- tuple of length 2, first entry: tuple of start times in seconds, second entry: length in seconds, e.g. ``((5, 10, 15), 5)`` defines three time windows of length 5 seconds starting at 5, 10, 15 seconds :param time_windows_relative: time windows can be defined relative to a velocity, default None or 0 -- time windows relative to zero leg time, otherwise velocity is given in km/s :param max_lag: max lag time in seconds, stream is trimmed to ``(-max_lag, max_lag)`` before stretching :param time_period: use correlations only from this time span (tuple of dates) """ if len(stream) <= 1: log.warning('For stretch the stream must have a minimum length of 2') return ids = {_corr_id(tr) for tr in stream} if None in ids: ids.discard(None) stream.traces = [tr for tr in stream if _corr_id(tr) is not None] if len(ids) != 1: warn('Different ids in stream: %s' % ids) _trim_time_period(stream, time_period) stream.sort() sr = stream[0].stats.sampling_rate rel = 0. if time_windows_relative is not None: rel = np.round(stream[0].stats.dist / 1000 / time_windows_relative) if time_windows is not None and isinstance(time_windows[1], (float, int)): args = ((rel + np.array(time_windows[0])) * int(sr), time_windows[1] * int(sr)) tw_mat = time_windows_creation(*args) else: raise ValueError('Wrong format for time_window') if max_lag is not None: for tr in stream: _trim(tr, (-max_lag, max_lag)) data = np.array([tr.data for tr in stream]) if np.min(tw_mat) < 0 or data.shape[1] < np.max(tw_mat): msg = ('Defined time window outside of data. ' 'shape, mintw index, maxtw index: %s, %s, %s') raise ValueError(msg % (data.shape[1], np.min(tw_mat), np.max(tw_mat))) data[np.isnan(data)] = 0 # bug fix data[np.isinf(data)] = 0 if reftr is None: reftr = yam.stack.stack(stream)[0] if reftr != 'alternative': if hasattr(reftr, 'stats'): assert reftr.stats.sampling_rate == sr ref_data = reftr.data #ref_data = _stream2matrix(obspy.Stream([reftr]))[0, :] else: ref_data = reftr # log.debug('calculate correlations and time shifts...') # convert str_range from % to decimal tse = time_stretch_estimate( data, ref_trc=ref_data, tw=tw_mat, stretch_range=str_range / 100, stretch_steps=nstr, sides=sides) # else: # assert len(tw_mat) == len(stretch) # tses = [] # log.debug('calculate correlations and time shifts...') # for i in range(len(tw_mat)): # tw = tw_mat[i:i + 1] # st = stretch[i] # sim_mat = time_stretch_apply(data, st, single_sided=False) # ref_data = np.mean(sim_mat, axis=0) # tse = time_stretch_estimate(data, ref_trc=ref_data, tw=tw, # stretch_range=str_range, stretch_steps=nstr, # sides=sides) # tses.append(tse) # for i in ('corr', 'stretch'): # tse[i] = np.hstack([t[i] for t in tses]) # i = 'sim_mat' # tse[i] = np.vstack([t[i] for t in tses]) times = np.array([str(tr.stats.starttime)[:19] for tr in stream], dtype='S19') ltw1 = rel + np.array(time_windows[0]) # convert streching to velocity change # -> minus at several places result = {'sim_mat': tse['sim_mat'][:, ::-1, :], 'velchange_values': -tse['second_axis'][::-1] * 100, 'times': times, #'velchange_vs_time': -tse['value'] * 100, #'corr_vs_time': tse['corr'], 'lag_time_windows': np.transpose([ltw1, ltw1 + time_windows[1]]), 'attrs': {'nstr': nstr, 'str_range': str_range, 'sides': sides, 'starttime': stream[0].stats.starttime, 'endtime': stream[-1].stats.starttime } } _update_result(result) for k in ('network1', 'network2', 'station1', 'station2', 'location1', 'location2', 'channel1', 'channel2', 'sampling_rate', 'dist', 'azi', 'baz'): result['attrs'][k] = stream[0].stats[k] return result
def plot_corr_vs_time(stream, fname, figsize=(10, 5), ext='png', xlim=None, ylim=None, vmax=None, cmap='RdBu_r', show_stack=True, line_style='k', line_width=1): """ Plot correlations versus time .. image:: _static/corr_vs_time.png :width: 30% .. image:: _static/corr_vs_time_zoom.png :width: 30% Default correlation plot. :param vmax: maximum value in colormap :param cmap: used colormap :param show_stack: show a wiggle plot of the stack at top """ ids = {_corr_id(tr) for tr in stream} if len(ids) != 1: warn('Different ids in stream: %s' % ids) stream.sort(['starttime']) _trim_time_period(stream, ylim) for tr in stream: lag_times = _trim(tr, xlim) times = [tr.stats.starttime.matplotlib_date for tr in stream] fig = plt.figure(figsize=figsize) ax = fig.add_axes([0.15, 0.1, 0.75, 0.75]) cax = fig.add_axes([0.91, 0.375, 0.008, 0.25]) data = np.array([tr.data for tr in stream]) if vmax is None: vmax = min(0.8 * np.max(data), 0.1) no_data = _get_times_no_data(times) times = _add_value(times, no_data) times2 = _align_values_for_pcolormesh(times) lag_times2 = _align_values_for_pcolormesh(lag_times) data2 = _add_value(np.transpose(data), no_data, value=0, masked=True) data2 = np.transpose(data2) mesh = ax.pcolormesh(lag_times2, times2, data2, cmap=cmap, vmin=-vmax, vmax=vmax) fig.colorbar(mesh, cax) ax.set_ylabel('date') ax.set_xlabel('time (s)') ax.yaxis_date() ax_ano = ax if show_stack: ax2 = fig.add_axes([0.15, 0.85, 0.75, 0.05], sharex=ax) stack = yam.stack.stack(stream) ax2.plot(lag_times, stack[0].data, line_style, lw=line_width) ax2.set_ylim(-vmax, vmax) ax2.set_ylabel('stack') plt.setp(ax2.get_xticklabels(), visible=False) ax_ano = ax2 ax.set_xlim(lag_times[0], lag_times[-1]) label = os.path.basename(fname) ax_ano.annotate(label, (0, 1), (10, 10), 'axes fraction', 'offset points', annotation_clip=False, va='bottom') fig.savefig(fname + '.' + ext)
def plot_corr_vs_time(stream, fname=None, figsize=(10, 5), ext='png', dpi=None, xlim=None, ylim=None, vmax=None, cmap='RdBu_r', stack_plot_kw={}): """ Plot correlations versus time .. image:: _static/corr_vs_time.png :width: 30% .. image:: _static/corr_vs_time_zoom.png :width: 30% Default correlation plot. :param vmax: maximum value in colormap :param cmap: used colormap """ ids = {_corr_id(tr) for tr in stream} srs = {tr.stats.sampling_rate for tr in stream} lens = {len(tr) for tr in stream} if len(ids) != 1: warn('Different ids in stream: %s' % ids) # These checks should be done when saving the correlations to hdf5. # On the other hand side, these problems will not occur often. if len(srs) != 1: sr = np.median([tr.stats.sampling_rate for tr in stream]) msg = 'Different sampling rates in stream: %s -> set %s Hz (%s)' warn(msg % (srs, sr, stream[0].id)) for tr in stream: tr.stats.sampling_rate = sr if len(lens) != 1: msg = ('Different lengths of traces in stream: %s (%s)' '-> Plese use xlim parameter to trim traces') warn(msg % (lens, stream[0].id)) stream.sort(['starttime']) _trim_time_period(stream, ylim) for tr in stream: lag_times = _trim(tr, xlim) times = [tr.stats.starttime.matplotlib_date for tr in stream] fig = plt.figure(figsize=figsize) ax = fig.add_axes([0.15, 0.1, 0.75, 0.75]) cax = fig.add_axes([0.91, 0.375, 0.008, 0.25]) data = np.array([tr.data for tr in stream]) if vmax is None: vmax = min(0.8 * np.max(data), 0.1) no_data = _get_times_no_data(times) times = _add_value(times, no_data) times2 = _align_values_for_pcolormesh(times) lag_times2 = _align_values_for_pcolormesh(lag_times) data2 = _add_value(np.transpose(data), no_data, value=0, masked=True) data2 = np.transpose(data2) mesh = ax.pcolormesh(lag_times2, times2, data2, cmap=cmap, vmin=-vmax, vmax=vmax) fig.colorbar(mesh, cax) ax.set_ylabel('date') ax.set_xlabel('time (s)') ax.yaxis_date() ax_ano = ax if stack_plot_kw is not None: stack_plot_kw = stack_plot_kw.copy() stack_plot_kw.setdefault('color', 'black') stack_plot_kw.setdefault('lw', 1) ax2 = fig.add_axes([0.15, 0.85, 0.75, 0.05], sharex=ax) stack = yam.stack.stack(stream) ax2.plot(lag_times, stack[0].data, **stack_plot_kw) ax2.set_ylim(-vmax, vmax) ax2.set_ylabel('stack') plt.setp(ax2.get_xticklabels(), visible=False) ax_ano = ax2 ax.set_xlim(lag_times[0], lag_times[-1]) label = '' if fname is None else os.path.basename(fname) ax_ano.annotate(label, (0, 1), (10, 10), 'axes fraction', 'offset points', annotation_clip=False, va='bottom') if fname is not None: fig.savefig(fname + '.' + ext, dpi=dpi)