def _old_test_plot_synthetics(self): from matplotlib import pyplot as plt fig, ax = plt.subplots(nrows=1, ncols=3, figsize=plot.mpl_papersize('a4', 'portrait')) cmap = plt.cm.jet fontsize = 12 sz = 10. if self.reference is None: self._get_synthetic_data() # disp = self.test_block_geometry() # disp = self.test_block_synthetics() disp = self._test_backslip_synthetics(2) for i, comp in enumerate('NEZ'): im = ax[i].scatter(self.lons, self.lats, sz, disp[:, i], cmap=cmap) cblabel = '%s displacement [m]' % comp cbs = plt.colorbar(im, ax=ax[i], orientation='horizontal', cmap=cmap) cbs.set_label(cblabel, fontsize=fontsize) plt.show()
def plot_init(size, save, show): fontsize = 9 mpl_init() fig = plt.figure(figsize=mpl_papersize(size, 'landscape')) labelpos = mpl_margins(fig, w=7., h=5., units=fontsize) axes = fig.add_subplot(1, 1, 1) labelpos(axes, 2., 1.5) showplt = bool(show or not save) return fig, axes, showplt
def _test_sample(self, n_jobs, test_folder): logger.info('Running on %i cores...' % n_jobs) n = 4 mu1 = num.ones(n) * (1. / 2) mu2 = -mu1 stdev = 0.1 sigma = num.power(stdev, 2) * num.eye(n) isigma = num.linalg.inv(sigma) dsigma = num.linalg.det(sigma) w1 = stdev w2 = (1 - stdev) def two_gaussians(x): log_like1 = - 0.5 * n * tt.log(2 * num.pi) \ - 0.5 * tt.log(dsigma) \ - 0.5 * (x - mu1).T.dot(isigma).dot(x - mu1) log_like2 = - 0.5 * n * tt.log(2 * num.pi) \ - 0.5 * tt.log(dsigma) \ - 0.5 * (x - mu2).T.dot(isigma).dot(x - mu2) return tt.log(w1 * tt.exp(log_like1) + w2 * tt.exp(log_like2)) with pm.Model() as PT_test: X = pm.Uniform('X', shape=n, lower=-2. * num.ones_like(mu1), upper=2. * num.ones_like(mu1), testval=-1. * num.ones_like(mu1), transform=None) like = pm.Deterministic('tmp', two_gaussians(X)) llk = pm.Potential('like', like) with PT_test: step = metropolis.Metropolis( n_chains=n_jobs, likelihood_name=PT_test.deterministics[0].name, proposal_name='MultivariateCauchy', tune_interval=self.tune_interval) pt.pt_sample( step, n_chains=n_jobs, n_samples=self.n_samples, swap_interval=self.swap_interval, beta_tune_interval=self.beta_tune_interval, n_workers_posterior=self.n_workers_posterior, homepath=test_folder, progressbar=False, buffer_size=self.buffer_size, model=PT_test, rm_flag=False, keep_tmp=False) stage_handler = TextStage(test_folder) mtrace = stage_handler.load_multitrace(-1, model=PT_test) history = load_objects(os.path.join(stage_handler.stage_path(-1), sample_p_outname)) n_steps = self.n_samples burn = self.burn thin = self.thin def burn_sample(x): if n_steps == 1: return x else: nchains = int(x.shape[0] / n_steps) xout = [] for i in range(nchains): nstart = int((n_steps * i) + (n_steps * burn)) nend = int(n_steps * (i + 1) - 1) xout.append(x[nstart:nend:thin]) return num.vstack(xout) from pymc3 import traceplot from matplotlib import pyplot as plt traceplot(mtrace, transform=burn_sample) fig, axes = plt.subplots( nrows=1, ncols=2, figsize=mpl_papersize('a5', 'portrait')) axes[0].plot(history.acceptance, 'r') axes[0].set_ylabel('Acceptance ratio') axes[0].set_xlabel('Update interval') axes[1].plot(num.array(history.t_scales), 'k') axes[1].set_ylabel('Temperature scaling') axes[1].set_xlabel('Update interval') n_acceptances = len(history) ncol = 3 nrow = int(num.ceil(n_acceptances / float(ncol))) fig2, axes1 = plt.subplots( nrows=nrow, ncols=ncol, figsize=mpl_papersize('a4', 'portrait')) axes1 = num.atleast_2d(axes1) fig3, axes2 = plt.subplots( nrows=nrow, ncols=ncol, figsize=mpl_papersize('a4', 'portrait')) axes2 = num.atleast_2d(axes2) acc_arrays = history.get_acceptance_matrixes_array() sc_arrays = history.get_sample_counts_array() scvmin = sc_arrays.min(0).min(0) scvmax = sc_arrays.max(0).max(0) accvmin = acc_arrays.min(0).min(0) accvmax = acc_arrays.max(0).max(0) for i in range(ncol * nrow): rowi, coli = mod_i(i, ncol) #if i == n_acceptances: # pass #plt.colorbar(im, axes1[rowi, coli]) #plt.colorbar(im2, axes2[rowi, coli]) if i > n_acceptances - 1: try: fig2.delaxes(axes1[rowi, coli]) fig3.delaxes(axes2[rowi, coli]) except KeyError: pass else: axes1[rowi, coli].matshow( history.acceptance_matrixes[i], vmin=accvmin[i], vmax=accvmax[i], cmap='hot') axes1[rowi, coli].set_title('min %i, max%i' % (accvmin[i], accvmax[i])) axes1[rowi, coli].get_xaxis().set_ticklabels([]) axes2[rowi, coli].matshow( history.sample_counts[i], vmin=scvmin[i], vmax=scvmax[i], cmap='hot') axes2[rowi, coli].set_title('min %i, max%i' % (scvmin[i], scvmax[i])) axes2[rowi, coli].get_xaxis().set_ticklabels([]) fig2.suptitle('Accepted number of samples') fig2.tight_layout() fig3.tight_layout() fig3.suptitle('Total number of samples') plt.show()
def plot_detection(grid, receivers, frames, tmin_frames, deltat_cf, imax, iframe, xpeak, ypeak, zpeak, tr_stackmax, tpeaks, apeaks, detector_threshold, wmin, wmax, pdata, trs_raw, fmin, fmax, idetection, tpeaksearch, movie=False, save_filename=None, show=True, event=None): from matplotlib import pyplot as plt from matplotlib import cm from matplotlib.animation import FuncAnimation nsls = set(tr.nslc_id[:3] for tr in trs_raw) receivers_on = [r for r in receivers if r.codes in nsls] receivers_off = [r for r in receivers if r.codes not in nsls] distances = grid.distances(receivers) plot.mpl_init(fontsize=9) fig = plt.figure(figsize=plot.mpl_papersize('a4', 'landscape')) axes = plt.subplot2grid((2, 3), (0, 2), aspect=1.0) plot.mpl_labelspace(axes) axes2 = plt.subplot2grid((2, 3), (1, 2)) plot.mpl_labelspace(axes2) axes3 = plt.subplot2grid((2, 3), (0, 1), rowspan=2) axes4 = plt.subplot2grid((2, 3), (0, 0), rowspan=2) if grid.distance_max() > km: dist_units = km axes.set_xlabel('Easting [km]') axes.set_ylabel('Northing [km]') axes4.set_ylabel('Distance [km]') else: dist_units = 1.0 axes.set_xlabel('Easting [m]') axes.set_ylabel('Northing [m]') axes4.set_ylabel('Distance [m]') axes.locator_params(nbins=6, tight=True) axes2.set_xlabel('Time [s]') axes2.set_ylabel('Detector level') axes3.set_xlabel('Time [s]') for el in axes3.get_yticklabels(): el.set_visible(False) axes4.set_xlabel('Time [s]') tpeak_current = tmin_frames + deltat_cf * iframe t0 = tpeak_current tduration = 2.0 * tpeaksearch axes2.axvspan(tr_stackmax.tmin - t0, wmin - t0, color=plot.mpl_color('aluminium2')) axes2.axvspan(wmax - t0, tr_stackmax.tmax - t0, color=plot.mpl_color('aluminium2')) axes2.axvspan(tpeak_current - 0.5 * tduration - t0, tpeak_current + 0.5 * tduration - t0, color=plot.mpl_color('scarletred2'), alpha=0.3, lw=0.) axes2.set_xlim(tr_stackmax.tmin - t0, tr_stackmax.tmax - t0) axes2.axhline(detector_threshold, color=plot.mpl_color('aluminium6'), lw=2.) t = tr_stackmax.get_xdata() amp = tr_stackmax.get_ydata() axes2.plot(t - t0, amp, color=plot.mpl_color('scarletred2'), lw=1.) for tpeak, apeak in zip(tpeaks, apeaks): axes2.plot(tpeak - t0, apeak, '*', ms=20., mfc='white', mec='black') station_index = dict((rec.codes, i) for (i, rec) in enumerate(receivers)) dists_all = [] amps = [] shifts = [] pdata2 = [] for trs, shift_table, shifter in pdata: trs = [tr.copy() for tr in trs] dists = [] for tr in trs: istation = station_index[tr.nslc_id[:3]] shift = shift_table[imax, istation] tr2 = tr.chop(tpeak_current - 0.5 * tduration + shift, tpeak_current + 0.5 * tduration + shift, inplace=False) dists.append(distances[imax, istation]) amp = tr2.get_ydata() * shifter.weight amps.append(num.max(num.abs(amp))) shifts.append(shift) pdata2.append((trs, dists, shift_table, shifter)) dists_all.extend(dists) dist_min = min(dists_all) dist_max = max(dists_all) shift_min = min(shifts) shift_max = max(shifts) amp_max = max(amps) scalefactor = (dist_max - dist_min) / len(trs) * 0.5 axes3.set_xlim(-0.5 * tduration + shift_min, 0.5 * tduration + shift_max) axes3.set_ylim((dist_min - scalefactor) / dist_units, (dist_max + scalefactor) / dist_units) axes4.set_xlim(-0.5 * tduration + shift_min, 0.5 * tduration + shift_max) axes4.set_ylim((dist_min - scalefactor) / dist_units, (dist_max + scalefactor) / dist_units) axes3.axvline(0., color=plot.mpl_color('aluminium3'), lw=2.) nsl_have = set() phase_markers = [] picks = [] for ishifter, (trs, dists, shift_table, shifter) in enumerate(pdata2): color = plot.mpl_graph_color(ishifter) for tr, dist in zip(trs, dists): tmint = tr.tmin tr = tr.chop(tpeak_current - 0.5 * tduration + shift_min, tpeak_current + 0.5 * tduration + shift_max, inplace=False) nsl = tr.nslc_id[:3] istation = station_index[nsl] shift = shift_table[imax, istation] phase_markers.append( PhaseMarker([(nsl[0], nsl[1], "", nsl[2])], tmin=tmint + shift, tmax=tmint + shift, phasename=shifter.name, event_time=t0, event_hash=idetection)) p = Pick(time=UTCDateTime(tmint + shift), waveform_id=WaveformStreamID(network_code=nsl[0], station_code=nsl[1]), phase_hint=shifter.name, method_id="lassie") picks.append(p) axes3.plot(shift, dist / dist_units, '|', mew=2, mec=color, ms=10, zorder=2) t = tr.get_xdata() amp = tr.get_ydata() * shifter.weight amp /= amp_max axes3.plot( t - t0, (dist + scalefactor * amp + ishifter * scalefactor * 0.1) / dist_units, color=color, zorder=1) if nsl not in nsl_have: axes3.annotate('.'.join(nsl), xy=(t[0] - t0, dist / dist_units), xytext=(10., 0.), textcoords='offset points', verticalalignment='top') nsl_have.add(nsl) for tr in trs_raw: istation = station_index[tr.nslc_id[:3]] dist = distances[imax, istation] shift = shift_table[imax, istation] tr = tr.copy() tr.highpass(4, fmin, demean=True) tr.lowpass(4, fmax, demean=False) tr.chop(tpeak_current - 0.5 * tduration + shift_min, tpeak_current + 0.5 * tduration + shift_max) t = tr.get_xdata() amp = tr.get_ydata().astype(num.float) amp = amp / num.max(num.abs(amp)) axes4.plot(t - t0, (dist + scalefactor * amp) / dist_units, color='black', alpha=0.5, zorder=1) axes4.plot(shift, dist / dist_units, '|', mew=2, mec=color, ms=10, zorder=2) PhaseMarker.save_markers(phase_markers, "%s.pym" % (save_filename[:-4]), fdigits=3) event_obspy = Event() origin = Origin(time=UTCDateTime(t0), longitude=event.lon, latitude=event.lat, method="lassie") event_obspy.origins.append(origin) event_obspy.picks = picks cat = Catalog() cat.append(event_obspy) cat.write(save_filename[:-4] + ".qml", format="QUAKEML") nframes = frames.shape[1] iframe_min = max(0, int(round(iframe - 0.5 * tduration / deltat_cf))) iframe_max = min(nframes - 1, int(round(iframe + 0.5 * tduration / deltat_cf))) amax = frames[imax, iframe] axes.set_xlim(grid.ymin / dist_units, grid.ymax / dist_units) axes.set_ylim(grid.xmin / dist_units, grid.xmax / dist_units) cmap = cm.YlOrBr system = ('ne', grid.lat, grid.lon) static_artists = [] static_artists.extend( plot_receivers(axes, receivers_on, system=system, units=dist_units, style=dict(mfc='black', ms=5.0))) static_artists.extend( plot_receivers(axes, receivers_off, system=system, units=dist_units, style=dict(mfc='none', ms=5.0))) static_artists.extend( axes.plot(ypeak / dist_units, xpeak / dist_units, '*', ms=20., mec='black', mfc='white')) static_artists.append( fig.suptitle('%06i - %s' % (idetection, util.time_to_str(t0)))) frame_artists = [] progress_artists = [] def update(iframe): if iframe is not None: frame = frames[:, iframe] if not progress_artists: progress_artists[:] = [ axes2.axvline(tmin_frames - t0 + deltat_cf * iframe, color=plot.mpl_color('scarletred3'), alpha=0.5, lw=2.) ] else: progress_artists[0].set_xdata(tmin_frames - t0 + deltat_cf * iframe) else: frame = num.max(frames[:, iframe_min:iframe_max + 1], axis=1) frame_artists[:] = grid.plot(axes, frame, amin=0.0, amax=amax, cmap=cmap, system=system, artists=frame_artists, units=dist_units, shading='gouraud') return frame_artists + progress_artists + static_artists if movie: ani = FuncAnimation( fig, update, frames=list(range(iframe_min, iframe_max + 1))[::10] + [None], interval=20., repeat=False, blit=True) else: ani = None update(None) if save_filename: fig.savefig(save_filename) if show: plt.show() else: plt.close() del ani
def bayesian_model_plot(models, axes=None, draw_bg=True, highlightidx=[]): """ Plot cake layered earth models. """ fontsize = 10 if axes is None: mpl_init(fontsize=fontsize) fig, axes = plt.subplots( nrows=1, ncols=1, figsize=mpl_papersize('a6', 'portrait')) labelpos = mpl_margins( fig, left=6, bottom=4, top=1.5, right=0.5, units=fontsize) labelpos(axes, 2., 1.5) def plot_profile(mod, axes, vp_c, vs_c, lw=0.5): z = mod.profile('z') vp = mod.profile('vp') vs = mod.profile('vs') axes.plot(vp, z, color=vp_c, lw=lw) axes.plot(vs, z, color=vs_c, lw=lw) cp.labelspace(axes) cp.labels_model(axes=axes) if draw_bg: cp.sketch_model(models[0], axes=axes) else: axes.spines['right'].set_visible(False) axes.spines['top'].set_visible(False) ref_vp_c = scolor('aluminium5') ref_vs_c = scolor('aluminium5') vp_c = scolor('scarletred2') vs_c = scolor('skyblue2') for i, mod in enumerate(models): plot_profile( mod, axes, vp_c=light(vp_c, 0.3), vs_c=light(vs_c, 0.3), lw=1.) for count, i in enumerate(sorted(highlightidx)): if count == 0: vpcolor = ref_vp_c vscolor = ref_vs_c elif count == 1: vpcolor = scolor('butter3') vscolor = scolor('butter3') elif count == 2: vpcolor = scolor('skyblue2') vscolor = scolor('skyblue2') elif count == 3: vpcolor = scolor('plum2') vscolor = scolor('plum2') else: vpcolor = scolor('scarletred2') vscolor = scolor('scarletred2') plot_profile( models[i], axes, vp_c=vpcolor, vs_c=vscolor, lw=2.) ymin, ymax = axes.get_ylim() xmin, xmax = axes.get_xlim() xmin = 0. my = (ymax - ymin) * 0.05 mx = (xmax - xmin) * 0.2 axes.set_ylim(ymax, ymin - my) axes.set_xlim(xmin, xmax + mx) return fig, axes
def plot( responses, filename=None, dpi=100, fmin=0.01, fmax=100., nf=100, normalize=False, fontsize=10., figsize=None, styles=None, labels=None): ''' Draw instrument responses in Bode plot style. :param responses: instrument responses as :py:class:`pyrocko.trace.FrequencyResponse` objects :param fmin: minimum frequency [Hz] :param fmax: maximum frequency [Hz] :param nf: number of frequencies where to evaluate the response :param normalize: if ``True`` normalize flat part of response to be ``1`` :param styles: :py:class:`list` of :py:class:`dict` objects with keyword arguments to be passed to matplotlib's :py:meth:`matplotlib.axes.Axes.plot` function when drawing the response lines. Length must match number of responses. :param filename: file name to pass to matplotlib's ``savefig`` function. If ``None``, the plot is shown with :py:func:`matplotlib.pyplot.show`. :param fontsize: font size in points used in axis labels and legend :param figsize: :py:class:`tuple`, ``(width, height)`` in inches :param labels: :py:class:`list` of names to show in legend. Length must correspond to number of responses. ''' from matplotlib import pyplot as plt from pyrocko.plot import mpl_init, mpl_margins, mpl_papersize from pyrocko.plot import graph_colors, to01 mpl_init(fontsize=fontsize) if figsize is None: figsize = mpl_papersize('a4', 'portrait') fig = plt.figure(figsize=figsize) labelpos = mpl_margins( fig, w=7., h=5., units=fontsize, nw=1, nh=2, hspace=2.) axes_amplitude = fig.add_subplot(2, 1, 1) labelpos(axes_amplitude, 2., 1.5) axes_phase = fig.add_subplot(2, 1, 2) labelpos(axes_phase, 2., 1.5) setup_axes(axes_amplitude, axes_phase) if styles is None: styles = [ dict(color=to01(graph_colors[i % len(graph_colors)])) for i in range(len(responses))] else: assert len(styles) == len(responses) if labels is None: labels = [None] * len(responses) else: assert len(labels) == len(responses) a_ranges, p_ranges = [], [] have_labels = False for style, resp, label in zip(styles, responses, labels): a_range, p_range = draw( response=resp, axes_amplitude=axes_amplitude, axes_phase=axes_phase, fmin=fmin, fmax=fmax, nf=nf, normalize=normalize, style=style, label=label) if label is not None: have_labels = True a_ranges.append(a_range) p_ranges.append(p_range) if have_labels: axes_amplitude.legend(loc='lower right', prop=dict(size=fontsize)) a_ranges = num.array(a_ranges) p_ranges = num.array(p_ranges) amin, amax = num.min(a_ranges), num.max(a_ranges) pmin, pmax = num.min(p_ranges), num.max(p_ranges) amin *= 0.5 amax *= 2.0 pmin -= 0.5 pmax += 0.5 axes_amplitude.set_ylim(amin, amax) axes_phase.set_ylim(pmin, pmax) axes_amplitude.set_xlim(fmin, fmax) axes_phase.set_xlim(fmin, fmax) if filename is not None: fig.savefig(filename, dpi=dpi) else: plt.show()
def draw_figures(self, history): misfit_cutoff = self.misfit_cutoff sort_by = self.sort_by problem = history.problem models = history.models npar = problem.nparameters ndep = problem.ndependants fontsize = self.font_size nfx, nfy = self.subplot_layout imodels = num.arange(history.nmodels) bounds = problem.get_combined_bounds() xref = problem.get_reference_model(expand=True) gms = problem.combine_misfits(history.misfits) gms_softclip = num.where(gms > 1.0, 0.2 * num.log10(gms) + 1.0, gms) isort = num.argsort(gms)[::-1] if sort_by == 'iteration': imodels = imodels[isort] elif sort_by == 'misfit': imodels = num.arange(imodels.size) else: assert False gms = gms[isort] gms_softclip = gms_softclip[isort] models = models[isort, :] iorder = num.empty_like(isort) iorder = num.arange(iorder.size) if misfit_cutoff is None: ibest = num.ones(gms.size, dtype=num.bool) else: ibest = gms < misfit_cutoff def config_axes(axes, nfx, nfy, impl, iplot, nplots): if (impl - 1) % nfx != nfx - 1: axes.get_yaxis().tick_left() if (impl - 1) >= (nfx * (nfy - 1)) or iplot >= nplots - nfx: axes.set_xlabel('Iteration') if not (impl - 1) // nfx == 0: axes.get_xaxis().tick_bottom() elif (impl - 1) // nfx == 0: axes.get_xaxis().tick_top() axes.set_xticklabels([]) else: axes.get_xaxis().set_visible(False) # nfz = (npar + ndep + 1 - 1) / (nfx*nfy) + 1 cmap = cm.YlOrRd cmap = cm.jet msize = self.marker_size axes = None figs = [] fig = None alpha = 0.5 for ipar in range(npar): impl = ipar % (nfx * nfy) + 1 if impl == 1: fig = plt.figure(figsize=self.size_inch) labelpos = mpl_margins(fig, nw=nfx, nh=nfy, w=7., h=5., wspace=7., hspace=2., units=fontsize) item = PlotItem(name='fig_%i' % (len(figs) + 1)) item.attributes['parameters'] = [] figs.append((item, fig)) par = problem.parameters[ipar] figs[-1][0].attributes['parameters'].append(par.name) axes = fig.add_subplot(nfy, nfx, impl) labelpos(axes, 2.5, 2.0) axes.set_ylabel(par.get_label()) axes.get_yaxis().set_major_locator(plt.MaxNLocator(4)) config_axes(axes, nfx, nfy, impl, ipar, npar + ndep + 1) axes.set_ylim(*fixlim(*par.scaled(bounds[ipar]))) axes.set_xlim(0, history.nmodels) axes.scatter(imodels[ibest], par.scaled(models[ibest, ipar]), s=msize, c=iorder[ibest], edgecolors='none', cmap=cmap, alpha=alpha) axes.axhline(par.scaled(xref[ipar]), color='black', alpha=0.3) for idep in range(ndep): # ifz, ify, ifx = num.unravel_index(ipar, (nfz, nfy, nfx)) impl = (npar + idep) % (nfx * nfy) + 1 if impl == 1: fig = plt.figure(figsize=mpl_papersize('a5', 'landscape')) labelpos = mpl_margins(fig, nw=nfx, nh=nfy, w=7., h=5., wspace=7., hspace=2., units=fontsize) item = PlotItem(name='fig_%i' % (len(figs) + 1)) item.attributes['parameters'] = [] figs.append((item, fig)) par = problem.dependants[idep] figs[-1][0].attributes['parameters'].append(par.name) axes = fig.add_subplot(nfy, nfx, impl) labelpos(axes, 2.5, 2.0) axes.set_ylabel(par.get_label()) axes.get_yaxis().set_major_locator(plt.MaxNLocator(4)) config_axes(axes, nfx, nfy, impl, npar + idep, npar + ndep + 1) axes.set_ylim(*fixlim(*par.scaled(bounds[npar + idep]))) axes.set_xlim(0, history.nmodels) ys = problem.make_dependant(models[ibest, :], par.name) axes.scatter(imodels[ibest], par.scaled(ys), s=msize, c=iorder[ibest], edgecolors='none', cmap=cmap, alpha=alpha) y = problem.make_dependant(xref, par.name) axes.axhline(par.scaled(y), color='black', alpha=0.3) impl = (npar + ndep) % (nfx * nfy) + 1 if impl == 1: fig = plt.figure(figsize=mpl_papersize('a5', 'landscape')) labelpos = mpl_margins(fig, nw=nfx, nh=nfy, w=7., h=5., wspace=7., hspace=2., units=fontsize) item = PlotItem(name='fig_%i' % (len(figs) + 1)) item.attributes['parameters'] = [] figs.append((item, fig)) axes = fig.add_subplot(nfy, nfx, impl) labelpos(axes, 2.5, 2.0) config_axes(axes, nfx, nfy, impl, npar + ndep, npar + ndep + 1) axes.set_ylim(0., 1.5) axes.set_yticks([0., 0.2, 0.4, 0.6, 0.8, 1.0, 1.2, 1.4]) axes.set_yticklabels( ['0.0', '0.2', '0.4', '0.6', '0.8', '1', '10', '100']) axes.scatter(imodels[ibest], gms_softclip[ibest], c=iorder[ibest], s=msize, edgecolors='none', cmap=cmap, alpha=alpha) axes.axhspan(1.0, 1.5, color=(0.8, 0.8, 0.8), alpha=0.2) axes.axhline(1.0, color=(0.5, 0.5, 0.5), zorder=2) axes.set_xlim(0, history.nmodels) axes.set_xlabel('Iteration') axes.set_ylabel('Misfit') return figs
def run_plot(results_path, formats=['png'], min_bin_count=10, mag_step=0.1, nbins_dist=20): config = wconfig.read_config(op.join(results_path, 'config.yaml')) dists = [] mags = [] measures = [] old_event_name = None with open(op.join(results_path, 'measures.txt'), 'r') as f: for line in f: if line.strip().startswith('#'): continue toks = line.split() event_name, station_codes = toks[:2] measures_this = list(map(float, toks[2:])) if event_name != old_event_name: ds = config.get_dataset(event_name) old_event_name = event_name station = ds.get_station(tuple(station_codes.split('.'))) event = ds.get_event() dist = station.distance_to(event) mag = event.magnitude dists.append(dist) mags.append(mag) measures.append(measures_this) dists = num.array(dists, dtype=num.float) mags = num.array(mags, dtype=num.float) measures = num.array(measures, dtype=num.float) from matplotlib import pyplot as plt from pyrocko import plot from scipy.stats import binned_statistic_2d plot.mpl_init() mag_min = num.floor(num.min(mags) / mag_step) * mag_step - mag_step / 2. mag_max = num.ceil(num.max(mags) / mag_step) * mag_step + mag_step / 2. nbins_mag = int(round((mag_max - mag_min) / mag_step)) mag_bins = num.linspace(mag_min, mag_max, nbins_mag + 1) # mag_centers = 0.5*(mag_bins[:-1] + mag_bins[1:]) dist_min = num.min(dists) dist_max = num.max(dists) dist_bins = num.linspace(dist_min, dist_max, nbins_dist + 1) # dist_centers = 0.5*(dist_bins[:-1] + dist_bins[1:]) measure_names = [m.name for m in config.measures] for imeasure, measure_name in enumerate(measure_names): fontsize = 9.0 fig = plt.figure(figsize=plot.mpl_papersize('a5', 'landscape')) labelpos = plot.mpl_margins(fig, w=7, h=5., units=fontsize) axes = fig.add_subplot(1, 1, 1) axes.set_xlabel('Distance [km]') axes.set_ylabel('Magnitude') labelpos(axes, 2., 1.5) fig.suptitle(measure_name) medians, _, _, _ = binned_statistic_2d(dists, mags, measures[:, imeasure], statistic='median', bins=[dist_bins, mag_bins]) counts, _, _, _ = binned_statistic_2d(dists, mags, measures[:, imeasure], statistic='count', bins=[dist_bins, mag_bins]) medians[counts < min_bin_count] = None medians = num.log10(medians) im = axes.pcolorfast(dist_bins / km, mag_bins, medians.T, vmin=num.nanmin(medians), vmax=num.nanmax(medians), cmap='YlOrBr') fig.colorbar(im).set_label('$log_{10}$ measure') for fmt in formats: plot_path = op.join(results_path, 'plots', 'dist_mag_median_%s.%s' % (measure_name, fmt)) util.ensuredirs(plot_path) fig.savefig(plot_path) logger.info('plot saved: %s' % plot_path)
from pyrocko import topo, plot, orthodrome as od lon_min, lon_max, lat_min, lat_max = 14.34, 14.50, 40.77, 40.87 dem_name = 'SRTMGL3' # extract gridded topography (possibly downloading first) tile = topo.get(dem_name, (lon_min, lon_max, lat_min, lat_max)) # geographic to local cartesian coordinates lons = tile.x() lats = tile.y() lons2 = num.tile(lons, lats.size) lats2 = num.repeat(lats, lons.size) norths, easts = od.latlon_to_ne_numpy(lats[0], lons[0], lats2, lons2) norths = norths.reshape((lats.size, lons.size)) easts = easts.reshape((lats.size, lons.size)) # plot it plt = plot.mpl_init(fontsize=10.) fig = plt.figure(figsize=plot.mpl_papersize('a5', 'landscape')) axes = fig.add_subplot(1, 1, 1, aspect=1.0) cbar = axes.pcolormesh(easts, norths, tile.data, cmap='gray', shading='gouraud') fig.colorbar(cbar, label='Altitude [m]') axes.set_title(dem_name) axes.set_xlim(easts.min(), easts.max()) axes.set_ylim(norths.min(), norths.max()) axes.set_xlabel('Easting [m]') axes.set_ylabel('Northing [m]') fig.savefig('topo_example.png')
def correlation_plot(mtrace, varnames=None, transform=lambda x: x, figsize=None, cmap=None, grid=200, point=None, point_style='.', point_color='white', point_size='8'): """ Plot 2d marginals (with kernel density estimation) showing the correlations of the model parameters. Parameters ---------- mtrace : :class:`pymc3.base.MutliTrace` Mutlitrace instance containing the sampling results varnames : list of variable names Variables to be plotted, if None all variable are plotted transform : callable Function to transform data (defaults to identity) figsize : figure size tuple If None, size is (12, num of variables * 2) inch cmap : matplotlib colormap grid : resolution of kernel density estimation point : dict Dictionary of variable name / value to be overplotted as marker to the posteriors e.g. mean of posteriors, true values of a simulation point_style : str style of marker according to matplotlib conventions point_color : str or tuple of 3 color according to matplotlib convention point_size : str marker size according to matplotlib conventions Returns ------- fig : figure object axs : subplot axis handles """ if varnames is None: varnames = mtrace.varnames nvar = len(varnames) if figsize is None: figsize = mpl_papersize('a4', 'landscape') fig, axs = plt.subplots(sharey='row', sharex='col', nrows=nvar - 1, ncols=nvar - 1, figsize=figsize) d = dict() for var in varnames: d[var] = transform(mtrace.get_values( var, combine=True, squeeze=True)) for k in range(nvar - 1): a = d[varnames[k]] for l in range(k + 1, nvar): logger.debug('%s, %s' % (varnames[k], varnames[l])) b = d[varnames[l]] pmp.kde2plot( a, b, grid=grid, ax=axs[l - 1, k], cmap=cmap, aspect='auto') if point is not None: axs[l - 1, k].plot(point[varnames[k]], point[varnames[l]], color=point_color, marker=point_style, markersize=point_size) axs[l - 1, k].tick_params(direction='in') if k == 0: axs[l - 1, k].set_ylabel(varnames[l]) axs[l - 1, k].set_xlabel(varnames[k]) for k in range(nvar - 1): for l in range(k): fig.delaxes(axs[l, k]) fig.subplots_adjust(wspace=0.05, hspace=0.05) return fig, axs
def seismic_fits(problem, stage, plot_options): """ Modified from grond. Plot synthetic and data waveforms and the misfit for the selected posterior model. """ fontsize = 8 fontsize_title = 10 target_index = dict( (target, i) for (i, target) in enumerate(problem.stargets)) po = plot_options population, _, llk = stage.step.select_end_points(stage.mtrace) posterior_idxs = get_fit_indexes(llk) idx = posterior_idxs[po.post_llk] n_steps = problem.config.sampler_config.parameters.n_steps - 1 d = stage.mtrace.point(idx=n_steps, chain=idx) gcms = d['seis_like'] gcm_max = d['like'] out_point = population[idx] results = problem.assemble_seismic_results(out_point) source = problem.sources[0] logger.info('Plotting waveforms ...') target_to_result = {} all_syn_trs = [] dtraces = [] for target in problem.stargets: i = target_index[target] target_to_result[target] = results[i] all_syn_trs.append(results[i].processed_syn) dtraces.append(results[i].processed_res) skey = lambda tr: tr.channel trace_minmaxs = trace.minmax(all_syn_trs, skey) dminmaxs = trace.minmax(dtraces, skey) for tr in dtraces: if tr: dmin, dmax = dminmaxs[skey(tr)] tr.ydata /= max(abs(dmin), abs(dmax)) cg_to_targets = utility.gather( problem.stargets, lambda t: t.codes[3], filter=lambda t: t in target_to_result) cgs = cg_to_targets.keys() figs = [] for cg in cgs: targets = cg_to_targets[cg] # can keep from here ... until nframes = len(targets) nx = int(math.ceil(math.sqrt(nframes))) ny = (nframes - 1) / nx + 1 nxmax = 4 nymax = 4 nxx = (nx - 1) / nxmax + 1 nyy = (ny - 1) / nymax + 1 xs = num.arange(nx) / ((max(2, nx) - 1.0) / 2.) ys = num.arange(ny) / ((max(2, ny) - 1.0) / 2.) xs -= num.mean(xs) ys -= num.mean(ys) fxs = num.tile(xs, ny) fys = num.repeat(ys, nx) data = [] for target in targets: azi = source.azibazi_to(target)[0] dist = source.distance_to(target) x = dist * num.sin(num.deg2rad(azi)) y = dist * num.cos(num.deg2rad(azi)) data.append((x, y, dist)) gxs, gys, dists = num.array(data, dtype=num.float).T iorder = num.argsort(dists) gxs = gxs[iorder] gys = gys[iorder] targets_sorted = [targets[ii] for ii in iorder] gxs -= num.mean(gxs) gys -= num.mean(gys) gmax = max(num.max(num.abs(gys)), num.max(num.abs(gxs))) if gmax == 0.: gmax = 1. gxs /= gmax gys /= gmax dists = num.sqrt( (fxs[num.newaxis, :] - gxs[:, num.newaxis]) ** 2 + (fys[num.newaxis, :] - gys[:, num.newaxis]) ** 2) distmax = num.max(dists) availmask = num.ones(dists.shape[1], dtype=num.bool) frame_to_target = {} for itarget, target in enumerate(targets_sorted): iframe = num.argmin( num.where(availmask, dists[itarget], distmax + 1.)) availmask[iframe] = False iy, ix = num.unravel_index(iframe, (ny, nx)) frame_to_target[iy, ix] = target figures = {} for iy in xrange(ny): for ix in xrange(nx): if (iy, ix) not in frame_to_target: continue ixx = ix / nxmax iyy = iy / nymax if (iyy, ixx) not in figures: figures[iyy, ixx] = plt.figure( figsize=mpl_papersize('a4', 'landscape')) figures[iyy, ixx].subplots_adjust( left=0.03, right=1.0 - 0.03, bottom=0.03, top=1.0 - 0.06, wspace=0.2, hspace=0.2) figs.append(figures[iyy, ixx]) fig = figures[iyy, ixx] target = frame_to_target[iy, ix] amin, amax = trace_minmaxs[target.codes[3]] absmax = max(abs(amin), abs(amax)) ny_this = nymax # min(ny, nymax) nx_this = nxmax # min(nx, nxmax) i_this = (iy % ny_this) * nx_this + (ix % nx_this) + 1 axes2 = fig.add_subplot(ny_this, nx_this, i_this) space = 0.5 space_factor = 1.0 + space axes2.set_axis_off() axes2.set_ylim(-1.05 * space_factor, 1.05) axes = axes2.twinx() axes.set_axis_off() axes.set_ylim(- absmax * 1.33 * space_factor, absmax * 1.33) itarget = target_index[target] result = target_to_result[target] dtrace = dtraces[itarget] tap_color_annot = (0.35, 0.35, 0.25) tap_color_edge = (0.85, 0.85, 0.80) tap_color_fill = (0.95, 0.95, 0.90) plot_taper( axes2, result.processed_obs.get_xdata(), result.taper, fc=tap_color_fill, ec=tap_color_edge) obs_color = scolor('aluminium5') obs_color_light = light(obs_color, 0.5) syn_color = scolor('scarletred2') syn_color_light = light(syn_color, 0.5) misfit_color = scolor('scarletred2') plot_dtrace( axes2, dtrace, space, 0., 1., fc=light(misfit_color, 0.3), ec=misfit_color) plot_trace( axes, result.filtered_syn, color=syn_color_light, lw=1.0) plot_trace( axes, result.filtered_obs, color=obs_color_light, lw=0.75) plot_trace( axes, result.processed_syn, color=syn_color, lw=1.0) plot_trace( axes, result.processed_obs, color=obs_color, lw=0.75) xdata = result.filtered_obs.get_xdata() axes.set_xlim(xdata[0], xdata[-1]) tmarks = [ result.processed_obs.tmin, result.processed_obs.tmax] for tmark in tmarks: axes2.plot( [tmark, tmark], [-0.9, 0.1], color=tap_color_annot) for tmark, text, ha, va in [ (tmarks[0], '$\,$ ' + str_duration(tmarks[0] - source.time), 'right', 'bottom'), (tmarks[1], '$\Delta$ ' + str_duration(tmarks[1] - tmarks[0]), 'left', 'top')]: axes2.annotate( text, xy=(tmark, -0.9), xycoords='data', xytext=( fontsize * 0.4 * [-1, 1][ha == 'left'], fontsize * 0.2), textcoords='offset points', ha=ha, va=va, color=tap_color_annot, fontsize=fontsize) # rel_c = num.exp(gcms[itarget] - gcm_max) # sw = 0.25 # sh = 0.1 # ph = 0.01 # for (ih, rw, facecolor, edgecolor) in [ # (1, rel_c, light(misfit_color, 0.5), misfit_color)]: # bar = patches.Rectangle( # (1.0 - rw * sw, 1.0 - (ih + 1) * sh + ph), # rw * sw, # sh - 2 * ph, # facecolor=facecolor, edgecolor=edgecolor, # zorder=10, # transform=axes.transAxes, clip_on=False) # axes.add_patch(bar) scale_string = None infos = [] if scale_string: infos.append(scale_string) infos.append('.'.join(x for x in target.codes if x)) dist = source.distance_to(target) azi = source.azibazi_to(target)[0] infos.append(str_dist(dist)) infos.append(u'%.0f\u00B0' % azi) infos.append('%.3f' % gcms[itarget]) axes2.annotate( '\n'.join(infos), xy=(0., 1.), xycoords='axes fraction', xytext=(2., 2.), textcoords='offset points', ha='left', va='top', fontsize=fontsize, fontstyle='normal') for (iyy, ixx), fig in figures.iteritems(): title = '.'.join(x for x in cg if x) if len(figures) > 1: title += ' (%i/%i, %i/%i)' % (iyy + 1, nyy, ixx + 1, nxx) fig.suptitle(title, fontsize=fontsize_title) return figs
def geodetic_fits(problem, stage, plot_options): """ Plot geodetic data, synthetics and residuals. """ scattersize = 16 fontsize = 10 fontsize_title = 12 ndmax = 3 nxmax = 3 cmap = plt.cm.jet po = plot_options if po.reference is not None: problem.get_synthetics(po.reference) ref_sources = copy.deepcopy(problem.sources) target_index = dict( (target, i) for (i, target) in enumerate(problem.gtargets)) population, _, llk = stage.step.select_end_points(stage.mtrace) posterior_idxs = get_fit_indexes(llk) idx = posterior_idxs[po.post_llk] out_point = population[idx] results = problem.assemble_geodetic_results(out_point) nrmax = len(results) target_to_result = {} for target, result in zip(problem.gtargets, results): target_to_result[target] = result nfigs = int(num.ceil(float(nrmax) / float(ndmax))) figures = [] axes = [] for f in range(nfigs): fig, ax = plt.subplots( nrows=ndmax, ncols=nxmax, figsize=mpl_papersize('a4', 'portrait')) fig.tight_layout() fig.subplots_adjust( left=0.08, right=1.0 - 0.03, bottom=0.06, top=1.0 - 0.06, wspace=0., hspace=0.3) figures.append(fig) axes.append(ax) def axis_config(axes, po): axes[1].get_yaxis().set_ticklabels([]) axes[2].get_yaxis().set_ticklabels([]) axes[1].get_xaxis().set_ticklabels([]) axes[2].get_xaxis().set_ticklabels([]) if po.plot_projection == 'latlon': ystr = 'Latitude [deg]' xstr = 'Longitude [deg]' elif po.plot_projection == 'utm': ystr = 'UTM Northing [km]' xstr = 'UTM Easting [km]' elif po.plot_projection == 'local': ystr = 'Distance [km]' xstr = 'Distance [km]' else: raise Exception( 'Plot projection %s not available' % po.plot_projection) axes[0].set_ylabel(ystr, fontsize=fontsize) axes[0].set_xlabel(xstr, fontsize=fontsize) def draw_sources(ax, sources, po, **kwargs): for source in sources: rf = source.patches(1, 1, 'seismic')[0] if po.plot_projection == 'latlon': outline = rf.outline(cs='lonlat') elif po.plot_projection == 'utm': outline = rf.outline(cs='lonlat') utme, utmn = utility.lonlat_to_utm( lon=outline[:, 0], lat=outline[:, 1], zone=po.utm_zone) outline = num.vstack([utme / km, utmn / km]).T elif po.plot_projection == 'local': outline = rf.outline(cs='xy') ax.plot(outline[:, 0], outline[:, 1], '-', linewidth=1.0, **kwargs) ax.plot( outline[0:2, 0], outline[0:2, 1], '-k', linewidth=1.0) def cbtick(x): rx = math.floor(x * 1000.) / 1000. return [-rx, rx] def str_title(track): if track[0] == 'A': orbit = 'ascending' elif track[0] == 'D': orbit = 'descending' title = 'Orbit: ' + orbit return title orbits_to_targets = utility.gather( problem.gtargets, lambda t: t.track, filter=lambda t: t in target_to_result) ott = orbits_to_targets.keys() colims = [num.max([ num.max(num.abs(r.processed_obs)), num.max(num.abs(r.processed_syn))]) for r in results] dcolims = [num.max(num.abs(r.processed_res)) for r in results] for o in ott: targets = orbits_to_targets[o] for target in targets: if po.plot_projection == 'local': target.update_local_coords(problem.event) result = target_to_result[target] tidx = target_index[target] figidx, rowidx = utility.mod_i(tidx, ndmax) plot_scene( axes[figidx][rowidx, 0], target, result.processed_obs, scattersize, colim=colims[tidx], outmode=po.plot_projection, cmap=cmap) syn = plot_scene( axes[figidx][rowidx, 1], target, result.processed_syn, scattersize, colim=colims[tidx], outmode=po.plot_projection, cmap=cmap) res = plot_scene( axes[figidx][rowidx, 2], target, result.processed_res, scattersize, colim=dcolims[tidx], outmode=po.plot_projection, cmap=cmap) titley = 0.91 titlex = 0.16 axes[figidx][rowidx, 0].annotate( o, xy=(titlex, titley), xycoords='axes fraction', xytext=(2., 2.), textcoords='offset points', weight='bold', fontsize=fontsize_title) syn_color = scolor('plum1') ref_color = scolor('aluminium3') draw_sources( axes[figidx][rowidx, 1], problem.sources, po, color=syn_color) if po.reference is not None: draw_sources( axes[figidx][rowidx, 1], ref_sources, po, color=ref_color) cbb = 0.68 - (0.3175 * rowidx) cbl = 0.46 cbw = 0.15 cbh = 0.01 cbaxes = figures[figidx].add_axes([cbl, cbb, cbw, cbh]) dcbaxes = figures[figidx].add_axes([cbl + 0.3, cbb, cbw, cbh]) cblabel = 'LOS displacement [m]' cbs = plt.colorbar(syn, ax=axes[figidx][rowidx, 0], ticks=cbtick(colims[tidx]), cax=cbaxes, orientation='horizontal', cmap=cmap) cbs.set_label(cblabel, fontsize=fontsize) cbr = plt.colorbar(res, ax=axes[figidx][rowidx, 2], ticks=cbtick(dcolims[tidx]), cax=dcbaxes, orientation='horizontal', cmap=cmap) cbr.set_label(cblabel, fontsize=fontsize) axis_config(axes[figidx][rowidx, :], po) title = str_title(o) + ' Llk_' + po.post_llk figures[figidx].suptitle( title, fontsize=fontsize_title, weight='bold') nplots = ndmax * nfigs for delidx in range(nrmax, nplots): figidx, rowidx = utility.mod_i(delidx, ndmax) for colidx in range(nxmax): figures[figidx].delaxes(axes[figidx][rowidx, colidx]) return figures
def correlation_plot_hist(mtrace, varnames=None, transform=lambda x: x, figsize=None, hist_color='orange', cmap=None, grid=200, point=None, point_style='.', point_color='red', point_size='8', alpha=0.35): """ Plot 2d marginals (with kernel density estimation) showing the correlations of the model parameters. In the main diagonal is shown the parameter histograms. Parameters ---------- mtrace : :class:`pymc3.base.MutliTrace` Mutlitrace instance containing the sampling results varnames : list of variable names Variables to be plotted, if None all variable are plotted transform : callable Function to transform data (defaults to identity) figsize : figure size tuple If None, size is (12, num of variables * 2) inch cmap : matplotlib colormap hist_color : str or tuple of 3 color according to matplotlib convention grid : resolution of kernel density estimation point : dict Dictionary of variable name / value to be overplotted as marker to the posteriors e.g. mean of posteriors, true values of a simulation point_style : str style of marker according to matplotlib conventions point_color : str or tuple of 3 color according to matplotlib convention point_size : str marker size according to matplotlib conventions Returns ------- fig : figure object axs : subplot axis handles """ logger.info('Drawing correlation figure ...') if varnames is None: varnames = mtrace.varnames nvar = len(varnames) if figsize is None: figsize = mpl_papersize('a4', 'landscape') fig, axs = plt.subplots(nrows=nvar, ncols=nvar, figsize=figsize, subplot_kw={'adjustable': 'box-forced'}) d = dict() for var in varnames: d[var] = transform(mtrace.get_values( var, combine=True, squeeze=True)) for k in range(nvar): a = d[varnames[k]] for l in range(k, nvar): logger.debug('%s, %s' % (varnames[k], varnames[l])) if l == k: histplot_op( axs[l, k], pmp.make_2d(a), alpha=alpha, color='orange') axs[l, k].set_xbound(a.min(), a.max()) axs[l, k].get_yaxis().set_visible(False) if point is not None: axs[l, k].axvline( x=point[varnames[k]], color=point_color, lw=int(point_size) / 4.) else: b = d[varnames[l]] pmp.kde2plot( a, b, grid=grid, ax=axs[l, k], cmap=cmap, aspect='auto') if point is not None: axs[l, k].plot(point[varnames[k]], point[varnames[l]], color=point_color, marker=point_style, markersize=point_size) if l != nvar - 1: axs[l, k].get_xaxis().set_ticklabels([]) if k == 0: axs[l, k].set_ylabel(varnames[l]) else: axs[l, k].get_yaxis().set_ticklabels([]) axs[l, k].tick_params(direction='in') axs[l, k].set_xlabel(varnames[k]) for k in range(nvar): for l in range(k): fig.delaxes(axs[l, k]) fig.subplots_adjust(wspace=0.05, hspace=0.05) return fig, axs
def plot_waveforms(traces, event, stations, savedir, picks, show=True): fig = plt.figure(figsize=plot.mpl_papersize('a4', 'landscape')) tap_color_annot = (0.35, 0.35, 0.25) tap_color_edge = (0.85, 0.85, 0.80) waveform_color = scolor('aluminium5') misfit_color = scolor('scarletred1') ncomps = 3 k = 0 nstations = len(stations) ntraces = nstations * ncomps i = 0 for st in stations: for comp in st.channels: for tr in traces: if tr.station == st.station: if comp.name == tr.channel: # tr.downsample_to(0.05) # tr.highpass(4, 0.01) # tr.lowpass(4, 0.2) dtrace = tr i = i + 1 target = st tmin_fit = dtrace.tmin tmax_fit = dtrace.tmax tfade_taper = 1. / 0.2 taper = trace.CosTaper(tmin_fit - 20, tmin_fit, tmax_fit, tmax_fit + 30) k = k + 1 axes2 = fig.add_subplot(nstations / 3, nstations / 3, k) space = 0.5 space_factor = 1.0 + space axes2.set_axis_off() axes2.set_ylim(-1.05 * space_factor, 1.05) axes = axes2.twinx() axes.set_axis_off() bw_filter = trace.ButterworthResponse(corner=2, order=4, type='low') setup = trace.MisfitSetup(description='setup', norm=2, taper=taper, filter=bw_filter, domain='time_domain') abs_tr = dtrace.copy() abs_tr.set_ydata(abs(dtrace.get_ydata())) plot_cc(axes2, abs_tr, space, 0., num.max(abs_tr.get_ydata()), fc=light(misfit_color, 0.3), ec=misfit_color, zorder=4) plot_trace(axes, dtrace, color=waveform_color, lw=0.5, zorder=5) tmarks = [dtrace.tmin, dtrace.tmax] for tmark in tmarks: axes2.plot([tmark, tmark], [-0.9, 0.1], color=tap_color_annot) for tmark, text, ha, va in [ (tmarks[0], '$\,$ ' + str_duration(tmarks[0]), 'left', 'bottom'), (tmarks[1], '$\Delta$ ' + str_duration(tmarks[1] - tmarks[0]), 'right', 'bottom') ]: axes2.annotate(text, xy=(tmark, -0.9), xycoords='data', xytext=(fontsize * 0.4 * [-1, 1][ha == 'left'], fontsize * 0.2), textcoords='offset points', ha=ha, va=va, color=tap_color_annot, fontsize=fontsize, zorder=10) if picks is not None: for stp in picks["phases"]: phases_station = [] picks_station = [] if st.station == stp["station"]: phases_station.append(str(stp["phase"])) picks_station.append(event.time + float(stp["pick"])) picks_station.append(event.time) tmarks = picks_station for tmark in tmarks: axes2.plot([tmark, tmark], [-1, 1.], color="blue") for tmark, text, ha, va in [(tmarks, phases_station, 'left', 'bottom')]: try: axes2.annotate( text[0], xy=(tmark[0], -1.2), xycoords='data', xytext=(8 * 0.4 * [-1, 1][ha == 'left'], 8 * 0.2), textcoords='offset points', ha=ha, va=va, color=tap_color_annot, fontsize=8, zorder=10) except: pass infos = [] infos.append(target.network + "." + target.station + "." + dtrace.channel) dist = event.distance_to(target) azi = event.azibazi_to(target)[0] infos.append(str_dist(dist)) infos.append(u'%.0f\u00B0' % azi) axes2.annotate('\n'.join(infos), xy=(0., 1.), xycoords='axes fraction', xytext=(2., 2.), textcoords='offset points', ha='left', va='top', fontsize=fontsize, fontstyle='normal') if i / nstations == 1 or i / nstations == 2 or i / nstations == 3: fig.savefig(savedir + "waveforms_%s.png" % str(int(i / nstations)), dpi=100) if show is True: plt.show() else: plt.close() fig = plt.figure(figsize=plot.mpl_papersize('a4', 'landscape')) k = 0
def plot_polarizations(stations, trs, event=None, size_factor=0.05, fontsize=10., output_filename=None, output_format=None, output_dpi=None): if event is None: slats = num.array([s.lat for s in stations], dtype=num.float) slons = num.array([s.lon for s in stations], dtype=num.float) clat, clon = od.geographic_midpoint(slats, slons) event = od.Loc(clat, clon) nsl_c_to_trs = defaultdict(dict) for tr in trs: nsl_c_to_trs[tr.nslc_id[:3]][tr.nslc_id[3]] = tr nsl_to_station = dict((s.nsl(), s) for s in stations) plot.mpl_init(fontsize=fontsize) fig = plt.figure(figsize=plot.mpl_papersize('a4', 'landscape')) plot.mpl_margins(fig, w=7., h=6., units=fontsize) grid = ImageGrid(fig, 111, nrows_ncols=(2, 2), axes_pad=0.5, add_all=True, label_mode='L', aspect=True) axes_en = grid[0] axes_en.set_ylabel('Northing [km]') axes_dn = grid[1] axes_dn.locator_params(axis='x', nbins=4) axes_dn.set_xlabel('Depth [km]') axes_ed = grid[2] axes_ed.locator_params(axis='y', nbins=4) axes_ed.set_ylabel('Depth [km]') axes_ed.set_xlabel('Easting [km]') if isinstance(event, model.Event): axes_en.plot(0., 0., '*') axes_dn.plot(event.depth / km, 0., '*') axes_ed.plot(0., event.depth / km, '*') grid[3].set_axis_off() locations = [] for nsl in sorted(nsl_c_to_trs.keys()): station = nsl_to_station[nsl] n, e = od.latlon_to_ne(event.lat, event.lon, station.lat, station.lon) locations.append((n, e)) ns, es = num.array(locations, dtype=num.float).T n_min = num.min(ns) n_max = num.max(ns) e_min = num.min(es) e_max = num.max(es) factor = max((n_max - n_min) * size_factor, (e_max - e_min) * size_factor) fontsize_annot = fontsize * 0.7 data = {} for insl, nsl in enumerate(sorted(nsl_c_to_trs.keys())): color = plot.mpl_graph_color(insl) try: tr_e = nsl_c_to_trs[nsl]['E'] tr_n = nsl_c_to_trs[nsl]['N'] tr_z = nsl_c_to_trs[nsl]['Z'] except KeyError: continue station = nsl_to_station[nsl] n, e = od.latlon_to_ne(event.lat, event.lon, station.lat, station.lon) d = station.depth axes_en.annotate('.'.join(x for x in nsl if x), xy=(e / km, n / km), xycoords='data', xytext=(fontsize_annot / 3., fontsize_annot / 3.), textcoords='offset points', verticalalignment='bottom', horizontalalignment='left', rotation=0., size=fontsize_annot) axes_en.plot(e / km, n / km, '^', mfc=color, mec=darken(color)) axes_dn.plot(d / km, n / km, '^', mfc=color, mec=darken(color)) axes_ed.plot(e / km, d / km, '^', mfc=color, mec=darken(color)) arr_e = tr_e.ydata arr_n = tr_n.ydata arr_z = tr_z.ydata arr_t = tr_z.get_xdata() data[nsl] = (arr_e, arr_n, arr_z, arr_t, n, e, d, color) amaxs = [] amax_hors = [] for nsl in sorted(data.keys()): arr_e, arr_n, arr_z, arr_t, n, e, d, color = data[nsl] amaxs.append(num.max(num.abs(num.sqrt(arr_e**2 + arr_n**2 + arr_z**2)))) amax_hors.append(num.max(num.abs(num.sqrt(arr_e**2 + arr_n**2)))) amax = num.median(amaxs) amax_hor = num.median(amax_hors) for nsl in sorted(data.keys()): arr_e, arr_n, arr_z, arr_t, n, e, d, color = data[nsl] tmin = arr_t.min() tmax = arr_t.max() plot_color_line(axes_en, (e + arr_e / amax_hor * factor) / km, (n + arr_n / amax_hor * factor) / km, arr_t, color, tmin, tmax) plot_color_line(axes_dn, (d - arr_z / amax * factor) / km, (n + arr_n / amax * factor) / km, arr_t, color, tmin, tmax) plot_color_line(axes_ed, (e + arr_e / amax * factor) / km, (d - arr_z / amax * factor) / km, arr_t, color, tmin, tmax) axes_ed.invert_yaxis() for axes in (axes_dn, axes_ed, axes_en): axes.autoscale_view(tight=True) if output_filename is None: plt.show() else: fig.savefig(output_filename, format=output_format, dpi=output_dpi)
from matplotlib import pyplot as plt from pyrocko.plot import mpl_init, mpl_margins, mpl_papersize # from pyrocko.plot import mpl_labelspace fontsize = 9. # in points # set some Pyrocko style defaults mpl_init(fontsize=fontsize) fig = plt.figure(figsize=mpl_papersize('a4', 'landscape')) # let margins be proportional to selected font size, e.g. top and bottom # margin are set to be 5*fontsize = 45 [points] labelpos = mpl_margins(fig, w=7., h=5., units=fontsize) axes = fig.add_subplot(1, 1, 1) # positioning of axis labels # mpl_labelspace(axes) # either: relative to axis tick labels labelpos(axes, 2., 1.5) # or: relative to left/bottom paper edge axes.plot([0, 1], [0, 9]) axes.set_xlabel('Time [s]') axes.set_ylabel('Amplitude [m]') fig.savefig('plot_skeleton.pdf') plt.show()
from matplotlib import pyplot as plt from pyrocko.plot import mpl_init, mpl_margins, mpl_papersize # from pyrocko.plot import mpl_labelspace fontsize = 9. # in points # set some Pyrocko style defaults mpl_init(fontsize=fontsize) fig = plt.figure(figsize=mpl_papersize('a4', 'landscape')) # let margins be proportional to selected font size, e.g. top and bottom # margin are set to be 5*fontsize = 45 [points] labelpos = mpl_margins(fig, w=7., h=5., units=fontsize) axes = fig.add_subplot(1, 1, 1) # positioning of axis labels # mpl_labelspace(axes) # either: relative to axis tick labels labelpos(axes, 2., 1.5) # or: relative to left/bottom paper edge axes.plot([0, 1], [0, 9]) axes.set_xlabel('Time [s]') axes.set_ylabel('Amplitude [m]') fig.savefig('plot_skeleton.pdf') plt.show()
def plot(responses, filename=None, dpi=100, fmin=0.01, fmax=100., nf=100, fontsize=10., figsize=None, styles=None, labels=None): ''' Draw instrument responses in Bode plot style. :param responses: instrument responses as :py:class:`pyrocko.trace.FrequencyResponse` objects :param fmin: minimum frequency [Hz] :param fmax: maximum frequency [Hz] :param nf: number of frequencies where to evaluate the response :param styles: :py:class:`list` of :py:class:`dict` objects with keyword arguments to be passed to matplotlib's :py:meth:`matplotlib.axes.Axes.plot` function when drawing the response lines. Length must match number of responses. :param filename: file name to pass to matplotlib's ``savefig`` function. If ``None``, the plot is shown with :py:func:`matplotlib.pyplot.show`. :param fontsize: font size in points used in axis labels and legend :param figsize: :py:class:`tuple`, ``(width, height)`` in inches :param labels: :py:class:`list` of names to show in legend. Length must correspond to number of responses. ''' from matplotlib import pyplot as plt from pyrocko.plot import mpl_init, mpl_margins, mpl_papersize from pyrocko.plot import graph_colors, to01 mpl_init(fontsize=fontsize) if figsize is None: figsize = mpl_papersize('a4', 'portrait') fig = plt.figure(figsize=figsize) labelpos = mpl_margins(fig, w=7., h=5., units=fontsize, nw=1, nh=2, hspace=2.) axes_amplitude = fig.add_subplot(2, 1, 1) labelpos(axes_amplitude, 2., 1.5) axes_phase = fig.add_subplot(2, 1, 2) labelpos(axes_phase, 2., 1.5) setup_axes(axes_amplitude, axes_phase) if styles is None: styles = [ dict(color=to01(graph_colors[i % len(graph_colors)])) for i in xrange(len(responses)) ] else: assert len(styles) == len(responses) if labels is None: labels = [None] * len(responses) else: assert len(labels) == len(responses) a_ranges, p_ranges = [], [] for style, resp, label in zip(styles, responses, labels): a_range, p_range = draw(response=resp, axes_amplitude=axes_amplitude, axes_phase=axes_phase, fmin=fmin, fmax=fmax, nf=nf, style=style, label=label) a_ranges.append(a_range) p_ranges.append(p_range) axes_amplitude.legend(loc='lower right', prop=dict(size=fontsize)) a_ranges = num.array(a_ranges) p_ranges = num.array(p_ranges) amin, amax = num.min(a_ranges), num.max(a_ranges) pmin, pmax = num.min(p_ranges), num.max(p_ranges) amin *= 0.5 amax *= 2.0 pmin -= 0.5 pmax += 0.5 axes_amplitude.set_ylim(amin, amax) axes_phase.set_ylim(pmin, pmax) axes_amplitude.set_xlim(fmin, fmax) axes_phase.set_xlim(fmin, fmax) if filename is not None: fig.savefig(filename, dpi=dpi) else: plt.show()
def plot_shakemap(sources, norths, easts, values_list, filename, folder, stations, values_stations_list=None, easts_stations=None, norths_stations=None, latlon=True, show=False, plot_background_map=True, measured=None, value_level=0.001, quantity="velocity", scale="mm", plot_values=False, vs30=True, engine=None, type_factors=None, store_id=None, plot_snr=False): plot.mpl_init() fig = plt.figure(figsize=plot.mpl_papersize('a5', 'landscape')) axes = fig.add_subplot(1, 1, 1, aspect=1.0) mts = [] plot_kwargs = {'size': 4000, 'edgecolor': 'black'} for i, source in enumerate(sources): mts.append(source.pyrocko_moment_tensor()) if i == 0: best_mt = source.pyrocko_moment_tensor() for i, values_pertubed in enumerate(values_list): if i == 0: values = values_pertubed values_cum = num.zeros(num.shape(values)) values_cum = values_cum + values else: values_cum = values_cum + values_pertubed vales_cum = values_cum / float(len(values_list)) if scale == "mm": values = values * 1000. if values_stations_list is not None: values_stations = values_stations_list[0] if scale == "mm": values_stations = values_stations * 1000. if latlon is False: axes.set_xlim(easts.min() / km, easts.max() / km) axes.set_ylim(norths.min() / km, norths.max() / km) axes.set_xlabel('Easting [km]') axes.set_ylabel('Northing [km]') im = axes.contourf(easts / km, norths / km, values, vmin=0., vmax=vmax, cmap=plt.get_cmap('YlOrBr')) if quantity == "velocity": if scale == "mm": fig.colorbar(im, label='Velocity [mm/s]') else: fig.colorbar(im, label='Velocity [m/s]') if quantity == "acceleration": if scale == "mm": fig.colorbar(im, label='Velocity [mm/s]') else: fig.colorbar(im, label='Velocity [m/s]') if source.base_key()[6] is not "ExplosionSource": beachball.plot_fuzzy_beachball_mpl_pixmap(mts, axes, best_mt, position=(0, 0.), color_t='black', **plot_kwargs) if values_stations is not None: plt.scatter(easts_stations / km, norths_stations / km, c=values_stations, s=36, cmap=plt.get_cmap('YlOrBr'), vmin=0., vmax=vmax, edgecolor="k") else: lats = [] lons = [] for east, north in zip(easts, norths): lat, lon = orthodrome.ne_to_latlon(source.lat, source.lon, north, east) lats.append(lat) lons.append(lon) if vs30 is True: from silvertine.shakemap import vs30 values_vs30 = vs30.extract_rectangle(num.min(lons), num.max(lons), num.min(lats), num.max(lats)) from scipy import ndimage factor_x = num.shape(values)[0] / num.shape(values_vs30)[0] factor_y = num.shape(values)[1] / num.shape(values_vs30)[1] values_vs30_resam = ndimage.zoom(values_vs30, (factor_x, factor_y)) store = engine.get_store(store_id) if type_factors is None: layer0 = store.config.earthmodel_1d.layer(0) base_velocity = layer0.mtop.vs base_velocity = 400. type_factors = 1 amp_factor = (base_velocity / values_vs30_resam)**type_factors values = values * amp_factor values = values / 15.87 #values = values/10. if plot_background_map is True: map = Basemap(projection='merc', llcrnrlon=num.min(lons), llcrnrlat=num.min(lats), urcrnrlon=num.max(lons), urcrnrlat=num.max(lats), resolution='h', epsg=3395) ratio_lat = num.max(lats) / num.min(lats) ratio_lon = num.max(lons) / num.min(lons) map.drawmapscale( num.min(lons) + 0.05, num.min(lats) + 0.05, num.min(lons), num.min(lats), 10) parallels = num.arange(num.around(num.min(lats), decimals=2), num.around(num.max(lats), decimals=2), 0.1) meridians = num.arange(num.around(num.min(lons), decimals=2), num.around(num.max(lons), decimals=2), 0.2) map.drawparallels(parallels, labels=[1, 0, 0, 0], fontsize=22) map.drawmeridians(meridians, labels=[1, 1, 0, 1], fontsize=22) xpixels = 1000 try: map.arcgisimage(service='World_Shaded_Relief', xpixels=xpixels, verbose=False, zorder=1, cmap="gray") except urllib.error.URLError: pass # axes.set_xlim(lats.min()/km, lats.max()/km) # axes.set_ylim(norths.min()/km, norths.max()/km) if plot_background_map is True: pos1, pos2 = map(source.lon, source.lat) else: pos1 = source.lat pos2 = source.lon if source.base_key()[6] is not "ExplosionSource": beachball.plot_fuzzy_beachball_mpl_pixmap(mts, axes, best_mt, position=(pos1, pos2), color_t='black', zorder=2, **plot_kwargs) if plot_background_map is True: lats_map, lons_map = map(lons, lats) values[values == 0] = 'nan' alpha = 0.5 else: lats_map, lons_map = lats, lons alpha = 1. _, vmax = num.min(values), num.max(values) if values_stations_list is not None: st_lats, st_lons = [], [] for st in stations: st_lats.append(st.lat) st_lons.append(st.lon) if plot_background_map is True: st_lats, st_lons = map(st_lons, st_lats) if plot_values is True and measured is not None: measured_values = [] try: for k, st in enumerate(stations): for data in measured: if data[0].decode() == st.station: if scale == "mm": measured_values.append(data[1] * 1000.) _, vmax = num.min(measured_values), num.max(measured_values) except: measured_values = [] if measured is not None: for data in measured: if scale == "mm": # measured_values.append(data*1000.*100) measured_values.append(data * 1000.) _, vmax = num.min(measured_values), num.max( measured_values) if plot_values is True and measured is None: plt.scatter(st_lats, st_lons, c=num.asarray(values_stations), s=36, cmap=plt.get_cmap('YlOrBr'), vmin=0., vmax=vmax, edgecolor="k", alpha=alpha) for k, st in enumerate(stations): plt.text(st_lats[k], st_lons[k], str(st.station)) if plot_values is True and measured is not None: plt.scatter(st_lats, st_lons, c=num.asarray(measured_values), s=36, cmap=plt.get_cmap('YlOrBr'), vmin=0., vmax=vmax, edgecolor="k", alpha=alpha) for k, st in enumerate(stations): plt.text(st_lats[k], st_lons[k], str(st.station)) if measured is not None and plot_values is False: residuals = [] stations_write = [] try: for k, st in enumerate(stations): for data in measured: # case for manual input if data[0].decode() == st.station: residuals.append(values_stations[k] - data[1]) stations_write.append(st.station) except: if measured is not None: for data in measured: # case for measured input residuals.append(values_stations[k] - data) stations_write.append(st.station) fobj = open(os.path.join(folder, 'residuals.txt'), 'w') for i in range(0, len(residuals)): fobj.write('%s %.20f\n' % (stations_write[i], residuals[i])) fobj.close() fobj = open(os.path.join(folder, 'synthetic_pga.txt'), 'w') for i in range(0, len(residuals)): fobj.write('%s %.20f\n' % (stations_write[i], values_stations[i])) fobj.close() plt.scatter(st_lats, st_lons, c=residuals, s=36, cmap=plt.get_cmap('YlOrBr'), vmin=0., vmax=vmax, edgecolor="k", alpha=alpha) #values = values*77.66 im = axes.contourf(lats_map, lons_map, values.T, vmin=0., vmax=vmax, cmap=plt.get_cmap('YlOrBr'), alpha=alpha) if quantity == "velocity": if scale == "mm": #fig.colorbar(im, label='Velocity [mm/s]') m = plt.cm.ScalarMappable(cmap=plt.get_cmap('YlOrBr')) m.set_array(values) m.set_clim(0., vmax) plt.colorbar(m, boundaries=num.linspace(0, vmax, 6)) else: fig.colorbar(im, label='Velocity [m/s]') if quantity == "acceleration": if scale == "mm": fig.colorbar(im, label='Velocity [mm/s]') else: fig.colorbar(im, label='Velocity [m/s]') axes.contour(lats_map, lons_map, vales_cum.T, cmap='brg', levels=[value_level]) fig.savefig(folder + filename) if show is True: plt.show() else: plt.close() if vs30 is not False: fig = plt.figure(figsize=plot.mpl_papersize('a5', 'landscape')) axes = fig.add_subplot(1, 1, 1, aspect=1.0) map = Basemap(projection='merc', llcrnrlon=num.min(lons), llcrnrlat=num.min(lats), urcrnrlon=num.max(lons), urcrnrlat=num.max(lats), resolution='h', epsg=3395) ratio_lat = num.max(lats) / num.min(lats) ratio_lon = num.max(lons) / num.min(lons) parallels = num.arange(num.around(num.min(lats), decimals=2), num.around(num.max(lats), decimals=2), 0.1) meridians = num.arange(num.around(num.min(lons), decimals=2), num.around(num.max(lons), decimals=2), 0.2) map.drawparallels(parallels, labels=[1, 0, 0, 0], fontsize=22) map.drawmeridians(meridians, labels=[1, 1, 0, 1], fontsize=22) im = map.imshow(num.rot90(values_vs30.T)) fig.colorbar(im, label='Velocity [m/s]') fig.savefig(folder + "vs30.png")