def test_source_dict(self): s1 = gf.DCSource(strike=0.) s1.strike = 10. s2 = s1.clone(strike=20.) s2.update(strike=30.) s2['strike'] = 40. d = dict(s2) s3 = gf.DCSource(**d) s3.strike
def test_qssp_build_2020_rotational(self): qssp.init(self.tmpdir, '2020', config_params=dict(stored_quantity='rotation', source_depth_max=10e3, distance_min=500e3, distance_max=600e3)) store = gf.store.Store(self.tmpdir, 'r') store.make_ttt() qssp.build(self.tmpdir) del store engine = gf.LocalEngine(store_dirs=[self.tmpdir]) source = gf.DCSource(lat=0., lon=0., depth=10e3, magnitude=6.0) targets = [ gf.Target(quantity='rotation', codes=('', 'ROT', '', comp), lat=0., lon=0., north_shift=500e3, east_shift=100e3) for comp in 'NEZ' ] engine.process(source, targets)
def test_sgrid2(self): expect = [10., 12., 14., 16., 18., 20.] source = gf.DCSource() sgrid = source.grid(dip=gf.Range(10, 20, 2)) dips = [] for source in sgrid: dips.append(source.dip) num.testing.assert_array_almost_equal(dips, expect) source = gf.DCSource(dip=10) sgrid = source.grid(dip=gf.Range(1, 2, 0.2, relative='mult')) dips = [] for source in sgrid: dips.append(source.dip) num.testing.assert_array_almost_equal(dips, expect)
def test_sgrid(self): r = gf.Range source = gf.DCSource() sgrid = source.grid(rake=r(-10, 10, 1), strike=r(-100, 100, n=21), depth=r('0k .. 100k : 10k'), moment=r(1, 2, 1)) sgrid = guts.load_string(sgrid.dump()) n = len(sgrid) i = 0 for source in sgrid: i += 1 assert i == n
def test_static_timing(self): src_length = 5 * km src_width = 2 * km nstations = 100 day = 3600 * 24 interp = ['nearest_neighbor', 'multilinear'] interpolation = interp[0] source = gf.RectangularSource( lat=0., lon=0., north_shift=0., east_shift=0., depth=6.5*km, width=src_width, length=src_length, dip=90., rake=90., strike=90., slip=1., time=time.time()-day) source = gf.DCSource( lat=0., lon=0., north_shift=0., east_shift=0., depth=6.5*km, dip=90., rake=90., strike=90., time=time.time()-day) lats = random.uniform(-.2, .2, nstations) lons = random.uniform(-.2, .2, nstations) target_1 = gf.StaticTarget( lats=lats, lons=lons, interpolation=interpolation, tsnapshot=time.time() + day) target_2 = gf.StaticTarget( lats=lats, lons=lons, interpolation=interpolation, tsnapshot=time.time()) engine = gf.LocalEngine(store_dirs=[self.get_store_dir('pscmp')]) res = engine.process(source, [target_1, target_2], nprocs=0)\ statics_1, statics_2 = res.static_results() num.testing.assert_equal( statics_1.result['displacement.n'], statics_2.result['displacement.n'])
def get_source(self, ievent): rstate = self.get_rstate(ievent) time = rstate.uniform(self.time_min, self.time_max) lat, lon, north_shift, east_shift, depth = self.get_coordinates(ievent) depth = rstate.uniform(self.depth_min, self.depth_max) magnitude = self.draw_magnitude(rstate) if self.strike is None and self.dip is None and self.rake is None: mt = moment_tensor.MomentTensor.random_dc(x=rstate.uniform(size=3)) else: if None in (self.strike, self.dip, self.rake): raise ScenarioError( 'DCSourceGenerator: ' 'strike, dip, and rake must be used in combination.') mt = moment_tensor.MomentTensor(strike=self.strike, dip=self.dip, rake=self.rake) if self.perturbation_angle_std is not None: mt = mt.random_rotated(self.perturbation_angle_std, rstate=rstate) (s, d, r), (_, _, _) = mt.both_strike_dip_rake() source = gf.DCSource(name='ev%04i' % ievent, time=float(time), lat=float(lat), lon=float(lon), north_shift=float(north_shift), east_shift=float(east_shift), depth=float(depth), magnitude=float(magnitude), strike=float(s), dip=float(d), rake=float(r)) return source
def _off_test_synthetic(self): from pyrocko import gf km = 1000. nstations = 10 edepth = 5 * km store_id = 'crust2_d0' swin = 2. lwin = 9. * swin ks = 1.0 kl = 1.0 kd = 3.0 engine = gf.get_engine() snorths = (num.random.random(nstations) - 1.0) * 50 * km seasts = (num.random.random(nstations) - 1.0) * 50 * km targets = [] for istation, (snorths, seasts) in enumerate(zip(snorths, seasts)): targets.append( gf.Target(quantity='displacement', codes=('', 's%03i' % istation, '', 'Z'), north_shift=float(snorths), east_shift=float(seasts), store_id=store_id, interpolation='multilinear')) source = gf.DCSource(north_shift=50 * km, east_shift=50 * km, depth=edepth) store = engine.get_store(store_id) response = engine.process(source, targets) trs = [] station_traces = defaultdict(list) station_targets = defaultdict(list) for source, target, tr in response.iter_results(): tp = store.t('any_P', source, target) t = tp - 5 * tr.deltat + num.arange(11) * tr.deltat if False: gauss = trace.Trace(tmin=t[0], deltat=tr.deltat, ydata=num.exp(-((t - tp)**2) / ((2 * tr.deltat)**2))) tr.ydata[:] = 0.0 tr.add(gauss) trs.append(tr) station_traces[target.codes[:3]].append(tr) station_targets[target.codes[:3]].append(target) station_stalta_traces = {} for nsl, traces in station_traces.items(): etr = None for tr in traces: sqr_tr = tr.copy(data=False) sqr_tr.ydata = tr.ydata**2 if etr is None: etr = sqr_tr else: etr += sqr_tr autopick.recursive_stalta(swin, lwin, ks, kl, kd, etr) etr.set_codes(channel='C') station_stalta_traces[nsl] = etr trace.snuffle(trs + list(station_stalta_traces.values())) deltat = trs[0].deltat nnorth = 50 neast = 50 size = 200 * km north = num.linspace(-size, size, nnorth) north2 = num.repeat(north, neast) east = num.linspace(-size, size, neast) east2 = num.tile(east, nnorth) depth = 5 * km def tcal(target, i): try: return store.t( 'any_P', gf.Location(north_shift=north2[i], east_shift=east2[i], depth=depth), target) except gf.OutOfBounds: return 0.0 nsls = sorted(station_stalta_traces.keys()) tts = num.fromiter((tcal(station_targets[nsl][0], i) for i in range(nnorth * neast) for nsl in nsls), dtype=num.float) arrays = [ station_stalta_traces[nsl].ydata.astype(num.float) for nsl in nsls ] offsets = num.array([ int(round(station_stalta_traces[nsl].tmin / deltat)) for nsl in nsls ], dtype=num.int32) shifts = -num.array([int(round(tt / deltat)) for tt in tts], dtype=num.int32).reshape(nnorth * neast, nstations) weights = num.ones((nnorth * neast, nstations)) print(shifts[25 * neast + 25] * deltat) print(offsets.dtype, shifts.dtype, weights.dtype) print('stack start') mat, ioff = parstack(arrays, offsets, shifts, weights, 1) print('stack stop') mat = num.reshape(mat, (nnorth, neast)) from matplotlib import pyplot as plt fig = plt.figure() axes = fig.add_subplot(1, 1, 1, aspect=1.0) axes.contourf(east / km, north / km, mat) axes.plot( g(targets, 'east_shift') / km, g(targets, 'north_shift') / km, '^') axes.plot(source.east_shift / km, source.north_shift / km, 'o') plt.show()
def call(self): '''Main work routine of the snuffling.''' self.cleanup() olat = 0. olon = 0. f = (0., 0., 0.) deltat = 1./self.fsampling if self.stf == 'Gauss': stf = Gauss(self.tau) elif self.stf == 'Impulse': stf = Impulse() viewer = self.get_viewer() event = viewer.get_active_event() if event: event, stations = self.get_active_event_and_stations(missing='warn') else: event = model.Event(lat=olat, lon=olon) stations = [] if not stations: s = model.Station(lat=olat, lon=olon, station='AFG') stations = [s] viewer.add_stations(stations) source = gf.DCSource( time=event.time+self.time, lat=event.lat, lon=event.lon, north_shift=self.north_km*km, east_shift=self.east_km*km, depth=self.depth_km*km, magnitude=moment_tensor.moment_to_magnitude(self.moment), strike=self.strike, dip=self.dip, rake=self.rake) source.regularize() m = EventMarker(source.pyrocko_event()) self.add_marker(m) targets = [] mt = moment_tensor.MomentTensor( strike=source.strike, dip=source.dip, rake=source.rake, moment=self.moment) traces = [] for station in stations: xyz = (self.north_km*km, self.east_km*km, self.depth_km*km) r = num.sqrt(xyz[0]**2 + xyz[1]**2 + xyz[2]**2) ns = math.ceil(r/self.vs/1.6)*2 outx = num.zeros(int(ns)) outy = num.zeros(int(ns)) outz = num.zeros(int(ns)) nsl = station.nsl() quantity = self.quantity.split()[0].lower() add_seismogram( self.vp*km, self.vs*km, self.density, self.qp, self.qs, xyz, f, mt.m6(), quantity, deltat, 0., outx, outy, outz, stf=stf, want_near=self.want_near, want_intermediate=self.want_intermediate, want_far=self.want_far) for channel, out in zip('NEZ', [outx, outy, outz]): tr = trace.Trace('', station.station, '', channel, deltat=deltat, tmin=source.time, ydata=out) traces.append(tr) self.add_traces(traces)
def test_calc_timeseries(self): from pyrocko.gf import store_ext benchmark.show_factor = True rstate = num.random.RandomState(123) def test_timeseries(store, source, dim, ntargets, interpolation, nthreads, niter=1, random_itmin=False, random_nsamples=False): source = gf.RectangularSource(lat=0., lon=0., depth=3 * km, length=dim, width=dim, anchor='top') targets = [ gf.Target(lat=rstate.uniform(), lon=rstate.uniform()) for x in range(ntargets) ] dsource = source.discretize_basesource(store, targets[0]) source_coords_arr = dsource.coords5() mts_arr = dsource.m6s receiver_coords_arr = num.empty((len(targets), 5)) for itarget, target in enumerate(targets): receiver = target.receiver(store) receiver_coords_arr[itarget, :] = \ [receiver.lat, receiver.lon, receiver.north_shift, receiver.east_shift, receiver.depth] nsources = mts_arr.shape[0] delays = num.zeros(nsources) itmin = num.zeros(ntargets, dtype=num.int32) nsamples = num.full(ntargets, -1, dtype=num.int32) if random_itmin: itmin = num.random.randint(-20, 5, size=ntargets, dtype=num.int32) if random_nsamples: nsamples = num.random.randint(10, 100, size=ntargets, dtype=num.int32) @benchmark.labeled('calc_timeseries-%s' % interpolation) def calc_timeseries(): return store_ext.store_calc_timeseries( store.cstore, source_coords_arr, mts_arr, delays, receiver_coords_arr, 'elastic10', interpolation, itmin, nsamples, nthreads) @benchmark.labeled('sum_timeseries-%s' % interpolation) def sum_timeseries(): results = [] for itarget, target in enumerate(targets): params = store_ext.make_sum_params( store.cstore, source_coords_arr, mts_arr, target.coords5[num.newaxis, :].copy(), 'elastic10', interpolation, nthreads) for weights, irecords in params: d = num.zeros(irecords.shape[0], dtype=num.float32) r = store_ext.store_sum(store.cstore, irecords, d, weights, int(itmin[itarget]), int(nsamples[itarget])) results.append(r) return results for _ in range(niter): res_calc = calc_timeseries() for _ in range(niter): res_sum = sum_timeseries() for c, s in zip(res_calc, res_sum): num.testing.assert_equal(c[0], s[0], verbose=True) for cc, cs in zip(c[1:-1], s[1:]): continue assert cc == cs store = gf.Store(self.get_pulse_store_dir()) store.open() sources = [ gf.DCSource(lat=0., lon=0., depth=1 * km, magnitude=8.), gf.RectangularSource(lat=0., lon=0., anchor='top', depth=5 * km, width=10 * km, length=20 * km) ] for source in sources: for interp in ['multilinear', 'nearest_neighbor']: for random_itmin in [True, False]: for random_nsamples in [True, False]: test_timeseries(store, source, dim=10 * km, niter=1, ntargets=20, interpolation=interp, nthreads=0, random_itmin=random_itmin, random_nsamples=random_nsamples) print(benchmark) benchmark.clear() def plot(res): import matplotlib.pyplot as plt plt.plot(res[0]) plt.show()
def __init__(self, *args, **kwargs): SandboxSource.__init__(self, *args, **kwargs) self.pyrocko_source = gf.DCSource(**self._src_args)
def test_regional(self): engine = gf.get_engine() store_id = 'crust2_mf' try: engine.get_store(store_id) except gf.NoSuchStore: logger.warn('GF Store %s not available - skipping test' % store_id) return nsources = 10 nstations = 10 print 'cache source channels par wallclock seismograms_per_second' nprocs_max = multiprocessing.cpu_count() for sourcetype, channels in [ ['point', 'Z'], ['point', 'NEZ'], ['rect', 'Z'], ['rect', 'NEZ']]: for nprocs in [1, 2, 4, 8, 16, 32]: if nprocs > nprocs_max: continue sources = [] for isource in xrange(nsources): m = pmt.MomentTensor.random_dc() strike, dip, rake = map(float, m.both_strike_dip_rake()[0]) if sourcetype == 'point': source = gf.DCSource( north_shift=rand(-20.*km, 20*km), east_shift=rand(-20.*km, 20*km), depth=rand(10*km, 20*km), strike=strike, dip=dip, rake=rake, magnitude=rand(4.0, 5.0)) elif sourcetype == 'rect': source = gf.RectangularSource( north_shift=rand(-20.*km, 20*km), east_shift=rand(-20.*km, 20*km), depth=rand(10*km, 20*km), length=10*km, width=5*km, nucleation_x=0., nucleation_y=-1., strike=strike, dip=dip, rake=rake, magnitude=rand(4.0, 5.0)) else: assert False sources.append(source) targets = [] for istation in xrange(nstations): dist = rand(40.*km, 900*km) azi = rand(-180., 180.) north_shift = dist * math.cos(azi*d2r) east_shift = dist * math.sin(azi*d2r) for cha in channels: target = gf.Target( codes=('', 'S%04i' % istation, '', cha), north_shift=north_shift, east_shift=east_shift, quantity='displacement', interpolation='multilinear', optimization='enable', store_id=store_id) targets.append(target) ntraces = len(targets) * len(sources) for temperature in ['cold', 'hot']: t0 = time.time() resp = engine.process(sources, targets, nprocs=nprocs) # print resp.stats t1 = time.time() duration = t1 - t0 sps = ntraces / duration if temperature == 'hot': if nprocs == 1: sps_ref = sps print '%-5s %-6s %-8s %3i %9.3f %12.1f %12.1f' % ( temperature, sourcetype, channels, nprocs, t1-t0, sps, sps/sps_ref) del resp
from matplotlib import transforms, pyplot as plt from pyrocko import gf from pyrocko.plot import beachball # create source object source1 = gf.DCSource(depth=35e3, strike=0., dip=90., rake=0.) # set size of beachball sz = 20. # set beachball offset in points (one point from each axis) szpt = (sz / 2.) / 72. + 1. / 72. fig = plt.figure(figsize=(10., 4.)) ax = fig.add_subplot(1, 1, 1) ax.set_xlim(0, 10) ax.set_ylim(0, 10) # get the bounding point (left-top) x0 = ax.get_xlim()[0] y1 = ax.get_ylim()[1] # create a translation matrix, based on the final figure size and # beachball location move_trans = transforms.ScaledTranslation(szpt, -szpt, fig.dpi_scale_trans) # get the inverse matrix for the axis where the beachball will be plotted inv_trans = ax.transData.inverted() # set the bouding point relative to the plotted axis of the beachball x0, y1 = inv_trans.transform( move_trans.transform(ax.transData.transform((x0, y1))))
#sources = [ # gf.MTSource( # lat=10.0, # lon=lat, # depth=depth, # mnn=1., # mee=0.3, # mdd=0.1, # mne=0., # med=0., # mnd=0.) for depth in [5e3, 10e3, 15e3] for lat in [11.0,11.1,11.2]] sources = [ gf.DCSource(lat=10.0, lon=10.0, depth=depth, magnitude=magnitude, strike=33., dip=80., rake=5.) for depth in [5e3, 10e3, 15e3] for magnitude in [5., 6., 7.] ] targets = [ gf.Target( codes=('', 'STA', '', component), lat=11.0, lon=10.0, store_id='local1', ) for component in 'NEZ' ] print targets[0].codes