def test_get_synthetics():
# Try to load 3 stations, out of which 2 are in range for P
db = instaseis.open_db('syngine://prem_a_20s')
cat = obspy.read_events('./stfinv/data/virginia.xml')
st = read('./stfinv/data/dis.II.BFO.00.BHZ')
st += read('./stfinv/data/dis.GE.DAG..BHZ')
st += read('./stfinv/data/dis.G.CRZF.00.BHZ')
st_data, st_syn = st.get_synthetics(db=db,
origin=cat[0].origins[0],
out_dir='/tmp')
npt.assert_equal(len(st_data), 2)
npt.assert_equal(len(st_syn), 12)
for istat in range(0, 2):
channels = ['MPP', 'MRP', 'MRR', 'MRT', 'MTP', 'MTT']
for channel in channels:
st_test = st_syn.select(station=st_data[istat].stats.station,
network=st_data[istat].stats.network,
location=st_data[istat].stats.location,
channel=channel)
npt.assert_equal(len(st_test), 1)
for tr in st_syn[istat * 6:(istat + 1) * 6]:
npt.assert_string_equal(str(tr.stats.station),
str(st_data[istat].stats.station))
npt.assert_string_equal(str(tr.stats.location),
str(st_data[istat].stats.location))
npt.assert_string_equal(str(tr.stats.network),
str(st_data[istat].stats.network))
npt.assert_equal(tr.stats.npts, st_data[istat].stats.npts)
npt.assert_allclose(tr.stats.delta, st_data[istat].stats.delta)
npt.assert_allclose(float(tr.stats.starttime),
float(st_data[istat].stats.starttime))
def test_seismogram_extraction(all_remote_dbs):
"""
Test the seismogram extraction from local and remote databases.
"""
# Remote and local database.
r_db = all_remote_dbs
l_db = instaseis.open_db(r_db._client.filepath)
# Mock responses to get the tornado testing to work.
_add_callback(r_db._client)
source = instaseis.Source(
latitude=4., longitude=3.0, depth_in_m=0, m_rr=4.71e+17, m_tt=3.81e+17,
m_pp=-4.74e+17, m_rt=3.99e+17, m_rp=-8.05e+17, m_tp=-1.23e+17)
receiver = instaseis.Receiver(latitude=10., longitude=20., depth_in_m=None)
components = r_db.available_components
kwargs = {"source": source, "receiver": receiver,
"components": components}
_compare_streams(r_db, l_db, kwargs)
# Test velocity and acceleration.
kwargs = {"source": source, "receiver": receiver,
"components": components, "kind": "velocity"}
_compare_streams(r_db, l_db, kwargs)
kwargs = {"source": source, "receiver": receiver,
"components": components, "kind": "acceleration"}
_compare_streams(r_db, l_db, kwargs)
# Test remove source shift.
kwargs = {"source": source, "receiver": receiver,
"components": components,
"remove_source_shift": False}
_compare_streams(r_db, l_db, kwargs)
# Test resampling.
kwargs = {"source": source, "receiver": receiver,
"components": components,
"dt": 1.0, "kernelwidth": 6}
_compare_streams(r_db, l_db, kwargs)
# Test force source.
if "displ_only" in r_db._client.filepath:
source = instaseis.ForceSource(
latitude=89.91, longitude=0.0, depth_in_m=12000,
f_r=1.23E10,
f_t=2.55E10,
f_p=1.73E10)
kwargs = {"source": source, "receiver": receiver}
_compare_streams(r_db, l_db, kwargs)
# Fix receiver depth, network, and station codes.
receiver = instaseis.Receiver(latitude=10., longitude=20.,
depth_in_m=0.0, station="ALTM",
network="BW")
kwargs = {"source": source, "receiver": receiver,
"components": components}
_compare_streams(r_db, l_db, kwargs)
def __init__(self, path, kernelwidth=12):
try:
db = instaseis.open_db(path)
except:
Exception
self.db = db
self.kernelwidth = 12
def test_get_synthetics():
# Try to load 3 stations, out of which 2 are in range for P
db = instaseis.open_db('syngine://prem_a_20s')
cat = obspy.read_events('./stfinv/data/virginia.xml')
st = read('./stfinv/data/dis.II.BFO.00.BHZ')
st += read('./stfinv/data/dis.GE.DAG..BHZ')
st += read('./stfinv/data/dis.G.CRZF.00.BHZ')
st_data, st_syn = st.get_synthetics(db=db, origin=cat[0].origins[0],
out_dir='/tmp')
npt.assert_equal(len(st_data), 2)
npt.assert_equal(len(st_syn), 12)
for istat in range(0, 2):
channels = ['MPP', 'MRP', 'MRR', 'MRT', 'MTP', 'MTT']
for channel in channels:
st_test = st_syn.select(station=st_data[istat].stats.station,
network=st_data[istat].stats.network,
location=st_data[istat].stats.location,
channel=channel)
npt.assert_equal(len(st_test), 1)
for tr in st_syn[istat * 6:(istat + 1) * 6]:
npt.assert_string_equal(str(tr.stats.station),
str(st_data[istat].stats.station))
npt.assert_string_equal(str(tr.stats.location),
str(st_data[istat].stats.location))
npt.assert_string_equal(str(tr.stats.network),
str(st_data[istat].stats.network))
npt.assert_equal(tr.stats.npts, st_data[istat].stats.npts)
npt.assert_allclose(tr.stats.delta, st_data[istat].stats.delta)
npt.assert_allclose(float(tr.stats.starttime),
float(st_data[istat].stats.starttime))
def get_ns(wf1,source_conf,insta):
# Nr of time steps in traces
if insta:
# get path to instaseis db
#ToDo: ugly.
dbpath = json.load(open(os.path.join(source_conf['project_path'],
'config.json')))['wavefield_path']
# open
db = instaseis.open_db(dbpath)
# get a test seismogram to determine...
stest = db.get_seismograms(source=instaseis.ForceSource(latitude=0.0,
longitude=0.0),receiver=instaseis.Receiver(latitude=10.,
longitude=0.0),dt=1./source_conf['sampling_rate'])[0]
nt = stest.stats.npts
Fs = stest.stats.sampling_rate
else:
with WaveField(wf1) as wf1:
nt = int(wf1.stats['nt'])
Fs = round(wf1.stats['Fs'],8)
# Necessary length of zero padding for carrying out frequency domain correlations/convolutions
n = next_fast_len(2*nt-1)
# Number of time steps for synthetic correlation
n_lag = int(source_conf['max_lag'] * Fs)
if nt - 2*n_lag <= 0:
click.secho('Resetting maximum lag to %g seconds: Synthetics are too\
short for a maximum lag of %g seconds.' %(nt//2/Fs,n_lag/Fs))
n_lag = nt // 2
n_corr = 2*n_lag + 1
return nt,n,n_corr,Fs
def all_remote_dbs(request):
client = create_async_client(request.param, None)
_add_callback(client)
db = instaseis.open_db("http://localhost:%i" % client.port)
db._client = client
return db
def all_remote_dbs(request):
client = create_async_client(request.param, None)
_add_callback(client)
db = instaseis.open_db("http://localhost:%i" % client.port)
db._client = client
return db
def compare_dbs(seed, databases):
if seed:
random.seed(seed)
reference = instaseis.open_db(databases[0])
others = [instaseis.open_db(_i) for _i in databases[1:]]
max_depth = reference.info.max_radius - reference.info.min_radius
while True:
receiver = instaseis.Receiver(
latitude=random.random() * 180.0 - 90.0,
longitude=random.random() * 360.0 - 180.0,
network="AB",
station="CED",
)
source = instaseis.Source(
latitude=random.random() * 180.0 - 90.0,
longitude=random.random() * 360.0 - 180.0,
depth_in_m=random.random() * max_depth,
m_rr=4.710000e24 / 1e7,
m_tt=3.810000e22 / 1e7,
m_pp=-4.740000e24 / 1e7,
m_rt=3.990000e23 / 1e7,
m_rp=-8.050000e23 / 1e7,
m_tp=-1.230000e24 / 1e7,
origin_time=obspy.UTCDateTime(2011, 1, 2, 3, 4, 5),
)
print("======")
ref = reference.get_seismograms(source=source,
receiver=receiver,
components="ZNERT")
oth = [
_i.get_seismograms(source=source,
receiver=receiver,
components="ZNERT") for _i in others
]
for _i, _j in zip(oth, others):
print(_j.info.directory, ":", ref == _i)
assert ref == _i, str(source) + "\n" + str(receiver)
def prepare(self):
# initialize parameters
self.Fs = self.config['wavefield_sampling_rate']
self.npts = int(self.config['wavefield_duration'] * self.Fs)
self.ntraces = self.sourcegrid.shape[-1]
self.data_quantity = self.config['synt_data']
if self.config['wavefield_domain'] == 'fourier':
self.fdomain = True
if self.npts % 2 == 1:
self.npad = 2 * self.npts - 2
else:
self.npad = 2 * self.npts
elif self.config['wavefield_domain'] == 'time':
self.fdomain = False
self.npad = next_fast_len(2 * self.npts - 1)
else:
raise ValueError('Unknown domain {}.'.format(
self.config['wavefield_domain']))
self.freq = np.fft.rfftfreq(self.npad, d=1.0 / self.Fs)
# Apply a filter
if self.config['wavefield_filter'] is not None:
freq_nyq = self.Fs / 2.0 # Nyquist
if freq_nyq < self.config['wavefield_filter'][1]:
warn("Selected upper freq > Nyquist, \
reset to 95\% of Nyquist freq.")
freq_minres = 1. / self.config['wavefield_duration']
# lowest resolved
freq_max = min(0.999 * freq_nyq,
self.config['wavefield_filter'][1])
freq_min = max(freq_minres, self.config['wavefield_filter'][0])
f0 = freq_min / freq_nyq
f1 = freq_max / freq_nyq
self.filter = butter(4, [f0, f1], 'bandpass')
else:
self.filter = None
# if using instaseis: Find and open database
if self.config['wavefield_type'] == 'instaseis':
path_to_db = self.config['wavefield_path']
self.db = instaseis.open_db(path_to_db)
if self.db.info['length'] < self.npts / self.Fs:
warn("Resetting wavefield duration to axisem database length.")
fsrc = instaseis.ForceSource(latitude=0.0,
longitude=0.0,
f_r=1.0)
rec = instaseis.Receiver(latitude=0.0, longitude=0.0)
test = self.db.get_seismograms(source=fsrc,
receiver=rec,
dt=1. / self.Fs)
self.npts = test[0].stats.npts
def play(path_LF, path_HF, nevent=40):
global events
events = []
fnam = os.path.join(DATA_PATH, 'VBB_3days_VEL.mseed')
if not os.path.exists(fnam):
fnam = os.path.join(DATA_PATH, 'VBB_3days_VEL_SYNT.mseed')
st = read(fnam)
db_HF = instaseis.open_db(path_HF)
db_LF = instaseis.open_db(path_LF)
for i in range(0, nevent):
M, dist = create_event(M_min=2.0, M_max=4.0)
if autoreject(M, dist):
events.append([dist, M, 0])
string = '%3d/%3d: Below threshold: Event in %d deg with M%3.1f'
elif autoaccept(M, dist):
events.append([dist, M, 1])
string = '%3d/%3d: Above threshold: Event in %d deg with M%3.1f'
else:
st_LF, st_HF, t0 = select_and_add(st, db_HF, db_LF, M, dist)
fig, ax = plot_spec(st_HF=st_HF, st_LF=st_LF, winlen_sec_LF=50)
picks = pickify(fig, ax, M=M, dist=dist, t0=t0)
if events[-1][-1] == 1:
string = '%3d/%3d: Found event in %d deg with M%3.1f'
else:
string = '%3d/%3d: Missed event in %d deg with M%3.1f'
print(string % (i, nevent, dist, M))
with open('result.txt', 'a') as f:
for event in events:
plt.plot(event[0], event[1], 'o', c='C%d' % event[2])
f.write('%5.1f, %4.2f, %d \n' % (event[0], event[1], event[2]))
plt.plot(-1, -1, 'o', c='C1', label='detected')
plt.plot(-1, -1, 'o', c='C0', label='missed')
plt.legend()
plt.title('Your detection results after %d events' % nevent)
plt.xlabel('distance [degree]')
plt.ylabel('magnitude $M_W$')
plt.ylim(2, 4)
plt.xlim(0, 180)
plt.show()
def setup(self):
self.db = open_db(self.path, read_on_demand=False,
buffer_size_in_mb=250)
self.counter = 0
self.current_depth_counter = 0
# Depth increases in 1 km steps up to a depth of 25 km.
self.depths = range(0, 25001, 1000)
self.depth_count = len(self.depths)
# Fix Receiver
self.rec = Receiver(latitude=45.0, longitude=45.0)
def setup(self):
self.db = open_db(self.path,
read_on_demand=False,
buffer_size_in_mb=250)
self.counter = 0
self.current_depth_counter = 0
# Depth increases in 1 km steps up to a depth of 25 km.
self.depths = range(0, 25001, 1000)
self.depth_count = len(self.depths)
# Fix Receiver
self.rec = Receiver(latitude=45.0, longitude=45.0)
def test_get_grf6():
db = instaseis.open_db('syngine://prem_a_20s')
reclat = 10.0
reclon = 10.0
cat = obspy.read_events('./stfinv/data/virginia.xml')
# Define Moment tensor
tensor = cat[0].focal_mechanisms[0].moment_tensor.tensor
# tensor = obspy.core.event.Tensor(m_rr=1e20, m_pp=-2e20, m_tt=0.5e20,
# m_rt=5e19, m_rp=-7e19, m_tp=-1e20)
# Get a reference trace with normal instaseis
rec = instaseis.Receiver(latitude=reclat,
longitude=reclon,
network='XX',
station='YY',
location='00')
# src = instaseis.Source(latitude=evlat, longitude=evlon,
# m_rr=tensor.m_rr,
# m_tt=tensor.m_tt,
# m_pp=tensor.m_pp,
# m_tp=tensor.m_tp,
# m_rt=tensor.m_rt,
# m_rp=tensor.m_rp,
# depth_in_m=evdepth)
src = instaseis.Source.parse(cat[0])
st_ref = db.get_seismograms(src, rec, dt=0.1, components='Z')
# Get a synthetic
st_grf6 = Stream()
st_grf6 += get_grf6(db,
origin=cat[0].origins[0],
rec_lat=reclat,
rec_lon=reclon,
dt=0.1,
stats=st_ref[0].stats,
depth_in_m=cat[0].origins[0].depth)
st_synth = st_grf6.calc_synthetic_from_grf6(st_ref, tensor=tensor, stf=[1])
# st_synth.plot(outfile='synth.png')
# st_ref.plot(outfile='ref.png')
npt.assert_allclose(st_ref[0].data,
st_synth[0].data,
rtol=5e-1,
atol=1e-7,
err_msg='Synthetic not the same')
def main():
# === Read input file ===
param = toml.load(toml_path, _dict=dict)
# === Read the mSEED file ===
get_parameters = Get_Parameters()
mSEED_path = get_parameters.Get_Path(param['directory'],
param['mSEED_file'])
stream = obspy.read(mSEED_path)
PRIOR = get_parameters.PRIOR(stream, param['PRIOR'])
# === GET PRIOR ===
PRIOR = get_parameters.Get_ranges(PRIOR) # WHEN RUN IS NOT YET DONE
# === Cut the BW windows (P&S) ===
BW_obs = Cut_windows(PRIOR['VELOC_taup'],
P_HP=PRIOR['P_HP'],
P_LP=PRIOR['P_LP'],
S_HP=PRIOR['S_HP'],
S_LP=PRIOR['S_LP'],
Pre_P=PRIOR['Pre_P'],
Pre_S=PRIOR['Pre_S'],
Post_P=PRIOR['Post_P'],
Post_S=PRIOR['Post_S'],
global_P_shift=PRIOR['Global_P_shift'],
global_S_shift=PRIOR['Global_S_shift'],
zero_phase=PRIOR['Zero_Phase'],
Order=PRIOR['Order'],
Taper=PRIOR['Taper_obs'],
Taper_len=PRIOR['Taper_len'],
Zero_len=PRIOR['Zero_len'])
if PRIOR['P_pick'] == None or PRIOR['S_pick'] == None:
BW_obs.Get_bw_windows(stream,
PRIOR['epi_s'],
PRIOR['depth_s'],
PRIOR['origin_time'],
MANUAL=False)
else:
BW_obs.Get_bw_windows(stream,
PRIOR['P_pick'],
PRIOR['S_pick'],
PRIOR['origin_time'],
MANUAL=True)
## === 2. Get Green's Functions ===
db = instaseis.open_db(PRIOR['VELOC'])
depth = 58691.9
a = 1
def compare_dbs(seed, databases):
if seed:
random.seed(seed)
reference = instaseis.open_db(databases[0])
others = [instaseis.open_db(_i) for _i in databases[1:]]
max_depth = (reference.info.max_radius - reference.info.min_radius)
while True:
receiver = instaseis.Receiver(
latitude=random.random() * 180.0 - 90.0,
longitude=random.random() * 360.0 - 180.0,
network="AB", station="CED")
source = instaseis.Source(
latitude=random.random() * 180.0 - 90.0,
longitude=random.random() * 360.0 - 180.0,
depth_in_m=random.random() * max_depth,
m_rr=4.710000e+24 / 1E7,
m_tt=3.810000e+22 / 1E7,
m_pp=-4.740000e+24 / 1E7,
m_rt=3.990000e+23 / 1E7,
m_rp=-8.050000e+23 / 1E7,
m_tp=-1.230000e+24 / 1E7,
origin_time=obspy.UTCDateTime(2011, 1, 2, 3, 4, 5))
print('======')
ref = reference.get_seismograms(source=source, receiver=receiver,
components="ZNERT")
oth = [_i.get_seismograms(source=source, receiver=receiver,
components="ZNERT") for _i in others]
for _i, _j in zip(oth, others):
print(_j.info.directory, ":", ref == _i)
assert ref == _i, str(source) + "\n" + str(receiver)
def _calc(self):
db = instaseis.open_db(self.db_name)
nazi = 8
dt = min([self.dt, db.info.dt])
lats = np.linspace(start=-90., stop=90., num=self.ndist)
lons = np.linspace(start=-180, stop=180., num=nazi, endpoint=False)
src = instaseis.Source(latitude=90.0,
longitude=0.0,
depth_in_m=self.depth_in_m,
m_rr=-1.670000e+28 / 1e7,
m_tt=3.820000e+27 / 1e7,
m_pp=1.280000e+28 / 1e7,
m_rt=-7.840000e+27 / 1e7,
m_rp=-3.570000e+28 / 1e7,
m_tp=1.550000e+27 / 1e7)
npts = _get_npts(db, dt)
stack_R = np.zeros(shape=(self.ndist, nazi, npts))
stack_T = np.zeros(shape=(self.ndist, nazi, npts))
stack_Z = np.zeros(shape=(self.ndist, nazi, npts))
for ilat in tqdm(range(0, int(self.ndist))):
lat = lats[ilat]
for ilon in range(0, nazi):
lon = lons[ilon]
rec = instaseis.Receiver(latitude=lat,
longitude=lon,
network="AB",
station="%d" % lon)
st = db.get_seismograms(src,
rec,
components='RTZ',
kind='velocity',
dt=dt,
remove_source_shift=True)
stack_R[ilat, ilon, :] = st.select(channel='*R')[0].data
stack_T[ilat, ilon, :] = st.select(channel='*T')[0].data
stack_Z[ilat, ilon, :] = st.select(channel='*Z')[0].data
return stack_R, stack_T, stack_Z, st[0].stats, db.info
def test_get_grf6():
db = instaseis.open_db('syngine://prem_a_20s')
reclat = 10.0
reclon = 10.0
cat = obspy.read_events('./stfinv/data/virginia.xml')
# Define Moment tensor
tensor = cat[0].focal_mechanisms[0].moment_tensor.tensor
# tensor = obspy.core.event.Tensor(m_rr=1e20, m_pp=-2e20, m_tt=0.5e20,
# m_rt=5e19, m_rp=-7e19, m_tp=-1e20)
# Get a reference trace with normal instaseis
rec = instaseis.Receiver(latitude=reclat, longitude=reclon,
network='XX', station='YY', location='00')
# src = instaseis.Source(latitude=evlat, longitude=evlon,
# m_rr=tensor.m_rr,
# m_tt=tensor.m_tt,
# m_pp=tensor.m_pp,
# m_tp=tensor.m_tp,
# m_rt=tensor.m_rt,
# m_rp=tensor.m_rp,
# depth_in_m=evdepth)
src = instaseis.Source.parse(cat[0])
st_ref = db.get_seismograms(src, rec, dt=0.1, components='Z')
# Get a synthetic
st_grf6 = Stream()
st_grf6 += get_grf6(db, origin=cat[0].origins[0],
rec_lat=reclat, rec_lon=reclon,
dt=0.1, stats=st_ref[0].stats,
depth_in_m=cat[0].origins[0].depth)
st_synth = st_grf6.calc_synthetic_from_grf6(st_ref,
tensor=tensor,
stf=[1])
# st_synth.plot(outfile='synth.png')
# st_ref.plot(outfile='ref.png')
npt.assert_allclose(st_ref[0].data, st_synth[0].data,
rtol=5e-1,
atol=1e-7,
err_msg='Synthetic not the same')
def create_insta_from_invcat(network, event, database):
"""
This function creates synthetic data using the given network and
event information, with the database of instaseis
:param network: Desired Network, for which the data is generated
:type network: obspy.core.inventory.Network
:param event: Event, for wich the data is generated. The event must have
stored the moment tensor (e.g. given by glogalcmt.org)
:type event: obspy.core.event.Event
:param database: Link to the database, e.g. the path on your harddrive
:type database: str
"""
db = instaseis.open_db(database)
tofe = event.origins[0].time
lat = event.origins[0].latitude
lon = event.origins[0].longitude
depth = event.origins[0].depth
source = instaseis.Source(latitude=lat,
longitude=lon,
depth_in_m=depth,
m_rr=event.MomentTensor.m_rr,
m_tt=event.MomentTensor.m_tt,
m_pp=event.MomentTensor.m_pp,
m_rt=event.MomentTensor.m_rt,
m_rp=event.MomentTensor.m_rp,
m_tp=event.MomentTensor.m_tp,
origin_time=tofe)
stream = Stream()
tmp = []
for station in network:
rec = instaseis.Receiver(latitude=str(station.latitude),
longitude=str(station.longitude),
network=str(network.code),
station=str(station.code))
tmp.append(db.get_seismograms(source=source, receiver=rec))
for x in tmp:
stream += x
return stream
def on_select_folder_button_released(self):
pwd = os.getcwd()
self.folder = str(QtGui.QFileDialog.getExistingDirectory(self, "Choose Directory", pwd))
if not self.folder:
return
self.instaseis_db = open_db(self.folder)
# Adjust depth slider to the DB.
max_rad = self.instaseis_db.info.max_radius / 1e3
min_rad = self.instaseis_db.info.min_radius / 1e3
self.ui.depth_slider.setMinimum(min_rad - max_rad)
self.ui.depth_slider.setMaximum(0)
self._setup_finite_source()
self.plot_map()
self.update()
self.set_info()
def test_info(syngine_client):
"""
Make sure the /info route is similar enough.
"""
# Syngine and local database.
s_db = syngine_client
l_db = instaseis.open_db(db_path)
s_info = copy.deepcopy(s_db.info)
l_info = copy.deepcopy(l_db.info)
np.testing.assert_allclose(s_info.slip, l_info.slip)
np.testing.assert_allclose(s_info.sliprate, l_info.sliprate)
for key in ["directory", "slip", "sliprate"]:
del s_info[key]
del l_info[key]
assert s_info.__dict__ == l_info.__dict__
def test_info(syngine_client):
"""
Make sure the /info route is similar enough.
"""
# Syngine and local database.
s_db = syngine_client
l_db = instaseis.open_db(db_path)
s_info = copy.deepcopy(s_db.info)
l_info = copy.deepcopy(l_db.info)
np.testing.assert_allclose(s_info.slip, l_info.slip)
np.testing.assert_allclose(s_info.sliprate, l_info.sliprate)
for key in ["directory", "slip", "sliprate"]:
del s_info[key]
del l_info[key]
assert s_info.__dict__ == l_info.__dict__
def open_files(data_path, event_file, db_path):
# Read all data
st = read(data_path)
# Fill stream with station coordinates (in SAC header)
st.get_station_coordinates()
# Read event file
try:
cat = obspy.read_events(event_file)
if len(cat) > 1:
msg = 'File %s contains more than one event. Dont know, which one\
to chose. Please provide QuakeML file with just one event.'
raise TypeError(msg)
event = cat[0]
except:
event = get_event_from_obspydmt(event_file)
origin = event.origins[0]
db = instaseis.open_db(db_path)
# Initialize with MT from event file
try:
tensor = event.focal_mechanisms[0].moment_tensor.tensor
except IndexError:
print('No moment tensor present, using explosion. Hilarity may ensue')
tensor = obspy.core.event.Tensor(m_rr=1e20, m_tt=1e20, m_pp=1e20,
m_rp=0.0, m_rt=0.0, m_tp=0.0)
# Init with Gaussian STF with a length T:
# log10 T propto 0.5*Magnitude
# Scaling is such that the 5.7 Virginia event takes 5 seconds
if len(event.magnitudes) > 0:
duration = 10 ** (0.5 * (event.magnitudes[0].mag / 5.7)) * 5.0 / 2
else:
duration = 2.5
print('Assuming duration of %8.1f sec' % duration)
stf = signal.gaussian(duration * 2, duration / 4 / db.info.dt)
return db, st, origin, tensor, stf
def on_select_folder_button_released(self):
pwd = os.getcwd()
self.folder = str(
QtGui.QFileDialog.getExistingDirectory(self, "Choose Directory",
pwd))
if not self.folder:
return
self.instaseis_db = open_db(self.folder)
# Adjust depth slider to the DB.
max_rad = self.instaseis_db.info.max_radius / 1e3
min_rad = self.instaseis_db.info.min_radius / 1e3
self.ui.depth_slider.setMinimum(min_rad - max_rad)
self.ui.depth_slider.setMaximum(0)
self._setup_finite_source()
self.plot_map()
self.update()
self.set_info()
def on_open_instaseis_button_released(self):
cwd = os.getcwd()
self.folder = str(
QtGui.QFileDialog.getExistingDirectory(
self, "choose instaseis database folder", cwd))
if not self.folder:
return
self.instaseis_db = instaseis.open_db(self.folder)
self.source = instaseis.Source(latitude=self.ui.evla.value(),
longitude=self.ui.evlo.value(),
depth_in_m=self.ui.evdp.value() * 1000.,
m_rr=self.ui.m_rr.value(),
m_tt=self.ui.m_tt.value(),
m_pp=self.ui.m_pp.value(),
m_rt=self.ui.m_rt.value(),
m_rp=self.ui.m_rp.value(),
m_tp=self.ui.m_pp.value())
self.receiver = instaseis.Receiver(latitude=self.ui.stla.value(),
longitude=self.ui.stlo.value())
self.stream = self.instaseis_db.get_seismograms(
source=self.source,
receiver=self.receiver,
components=str(self.ui.component.currentText()),
kind=str(self.ui.motion_type.currentText()),
remove_source_shift=True)
self.stream[0].stats.sac = {}
self.stream[0].stats.sac['o'] = 0.0
self.stream[0].stats.sac['gcarc'] = geodetics.locations2degrees(
float(self.ui.evla.value()), float(self.ui.evlo.value()),
float(self.ui.stla.value()), float(self.ui.stlo.value()))
self.stream_copy = self.stream.copy()
time = self.get_time_axis
self.ui.window_start.setMaximum(time[-1])
self.ui.window_end.setMaximum(time[-1])
self.ui.window_start.setValue(time[0])
self.ui.window_end.setValue(time[-1])
self.instaseis = True
self.plot_map()
self.update()
def on_select_remote_connection_button_released(self):
text, ok = QtGui.QInputDialog.getText(
self, "Remote Instaseis Connection",
"Enter URL to remote Instaseis Server:")
if not ok:
return
text = str(text)
self.instaseis_db = open_db(text)
# Adjust depth slider to the DB.
max_rad = self.instaseis_db.info.max_radius / 1E3
min_rad = self.instaseis_db.info.min_radius / 1E3
self.ui.depth_slider.setMinimum(min_rad - max_rad)
self.ui.depth_slider.setMaximum(0)
self._setup_finite_source()
self.plot_map()
self.update()
self.set_info()
def on_select_remote_connection_button_released(self):
text, ok = QtGui.QInputDialog.getText(
self, "Remote Instaseis Connection",
"Enter URL to remote Instaseis Server:")
if not ok:
return
text = str(text)
self.instaseis_db = open_db(text)
# Adjust depth slider to the DB.
max_rad = self.instaseis_db.info.max_radius / 1E3
min_rad = self.instaseis_db.info.min_radius / 1E3
self.ui.depth_slider.setMinimum(min_rad - max_rad)
self.ui.depth_slider.setMaximum(0)
self._setup_finite_source()
self.plot_map()
self.update()
self.set_info()
def test_info(all_remote_dbs):
"""
Make sure the info is identical no matter if it comes from a local or
from a remote database.
"""
# Remote and local database.
r_db = all_remote_dbs
l_db = instaseis.open_db(r_db._client.filepath)
# Mock responses to get the tornado testing to work.
_add_callback(r_db._client)
r_info = copy.deepcopy(r_db.info)
l_info = copy.deepcopy(l_db.info)
np.testing.assert_allclose(r_info.slip, l_info.slip)
np.testing.assert_allclose(r_info.sliprate, l_info.sliprate)
for key in ["directory", "slip", "sliprate"]:
del r_info[key]
del l_info[key]
assert r_info.__dict__ == l_info.__dict__
def test_info(all_remote_dbs):
"""
Make sure the info is identical no matter if it comes from a local or
from a remote database.
"""
# Remote and local database.
r_db = all_remote_dbs
l_db = instaseis.open_db(r_db._client.filepath)
# Mock responses to get the tornado testing to work.
_add_callback(r_db._client)
r_info = copy.deepcopy(r_db.info)
l_info = copy.deepcopy(l_db.info)
np.testing.assert_allclose(r_info.slip, l_info.slip)
np.testing.assert_allclose(r_info.sliprate, l_info.sliprate)
for key in ["directory", "slip", "sliprate"]:
del r_info[key]
del l_info[key]
assert r_info.__dict__ == l_info.__dict__
def get_ns(all_conf, insta=False):
# Nr of time steps in traces
if insta:
# get path to instaseis db
dbpath = all_conf.config['wavefield_path']
# open
db = instaseis.open_db(dbpath)
# get a test seismogram to determine...
stest = db.get_seismograms(source=instaseis.ForceSource(latitude=0.0,
longitude=0.),
receiver=instaseis.Receiver(latitude=10.,
longitude=0.),
dt=1. / all_conf.config
['wavefield_sampling_rate'])[0]
nt = stest.stats.npts
Fs = stest.stats.sampling_rate
else:
any_wavefield = glob(os.path.join(all_conf.config['project_path'],
'greens', '*.h5'))[-1]
with WaveField(any_wavefield) as wf1:
nt = int(wf1.stats['nt'])
Fs = round(wf1.stats['Fs'], 8)
n = wf1.stats['npad']
# # Necessary length of zero padding
# # for carrying out frequency domain correlations/convolutions
# n = next_fast_len(2 * nt - 1)
# Number of time steps for synthetic correlation
n_lag = int(all_conf.source_config['max_lag'] * Fs)
if nt - 2 * n_lag <= 0:
n_lag_old = n_lag
n_lag = nt // 2
warn('Resetting maximum lag to %g seconds:\
Synthetics are too short for %g seconds.' % (n_lag / Fs, n_lag_old / Fs))
n_corr = 2 * n_lag + 1
return nt, n, n_corr, Fs
def get_ns(wf1, source_conf, insta):
# Nr of time steps in traces
if insta:
# get path to instaseis db
#ToDo: ugly.
dbpath = json.load(
open(os.path.join(source_conf['project_path'],
'config.json')))['wavefield_path']
# open
db = instaseis.open_db(dbpath)
# get a test seismogram to determine...
stest = db.get_seismograms(source=instaseis.ForceSource(latitude=0.0,
longitude=0.0),
receiver=instaseis.Receiver(latitude=10.,
longitude=0.0),
dt=1. / source_conf['sampling_rate'])[0]
nt = stest.stats.npts
Fs = stest.stats.sampling_rate
else:
with WaveField(wf1) as wf1:
nt = int(wf1.stats['nt'])
Fs = round(wf1.stats['Fs'], 8)
# Necessary length of zero padding for carrying out
# frequency domain correlations/convolutions
n = next_fast_len(2 * nt - 1)
# Number of time steps for synthetic correlation
n_lag = int(source_conf['max_lag'] * Fs)
if nt - 2 * n_lag <= 0:
click.secho('Resetting maximum lag to %g seconds: Synthetics are too\
short for a maximum lag of %g seconds.' % (nt // 2 / Fs, n_lag / Fs))
n_lag = nt // 2
n_corr = 2 * n_lag + 1
return nt, n, n_corr, Fs
def test_initialization_failures():
"""
Tests various initialization failures for the remote instaseis db.
"""
# Random error during init.
with mock.patch("instaseis.database_interfaces.remote_instaseis_db"
".RemoteInstaseisDB._download_url") as p:
p.side_effect = ValueError("random")
with pytest.raises(instaseis.InstaseisError) as err:
instaseis.open_db("http://localhost:8765432")
assert err.value.args[0] == ("Failed to connect to remote Instaseis "
"server due to: random")
# Invalid JSON returned.
with mock.patch("instaseis.database_interfaces.remote_instaseis_db"
".RemoteInstaseisDB._download_url") as p:
p.return_value = {"a": "b"}
with pytest.raises(instaseis.InstaseisError) as err:
instaseis.open_db("http://localhost:8765432")
assert err.value.args[0].startswith("Instaseis server responded with "
"invalid response:")
# Incompatible version number - should raise a warning.
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
with mock.patch("instaseis.database_interfaces.remote_instaseis_db"
".RemoteInstaseisDB._download_url") as p_1:
p_1.return_value = {
"type": "Instaseis Remote Server",
"datetime": "2001-01-01",
"version": "test version",
}
try:
instaseis.open_db("http://localhost:8765432")
except Exception:
pass
assert len(w) == 1
assert w[0].message.args[0].startswith("Instaseis versions on server")
def test_initialization_failures():
"""
Tests various initialization failures for the remote instaseis db.
"""
# Random error during init.
with mock.patch("instaseis.database_interfaces.remote_instaseis_db"
".RemoteInstaseisDB._download_url") as p:
p.side_effect = ValueError("random")
with pytest.raises(instaseis.InstaseisError) as err:
instaseis.open_db("http://localhost:8765432")
assert err.value.args[0] == ("Failed to connect to remote Instaseis "
"server due to: random")
# Invalid JSON returned.
with mock.patch("instaseis.database_interfaces.remote_instaseis_db"
".RemoteInstaseisDB._download_url") as p:
p.return_value = {"a": "b"}
with pytest.raises(instaseis.InstaseisError) as err:
instaseis.open_db("http://localhost:8765432")
assert err.value.args[0].startswith("Instaseis server responded with "
"invalid response:")
# Incompatible version number - should raise a warning.
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
with mock.patch("instaseis.database_interfaces.remote_instaseis_db"
".RemoteInstaseisDB._download_url") as p_1:
p_1.return_value = {"type": "Instaseis Remote Server",
"datetime": "2001-01-01",
"version": "test version"}
try:
instaseis.open_db("http://localhost:8765432")
except:
pass
assert len(w) == 1
assert w[0].message.args[0].startswith('Instaseis versions on server')
stf = 2 * np.exp(-(t/t_half)**2) * t / t_half**2
nsample = len(t)
f = open('../stf_test.txt', 'w')
f.write('%d %f\n'%(nsample, dt))
for y in stf:
f.write('%f\n'%(y))
f.close()
print sum(stf*dt)
db = instaseis.open_db('../wavefield/bwd')
receiver = instaseis.Receiver(latitude = 30, longitude = 0, network='MC', station='kerner')
source = instaseis.Source(latitude = 90.0,
longitude = 0.0,
depth_in_m=0.0,
m_rr=1.0e13,
m_tt=1.0e13,
m_pp=1.0e13,
m_rt=0.0,
m_rp=0.0,
m_tp=0.0,
time_shift=None,
sliprate=stf,
dt=dt)
source.resample_sliprate(db.info.dt, db.info.npts)
def compute_correlation(input_files, all_conf, nsrc, all_ns, taper,
insta=False):
"""
Compute noise cross-correlations from two .h5 'wavefield' files.
Noise source distribution and spectrum is given by starting_model.h5
It is assumed that noise sources are delta-correlated in space.
Metainformation: Include the reference station names for both stations
from wavefield files, if possible. Do not include geographic information
from .csv file as this might be error-prone. Just add the geographic
info later if needed.
"""
wf1, wf2 = input_files
ntime, n, n_corr, Fs = all_ns
ntraces = nsrc.src_loc[0].shape[0]
correlation = np.zeros(n_corr)
if insta:
# open database
dbpath = all_conf.config['wavefield_path']
# open
db = instaseis.open_db(dbpath)
# get receiver locations
station1 = wf1[0]
station2 = wf2[0]
lat1 = geograph_to_geocent(float(wf1[2]))
lon1 = float(wf1[3])
rec1 = instaseis.Receiver(latitude=lat1, longitude=lon1)
lat2 = geograph_to_geocent(float(wf2[2]))
lon2 = float(wf2[3])
rec2 = instaseis.Receiver(latitude=lat2, longitude=lon2)
else:
wf1 = WaveField(wf1)
wf2 = WaveField(wf2)
station1 = wf1.stats['reference_station']
station2 = wf2.stats['reference_station']
# Make sure all is consistent
if False in (wf1.sourcegrid[1, 0:10] == wf2.sourcegrid[1, 0:10]):
raise ValueError("Wave fields not consistent.")
if False in (wf1.sourcegrid[1, -10:] == wf2.sourcegrid[1, -10:]):
raise ValueError("Wave fields not consistent.")
if False in (wf1.sourcegrid[0, -10:] == nsrc.src_loc[0, -10:]):
raise ValueError("Wave field and source not consistent.")
# Loop over source locations
print_each_n = max(5, round(max(ntraces // 5, 1), -1))
for i in range(ntraces):
# noise source spectrum at this location
S = nsrc.get_spect(i)
if S.sum() == 0.:
# If amplitude is 0, continue. (Spectrum has 0 phase anyway.)
continue
if insta:
# get source locations
lat_src = geograph_to_geocent(nsrc.src_loc[1, i])
lon_src = nsrc.src_loc[0, i]
fsrc = instaseis.ForceSource(latitude=lat_src,
longitude=lon_src,
f_r=1.e12)
Fs = all_conf.config['wavefield_sampling_rate']
s1 = db.get_seismograms(source=fsrc, receiver=rec1,
dt=1. / Fs)[0].data * taper
s2 = db.get_seismograms(source=fsrc, receiver=rec2,
dt=1. / Fs)[0].data * taper
s1 = np.ascontiguousarray(s1)
s2 = np.ascontiguousarray(s2)
spec1 = np.fft.rfft(s1, n)
spec2 = np.fft.rfft(s2, n)
else:
if not wf1.fdomain:
# read Green's functions
s1 = np.ascontiguousarray(wf1.data[i, :] * taper)
s2 = np.ascontiguousarray(wf2.data[i, :] * taper)
# Fourier transform for greater ease of convolution
spec1 = np.fft.rfft(s1, n)
spec2 = np.fft.rfft(s2, n)
else:
spec1 = np.ascontiguousarray(wf1.data[i, :])
spec2 = np.ascontiguousarray(wf2.data[i, :])
# convolve G1G2
g1g2_tr = np.multiply(np.conjugate(spec1), spec2)
# convolve noise source
c = np.multiply(g1g2_tr, S)
# transform back
correlation += my_centered(np.fft.fftshift(np.fft.irfft(c, n)),
n_corr) * nsrc.surf_area[i]
# occasional info
if i % print_each_n == 0 and all_conf.config['verbose']:
print("Finished {} of {} source locations.".format(i, ntraces))
# end of loop over all source locations #######################################
return(correlation, station1, station2)
def dosynthetics(database_path, quake_origins, inv=None, inv_list=None, stream=None, stream_file_name='insta_stream.pickle'):
"""
Routine to create synthetic data using instaseis.
:param database_path:
:type database_path:
:param quake_origins:
:type quake_origins: dict from create_quake_origins
"""
if None in quake_origins.viewvalues():
msg = '"None" values in quake_origins are not allowed, check and set again'
raise IOError(msg)
db = ins.open_db(database_path)
source = ins.Source(
latitude = quake_origins['latitude'],
longitude = quake_origins['longitude'],
depth_in_m = quake_origins['depth_in_m'],
m_rr = quake_origins['m_rr'],
m_tt = quake_origins['m_tt'],
m_pp = quake_origins['m_pp'],
m_rt = quake_origins['m_rt'],
m_rp = quake_origins['m_rp'],
m_tp = quake_origins['m_rp'],
origin_time = quake_origins['tofe']
)
# Prepare synthetic stream and inv.
if stream_file_name:
prefix = stream_file_name.split('.')
inv_file_name = prefix[0] + '_inv.xml'
cat_file_name = prefix[0] + '_cat.xml'
else:
inv_file_name = 'inv_tmp.xml'
cat_file_name = 'cat_tmp.xml'
receiver_synth = []
invlist = []
if stream:
for trace in stream:
receiver_synth.append(ins.Receiver(latitude=str(trace.stats.coordinates['latitude']), longitude=str(trace.stats.coordinates['longitude']),
network=str(trace.stats.network), station=str(trace.stats.station)))
elif inv and not stream:
network = inv[0]
for station in network:
receiver_synth.append(ins.Receiver(latitude=str(station.latitude), longitude=str(station.longitude), network=str(network.code), station=str(station.code) ))
elif inv_list:
for i, station in enumerate(inv_list):
receiver_synth.append(ins.Receiver(latitude=str(station[0]), longitude=str(station[1]), network=str('X'), station='X' + str(i) ))
st_synth = []
for i in range(len(x)):
st_synth.append(db.get_seismograms(source=source, receiver=receiver_synth[i]))
stream=st_synth[0]
for i in range(len(st_synth))[1:]:
stream.append(st_synth[i][0])
writeQuakeML(cat_file_name, quake_origins['tofe'], quake_origins['latitude'], quake_origins['longitude'], quake_origins['depth_in_m'])
if not inv:
writeStationML(inv_file_name)
inv=read_inv(inv_file_name)
cat=read_cat(cat_file_name)
if stream_file_name:
stream.write(stream_file_name, format='pickle')
else:
os.remove(cat_file_name)
if inv:
os.remove(inv_file_name)
return stream, inv, cat
def test_finite_source_retrieval(reciprocal_clients, usgs_param):
"""
Tests if the finite sources requested from the server are identical to
the one requested with the local instaseis client with some required
tweaks.
"""
client = reciprocal_clients
db = instaseis.open_db(client.filepath)
basic_parameters = {
"receiverlongitude": 11,
"receiverlatitude": 22,
"receiverdepthinmeters": 0,
"format": "miniseed"
}
with io.open(usgs_param, "rb") as fh:
body = fh.read()
# default parameters
params = copy.deepcopy(basic_parameters)
request = client.fetch(_assemble_url('finite_source', **params),
method="POST",
body=body)
assert request.code == 200
st_server = obspy.read(request.buffer)
for tr in st_server:
assert tr.stats._format == "MSEED"
# Parse the finite source.
fs = _parse_finite_source(usgs_param)
rec = instaseis.Receiver(latitude=22,
longitude=11,
network="XX",
station="SYN",
location="SE")
st_db = db.get_seismograms_finite_source(sources=fs, receiver=rec)
# The origin time is the time of the first sample in the route.
for tr in st_db:
# Cut away the first ten samples as they have been previously added.
tr.data = tr.data[10:]
tr.stats.starttime = obspy.UTCDateTime(1900, 1, 1)
for tr_db, tr_server in zip(st_db, st_server):
# Sample spacing is very similar but not equal due to floating point
# accuracy.
np.testing.assert_allclose(tr_server.stats.delta, tr_db.stats.delta)
tr_server.stats.delta = tr_db.stats.delta
del tr_server.stats._format
del tr_server.stats.mseed
assert tr_db.stats == tr_server.stats
np.testing.assert_allclose(tr_db.data, tr_server.data)
# Once again but this time request a SAC file.
params = copy.deepcopy(basic_parameters)
params["format"] = "saczip"
request = client.fetch(_assemble_url('finite_source', **params),
method="POST",
body=body)
assert request.code == 200
st_server = obspy.Stream()
zip_obj = zipfile.ZipFile(request.buffer)
for name in zip_obj.namelist():
st_server += obspy.read(io.BytesIO(zip_obj.read(name)))
for tr in st_server:
assert tr.stats._format == "SAC"
for tr_db, tr_server in zip(st_db, st_server):
# Sample spacing is very similar but not equal due to floating point
# accuracy.
np.testing.assert_allclose(tr_server.stats.delta, tr_db.stats.delta)
tr_server.stats.delta = tr_db.stats.delta
del tr_server.stats._format
del tr_server.stats.sac
assert tr_db.stats == tr_server.stats
np.testing.assert_allclose(tr_db.data, tr_server.data)
# One with a label.
params = copy.deepcopy(basic_parameters)
params["label"] = "random_things"
request = client.fetch(_assemble_url('finite_source', **params),
method="POST",
body=body)
assert request.code == 200
cd = request.headers["Content-Disposition"]
assert cd.startswith("attachment; filename=random_things_")
assert cd.endswith(".mseed")
# One simulating a crash in the underlying function.
params = copy.deepcopy(basic_parameters)
with mock.patch("instaseis.database_interfaces.base_instaseis_db"
".BaseInstaseisDB.get_seismograms_finite_source") as p:
p.side_effect = ValueError("random crash")
request = client.fetch(_assemble_url('finite_source', **params),
method="POST",
body=body)
assert request.code == 400
assert request.reason == ("Could not extract finite source seismograms. "
"Make sure, the parameters are valid, and the "
"depth settings are correct.")
# Simulating a logic error that should not be able to happen.
params = copy.deepcopy(basic_parameters)
with mock.patch("instaseis.database_interfaces.base_instaseis_db"
".BaseInstaseisDB.get_seismograms_finite_source") as p:
# Longer than the database returned stream thus the endtime is out
# of bounds.
st = obspy.read()
p.return_value = st
request = client.fetch(_assemble_url('finite_source', **params),
method="POST",
body=body)
assert request.code == 500
assert request.reason.startswith("Endtime larger than the extracted "
"endtime")
# One more with resampling parameters and different units.
params = copy.deepcopy(basic_parameters)
# We must have a sampling rate that cleanly fits in the existing one,
# otherwise we cannot fake the cutting.
dt_new = 24.724845445855724 / 10
params["dt"] = dt_new
params["kernelwidth"] = 2
params["units"] = "acceleration"
st_db = db.get_seismograms_finite_source(sources=fs,
receiver=rec,
dt=dt_new,
kernelwidth=2,
kind="acceleration")
# The origin time is the time of the first sample in the route.
for tr in st_db:
# Cut away the first ten samples as they have been previously added.
tr.data = tr.data[100:]
tr.stats.starttime = obspy.UTCDateTime(1900, 1, 1)
request = client.fetch(_assemble_url('finite_source', **params),
method="POST",
body=body)
assert request.code == 200
st_server = obspy.read(request.buffer)
# Cut some parts in the middle to avoid any potential boundary effects.
st_db.trim(obspy.UTCDateTime(1900, 1, 1, 0, 4),
obspy.UTCDateTime(1900, 1, 1, 0, 14))
st_server.trim(obspy.UTCDateTime(1900, 1, 1, 0, 4),
obspy.UTCDateTime(1900, 1, 1, 0, 14))
for tr_db, tr_server in zip(st_db, st_server):
# Sample spacing and times are very similar but not identical due to
# floating point inaccuracies in the arithmetics.
np.testing.assert_allclose(tr_server.stats.delta, tr_db.stats.delta)
np.testing.assert_allclose(tr_server.stats.starttime.timestamp,
tr_db.stats.starttime.timestamp)
tr_server.stats.delta = tr_db.stats.delta
tr_server.stats.starttime = tr_db.stats.starttime
del tr_server.stats._format
del tr_server.stats.mseed
del tr_server.stats.processing
del tr_db.stats.processing
np.testing.assert_allclose(tr_server.stats.delta, tr_db.stats.delta)
assert tr_db.stats == tr_server.stats
np.testing.assert_allclose(tr_db.data,
tr_server.data,
rtol=1E-7,
atol=tr_db.data.ptp() * 1E-7)
# Testing network and station code parameters.
# Default values.
params = copy.deepcopy(basic_parameters)
request = client.fetch(_assemble_url('finite_source', **params),
method="POST",
body=body)
assert request.code == 200
st_server = obspy.read(request.buffer)
for tr in st_server:
assert tr.stats.network == "XX"
assert tr.stats.station == "SYN"
assert tr.stats.location == "SE"
# Setting all three.
params = copy.deepcopy(basic_parameters)
params["networkcode"] = "AA"
params["stationcode"] = "BB"
params["locationcode"] = "CC"
request = client.fetch(_assemble_url('finite_source', **params),
method="POST",
body=body)
assert request.code == 200
st_server = obspy.read(request.buffer)
for tr in st_server:
assert tr.stats.network == "AA"
assert tr.stats.station == "BB"
assert tr.stats.location == "CC"
# Setting only the location code.
params = copy.deepcopy(basic_parameters)
params["locationcode"] = "AA"
request = client.fetch(_assemble_url('finite_source', **params),
method="POST",
body=body)
assert request.code == 200
st_server = obspy.read(request.buffer)
for tr in st_server:
assert tr.stats.network == "XX"
assert tr.stats.station == "SYN"
assert tr.stats.location == "AA"
# Test the scale parameter.
params = copy.deepcopy(basic_parameters)
params["scale"] = 33.33
request = client.fetch(_assemble_url('finite_source', **params),
method="POST",
body=body)
assert request.code == 200
st_server = obspy.read(request.buffer)
for tr in st_server:
assert tr.stats._format == "MSEED"
# Parse the finite source.
fs = _parse_finite_source(usgs_param)
rec = instaseis.Receiver(latitude=22,
longitude=11,
network="XX",
station="SYN",
location="SE")
st_db = db.get_seismograms_finite_source(sources=fs, receiver=rec)
# The origin time is the time of the first sample in the route.
for tr in st_db:
# Multiply with scale parameter.
tr.data *= 33.33
# Cut away the first ten samples as they have been previously added.
tr.data = tr.data[10:]
tr.stats.starttime = obspy.UTCDateTime(1900, 1, 1)
for tr_db, tr_server in zip(st_db, st_server):
# Sample spacing is very similar but not equal due to floating point
# accuracy.
np.testing.assert_allclose(tr_server.stats.delta, tr_db.stats.delta)
tr_server.stats.delta = tr_db.stats.delta
del tr_server.stats._format
del tr_server.stats.mseed
assert tr_db.stats == tr_server.stats
np.testing.assert_allclose(tr_db.data,
tr_server.data,
atol=1E-6 * tr_db.data.ptp())
help='Number of seismograms to be calculated for each '
'benchmark. Overwrites any time limitations if '
'given.')
parser.add_argument('--save', action="store_true",
help='save output to txt file')
args = parser.parse_args()
path = os.path.abspath(args.folder) if "://" not in args.folder \
else args.folder
print(colorama.Fore.GREEN + 79 * "=" + "\nInstaseis Benchmark Suite\n")
print("It enables to gauge the speed of Instaseis for a certain DB.")
print(79 * "=" + colorama.Fore.RESET)
print(colorama.Fore.RED + "\nIt does not deal with OS level caches! So "
"interpret the results accordingly!\n" + colorama.Fore.RESET)
db = open_db(path, read_on_demand=True, buffer_size_in_mb=0)
if not db.info.is_reciprocal:
print("Benchmark currently only works with a reciprocal database.")
sys.exit(1)
print(db)
# Recursively get all subclasses of the benchmark class.
def get_subclasses(cls):
subclasses = []
sub = cls.__subclasses__()
subclasses.extend(sub)
for subclass in sub:
subclasses.extend(get_subclasses(subclass))
def setup(self):
self.db = open_db(self.path, read_on_demand=True, buffer_size_in_mb=0)
self.max_depth = self.db.info.max_radius - self.db.info.min_radius
def test_finite_source_retrieval(reciprocal_clients, usgs_param):
"""
Tests if the finite sources requested from the server are identical to
the one requested with the local instaseis client with some required
tweaks.
"""
client = reciprocal_clients
db = instaseis.open_db(client.filepath)
basic_parameters = {
"receiverlongitude": 11,
"receiverlatitude": 22,
"receiverdepthinmeters": 0,
"format": "miniseed"}
with io.open(usgs_param, "rb") as fh:
body = fh.read()
# default parameters
params = copy.deepcopy(basic_parameters)
request = client.fetch(_assemble_url('finite_source', **params),
method="POST", body=body)
assert request.code == 200
st_server = obspy.read(request.buffer)
for tr in st_server:
assert tr.stats._format == "MSEED"
# Parse the finite source.
fs = _parse_finite_source(usgs_param)
rec = instaseis.Receiver(latitude=22, longitude=11, network="XX",
station="SYN", location="SE")
st_db = db.get_seismograms_finite_source(sources=fs, receiver=rec)
# The origin time is the time of the first sample in the route.
for tr in st_db:
# Cut away the first ten samples as they have been previously added.
tr.data = tr.data[10:]
tr.stats.starttime = obspy.UTCDateTime(1900, 1, 1)
for tr_db, tr_server in zip(st_db, st_server):
# Sample spacing is very similar but not equal due to floating point
# accuracy.
np.testing.assert_allclose(tr_server.stats.delta, tr_db.stats.delta)
tr_server.stats.delta = tr_db.stats.delta
del tr_server.stats._format
del tr_server.stats.mseed
assert tr_db.stats == tr_server.stats
np.testing.assert_allclose(tr_db.data, tr_server.data)
# Once again but this time request a SAC file.
params = copy.deepcopy(basic_parameters)
params["format"] = "saczip"
request = client.fetch(_assemble_url('finite_source', **params),
method="POST", body=body)
assert request.code == 200
st_server = obspy.Stream()
zip_obj = zipfile.ZipFile(request.buffer)
for name in zip_obj.namelist():
st_server += obspy.read(io.BytesIO(zip_obj.read(name)))
for tr in st_server:
assert tr.stats._format == "SAC"
for tr_db, tr_server in zip(st_db, st_server):
# Sample spacing is very similar but not equal due to floating point
# accuracy.
np.testing.assert_allclose(tr_server.stats.delta, tr_db.stats.delta)
tr_server.stats.delta = tr_db.stats.delta
del tr_server.stats._format
del tr_server.stats.sac
assert tr_db.stats == tr_server.stats
np.testing.assert_allclose(tr_db.data, tr_server.data)
# One with a label.
params = copy.deepcopy(basic_parameters)
params["label"] = "random_things"
request = client.fetch(_assemble_url('finite_source', **params),
method="POST", body=body)
assert request.code == 200
cd = request.headers["Content-Disposition"]
assert cd.startswith("attachment; filename=random_things_")
assert cd.endswith(".mseed")
# One simulating a crash in the underlying function.
params = copy.deepcopy(basic_parameters)
with mock.patch("instaseis.database_interfaces.base_instaseis_db"
".BaseInstaseisDB.get_seismograms_finite_source") as p:
p.side_effect = ValueError("random crash")
request = client.fetch(_assemble_url('finite_source', **params),
method="POST", body=body)
assert request.code == 400
assert request.reason == ("Could not extract finite source seismograms. "
"Make sure, the parameters are valid, and the "
"depth settings are correct.")
# Simulating a logic error that should not be able to happen.
params = copy.deepcopy(basic_parameters)
with mock.patch("instaseis.database_interfaces.base_instaseis_db"
".BaseInstaseisDB.get_seismograms_finite_source") as p:
# Longer than the database returned stream thus the endtime is out
# of bounds.
st = obspy.read()
p.return_value = st
request = client.fetch(_assemble_url('finite_source', **params),
method="POST", body=body)
assert request.code == 500
assert request.reason.startswith("Endtime larger than the extracted "
"endtime")
# One more with resampling parameters and different units.
params = copy.deepcopy(basic_parameters)
# We must have a sampling rate that cleanly fits in the existing one,
# otherwise we cannot fake the cutting.
dt_new = 24.724845445855724 / 10
params["dt"] = dt_new
params["kernelwidth"] = 2
params["units"] = "acceleration"
st_db = db.get_seismograms_finite_source(sources=fs, receiver=rec,
dt=dt_new, kernelwidth=2,
kind="acceleration")
# The origin time is the time of the first sample in the route.
for tr in st_db:
# Cut away the first ten samples as they have been previously added.
tr.data = tr.data[100:]
tr.stats.starttime = obspy.UTCDateTime(1900, 1, 1)
request = client.fetch(_assemble_url('finite_source', **params),
method="POST", body=body)
assert request.code == 200
st_server = obspy.read(request.buffer)
# Cut some parts in the middle to avoid any potential boundary effects.
st_db.trim(obspy.UTCDateTime(1900, 1, 1, 0, 4),
obspy.UTCDateTime(1900, 1, 1, 0, 14))
st_server.trim(obspy.UTCDateTime(1900, 1, 1, 0, 4),
obspy.UTCDateTime(1900, 1, 1, 0, 14))
for tr_db, tr_server in zip(st_db, st_server):
# Sample spacing and times are very similar but not identical due to
# floating point inaccuracies in the arithmetics.
np.testing.assert_allclose(tr_server.stats.delta, tr_db.stats.delta)
np.testing.assert_allclose(tr_server.stats.starttime.timestamp,
tr_db.stats.starttime.timestamp)
tr_server.stats.delta = tr_db.stats.delta
tr_server.stats.starttime = tr_db.stats.starttime
del tr_server.stats._format
del tr_server.stats.mseed
del tr_server.stats.processing
del tr_db.stats.processing
np.testing.assert_allclose(tr_server.stats.delta, tr_db.stats.delta)
assert tr_db.stats == tr_server.stats
np.testing.assert_allclose(tr_db.data, tr_server.data,
rtol=1E-7, atol=tr_db.data.ptp() * 1E-7)
# Testing network and station code parameters.
# Default values.
params = copy.deepcopy(basic_parameters)
request = client.fetch(_assemble_url('finite_source', **params),
method="POST", body=body)
assert request.code == 200
st_server = obspy.read(request.buffer)
for tr in st_server:
assert tr.stats.network == "XX"
assert tr.stats.station == "SYN"
assert tr.stats.location == "SE"
# Setting all three.
params = copy.deepcopy(basic_parameters)
params["networkcode"] = "AA"
params["stationcode"] = "BB"
params["locationcode"] = "CC"
request = client.fetch(_assemble_url('finite_source', **params),
method="POST", body=body)
assert request.code == 200
st_server = obspy.read(request.buffer)
for tr in st_server:
assert tr.stats.network == "AA"
assert tr.stats.station == "BB"
assert tr.stats.location == "CC"
# Setting only the location code.
params = copy.deepcopy(basic_parameters)
params["locationcode"] = "AA"
request = client.fetch(_assemble_url('finite_source', **params),
method="POST", body=body)
assert request.code == 200
st_server = obspy.read(request.buffer)
for tr in st_server:
assert tr.stats.network == "XX"
assert tr.stats.station == "SYN"
assert tr.stats.location == "AA"
# Test the scale parameter.
params = copy.deepcopy(basic_parameters)
params["scale"] = 33.33
request = client.fetch(_assemble_url('finite_source', **params),
method="POST", body=body)
assert request.code == 200
st_server = obspy.read(request.buffer)
for tr in st_server:
assert tr.stats._format == "MSEED"
# Parse the finite source.
fs = _parse_finite_source(usgs_param)
rec = instaseis.Receiver(latitude=22, longitude=11, network="XX",
station="SYN", location="SE")
st_db = db.get_seismograms_finite_source(sources=fs, receiver=rec)
# The origin time is the time of the first sample in the route.
for tr in st_db:
# Multiply with scale parameter.
tr.data *= 33.33
# Cut away the first ten samples as they have been previously added.
tr.data = tr.data[10:]
tr.stats.starttime = obspy.UTCDateTime(1900, 1, 1)
for tr_db, tr_server in zip(st_db, st_server):
# Sample spacing is very similar but not equal due to floating point
# accuracy.
np.testing.assert_allclose(tr_server.stats.delta, tr_db.stats.delta)
tr_server.stats.delta = tr_db.stats.delta
del tr_server.stats._format
del tr_server.stats.mseed
assert tr_db.stats == tr_server.stats
np.testing.assert_allclose(tr_db.data, tr_server.data,
atol=1E-6 * tr_db.data.ptp())
dt = 1.0
t_half = 10.0
t = np.arange(0,100,dt)
stf = 2 * np.exp(-(t/t_half)**2) * t / t_half**2
nsample = len(t)
f = open('./stf_pyffproc.dat', 'w')
f.write('%d %f\n'%(nsample, dt))
for y in stf:
f.write('%f\n'%(y))
f.close()
# Open instaseis db
db = instaseis.open_db("/scratch/auerl/wavefield_pyffproc_10s_647km_prem_ani/bwd/")
#db = instaseis.open_db('../wavefield/bwd')
receiver = instaseis.Receiver(latitude=-51.68, longitude=-58.06, network="AB", station="EFI")
source = instaseis.Source(latitude = -13.8200,
longitude = -67.2500,
depth_in_m = 647100,
m_rr = -7.590000e+27 / 1E7,
m_tt = 7.750000e+27 / 1E7,
m_pp = -1.600000e+26 / 1E7,
m_rt = -2.503000e+28 / 1E7,
m_rp = 4.200000e+26 / 1E7,
m_tp = -2.480000e+27 / 1E7,
time_shift=None,
sliprate=stf,
dt=dt)
parser = argparse.ArgumentParser(description=helptext,
formatter_class=formatter_class)
helptext = "Database 1 directory name. \n"
parser.add_argument('db_1_name', help=helptext)
helptext = "Database 2 directory name. \n"
parser.add_argument('db_2_name', help=helptext)
return parser
if __name__ == "__main__":
parser = define_arguments()
args = parser.parse_args()
db1 = instaseis.open_db(args.db_1_name)
db2 = instaseis.open_db(args.db_2_name)
src = instaseis.Source(latitude=0.0, longitude=0.0, m_rr=1e20)
rec = instaseis.Receiver(latitude=45.0, longitude=0.0)
st1 = db1.get_seismograms(src, rec)
st2 = db2.get_seismograms(src, rec)
plt.plot(st1[0].times(), st1[0].data, label=args.db_1_name)
plt.plot(st2[0].times(), st2[0].data, label=args.db_2_name)
plt.xlabel('time / seconds')
plt.legend()
def calc_static_offset(src_file, db_dir, nx=200, ny=200):
import obspy
import instaseis
db = instaseis.open_db(db_dir)
print db
source = instaseis.FiniteSource.from_usgs_param_file(src_file, dt=db.info.dt)
print source
pntsrc_lats = np.zeros(source.npointsources)
pntsrc_lons = np.zeros(source.npointsources)
pntsrc_depth = np.zeros(source.npointsources)
for i in range(0, source.npointsources):
pntsrc_depth[i] = source.pointsources[i].depth_in_m
pntsrc_lats[i] = source.pointsources[i].latitude
pntsrc_lons[i] = source.pointsources[i].longitude
x_extent = source.max_longitude - source.min_longitude
y_extent = source.max_latitude - source.min_latitude
extent = np.max((x_extent, y_extent))
latmin = source.hypocenter_latitude - extent * 1.5
lonmin = source.hypocenter_longitude - extent * 1.5
latmax = source.hypocenter_latitude + extent * 1.5
lonmax = source.hypocenter_longitude + extent * 1.5
print 'Window: ', latmin, latmax, lonmin, lonmax
lats = []
lons = []
offset = []
lats, lons = np.meshgrid(np.linspace(latmin, latmax, nx),
np.linspace(lonmin, lonmax, ny))
offset_E = np.zeros_like(lats)
offset_N = np.zeros_like(lats)
offset_Z = np.zeros_like(lats)
# Define progress bar
widgets = ['Calculating displacement: ', Percentage(), ' ',
Bar(), ' ', ETA()]
pbar = ProgressBar(widgets=widgets, maxval=nx).start()
for ix in range(0, lats.shape[0]):
for iy in range(0, lats.shape[1]):
npts = db.info.npts
rec = instaseis.Receiver(latitude=lats[ix, iy], longitude=lons[ix, iy])
st = db.get_seismograms_finite_source(sources=source, receiver=rec, components='ENZ')
offset_E[ix, iy] = np.mean(st.select(channel='LXE')[0].data[npts*0.5:npts])
offset_N[ix, iy] = np.mean(st.select(channel='LXN')[0].data[npts*0.5:npts])
offset_Z[ix, iy] = np.mean(st.select(channel='LXZ')[0].data[npts*0.5:npts])
# Update Progress Bar
pbar.update(ix)
all_data = [lats, lons, offset_E, offset_N, offset_Z]
fnam = '%s.npy' % (os.path.splitext(src_file)[0])
np.save(fnam, all_data, allow_pickle=True)
return all_data
def g1g2_kern(wf1str,wf2str,kernel,adjt,
src,source_conf,insta):
measr_conf = json.load(open(os.path.join(source_conf['source_path'],
'measr_config.json')))
bandpass = measr_conf['bandpass']
if bandpass == None:
filtcnt = 1
elif type(bandpass) == list:
if type(bandpass[0]) != list:
filtcnt = 1
else:
filtcnt = len(bandpass)
ntime, n, n_corr, Fs = get_ns(wf1str,source_conf,insta)
# use a one-sided taper: The seismogram probably has a non-zero end,
# being cut off whereever the solver stopped running.
taper = cosine_taper(ntime,p=0.01)
taper[0:ntime//2] = 1.0
########################################################################
# Prepare filenames and adjoint sources
########################################################################
filenames = []
adjt_srcs = []
adjt_srcs_cnt = 0
for ix_f in range(filtcnt):
filename = kernel+'.{}.npy'.format(ix_f)
filenames.append(filename)
#if os.path.exists(filename):
# continue
f = Stream()
for a in adjt:
adjtfile = a + '*.{}.sac'.format(ix_f)
adjtfile = glob(adjtfile)
try:
f += read(adjtfile[0])[0]
f[-1].data = my_centered(f[-1].data,n_corr)
adjt_srcs_cnt += 1
except IndexError:
print('No adjoint source found: {}\n'.format(a))
break
adjt_srcs.append(f)
########################################################################
# Compute the kernels
########################################################################
with NoiseSource(src) as nsrc:
ntraces = nsrc.src_loc[0].shape[0]
if insta:
# open database
dbpath = json.load(open(os.path.join(source_conf['project_path'],
'config.json')))['wavefield_path']
# open and determine Fs, nt
db = instaseis.open_db(dbpath)
# get receiver locations
lat1 = geograph_to_geocent(float(wf1[2]))
lon1 = float(wf1[3])
rec1 = instaseis.Receiver(latitude=lat1,longitude=lon1)
lat2 = geograph_to_geocent(float(wf2[2]))
lon2 = float(wf2[3])
rec2 = instaseis.Receiver(latitude=lat2,longitude=lon2)
else:
wf1 = WaveField(wf1str)
wf2 = WaveField(wf2str)
kern = np.zeros((filtcnt,ntraces,len(adjt)))
########################################################################
# Loop over locations
########################################################################
for i in range(ntraces):
# noise source spectrum at this location
# For the kernel, this contains only the basis functions of the
# spectrum without weights; might still be location-dependent,
# for example when constraining sensivity to ocean
S = nsrc.get_spect(i)
if S.sum() == 0.:
# The spectrum has 0 phase so only checking absolute value here
continue
####################################################################
# Get synthetics
####################################################################
if insta:
# get source locations
lat_src = geograph_to_geocent(nsrc.src_loc[1,i])
lon_src = nsrc.src_loc[0,i]
fsrc = instaseis.ForceSource(latitude=lat_src,
longitude=lon_src,f_r=1.e12)
s1 = np.ascontiguousarray(db.get_seismograms(source=fsrc,
receiver=rec1,
dt=1./source_conf['sampling_rate'])[0].data*taper)
s2 = np.ascontiguousarray(db.get_seismograms(source=fsrc,
receiver=rec2,
dt=1./source_conf['sampling_rate'])[0].data*taper)
else:
s1 = np.ascontiguousarray(wf1.data[i,:]*taper)
s2 = np.ascontiguousarray(wf2.data[i,:]*taper)
spec1 = np.fft.rfft(s1,n)
spec2 = np.fft.rfft(s2,n)
g1g2_tr = np.multiply(np.conjugate(spec1),spec2)
c = np.multiply(g1g2_tr,S)
#######################################################################
# Get Kernel at that location
#######################################################################
corr_temp = my_centered(np.fft.ifftshift(np.fft.irfft(c,n)),n_corr)
#######################################################################
# Apply the 'adjoint source'
#######################################################################
for ix_f in range(filtcnt):
f = adjt_srcs[ix_f]
if f==None:
continue
for j in range(len(f)):
delta = f[j].stats.delta
kern[ix_f,i,j] = np.dot(corr_temp,f[j].data) * delta
#elif measr_conf['mtype'] in ['envelope']:
# if j == 0:
# corr_temp_h = corr_temp
# print(corr_temp_h)
# if j == 1:
# corr_temp_h = hilbert(corr_temp)
# print(corr_temp_h)
#
# kern[ix_f,i,j] = np.dot(corr_temp,f[j].data) * delta
if i%50000 == 0:
print("Finished {} source locations.".format(i))
if not insta:
wf1.file.close()
wf2.file.close()
for ix_f in range(filtcnt):
filename = filenames[ix_f]
if kern[ix_f,:,:].sum() != 0:
np.save(filename,kern[ix_f,:,:])
return()
"given.",
)
parser.add_argument("--save",
action="store_true",
help="save output to txt file")
args = parser.parse_args()
path = (os.path.abspath(args.folder)
if "://" not in args.folder else args.folder)
print(colorama.Fore.GREEN + 79 * "=" + "\nInstaseis Benchmark Suite\n")
print("It enables to gauge the speed of Instaseis for a certain DB.")
print(79 * "=" + colorama.Fore.RESET)
print(colorama.Fore.RED + "\nIt does not deal with OS level caches! So "
"interpret the results accordingly!\n" + colorama.Fore.RESET)
db = open_db(path, read_on_demand=True, buffer_size_in_mb=0)
if not db.info.is_reciprocal:
print("Benchmark currently only works with a reciprocal database.")
sys.exit(1)
print(db)
# Recursively get all subclasses of the benchmark class.
def get_subclasses(cls):
subclasses = []
sub = cls.__subclasses__()
subclasses.extend(sub)
for subclass in sub:
subclasses.extend(get_subclasses(subclass))
def setup(self):
self.db = open_db(self.path,
read_on_demand=False,
buffer_size_in_mb=250)
def syngine_client():
return instaseis.open_db("syngine://test")
def test_seismogram_extraction(syngine_client):
"""
Test the seismogram extraction from local and syngine databases.
"""
# syngine and local database.
s_db = syngine_client
l_db = instaseis.open_db(db_path)
source = instaseis.Source(
latitude=4., longitude=3.0, depth_in_m=0, m_rr=4.71e+17, m_tt=3.81e+17,
m_pp=-4.74e+17, m_rt=3.99e+17, m_rp=-8.05e+17, m_tp=-1.23e+17)
receiver = instaseis.Receiver(latitude=10., longitude=20., depth_in_m=None)
kwargs = {"source": source, "receiver": receiver,
"components": ["Z", "N", "E", "R", "T"]}
_compare_streams(s_db, l_db, kwargs)
# Test velocity and acceleration.
kwargs = {"source": source, "receiver": receiver,
"components": ["Z", "N", "E", "R", "T"], "kind": "velocity"}
_compare_streams(s_db, l_db, kwargs)
kwargs = {"source": source, "receiver": receiver,
"components": ["Z", "N", "E", "R", "T"], "kind": "acceleration"}
_compare_streams(s_db, l_db, kwargs)
# Test remove source shift.
kwargs = {"source": source, "receiver": receiver,
"components": ["Z", "N", "E", "R", "T"],
"remove_source_shift": False}
_compare_streams(s_db, l_db, kwargs)
# Test resampling.
kwargs = {"source": source, "receiver": receiver,
"components": ["Z", "N", "E", "R", "T"],
"dt": 1.0, "kernelwidth": 6}
_compare_streams(s_db, l_db, kwargs)
# Force sources currently raise an error.
source = instaseis.ForceSource(
latitude=89.91, longitude=0.0, depth_in_m=12000,
f_r=1.23E10,
f_t=2.55E10,
f_p=1.73E10)
kwargs = {"source": source, "receiver": receiver}
with pytest.raises(ValueError) as e:
_compare_streams(s_db, l_db, kwargs)
assert e.value.args[0] == (
"The Syngine Instaseis client does currently not "
"support force sources. You can still download "
"data from the Syngine service for force "
"sources manually.")
# Test less components and a latitude of 45 degrees to have the maximal
# effect of geocentric vs geographic coordinates.
source = instaseis.Source(
latitude=45.0, longitude=3.0, depth_in_m=0, m_rr=4.71e+17,
m_tt=3.81e+17, m_pp=-4.74e+17, m_rt=3.99e+17, m_rp=-8.05e+17,
m_tp=-1.23e+17)
receiver = instaseis.Receiver(latitude=-45.0, longitude=20.0,
depth_in_m=None)
kwargs = {"source": source, "receiver": receiver,
"components": ["Z", "N", "E", "R", "T"]}
_compare_streams(s_db, l_db, kwargs)
t_half = 20.0
t = np.arange(0, 100, dt)
stf = 2 * np.exp(-(t / t_half)**2) * t / t_half**2
nsample = len(t)
f = open('../stf_test.txt', 'w')
f.write('%d %f\n' % (nsample, dt))
for y in stf:
f.write('%f\n' % (y))
f.close()
print sum(stf * dt)
db = instaseis.open_db('../wavefield/bwd')
receiver = instaseis.Receiver(latitude=30,
longitude=0,
network='MC',
station='kerner')
source = instaseis.Source(latitude=90.0,
longitude=0.0,
depth_in_m=0.0,
m_rr=1.0e13,
m_tt=1.0e13,
m_pp=1.0e13,
m_rt=0.0,
m_rp=0.0,
m_tp=0.0,
time_shift=None,
sliprate=stf,
from geopy.distance import VincentyDistance
print(instaseis.__path__)
# input directory with PICKLE data as argument
event = sys.argv[1]
dr = '/raid3/zl382/Data/' + event + '/'
###!!!! All previous synthetics can be removed from the PICKLE by this script
cleansyn = input("Do you want all previous synethetics removed? (y/n) ")
if cleansyn == 'y':
clean = True
else:
clean = False
# Load database with Green Functions
db = instaseis.open_db("syngine://prem_a_2s")
# Directory needs to contain a CMTSOLUTION source text file!!!
cat = obspy.read_events(dir + 'CMTSOLUTION')
# Read in source
source = instaseis.Source(
latitude=cat[0].origins[0].latitude,
longitude=cat[0].origins[0].longitude,
depth_in_m=cat[0].origins[0].depth,
m_rr=cat[0].focal_mechanisms[0].moment_tensor.tensor.m_rr,
m_tt=cat[0].focal_mechanisms[0].moment_tensor.tensor.m_tt,
m_pp=cat[0].focal_mechanisms[0].moment_tensor.tensor.m_pp,
m_rt=cat[0].focal_mechanisms[0].moment_tensor.tensor.m_rt,
m_rp=cat[0].focal_mechanisms[0].moment_tensor.tensor.m_rp,
m_tp=cat[0].focal_mechanisms[0].moment_tensor.tensor.m_tp,
origin_time=cat[0].origins[0].time)
def setup(self):
self.db = open_db(self.path, read_on_demand=True,
buffer_size_in_mb=0)
self.max_depth = self.db.info.max_radius - self.db.info.min_radius
def test_more_complex_queries(reciprocal_clients_all_callbacks, usgs_param):
"""
These are not exhaustive tests but test that the queries do something.
Elsewhere they are tested in more details.
Test phase relative offsets.
+ must be encoded with %2B
- must be encoded with %2D
"""
client = reciprocal_clients_all_callbacks
db = instaseis.open_db(client.filepath)
basic_parameters = {
"receiverlongitude": 11,
"receiverlatitude": 22,
"components": "".join(db.available_components),
"format": "miniseed"
}
with io.open(usgs_param, "rb") as fh:
body = fh.read()
# default parameters
params = copy.deepcopy(basic_parameters)
params["dt"] = 2
request = client.fetch(_assemble_url('finite_source', **params),
method="POST",
body=body)
assert request.code == 200
st = obspy.read(request.buffer)
# Now request one starting ten seconds later.
params = copy.deepcopy(basic_parameters)
params["starttime"] = 10
params["dt"] = 2
request = client.fetch(_assemble_url('finite_source', **params),
method="POST",
body=body)
assert request.code == 200
st_2 = obspy.read(request.buffer)
assert st[0].stats.starttime + 10 == st_2[0].stats.starttime
# The rest of data should still be identical.
np.testing.assert_allclose(st.slice(starttime=10)[0].data, st_2[0].data)
# Try with the endtime.
params = copy.deepcopy(basic_parameters)
params["endtime"] = 20
params["dt"] = 2
request = client.fetch(_assemble_url('finite_source', **params),
method="POST",
body=body)
assert request.code == 200
st_2 = obspy.read(request.buffer)
assert st_2[0].stats.endtime == st[0].stats.starttime + 20
# The rest of data should still be identical.
np.testing.assert_allclose(
st.slice(endtime=st[0].stats.starttime + 20)[0].data, st_2[0].data)
# Phase relative start and endtimes.
params = copy.deepcopy(basic_parameters)
params["starttime"] = "P%2D5"
params["endtime"] = "P%2B5"
params["dt"] = 2
request = client.fetch(_assemble_url('finite_source', **params),
method="POST",
body=body)
assert request.code == 200
st_2 = obspy.read(request.buffer)
# Just make sure they actually do something.
assert st_2[0].stats.starttime > st[0].stats.starttime
assert st_2[0].stats.endtime < st[0].stats.endtime
# Mixing things
params = copy.deepcopy(basic_parameters)
params["starttime"] = "P%2D5"
params["endtime"] = "50"
params["dt"] = 2
request = client.fetch(_assemble_url('finite_source', **params),
method="POST",
body=body)
assert request.code == 200
st_2 = obspy.read(request.buffer)
# Just make sure they actually do something.
assert st_2[0].stats.starttime > st[0].stats.starttime
assert st_2[0].stats.endtime < st[0].stats.endtime
if "Z" not in db.available_components:
return
# Network and station searches.
params = {
"network": "IU,B*",
"station": "ANT*,ANM?",
"components": "Z",
"format": "miniseed"
}
request = client.fetch(_assemble_url('finite_source', **params),
method="POST",
body=body)
assert request.code == 200
st_2 = obspy.read(request.buffer)
assert sorted(tr.id for tr in st_2) == ["IU.ANMO..LXZ", "IU.ANTO..LXZ"]
def g1g2_corr(wf1,wf2,corr_file,src,source_conf,insta):
"""
Compute noise cross-correlations from two .h5 'wavefield' files.
Noise source distribution and spectrum is given by starting_model.h5
It is assumed that noise sources are delta-correlated in space.
"""
#ToDo: check whether to include autocorrs from user (now hardcoded off)
#ToDo: Parallel loop(s)
#ToDo tests
# Metainformation: Include the reference station names for both stations
# from wavefield files, if possible. Do not include geographic information
# from .csv file as this might be error-prone. Just add the geographic
# info later if needed.
with NoiseSource(src) as nsrc:
ntime, n, n_corr, Fs = get_ns(wf1,source_conf,insta)
# use a one-sided taper: The seismogram probably has a non-zero end,
# being cut off whereever the solver stopped running.
taper = cosine_taper(ntime,p=0.01)
taper[0:ntime//2] = 1.0
ntraces = nsrc.src_loc[0].shape[0]
print(taper.shape)
correlation = np.zeros(n_corr)
if insta:
# open database
dbpath = json.load(open(os.path.join(source_conf['project_path'],
'config.json')))['wavefield_path']
# open and determine Fs, nt
db = instaseis.open_db(dbpath)
# get receiver locations
lat1 = geograph_to_geocent(float(wf1[2]))
lon1 = float(wf1[3])
rec1 = instaseis.Receiver(latitude=lat1,longitude=lon1)
lat2 = geograph_to_geocent(float(wf2[2]))
lon2 = float(wf2[3])
rec2 = instaseis.Receiver(latitude=lat2,longitude=lon2)
else:
wf1 = WaveField(wf1)
wf2 = WaveField(wf2)
# Loop over source locations
for i in range(ntraces):
# noise source spectrum at this location
S = nsrc.get_spect(i)
if S.sum() == 0.:
#If amplitude is 0, continue. (Spectrum has 0 phase anyway. )
continue
if insta:
# get source locations
lat_src = geograph_to_geocent(nsrc.src_loc[1,i])
lon_src = nsrc.src_loc[0,i]
fsrc = instaseis.ForceSource(latitude=lat_src,
longitude=lon_src,f_r=1.e12)
s1 = np.ascontiguousarray(db.get_seismograms(source=fsrc,
receiver=rec1,
dt=1./source_conf['sampling_rate'])[0].data*taper)
s2 = np.ascontiguousarray(db.get_seismograms(source=fsrc,
receiver=rec2,
dt=1./source_conf['sampling_rate'])[0].data*taper)
else:
# read Green's functions
s1 = np.ascontiguousarray(wf1.data[i,:]*taper)
s2 = np.ascontiguousarray(wf2.data[i,:]*taper)
# Fourier transform for greater ease of convolution
spec1 = np.fft.rfft(s1,n)
spec2 = np.fft.rfft(s2,n)
# convolve G1G2
g1g2_tr = np.multiply(np.conjugate(spec1),spec2)
# convolve noise source
c = np.multiply(g1g2_tr,S)
# transform back
correlation += my_centered(np.fft.ifftshift(np.fft.irfft(c,n)),
n_corr) * nsrc.surf_area[i]
# occasional info
if i%50000 == 0:
print("Finished {} source locations.".format(i))
###################### end of loop over all source locations ###################
if not insta:
wf1.file.close()
wf2.file.close()
# save output
trace = Trace()
trace.stats.sampling_rate = Fs
trace.data = correlation
# try to add some meta data
try:
sta1 = wf1.stats['reference_station']
sta2 = wf2.stats['reference_station']
trace.stats.station = sta1.split('.')[1]
trace.stats.network = sta1.split('.')[0]
trace.stats.location = sta1.split('.')[2]
trace.stats.channel = sta1.split('.')[3]
trace.stats.sac = {}
trace.stats.sac['kuser0'] = sta2.split('.')[1]
trace.stats.sac['kuser1'] = sta2.split('.')[0]
trace.stats.sac['kuser2'] = sta2.split('.')[2]
trace.stats.sac['kevnm'] = sta2.split('.')[3]
except:
pass
trace.write(filename=corr_file,format='SAC')
def test_more_complex_queries(reciprocal_clients_all_callbacks,
usgs_param):
"""
These are not exhaustive tests but test that the queries do something.
Elsewhere they are tested in more details.
Test phase relative offsets.
+ must be encoded with %2B
- must be encoded with %2D
"""
client = reciprocal_clients_all_callbacks
db = instaseis.open_db(client.filepath)
basic_parameters = {
"receiverlongitude": 11,
"receiverlatitude": 22,
"components": "".join(db.available_components),
"format": "miniseed"}
with io.open(usgs_param, "rb") as fh:
body = fh.read()
# default parameters
params = copy.deepcopy(basic_parameters)
params["dt"] = 2
request = client.fetch(_assemble_url('finite_source', **params),
method="POST", body=body)
assert request.code == 200
st = obspy.read(request.buffer)
# Now request one starting ten seconds later.
params = copy.deepcopy(basic_parameters)
params["starttime"] = 10
params["dt"] = 2
request = client.fetch(_assemble_url('finite_source', **params),
method="POST", body=body)
assert request.code == 200
st_2 = obspy.read(request.buffer)
assert st[0].stats.starttime + 10 == st_2[0].stats.starttime
# The rest of data should still be identical.
np.testing.assert_allclose(st.slice(starttime=10)[0].data, st_2[0].data)
# Try with the endtime.
params = copy.deepcopy(basic_parameters)
params["endtime"] = 20
params["dt"] = 2
request = client.fetch(_assemble_url('finite_source', **params),
method="POST", body=body)
assert request.code == 200
st_2 = obspy.read(request.buffer)
assert st_2[0].stats.endtime == st[0].stats.starttime + 18
# The rest of data should still be identical.
np.testing.assert_allclose(
st.slice(endtime=st[0].stats.starttime + 18)[0].data,
st_2[0].data)
# Phase relative start and endtimes.
params = copy.deepcopy(basic_parameters)
params["starttime"] = "P%2D5"
params["endtime"] = "P%2B5"
params["dt"] = 2
request = client.fetch(_assemble_url('finite_source', **params),
method="POST", body=body)
assert request.code == 200
st_2 = obspy.read(request.buffer)
# Just make sure they actually do something.
assert st_2[0].stats.starttime > st[0].stats.starttime
assert st_2[0].stats.endtime < st[0].stats.endtime
# Mixing things
params = copy.deepcopy(basic_parameters)
params["starttime"] = "P%2D5"
params["endtime"] = "50"
params["dt"] = 2
request = client.fetch(_assemble_url('finite_source', **params),
method="POST", body=body)
assert request.code == 200
st_2 = obspy.read(request.buffer)
# Just make sure they actually do something.
assert st_2[0].stats.starttime > st[0].stats.starttime
assert st_2[0].stats.endtime < st[0].stats.endtime
if "Z" not in db.available_components:
return
# Network and station searches.
params = {
"network": "IU,B*",
"station": "ANT*,ANM?",
"components": "Z",
"format": "miniseed"}
request = client.fetch(_assemble_url('finite_source', **params),
method="POST", body=body)
assert request.code == 200
st_2 = obspy.read(request.buffer)
assert sorted(tr.id for tr in st_2) == ["IU.ANMO..LXZ", "IU.ANTO..LXZ"]
rank = comm.Get_rank()
# get config
source_config=json.load(open('source_config.json'))
config = json.load(open('../config.json'))
Fs = source_config['sampling_rate']
path_to_db = config['wavefield_path']
channel = source_config['channel']
# read sourcegrid
f_sources = np.load('../sourcegrid.npy')
ntraces = f_sources.shape[-1]
# open the database
db = instaseis.open_db(path_to_db)
# get: synthetics duration and sampling rate in Hz
stest = db.get_seismograms(source=instaseis.ForceSource(latitude=0.0,
longitude=0.0),receiver=instaseis.Receiver(latitude=10.,
longitude=0.0),dt=1./source_config['sampling_rate'])[0]
ntimesteps = stest.stats.npts
# read station from file
stationlist = read_csv('../stationlist.csv')
net = stationlist.at[rank,'net']
sta = stationlist.at[rank,'sta']
lat = stationlist.at[rank,'lat']
lon = stationlist.at[rank,'lon']
print(net,sta,lat,lon)
def g1g2_kern(wf1str, wf2str, kernel, adjt, src, source_conf, insta):
measr_conf = json.load(
open(os.path.join(source_conf['source_path'], 'measr_config.json')))
bandpass = measr_conf['bandpass']
if bandpass == None:
filtcnt = 1
elif type(bandpass) == list:
if type(bandpass[0]) != list:
filtcnt = 1
else:
filtcnt = len(bandpass)
ntime, n, n_corr, Fs = get_ns(wf1str, source_conf, insta)
# use a one-sided taper: The seismogram probably has a non-zero end,
# being cut off whereever the solver stopped running.
taper = cosine_taper(ntime, p=0.01)
taper[0:ntime // 2] = 1.0
########################################################################
# Prepare filenames and adjoint sources
########################################################################
filenames = []
adjt_srcs = []
adjt_srcs_cnt = 0
for ix_f in range(filtcnt):
filename = kernel + '.{}.npy'.format(ix_f)
filenames.append(filename)
#if os.path.exists(filename):
# continue
f = Stream()
for a in adjt:
adjtfile = a + '*.{}.sac'.format(ix_f)
adjtfile = glob(adjtfile)
try:
f += read(adjtfile[0])[0]
f[-1].data = my_centered(f[-1].data, n_corr)
adjt_srcs_cnt += 1
except IndexError:
print('No adjoint source found: {}\n'.format(a))
break
adjt_srcs.append(f)
########################################################################
# Compute the kernels
########################################################################
with NoiseSource(src) as nsrc:
ntraces = nsrc.src_loc[0].shape[0]
if insta:
# open database
dbpath = json.load(
open(os.path.join(source_conf['project_path'],
'config.json')))['wavefield_path']
# open and determine Fs, nt
db = instaseis.open_db(dbpath)
# get receiver locations
lat1 = geograph_to_geocent(float(wf1[2]))
lon1 = float(wf1[3])
rec1 = instaseis.Receiver(latitude=lat1, longitude=lon1)
lat2 = geograph_to_geocent(float(wf2[2]))
lon2 = float(wf2[3])
rec2 = instaseis.Receiver(latitude=lat2, longitude=lon2)
else:
wf1 = WaveField(wf1str)
wf2 = WaveField(wf2str)
kern = np.zeros((filtcnt, ntraces, len(adjt)))
########################################################################
# Loop over locations
########################################################################
for i in range(ntraces):
# noise source spectrum at this location
# For the kernel, this contains only the basis functions of the
# spectrum without weights; might still be location-dependent,
# for example when constraining sensivity to ocean
S = nsrc.get_spect(i)
if S.sum() == 0.:
# The spectrum has 0 phase so only checking absolute value here
continue
####################################################################
# Get synthetics
####################################################################
if insta:
# get source locations
lat_src = geograph_to_geocent(nsrc.src_loc[1, i])
lon_src = nsrc.src_loc[0, i]
fsrc = instaseis.ForceSource(latitude=lat_src,
longitude=lon_src,
f_r=1.e12)
s1 = np.ascontiguousarray(
db.get_seismograms(
source=fsrc,
receiver=rec1,
dt=1. / source_conf['sampling_rate'])[0].data * taper)
s2 = np.ascontiguousarray(
db.get_seismograms(
source=fsrc,
receiver=rec2,
dt=1. / source_conf['sampling_rate'])[0].data * taper)
else:
s1 = np.ascontiguousarray(wf1.data[i, :] * taper)
s2 = np.ascontiguousarray(wf2.data[i, :] * taper)
spec1 = np.fft.rfft(s1, n)
spec2 = np.fft.rfft(s2, n)
g1g2_tr = np.multiply(np.conjugate(spec1), spec2)
c = np.multiply(g1g2_tr, S)
#######################################################################
# Get Kernel at that location
#######################################################################
corr_temp = my_centered(np.fft.ifftshift(np.fft.irfft(c, n)),
n_corr)
#######################################################################
# Apply the 'adjoint source'
#######################################################################
for ix_f in range(filtcnt):
f = adjt_srcs[ix_f]
if f == None:
continue
for j in range(len(f)):
delta = f[j].stats.delta
kern[ix_f, i, j] = np.dot(corr_temp, f[j].data) * delta
#elif measr_conf['mtype'] in ['envelope']:
# if j == 0:
# corr_temp_h = corr_temp
# print(corr_temp_h)
# if j == 1:
# corr_temp_h = hilbert(corr_temp)
# print(corr_temp_h)
#
# kern[ix_f,i,j] = np.dot(corr_temp,f[j].data) * delta
if i % 50000 == 0:
print("Finished {} source locations.".format(i))
if not insta:
wf1.file.close()
wf2.file.close()
for ix_f in range(filtcnt):
filename = filenames[ix_f]
if kern[ix_f, :, :].sum() != 0:
np.save(filename, kern[ix_f, :, :])
return ()
def Acces_Normal():
# Initiate Parameters:
get_parameters = Get_Paramters()
PARAMETERS = get_parameters.get_unkown()
PRIOR = get_parameters.get_prior()
VALUES = get_parameters.specifications()
VALUES[
'directory'] = '/home/nienke/Documents/Applied_geophysics/Thesis/anaconda/Final'
## DISCUSS THIS!!!!
PRIOR['az'] = PARAMETERS['az']
PRIOR['baz'] = PARAMETERS['baz']
# Initiate the databases from instaseis:
db = instaseis.open_db(PRIOR['VELOC'])
create = Create_observed(PRIOR, db)
d_obs, tr_obs, source = create.get_seis_automatic(
parameters=PARAMETERS,
prior=PRIOR,
noise_model=VALUES['noise'],
sdr=VALUES['sdr'])
time_at_receiver = create.get_receiver_time(PARAMETERS['epi'],
PARAMETERS['depth_s'],
PARAMETERS['origin_time'])
traces_obs, p_obs, s_obs, start_time_p, start_time_s = create.get_window_obspy(
tr_obs, PARAMETERS['epi'], PARAMETERS['depth_s'],
PARAMETERS['origin_time'], VALUES['npts'])
PRIOR['var_est'] = create.get_var_data(start_time_p, tr_obs)
# PRIOR['var_est'] =1
sw = Surface_waves(PRIOR)
R_env_obs = sw.rayleigh_pick(tr_obs.traces[0],
PARAMETERS['la_s'],
PARAMETERS['lo_s'],
PARAMETERS['depth_s'],
VALUES['directory'],
PARAMETERS['origin_time'],
VALUES['npts'],
plot_modus=False)
L_env_obs = sw.love_pick(tr_obs.traces[2],
PARAMETERS['la_s'],
PARAMETERS['lo_s'],
PARAMETERS['depth_s'],
VALUES['directory'],
PARAMETERS['origin_time'],
VALUES['npts'],
plot_modus=False)
# tr_obs.plot()
# ------------------------------------------------------------------
seis = Seismogram(PRIOR, db)
window_code = Source_code(PRIOR['VELOC_taup'])
misfit = Misfit(VALUES['directory'])
# start_sample_path = '/home/nienke/Documents/Applied_geophysics/Thesis/anaconda/Final/close_sample.txt'
start_sample_path = None
m = MCMC_stream(R_env_obs,
L_env_obs,
traces_obs,
p_obs,
s_obs,
PRIOR,
db,
VALUES,
PARAMETERS['origin_time'],
start_time_p,
start_time_s,
start_sample_path,
None,
full_obs_trace=tr_obs)
m.start_MCMC(VALUES['directory'] + '/Exploring.txt')
dirname = dirname.lstrip("'")
dirname = dirname.rstrip("'")
print dirname
f.close()
dir_not_found_yet = False
except ValueError:
str = f.readline()
### Load instaseis database
# In[3]:
db = instaseis.open_db(os.path.join(kerner_dir, dirname))
print db
### Load CMTSOLUTION file
# In[4]:
src = instaseis.Source.parse(os.path.join(kerner_dir, 'CMTSOLUTION'))
print src
### Parse receivers.dat file
# In[ ]:
def Normal_check():
# Initiate Parameters:
get_parameters = Get_Paramters()
PARAMETERS = get_parameters.get_unkown()
PRIOR = get_parameters.get_prior()
VALUES = get_parameters.specifications()
VALUES['blind'] = False
VALUES[
'directory'] = '/home/nienke/Documents/Applied_geophysics/Thesis/anaconda/Final/check_waveforms'
## DISCUSS THIS!!!!
PRIOR['az'] = PARAMETERS['az']
PRIOR['baz'] = PARAMETERS['baz']
# Initiate the databases from instaseis:
db = instaseis.open_db(PRIOR['VELOC'])
create = Create_observed(PRIOR, db)
d_obs, tr_obs, source = create.get_seis_automatic(
parameters=PARAMETERS,
prior=PRIOR,
noise_model=VALUES['noise'],
sdr=VALUES['sdr'])
traces_obs, p_obs, s_obs, p_time_obs, s_time_obs = create.get_window_obspy(
tr_obs, PARAMETERS['epi'], PARAMETERS['depth_s'],
PARAMETERS['origin_time'], VALUES['npts'])
time_at_receiver = create.get_receiver_time(PARAMETERS['epi'],
PARAMETERS['depth_s'],
PARAMETERS['origin_time'])
PRIOR['var_est'] = create.get_var_data(p_time_obs, tr_obs)
sw = Surface_waves(PRIOR)
R_env_obs = sw.rayleigh_pick(tr_obs.traces[0],
PARAMETERS['la_s'],
PARAMETERS['lo_s'],
PARAMETERS['depth_s'],
VALUES['directory'],
PARAMETERS['origin_time'],
VALUES['npts'],
plot_modus=False)
L_env_obs = sw.love_pick(tr_obs.traces[2],
PARAMETERS['la_s'],
PARAMETERS['lo_s'],
PARAMETERS['depth_s'],
VALUES['directory'],
PARAMETERS['origin_time'],
VALUES['npts'],
plot_modus=False)
# tr_obs.plot()
# ------------------------------------------------------------------
seis = Seismogram(PRIOR, db)
window_code = Source_code(PRIOR['VELOC_taup'])
misfit = Misfit(VALUES['directory'])
epi = PARAMETERS['epi']
depth = PARAMETERS['depth_s']
strike = PARAMETERS['strike']
dip = PARAMETERS['dip']
rake = PARAMETERS['rake']
time = PARAMETERS['origin_time']
# --------------------------------------------------------------------------------------------------------------- #
dict = geo.Geodesic(a=PRIOR['radius'], f=0).ArcDirect(lat1=PRIOR['la_r'],
lon1=PRIOR['lo_r'],
azi1=PRIOR['baz'],
a12=epi,
outmask=1929)
d_syn, traces_syn, sources = seis.get_seis_manual(la_s=dict['lat2'],
lo_s=dict['lon2'],
depth=depth,
strike=strike,
dip=dip,
rake=rake,
time=time,
M0=PRIOR['M0'],
sdr=VALUES['sdr'])
R_env_syn = sw.rayleigh_pick(Z_trace=traces_syn.traces[0],
la_s=dict['lat2'],
lo_s=dict['lon2'],
depth=depth,
save_directory=VALUES['directory'],
time_at_rec=time,
npts=VALUES['npts'],
plot_modus=True)
L_env_syn = sw.love_pick(T_trace=traces_syn.traces[2],
la_s=dict['lat2'],
lo_s=dict['lon2'],
depth=depth,
save_directory=VALUES['directory'],
time_at_rec=time,
npts=VALUES['npts'],
plot_modus=False)
traces_syn.plot(outfile=VALUES['directory'] + '/syntethic')
total_syn, p_syn, s_syn, p_time_syn, s_time_syn = window_code.get_window_obspy(
traces_syn, epi, depth, time, VALUES['npts'])
ax1 = plt.subplot2grid((5, 1), (0, 0))
ax1.plot(zero_to_nan(p_syn.traces[0].data), c='r', linewidth=0.3)
ax1.plot(zero_to_nan(p_obs.traces[0].data),
c='k',
linestyle=':',
linewidth=0.3)
plt.tight_layout()
ax2 = plt.subplot2grid((5, 1), (1, 0))
ax2.plot(zero_to_nan(p_syn.traces[1].data), c='r', linewidth=0.3)
ax2.plot(zero_to_nan(p_obs.traces[1].data),
c='k',
linestyle=':',
linewidth=0.3)
plt.tight_layout()
ax3 = plt.subplot2grid((5, 1), (2, 0))
ax3.plot(zero_to_nan(s_syn.traces[0].data), c='r', linewidth=0.3)
ax3.plot(zero_to_nan(s_obs.traces[0].data), c='k', linewidth=0.3)
plt.tight_layout()
ax4 = plt.subplot2grid((5, 1), (3, 0))
ax4.plot(zero_to_nan(s_syn.traces[1].data), c='r', linewidth=0.3)
ax4.plot(zero_to_nan(s_obs.traces[1].data), c='k', linewidth=0.3)
plt.tight_layout()
ax5 = plt.subplot2grid((5, 1), (4, 0))
ax5.plot(zero_to_nan(s_syn.traces[2].data), c='r', linewidth=0.3)
ax5.plot(zero_to_nan(s_obs.traces[2].data), c='k', linewidth=0.3)
plt.tight_layout()
plt.savefig(VALUES['directory'] + '/%.2f_%.2f.pdf' % (epi, depth))
plt.close()
ax1 = plt.subplot2grid((3, 1), (0, 0))
ax1.plot(zero_to_nan(total_syn.traces[0].data), c='r', linewidth=0.5)
ax1.plot(zero_to_nan(traces_obs.traces[0].data),
c='k',
linestyle=':',
linewidth=0.5)
ax1.set_title('SYNTHETIC: = epi: %.2f REAL: epi = %.2f (depth fixed' %
(epi, epi))
plt.tight_layout()
ax2 = plt.subplot2grid((3, 1), (1, 0))
ax2.plot(zero_to_nan(total_syn.traces[1].data), c='r', linewidth=0.5)
ax2.plot(zero_to_nan(traces_obs.traces[1].data),
c='k',
linestyle=':',
linewidth=0.5)
plt.tight_layout()
ax3 = plt.subplot2grid((3, 1), (2, 0))
ax3.plot(zero_to_nan(total_syn.traces[2].data), c='r', linewidth=0.5)
ax3.plot(zero_to_nan(traces_obs.traces[2].data),
c='k',
linestyle=':',
linewidth=0.5)
plt.tight_layout()
plt.savefig(VALUES['directory'] + '/PS_%.2f_%.2f.pdf' % (epi, depth))
plt.close()
Xi_bw_new, time_shift_new, amplitude = misfit.CC_stream(
p_obs, p_syn, s_obs, s_syn, p_time_obs, p_time_syn)
s_z_new = 0.1 * Xi_bw_new[0]
s_r_new = 0.1 * Xi_bw_new[1]
s_t_new = 1 * Xi_bw_new[2]
p_z_new = 5 * Xi_bw_new[3]
p_r_new = 5 * Xi_bw_new[4]
bw_new = s_z_new + s_r_new + s_t_new + p_z_new + p_r_new
Xi_R_new = misfit.SW_L2(R_env_obs, R_env_syn, PRIOR['var_est'], amplitude)
Xi_L_new = misfit.SW_L2(L_env_obs, L_env_syn, PRIOR['var_est'], amplitude)
R_dict_new = {}
rw_new = 0
for j, v in enumerate(Xi_R_new):
R_dict_new.update({'R_%i_new' % j: v})
rw_new += v
L_dict_new = {}
lw_new = 0
for j, v in enumerate(Xi_L_new):
L_dict_new.update({'L_%i_new' % j: v})
lw_new += v
Xi_new = bw_new + rw_new + lw_new
a = 1
def create_insta_from_invcat(network, event, database): import obspy from obspy.geodetics.base import gps2dist_azimuth, kilometer2degrees, locations2degrees from obspy import read as read_st from obspy import read_inventory as read_inv from obspy import read_events as read_cat from obspy.taup import TauPyModel import numpy import numpy as np import matplotlib.pyplot as plt import matplotlib as mpl import scipy as sp import scipy.signal as signal from numpy import genfromtxt from sipy.util.array_util import get_coords import os import datetime import sipy.filter.fk as fk from sipy.filter.fk import fk_filter import sipy.util.fkutil as fku import instaseis as ins """ This function creates synthetic data using the given network and event information, with the database of instaseis :param network: Desired Network, for which the data is generated :type network: obspy.core.inventory.Network :param event: Event, for wich the data is generated. The event must have stored the moment tensor (e.g. given by glogalcmt.org) :type event: obspy.core.event.Event :param database: Link to the database, e.g. the path on your harddrive :type database: str """ db = ins.open_db(database) tofe = event.origins[0].time lat = event.origins[0].latitude lon = event.origins[0].longitude depth = event.origins[0].depth source = ins.Source( latitude=lat, longitude=lon, depth_in_m=depth, m_rr = event.MomentTensor.m_rr, m_tt = event.MomentTensor.m_tt, m_pp = event.MomentTensor.m_pp, m_rt = event.MomentTensor.m_rt, m_rp = event.MomentTensor.m_rp, m_tp = event.MomentTensor.m_tp, origin_time=tofe ) stream = Stream() tmp = [] for station in network: rec = ins.Receiver(latitude=str(station.latitude), longitude=str(station.longitude), network=str(network.code), station=str(station.code) ) tmp.append(db.get_seismograms(source=source, receiver=rec)) for x in tmp: stream += x return stream
def setup(self):
self.db = open_db(self.path, read_on_demand=False,
buffer_size_in_mb=250)
