def __init__(self, sc, events, project_dir, hypers=False): super(SeismicComposite, self).__init__(events) logger.debug('Setting up seismic structure ...\n') self.name = 'seismic' self._like_name = 'seis_like' self.correction_name = 'time_shift' self.engine = LocalEngine( store_superdirs=[sc.gf_config.store_superdir]) if sc.responses_path is not None: responses_path = os.path.join(sc.responses_path, bconfig.response_file_name) else: responses_path = sc.responses_path # load data self.datahandlers = [] for i in range(self.nevents): seismic_data_path = os.path.join( project_dir, bconfig.multi_event_seismic_data_name(i)) logger.info('Loading seismic data for event %i' ' from: %s ' % (i, seismic_data_path)) self.datahandlers.append( heart.init_datahandler(seismic_config=sc, seismic_data_path=seismic_data_path, responses_path=responses_path)) self.noise_analyser = cov.SeismicNoiseAnalyser( structure=sc.noise_estimator.structure, pre_arrival_time=sc.noise_estimator.pre_arrival_time, engine=self.engine, events=self.events, chop_bounds=['b', 'c']) self.wavemaps = [] for i, wc in enumerate(sc.waveforms): if wc.include: wmap = heart.init_wavemap( waveformfit_config=wc, datahandler=self.datahandlers[wc.event_idx], event=self.events[wc.event_idx], mapnumber=i) self.wavemaps.append(wmap) else: logger.info('The waveform defined in "%s %i" config is not ' 'included in the optimization!' % (wc.name, i)) if hypers: self._llks = [] for t in range(self.n_t): self._llks.append( shared(num.array([1.]), name='seis_llk_%i' % t, borrow=True))
def __init__(self, gc, project_dir, sources, event, hypers=False): super(GeodeticSourceComposite, self).__init__(gc, project_dir, event, hypers=hypers) self.engine = LocalEngine( store_superdirs=[gc.gf_config.store_superdir]) self.sources = sources
def main(n, depths, durations, noisy, noise_factor, velocity_model, long, tmin, tmax, save_file, save_dir, _run): engine = LocalEngine(store_dirs=[velocity_model]) target = gf.Target(quantity='displacement', lat=0, lon=long, store_id=velocity_model, codes=('NET', 'STA', 'LOC', 'E'), tmin=tmin, tmax=tmax) df = createFocalMechanisms(n, depths, durations, target, engine, noisy=noisy, noise_factor=noise_factor) if os.path.exists(save_dir) == False: os.mkdir(save_dir) path = save_dir + save_file df.to_pickle(path) ex.add_artifact(path)
def prep_data_batch(data_dir, store_id, stations=None, pre=0.5, post=3, reference_event=None, min_len=420, pick_sigma=0.02): engine = LocalEngine(store_superdirs=['/home/asteinbe/gf_stores']) store = engine.get_store(store_id) mod = store.config.earthmodel_1d gf_freq = store.config.sample_rate cake_phase = cake.PhaseDef("P") phase_list = [cake_phase] events = [] waveforms = [] waveforms_shifted = [] events = scedc_util.scedc_fm_to_pyrocko(file) labels = labels_from_events(events) pathlist = Path(data_dir).glob('ev_0/') for path in sorted(pathlist): try: targets = [] path = str(path)+"/" event = model.load_events(path+"event.txt")[0] traces_loaded = io.load(path+"traces.mseed") stations_unsorted = model.load_stations(data_dir+"stations.pf") for st in stations_unsorted: st.dist = orthodrome.distance_accurate50m(st.lat, st.lon, event.lat, event.lon) st.azi = orthodrome.azimuth(st.lat, st.lon, event.lat, event.lon) stations = sorted(stations_unsorted, key=lambda x: x.dist, reverse=True) traces_processed = [] traces = check_traces(traces_loaded, stations, min_len=min_len) traces_processed, nsamples = wp.process_loaded_waveforms(traces, stations, event, gf_freq, mod, pre, post) events.append(event) waveforms.append(traces_processed) except: pass return waveforms, nsamples, events, waveforms_shifted
def invert(self, args): align_phase = 'P' ampl_scaler = '4*standard deviation' for array_id in self.provider.use: try: if args.array_id and array_id != args.array_id: continue except AttributeError: pass subdir = pjoin('array_data', array_id) settings_fn = pjoin(subdir, 'plot_settings.yaml') if os.path.isfile(settings_fn): settings = PlotSettings.load(filename=pjoin(settings_fn)) settings.update_from_args(self.args) else: logger.warn('no settings found: %s' % array_id) continue if settings.store_superdirs: engine = LocalEngine(store_superdirs=settings.store_superdirs) else: engine = LocalEngine(use_config=True) try: store = engine.get_store(settings.store_id) except seismosizer.NoSuchStore as e: logger.info('%s ... skipping.' % e) return try: store = engine.get_store(settings.store_id) except seismosizer.NoSuchStore as e: logger.info('%s ... skipping.' % e) return if not settings.trace_filename: settings.trace_filename = pjoin(subdir, 'beam.mseed') if not settings.station_filename: settings.station_filename = pjoin(subdir, 'array_center.pf') zoom_window = settings.zoom mod = store.config.earthmodel_1d zstart, zstop, inkr = settings.depths.split(':') test_depths = num.arange(float(zstart)*km, float(zstop)*km, float(inkr)*km) traces = io.load(settings.trace_filename) event = model.load_events(settings.event_filename) assert len(event)==1 event = event[0] event.depth = float(settings.depth) * 1000. base_source = MTSource.from_pyrocko_event(event) test_sources = [] for d in test_depths: s = base_source.clone() s.depth = float(d) test_sources.append(s) stations = model.load_stations(settings.station_filename) station = filter(lambda s: match_nslc('%s.%s.%s.*' % s.nsl(), traces[0].nslc_id), stations) if len(station) != 1: logger.error('no matching stations found. %s %s' % []) else: station = station[0] targets = [station_to_target(station, quantity=settings.quantity, store_id=settings.store_id)] try: request = engine.process(targets=targets, sources=test_sources) except seismosizer.NoSuchStore as e: logger.info('%s ... skipping.' % e) return except meta.OutOfBounds as error: if settings.force_nearest_neighbor: logger.warning('%s Using nearest neighbor instead.' % error) mod_targets = [] for t in targets: closest_source = min(test_sources, key=lambda s: s.distance_to(t)) farthest_source = max(test_sources, key=lambda s: s.distance_to(t)) min_dist_delta = store.config.distance_min - closest_source.distance_to(t) max_dist_delta = store.config.distance_max - farthest_source.distance_to(t) if min_dist_delta < 0: azi, bazi = closest_source.azibazi_to(t) newlat, newlon = ortho.azidist_to_latlon(t.lat, t.lon, azi, min_dist_delta*cake.m2d) elif max_dist_delta < 0: azi, bazi = farthest_source.azibazi_to(t) newlat, newlon = ortho.azidist_to_latlon(t.lat, t.lon, azi, max_dist_delta*cake.m2d) t.lat, t.lon = newlat, newlon mod_targets.append(t) request = engine.process(targets=mod_targets, sources=test_sources) else: raise error candidates = [] for s, t, tr in request.iter_results(): tr.deltat = regularize_float(tr.deltat) if True: tr = integrate_differentiate(tr, 'differentiate') tr = settings.do_filter(tr) candidates.append((s, tr)) assert len(traces)==1 ref = traces[0] ref = settings.do_filter(ref) dist = ortho.distance_accurate50m(event, station) tstart = self.provider.timings[array_id].timings[0].t(mod, (event.depth, dist)) + event.time tend = self.provider.timings[array_id].timings[1].t(mod, (event.depth, dist)) + event.time ref = ref.chop(tstart, tend) misfits = [] center_freqs = num.arange(1., 9., 4.) num_f_widths = len(center_freqs) mesh_fc = num.zeros(len(center_freqs)*num_f_widths*len(candidates)) mesh_fwidth = num.zeros(len(center_freqs)*num_f_widths*len(candidates)) misfits_array = num.zeros((len(center_freqs), num_f_widths, len(candidates))) depths_array = num.zeros((len(center_freqs), num_f_widths, len(candidates))) debug = False pb = ProgressBar(maxval=max(center_freqs)).start() i = 0 for i_fc, fc in enumerate(center_freqs): if debug: fig = plt.figure() fl_min = fc-fc*2./5. fr_max = fc+fc*2./5. widths = num.linspace(fl_min, fr_max, num_f_widths) for i_width, width in enumerate(widths): i_candidate = 0 mesh_fc[i] = fc mesh_fwidth[i] = width i += 1 for source, candidate in candidates: candidate = candidate.copy() tstart = self.provider.timings[array_id].timings[0].t(mod, (source.depth, dist)) + event.time tend = self.provider.timings[array_id].timings[1].t(mod, (source.depth, dist)) + event.time filters = [ ButterworthResponse(corner=float(fc+width*0.5), order=4, type='low'), ButterworthResponse(corner=float(fc-width*0.5), order=4, type='high')] settings.filters = filters candidate = settings.do_filter(candidate) candidate.chop(tmin=tstart, tmax=tend) candidate.shift(float(settings.correction)) m, n, aproc, bproc = ref.misfit(candidate=candidate, setup=settings.misfit_setup, debug=True) aproc.set_codes(station='aproc') bproc.set_codes(station='bproc') if debug: ax = fig.add_subplot(len(test_depths)+1, 1, i+1) ax.plot(aproc.get_xdata(), aproc.get_ydata()) ax.plot(bproc.get_xdata(), bproc.get_ydata()) mf = m/n #misfits.append((source.depth, mf)) misfits_array[i_fc][i_width][i_candidate] = mf i_candidate += 1 pb.update(fc) pb.finish() fig = plt.figure() ax = fig.add_subplot(111) i_best_fits = num.argmin(misfits_array, 2) print 'best fits: \n', i_best_fits best_fits = num.min(misfits_array, 2) #cmap = matplotlib.cm.get_cmap() xmesh, ymesh = num.meshgrid(mesh_fc, mesh_fwidth) #c = (best_fits-num.min(best_fits))/(num.max(best_fits)-num.min(best_fits)) ax.scatter(xmesh, ymesh, best_fits*100) #ax.scatter(mesh_fc, mesh_fwidth, c) #ax.scatter(mesh_fc, mesh_fwidth, s=best_fits) ax.set_xlabel('fc') ax.set_ylabel('f_width') plt.legend() plt.show()
from pyrocko.gf import LocalEngine, Target, DCSource from pyrocko import trace from pyrocko.gui_util import PhaseMarker # We need a pyrocko.gf.Engine object which provides us with the traces # extracted from the store. In this case we are going to use a local # engine since we are going to query a local store. engine = LocalEngine(store_superdirs=['/media/usb/gf_stores']) # The store we are going extract data from: store_id = 'crust2_dd' # Define a list of pyrocko.gf.Target objects, representing the recording # devices. In this case one station with a three component sensor will # serve fine for demonstation. channel_codes = 'ENZ' targets = [ Target(lat=10., lon=10., store_id=store_id, codes=('', 'STA', '', channel_code)) for channel_code in channel_codes ] # Let's use a double couple source representation. source_dc = DCSource(lat=11., lon=11., depth=10000., strike=20., dip=40., rake=60.,
class GeodeticSourceComposite(GeodeticComposite): """ Comprises how to solve the non-linear geodetic forward model. Parameters ---------- gc : :class:`config.GeodeticConfig` configuration object containing seismic setup parameters project_dir : str directory of the model project, where to find the data sources : list of :class:`pyrocko.gf.seismosizer.Source` event : :class:`pyrocko.model.Event` contains information of reference event, coordinates of reference point and source time hypers : boolean if true initialise object for hyper parameter optimization """ def __init__(self, gc, project_dir, sources, event, hypers=False): super(GeodeticSourceComposite, self).__init__(gc, project_dir, event, hypers=hypers) self.engine = LocalEngine( store_superdirs=[gc.gf_config.store_superdir]) self.sources = sources def __getstate__(self): self.engine.close_cashed_stores() return self.__dict__.copy() def point2sources(self, point): """ Updates the composite source(s) (in place) with the point values. """ tpoint = copy.deepcopy(point) tpoint = utility.adjust_point_units(tpoint) # remove hyperparameters from point hps = self.config.get_hypernames() for hyper in hps: if hyper in tpoint: tpoint.pop(hyper) source_params = list(self.sources[0].keys()) for param in list(tpoint.keys()): if param not in source_params: tpoint.pop(param) source_points = utility.split_point(tpoint) for i, source in enumerate(self.sources): utility.update_source(source, **source_points[i]) # reset source time may result in store error otherwise source.time = 0. def get_formula(self, input_rvs, fixed_rvs, hyperparams, problem_config): """ Get geodetic likelihood formula for the model built. Has to be called within a with model context. Part of the pymc3 model. Parameters ---------- input_rvs : dict of :class:`pymc3.distribution.Distribution` fixed_rvs : dict of :class:`numpy.array` hyperparams : dict of :class:`pymc3.distribution.Distribution` problem_config : :class:`config.ProblemConfig` Returns ------- posterior_llk : :class:`theano.tensor.Tensor` """ hp_specific = self.config.dataset_specific_residual_noise_estimation self.input_rvs = input_rvs self.fixed_rvs = fixed_rvs logger.info('Geodetic optimization on: \n ' '%s' % ', '.join(self.input_rvs.keys())) self.input_rvs.update(fixed_rvs) t0 = time() disp = self.get_synths(self.input_rvs) t1 = time() logger.debug('Geodetic forward model on test model takes: %f' % (t1 - t0)) los_disp = (disp * self.slos_vectors).sum(axis=1) residuals = self.Bij.srmap( tt.cast((self.sdata - los_disp) * self.sodws, tconfig.floatX)) self.init_hierarchicals(problem_config) if len(self.hierarchicals) > 0: residuals = self.remove_ramps(residuals) logpts = multivariate_normal_chol(self.datasets, self.weights, hyperparams, residuals, hp_specific=hp_specific) llk = Deterministic(self._like_name, logpts) return llk.sum()
self.amplitudes = self._amplitudes else: self.amplitudes = np.ones(1) return times, self.amplitudes def base_key(self): # method returns STF name and the values return (self.__class__.__name__, self.duration, self.anchor) if __name__ == '__main__': model = 'crust2_m5_hardtop_16Hz' engine = LocalEngine(store_dirs=[model]) target = gf.Target(quantity='displacement', lat=0, lon=1, store_id=model, codes=('NET', 'STA', 'LOC', 'E'), tmin=10, tmax=75) DC_tensors = [createMT_DC(mag) for mag in 4 * np.random.rand(1000)] CLVD_tensors = [createMT_CLVD(mag) for mag in 4 * np.random.rand(1000)] Iso_tensors = [createMT_Isotropic(mag) for mag in 4 * np.random.rand(1000)] moment_tensors = DC_tensors + CLVD_tensors + Iso_tensors
class SeismicComposite(Composite): """ Comprises how to solve the non-linear seismic forward model. Parameters ---------- sc : :class:`config.SeismicConfig` configuration object containing seismic setup parameters events: list of :class:`pyrocko.model.Event` project_dir : str directory of the model project, where to find the data hypers : boolean if true initialise object for hyper parameter optimization """ _datasets = None _weights = None _targets = None _hierarchicalnames = None def __init__(self, sc, events, project_dir, hypers=False): super(SeismicComposite, self).__init__(events) logger.debug('Setting up seismic structure ...\n') self.name = 'seismic' self._like_name = 'seis_like' self.correction_name = 'time_shift' self.engine = LocalEngine( store_superdirs=[sc.gf_config.store_superdir]) if sc.responses_path is not None: responses_path = os.path.join(sc.responses_path, bconfig.response_file_name) else: responses_path = sc.responses_path # load data self.datahandlers = [] for i in range(self.nevents): seismic_data_path = os.path.join( project_dir, bconfig.multi_event_seismic_data_name(i)) logger.info('Loading seismic data for event %i' ' from: %s ' % (i, seismic_data_path)) self.datahandlers.append( heart.init_datahandler(seismic_config=sc, seismic_data_path=seismic_data_path, responses_path=responses_path)) self.noise_analyser = cov.SeismicNoiseAnalyser( structure=sc.noise_estimator.structure, pre_arrival_time=sc.noise_estimator.pre_arrival_time, engine=self.engine, events=self.events, chop_bounds=['b', 'c']) self.wavemaps = [] for i, wc in enumerate(sc.waveforms): if wc.include: wmap = heart.init_wavemap( waveformfit_config=wc, datahandler=self.datahandlers[wc.event_idx], event=self.events[wc.event_idx], mapnumber=i) self.wavemaps.append(wmap) else: logger.info('The waveform defined in "%s %i" config is not ' 'included in the optimization!' % (wc.name, i)) if hypers: self._llks = [] for t in range(self.n_t): self._llks.append( shared(num.array([1.]), name='seis_llk_%i' % t, borrow=True)) def _hyper2wavemap(self, hypername): dummy = '_'.join(hypername.split('_')[1:-1]) for wmap in self.wavemaps: if wmap._mapid == dummy: return wmap raise ValueError('No waveform mapping found for hyperparameter! %s' % hypername) def get_hypersize(self, hp_name): """ Return size of the hyperparameter Parameters ---------- hp_name: str of hyperparameter name Returns ------- int """ if self.config.dataset_specific_residual_noise_estimation: wmap = self._hyper2wavemap(hp_name) return wmap.hypersize else: return 1 def __getstate__(self): self.engine.close_cashed_stores() return self.__dict__.copy() def analyse_noise(self, tpoint=None, chop_bounds=['b', 'c']): """ Analyse seismic noise in datatraces and set data-covariance matrixes accordingly. """ if self.config.noise_estimator.structure == 'non-toeplitz': results = self.assemble_results(tpoint, order='wmap', chop_bounds=chop_bounds) else: results = [None] * len(self.wavemaps) for wmap, wmap_results in zip(self.wavemaps, results): logger.info( 'Retrieving seismic data-covariances with structure "%s" ' 'for %s ...' % (self.config.noise_estimator.structure, wmap._mapid)) cov_ds_seismic = self.noise_analyser.get_data_covariances( wmap=wmap, results=wmap_results, sample_rate=self.config.gf_config.sample_rate, chop_bounds=chop_bounds) for j, trc in enumerate(wmap.datasets): if trc.covariance is None: trc.covariance = heart.Covariance(data=cov_ds_seismic[j]) else: trc.covariance.data = cov_ds_seismic[j] if int(trc.covariance.data.sum()) == trc.data_len(): logger.warning('Data covariance is identity matrix!' ' Please double check!!!') def init_hierarchicals(self, problem_config): """ Initialise random variables for temporal station corrections. """ hierarchicals = problem_config.hierarchicals self._hierarchicalnames = [] if not self.config.station_corrections and \ self.correction_name in hierarchicals: raise ConfigInconsistentError( 'Station corrections disabled, but they are defined' ' in the problem configuration!') if self.config.station_corrections and \ self.correction_name not in hierarchicals: raise ConfigInconsistentError( 'Station corrections enabled, but they are not defined' ' in the problem configuration!') if self.correction_name in hierarchicals: logger.info( 'Estimating time shift for each station and waveform map...') for wmap in self.wavemaps: hierarchical_name = wmap.time_shifts_id nhierarchs = len(wmap.get_station_names()) logger.info('For %s with %i shifts' % (hierarchical_name, nhierarchs)) if hierarchical_name in hierarchicals: logger.info('Using wavemap specific imported:' ' %s ' % hierarchical_name) param = hierarchicals[hierarchical_name] else: logger.info('Using global %s' % self.correction_name) param = copy.deepcopy( problem_config.hierarchicals[self.correction_name]) param.lower = num.repeat(param.lower, nhierarchs) param.upper = num.repeat(param.upper, nhierarchs) param.testvalue = num.repeat(param.testvalue, nhierarchs) if hierarchical_name not in self.hierarchicals: if not num.array_equal(param.lower, param.upper): kwargs = dict(name=hierarchical_name, shape=param.dimension, lower=param.lower, upper=param.upper, testval=param.testvalue, transform=None, dtype=tconfig.floatX) try: self.hierarchicals[hierarchical_name] = Uniform( **kwargs) except TypeError: kwargs.pop('name') self.hierarchicals[hierarchical_name] = \ Uniform.dist(**kwargs) self._hierarchicalnames.append(hierarchical_name) else: logger.info( 'not solving for %s, got fixed at %s' % (param.name, utility.list2string(param.lower.flatten()))) self.hierarchicals[hierarchical_name] = param.lower def export(self, point, results_path, stage_number, fix_output=False, force=False, update=False, chop_bounds=['b', 'c']): """ Save results for given point to result path. """ def save_covs(wmap, cov_mat='pred_v'): """ Save covariance matrixes of given attribute """ covs = { utility.list2string(dataset.nslc_id): getattr(dataset.covariance, cov_mat) for dataset in wmap.datasets } outname = os.path.join( results_path, '%s_C_%s_%s' % ('seismic', cov_mat, wmap._mapid)) logger.info('"%s" to: %s' % (wmap._mapid, outname)) num.savez(outname, **covs) from pyrocko import io # synthetics and data results = self.assemble_results(point, chop_bounds=chop_bounds) for traces, attribute in heart.results_for_export(results=results, datatype='seismic'): filename = '%s_%i.mseed' % (attribute, stage_number) outpath = os.path.join(results_path, filename) try: io.save(traces, outpath, overwrite=force) except io.mseed.CodeTooLong: if fix_output: for tr in traces: tr.set_station(tr.station[-5::]) tr.set_location( str(self.config.gf_config.reference_model_idx)) io.save(traces, outpath, overwrite=force) else: raise ValueError( 'Some station codes are too long! ' '(the --fix_output option will truncate to ' 'last 5 characters!)') # export stdz residuals self.analyse_noise(point, chop_bounds=chop_bounds) if update: logger.info('Saving velocity model covariance matrixes...') self.update_weights(point, chop_bounds=chop_bounds) for wmap in self.wavemaps: save_covs(wmap, 'pred_v') logger.info('Saving data covariance matrixes...') for wmap in self.wavemaps: save_covs(wmap, 'data') def init_weights(self): """ Initialise shared weights in wavemaps. """ logger.info('Initialising weights ...') for wmap in self.wavemaps: weights = [] for j, trc in enumerate(wmap.datasets): icov = trc.covariance.chol_inverse weights.append( shared(icov, name='seis_%s_weight_%i' % (wmap._mapid, j), borrow=True)) wmap.add_weights(weights) def get_all_station_names(self): """ Returns list of station names in the order of wavemaps. """ us = [] for wmap in self.wavemaps: us.extend(wmap.get_station_names()) return us def get_unique_time_shifts_ids(self): """ Return unique time_shifts ids from wavemaps, which are keys to hierarchical RVs of station corrections """ ts = [] for wmap in self.wavemaps: ts.append(wmap.time_shifts_id) return utility.unique_list(ts) def get_unique_station_names(self): """ Return unique station names from all wavemaps """ return utility.unique_list(self.get_all_station_names()) @property def n_t(self): return sum(wmap.n_t for wmap in self.wavemaps) @property def datasets(self): if self._datasets is None: ds = [] for wmap in self.wavemaps: ds.extend(wmap.datasets) self._datasets = ds return self._datasets @property def weights(self): if self._weights is None or len(self._weights) == 0: ws = [] for wmap in self.wavemaps: if wmap.weights: ws.extend(wmap.weights) self._weights = ws return self._weights @property def targets(self): if self._targets is None: ts = [] for wmap in self.wavemaps: ts.extend(wmap.targets) self._targets = ts return self._targets def assemble_results(self, point, chop_bounds=['a', 'd'], order='list', outmode='stacked_traces'): """ Assemble seismic traces for given point in solution space. Parameters ---------- point : :func:`pymc3.Point` Dictionary with model parameters Returns ------- List with :class:`heart.SeismicResult` """ if point is None: raise ValueError('A point has to be provided!') logger.debug('Assembling seismic waveforms ...') syn_proc_traces, obs_proc_traces = self.get_synthetics( point, outmode=outmode, chop_bounds=chop_bounds, order='wmap') # will yield exactly the same as previous call needs wmap.prepare data # to be aware of taper_tolerance_factor # DEPRECATED but keep for now # syn_filt_traces, obs_filt_traces = self.get_synthetics( # point, outmode=outmode, taper_tolerance_factor=0., # chop_bounds=chop_bounds, order='wmap') # syn_filt_traces, obs_filt_traces = syn_proc_traces, obs_proc_traces #from pyrocko import trace #trace.snuffle(syn_proc_traces + obs_proc_traces) results = [] for i, wmap in enumerate(self.wavemaps): wc = wmap.config at = wc.arrival_taper wmap_results = [] for j, obs_tr in enumerate(obs_proc_traces[i]): taper = at.get_pyrocko_taper(float(obs_tr.tmin - at.a)) if outmode != 'tapered_data': source_contributions = [syn_proc_traces[i][j]] else: source_contributions = syn_proc_traces[i][j] wmap_results.append( heart.SeismicResult( point=point, processed_obs=obs_tr, source_contributions=source_contributions, taper=taper)) if order == 'list': results.extend(wmap_results) elif order == 'wmap': results.append(wmap_results) else: raise ValueError('Order "%s" is not supported' % order) return results def update_llks(self, point): """ Update posterior likelihoods of the composite with respect to one point in the solution space. Parameters ---------- point : dict with numpy array-like items and variable name keys """ results = self.assemble_results(point, chop_bounds=['b', 'c']) for k, result in enumerate(results): choli = self.datasets[k].covariance.chol_inverse tmp = choli.dot(result.processed_res.ydata) _llk = num.asarray([num.dot(tmp, tmp)]) self._llks[k].set_value(_llk) def get_standardized_residuals(self, point, chop_bounds=['b', 'c']): """ Parameters ---------- point : dict with parameters to point in solution space to calculate standardized residuals Returns ------- dict of arrays of standardized residuals, keys are nslc_ids """ results = self.assemble_results(point, order='list', chop_bounds=chop_bounds) self.update_weights(point, chop_bounds=chop_bounds) counter = utility.Counter() hp_specific = self.config.dataset_specific_residual_noise_estimation stdz_res = OrderedDict() for data_trc, result in zip(self.datasets, results): hp_name = get_hyper_name(data_trc) if hp_specific: hp = point[hp_name][counter(hp_name)] else: hp = point[hp_name] choli = num.linalg.inv(data_trc.covariance.chol * num.exp(hp) / 2.) stdz_res[data_trc.nslc_id] = choli.dot( result.processed_res.get_ydata()) return stdz_res def get_variance_reductions(self, point, results=None, weights=None, chop_bounds=['a', 'd']): """ Parameters ---------- point : dict with parameters to point in solution space to calculate variance reductions Returns ------- dict of floats, keys are nslc_ids """ if results is None: results = self.assemble_results(point, order='list', chop_bounds=chop_bounds) ndatasets = len(self.datasets) assert len(results) == ndatasets if weights is None: self.analyse_noise(point, chop_bounds=chop_bounds) self.update_weights(point, chop_bounds=chop_bounds) weights = self.weights nweights = len(weights) assert nweights == ndatasets logger.debug('n weights %i , n datasets %i' % (nweights, ndatasets)) assert nweights == ndatasets logger.debug('Calculating variance reduction for solution ...') var_reds = OrderedDict() for data_trc, weight, result in zip(self.datasets, weights, results): icov = data_trc.covariance.inverse data = result.processed_obs.get_ydata() residual = result.processed_res.get_ydata() nom = residual.T.dot(icov).dot(residual) denom = data.T.dot(icov).dot(data) logger.debug('nom %f, denom %f' % (float(nom), float(denom))) var_red = 1 - (nom / denom) nslc_id = utility.list2string(data_trc.nslc_id) logger.debug('Variance reduction for %s is %f' % (nslc_id, var_red)) if 0: from matplotlib import pyplot as plt fig, ax = plt.subplots(1, 1) im = ax.imshow(data_trc.covariance.data) plt.colorbar(im) plt.show() var_reds[nslc_id] = var_red return var_reds
class SeismicComposite(Composite): """ Comprises how to solve the non-linear seismic forward model. Parameters ---------- sc : :class:`config.SeismicConfig` configuration object containing seismic setup parameters event: :class:`pyrocko.model.Event` project_dir : str directory of the model project, where to find the data hypers : boolean if true initialise object for hyper parameter optimization """ _datasets = None _weights = None _targets = None def __init__(self, sc, event, project_dir, hypers=False): super(SeismicComposite, self).__init__() logger.debug('Setting up seismic structure ...\n') self.name = 'seismic' self._like_name = 'seis_like' self.correction_name = 'time_shift' self.event = event self.engine = LocalEngine( store_superdirs=[sc.gf_config.store_superdir]) seismic_data_path = os.path.join( project_dir, bconfig.seismic_data_name) self.datahandler = heart.init_datahandler( seismic_config=sc, seismic_data_path=seismic_data_path) self.noise_analyser = cov.SeismicNoiseAnalyser( structure=sc.noise_estimator.structure, pre_arrival_time=sc.noise_estimator.pre_arrival_time, engine=self.engine, event=self.event, chop_bounds=['b', 'c']) self.wavemaps = [] for i, wc in enumerate(sc.waveforms): if wc.include: wmap = heart.init_wavemap( waveformfit_config=wc, datahandler=self.datahandler, event=event, mapnumber=i) self.wavemaps.append(wmap) else: logger.info( 'The waveform defined in "%s %i" config is not ' 'included in the optimization!' % (wc.name, i)) if hypers: self._llks = [] for t in range(self.n_t): self._llks.append( shared( num.array([1.]), name='seis_llk_%i' % t, borrow=True)) def __getstate__(self): self.engine.close_cashed_stores() return self.__dict__.copy() def analyse_noise(self, tpoint=None): """ Analyse seismic noise in datatraces and set data-covariance matrixes accordingly. """ if self.config.noise_estimator.structure == 'non-toeplitz': results = self.assemble_results( tpoint, order='wmap', chop_bounds=['b', 'c']) else: results = [None] * len(self.wavemaps) for wmap, wmap_results in zip(self.wavemaps, results): logger.info( 'Retrieving seismic data-covariances with structure "%s" ' 'for %s ...' % ( self.config.noise_estimator.structure, wmap._mapid)) cov_ds_seismic = self.noise_analyser.get_data_covariances( wmap=wmap, results=wmap_results, sample_rate=self.config.gf_config.sample_rate) for j, trc in enumerate(wmap.datasets): if trc.covariance is None: trc.covariance = heart.Covariance(data=cov_ds_seismic[j]) else: trc.covariance.data = cov_ds_seismic[j] if int(trc.covariance.data.sum()) == trc.data_len(): logger.warn('Data covariance is identity matrix!' ' Please double check!!!') def init_hierarchicals(self, problem_config): """ Initialise random variables for temporal station corrections. """ if not self.config.station_corrections and \ self.correction_name in problem_config.hierarchicals: raise ConfigInconsistentError( 'Station corrections disabled, but they are defined' ' in the problem configuration!') if self.config.station_corrections and \ self.correction_name not in problem_config.hierarchicals: raise ConfigInconsistentError( 'Station corrections enabled, but they are not defined' ' in the problem configuration!') if self.correction_name in problem_config.hierarchicals: nhierarchs = len(self.get_unique_stations()) param = problem_config.hierarchicals[self.correction_name] logger.info( 'Estimating time shift for each station...') kwargs = dict( name=self.correction_name, shape=nhierarchs, lower=num.repeat(param.lower, nhierarchs), upper=num.repeat(param.upper, nhierarchs), testval=num.repeat(param.testvalue, nhierarchs), transform=None, dtype=tconfig.floatX) try: station_corrs_rv = Uniform(**kwargs) except TypeError: kwargs.pop('name') station_corrs_rv = Uniform.dist(**kwargs) self.hierarchicals[self.correction_name] = station_corrs_rv else: nhierarchs = 0 def init_weights(self): """ Initialise shared weights in wavemaps. """ for wmap in self.wavemaps: weights = [] for j, trc in enumerate(wmap.datasets): icov = trc.covariance.chol_inverse weights.append( shared( icov, name='seis_%s_weight_%i' % (wmap._mapid, j), borrow=True)) wmap.add_weights(weights) def get_unique_stations(self): us = [] for wmap in self.wavemaps: us.extend(wmap.get_station_names()) return utility.unique_list(us) @property def n_t(self): return sum(wmap.n_t for wmap in self.wavemaps) @property def datasets(self): if self._datasets is None: ds = [] for wmap in self.wavemaps: ds.extend(wmap.datasets) self._datasets = ds return self._datasets @property def weights(self): if self._weights is None: ws = [] for wmap in self.wavemaps: ws.extend(wmap.weights) self._weights = ws return self._weights @property def targets(self): if self._targets is None: ts = [] for wmap in self.wavemaps: ts.extend(wmap.targets) self._targets = ts return self._targets def assemble_results( self, point, chop_bounds=['a', 'd'], order='list', outmode='stacked_traces'): """ Assemble seismic traces for given point in solution space. Parameters ---------- point : :func:`pymc3.Point` Dictionary with model parameters Returns ------- List with :class:`heart.SeismicResult` """ if point is None: raise ValueError('A point has to be provided!') logger.debug('Assembling seismic waveforms ...') syn_proc_traces, obs_proc_traces = self.get_synthetics( point, outmode=outmode, chop_bounds=chop_bounds, order='wmap') # will yield exactly the same as previous call needs wmap.prepare data # to be aware of taper_tolerance_factor syn_filt_traces, obs_filt_traces = self.get_synthetics( point, outmode=outmode, taper_tolerance_factor=0., chop_bounds=chop_bounds, order='wmap') results = [] for i, wmap in enumerate(self.wavemaps): wc = wmap.config at = wc.arrival_taper wmap_results = [] for j, obs_tr in enumerate(obs_proc_traces[i]): dtrace_proc = obs_tr.copy() dtrace_proc.set_ydata( (obs_tr.get_ydata() - syn_proc_traces[i][j].get_ydata())) dtrace_filt = obs_filt_traces[i][j].copy() dtrace_filt.set_ydata( (obs_filt_traces[i][j].get_ydata() - syn_filt_traces[i][j].get_ydata())) taper = at.get_pyrocko_taper( float(obs_tr.tmin - at.a)) wmap_results.append(heart.SeismicResult( processed_obs=obs_tr, processed_syn=syn_proc_traces[i][j], processed_res=dtrace_proc, filtered_obs=obs_filt_traces[i][j], filtered_syn=syn_filt_traces[i][j], filtered_res=dtrace_filt, taper=taper)) if order == 'list': results.extend(wmap_results) elif order == 'wmap': results.append(wmap_results) else: raise ValueError('Order "%s" is not supported' % order) return results def update_llks(self, point): """ Update posterior likelihoods of the composite with respect to one point in the solution space. Parameters ---------- point : dict with numpy array-like items and variable name keys """ results = self.assemble_results(point, chop_bounds=['b', 'c']) for k, result in enumerate(results): choli = self.datasets[k].covariance.chol_inverse tmp = choli.dot(result.processed_res.ydata) _llk = num.asarray([num.dot(tmp, tmp)]) self._llks[k].set_value(_llk)
def __init__(self, sc, event, project_dir, hypers=False): super(SeismicComposite, self).__init__() logger.debug('Setting up seismic structure ...\n') self.name = 'seismic' self._like_name = 'seis_like' self.correction_name = 'time_shift' self.event = event self.engine = LocalEngine( store_superdirs=[sc.gf_config.store_superdir]) seismic_data_path = os.path.join(project_dir, bconfig.seismic_data_name) self.datahandler = heart.init_datahandler( seismic_config=sc, seismic_data_path=seismic_data_path) self.wavemaps = [] for wc in sc.waveforms: if wc.include: wmap = heart.init_wavemap(waveformfit_config=wc, datahandler=self.datahandler, event=event) if sc.calc_data_cov: logger.info('Estimating seismic data-covariances ' 'for %s ...\n' % wmap.name) cov_ds_seismic = cov.seismic_data_covariance( data_traces=wmap.datasets, filterer=wc.filterer, sample_rate=sc.gf_config.sample_rate, arrival_taper=wc.arrival_taper, engine=self.engine, event=self.event, targets=wmap.targets) else: logger.info('No data-covariance estimation, using imported' ' covariances...\n') cov_ds_seismic = [] at = wc.arrival_taper n_samples = int( num.ceil(at.duration * sc.gf_config.sample_rate)) for trc in wmap.datasets: if trc.covariance is None: logger.warn('No data covariance given/estimated! ' 'Setting default: eye') cov_ds_seismic.append(num.eye(n_samples)) else: data_cov = trc.covariance.data if data_cov.shape[0] != n_samples: raise ValueError( 'Imported covariance %i does not agree ' ' with taper duration %i!' % (data_cov.shape[0], n_samples)) cov_ds_seismic.append(data_cov) weights = [] for t, trc in enumerate(wmap.datasets): trc.covariance = heart.Covariance(data=cov_ds_seismic[t]) if int(trc.covariance.data.sum()) == trc.data_len(): logger.warn('Data covariance is identity matrix!' ' Please double check!!!') icov = trc.covariance.chol_inverse weights.append( shared(icov, name='seis_%s_weight_%i' % (wc.name, t), borrow=True)) wmap.add_weights(weights) self.wavemaps.append(wmap) else: logger.info('The waveform defined in "%s" config is not ' 'included in the optimization!' % wc.name) if hypers: self._llks = [] for t in range(self.n_t): self._llks.append( shared(num.array([1.]), name='seis_llk_%i' % t, borrow=True))
class SeismicComposite(Composite): """ Comprises how to solve the non-linear seismic forward model. Parameters ---------- sc : :class:`config.SeismicConfig` configuration object containing seismic setup parameters event: :class:`pyrocko.model.Event` project_dir : str directory of the model project, where to find the data hypers : boolean if true initialise object for hyper parameter optimization """ _datasets = None _weights = None _targets = None def __init__(self, sc, event, project_dir, hypers=False): super(SeismicComposite, self).__init__() logger.debug('Setting up seismic structure ...\n') self.name = 'seismic' self._like_name = 'seis_like' self.correction_name = 'time_shift' self.event = event self.engine = LocalEngine( store_superdirs=[sc.gf_config.store_superdir]) seismic_data_path = os.path.join(project_dir, bconfig.seismic_data_name) self.datahandler = heart.init_datahandler( seismic_config=sc, seismic_data_path=seismic_data_path) self.wavemaps = [] for wc in sc.waveforms: if wc.include: wmap = heart.init_wavemap(waveformfit_config=wc, datahandler=self.datahandler, event=event) if sc.calc_data_cov: logger.info('Estimating seismic data-covariances ' 'for %s ...\n' % wmap.name) cov_ds_seismic = cov.seismic_data_covariance( data_traces=wmap.datasets, filterer=wc.filterer, sample_rate=sc.gf_config.sample_rate, arrival_taper=wc.arrival_taper, engine=self.engine, event=self.event, targets=wmap.targets) else: logger.info('No data-covariance estimation, using imported' ' covariances...\n') cov_ds_seismic = [] at = wc.arrival_taper n_samples = int( num.ceil(at.duration * sc.gf_config.sample_rate)) for trc in wmap.datasets: if trc.covariance is None: logger.warn('No data covariance given/estimated! ' 'Setting default: eye') cov_ds_seismic.append(num.eye(n_samples)) else: data_cov = trc.covariance.data if data_cov.shape[0] != n_samples: raise ValueError( 'Imported covariance %i does not agree ' ' with taper duration %i!' % (data_cov.shape[0], n_samples)) cov_ds_seismic.append(data_cov) weights = [] for t, trc in enumerate(wmap.datasets): trc.covariance = heart.Covariance(data=cov_ds_seismic[t]) if int(trc.covariance.data.sum()) == trc.data_len(): logger.warn('Data covariance is identity matrix!' ' Please double check!!!') icov = trc.covariance.chol_inverse weights.append( shared(icov, name='seis_%s_weight_%i' % (wc.name, t), borrow=True)) wmap.add_weights(weights) self.wavemaps.append(wmap) else: logger.info('The waveform defined in "%s" config is not ' 'included in the optimization!' % wc.name) if hypers: self._llks = [] for t in range(self.n_t): self._llks.append( shared(num.array([1.]), name='seis_llk_%i' % t, borrow=True)) def __getstate__(self): self.engine.close_cashed_stores() return self.__dict__.copy() def init_hierarchicals(self, problem_config): """ Initialise random variables for temporal station corrections. """ if not self.config.station_corrections and \ self.correction_name in problem_config.hierarchicals: raise ConfigInconsistentError( 'Station corrections disabled, but they are defined' ' in the problem configuration!') if self.config.station_corrections and \ self.correction_name not in problem_config.hierarchicals: raise ConfigInconsistentError( 'Station corrections enabled, but they are not defined' ' in the problem configuration!') if self.correction_name in problem_config.hierarchicals: nhierarchs = len(self.get_unique_stations()) param = problem_config.hierarchicals[self.correction_name] logger.info('Estimating time shift for each station...') kwargs = dict(name=self.correction_name, shape=nhierarchs, lower=num.repeat(param.lower, nhierarchs), upper=num.repeat(param.upper, nhierarchs), testval=num.repeat(param.testvalue, nhierarchs), transform=None, dtype=tconfig.floatX) try: station_corrs_rv = Uniform(**kwargs) except TypeError: kwargs.pop('name') station_corrs_rv = Uniform.dist(**kwargs) self.hierarchicals[self.correction_name] = station_corrs_rv else: nhierarchs = 0 def get_unique_stations(self): sl = [wmap.stations for wmap in self.wavemaps] us = [] map(us.extend, sl) return list(set(us)) @property def n_t(self): return sum(wmap.n_t for wmap in self.wavemaps) @property def datasets(self): if self._datasets is None: ds = [] for wmap in self.wavemaps: ds.extend(wmap.datasets) self._datasets = ds return self._datasets @property def weights(self): if self._weights is None: ws = [] for wmap in self.wavemaps: ws.extend(wmap.weights) self._weights = ws return self._weights @property def targets(self): if self._targets is None: ts = [] for wmap in self.wavemaps: ts.extend(wmap.targets) self._targets = ts return self._targets def assemble_results(self, point): """ Assemble seismic traces for given point in solution space. Parameters ---------- point : :func:`pymc3.Point` Dictionary with model parameters Returns ------- List with :class:`heart.SeismicResult` """ logger.debug('Assembling seismic waveforms ...') syn_proc_traces, obs_proc_traces = self.get_synthetics( point, outmode='stacked_traces') syn_filt_traces, obs_filt_traces = self.get_synthetics( point, outmode='stacked_traces', taper_tolerance_factor=2.) ats = [] for wmap in self.wavemaps: wc = wmap.config ats.extend(wmap.n_t * [wc.arrival_taper]) results = [] for i, (obs_tr, at) in enumerate(zip(obs_proc_traces, ats)): dtrace_proc = obs_tr.copy() dtrace_proc.set_ydata( (obs_tr.get_ydata() - syn_proc_traces[i].get_ydata())) dtrace_filt = obs_filt_traces[i].copy() dtrace_filt.set_ydata((obs_filt_traces[i].get_ydata() - syn_filt_traces[i].get_ydata())) taper = at.get_pyrocko_taper(float(obs_tr.tmin + num.abs(at.a))) results.append( heart.SeismicResult(processed_obs=obs_tr, processed_syn=syn_proc_traces[i], processed_res=dtrace_proc, filtered_obs=obs_filt_traces[i], filtered_syn=syn_filt_traces[i], filtered_res=dtrace_filt, taper=taper)) return results def update_llks(self, point): """ Update posterior likelihoods of the composite with respect to one point in the solution space. Parameters ---------- point : dict with numpy array-like items and variable name keys """ results = self.assemble_results(point) for k, result in enumerate(results): choli = self.datasets[k].covariance.chol_inverse tmp = choli.dot(result.processed_res.ydata) _llk = num.asarray([num.dot(tmp, tmp)]) self._llks[k].set_value(_llk)
def loadEngine(self, store, store_path): # load engine self.eng = LocalEngine(store_superdirs=store_path, default_store_id=store)
class patch: def __init__(self, name, ss, ds, east, north, down, length, width, strike, dip, sig_ss, sig_ds, sig_east, sig_north, sig_down, sig_length, sig_width, sig_strike, sig_dip, dist='Unif', connectivity=False, conservation=False): self.name = name self.ss, self.sss = ss, sig_ss self.ds, self.sds = ds, sig_ds self.x1, self.sx1 = north, sig_north # north top-left corner self.x2, self.sx2 = east, sig_east # east top-left corner self.x3, self.sx3 = down, sig_down self.l, self.sl = length, sig_length self.w, self.sw = width, sig_width self.strike, self.sstrike = strike, sig_strike self.dip, self.sdip = dip, sig_dip self.dist = dist self.connectivity = connectivity self.conservation = conservation # initiate variable self.connectindex = 0 # set uncertainties to 0 for connected patches if self.connectivity is not False: self.sstrike, self.sx3, self.sx2, self.sx1 = 0, 0, 0, 0 # create model vector self.param = ['{} strike slip'.format(self.name),'{} dip slip'.format(self.name),\ '{} north'.format(self.name),'{} east'.format(self.name),'{} down'.format(self.name),\ '{} length'.format(self.name),'{} width'.format(self.name),'{} strike'.format(self.name),\ '{} dip'.format(self.name)] self.m = self.tolist() self.sigmam = self.sigtolist() # self.mmin = list(map(operator.sub, self.m, self.sigmam)) # self.mmax = list(map(operator.add, self.m, self.sigmam)) # number of parameters per patch self.Mpatch = len(self.m) def connect(self, seg): # set strike self.strike = seg.strike # compute vertical distance and depth self.x3 = seg.x3 - self.w * math.sin(np.deg2rad(self.dip)) # compute horizontal distance yp = math.cos(np.deg2rad(self.dip)) * self.w east_shift = -math.cos(np.deg2rad(seg.strike)) * yp north_shift = math.sin(np.deg2rad(seg.strike)) * yp self.x2, self.x1 = seg.x2 + east_shift, seg.x1 + north_shift # set uncertainties to 0 # self.sstrike, self.sx3, self.sx2, self.sx1 = 0, 0, 0, 0 # update m vector !!!! dangerous !!!! self.m = self.tolist() # self.sigmam = self.sigtolist() def build_prior(self): self.sampled = [] self.fixed = [] self.priors = [] self.mmin, self.mmax = [], [] for name, m, sig in zip(self.param, self.m, self.sigmam): if sig > 0.: # print name, m-sig, m+sig self.mmin.append(m - sig), self.mmax.append(m + sig) if self.dist == 'Normal': p = pymc.Normal(name, mu=m, sd=sig) elif self.dist == 'Unif': p = pymc.Uniform(name, lower=m - sig, upper=m + sig, value=m) else: print( 'Problem with prior distribution difinition of parameter {}' .format(name)) sys.exit(1) self.sampled.append(name) self.priors.append(p) elif sig == 0: self.fixed.append(name) else: print('Problem with prior difinition of parameter {}'.format( name)) sys.exit(1) # number of free parameters per patch self.Mfree = len(self.sampled) def info(self): print "name segment:", self.name print "# ss ds x1(km) x2(km) x3(km) length(km) width(km) strike dip " print ' {:.2f} {:.2f} {:.1f} {:.1f} {:.2f} {:.2f} {:.2f} {:d} {:d}'.\ format(*(self.tolist())) print "#sigma_ss sigma_ds sigma_x1 sigma_x2 sigma_x3 sigma_length sigma_width sigma_strike sigma_dip " print ' {:.2f} {:.2f} {:.1f} {:.1f} {:.2f} {:.2f} {:.2f} {:d} {:d}'.\ format(*(self.sigtolist())) print def tolist(self): return [ self.ss, self.ds, self.x1, self.x2, self.x3, self.l, self.w, int(self.strike), int(self.dip) ] def sigtolist(self): return [ self.sss, self.sds, self.sx1, self.sx2, self.sx3, self.sl, self.sw, int(self.sstrike), int(self.sdip) ] def loadEngine(self, store, store_path): # load engine self.eng = LocalEngine(store_superdirs=store_path, default_store_id=store) def engine(self, target, ref): # print store_path, store # print ref[0], ref[1] # print self.x1*1000., self.x2*1000., self.x3*1000., self.w*1000., self.l*1000., self.dip, # print np.rad2deg(math.atan2(self.ds,self.ss)), self.strike, self.time, (self.ss**2+self.ds**2)**0.5 # print # print self.time self.source = RectangularSource( lon=ref[0], lat=ref[1], # distances in meters north_shift=np.float(self.x1 * 1000.), east_shift=np.float(self.x2 * 1000.), depth=np.float(self.x3 * 1000.), width=np.float(self.w * 1000.), length=np.float(self.l * 1000.), # angles in degree dip=np.float(self.dip), rake=np.float(np.rad2deg(math.atan2(self.ds, self.ss))), strike=np.float(self.strike), slip=np.float((self.ss**2 + self.ds**2)**0.5), time=self.time, anchor='top') # print self.source return self.eng.process(self.source, target)
from pyrocko.gf import LocalEngine, Target, DCSource, ws from pyrocko import trace from pyrocko.marker import PhaseMarker # The store we are going extract data from: store_id = 'landau_100hz' # First, download a Greens Functions store. If you already have one that you # would like to use, you can skip this step and point the *store_superdirs* in # the next step to that directory. # We need a pyrocko.gf.Engine object which provides us with the traces # extracted from the store. In this case we are going to use a local # engine since we are going to query a local store. engine = LocalEngine(store_superdirs=['/home/asteinbe/gf_stores']) from silvertine import scenario from pyrocko import model, cake, orthodrome from silvertine.util.ref_mods import landau_layered_model from silvertine.locate.locate1D import get_phases_list mod = landau_layered_model() scale = 2e-14 cake_phase = cake.PhaseDef("P") phase_list = [cake_phase] waveforms_events = [] waveforms_noise = [] stations = model.load_stations("stations.raw.txt") nstations = len(stations)*3
from pyrocko.marker import PhaseMarker # The store we are going extract data from: store_id = 'iceland_reg_v2' # First, download a Greens Functions store. If you already have one that you # would like to use, you can skip this step and point the *store_superdirs* in # the next step to that directory. if not os.path.exists(store_id): ws.download_gf_store(site='kinherd', store_id=store_id) # We need a pyrocko.gf.Engine object which provides us with the traces # extracted from the store. In this case we are going to use a local # engine since we are going to query a local store. engine = LocalEngine(store_superdirs=['.']) # Define a list of pyrocko.gf.Target objects, representing the recording # devices. In this case one station with a three component sensor will # serve fine for demonstation. channel_codes = 'ENZ' targets = [ Target( lat=10., lon=10., store_id=store_id, codes=('', 'STA', '', channel_code)) for channel_code in channel_codes] # Let's use a double couple source representation. source_dc = DCSource(
def plot(settings, show=False): # align_phase = 'P(cmb)P<(icb)(cmb)p' with_onset_line = False fill = True align_phase = "P" zoom_window = list(settings.zoom) ampl_scaler = "4*standard deviation" quantity = settings.quantity zstart, zstop, inkr = settings.depths.split(":") test_depths = num.arange( float(zstart) * km, float(zstop) * km, float(inkr) * km) try: traces = io.load(settings.trace_filename) except FileLoadError as e: logger.info(e) return event = model.load_events(settings.event_filename) assert len(event) == 1 event = event[0] event.depth = float(settings.depth) * 1000.0 base_source = MTSource.from_pyrocko_event(event) test_sources = [] for d in test_depths: s = base_source.clone() s.depth = float(d) test_sources.append(s) if settings.store_superdirs: engine = LocalEngine(store_superdirs=settings.store_superdirs) else: engine = LocalEngine(use_config=True) try: store = engine.get_store(settings.store_id) except seismosizer.NoSuchStore as e: logger.info("%s ... skipping." % e) return stations = model.load_stations(settings.station_filename) station = list( filter(lambda s: match_nslc("%s.%s.%s.*" % s.nsl(), traces[0].nslc_id), stations)) assert len(station) == 1 station = station[0] targets = [ station_to_target(station, quantity=quantity, store_id=settings.store_id) ] try: request = engine.process(targets=targets, sources=test_sources) except seismosizer.NoSuchStore as e: logger.info("%s ... skipping." % e) return except meta.OutOfBounds as error: if settings.force_nearest_neighbor: logger.warning("%s Using nearest neighbor instead." % error) mod_targets = [] for t in targets: closest_source = min(test_sources, key=lambda s: s.distance_to(t)) farthest_source = max(test_sources, key=lambda s: s.distance_to(t)) min_dist_delta = store.config.distance_min - closest_source.distance_to( t) max_dist_delta = (store.config.distance_max - farthest_source.distance_to(t)) if min_dist_delta < 0: azi, bazi = closest_source.azibazi_to(t) newlat, newlon = ortho.azidist_to_latlon( t.lat, t.lon, azi, min_dist_delta * cake.m2d) elif max_dist_delta < 0: azi, bazi = farthest_source.azibazi_to(t) newlat, newlon = ortho.azidist_to_latlon( t.lat, t.lon, azi, max_dist_delta * cake.m2d) t.lat, t.lon = newlat, newlon mod_targets.append(t) request = engine.process(targets=mod_targets, sources=test_sources) else: logger.error("%s: %s" % (error, ".".join(station.nsl()))) return alldepths = list(test_depths) fig = plt.figure() ax = fig.add_subplot(111) maxz = max(test_depths) minz = min(test_depths) relative_scale = (maxz - minz) * 0.02 for s, t, tr in request.iter_results(): if quantity == "velocity": tr = integrate_differentiate(tr, "differentiate") onset = engine.get_store(t.store_id).t("begin", (s.depth, s.distance_to(t))) tr = settings.do_filter(tr) if settings.normalize: tr.set_ydata(tr.get_ydata() / num.max(abs(tr.get_ydata()))) ax.tick_params(axis="y", which="both", left="off", right="off", labelleft="off") y_pos = s.depth xdata = tr.get_xdata() - onset - s.time tr_ydata = tr.get_ydata() * -1 visible = tr.chop( tmin=event.time + onset + zoom_window[0], tmax=event.time + onset + zoom_window[1], ) if ampl_scaler == "trace min/max": ampl_scale = float(max(abs(visible.get_ydata()))) elif ampl_scaler == "4*standard deviation": ampl_scale = 4 * float(num.std(visible.get_ydata())) else: ampl_scale = 1.0 ampl_scale /= settings.gain ydata = (tr_ydata / ampl_scale) * relative_scale + y_pos ax.plot(xdata, ydata, c="black", linewidth=1.0, alpha=1.0) if False: ax.fill_between(xdata, y_pos, ydata, where=ydata < y_pos, color="black", alpha=0.5) ax.text( zoom_window[0] * 1.09, y_pos, "%1.1f" % (s.depth / 1000.0), horizontalalignment="right", ) # , fontsize=12.) if False: mod = store.config.earthmodel_1d label = "pP" arrivals = mod.arrivals( phases=[cake.PhaseDef(label)], distances=[s.distance_to(t) * cake.m2d], zstart=s.depth, ) try: t = arrivals[0].t ydata_absmax = num.max(num.abs(tr.get_ydata())) marker_length = 0.5 x_marker = [t - onset] * 2 y = [ y_pos - (maxz - minz) * 0.025, y_pos + (maxz - minz) * 0.025 ] ax.plot(x_marker, y, linewidth=1, c="blue") ax.text( x_marker[1] - x_marker[1] * 0.005, y[1], label, # fontsize=12, color="black", verticalalignment="top", horizontalalignment="right", ) except IndexError: logger.warning( "no pP phase at d=%s z=%s stat=%s" % (s.distance_to(t) * cake.m2d, s.depth, station.station)) pass if len(traces) == 0: raise Exception("No Trace found!") if len(traces) > 1: raise Exception("More then one trace provided!") else: tr = traces[0] correction = float(settings.correction) if quantity == "displacement": tr = integrate_differentiate(tr, "integrate") tr = settings.do_filter(tr) onset = (engine.get_store(targets[0].store_id).t( "begin", (event.depth, s.distance_to(targets[0]))) + event.time) if settings.normalize: tr.set_ydata(tr.get_ydata() / max(abs(tr.get_ydata()))) ax.tick_params(axis="y", which="both", left="off", right="off", labelleft="off") y_pos = event.depth xdata = tr.get_xdata() - onset + correction tr_ydata = tr.get_ydata() * -1 visible = tr.chop( tmin=onset + zoom_window[0] + correction, tmax=onset + zoom_window[1] + correction, ) if ampl_scaler == "trace min/max": ampl_scale = float(max(abs(visible.get_ydata()))) elif ampl_scaler == "4*standard deviation": ampl_scale = 4 * float(num.std(visible.get_ydata())) else: ampl_scale = 1.0 ydata = (tr_ydata / ampl_scale * settings.gain * settings.gain_record) * relative_scale + y_pos ax.plot(xdata, ydata, c=settings.color, linewidth=1.0) ax.set_xlim(zoom_window) zmax = max(test_depths) zmin = min(test_depths) zrange = zmax - zmin ax.set_ylim((zmin - zrange * 0.2, zmax + zrange * 0.2)) ax.set_xlabel("Time [s]") ax.text( 0.0, 0.6, "Source depth [km]", rotation=90, horizontalalignment="left", transform=fig.transFigure, ) # , fontsize=12.) if fill: ax.fill_between(xdata, y_pos, ydata, where=ydata < y_pos, color=settings.color, alpha=0.5) if with_onset_line: ax.text(0.08, zmax + zrange * 0.1, align_phase, fontsize=14) vline = ax.axvline(0.0, c="black") vline.set_linestyle("--") if settings.title: params = { "array-id": "".join(station.nsl()), "event_name": event.name, "event_time": time_to_str(event.time), } ax.text( 0.5, 1.05, settings.title % params, horizontalalignment="center", transform=ax.transAxes, ) if settings.auto_caption: cax = fig.add_axes([0.0, 0.0, 1, 0.05], label="caption") cax.axis("off") cax.xaxis.set_visible(False) cax.yaxis.set_visible(False) if settings.quantity == "displacement": quantity_info = "integrated velocity trace. " if settings.quantity == "velocity": quantity_info = "differentiated synthetic traces. " if settings.quantity == "restituted": quantity_info = "restituted traces. " captions = {"filters": ""} for f in settings.filters: captions["filters"] += "%s-pass, order %s, f$_c$=%s Hz. " % ( f.type, f.order, f.corner, ) captions["quantity_info"] = quantity_info captions["store_sampling"] = 1.0 / store.config.deltat cax.text( 0, 0, "Filters: %(filters)s f$_{GF}$=%(store_sampling)s Hz.\n%(quantity_info)s" % captions, fontsize=12, transform=cax.transAxes, ) plt.subplots_adjust(hspace=0.4, bottom=0.15) else: plt.subplots_adjust(bottom=0.1) ax.invert_yaxis() if settings.save_as: logger.info("save as: %s " % settings.save_as) options = settings.__dict__ options.update({"array-id": "".join(station.nsl())}) fig.savefig(settings.save_as % options, dpi=160, bbox_inches="tight") if show: plt.show()
stftypes = n_eachstf * ['lognorm'] + n_eachstf * ['lognorm'] noise_types = n_eachstf * ['GR'] + n_eachstf * ['Gaussian'] # uniform depth of 20 km / 20,000m depths = n_seismograms * [20000] # seismometer target and the actual computation engine target = gf.Target(quantity='displacement', lat=0, lon=long, store_id=velocity_model, codes=('NET', 'STA', 'LOC', 'E'), tmin=tmin, tmax=tmax) engine = LocalEngine(store_dirs=[velocity_model]) # all of that for this! print('Creating synthetic seismograms...') seismograms, spectrograms = createSynthetics(moment_tensors, stfs, depths, target, engine) fin = { 'seismograms': seismograms, 'spectrograms': spectrograms, 'moment_tensors': [mt.m() for mt in moment_tensors], # dump the actual tensors 'strike_dip_rakes': [mt.both_strike_dip_rake() for mt in moment_tensors], 'source_mechanisms': source_mechanisms, 'depths': depths, 'noise_types': noise_types,
def doCalc (flag,Config,WaveformDict,FilterMetaData,Gmint,Gmaxt,TTTGridMap,Folder,Origin, ntimes, switch, ev,arrayfolder, syn_in): ''' method for calculating semblance of one station array ''' Logfile.add ('PROCESS %d %s' % (flag,' Enters Semblance Calculation') ) Logfile.add ('MINT : %f MAXT: %f Traveltime' % (Gmint,Gmaxt)) cfg = ConfigObj (dict=Config) dimX = cfg.dimX() # ('dimx') dimY = cfg.dimY() # ('dimy') winlen = cfg.winlen () # ('winlen') step = cfg.step() # ('step') new_frequence = cfg.newFrequency() #('new_frequence') forerun= cfg.Int('forerun') duration= cfg.Int('duration') gridspacing = cfg.Float('gridspacing') nostat = len (WaveformDict) traveltimes = {} recordstarttime = '' minSampleCount = 999999999 if cfg.UInt ('forerun')>0: ntimes = int ((cfg.UInt ('forerun') + cfg.UInt ('duration') ) / cfg.UInt ('step') ) else: ntimes = int ((cfg.UInt ('duration') ) / cfg.UInt ('step') ) nsamp = int (winlen * new_frequence) nstep = int (step * new_frequence) from pyrocko import obspy_compat from pyrocko import orthodrome, model obspy_compat.plant() ############################################################################ calcStreamMap = WaveformDict stations = [] py_trs = [] for trace in calcStreamMap.keys(): py_tr = obspy_compat.to_pyrocko_trace(calcStreamMap[trace]) py_trs.append(py_tr) for il in FilterMetaData: if str(il) == str(trace): szo = model.Station(lat=il.lat, lon=il.lon, station=il.sta, network=il.net, channels=py_tr.channel, elevation=il.ele, location=il.loc) stations.append(szo) #right number of stations? #==================================synthetic BeamForming======================================= if cfg.Bool('shift_by_phase_pws') == True: calcStreamMapshifted= calcStreamMap.copy() from obspy.core import stream stream = stream.Stream() for trace in calcStreamMapshifted.keys(): stream.append(calcStreamMapshifted[trace]) pws_stack = PWS_stack([stream], weight=2, normalize=True) for tr in pws_stack: for trace in calcStreamMapshifted.keys(): calcStreamMapshifted[trace]=tr calcStreamMap = calcStreamMapshifted if cfg.Bool('shift_by_phase_onset') == True: pjoin = os.path.join timeev = util.str_to_time(ev.time) trs_orgs= [] calcStreamMapshifted= calcStreamMap.copy() for trace in calcStreamMapshifted.keys(): tr_org = obspy_compat.to_pyrocko_trace(calcStreamMapshifted[trace]) trs_orgs.append(tr_org) timing = CakeTiming( phase_selection='first(p|P|PP|P(cmb)P(icb)P(icb)p(cmb)p)-20', fallback_time=100.) traces = trs_orgs event = model.Event(lat=float(ev.lat), lon=float(ev.lon), depth=ev.depth*1000., time=timeev) directory = arrayfolder bf = BeamForming(stations, traces, normalize=True) shifted_traces = bf.process(event=event, timing=timing, fn_dump_center=pjoin(directory, 'array_center.pf'), fn_beam=pjoin(directory, 'beam.mseed')) i = 0 store_id = syn_in.store() engine = LocalEngine(store_superdirs=[syn_in.store_superdirs()]) for trace in calcStreamMapshifted.keys(): recordstarttime = calcStreamMapshifted[trace].stats.starttime.timestamp recordendtime = calcStreamMapshifted[trace].stats.endtime.timestamp mod = shifted_traces[i] extracted = mod.chop(recordstarttime, recordendtime, inplace=False) shifted_obs_tr = obspy_compat.to_obspy_trace(extracted) calcStreamMapshifted[trace]=shifted_obs_tr i = i+1 calcStreamMap = calcStreamMapshifted weight = 0. if cfg.Bool('weight_by_noise') == True: from noise_analyser import analyse pjoin = os.path.join timeev = util.str_to_time(ev.time) trs_orgs= [] calcStreamMapshifted= calcStreamMap.copy() for trace in calcStreamMapshifted.keys(): tr_org = obspy_compat.to_pyrocko_trace(calcStreamMapshifted[trace]) trs_orgs.append(tr_org) timing = CakeTiming( phase_selection='first(p|P|PP|P(cmb)P(icb)P(icb)p(cmb)p)-20', fallback_time=100.) traces = trs_orgs event = model.Event(lat=float(ev.lat), lon=float(ev.lon), depth=ev.depth*1000., time=timeev) directory = arrayfolder bf = BeamForming(stations, traces, normalize=True) shifted_traces = bf.process(event=event, timing=timing, fn_dump_center=pjoin(directory, 'array_center.pf'), fn_beam=pjoin(directory, 'beam.mseed')) i = 0 store_id = syn_in.store() engine = LocalEngine(store_superdirs=[syn_in.store_superdirs()]) weight = analyse(shifted_traces, engine, event, stations, 100., store_id, nwindows=1, check_events=True, phase_def='P') for trace in calcStreamMap.keys(): recordstarttime = calcStreamMap[trace].stats.starttime d = calcStreamMap[trace].stats.starttime d = d.timestamp if calcStreamMap[trace].stats.npts < minSampleCount: minSampleCount = calcStreamMap[trace].stats.npts ############################################################################ traces = num.ndarray (shape=(len(calcStreamMap), minSampleCount), dtype=float) traveltime = num.ndarray (shape=(len(calcStreamMap), dimX*dimY), dtype=float) latv = num.ndarray (dimX*dimY, dtype=float) lonv = num.ndarray (dimX*dimY, dtype=float) ############################################################################ c=0 streamCounter = 0 for key in calcStreamMap.keys(): streamID = key c2 = 0 for o in calcStreamMap[key]: if c2 < minSampleCount: traces[c][c2] = o c2 += 1 for key in TTTGridMap.keys(): if streamID == key: traveltimes[streamCounter] = TTTGridMap[key] else: "NEIN", streamID, key if not streamCounter in traveltimes : continue #hs : thread crashed before g = traveltimes[streamCounter] dimZ = g.dimZ mint = g.mint maxt = g.maxt Latul = g.Latul Lonul = g.Lonul Lator = g.Lator Lonor = g.Lonor gridElem = g.GridArray for x in range(dimX): for y in range(dimY): elem = gridElem[x, y] traveltime [c][x * dimY + y] = elem.tt latv [x * dimY + y] = elem.lat lonv [x * dimY + y] = elem.lon #endfor c += 1 streamCounter += 1 #endfor # ==================================semblance calculation======= t1 = time.time() traces = traces.reshape(1, nostat*minSampleCount) traveltimes = traveltime.reshape(1, nostat*dimX*dimY) TTTGrid = True manual_shift = False if manual_shift: pjoin = os.path.join timeev = util.str_to_time(ev.time) trs_orgs = [] calcStreamMapshifted = calcStreamMap.copy() for trace in calcStreamMapshifted.keys(): tr_org = obspy_compat.to_pyrocko_trace( calcStreamMapshifted[trace]) trs_orgs.append(tr_org) timing = CakeTiming( phase_selection='first(p|P|PP|P(cmb)P(icb)P(icb)p(cmb)p)-20', fallback_time=100.) traces = trs_orgs backSemb = num.ndarray(shape=(ntimes, dimX*dimY), dtype=float) bf = BeamForming(stations, traces, normalize=True) for i in range(ntimes): sembmax = 0 sembmaxX = 0 sembmaxY = 0 for j in range(dimX * dimY): event = model.Event(lat=float(latv[j]), lon=float(lonv[j]), depth=ev.depth*1000., time=timeev) directory = arrayfolder shifted_traces, stack = bf.process(event=event, timing=timing, fn_dump_center=pjoin( directory, 'array_center.pf'), fn_beam=pjoin(directory, 'beam.mseed')) tmin = stack.tmin+(i*nstep)+20 tmax = stack.tmin+(i*nstep)+60 stack.chop(tmin, tmax) backSemb[i][j] = abs(sum(stack.ydata)) k = backSemb TTTGrid = False if TTTGrid: start_time = time.time() if cfg.UInt('forerun') > 0: ntimes = int((cfg.UInt('forerun') + cfg.UInt('duration'))/step) else: ntimes = int((cfg.UInt('duration')) / step) nsamp = int(winlen) nstep = int(step) Gmint = cfg.Int('forerun') k = semblance(maxp, nostat, nsamp, ntimes, nstep, dimX, dimY, Gmint, new_frequence, minSampleCount, latv, lonv, traveltimes, traces, calcStreamMap, timeev, Config, Origin) print("--- %s seconds ---" % (time.time() - start_time)) t2 = time.time() Logfile.add('%s took %0.3f s' % ('CALC:',(t2-t1))) partSemb = k partSemb = partSemb.reshape(ntimes, migpoints) return partSemb
def __init__(self, serve_dir): threading.Thread.__init__(self) self.engine = LocalEngine(store_dirs=[serve_dir]) self.s = server.Server('localhost', 32483, server.SeismosizerHandler, self.engine)
def plot(settings, show=False): #align_phase = 'P(cmb)P<(icb)(cmb)p' with_onset_line = False fill = True align_phase = 'P' zoom_window = settings.zoom ampl_scaler = '4*standard deviation' quantity = settings.quantity zstart, zstop, inkr = settings.depths.split(':') test_depths = num.arange( float(zstart) * km, float(zstop) * km, float(inkr) * km) try: traces = io.load(settings.trace_filename) except FileLoadError as e: logger.info(e) return event = model.load_events(settings.event_filename) assert len(event) == 1 event = event[0] event.depth = float(settings.depth) * 1000. base_source = MTSource.from_pyrocko_event(event) test_sources = [] for d in test_depths: s = base_source.clone() s.depth = float(d) test_sources.append(s) if settings.store_superdirs: engine = LocalEngine(store_superdirs=settings.store_superdirs) else: engine = LocalEngine(use_config=True) try: store = engine.get_store(settings.store_id) except seismosizer.NoSuchStore as e: logger.info('%s ... skipping.' % e) return stations = model.load_stations(settings.station_filename) station = filter( lambda s: match_nslc('%s.%s.%s.*' % s.nsl(), traces[0].nslc_id), stations) assert len(station) == 1 station = station[0] targets = [ station_to_target(station, quantity=quantity, store_id=settings.store_id) ] try: request = engine.process(targets=targets, sources=test_sources) except seismosizer.NoSuchStore as e: logger.info('%s ... skipping.' % e) return except meta.OutOfBounds as error: if settings.force_nearest_neighbor: logger.warning('%s Using nearest neighbor instead.' % error) mod_targets = [] for t in targets: closest_source = min(test_sources, key=lambda s: s.distance_to(t)) farthest_source = max(test_sources, key=lambda s: s.distance_to(t)) min_dist_delta = store.config.distance_min - closest_source.distance_to( t) max_dist_delta = store.config.distance_max - farthest_source.distance_to( t) if min_dist_delta < 0: azi, bazi = closest_source.azibazi_to(t) newlat, newlon = ortho.azidist_to_latlon( t.lat, t.lon, azi, min_dist_delta * cake.m2d) elif max_dist_delta < 0: azi, bazi = farthest_source.azibazi_to(t) newlat, newlon = ortho.azidist_to_latlon( t.lat, t.lon, azi, max_dist_delta * cake.m2d) t.lat, t.lon = newlat, newlon mod_targets.append(t) request = engine.process(targets=mod_targets, sources=test_sources) else: logger.error("%s: %s" % (error, ".".join(station.nsl()))) return alldepths = list(test_depths) depth_count = dict(zip(sorted(alldepths), range(len(alldepths)))) target_count = dict( zip([t.codes[:3] for t in targets], range(len(targets)))) fig = plt.figure() ax = fig.add_subplot(111) maxz = max(test_depths) minz = min(test_depths) relative_scale = (maxz - minz) * 0.02 for s, t, tr in request.iter_results(): if quantity == 'velocity': tr = integrate_differentiate(tr, 'differentiate') onset = engine.get_store(t.store_id).t('begin', (s.depth, s.distance_to(t))) tr = settings.do_filter(tr) if settings.normalize: tr.set_ydata(tr.get_ydata() / num.max(abs(tr.get_ydata()))) ax.tick_params(axis='y', which='both', left='off', right='off', labelleft='off') y_pos = s.depth xdata = tr.get_xdata() - onset - s.time tr_ydata = tr.get_ydata() * -1 visible = tr.chop(tmin=event.time + onset + zoom_window[0], tmax=event.time + onset + zoom_window[1]) if ampl_scaler == 'trace min/max': ampl_scale = float(max(abs(visible.get_ydata()))) elif ampl_scaler == '4*standard deviation': ampl_scale = 4 * float(num.std(visible.get_ydata())) else: ampl_scale = 1. ampl_scale /= settings.gain ydata = (tr_ydata / ampl_scale) * relative_scale + y_pos ax.plot(xdata, ydata, c='black', linewidth=1., alpha=1.) if False: ax.fill_between(xdata, y_pos, ydata, where=ydata < y_pos, color='black', alpha=0.5) ax.text(zoom_window[0] * 1.09, y_pos, '%1.1f' % (s.depth / 1000.), horizontalalignment='right') #, fontsize=12.) if False: mod = store.config.earthmodel_1d label = 'pP' arrivals = mod.arrivals(phases=[cake.PhaseDef(label)], distances=[s.distance_to(t) * cake.m2d], zstart=s.depth) try: t = arrivals[0].t ydata_absmax = num.max(num.abs(tr.get_ydata())) marker_length = 0.5 x_marker = [t - onset] * 2 y = [ y_pos - (maxz - minz) * 0.025, y_pos + (maxz - minz) * 0.025 ] ax.plot(x_marker, y, linewidth=1, c='blue') ax.text( x_marker[1] - x_marker[1] * 0.005, y[1], label, #fontsize=12, color='black', verticalalignment='top', horizontalalignment='right') except IndexError: logger.warning( 'no pP phase at d=%s z=%s stat=%s' % (s.distance_to(t) * cake.m2d, s.depth, station.station)) pass if len(traces) == 0: raise Exception('No Trace found!') if len(traces) > 1: raise Exception('More then one trace provided!') else: onset = 0 tr = traces[0] correction = float(settings.correction) if quantity == 'displacement': tr = integrate_differentiate(tr, 'integrate') tr = settings.do_filter(tr) onset = engine.get_store(targets[0].store_id).t( 'begin', (event.depth, s.distance_to(targets[0]))) + event.time if settings.normalize: tr.set_ydata(tr.get_ydata() / max(abs(tr.get_ydata()))) ax.tick_params(axis='y', which='both', left='off', right='off', labelleft='off') y_pos = event.depth xdata = tr.get_xdata() - onset + correction tr_ydata = tr.get_ydata() * -1 visible = tr.chop(tmin=onset + zoom_window[0] + correction, tmax=onset + zoom_window[1] + correction) if ampl_scaler == 'trace min/max': ampl_scale = float(max(abs(visible.get_ydata()))) elif ampl_scaler == '4*standard deviation': ampl_scale = 4 * float(num.std(visible.get_ydata())) else: ampl_scale = 1. ydata = (tr_ydata / ampl_scale * settings.gain * settings.gain_record) * relative_scale + y_pos ax.plot(xdata, ydata, c=settings.color, linewidth=1.) ax.set_xlim(zoom_window) zmax = max(test_depths) zmin = min(test_depths) zrange = zmax - zmin ax.set_ylim((zmin - zrange * 0.2, zmax + zrange * 0.2)) ax.set_xlabel('Time [s]') ax.text(0.0, 0.6, 'Source depth [km]', rotation=90, horizontalalignment='left', transform=fig.transFigure) #, fontsize=12.) if fill: ax.fill_between(xdata, y_pos, ydata, where=ydata < y_pos, color=settings.color, alpha=0.5) if with_onset_line: ax.text(0.08, zmax + zrange * 0.1, align_phase, fontsize=14) vline = ax.axvline(0., c='black') vline.set_linestyle('--') if settings.title: params = { 'array-id': ''.join(station.nsl()), 'event_name': event.name, 'event_time': time_to_str(event.time) } ax.text(0.5, 1.05, settings.title % params, horizontalalignment='center', transform=ax.transAxes) if settings.auto_caption: cax = fig.add_axes([0., 0., 1, 0.05], label='caption') cax.axis('off') cax.xaxis.set_visible(False) cax.yaxis.set_visible(False) if settings.quantity == 'displacement': quantity_info = 'integrated velocity trace. ' if settings.quantity == 'velocity': quantity_info = 'differentiated synthetic traces. ' if settings.quantity == 'restituted': quantity_info = 'restituted traces. ' captions = {'filters': ''} for f in settings.filters: captions['filters'] += '%s-pass, order %s, f$_c$=%s Hz. ' % ( f.type, f.order, f.corner) captions['quantity_info'] = quantity_info captions['store_sampling'] = 1. / store.config.deltat cax.text( 0, 0, 'Filters: %(filters)s f$_{GF}$=%(store_sampling)s Hz.\n%(quantity_info)s' % captions, fontsize=12, transform=cax.transAxes) plt.subplots_adjust(hspace=.4, bottom=0.15) else: plt.subplots_adjust(bottom=0.1) ax.invert_yaxis() if settings.save_as: logger.info('save as: %s ' % settings.save_as) options = settings.__dict__ options.update({'array-id': ''.join(station.nsl())}) fig.savefig(settings.save_as % options, dpi=160, bbox_inches='tight') if show: plt.show()
def load(self, inv): # load the data as a pyrocko pile and reform them into an array of traces data = pile.make_pile([self.wdir + self.reduction]) self.traces = data.all() # load station file fname = self.wdir + self.network stations_list = model.load_stations(fname) for s in stations_list: s.set_channels_by_name(*self.component.split()) self.targets = [] self.tmin, self.tmax = [], [] self.arrivals = [] self.names = [] for station, tr in zip(stations_list, self.traces): # iterate over all stations # print station.lat, station.lon target = Target( lat=np.float(station.lat), # station lat. lon=np.float(station.lon), # station lon. store_id=inv.store, # The gf-store to be used for this target, # we can also employ different gf-stores for different targets. interpolation='multilinear', # interp. method between gf cells quantity='displacement', # wanted retrieved quantity codes=station.nsl() + ('BH' + self.component, )) # Station and network code # Next we extract the expected arrival time for this station from the the store, # so we can use this later to define a cut-out window for the optimization: self.targets.append(target) self.names.append(station.nsl()[1]) # print len(self.traces), len(self.targets) for station, tr, target in zip(stations_list, self.traces, self.targets): engine = LocalEngine(store_superdirs=inv.store_path) store = engine.get_store(inv.store) # trace.snuffle(tr, events=self.events) arrival = store.t(self.phase, self.base_source, target) # expected P-wave arrival # print arrival tmin = self.base_source.time + arrival - 15 # start 15s before theor. arrival tmax = self.base_source.time + arrival + 15 # end 15s after theor. arrival # # print self.tmin,self.tmax tr.chop(tmin=tmin, tmax=tmax) self.tmin.append(tmin) self.tmax.append(tmax) self.arrivals.append(self.base_source.time + arrival) self.Npoints = len(self.targets) # data vector self.d = [] self.d.append(map((lambda x: getattr(x, 'ydata')), self.traces)) self.d = flatten(self.d) # time vector t = [] for i in xrange(self.Npoints): t.append(self.traces[i].get_xdata()) # self.t.append(map((lambda x: getattr(x,'get_xdata()')),self.traces)) # convert time self.t = time2dec(map(util.time_to_str, flatten(t))) # print self.t self.N = len(self.d)
def __init__(self): pass def check_snr(self): pass if __name__ == '__main__': '''usage example''' km = 1000. #fbands = [] #fbands.apppend([1.0, 2.0]) #fbands.apppend([2.0, 6.0]) #fbands.apppend([4.0, 10.]) phases = LocalEngine(store_superdirs=['/data/stores'], default_store_id='globalttt').get_store() #filenames = glob.glob('data/*.mseed') #filenames = glob.glob('/data/webnet/waveform_R/2008/*.mseed') #datapath = '/data/webnet/mseed/2008' #datapath = '/data/webnet/waveform_R/2008' #datapath = '/data/share/Res_all_NKC' datapath = '/media/usb0/Res_all_NKC_taper' #datapath = '/media/usb0/restituted_pyrocko' stations = model.load_stations('../data/stations.pf') reference_id = 'NKC' references = {} data_pile = pile.make_pile(datapath, selector='rest_*') fband = {'order': 4, 'corner_hp': 1.0, 'corner_lp': 4.} window = StaticLengthWindow(static_length=30., phase_position=0.5)
def doCalc_syn (flag,Config,WaveformDict,FilterMetaData,Gmint,Gmaxt,TTTGridMap, Folder,Origin, ntimes, switch, ev,arrayfolder, syn_in, parameter): ''' method for calculating semblance of one station array ''' Logfile.add ('PROCESS %d %s' % (flag,' Enters Semblance Calculation') ) Logfile.add ('MINT : %f MAXT: %f Traveltime' % (Gmint,Gmaxt)) cfg = ConfigObj (dict=Config) dimX = cfg.dimX() # ('dimx') dimY = cfg.dimY() # ('dimy') winlen = cfg.winlen () # ('winlen') step = cfg.step() # ('step') new_frequence = cfg.newFrequency() #('new_frequence') forerun= cfg.Int('forerun') duration= cfg.Int('duration') gridspacing = cfg.Float('gridspacing') nostat = len (WaveformDict) traveltimes = {} recordstarttime = '' minSampleCount = 999999999 if cfg.UInt ('forerun')>0: ntimes = int ((cfg.UInt ('forerun') + cfg.UInt ('duration') ) / cfg.UInt ('step') ) else: ntimes = int ((cfg.UInt ('duration') ) / cfg.UInt ('step') ) nsamp = int (winlen * new_frequence) nstep = int (step * new_frequence) from pyrocko import obspy_compat from pyrocko import orthodrome, model obspy_compat.plant() ############################################################################ calcStreamMap = WaveformDict stations = [] py_trs = [] for trace in calcStreamMap.keys(): py_tr = obspy_compat.to_pyrocko_trace(calcStreamMap[trace]) py_trs.append(py_tr) for il in FilterMetaData: if str(il) == str(trace): szo = model.Station(lat=il.lat, lon=il.lon, station=il.sta, network=il.net, channels=py_tr.channel, elevation=il.ele, location=il.loc) stations.append(szo) #right number of stations? store_id = syn_in.store() engine = LocalEngine(store_superdirs=[syn_in.store_superdirs()]) targets = [] for st in stations: target = Target( lat=st.lat, lon=st.lon, store_id=store_id, codes=(st.network, st.station, st.location, 'BHZ'), tmin=-1900, tmax=3900, interpolation='multilinear', quantity=cfg.quantity()) targets.append(target) if syn_in.nsources() == 1: if syn_in.use_specific_stf() is True: stf = syn_in.stf() exec(stf) else: stf = STF() if syn_in.source() == 'RectangularSource': source = RectangularSource( lat=float(syn_in.lat_0()), lon=float(syn_in.lon_0()), depth=syn_in.depth_syn_0()*1000., strike=syn_in.strike_0(), dip=syn_in.dip_0(), rake=syn_in.rake_0(), width=syn_in.width_0()*1000., length=syn_in.length_0()*1000., nucleation_x=syn_in.nucleation_x_0(), slip=syn_in.slip_0(), nucleation_y=syn_in.nucleation_y_0(), stf=stf, time=util.str_to_time(syn_in.time_0())) if syn_in.source() == 'DCSource': source = DCSource( lat=float(syn_in.lat_0()), lon=float(syn_in.lon_0()), depth=syn_in.depth_syn_0()*1000., strike=syn_in.strike_0(), dip=syn_in.dip_0(), rake=syn_in.rake_0(), stf=stf, time=util.str_to_time(syn_in.time_0()), magnitude=syn_in.magnitude_0()) else: sources = [] for i in range(syn_in.nsources()): if syn_in.use_specific_stf() is True: stf = syn_in.stf() exec(stf) else: stf = STF() if syn_in.source() == 'RectangularSource': sources.append(RectangularSource( lat=float(syn_in.lat_1(i)), lon=float(syn_in.lon_1(i)), depth=syn_in.depth_syn_1(i)*1000., strike=syn_in.strike_1(i), dip=syn_in.dip_1(i), rake=syn_in.rake_1(i), width=syn_in.width_1(i)*1000., length=syn_in.length_1(i)*1000., nucleation_x=syn_in.nucleation_x_1(i), slip=syn_in.slip_1(i), nucleation_y=syn_in.nucleation_y_1(i), stf=stf, time=util.str_to_time(syn_in.time_1(i)))) if syn_in.source() == 'DCSource': sources.append(DCSource( lat=float(syn_in.lat_1(i)), lon=float(syn_in.lon_1(i)), depth=syn_in.depth_1(i)*1000., strike=syn_in.strike_1(i), dip=syn_in.dip_1(i), rake=syn_in.rake_1(i), stf=stf, time=util.str_to_time(syn_in.time_1(i)), magnitude=syn_in.magnitude_1(i))) source = CombiSource(subsources=sources) response = engine.process(source, targets) synthetic_traces = response.pyrocko_traces() if cfg.Bool('synthetic_test_add_noise') is True: from noise_addition import add_noise trs_orgs = [] calcStreamMapsyn = calcStreamMap.copy() #from pyrocko import trace for tracex in calcStreamMapsyn.keys(): for trl in synthetic_traces: if str(trl.name()[4:12]) == str(tracex[4:]): tr_org = obspy_compat.to_pyrocko_trace(calcStreamMapsyn[tracex]) tr_org.downsample_to(2.0) trs_orgs.append(tr_org) store_id = syn_in.store() engine = LocalEngine(store_superdirs=[syn_in.store_superdirs()]) synthetic_traces = add_noise(trs_orgs, engine, source.pyrocko_event(), stations, store_id, phase_def='P') trs_org = [] trs_orgs = [] fobj = os.path.join(arrayfolder, 'shift.dat') xy = num.loadtxt(fobj, usecols=1, delimiter=',') calcStreamMapsyn = calcStreamMap.copy() #from pyrocko import trace for tracex in calcStreamMapsyn.keys(): for trl in synthetic_traces: if str(trl.name()[4:12])== str(tracex[4:]): mod = trl recordstarttime = calcStreamMapsyn[tracex].stats.starttime.timestamp recordendtime = calcStreamMapsyn[tracex].stats.endtime.timestamp tr_org = obspy_compat.to_pyrocko_trace(calcStreamMapsyn[tracex]) trs_orgs.append(tr_org) tr_org_add = mod.chop(recordstarttime, recordendtime, inplace=False) synthetic_obs_tr = obspy_compat.to_obspy_trace(tr_org_add) calcStreamMapsyn[tracex] = synthetic_obs_tr trs_org.append(tr_org_add) calcStreamMap = calcStreamMapsyn if cfg.Bool('shift_by_phase_pws') == True: calcStreamMapshifted= calcStreamMap.copy() from obspy.core import stream stream = stream.Stream() for trace in calcStreamMapshifted.keys(): stream.append(calcStreamMapshifted[trace]) pws_stack = PWS_stack([stream], weight=2, normalize=True) for tr in pws_stack: for trace in calcStreamMapshifted.keys(): calcStreamMapshifted[trace]=tr calcStreamMap = calcStreamMapshifted if cfg.Bool('shift_by_phase_onset') == True: pjoin = os.path.join timeev = util.str_to_time(ev.time) trs_orgs= [] calcStreamMapshifted= calcStreamMap.copy() for trace in calcStreamMapshifted.keys(): tr_org = obspy_compat.to_pyrocko_trace(calcStreamMapshifted[trace]) trs_orgs.append(tr_org) timing = CakeTiming( phase_selection='first(p|P|PP|P(cmb)P(icb)P(icb)p(cmb)p)-20', fallback_time=100.) traces = trs_orgs event = model.Event(lat=float(ev.lat), lon=float(ev.lon), depth=ev.depth*1000., time=timeev) directory = arrayfolder bf = BeamForming(stations, traces, normalize=True) shifted_traces = bf.process(event=event, timing=timing, fn_dump_center=pjoin(directory, 'array_center.pf'), fn_beam=pjoin(directory, 'beam.mseed')) i = 0 store_id = syn_in.store() engine = LocalEngine(store_superdirs=[syn_in.store_superdirs()]) for trace in calcStreamMapshifted.keys(): recordstarttime = calcStreamMapshifted[trace].stats.starttime.timestamp recordendtime = calcStreamMapshifted[trace].stats.endtime.timestamp mod = shifted_traces[i] extracted = mod.chop(recordstarttime, recordendtime, inplace=False) shifted_obs_tr = obspy_compat.to_obspy_trace(extracted) calcStreamMapshifted[trace]=shifted_obs_tr i = i+1 calcStreamMap = calcStreamMapshifted weight = 0. if cfg.Bool('weight_by_noise') == True: from noise_analyser import analyse pjoin = os.path.join timeev = util.str_to_time(ev.time) trs_orgs= [] calcStreamMapshifted= calcStreamMap.copy() for trace in calcStreamMapshifted.keys(): tr_org = obspy_compat.to_pyrocko_trace(calcStreamMapshifted[trace]) trs_orgs.append(tr_org) timing = CakeTiming( phase_selection='first(p|P|PP|P(cmb)P(icb)P(icb)p(cmb)p)-20', fallback_time=100.) traces = trs_orgs event = model.Event(lat=float(ev.lat), lon=float(ev.lon), depth=ev.depth*1000., time=timeev) directory = arrayfolder bf = BeamForming(stations, traces, normalize=True) shifted_traces = bf.process(event=event, timing=timing, fn_dump_center=pjoin(directory, 'array_center.pf'), fn_beam=pjoin(directory, 'beam.mseed')) i = 0 store_id = syn_in.store() engine = LocalEngine(store_superdirs=[syn_in.store_superdirs()]) weight = analyse(shifted_traces, engine, event, stations, 100., store_id, nwindows=1, check_events=True, phase_def='P') for trace in calcStreamMap.keys(): recordstarttime = calcStreamMap[trace].stats.starttime d = calcStreamMap[trace].stats.starttime d = d.timestamp if calcStreamMap[trace].stats.npts < minSampleCount: minSampleCount = calcStreamMap[trace].stats.npts ############################################################################ traces = num.ndarray (shape=(len(calcStreamMap), minSampleCount), dtype=float) traveltime = num.ndarray (shape=(len(calcStreamMap), dimX*dimY), dtype=float) latv = num.ndarray (dimX*dimY, dtype=float) lonv = num.ndarray (dimX*dimY, dtype=float) ############################################################################ c=0 streamCounter = 0 for key in calcStreamMap.keys(): streamID = key c2 = 0 for o in calcStreamMap[key]: if c2 < minSampleCount: traces[c][c2] = o c2 += 1 for key in TTTGridMap.keys(): if streamID == key: traveltimes[streamCounter] = TTTGridMap[key] else: "NEIN", streamID, key if not streamCounter in traveltimes : continue #hs : thread crashed before g = traveltimes[streamCounter] dimZ = g.dimZ mint = g.mint maxt = g.maxt Latul = g.Latul Lonul = g.Lonul Lator = g.Lator Lonor = g.Lonor gridElem = g.GridArray for x in range(dimX): for y in range(dimY): elem = gridElem[x, y] traveltime [c][x * dimY + y] = elem.tt latv [x * dimY + y] = elem.lat lonv [x * dimY + y] = elem.lon #endfor c += 1 streamCounter += 1 #endfor ############################## CALCULATE PARAMETER FOR SEMBLANCE CALCULATION ################## nsamp = winlen * new_frequence nstep = int (step*new_frequence) migpoints = dimX * dimY dimZ = 0 new_frequence = cfg.newFrequency () # ['new_frequence'] maxp = int (Config['ncore']) Logfile.add ('PROCESS %d NTIMES: %d' % (flag,ntimes)) if False : print ('nostat ',nostat,type(nostat)) print ('nsamp ',nsamp,type(nsamp)) print ('ntimes ',ntimes,type(ntimes)) print ('nstep ',nstep,type(nstep)) print ('dimX ',dimX,type(dimX)) print ('dimY ',dimY,type(dimY)) print ('mint ',Gmint,type(mint)) print ('new_freq ',new_frequence,type(new_frequence)) print ('minSampleCount ',minSampleCount,type(minSampleCount)) print ('latv ',latv,type(latv)) print ('traces',traces,type(traces)) print ('traveltime',traveltime,type(traveltime)) #==================================semblance calculation======================================== t1 = time.time() traces = traces.reshape (1,nostat*minSampleCount) traveltime = traveltime.reshape (1,nostat*dimX*dimY) USE_C_CODE = True try: if USE_C_CODE : import Cm import CTrig start_time = time.time() k = Cm.otest (maxp,nostat,nsamp,ntimes,nstep,dimX,dimY,Gmint,new_frequence, minSampleCount,latv,lonv,traveltime,traces) print("--- %s seconds ---" % (time.time() - start_time)) else : start_time = time.time() k = otest (maxp,nostat,nsamp,ntimes,nstep,dimX,dimY,Gmint,new_frequence, minSampleCount,latv,lonv,traveltime,traces) #hs print("--- %s seconds ---" % (time.time() - start_time)) except: print("loaded tttgrid has probably wrong dimensions or stations, delete\ ttgrid or exchange") t2 = time.time() partSemb = k partSemb_syn = partSemb.reshape (ntimes,migpoints) return partSemb_syn
def doCalc(flag, Config, WaveformDict, FilterMetaData, Gmint, Gmaxt, TTTGridMap, Folder, Origin, ntimes, switch, ev, arrayfolder, syn_in): ''' method for calculating semblance of one station array ''' Logfile.add('PROCESS %d %s' % (flag, ' Enters Semblance Calculation')) Logfile.add('MINT : %f MAXT: %f Traveltime' % (Gmint, Gmaxt)) cfg = ConfigObj(dict=Config) 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 invert(self, args): align_phase = 'P' ampl_scaler = '4*standard deviation' for array_id in self.provider.use: try: if args.array_id and array_id != args.array_id: continue except AttributeError: pass subdir = pjoin('array_data', array_id) settings_fn = pjoin(subdir, 'plot_settings.yaml') if os.path.isfile(settings_fn): settings = PlotSettings.load(filename=pjoin(settings_fn)) settings.update_from_args(self.args) else: logger.warn('no settings found: %s' % array_id) continue if settings.store_superdirs: engine = LocalEngine(store_superdirs=settings.store_superdirs) else: engine = LocalEngine(use_config=True) try: store = engine.get_store(settings.store_id) except seismosizer.NoSuchStore as e: logger.info('%s ... skipping.' % e) return try: store = engine.get_store(settings.store_id) except seismosizer.NoSuchStore as e: logger.info('%s ... skipping.' % e) return if not settings.trace_filename: settings.trace_filename = pjoin(subdir, 'beam.mseed') if not settings.station_filename: settings.station_filename = pjoin(subdir, 'array_center.pf') zoom_window = settings.zoom mod = store.config.earthmodel_1d zstart, zstop, inkr = settings.depths.split(':') test_depths = num.arange( float(zstart) * km, float(zstop) * km, float(inkr) * km) traces = io.load(settings.trace_filename) event = model.load_events(settings.event_filename) assert len(event) == 1 event = event[0] event.depth = float(settings.depth) * 1000. base_source = MTSource.from_pyrocko_event(event) test_sources = [] for d in test_depths: s = base_source.clone() s.depth = float(d) test_sources.append(s) stations = model.load_stations(settings.station_filename) station = filter( lambda s: match_nslc('%s.%s.%s.*' % s.nsl(), traces[0].nslc_id ), stations) if len(station) != 1: logger.error('no matching stations found. %s %s' % []) else: station = station[0] targets = [ station_to_target(station, quantity=settings.quantity, store_id=settings.store_id) ] try: request = engine.process(targets=targets, sources=test_sources) except seismosizer.NoSuchStore as e: logger.info('%s ... skipping.' % e) return except meta.OutOfBounds as error: if settings.force_nearest_neighbor: logger.warning('%s Using nearest neighbor instead.' % error) mod_targets = [] for t in targets: closest_source = min(test_sources, key=lambda s: s.distance_to(t)) farthest_source = max(test_sources, key=lambda s: s.distance_to(t)) min_dist_delta = store.config.distance_min - closest_source.distance_to( t) max_dist_delta = store.config.distance_max - farthest_source.distance_to( t) if min_dist_delta < 0: azi, bazi = closest_source.azibazi_to(t) newlat, newlon = ortho.azidist_to_latlon( t.lat, t.lon, azi, min_dist_delta * cake.m2d) elif max_dist_delta < 0: azi, bazi = farthest_source.azibazi_to(t) newlat, newlon = ortho.azidist_to_latlon( t.lat, t.lon, azi, max_dist_delta * cake.m2d) t.lat, t.lon = newlat, newlon mod_targets.append(t) request = engine.process(targets=mod_targets, sources=test_sources) else: raise error candidates = [] for s, t, tr in request.iter_results(): tr.deltat = regularize_float(tr.deltat) if True: tr = integrate_differentiate(tr, 'differentiate') tr = settings.do_filter(tr) candidates.append((s, tr)) assert len(traces) == 1 ref = traces[0] ref = settings.do_filter(ref) dist = ortho.distance_accurate50m(event, station) tstart = self.provider.timings[array_id].timings[0].t( mod, (event.depth, dist)) + event.time tend = self.provider.timings[array_id].timings[1].t( mod, (event.depth, dist)) + event.time ref = ref.chop(tstart, tend) misfits = [] center_freqs = num.arange(1., 9., 4.) num_f_widths = len(center_freqs) mesh_fc = num.zeros( len(center_freqs) * num_f_widths * len(candidates)) mesh_fwidth = num.zeros( len(center_freqs) * num_f_widths * len(candidates)) misfits_array = num.zeros( (len(center_freqs), num_f_widths, len(candidates))) depths_array = num.zeros( (len(center_freqs), num_f_widths, len(candidates))) debug = False pb = ProgressBar(maxval=max(center_freqs)).start() i = 0 for i_fc, fc in enumerate(center_freqs): if debug: fig = plt.figure() fl_min = fc - fc * 2. / 5. fr_max = fc + fc * 2. / 5. widths = num.linspace(fl_min, fr_max, num_f_widths) for i_width, width in enumerate(widths): i_candidate = 0 mesh_fc[i] = fc mesh_fwidth[i] = width i += 1 for source, candidate in candidates: candidate = candidate.copy() tstart = self.provider.timings[array_id].timings[0].t( mod, (source.depth, dist)) + event.time tend = self.provider.timings[array_id].timings[1].t( mod, (source.depth, dist)) + event.time filters = [ ButterworthResponse(corner=float(fc + width * 0.5), order=4, type='low'), ButterworthResponse(corner=float(fc - width * 0.5), order=4, type='high') ] settings.filters = filters candidate = settings.do_filter(candidate) candidate.chop(tmin=tstart, tmax=tend) candidate.shift(float(settings.correction)) m, n, aproc, bproc = ref.misfit( candidate=candidate, setup=settings.misfit_setup, debug=True) aproc.set_codes(station='aproc') bproc.set_codes(station='bproc') if debug: ax = fig.add_subplot( len(test_depths) + 1, 1, i + 1) ax.plot(aproc.get_xdata(), aproc.get_ydata()) ax.plot(bproc.get_xdata(), bproc.get_ydata()) mf = m / n #misfits.append((source.depth, mf)) misfits_array[i_fc][i_width][i_candidate] = mf i_candidate += 1 pb.update(fc) pb.finish() fig = plt.figure() ax = fig.add_subplot(111) i_best_fits = num.argmin(misfits_array, 2) print('best fits: \n', i_best_fits) best_fits = num.min(misfits_array, 2) #cmap = matplotlib.cm.get_cmap() xmesh, ymesh = num.meshgrid(mesh_fc, mesh_fwidth) #c = (best_fits-num.min(best_fits))/(num.max(best_fits)-num.min(best_fits)) ax.scatter(xmesh, ymesh, best_fits * 100) #ax.scatter(mesh_fc, mesh_fwidth, c) #ax.scatter(mesh_fc, mesh_fwidth, s=best_fits) ax.set_xlabel('fc') ax.set_ylabel('f_width') plt.legend() plt.show()
def generate_test_data_grid(store_id, store_dirs, coordinates, geometry_params, pre=0.5, post=3, stations_input=None, batch_loading=256, paths_disks=None): engine = LocalEngine(store_superdirs=[store_dirs]) store = engine.get_store(store_id) mod = store.config.earthmodel_1d cake_phase = cake.PhaseDef("P") phase_list = [cake_phase] waveforms_events = [] waveforms_events_uncut = [] waveforms_noise = [] sources = [] lats = coordinates[0] lons = coordinates[1] depths = coordinates[2] if stations_input is None: stations_unsorted = model.load_stations("data/stations.pf") else: stations_unsorted = model.load_stations(stations_input) for st in stations_unsorted: st.dist = orthodrome.distance_accurate50m(st.lat, st.lon, lats[0], lons[0]) st.azi = orthodrome.azimuth(st.lat, st.lon, lats[0], lons[0]) stations = sorted(stations_unsorted, key=lambda x: x.dist, reverse=True) targets = [] events = [] mean_lat = [] mean_lon = [] max_rho = 0. for st in stations: mean_lat.append(st.lat) mean_lon.append(st.lon) for cha in st.channels: if cha.name is not "R" and cha.name is not "T" and cha.name is not "Z": target = Target(lat=st.lat, lon=st.lon, store_id=store_id, interpolation='multilinear', quantity='displacement', codes=st.nsl() + (cha.name, )) targets.append(target) strikes = geometry_params[0] dips = geometry_params[1] rakes = geometry_params[2] vs = geometry_params[3] ws = geometry_params[4] grid_points = [] for lat in lats: for lon in lons: for depth in depths: grid_points.append([lat, lon, depth]) ray.init(num_cpus=num_cpus - 1) npm = len(lats) * len(lons) * len(depths) npm_geom = len(strikes) * len(dips) * len(rakes) results = ray.get([ get_parallel_mtqt.remote(i, targets, store_id, post, pre, stations, mod, grid_points[i], strikes, dips, rakes, vs, ws, store_dirs, batch_loading=batch_loading, npm=npm_geom, paths_disks=paths_disks) for i in range(len(grid_points)) ]) ray.shutdown() return waveforms_events
if envelope: cbar_label = 'Envelope ' + cbar_label cb = fig.colorbar(cmw, ax=ax, orientation='vertical', shrink=.8, pad=0.11) cb.set_label(cbar_label) if axes is None: plt.show() return resp __all__ = ['plot_directivity'] if __name__ == '__main__': engine = LocalEngine(store_superdirs=['.'], use_config=True) rect_source = RectangularSource(depth=2.6 * km, strike=240., dip=76.6, rake=-.4, anchor='top', nucleation_x=-.57, nucleation_y=-.59, velocity=2070., length=27 * km, width=9.4 * km, slip=1.4) resp = plot_directivity(engine, rect_source,
def get_parallel_mtqt(i, targets, store_id, post, pre, stations, mod, params, strikes, dips, rakes, vs, ws, store_dirs, batch_loading=192, npm=0, dump_full=False, seiger1f=False, path_count=0, paths_disks=None, con_line=True, max_rho=0., mag=-6): engine = LocalEngine(store_superdirs=[store_dirs]) store = engine.get_store(store_id) lat, lon, depth = params traces_uncuts = [] tracess = [] sources = [] mtqt_ps = [] count = 0 npm = len(strikes) * len(dips) * len(rakes) * len(vs) * len(ws) npm_rem = npm data_events = [] labels_events = [] events = [] if seiger1f is True: current_path = paths_disks[path_count] k = 0 for strike in strikes: for dip in dips: for rake in rakes: for v in vs: for w in ws: name = "scenario" + str(i) event = model.Event(name=name, lat=lat, lon=lon, magnitude=mag, depth=depth) kappa = strike sigma = rake h = dip source_mtqt = MTQTSource(lon=lon, lat=lat, depth=depth, w=w, v=v, kappa=kappa, sigma=sigma, h=h, magnitude=mag) response = engine.process(source_mtqt, targets) traces_synthetic = response.pyrocko_traces() event.moment_tensor = source_mtqt.pyrocko_moment_tensor( ) if dump_full is True: traces_uncut = copy.deepcopy(traces) traces_uncuts.append(traces_uncut) traces = [] for tr in traces_synthetic: for st in stations: if st.station == tr.station: processed = False dist = (orthodrome.distance_accurate50m( source_mtqt.lat, source_mtqt.lon, st.lat, st.lon) + st.elevation ) #*cake.m2d while processed is False: processed = False depth = source_mtqt.depth arrival = store.t('P', (depth, dist)) if processed is False: tr.chop(arrival - pre, arrival + post) traces.append(tr) processed = True else: pass nsamples = len(tr.ydata) rho = 1 mtqt_ps = [[rho, v, w, kappa, sigma, h]] data_event, nsamples = prepare_waveforms([traces]) label_event = prepare_labels([event], mtqt_ps) data_events.append(data_event) labels_events.append(label_event) events.append(event) if count == batch_loading or npm_rem < batch_loading: npm_rem = npm_rem - batch_loading k = k + 1 if seiger1f is True: free = os.statvfs(current_path)[ 0] * os.statvfs(current_path)[4] if free < 80000: current_path = paths_disks[path_count + 1] path_count = path_count + 1 f = open( current_path + "grid_%s_%s_%s_%s/batch_%s_grid_%s_SDR%s_%s_%s_%s_%s" % (store_id, lat, lon, int(depth), count, i, strike, dip, rake, v, w), 'ab') pickle.dump([ data_events, labels_events, nstations, nsamples, events ], f) f.close() else: util.ensuredir( "grids/grid_%s_%s_%s_%s/" % (store_id, lat, lon, int(depth))) f = open( "grids/grid_%s_%s_%s_%s/batch_%s_grid_%s_SDR%s_%s_%s_%s_%s" % (store_id, lat, lon, int(depth), count, i, strike, dip, rake, v, w), 'ab') pickle.dump([ data_events, labels_events, nsamples, events ], f) f.close() count = 0 data_events = [] labels_events = [] events = [] traces_uncuts = [] mtqt_ps = [] else: count = count + 1 return []
from pyrocko.gf import LocalEngine, RectangularSource, ws km = 1e3 # The store we are going extract data from: store_id = 'iceland_reg_v2' # First, download a Greens Functions store. If you already have one that you # would like to use, you can skip this step and point the *store_superdirs* in # the next step to that directory. if not os.path.exists(store_id): ws.download_gf_store(site='kinherd', store_id=store_id) # We need a pyrocko.gf.Engine object which provides us with the traces # extracted from the store. engine = LocalEngine(store_superdirs=['.']) # Create a RectangularSource with uniform fit. rect_source = RectangularSource(depth=1.6 * km, strike=240., dip=76.6, rake=-.4, anchor='top', nucleation_x=-.57, nucleation_y=-.59, velocity=2070., length=27 * km, width=9.4 * km, slip=1.4) resp = plot_directivity(engine,
import numpy as np import os pi = np.pi np.random.seed(1234) tf.random.set_seed(1234) # Use the following store directory store_dirs = "gf_stores/" # Use the following store id store_id = "mojavelargemlhf" engine = LocalEngine(store_superdirs=[store_dirs]) model = tf.keras.models.load_model( 'models/model_mechanism_single_gp_bnn_MT_mojavelargemlhf_5000.tf', compile=False) #model = tf.keras.models.load_model('/media/asteinbe/aki/models_halfwork/model_mojavelargemlhf_35.919999999999995_-117.68999999999997_4000', compile=False) # model compilation in seperate step because we use Tensorflow probability layers and loss model.compile(optimizer=Adam(), loss=cnn_util.loss_function_negative_log_likelihood()) # To be able to evaluate the neg-log likelihood given certaint input we also need to load the weights again #checkpoint_status = model.load_weights('models/model_weights_mechanism_single_gp_bnn_MT_mojavelargemlhf_5000') data_dir = "data_syn/events/" #data_dir="data/events/"
mod.profile('z') / 1000., label=label) ax.set_ylim([0, max_depth / 1000.]) if xlim: ax.set_xlim(xlim) ax.set_ylabel('Depth [km]') ax.set_xlabel('$v_p$ [km/s]') if combine and len(store_ids) > 1: ax.legend(fontsize=9) else: ax.set_title(label) ax.invert_yaxis() fig.savefig(out_filename, pad_inches=0.04, bbox_inches='tight') engine = LocalEngine(use_config=True) parameters = ['vp'] store_ids = ['castor_geres_4'] max_depth = 15000. xlim = (2, 9) # Can be receiver or source: store_id_mapping = ['Source Site'] out_filename = 'velocity_model_source.pdf' which = 'source' make_plot(which, store_ids, engine, parameters, out_filename, max_depth, xlim, store_id_mapping) ############################################## out_filename = 'velocity_models.pdf'
def plot(settings, show=False): #align_phase = 'P(cmb)P<(icb)(cmb)p' with_onset_line = False fill = True align_phase = 'P' zoom_window = settings.zoom ampl_scaler = '4*standard deviation' quantity = settings.quantity zstart, zstop, inkr = settings.depths.split(':') test_depths = num.arange(float(zstart)*km, float(zstop)*km, float(inkr)*km) try: traces = io.load(settings.trace_filename) except FileLoadError as e: logger.info(e) return event = model.load_events(settings.event_filename) assert len(event)==1 event = event[0] event.depth = float(settings.depth) * 1000. base_source = MTSource.from_pyrocko_event(event) test_sources = [] for d in test_depths: s = base_source.clone() s.depth = float(d) test_sources.append(s) if settings.store_superdirs: engine = LocalEngine(store_superdirs=settings.store_superdirs) else: engine = LocalEngine(use_config=True) try: store = engine.get_store(settings.store_id) except seismosizer.NoSuchStore as e: logger.info('%s ... skipping.' % e) return stations = model.load_stations(settings.station_filename) station = filter(lambda s: match_nslc('%s.%s.%s.*' % s.nsl(), traces[0].nslc_id), stations) assert len(station) == 1 station = station[0] targets = [station_to_target(station, quantity=quantity, store_id=settings.store_id)] try: request = engine.process(targets=targets, sources=test_sources) except seismosizer.NoSuchStore as e: logger.info('%s ... skipping.' % e) return except meta.OutOfBounds as error: if settings.force_nearest_neighbor: logger.warning('%s Using nearest neighbor instead.' % error) mod_targets = [] for t in targets: closest_source = min(test_sources, key=lambda s: s.distance_to(t)) farthest_source = max(test_sources, key=lambda s: s.distance_to(t)) min_dist_delta = store.config.distance_min - closest_source.distance_to(t) max_dist_delta = store.config.distance_max - farthest_source.distance_to(t) if min_dist_delta < 0: azi, bazi = closest_source.azibazi_to(t) newlat, newlon = ortho.azidist_to_latlon(t.lat, t.lon, azi, min_dist_delta*cake.m2d) elif max_dist_delta < 0: azi, bazi = farthest_source.azibazi_to(t) newlat, newlon = ortho.azidist_to_latlon(t.lat, t.lon, azi, max_dist_delta*cake.m2d) t.lat, t.lon = newlat, newlon mod_targets.append(t) request = engine.process(targets=mod_targets, sources=test_sources) else: logger.error("%s: %s" % (error, ".".join(station.nsl()))) return alldepths = list(test_depths) depth_count = dict(zip(sorted(alldepths), range(len(alldepths)))) target_count = dict(zip([t.codes[:3] for t in targets], range(len(targets)))) fig = plt.figure() ax = fig.add_subplot(111) maxz = max(test_depths) minz = min(test_depths) relative_scale = (maxz-minz)*0.02 for s, t, tr in request.iter_results(): if quantity=='velocity': tr = integrate_differentiate(tr, 'differentiate') onset = engine.get_store(t.store_id).t( 'begin', (s.depth, s.distance_to(t))) tr = settings.do_filter(tr) if settings.normalize: tr.set_ydata(tr.get_ydata()/num.max(abs(tr.get_ydata()))) ax.tick_params(axis='y', which='both', left='off', right='off', labelleft='off') y_pos = s.depth xdata = tr.get_xdata()-onset-s.time tr_ydata = tr.get_ydata() * -1 visible = tr.chop(tmin=event.time+onset+zoom_window[0], tmax=event.time+onset+zoom_window[1]) if ampl_scaler == 'trace min/max': ampl_scale = float(max(abs(visible.get_ydata()))) elif ampl_scaler == '4*standard deviation': ampl_scale = 4*float(num.std(visible.get_ydata())) else: ampl_scale = 1. ampl_scale /= settings.gain ydata = (tr_ydata/ampl_scale)*relative_scale + y_pos ax.plot(xdata, ydata, c='black', linewidth=1., alpha=1.) if False: ax.fill_between(xdata, y_pos, ydata, where=ydata<y_pos, color='black', alpha=0.5) ax.text(zoom_window[0]*1.09, y_pos, '%1.1f' % (s.depth/1000.), horizontalalignment='right') #, fontsize=12.) if False: mod = store.config.earthmodel_1d label = 'pP' arrivals = mod.arrivals(phases=[cake.PhaseDef(label)], distances=[s.distance_to(t)*cake.m2d], zstart=s.depth) try: t = arrivals[0].t ydata_absmax = num.max(num.abs(tr.get_ydata())) marker_length = 0.5 x_marker = [t-onset]*2 y = [y_pos-(maxz-minz)*0.025, y_pos+(maxz-minz)*0.025] ax.plot(x_marker, y, linewidth=1, c='blue') ax.text(x_marker[1]-x_marker[1]*0.005, y[1], label, #fontsize=12, color='black', verticalalignment='top', horizontalalignment='right') except IndexError: logger.warning('no pP phase at d=%s z=%s stat=%s' % (s.distance_to(t)*cake.m2d, s.depth, station.station)) pass if len(traces)==0: raise Exception('No Trace found!') if len(traces)>1: raise Exception('More then one trace provided!') else: onset = 0 tr = traces[0] correction = float(settings.correction) if quantity=='displacement': tr = integrate_differentiate(tr, 'integrate') tr = settings.do_filter(tr) onset = engine.get_store(targets[0].store_id).t( 'begin', (event.depth, s.distance_to(targets[0]))) + event.time if settings.normalize: tr.set_ydata(tr.get_ydata()/max(abs(tr.get_ydata()))) ax.tick_params(axis='y', which='both', left='off', right='off', labelleft='off') y_pos = event.depth xdata = tr.get_xdata()-onset+correction tr_ydata = tr.get_ydata() *-1 visible = tr.chop(tmin=onset+zoom_window[0]+correction, tmax=onset+zoom_window[1]+correction) if ampl_scaler == 'trace min/max': ampl_scale = float(max(abs(visible.get_ydata()))) elif ampl_scaler == '4*standard deviation': ampl_scale = 4*float(num.std(visible.get_ydata())) else: ampl_scale = 1. ydata = (tr_ydata/ampl_scale * settings.gain*settings.gain_record)*relative_scale + y_pos ax.plot(xdata, ydata, c=settings.color, linewidth=1.) ax.set_xlim(zoom_window) zmax = max(test_depths) zmin = min(test_depths) zrange = zmax - zmin ax.set_ylim((zmin-zrange*0.2, zmax+zrange*0.2)) ax.set_xlabel('Time [s]') ax.text(0.0, 0.6, 'Source depth [km]', rotation=90, horizontalalignment='left', transform=fig.transFigure) #, fontsize=12.) if fill: ax.fill_between(xdata, y_pos, ydata, where=ydata<y_pos, color=settings.color, alpha=0.5) if with_onset_line: ax.text(0.08, zmax+zrange*0.1, align_phase, fontsize=14) vline = ax.axvline(0., c='black') vline.set_linestyle('--') if settings.title: params = {'array-id': ''.join(station.nsl()), 'event_name': event.name, 'event_time': time_to_str(event.time)} ax.text(0.5, 1.05, settings.title % params, horizontalalignment='center', transform=ax.transAxes) if settings.auto_caption: cax = fig.add_axes([0., 0., 1, 0.05], label='caption') cax.axis('off') cax.xaxis.set_visible(False) cax.yaxis.set_visible(False) if settings.quantity == 'displacement': quantity_info = 'integrated velocity trace. ' if settings.quantity == 'velocity': quantity_info = 'differentiated synthetic traces. ' if settings.quantity == 'restituted': quantity_info = 'restituted traces. ' captions = {'filters':''} for f in settings.filters: captions['filters'] += '%s-pass, order %s, f$_c$=%s Hz. '%(f.type, f.order, f.corner) captions['quantity_info'] = quantity_info captions['store_sampling'] = 1./store.config.deltat cax.text(0, 0, 'Filters: %(filters)s f$_{GF}$=%(store_sampling)s Hz.\n%(quantity_info)s' % captions, fontsize=12, transform=cax.transAxes) plt.subplots_adjust(hspace=.4, bottom=0.15) else: plt.subplots_adjust(bottom=0.1) ax.invert_yaxis() if settings.save_as: logger.info('save as: %s ' % settings.save_as) options = settings.__dict__ options.update({'array-id': ''.join(station.nsl())}) fig.savefig(settings.save_as % options, dpi=160, bbox_inches='tight') if show: plt.show()