def oldloadf(file):
d = {}
try:
for line in file:
if line.lstrip().startswith('#'):
continue
toks = line.split(' = ', 1)
if len(toks) == 2:
k, v = toks[0].strip(), toks[1].strip()
if k in ('name', 'region', 'catalog', 'magnitude_type'):
d[k] = v
if k in (('latitude longitude magnitude depth duration '
'north_shift east_shift '
'mnn mee mdd mne mnd med strike1 dip1 rake1 '
'strike2 dip2 rake2 duration').split()):
d[k] = float(v)
if k == 'time':
d[k] = util.str_to_time(v)
if k == 'tags':
d[k] = [x.strip() for x in v.split(',')]
if line.startswith('---'):
d['have_separator'] = True
break
except Exception as e:
raise FileParseError(e)
if not d:
raise EOF()
if 'have_separator' in d and len(d) == 1:
raise EmptyEvent()
mt = None
m6 = [d[x] for x in 'mnn mee mdd mne mnd med'.split() if x in d]
if len(m6) == 6:
mt = moment_tensor.MomentTensor(m=moment_tensor.symmat6(*m6))
else:
sdr = [d[x] for x in 'strike1 dip1 rake1'.split() if x in d]
if len(sdr) == 3:
moment = 1.0
if 'moment' in d:
moment = d['moment']
elif 'magnitude' in d:
moment = moment_tensor.magnitude_to_moment(d['magnitude'])
mt = moment_tensor.MomentTensor(strike=sdr[0],
dip=sdr[1],
rake=sdr[2],
scalar_moment=moment)
return (d.get('latitude', 0.0), d.get('longitude', 0.0),
d.get('north_shift', 0.0), d.get('east_shift', 0.0),
d.get('time', 0.0), d.get('name', ''), d.get('depth', None),
d.get('magnitude', None), d.get('magnitude_type',
None), d.get('region', None),
d.get('catalog', None), mt, d.get('duration',
None), d.get('tags', []))
def preconstrain(self, x):
d = self.get_parameter_dict(x)
m6 = num.array([d.rmnn, d.rmee, d.rmdd, d.rmne, d.rmnd, d.rmed],
dtype=num.float)
m9 = mtm.symmat6(*m6)
if self.mt_type == 'deviatoric':
trace_m = num.trace(m9)
m_iso = num.diag([trace_m / 3., trace_m / 3., trace_m / 3.])
m9 -= m_iso
elif self.mt_type == 'dc':
mt = mtm.MomentTensor(m=m9)
m9 = mt.standard_decomposition()[1][2]
m0_unscaled = math.sqrt(num.sum(m9.A**2)) / math.sqrt(2.)
m9 /= m0_unscaled
m6 = mtm.to6(m9)
d.rmnn, d.rmee, d.rmdd, d.rmne, d.rmnd, d.rmed = m6
x = self.get_parameter_array(d)
source = self.get_source(x)
for t in self.targets:
if (self.distance_min > num.asarray(t.distance_to(source))).any():
raise Forbidden()
return x
def test_random_mts(self):
nx = 2
for x in range(nx):
m6 = num.random.random(6)*2.-1.
m = mtm.symmat6(*m6)
mt = mtm.MomentTensor(m=m)
self.compare_beachball(mt)
def createMT_CLVD(mag):
exp = mtm.magnitude_to_moment(mag)
# init pyrocko moment tensor
cvld_matrix = np.array([[1, 0, 0], [0, 1, 0], [0, 0, -2]]) * exp
rotated_matrix = mtm.random_rotation() * cvld_matrix
return mtm.MomentTensor(rotated_matrix)
def get_all_scn_mechs():
mechs = np.loadtxt("ridgecrest/scn_plot.mech", dtype="str")
dates = []
strikes = []
rakes = []
dips = []
depths = []
lats = []
lons = []
events = []
for i in mechs:
dates.append(i[1][0:4] + "-" + i[1][5:7] + "-" + i[1][8:] + " " + i[2])
strikes.append(float(i[16]))
dips.append(float(i[17]))
rakes.append(float(i[18]))
lats.append(float(i[7]))
lons.append(float(i[8]))
depths.append(float(i[9]))
mt = pmt.MomentTensor(strike=float(i[16]),
dip=float(i[17]),
rake=float(i[18]),
magnitude=float(i[5]))
event = model.event.Event(
lat=float(i[7]),
lon=float(i[8]),
depth=float(i[9]),
moment_tensor=mt,
magnitude=float(i[5]),
time=util.str_to_time(i[1][0:4] + "-" + i[1][5:7] + "-" +
i[1][8:] + " " + i[2]))
events.append(event)
return events
def testIOEvent(self):
tempdir = tempfile.mkdtemp(prefix='pyrocko-model')
fn = pjoin(tempdir, 'event.txt')
e1 = model.Event(10.,
20.,
1234567890.,
'bubu',
depth=10.,
region='taka tuka land',
moment_tensor=moment_tensor.MomentTensor(strike=45.,
dip=90),
magnitude=5.1,
magnitude_type='Mw',
tags=['cluster:-1', 'custom_magnitude:2.5'])
guts.dump(e1, filename=fn)
e2 = guts.load(filename=fn)
assert e1.region == e2.region
assert e1.name == e2.name
assert e1.lat == e2.lat
assert e1.lon == e2.lon
assert e1.time == e2.time
assert e1.region == e2.region
assert e1.magnitude == e2.magnitude
assert e1.magnitude_type == e2.magnitude_type
assert e1.get_hash() == e2.get_hash()
assert e1.tags == e2.tags
fn2 = pjoin(tempdir, 'events.txt')
guts.dump_all([e1, e2], filename=fn2)
with self.assertRaises(model.OneEventRequired):
model.load_one_event(fn2)
shutil.rmtree(tempdir)
def __init__(self, *args):
QFrame.__init__(self, *args)
self._mt = mtm.MomentTensor(m=mtm.symmat6(1., -1., 2., 0., -2., 1.))
setupdata = [(LinValControl, 'Strike 1', 0., 360., 0., 0),
(LinValControl, 'Dip 1', 0., 90., 0., 1),
(LinValControl, 'Slip-Rake 1', -180., 180., 0., 2),
(LinValControl, 'Strike 2', 0., 360., 0., 3),
(LinValControl, 'Dip 2', 0., 90., 0., 4),
(LinValControl, 'Slip-Rake 2', -180., 180., 0., 5)]
layout = QGridLayout()
self.setLayout(layout)
val_controls = []
for irow, (typ, name, vmin, vmax, vcur, ind) in enumerate(setupdata):
val_control = typ()
val_control.setup(name, vmin, vmax, vcur, ind)
val_controls.append(val_control)
for icol, widget in enumerate(val_control.widgets()):
layout.addWidget(widget, irow, icol)
self.connect(val_control, SIGNAL('valchange(PyQt_PyObject,int)'),
self.valchange)
self.val_controls = val_controls
self.adjust_values()
def deco_part(mt, mt_type='full', view='top'):
assert view in ('top', 'north', 'south', 'east', 'west'),\
'Allowed views are top, north, south, east and west'
mt = mtm.as_mt(mt)
if view == 'top':
pass
elif view == 'north':
mt = mt.rotated(_view_north)
elif view == 'south':
mt = mt.rotated(_view_south)
elif view == 'east':
mt = mt.rotated(_view_east)
elif view == 'west':
mt = mt.rotated(_view_west)
if mt_type == 'full':
return mt
res = mt.standard_decomposition()
m = dict(
dc=res[1][2],
deviatoric=res[3][2])[mt_type]
return mtm.MomentTensor(m=m)
def test_specific_dcs(self):
for strike, dip, rake in [[270., 0.0, 0.01],
[360., 28.373841741182012, 90.],
[0., 0., 0.]]:
mt = mtm.MomentTensor(strike=strike, dip=dip, rake=rake)
self.compare_beachball(mt)
def mxy2mt(M):
mt = pmt.MomentTensor(mnn=M[0],
mee=M[1],
mdd=M[2],
mne=M[3],
mnd=M[4],
med=M[5])
return mt
def deco_part(mt, mt_type='full'):
mt = mtm.as_mt(mt)
if mt_type == 'full':
return mt
res = mt.standard_decomposition()
m = dict(dc=res[1][2], deviatoric=res[3][2])[mt_type]
return mtm.MomentTensor(m=m)
def test_specific_mts(self):
for m6 in [(1., 0., 0., 0., 0., 0.), (0., 1., 0., 0., 0., 0.),
(0., 0., 1., 0., 0., 0.), (0., 0., 0., 1., 0., 0.),
(0., 0., 0., 0., 1., 0.), (0., 0., 0., 0., 0., 1.)]:
m = mtm.symmat6(*m6)
mt = mtm.MomentTensor(m=m)
self.compare_beachball(mt)
def valchange(self, val, ind):
strike, dip, rake = [
val_control.get_value() for val_control in self.val_controls[:3]
]
self._mt = mtm.MomentTensor(strike=strike, dip=dip, rake=rake)
self.adjust_values()
self.emit(SIGNAL('moment_tensor_changed(PyQt_PyObject)'), self._mt)
def valchange(self, val, ind):
strike, dip, rake = [
val_control.get_value() for val_control in self.val_controls[:3]]
self._mt = mtm.MomentTensor(
strike=strike, dip=dip, rake=rake)
self.adjust_values()
self.moment_tensor_changed.emit(
self._mt)
def test_random_mts(self, **kwargs):
nx = 10
for x in range(nx):
m6 = num.random.random(6) * 2. - 1.
m = mtm.symmat6(*m6)
mt = mtm.MomentTensor(m=m)
self.compare_beachball(mt, **kwargs)
for x in range(nx):
mt = mtm.MomentTensor.random_mt()
self.compare_beachball(mt, **kwargs)
def test_random_dcs(self):
nx = 20
for x in range(nx):
strike = fuzz_angle(0., 360.)
dip = fuzz_angle(0., 90.)
rake = fuzz_angle(-180., 180.)
mt = mtm.MomentTensor(strike=strike, dip=dip, rake=rake)
self.compare_beachball(mt)
def pyrocko_moment_tensor(self):
mrr = self.tensor.mrr.value
mtt = self.tensor.mtt.value
mpp = self.tensor.mpp.value
mrt = self.tensor.mrt.value
mrp = self.tensor.mrp.value
mtp = self.tensor.mtp.value
mt = moment_tensor.MomentTensor(m_up_south_east=num.matrix(
[[mrr, mrt, mrp], [mrt, mtt, mtp], [mrp, mtp, mpp]]))
return mt
def moment_tensor(self):
'''Return moment tensor representation.'''
if self._sourcetype in ('eikonal', 'bilateral', 'circular'):
mt = moment_tensor.MomentTensor(
strike=self._params['strike'],
dip=self._params['dip'],
rake=self._params['slip-rake'],
scalar_moment=self._params['moment'])
elif self._sourcetype in 'moment_tensor':
mxx, myy, mzz, mxy, mxz, myz = [
self._params[mmm] for mmm in 'mxx myy mzz mxy mxz myz'.split()
]
m = num.mat([[mxx, mxy, mxz], [mxy, myy, myz], [mxz, myz, mzz]])
mt = moment_tensor.MomentTensor(m=m)
else:
raise Exception(
"Cannot get moment tensor representation of this source type.")
return mt
def plot_axis(events, eventsclusters, clusters, conf, plotdir):
'''
Plot axis orientations for the seismicity clusters
'''
c1, c2, c3 = [2., 1.8], [6., 1.8], [10., 1.8]
csize = 1.5
events_with_mt = []
cols = []
for iev, ev in enumerate(events):
if ev.moment_tensor is not None:
if conf.sw_dc_axis:
mt = ev.moment_tensor
decomposition = mt.standard_decomposition()
(moment_dc, ratio_dc, m_dc) = decomposition[1]
mtdc = pmt.MomentTensor(m_dc)
ev.moment_tensor = mtdc
events_with_mt.append(ev)
cols.append(cluster_to_color(eventsclusters[iev]))
xs, ys = get_axis_coords(events_with_mt)
pxs, pys = [x[0] * csize + c1[0]
for x in xs], [y[0] * csize + c1[1] for y in ys]
txs, tys = [x[1] * csize + c2[0]
for x in xs], [y[1] * csize + c2[1] for y in ys]
bxs, bys = [x[2] * csize + c3[0]
for x in xs], [y[2] * csize + c3[1] for y in ys]
f = plt.figure(figsize=(12, 4), facecolor='w', edgecolor='k')
f.suptitle('Pressure (P), tension (T) and null (B) axis' +
' for seismicity clusters',
fontsize=14)
plt.xlim(xmin=0., xmax=12.)
plt.ylim(ymin=0., ymax=4.)
plt.text(c1[0], 3.4, 'P axis', fontsize=12, ha='center')
plt.text(c2[0], 3.4, 'T axis', fontsize=12, ha='center')
plt.text(c3[0], 3.4, 'B axis', fontsize=12, ha='center')
plt.axis('off')
plt.scatter(pxs, pys, c=cols, alpha=0.5)
plt.scatter(txs, tys, c=cols, alpha=0.5)
plt.scatter(bxs, bys, c=cols, alpha=0.5)
ax = plt.gca()
ax.add_artist(plt.Circle((c1[0], c1[1]), csize, color='black', fill=False))
ax.add_artist(plt.Circle((c2[0], c2[1]), csize, color='black', fill=False))
ax.add_artist(plt.Circle((c3[0], c3[1]), csize, color='black', fill=False))
# plt.scatter(xs,ys,c=colors,alpha=0.5)
figname = os.path.join(plotdir, 'plot_axis.' + conf.figure_format)
f.savefig(figname)
def scedc_fm_to_pyrocko(file):
mechs = np.loadtxt(file, dtype="str")
dates = []
strikes = []
rakes = []
dips = []
depths = []
lats = []
lons = []
events = []
errors_h = []
errors_t = []
errors_z = []
for i in mechs:
dates.append(i[1][0:4] + "-" + i[1][5:7] + "-" + i[1][8:] + " " + i[2])
strikes.append(float(i[16]))
dips.append(float(i[17]))
rakes.append(float(i[18]))
lats.append(float(i[7]))
lons.append(float(i[8]))
depths.append(float(i[9]))
if float(i[13]) * 1000. > 4000.:
errors_h.append(2000.)
if float(i[13]) * 1000. < 1000.:
errors_h.append(2000.)
else:
errors_h.append(6000.)
if float(i[14]) * 1000. > 2000.:
errors_z.append(2000.)
else:
errors_z.append(2000.)
errors_t.append(float(i[15]))
mt = pmt.MomentTensor(strike=float(i[16]),
dip=float(i[17]),
rake=float(i[18]),
magnitude=float(i[5]))
event = model.event.Event(
lat=float(i[7]),
lon=float(i[8]),
depth=float(i[9]),
moment_tensor=mt,
magnitude=float(i[5]),
time=util.str_to_time(i[1][0:4] + "-" + i[1][5:7] + "-" +
i[1][8:] + " " + i[2]))
events.append(event)
return events, errors_h, errors_t, errors_z
def randomMT(mttype, mag):
'''
Returns a randomly rotated moment tensor
'''
# must be one of double couple, continuous linear vector dipole, isoptropic sources
mttypes = ['DC', 'CLVD', 'Isotropic']
assert mttype in mttypes, print('mttype must be one of {}'.format(mttypes))
if mttype == 'DC':
return mtm.MomentTensor.random_dc(magnitude=mag)
elif mttype == 'CLVD':
tensor = np.array([[1, 0, 0], [0, 1, 0], [0, 0, -2]])
elif mttype == 'Isotropic':
tensor = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
rotated_tensor = mtm.random_rotation() * tensor
return mtm.MomentTensor(rotated_tensor, magnitude=mag)
def pyrocko_event(self):
'''Considers only the *preferred* origin and magnitude'''
lat, lon, depth = self.preferred_origin.position_values()
otime = self.preferred_origin.time.value
reg = self.region
foc_mech = self.preferred_focal_mechanism
if foc_mech is not None:
mrr = foc_mech.moment_tensor_list[0].tensor.mrr.value
mtt = foc_mech.moment_tensor_list[0].tensor.mtt.value
mpp = foc_mech.moment_tensor_list[0].tensor.mpp.value
mrt = foc_mech.moment_tensor_list[0].tensor.mrt.value
mrp = foc_mech.moment_tensor_list[0].tensor.mrp.value
mtp = foc_mech.moment_tensor_list[0].tensor.mtp.value
mt = moment_tensor.MomentTensor(m_up_south_east=num.matrix(
[[mrr, mrt, mrp], [mrt, mtt, mtp], [mrp, mtp, mpp]]))
else:
mt = None
pref_mag = self.preferred_magnitude
if pref_mag is None:
mag = self.magnitude_list[0].mag.value
else:
mag = pref_mag.mag.value
cat = None
if self.preferred_origin.creation_info is not None:
cat = self.preferred_origin.creation_info.agency_id
reg = None
if self.description_list:
reg = self.description_list[0].text
return event.Event(name=self.public_id,
lat=lat,
lon=lon,
time=otime,
depth=depth,
magnitude=mag,
region=reg,
moment_tensor=mt,
catalog=cat)
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 testIOEvent(self):
tempdir = tempfile.mkdtemp()
fn = pjoin(tempdir, 'event.txt')
e1 = model.Event(10.,
20.,
1234567890.,
'bubu',
region='taka tuka land',
moment_tensor=moment_tensor.MomentTensor(strike=45.,
dip=90),
magnitude=5.1,
magnitude_type='Mw')
guts.dump(e1, filename=fn)
e2 = guts.load(filename=fn)
assert e1.region == e2.region
assert e1.name == e2.name
assert e1.lat == e2.lat
assert e1.lon == e2.lon
assert e1.time == e2.time
assert e1.region == e2.region
assert e1.magnitude == e2.magnitude
assert e1.magnitude_type == e2.magnitude_type
shutil.rmtree(tempdir)
def pyrocko_moment_tensor(self):
return mtm.MomentTensor(m=mtm.symmat6(*self.m6_astuple) * self.moment)
def __init__(self, markers, stations=None):
# Targets================================================
store_id = 'castor'
if store_id=='local1':
phase_ids_start = 'p|P|Pv20p|Pv35p'
phase_ids_end = 's|S|Sv20s|Sv35s'
if store_id=='very_local':
phase_ids_start = 'p|P|Pv3p|Pv8p|Pv20p|Pv35p'
phase_ids_end = 's|S|Sv3s|Sv8s|Sv20s|Sv35s'
if store_id=='very_local_20Hz':
phase_ids_start = 'begin_fallback|p|P|Pv1p|Pv3p|Pv8p|Pv20p|Pv35p'
phase_ids_end = 's|S|Sv1s|Sv3s|Sv8s|Sv20s|Sv35s'
if store_id=='very_local_20Hz':
phase_ids_start = 'begin_fallback|p|P|Pv1p|Pv3p|Pv8p|Pv20p|Pv35p'
phase_ids_end = 's|S|Sv1s|Sv3s|Sv8s|Sv20s|Sv35s'
if store_id=='castor':
# bug?! bei Pv1.5p gibt's bei nahen Entfernungen ein index ot of
# bounds
phase_ids_start = 'p|P|Pv12.5p|Pv2.5p|Pv18.5p|Pv20p|Pv35p'
phase_ids_end= 's|S|Sv12.5s|Sv2.5s|Sv18.5s|Sv20s|Sv35s'
# Event==================================================
event = filter(lambda x: isinstance(x, gui_util.EventMarker), markers)
assert len(event) == 1
event = event[0].get_event()
event.magnitude = 4.3
event.moment_tensor = moment_tensor.MomentTensor(
m=num.array([[0.0, 0.0, 1.0],
[0.0, 0.0, 0.0],
[0.0, 0.0, 0.0]]))
# generate stations from olat, olon:
if not stations:
print 'Generating station distribution.'
stations = du.station_distribution((event.lat,event.lon),
[[10000., 4], [130000., 8]],
rotate={3000.:45, 130000.:0})
targets = stations2targets(stations, store_id)
derec_home = os.environ["DEREC_HOME"]
store_dirs = [derec_home + '/fomostos']
engine = LocalEngine(store_superdirs=store_dirs)
model = get_earthmodel_from_engine(engine, store_id)
#TESTSOURCES===============================================
offset = 3*km
zoffset= 1000.
ref_source = event2source(event, 'DC', strike=37.3, dip=30, rake=-3)
center_lat = ref_source.lat
center_lon = ref_source.lon
negative_lat_offset, negative_lon_offset = du.lat_lon_relative_shift(
center_lat, center_lon, -offset, -offset)
positive_lat_offset, positive_lon_offset = du.lat_lon_relative_shift(
center_lat, center_lon, offset, offset)
lats=num.linspace(negative_lat_offset, positive_lat_offset, 3)
#lats = [ref_source.lat]
lons=num.linspace(negative_lon_offset, positive_lon_offset, 3)
#lons = [ref_source.lon]
depths=num.linspace(ref_source.depth-zoffset, ref_source.depth+zoffset, 3)
depths = [ref_source.depth]
#strikes = num.linspace(ref_source.strike-90, ref_source.strike+90, 25)
strikes = [ref_source.strike]
#dips = num.linspace(ref_source.dip-45, ref_source.dip+45, 25)
dips = [ref_source.dip]
#rakes = num.linspace(ref_source.rake-180, ref_source.rake+180, 25)
rakes = [ref_source.rake]
print lats, '<- lats'
print lons, '<- lons'
print depths, '<- depths'
print ref_source.lat, '<- event lat'
print ref_source.lon, '<- event lon'
print ref_source.depth, '<- event depth'
print ref_source.strike, ref_source.dip, ref_source.rake, '<- event S D R'
location_test_sources = [DCSource(lat=lat,
lon=lon,
depth=depth,
time=event.time,
strike=strike,
dip=dip,
rake=rake,
magnitude=event.magnitude) for strike in strikes
for dip in dips
for rake in rakes
for lat in lats
for lon in lons
for depth in depths]
for s in location_test_sources:
s.regularize()
#==========================================================
test_case = TestCase(location_test_sources,
targets,
engine,
store_id,
test_parameters={'lat':lats,
'lon':lons,
'depth':depths})
test_case.ref_source = ref_source
test_case.request_data()
print 'source location: ', test_case.ref_source
reference_seismograms = make_reference_trace(test_case.ref_source,
test_case.targets,
engine)
extended_ref_marker = du.chop_ranges(test_case.ref_source,
test_case.targets,
test_case.store,
phase_ids_start,
phase_ids_end)
print('test data marker....')
extended_test_marker = du.chop_ranges(test_case.sources,
test_case.targets,
test_case.store,
phase_ids_start,
phase_ids_end)
test_case.test_markers = extended_test_marker
test_case.ref_markers = extended_ref_marker
print('chopping ref....')
test_case.references = du.chop_using_markers(
reference_seismograms.iter_results(), extended_ref_marker,
t_shift_frac=0.1)
print('chopping cand....')
test_case.seismograms = du.chop_using_markers(
test_case.response.iter_results(), extended_test_marker,
t_shift_frac=0.1)
norm = 2.
#taper = trace.CosFader(xfade=4) # Seconds or samples?
taper = trace.CosFader(xfrac=0.1)
z, p, k = butter(4, (2.*num.pi*2. ,0.4*num.pi*2.) ,
'bandpass',
analog=True,
output='zpk')
z = num.array(z, dtype=complex)
p = num.array(p, dtype=complex)
k = num.complex(k)
fresponse = trace.PoleZeroResponse(z,p,k)
fresponse.regularize()
setup = trace.MisfitSetup(norm=norm,
taper=taper,
domain='envelope',
filter=fresponse)
test_case.set_misfit_setup(setup)
du.calculate_misfit(test_case)
#test_case.yaml_dump()
# Display results===================================================
#test_case.plot1d(order, event.lon)
#test_case.contourf(xkey='lon', ykey='lat')
test_case.check_plot({'lat':ref_source.lat, 'depth':ref_source.depth})
optics = OpticBase(test_case)
#optics.plot_1d(fix_parameters={'lat':event.lat, 'lon':event.lon})
optics.gmt_map(stations=True, events=True)
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 __init__(self, *args):
QWidget.__init__(self, *args)
mt = mtm.MomentTensor(m=mtm.symmat6(1., -1., 2., 0., -2., 1.))
print mt
self._mt = mt
self.set_moment_tensor(mt)
from pyrocko import moment_tensor as pmt magnitude = 6.3 # Magnitude of the earthquake m0 = pmt.magnitude_to_moment(magnitude) # convert the mag to moment strike = 130 dip = 40 rake = 110 mt = pmt.MomentTensor(strike=strike, dip=dip, rake=rake, scalar_moment=m0) m6 = [mt.mnn, mt.mee, mt.mdd, mt.mne, mt.mnd, mt.med] # The six MT components print(m6/mt.scalar_moment()) # normalized MT components
from __future__ import print_function
from matplotlib import pyplot as plt
from pyrocko.plot import hudson, beachball, mpl_init, mpl_color
from pyrocko import moment_tensor as mtm
import sys
m = mtm.MomentTensor(mnn=2.31,
mee=-2.63,
mdd=0.395,
mne=1.69,
mnd=0.232,
med=-0.935)
# setup plot layout
fontsize = 9.
markersize = fontsize
mpl_init(fontsize=fontsize)
width = 8.
figsize = (width, width / (4. / 3.))
fig = plt.figure(figsize=figsize)
axes = fig.add_subplot(1, 1, 1)
fig.subplots_adjust(left=0.03, right=0.97, bottom=0.03, top=0.97)
# draw focal sphere diagrams for the random MT
u, v = hudson.project(m)
print(u, v)
try:
beachball.plot_beachball_mpl(
m,
