def parse_eq_Canada(file_path):
"""
Parse eqcanada text file to an obspy Catalog
:param file_path: Path to downloaded file
:return:
"""
cat = Catalog()
with open(file_path, 'r') as f:
next(f)
for ln in f:
line = ln.split('|')
rid = ResourceIdentifier(id='smi:local/{}'.format(line[0]))
o = Origin(time=UTCDateTime(line[1]), latitude=float(line[2]),
longitude=float(line[3]), depth=float(line[4]))
m = Magnitude(magnitude_type=line[5], mag=float(line[6]))
e = Event(resource_id=rid, force_resource_id=False,
origins=[o], magnitudes=[m])
cat.events.append(e)
return cat
def make_test_catalog(self):
"""
Make a test catalog with fixed resource IDs some of which reference
other objects belonging to the event (eg arrivals -> picks)
"""
pick_rid = ResourceIdentifier(id='obspy.org/tests/test_pick')
origin_rid = ResourceIdentifier(id='obspy.org/tests/test_origin')
arrival_rid = ResourceIdentifier(id='obspy.org/tests/test_arrival')
ar_pick_rid = ResourceIdentifier(id='obspy.org/tests/test_pick')
catatlog_rid = ResourceIdentifier(id='obspy.org/tests/test_catalog')
picks = [Pick(time=UTCDateTime(), resource_id=pick_rid)]
arrivals = [Arrival(resource_id=arrival_rid, pick_id=ar_pick_rid)]
origins = [Origin(arrivals=arrivals, resource_id=origin_rid)]
events = [Event(picks=picks, origins=origins)]
events[0].preferred_origin_id = str(origin_rid.id)
catalog = Catalog(events=events, resource_id=catatlog_rid)
# next bind all unbound resource_ids to the current event scope
catalog.resource_id.bind_resource_ids()
return catalog
def read_origin(event_str):
"""
Read the origin information from the REST file string
:param event_str: Contents of file as list of str
:type event_str: list
:returns: :class:`obspy.core.event.Event`
"""
event = Event()
head = event_str[0].split()
try:
gap = float(head[17])
except IndexError:
gap = None
origin = Origin(
time=UTCDateTime(
year=int(head[0]), julday=int(head[1]), hour=int(head[2]),
minute=int(head[3])) + float(head[4]),
latitude=float(head[5]), longitude=float(head[6]),
depth=float(head[7]) * 1000, origin_quality=OriginQuality(
standard_error=float(head[9]),
azimuthal_gap=gap,
used_phase_count=int(head[17])),
longitude_errors=QuantityError(
uncertainty=kilometer2degrees(float(head[12]))),
latitude_errors=QuantityError(
uncertainty=kilometer2degrees(float(head[11]))),
depth_errors=QuantityError(uncertainty=float(head[13]) * 1000),
method_id=ResourceIdentifier("smi:local/REST"),
evaluation_mode="automatic")
event.origins.append(origin)
try:
event.magnitudes.append(Magnitude(
mag=float(head[19]), magnitude_type="M"))
except IndexError:
pass
return event
def write_events(db, start, end):
picks_query, ARC = split_event(db, start, end)
ev = Event()
ev.event_descriptions.append(EventDescription())
ev.origins.append(Origin(
time=UTCDateTime(start),
latitude=0,
longitude=0,
depth=0))
for p in picks_query:
_waveform_id_1 = WaveformStreamID(
station_code=p.station,
channel_code='EHZ',
network_code='HL'
)
ev.picks.append(
Pick(waveform_id=_waveform_id_1,
phase_hint='I' + p.phase,
time=UTCDateTime(p.time),
evaluation_mode="automatic")
)
return ev, ARC
def event_to_quakeml(event, filename):
"""
Write one of those events to QuakeML.
"""
# Create all objects.
cat = Catalog()
ev = Event()
org = Origin()
mag = Magnitude()
fm = FocalMechanism()
mt = MomentTensor()
t = Tensor()
# Link them together.
cat.append(ev)
ev.origins.append(org)
ev.magnitudes.append(mag)
ev.focal_mechanisms.append(fm)
fm.moment_tensor = mt
mt.tensor = t
# Fill values
ev.resource_id = "smi:inversion/%s" % str(event["identifier"])
org.time = event["time"]
org.longitude = event["longitude"]
org.latitude = event["latitude"]
org.depth = event["depth_in_km"] * 1000
mag.mag = event["Mw"]
mag.magnitude_type = "Mw"
t.m_rr = event["Mrr"]
t.m_tt = event["Mpp"]
t.m_pp = event["Mtt"]
t.m_rt = event["Mrt"]
t.m_rp = event["Mrp"]
t.m_tp = event["Mtp"]
cat.write(filename, format="quakeml")
def _block2event(block, seed_map, id_default, ph2comp):
"""
Read HypoDD event block
"""
lines = block.strip().splitlines()
yr, mo, dy, hr, mn, sc, la, lo, dp, mg, eh, ez, rms, id_ = lines[0].split()
time = UTCDateTime(int(yr), int(mo), int(dy), int(hr), int(mn), float(sc))
picks = []
arrivals = []
for line in lines[1:]:
sta, reltime, weight, phase = line.split()
comp = ph2comp.get(phase, '')
wid = seed_map.get(sta, id_default)
_waveform_id = WaveformStreamID(seed_string=wid.format(sta, comp))
pick = Pick(waveform_id=_waveform_id,
phase_hint=phase,
time=time + float(reltime))
arrival = Arrival(phase=phase,
pick_id=pick.resource_id,
time_weight=float(weight))
picks.append(pick)
arrivals.append(arrival)
qu = None if rms == '0.0' else OriginQuality(standard_error=float(rms))
origin = Origin(arrivals=arrivals,
resource_id="smi:local/origin/" + id_,
quality=qu,
latitude=float(la),
longitude=float(lo),
depth=1000 * float(dp),
time=time)
magnitude = Magnitude(mag=mg, resource_id="smi:local/magnitude/" + id_)
event = Event(resource_id="smi:local/event/" + id_,
picks=picks,
origins=[origin],
magnitudes=[magnitude],
preferred_origin_id=origin.resource_id,
preferred_magnitude_id=magnitude.resource_id)
return event
def test_reactor_spin_up(self):
rt_client = RealTimeClient(server_url="link.geonet.org.nz")
reactor = Reactor(client=Client("GEONET"),
rt_client=rt_client,
listener=self.listener,
trigger_func=self.trigger_func,
template_database=self.template_bank,
template_lookup_kwargs=dict(),
real_time_tribe_kwargs=dict(threshold=8,
threshold_type="MAD",
trig_int=2),
plot_kwargs=dict(),
listener_kwargs=dict(make_templates=False))
trigger_event = Event(origins=[
Origin(time=UTCDateTime(2019, 1, 1),
latitude=-45.,
longitude=178.0,
depth=10000.)
],
magnitudes=[Magnitude(mag=7.4)])
reactor.background_spin_up(triggering_event=trigger_event)
time.sleep(10)
reactor.stop()
def brightness(stations,
nodes,
lags,
stream,
threshold,
thresh_type,
template_length,
template_saveloc,
coherence_thresh,
coherence_stations=['all'],
coherence_clip=False,
gap=2.0,
clip_level=100,
instance=0,
pre_pick=0.2,
plotsave=True,
cores=1):
r"""Function to calculate the brightness function in terms of energy for \
a day of data over the entire network for a given grid of nodes.
Note data in stream must be all of the same length and have the same
sampling rates.
:type stations: list
:param stations: List of station names from in the form where stations[i] \
refers to nodes[i][:] and lags[i][:]
:type nodes: list, tuple
:param nodes: List of node points where nodes[i] referes to stations[i] \
and nodes[:][:][0] is latitude in degrees, nodes[:][:][1] is \
longitude in degrees, nodes[:][:][2] is depth in km.
:type lags: :class: 'numpy.array'
:param lags: Array of arrays where lags[i][:] refers to stations[i]. \
lags[i][j] should be the delay to the nodes[i][j] for stations[i] in \
seconds.
:type stream: :class: `obspy.Stream`
:param data: Data through which to look for detections.
:type threshold: float
:param threshold: Threshold value for detection of template within the \
brightness function
:type thresh_type: str
:param thresh_type: Either MAD or abs where MAD is the Median Absolute \
Deviation and abs is an absoulte brightness.
:type template_length: float
:param template_length: Length of template to extract in seconds
:type template_saveloc: str
:param template_saveloc: Path of where to save the templates.
:type coherence_thresh: tuple of floats
:param coherence_thresh: Threshold for removing incoherant peaks in the \
network response, those below this will not be used as templates. \
Must be in the form of (a,b) where the coherence is given by: \
a-kchan/b where kchan is the number of channels used to compute \
the coherence
:type coherence_stations: list
:param coherence_stations: List of stations to use in the coherance \
thresholding - defaults to 'all' which uses all the stations.
:type coherence_clip: float
:param coherence_clip: tuple
:type coherence_clip: Start and end in seconds of data to window around, \
defaults to False, which uses all the data given.
:type pre_pick: float
:param pre_pick: Seconds before the detection time to include in template
:type plotsave: bool
:param plotsave: Save or show plots, if False will try and show the plots \
on screen - as this is designed for bulk use this is set to \
True to save any plots rather than show them if you create \
them - changes the backend of matplotlib, so if is set to \
False you will see NO PLOTS!
:type cores: int
:param core: Number of cores to use, defaults to 1.
:type clip_level: float
:param clip_level: Multiplier applied to the mean deviation of the energy \
as an upper limit, used to remove spikes (earthquakes, \
lightning, electircal spikes) from the energy stack.
:type gap: float
:param gap: Minimum inter-event time in seconds for detections
:return: list of templates as :class: `obspy.Stream` objects
"""
from eqcorrscan.core.template_gen import _template_gen
if plotsave:
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
plt.ioff()
# from joblib import Parallel, delayed
from multiprocessing import Pool, cpu_count
from copy import deepcopy
from obspy import read as obsread
from obspy.core.event import Catalog, Event, Pick, WaveformStreamID, Origin
from obspy.core.event import EventDescription, CreationInfo, Comment
import obspy.Stream
import matplotlib.pyplot as plt
from eqcorrscan.utils import EQcorrscan_plotting as plotting
# Check that we actually have the correct stations
realstations = []
for station in stations:
st = stream.select(station=station)
if st:
realstations += station
del st
stream_copy = stream.copy()
# Force convert to int16
for tr in stream_copy:
# int16 max range is +/- 32767
if max(abs(tr.data)) > 32767:
tr.data = 32767 * (tr.data / max(abs(tr.data)))
# Make sure that the data aren't clipped it they are high gain
# scale the data
tr.data = tr.data.astype(np.int16)
# The internal _node_loop converts energy to int16 too to converse memory,
# to do this it forces the maximum of a single energy trace to be 500 and
# normalises to this level - this only works for fewer than 65 channels of
# data
if len(stream_copy) > 130:
raise OverflowError('Too many streams, either re-code and cope with' +
'either more memory usage, or less precision, or' +
'reduce data volume')
detections = []
detect_lags = []
parallel = True
plotvar = True
mem_issue = False
# Loop through each node in the input
# Linear run
print('Computing the energy stacks')
if not parallel:
for i in range(0, len(nodes)):
print(i)
if not mem_issue:
j, a = _node_loop(stations, lags[:, i], stream, plot=True)
if 'energy' not in locals():
energy = a
else:
energy = np.concatenate((energy, a), axis=0)
print('energy: ' + str(np.shape(energy)))
else:
j, filename = _node_loop(stations, lags[:, i], stream, i,
mem_issue)
energy = np.array(energy)
print(np.shape(energy))
else:
# Parallel run
num_cores = cores
if num_cores > len(nodes):
num_cores = len(nodes)
if num_cores > cpu_count():
num_cores = cpu_count()
pool = Pool(processes=num_cores)
results = [
pool.apply_async(_node_loop,
args=(stations, lags[:, i], stream, i, clip_level,
mem_issue, instance))
for i in range(len(nodes))
]
pool.close()
if not mem_issue:
print('Computing the cumulative network response from memory')
energy = [p.get() for p in results]
pool.join()
energy.sort(key=lambda tup: tup[0])
energy = [node[1] for node in energy]
energy = np.concatenate(energy, axis=0)
print(energy.shape)
else:
pool.join()
# Now compute the cumulative network response and then detect possible
# events
if not mem_issue:
print(energy.shape)
indeces = np.argmax(energy, axis=0) # Indeces of maximum energy
print(indeces.shape)
cum_net_resp = np.array([np.nan] * len(indeces))
cum_net_resp[0] = energy[indeces[0]][0]
peak_nodes = [nodes[indeces[0]]]
for i in range(1, len(indeces)):
cum_net_resp[i] = energy[indeces[i]][i]
peak_nodes.append(nodes[indeces[i]])
del energy, indeces
else:
print('Reading the temp files and computing network response')
node_splits = len(nodes) // num_cores
indeces = [range(node_splits)]
for i in range(1, num_cores - 1):
indeces.append(range(node_splits * i, node_splits * (i + 1)))
indeces.append(range(node_splits * (i + 1), len(nodes)))
pool = Pool(processes=num_cores)
results = [
pool.apply_async(_cum_net_resp, args=(indeces[i], instance))
for i in range(num_cores)
]
pool.close()
results = [p.get() for p in results]
pool.join()
responses = [result[0] for result in results]
print(np.shape(responses))
node_indeces = [result[1] for result in results]
cum_net_resp = np.array(responses)
indeces = np.argmax(cum_net_resp, axis=0)
print(indeces.shape)
print(cum_net_resp.shape)
cum_net_resp = np.array(
[cum_net_resp[indeces[i]][i] for i in range(len(indeces))])
peak_nodes = [
nodes[node_indeces[indeces[i]][i]] for i in range(len(indeces))
]
del indeces, node_indeces
if plotvar:
cum_net_trace = deepcopy(stream[0])
cum_net_trace.data = cum_net_resp
cum_net_trace.stats.station = 'NR'
cum_net_trace.stats.channel = ''
cum_net_trace.stats.network = 'Z'
cum_net_trace.stats.location = ''
cum_net_trace.stats.starttime = stream[0].stats.starttime
cum_net_trace = obspy.Stream(cum_net_trace)
cum_net_trace += stream.select(channel='*N')
cum_net_trace += stream.select(channel='*1')
cum_net_trace.sort(['network', 'station', 'channel'])
# np.save('cum_net_resp.npy',cum_net_resp)
# cum_net_trace.plot(size=(800,600), equal_scale=False,\
# outfile='NR_timeseries.eps')
# Find detection within this network response
print('Finding detections in the cumulatve network response')
detections = _find_detections(cum_net_resp, peak_nodes, threshold,
thresh_type, stream[0].stats.sampling_rate,
realstations, gap)
del cum_net_resp
templates = []
nodesout = []
good_detections = []
if detections:
print('Converting detections in to templates')
# Generate a catalog of detections
detections_cat = Catalog()
for j, detection in enumerate(detections):
print('Converting for detection ' + str(j) + ' of ' +
str(len(detections)))
# Create an event for each detection
event = Event()
# Set up some header info for the event
event.event_descriptions.append(EventDescription())
event.event_descriptions[0].text = 'Brightness detection'
event.creation_info = CreationInfo(agency_id='EQcorrscan')
copy_of_stream = deepcopy(stream_copy)
# Convert detections to obspy.core.event type -
# name of detection template is the node.
node = (detection.template_name.split('_')[0],
detection.template_name.split('_')[1],
detection.template_name.split('_')[2])
print(node)
# Look up node in nodes and find the associated lags
index = nodes.index(node)
detect_lags = lags[:, index]
ksta = Comment(text='Number of stations=' + len(detect_lags))
event.origins.append(Origin())
event.origins[0].comments.append(ksta)
event.origins[0].time = copy_of_stream[0].stats.starttime +\
detect_lags[0] + detection.detect_time
event.origins[0].latitude = node[0]
event.origins[0].longitude = node[1]
event.origins[0].depth = node[2]
for i, detect_lag in enumerate(detect_lags):
station = stations[i]
st = copy_of_stream.select(station=station)
if len(st) != 0:
for tr in st:
_waveform_id = WaveformStreamID(
station_code=tr.stats.station,
channel_code=tr.stats.channel,
network_code='NA')
event.picks.append(
Pick(waveform_id=_waveform_id,
time=tr.stats.starttime + detect_lag +
detection.detect_time + pre_pick,
onset='emergent',
evalutation_mode='automatic'))
print('Generating template for detection: ' + str(j))
template = (_template_gen(event.picks, copy_of_stream,
template_length, 'all'))
template_name = template_saveloc + '/' +\
str(template[0].stats.starttime) + '.ms'
# In the interests of RAM conservation we write then read
# Check coherancy here!
temp_coher, kchan = coherence(template, coherence_stations,
coherence_clip)
coh_thresh = float(coherence_thresh[0]) - kchan / \
float(coherence_thresh[1])
if temp_coher > coh_thresh:
template.write(template_name, format="MSEED")
print('Written template as: ' + template_name)
print('---------------------------------coherence LEVEL: ' +
str(temp_coher))
coherant = True
else:
print('Template was incoherant, coherence level: ' +
str(temp_coher))
coherant = False
del copy_of_stream, tr, template
if coherant:
templates.append(obsread(template_name))
nodesout += [node]
good_detections.append(detection)
else:
print('No template for you')
if plotvar:
all_detections = [(cum_net_trace[-1].stats.starttime +
detection.detect_time).datetime
for detection in detections]
good_detections = [(cum_net_trace[-1].stats.starttime +
detection.detect_time).datetime
for detection in good_detections]
if not plotsave:
plotting.NR_plot(cum_net_trace[0:-1],
obspy.Stream(cum_net_trace[-1]),
detections=good_detections,
size=(18.5, 10),
title='Network response')
# cum_net_trace.plot(size=(800,600), equal_scale=False)
else:
savefile = 'plots/' +\
cum_net_trace[0].stats.starttime.datetime.strftime('%Y%m%d') +\
'_NR_timeseries.pdf'
plotting.NR_plot(cum_net_trace[0:-1],
obspy.Stream(cum_net_trace[-1]),
detections=good_detections,
size=(18.5, 10),
save=savefile,
title='Network response')
nodesout = list(set(nodesout))
return templates, nodesout
def event(self):
"""Create an event with an origin."""
origin = Origin(time=self.time, latitude=47, longitude=-111.7)
return Event(origins=[origin])
def _read_ndk(filename, *args, **kwargs): # @UnusedVariable
"""
Reads an NDK file to a :class:`~obspy.core.event.Catalog` object.
:param filename: File or file-like object in text mode.
"""
# Read the whole file at once. While an iterator would be more efficient
# the largest NDK file out in the wild is 13.7 MB so it does not matter
# much.
if not hasattr(filename, "read"):
# Check if it exists, otherwise assume its a string.
try:
with open(filename, "rt") as fh:
data = fh.read()
except Exception:
try:
data = filename.decode()
except Exception:
data = str(filename)
data = data.strip()
else:
data = filename.read()
if hasattr(data, "decode"):
data = data.decode()
# Create iterator that yields lines.
def lines_iter():
prev_line = -1
while True:
next_line = data.find("\n", prev_line + 1)
if next_line < 0:
break
yield data[prev_line + 1:next_line]
prev_line = next_line
if len(data) > prev_line + 1:
yield data[prev_line + 1:]
# Use one Flinn Engdahl object for all region determinations.
fe = FlinnEngdahl()
cat = Catalog(resource_id=_get_resource_id("catalog", str(uuid.uuid4())))
# Loop over 5 lines at once.
for _i, lines in enumerate(zip_longest(*[lines_iter()] * 5)):
if None in lines:
msg = "Skipped last %i lines. Not a multiple of 5 lines." % (
lines.count(None))
warnings.warn(msg, ObsPyNDKWarning)
continue
# Parse the lines to a human readable dictionary.
try:
record = _read_lines(*lines)
except (ValueError, ObsPyNDKException):
exc = traceback.format_exc()
msg = ("Could not parse event %i (faulty file?). Will be "
"skipped. Lines of the event:\n"
"\t%s\n"
"%s") % (_i + 1, "\n\t".join(lines), exc)
warnings.warn(msg, ObsPyNDKWarning)
continue
# Use one creation info for essentially every item.
creation_info = CreationInfo(agency_id="GCMT",
version=record["version_code"])
# Use the ObsPy Flinn Engdahl region determiner as the region in the
# NDK files is oftentimes trimmed.
region = fe.get_region(record["centroid_longitude"],
record["centroid_latitude"])
# Create an event object.
event = Event(force_resource_id=False,
event_type="earthquake",
event_type_certainty="known",
event_descriptions=[
EventDescription(text=region,
type="Flinn-Engdahl region"),
EventDescription(text=record["cmt_event_name"],
type="earthquake name")
])
# Assemble the time for the reference origin.
try:
time = _parse_date_time(record["date"], record["time"])
except ObsPyNDKException:
msg = ("Invalid time in event %i. '%s' and '%s' cannot be "
"assembled to a valid time. Event will be skipped.") % \
(_i + 1, record["date"], record["time"])
warnings.warn(msg, ObsPyNDKWarning)
continue
# Create two origins, one with the reference latitude/longitude and
# one with the centroidal values.
ref_origin = Origin(
force_resource_id=False,
time=time,
longitude=record["hypo_lng"],
latitude=record["hypo_lat"],
# Convert to m.
depth=record["hypo_depth_in_km"] * 1000.0,
origin_type="hypocenter",
comments=[
Comment(text="Hypocenter catalog: %s" %
record["hypocenter_reference_catalog"],
force_resource_id=False)
])
ref_origin.comments[0].resource_id = _get_resource_id(
record["cmt_event_name"], "comment", tag="ref_origin")
ref_origin.resource_id = _get_resource_id(record["cmt_event_name"],
"origin",
tag="reforigin")
cmt_origin = Origin(
force_resource_id=False,
longitude=record["centroid_longitude"],
longitude_errors={
"uncertainty": record["centroid_longitude_error"]
},
latitude=record["centroid_latitude"],
latitude_errors={"uncertainty": record["centroid_latitude_error"]},
# Convert to m.
depth=record["centroid_depth_in_km"] * 1000.0,
depth_errors={
"uncertainty": record["centroid_depth_in_km_error"] * 1000
},
time=ref_origin["time"] + record["centroid_time"],
time_errors={"uncertainty": record["centroid_time_error"]},
depth_type=record["type_of_centroid_depth"],
origin_type="centroid",
time_fixed=False,
epicenter_fixed=False,
creation_info=creation_info.copy())
cmt_origin.resource_id = _get_resource_id(record["cmt_event_name"],
"origin",
tag="cmtorigin")
event.origins = [ref_origin, cmt_origin]
event.preferred_origin_id = cmt_origin.resource_id.id
# Create the magnitude object.
mag = Magnitude(force_resource_id=False,
mag=round(record["Mw"], 2),
magnitude_type="Mwc",
origin_id=cmt_origin.resource_id,
creation_info=creation_info.copy())
mag.resource_id = _get_resource_id(record["cmt_event_name"],
"magnitude",
tag="moment_mag")
event.magnitudes = [mag]
event.preferred_magnitude_id = mag.resource_id.id
# Add the reported mb, MS magnitudes as additional magnitude objects.
event.magnitudes.append(
Magnitude(
force_resource_id=False,
mag=record["mb"],
magnitude_type="mb",
comments=[
Comment(
force_resource_id=False,
text="Reported magnitude in NDK file. Most likely 'mb'."
)
]))
event.magnitudes[-1].comments[-1].resource_id = _get_resource_id(
record["cmt_event_name"], "comment", tag="mb_magnitude")
event.magnitudes[-1].resource_id = _get_resource_id(
record["cmt_event_name"], "magnitude", tag="mb")
event.magnitudes.append(
Magnitude(
force_resource_id=False,
mag=record["MS"],
magnitude_type="MS",
comments=[
Comment(
force_resource_id=False,
text="Reported magnitude in NDK file. Most likely 'MS'."
)
]))
event.magnitudes[-1].comments[-1].resource_id = _get_resource_id(
record["cmt_event_name"], "comment", tag="MS_magnitude")
event.magnitudes[-1].resource_id = _get_resource_id(
record["cmt_event_name"], "magnitude", tag="MS")
# Take care of the moment tensor.
tensor = Tensor(m_rr=record["m_rr"],
m_rr_errors={"uncertainty": record["m_rr_error"]},
m_pp=record["m_pp"],
m_pp_errors={"uncertainty": record["m_pp_error"]},
m_tt=record["m_tt"],
m_tt_errors={"uncertainty": record["m_tt_error"]},
m_rt=record["m_rt"],
m_rt_errors={"uncertainty": record["m_rt_error"]},
m_rp=record["m_rp"],
m_rp_errors={"uncertainty": record["m_rp_error"]},
m_tp=record["m_tp"],
m_tp_errors={"uncertainty": record["m_tp_error"]},
creation_info=creation_info.copy())
mt = MomentTensor(
force_resource_id=False,
scalar_moment=record["scalar_moment"],
tensor=tensor,
data_used=[DataUsed(**i) for i in record["data_used"]],
inversion_type=record["source_type"],
source_time_function=SourceTimeFunction(
type=record["moment_rate_type"],
duration=record["moment_rate_duration"]),
derived_origin_id=cmt_origin.resource_id,
creation_info=creation_info.copy())
mt.resource_id = _get_resource_id(record["cmt_event_name"],
"momenttensor")
axis = [Axis(**i) for i in record["principal_axis"]]
focmec = FocalMechanism(
force_resource_id=False,
moment_tensor=mt,
principal_axes=PrincipalAxes(
# The ordering is the same as for the IRIS SPUD service and
# from a website of the Saint Louis University Earthquake
# center so it should be correct.
t_axis=axis[0],
p_axis=axis[2],
n_axis=axis[1]),
nodal_planes=NodalPlanes(
nodal_plane_1=NodalPlane(**record["nodal_plane_1"]),
nodal_plane_2=NodalPlane(**record["nodal_plane_2"])),
comments=[
Comment(force_resource_id=False,
text="CMT Analysis Type: %s" %
record["cmt_type"].capitalize()),
Comment(force_resource_id=False,
text="CMT Timestamp: %s" % record["cmt_timestamp"])
],
creation_info=creation_info.copy())
focmec.comments[0].resource_id = _get_resource_id(
record["cmt_event_name"], "comment", tag="cmt_type")
focmec.comments[1].resource_id = _get_resource_id(
record["cmt_event_name"], "comment", tag="cmt_timestamp")
focmec.resource_id = _get_resource_id(record["cmt_event_name"],
"focal_mechanism")
event.focal_mechanisms = [focmec]
event.preferred_focal_mechanism_id = focmec.resource_id.id
# Set at end to avoid duplicate resource id warning.
event.resource_id = _get_resource_id(record["cmt_event_name"], "event")
cat.append(event)
if len(cat) == 0:
msg = "No valid events found in NDK file."
raise ObsPyNDKException(msg)
return cat
def makeCatalog(StazList, mt, scale, args):
epi = args.epi.rsplit()
model = args.model.split(os.sep)
NrSt = len(StazList)
NrCo = NrSt * 3
(Fmin, Fmax) = getFreq(args)
Tmin = ('%.0f' % (1 / Fmax))
Tmax = ('%.0f' % (1 / Fmin))
mo = ('%.3e' % (mt[0]))
mw = ('%.2f' % (mt[1]))
Pdc = ('%.2f' % (float(mt[2]) / 100))
Pclvd = ('%.2f' % (float(mt[3]) / 100))
Tval = ('%10.3e' % (mt[22]))
Tplg = ('%4.1f' % (mt[23]))
Tazi = ('%5.1f' % (mt[24]))
Nval = ('%10.3e' % (mt[25]))
Nplg = ('%4.1f' % (mt[26]))
Nazi = ('%5.1f' % (mt[27]))
Pval = ('%10.3e' % (mt[28]))
Pplg = ('%4.1f' % (mt[29]))
Pazi = ('%5.1f' % (mt[30]))
STp1 = ('%5.1f' % (mt[31]))
DPp1 = ('%4.1f' % (mt[32]))
RAp1 = ('%6.1f' % (mt[33]))
STp2 = ('%5.1f' % (mt[34]))
DPp2 = ('%4.1f' % (mt[35]))
RAp2 = ('%6.1f' % (mt[36]))
var = ('%.2f' % (mt[37]))
qua = ('%d' % (mt[38]))
mij = [mt[4], mt[5], mt[6], mt[7], mt[8], mt[9]]
mm0 = str('%10.3e' % (mij[0]))
mm1 = str('%10.3e' % (mij[1]))
mm2 = str('%10.3e' % (mij[2]))
mm3 = str('%10.3e' % (mij[3]))
mm4 = str('%10.3e' % (mij[4]))
mm5 = str('%10.3e' % (mij[5]))
# Aki konvention
Mrr = mm5
Mtt = mm0
Mff = mm1
Mrt = mm3
Mrf = mm4
Mtf = mm2
# stress regime
A1 = PrincipalAxis(val=mt[22], dip=mt[23], strike=mt[24])
A2 = PrincipalAxis(val=mt[25], dip=mt[26], strike=mt[27])
A3 = PrincipalAxis(val=mt[28], dip=mt[29], strike=mt[30])
(regime, sh) = stressRegime(A1, A2, A3)
sh = ('%5.1f' % (sh))
#### Build classes #################################
#
#Resource Id is the event origin time for definition
res_id = ResourceIdentifier(args.ori)
nowUTC = datetime.datetime.utcnow()
info = CreationInfo(author="pytdmt", version="2.4", creation_time=nowUTC)
evOrigin = Origin(resource_id=res_id,
time=args.ori,
latitude=epi[0],
longitude=epi[1],
depth=epi[2],
earth_model_id=model[-1],
creation_info=info)
# Magnitudes
magnitude = Magnitude(mag=mw, magnitude_type="Mw")
# Nodal Planes
np1 = NodalPlane(strike=STp1, dip=DPp1, rake=RAp1)
np2 = NodalPlane(strike=STp2, dip=DPp2, rake=RAp2)
planes = NodalPlanes(nodal_plane_1=np1, nodal_plane_2=np2)
# Principal axes
Taxe = Axis(azimuth=Tazi, plunge=Tplg, length=Tval)
Naxe = Axis(azimuth=Nazi, plunge=Nplg, length=Nval)
Paxe = Axis(azimuth=Pazi, plunge=Pplg, length=Pval)
axes = PrincipalAxes(t_axis=Taxe, p_axis=Paxe, n_axis=Naxe)
# MT elements
MT = Tensor(m_rr=Mrr, m_tt=Mtt, m_pp=Mff, m_rt=Mrt, m_rp=Mrf, m_tp=Mtf)
# Stress regime
regStr = 'Stress regime: ' + regime + ' - SH = ' + sh
strDes = EventDescription(regStr)
# MT dataset
dataInfo = DataUsed(wave_type="combined",
station_count=NrSt,
component_count=NrCo,
shortest_period=Tmin,
longest_period=Tmax)
source = MomentTensor(data_used=dataInfo,
scalar_moment=mo,
tensor=MT,
variance_reduction=var,
double_couple=Pdc,
clvd=Pclvd,
iso=0)
focMec = FocalMechanism(moment_tensor=source,
nodal_planes=planes,
principal_axes=axes,
azimuthal_gap=-1)
#Initialize Event Catalog
mtSolution = Event(creation_info=info)
mtSolution.origins.append(evOrigin)
mtSolution.magnitudes.append(magnitude)
mtSolution.focal_mechanisms.append(focMec)
mtSolution.event_descriptions.append(strDes)
cat = Catalog()
cat.append(mtSolution)
return cat
def stalta_pick(stream,
stalen,
ltalen,
trig_on,
trig_off,
freqmin=False,
freqmax=False,
show=False):
"""
Basic sta/lta picker, suggest using alternative in obspy.
Simple sta/lta (short-term average/long-term average) picker, using
obspy's :func:`obspy.signal.trigger.classic_sta_lta` routine to generate
the characteristic function.
Currently very basic quick wrapper, there are many other (better) options
in obspy in the :mod:`obspy.signal.trigger` module.
:type stream: obspy.core.stream.Stream
:param stream: The stream to pick on, can be any number of channels.
:type stalen: float
:param stalen: Length of the short-term average window in seconds.
:type ltalen: float
:param ltalen: Length of the long-term average window in seconds.
:type trig_on: float
:param trig_on: sta/lta ratio to trigger a detection/pick
:type trig_off: float
:param trig_off: sta/lta ratio to turn the trigger off - no further picks\
will be made between exceeding trig_on until trig_off is reached.
:type freqmin: float
:param freqmin: Low-cut frequency in Hz for bandpass filter
:type freqmax: float
:param freqmax: High-cut frequency in Hz for bandpass filter
:type show: bool
:param show: Show picks on waveform.
:returns: :class:`obspy.core.event.event.Event`
.. rubric:: Example
>>> from obspy import read
>>> from eqcorrscan.utils.picker import stalta_pick
>>> st = read()
>>> event = stalta_pick(st, stalen=0.2, ltalen=4, trig_on=10,
... trig_off=1, freqmin=3.0, freqmax=20.0)
>>> print(event.creation_info.author)
EQcorrscan
.. warning::
This function is not designed for accurate picking, rather it can give
a first idea of whether picks may be possible. Proceed with caution.
"""
event = Event()
event.origins.append(Origin())
event.creation_info = CreationInfo(author='EQcorrscan',
creation_time=UTCDateTime())
event.comments.append(Comment(text='stalta'))
picks = []
for tr in stream:
# We are going to assume, for now, that if the pick is made on the
# horizontal channel then it is an S, otherwise we will assume it is
# a P-phase: obviously a bad assumption...
if tr.stats.channel[-1] == 'Z':
phase = 'P'
else:
phase = 'S'
if freqmin and freqmax:
tr.detrend('simple')
tr.filter('bandpass',
freqmin=freqmin,
freqmax=freqmax,
corners=3,
zerophase=True)
df = tr.stats.sampling_rate
cft = classic_sta_lta(tr.data, int(stalen * df), int(ltalen * df))
triggers = trigger_onset(cft, trig_on, trig_off)
for trigger in triggers:
on = tr.stats.starttime + (trigger[0] / df)
# off = tr.stats.starttime + (trigger[1] / df)
wav_id = WaveformStreamID(station_code=tr.stats.station,
channel_code=tr.stats.channel,
network_code=tr.stats.network)
p = Pick(waveform_id=wav_id, phase_hint=phase, time=on)
Logger.info('Pick made: {0}'.format(p))
picks.append(p)
# QC picks
pick_stations = list(set([pick.waveform_id.station_code
for pick in picks]))
for pick_station in pick_stations:
station_picks = [
pick for pick in picks
if pick.waveform_id.station_code == pick_station
]
# If P-pick is after S-picks, remove it.
p_time = [
pick.time for pick in station_picks if pick.phase_hint == 'P'
]
s_time = [
pick.time for pick in station_picks if pick.phase_hint == 'S'
]
if p_time > s_time:
p_pick = [pick for pick in station_picks if pick.phase_hint == 'P']
for pick in p_pick:
Logger.info('P pick after S pick, removing P pick')
picks.remove(pick)
event.picks = picks
if show:
plotting.pretty_template_plot(stream,
event=event,
title='Autopicks',
size=(8, 9))
if len(event.picks) > 0:
event.origins[0].time = min([pick.time for pick in event.picks]) - 1
# event.origins[0].latitude = float('nan')
# event.origins[0].longitude = float('nan')
# Set arbitrary origin time
return event
def _calculate_event(self,
template=None,
template_st=None,
estimate_origin=True,
correct_prepick=True):
"""
Calculate an event for this detection using a given template.
:type template: Template
:param template: The template that made this detection
:type template_st: `obspy.core.stream.Stream`
:param template_st:
Template stream, used to calculate pick times, not needed if
template is given.
:type estimate_origin: bool
:param estimate_origin:
Whether to include an estimate of the origin based on the template
origin.
:type correct_prepick: bool
:param correct_prepick:
Whether to apply the prepick correction defined in the template.
Only applicable if template is not None
.. rubric:: Note
Works in place on Detection - over-writes previous events.
Corrects for prepick if template given.
"""
if template is not None and template.name != self.template_name:
Logger.info("Template names do not match: {0}: {1}".format(
template.name, self.template_name))
return
# Detect time must be valid QuakeML uri within resource_id.
# This will write a formatted string which is still
# readable by UTCDateTime
det_time = str(self.detect_time.strftime('%Y%m%dT%H%M%S.%f'))
ev = Event(resource_id=ResourceIdentifier(
id=self.template_name + '_' + det_time, prefix='smi:local'))
ev.creation_info = CreationInfo(author='EQcorrscan',
creation_time=UTCDateTime())
ev.comments.append(
Comment(text="Template: {0}".format(self.template_name)))
ev.comments.append(
Comment(text='threshold={0}'.format(self.threshold)))
ev.comments.append(
Comment(text='detect_val={0}'.format(self.detect_val)))
if self.chans is not None:
ev.comments.append(
Comment(text='channels used: {0}'.format(' '.join(
[str(pair) for pair in self.chans]))))
if template is not None:
template_st = template.st
if correct_prepick:
template_prepick = template.prepick
else:
template_prepick = 0
try:
template_picks = template.event.picks
except AttributeError:
template_picks = []
else:
template_prepick = 0
template_picks = []
min_template_tm = min([tr.stats.starttime for tr in template_st])
for tr in template_st:
if (tr.stats.station, tr.stats.channel) \
not in self.chans:
continue
elif tr.stats.__contains__("not_in_original"):
continue
elif np.all(np.isnan(tr.data)):
continue # The channel contains no data and was not used.
else:
pick_time = self.detect_time + (tr.stats.starttime -
min_template_tm)
pick_time += template_prepick
new_pick = Pick(time=pick_time,
waveform_id=WaveformStreamID(
network_code=tr.stats.network,
station_code=tr.stats.station,
channel_code=tr.stats.channel,
location_code=tr.stats.location))
template_pick = [
p for p in template_picks
if p.waveform_id.get_seed_string() ==
new_pick.waveform_id.get_seed_string()
]
if len(template_pick) == 0:
new_pick.phase_hint = None
elif len(template_pick) == 1:
new_pick.phase_hint = template_pick[0].phase_hint
else:
# Multiple picks for this trace in template
similar_traces = template_st.select(id=tr.id)
similar_traces.sort()
_index = similar_traces.traces.index(tr)
try:
new_pick.phase_hint = sorted(
template_pick,
key=lambda p: p.time)[_index].phase_hint
except IndexError:
Logger.error(f"No pick for trace: {tr.id}")
ev.picks.append(new_pick)
if estimate_origin and template is not None\
and template.event is not None:
try:
template_origin = (template.event.preferred_origin()
or template.event.origins[0])
except IndexError:
template_origin = None
if template_origin:
for pick in ev.picks:
comparison_pick = [
p for p in template.event.picks
if p.waveform_id.get_seed_string() ==
pick.waveform_id.get_seed_string()
]
comparison_pick = [
p for p in comparison_pick
if p.phase_hint == pick.phase_hint
]
if len(comparison_pick) > 0:
break
else:
Logger.error("Could not compute relative origin: no picks")
self.event = ev
return
origin_time = pick.time - (comparison_pick[0].time -
template_origin.time)
# Calculate based on difference between pick and origin?
_origin = Origin(
ResourceIdentifier(id="EQcorrscan/{0}_{1}".format(
self.template_name, det_time),
prefix="smi:local"),
time=origin_time,
evaluation_mode="automatic",
evaluation_status="preliminary",
creation_info=CreationInfo(author='EQcorrscan',
creation_time=UTCDateTime()),
comments=[
Comment(
text=
"Origin automatically assigned based on template"
" origin: use with caution.")
],
latitude=template_origin.latitude,
longitude=template_origin.longitude,
depth=template_origin.depth,
time_errors=template_origin.time_errors,
latitude_errors=template_origin.latitude_errors,
longitude_errors=template_origin.longitude_errors,
depth_errors=template_origin.depth_errors,
depth_type=template_origin.depth_type,
time_fixed=False,
epicenter_fixed=template_origin.epicenter_fixed,
reference_system_id=template_origin.reference_system_id,
method_id=template_origin.method_id,
earth_model_id=template_origin.earth_model_id,
origin_type=template_origin.origin_type,
origin_uncertainty=template_origin.origin_uncertainty,
region=template_origin.region)
ev.origins = [_origin]
self.event = ev
return self
def catalog(self):
""" assemble a events to test yield_event_waveforms with an event
that was not initiated from the start """
ori = Origin(time=self.t1, latitude=47.1, longitude=-100.22)
event = Event(origins=[ori])
return obspy.Catalog(events=[event])
def event(self):
origin = Origin(time=self.time, latitude=47, longitude=-111.7)
return Event(origins=[origin])
def to_dataframe(self, origin, imcs=None, imts=None):
"""Get a summary dataframe of streams.
Note: The PGM columns underneath each channel will be variable
depending on the units of the Stream being passed in (velocity
sensors can only generate PGV) and on the imtlist passed in by
user. Spectral acceleration columns will be formatted as SA(0.3)
for 0.3 second spectral acceleration, for example.
Args:
directory (str):
Directory of ground motion files (streams).
origin_dict (obspy):
Dictionary with the following keys:
- id
- magnitude
- time (UTCDateTime object)
- lon
- lat
- depth
imcs (list):
Strings designating desired components to create in table.
imts (list):
Strings designating desired PGMs to create in table.
Returns:
DataFrame: Pandas dataframe containing columns:
- STATION Station code.
- NAME Text description of station.
- LOCATION Two character location code.
- SOURCE Long form string containing source network.
- NETWORK Short network code.
- LAT Station latitude
- LON Station longitude
- DISTANCE Epicentral distance (km) (if epicentral
lat/lon provided)
- HN1 East-west channel (or H1) (multi-index with pgm columns):
- PGA Peak ground acceleration (%g).
- PGV Peak ground velocity (cm/s).
- SA(0.3) Pseudo-spectral acceleration at 0.3 seconds (%g).
- SA(1.0) Pseudo-spectral acceleration at 1.0 seconds (%g).
- SA(3.0) Pseudo-spectral acceleration at 3.0 seconds (%g).
- HN2 North-south channel (or H2) (multi-index with pgm
columns):
- PGA Peak ground acceleration (%g).
- PGV Peak ground velocity (cm/s).
- SA(0.3) Pseudo-spectral acceleration at 0.3 seconds (%g).
- SA(1.0) Pseudo-spectral acceleration at 1.0 seconds (%g).
- SA(3.0) Pseudo-spectral acceleration at 3.0 seconds (%g).
- HNZ Vertical channel (or HZ) (multi-index with pgm columns):
- PGA Peak ground acceleration (%g).
- PGV Peak ground velocity (cm/s).
- SA(0.3) Pseudo-spectral acceleration at 0.3 seconds (%g).
- SA(1.0) Pseudo-spectral acceleration at 1.0 seconds (%g).
- SA(3.0) Pseudo-spectral acceleration at 3.0 seconds (%g).
- GREATER_OF_TWO_HORIZONTALS (multi-index with pgm columns):
- PGA Peak ground acceleration (%g).
- PGV Peak ground velocity (cm/s).
- SA(0.3) Pseudo-spectral acceleration at 0.3 seconds (%g).
- SA(1.0) Pseudo-spectral acceleration at 1.0 seconds (%g).
- SA(3.0) Pseudo-spectral acceleration at 3.0 seconds (%g).
"""
streams = self.streams
# dept for an origin object should be stored in meters
origin = Origin(resource_id=origin['id'],
latitude=origin['lat'],
longitude=origin['lon'],
time=origin['time'],
depth=origin['depth'] * 1000)
if imcs is None:
station_summary_imcs = DEFAULT_IMCS
else:
station_summary_imcs = imcs
if imts is None:
station_summary_imts = DEFAULT_IMTS
else:
station_summary_imts = imts
if imcs is None:
station_summary_imcs = DEFAULT_IMCS
else:
station_summary_imcs = imcs
if imts is None:
station_summary_imts = DEFAULT_IMTS
else:
station_summary_imts = imts
subdfs = []
for stream in streams:
if not stream.passed:
continue
if len(stream) < 3:
continue
stream_summary = StationSummary.from_stream(
stream, station_summary_imcs, station_summary_imts, origin)
summary = stream_summary.summary
subdfs += [summary]
dataframe = pd.concat(subdfs, axis=0).reset_index(drop=True)
return dataframe
# !ls -l /tmp/large_events.xml # - the event type classes can be used to build up Events/Catalogs/Picks/.. from scratch in custom processing work flows and to share them with other researchers in the de facto standard format QuakeML # + from obspy import UTCDateTime from obspy.core.event import Catalog, Event, Origin, Magnitude from obspy.geodetics import FlinnEngdahl # cat = Catalog() cat.description = "Just a fictitious toy example catalog built from scratch" e = Event() e.event_type = "not existing" o = Origin() o.time = UTCDateTime(2014, 2, 23, 18, 0, 0) o.latitude = 47.6 o.longitude = 12.0 o.depth = 10000 o.depth_type = "operator assigned" o.evaluation_mode = "manual" o.evaluation_status = "preliminary" o.region = FlinnEngdahl().get_region(o.longitude, o.latitude) m = Magnitude() m.mag = 7.2 m.magnitude_type = "Mw" m2 = Magnitude() m2.mag = 7.4
def _add_catalog_layer(writer, catalog):
"""
:type writer: :class:`shapefile.Writer`.
:param writer: pyshp Writer object
:type catalog: :class:`~obspy.core.event.Catalog`
:param catalog: Event data to add as a new layer.
"""
# [name, type, width, precision]
# field name is 10 chars max
# ESRI shapefile attributes are stored in dbf files, which can not
# store datetimes, only dates, see:
# http://www.gdal.org/drv_shapefile.html
# use POSIX timestamp for exact origin time, set time of first pick
# for events with no origin
field_definitions = [
["EventID", 'C', 100, None],
["OriginID", 'C', 100, None],
["MagID", 'C', 100, None],
["Date", 'D', None, None],
["OriginTime", 'N', 20, 6],
["FirstPick", 'N', 20, 6],
["Longitude", 'N', 16, 10],
["Latitude", 'N', 16, 10],
["Depth", 'N', 8, 3],
["MinHorUncM", 'N', 12, 3],
["MaxHorUncM", 'N', 12, 3],
["MaxHorAzi", 'N', 7, 3],
["OriUncDesc", 'C', 40, None],
["Magnitude", 'N', 8, 3],
]
_create_layer(writer, field_definitions)
for event in catalog:
# try to use preferred origin/magnitude, fall back to first or use
# empty one with `None` values in it
origin = (event.preferred_origin()
or event.origins and event.origins[0]
or Origin(force_resource_id=False))
magnitude = (event.preferred_magnitude()
or event.magnitudes and event.magnitudes[0]
or Magnitude(force_resource_id=False))
t_origin = origin.time
pick_times = [
pick.time for pick in event.picks if pick.time is not None
]
t_pick = pick_times and min(pick_times) or None
date = t_origin or t_pick
feature = {}
# setting fields with `None` results in values of `0.000`
# need to really omit setting values if they are `None`
if event.resource_id is not None:
feature["EventID"] = str(event.resource_id)
if origin.resource_id is not None:
feature["OriginID"] = str(origin.resource_id)
if t_origin is not None:
# Use timestamp for exact timing
feature["OriginTime"] = t_origin.timestamp
if t_pick is not None:
# Use timestamp for exact timing
feature["FirstPick"] = t_pick.timestamp
if date is not None:
# ESRI shapefile attributes are stored in dbf files, which can
# not store datetimes, only dates. We still need to use the
# GDAL API with precision up to seconds (aiming at other output
# drivers of GDAL; `100` stands for GMT)
feature["Date"] = date.datetime
if origin.latitude is not None:
feature["Latitude"] = origin.latitude
if origin.longitude is not None:
feature["Longitude"] = origin.longitude
if origin.depth is not None:
feature["Depth"] = origin.depth / 1e3
if magnitude.mag is not None:
feature["Magnitude"] = magnitude.mag
if magnitude.resource_id is not None:
feature["MagID"] = str(magnitude.resource_id)
if origin.origin_uncertainty is not None:
ou = origin.origin_uncertainty
ou_description = ou.preferred_description
if ou_description == 'uncertainty ellipse':
feature["MinHorUncM"] = ou.min_horizontal_uncertainty
feature["MaxHorUncM"] = ou.max_horizontal_uncertainty
feature["MaxHorAzi"] = \
ou.azimuth_max_horizontal_uncertainty
feature["OriUncDesc"] = ou_description
elif ou_description == 'horizontal uncertainty':
feature["MinHorUncM"] = ou.horizontal_uncertainty
feature["MaxHorUncM"] = ou.horizontal_uncertainty
feature["MaxHorAzi"] = 0.0
feature["OriUncDesc"] = ou_description
else:
msg = ('Encountered an event with origin uncertainty '
'description of type "{}". This is not yet '
'implemented for output as shapefile. No origin '
'uncertainty will be added to shapefile for such '
'events.').format(ou_description)
warnings.warn(msg)
if origin.latitude is not None and origin.longitude is not None:
writer.point(origin.longitude, origin.latitude)
_add_record(writer, feature)
def _parseRecordDp(self, line, event):
"""
Parses the 'source parameter data - primary' record Dp
"""
source_contributor = line[2:6].strip()
computation_type = line[6]
exponent = self._intZero(line[7])
scale = math.pow(10, exponent)
centroid_origin_time = line[8:14] + '.' + line[14]
orig_time_stderr = line[15:17]
if orig_time_stderr == 'FX':
orig_time_stderr = 'Fixed'
else:
orig_time_stderr =\
self._floatWithFormat(orig_time_stderr, '2.1', scale)
centroid_latitude = self._floatWithFormat(line[17:21], '4.2')
lat_type = line[21]
if centroid_latitude is not None:
centroid_latitude *= self._coordinateSign(lat_type)
lat_stderr = line[22:25]
if lat_stderr == 'FX':
lat_stderr = 'Fixed'
else:
lat_stderr = self._floatWithFormat(lat_stderr, '3.2', scale)
centroid_longitude = self._floatWithFormat(line[25:30], '5.2')
lon_type = line[30]
if centroid_longitude is not None:
centroid_longitude *= self._coordinateSign(lon_type)
lon_stderr = line[31:34]
if lon_stderr == 'FX':
lon_stderr = 'Fixed'
else:
lon_stderr = self._floatWithFormat(lon_stderr, '3.2', scale)
centroid_depth = self._floatWithFormat(line[34:38], '4.1')
depth_stderr = line[38:40]
if depth_stderr == 'FX' or depth_stderr == 'BD':
depth_stderr = 'Fixed'
else:
depth_stderr = self._floatWithFormat(depth_stderr, '2.1', scale)
station_number = self._intZero(line[40:43])
component_number = self._intZero(line[43:46])
station_number2 = self._intZero(line[46:48])
component_number2 = self._intZero(line[48:51])
#unused: half_duration = self._floatWithFormat(line[51:54], '3.1')
moment = self._floatWithFormat(line[54:56], '2.1')
moment_stderr = self._floatWithFormat(line[56:58], '2.1')
moment_exponent = self._int(line[58:60])
if (moment is not None) and (moment_exponent is not None):
moment *= math.pow(10, moment_exponent)
if (moment_stderr is not None) and (moment_exponent is not None):
moment_stderr *= math.pow(10, moment_exponent)
evid = event.resource_id.id.split('/')[-1]
#Create a new origin only if centroid time is defined:
origin = None
if centroid_origin_time.strip() != '.':
origin = Origin()
res_id = '/'.join(
(res_id_prefix, 'origin', evid, source_contributor.lower(),
'mw' + computation_type.lower()))
origin.resource_id = ResourceIdentifier(id=res_id)
origin.creation_info =\
CreationInfo(agency_id=source_contributor)
date = event.origins[0].time.strftime('%Y%m%d')
origin.time = UTCDateTime(date + centroid_origin_time)
#Check if centroid time is on the next day:
if origin.time < event.origins[0].time:
origin.time += timedelta(days=1)
self._storeUncertainty(origin.time_errors, orig_time_stderr)
origin.latitude = centroid_latitude
origin.longitude = centroid_longitude
origin.depth = centroid_depth * 1000
if lat_stderr == 'Fixed' and lon_stderr == 'Fixed':
origin.epicenter_fixed = True
else:
self._storeUncertainty(origin.latitude_errors,
self._latErrToDeg(lat_stderr))
self._storeUncertainty(
origin.longitude_errors,
self._lonErrToDeg(lon_stderr, origin.latitude))
if depth_stderr == 'Fixed':
origin.depth_type = 'operator assigned'
else:
origin.depth_type = 'from location'
self._storeUncertainty(origin.depth_errors,
depth_stderr,
scale=1000)
quality = OriginQuality()
quality.used_station_count =\
station_number + station_number2
quality.used_phase_count =\
component_number + component_number2
origin.quality = quality
origin.type = 'centroid'
event.origins.append(origin)
focal_mechanism = FocalMechanism()
res_id = '/'.join(
(res_id_prefix, 'focalmechanism', evid, source_contributor.lower(),
'mw' + computation_type.lower()))
focal_mechanism.resource_id = ResourceIdentifier(id=res_id)
focal_mechanism.creation_info =\
CreationInfo(agency_id=source_contributor)
moment_tensor = MomentTensor()
if origin is not None:
moment_tensor.derived_origin_id = origin.resource_id
else:
#this is required for QuakeML validation:
res_id = '/'.join((res_id_prefix, 'no-origin'))
moment_tensor.derived_origin_id =\
ResourceIdentifier(id=res_id)
for mag in event.magnitudes:
if mag.creation_info.agency_id == source_contributor:
moment_tensor.moment_magnitude_id = mag.resource_id
res_id = '/'.join(
(res_id_prefix, 'momenttensor', evid, source_contributor.lower(),
'mw' + computation_type.lower()))
moment_tensor.resource_id = ResourceIdentifier(id=res_id)
moment_tensor.scalar_moment = moment
self._storeUncertainty(moment_tensor.scalar_moment_errors,
moment_stderr)
data_used = DataUsed()
data_used.station_count = station_number + station_number2
data_used.component_count = component_number + component_number2
if computation_type == 'C':
res_id = '/'.join((res_id_prefix, 'methodID=CMT'))
focal_mechanism.method_id = ResourceIdentifier(id=res_id)
#CMT algorithm uses long-period body waves,
#very-long-period surface waves and
#intermediate period surface waves (since 2004
#for shallow and intermediate-depth earthquakes
# --Ekstrom et al., 2012)
data_used.wave_type = 'combined'
if computation_type == 'M':
res_id = '/'.join((res_id_prefix, 'methodID=moment_tensor'))
focal_mechanism.method_id = ResourceIdentifier(id=res_id)
#FIXME: not sure which kind of data is used by
#"moment tensor" algorithm.
data_used.wave_type = 'unknown'
elif computation_type == 'B':
res_id = '/'.join((res_id_prefix, 'methodID=broadband_data'))
focal_mechanism.method_id = ResourceIdentifier(id=res_id)
#FIXME: is 'combined' correct here?
data_used.wave_type = 'combined'
elif computation_type == 'F':
res_id = '/'.join((res_id_prefix, 'methodID=P-wave_first_motion'))
focal_mechanism.method_id = ResourceIdentifier(id=res_id)
data_used.wave_type = 'P waves'
elif computation_type == 'S':
res_id = '/'.join((res_id_prefix, 'methodID=scalar_moment'))
focal_mechanism.method_id = ResourceIdentifier(id=res_id)
#FIXME: not sure which kind of data is used
#for scalar moment determination.
data_used.wave_type = 'unknown'
moment_tensor.data_used = data_used
focal_mechanism.moment_tensor = moment_tensor
event.focal_mechanisms.append(focal_mechanism)
return focal_mechanism
def _parse_origin(self, line):
# 1-10 i4,a1,i2,a1,i2 epicenter date (yyyy/mm/dd)
# 12-22 i2,a1,i2,a1,f5.2 epicenter time (hh:mm:ss.ss)
time = UTCDateTime.strptime(line[:17], '%Y/%m/%d %H:%M:')
time += float(line[17:22])
# 23 a1 fixed flag (f = fixed origin time solution, blank if
# not a fixed origin time)
time_fixed = fixed_flag(line[22])
# 25-29 f5.2 origin time error (seconds; blank if fixed origin time)
time_error = float_or_none(line[24:29])
time_error = time_error and QuantityError(uncertainty=time_error)
# 31-35 f5.2 root mean square of time residuals (seconds)
rms = float_or_none(line[30:35])
# 37-44 f8.4 latitude (negative for South)
latitude = float_or_none(line[36:44])
# 46-54 f9.4 longitude (negative for West)
longitude = float_or_none(line[45:54])
# 55 a1 fixed flag (f = fixed epicenter solution, blank if not
# a fixed epicenter solution)
epicenter_fixed = fixed_flag(line[54])
# 56-60 f5.1 semi-major axis of 90% ellipse or its estimate
# (km, blank if fixed epicenter)
_uncertainty_major_m = float_or_none(line[55:60], multiplier=1e3)
# 62-66 f5.1 semi-minor axis of 90% ellipse or its estimate
# (km, blank if fixed epicenter)
_uncertainty_minor_m = float_or_none(line[61:66], multiplier=1e3)
# 68-70 i3 strike (0 <= x <= 360) of error ellipse clock-wise from
# North (degrees)
_uncertainty_major_azimuth = float_or_none(line[67:70])
# 72-76 f5.1 depth (km)
depth = float_or_none(line[71:76], multiplier=1e3)
# 77 a1 fixed flag (f = fixed depth station, d = depth phases,
# blank if not a fixed depth)
epicenter_fixed = fixed_flag(line[76])
# 79-82 f4.1 depth error 90% (km; blank if fixed depth)
depth_error = float_or_none(line[78:82], multiplier=1e3)
# 84-87 i4 number of defining phases
used_phase_count = int_or_none(line[83:87])
# 89-92 i4 number of defining stations
used_station_count = int_or_none(line[88:92])
# 94-96 i3 gap in azimuth coverage (degrees)
azimuthal_gap = float_or_none(line[93:96])
# 98-103 f6.2 distance to closest station (degrees)
minimum_distance = float_or_none(line[97:103])
# 105-110 f6.2 distance to furthest station (degrees)
maximum_distance = float_or_none(line[104:110])
# 112 a1 analysis type: (a = automatic, m = manual, g = guess)
evaluation_mode, evaluation_status = \
evaluation_mode_and_status(line[111])
# 114 a1 location method: (i = inversion, p = pattern
# recognition, g = ground truth, o =
# other)
location_method = LOCATION_METHODS[line[113].strip().lower()]
# 116-117 a2 event type:
# XXX event type and event type certainty is specified per origin,
# XXX not sure how to bset handle this, for now only use it if
# XXX information on the individual origins do not clash.. not sure yet
# XXX how to identify the preferred origin..
event_type, event_type_certainty = \
EVENT_TYPE_CERTAINTY[line[115:117].strip().lower()]
# 119-127 a9 author of the origin
author = line[118:127].strip()
# 129-136 a8 origin identification
origin_id = self._construct_id(['origin', line[128:136].strip()])
# do some combinations
depth_error = depth_error and dict(uncertainty=depth_error,
confidence_level=90)
if all(v is not None
for v in (_uncertainty_major_m, _uncertainty_minor_m,
_uncertainty_major_azimuth)):
origin_uncertainty = OriginUncertainty(
min_horizontal_uncertainty=_uncertainty_minor_m,
max_horizontal_uncertainty=_uncertainty_major_m,
azimuth_max_horizontal_uncertainty=_uncertainty_major_azimuth,
preferred_description='uncertainty ellipse',
confidence_level=90)
# event init always sets an empty QuantityError, even when
# specifying None, which is strange
for key in ['confidence_ellipsoid']:
setattr(origin_uncertainty, key, None)
else:
origin_uncertainty = None
origin_quality = OriginQuality(standard_error=rms,
used_phase_count=used_phase_count,
used_station_count=used_station_count,
azimuthal_gap=azimuthal_gap,
minimum_distance=minimum_distance,
maximum_distance=maximum_distance)
comments = []
if location_method:
comments.append(
self._make_comment('location method: ' + location_method))
if author:
creation_info = CreationInfo(author=author)
else:
creation_info = None
# assemble whole event
origin = Origin(time=time,
resource_id=origin_id,
longitude=longitude,
latitude=latitude,
depth=depth,
depth_errors=depth_error,
origin_uncertainty=origin_uncertainty,
time_fixed=time_fixed,
epicenter_fixed=epicenter_fixed,
origin_quality=origin_quality,
comments=comments,
creation_info=creation_info)
# event init always sets an empty QuantityError, even when specifying
# None, which is strange
for key in ('time_errors', 'longitude_errors', 'latitude_errors',
'depth_errors'):
setattr(origin, key, None)
return origin, event_type, event_type_certainty
def cross_net(stream, env=False, master=False):
"""
Generate picks using a simple envelope cross-correlation.
Picks are made for each channel based on optimal moveout defined by
maximum cross-correlation with master trace. Master trace will be the
first trace in the stream if not set. Requires good inter-station
coherance.
:type stream: obspy.core.stream.Stream
:param stream: Stream to pick
:type env: bool
:param env: To compute cross-correlations on the envelope or not.
:type master: obspy.core.trace.Trace
:param master:
Trace to use as master, if False, will use the first trace in stream.
:returns: :class:`obspy.core.event.event.Event`
.. rubric:: Example
>>> from obspy import read
>>> from eqcorrscan.utils.picker import cross_net
>>> st = read()
>>> event = cross_net(st, env=True)
>>> print(event.creation_info.author)
EQcorrscan
.. warning::
This routine is not designed for accurate picking, rather it can be
used for a first-pass at picks to obtain simple locations. Based on
the waveform-envelope cross-correlation method.
"""
event = Event()
event.origins.append(Origin())
event.creation_info = CreationInfo(author='EQcorrscan',
creation_time=UTCDateTime())
event.comments.append(Comment(text='cross_net'))
samp_rate = stream[0].stats.sampling_rate
if not env:
Logger.info('Using the raw data')
st = stream.copy()
st.resample(samp_rate)
else:
st = stream.copy()
Logger.info('Computing envelope')
for tr in st:
tr.resample(samp_rate)
tr.data = envelope(tr.data)
if not master:
master = st[0]
else:
master = master
master.data = np.nan_to_num(master.data)
for i, tr in enumerate(st):
tr.data = np.nan_to_num(tr.data)
Logger.debug('Comparing {0} with the master'.format(tr.id))
shift_len = int(0.3 * len(tr))
Logger.debug('Shift length is set to ' + str(shift_len) + ' samples')
index, cc = xcorr(master, tr, shift_len)
wav_id = WaveformStreamID(station_code=tr.stats.station,
channel_code=tr.stats.channel,
network_code=tr.stats.network)
event.picks.append(
Pick(time=tr.stats.starttime + (index / tr.stats.sampling_rate),
waveform_id=wav_id,
phase_hint='S',
onset='emergent'))
Logger.debug(event.picks[i])
event.origins[0].time = min([pick.time for pick in event.picks]) - 1
# event.origins[0].latitude = float('nan')
# event.origins[0].longitude = float('nan')
# Set arbitrary origin time
del st
return event
def _parse_first_line_origin(self, line, event, magnitudes):
"""
Parse the first line of origin data.
:type line: str
:param line: Line to parse.
:type event: :class:`~obspy.core.event.event.Event`
:param event: Event of the origin.
:type magnitudes: list of
:class:`~obspy.core.event.magnitude.Magnitude`
:param magnitudes: Store magnitudes in a list to keep
their positions.
:rtype: :class:`~obspy.core.event.origin.Origin`,
:class:`~obspy.core.event.resourceid.ResourceIdentifier`
:returns: Parsed origin or None, resource identifier of the
origin.
"""
magnitude_types = []
magnitude_values = []
magnitude_station_counts = []
fields = self.fields['line_1']
time_origin = line[fields['time']].strip()
time_fixed_flag = line[fields['time_fixf']].strip()
latitude = line[fields['lat']].strip()
longitude = line[fields['lon']].strip()
epicenter_fixed_flag = line[fields['epicenter_fixf']].strip()
depth = line[fields['depth']].strip()
depth_fixed_flag = line[fields['depth_fixf']].strip()
phase_count = line[fields['n_def']].strip()
station_count = line[fields['n_sta']].strip()
azimuthal_gap = line[fields['gap']].strip()
magnitude_types.append(line[fields['mag_type_1']].strip())
magnitude_values.append(line[fields['mag_1']].strip())
magnitude_station_counts.append(line[fields['mag_n_sta_1']].strip())
magnitude_types.append(line[fields['mag_type_2']].strip())
magnitude_values.append(line[fields['mag_2']].strip())
magnitude_station_counts.append(line[fields['mag_n_sta_2']].strip())
magnitude_types.append(line[fields['mag_type_3']].strip())
magnitude_values.append(line[fields['mag_3']].strip())
magnitude_station_counts.append(line[fields['mag_n_sta_3']].strip())
author = line[fields['author']].strip()
origin_id = line[fields['id']].strip()
origin = Origin()
origin.quality = OriginQuality()
try:
origin.time = UTCDateTime(time_origin.replace('/', '-'))
origin.latitude = float(latitude)
origin.longitude = float(longitude)
except (TypeError, ValueError):
self._warn('Missing origin data, skipping event')
return None, None
origin.time_fixed = time_fixed_flag.lower() == 'f'
origin.epicenter_fixed = epicenter_fixed_flag.lower() == 'f'
try:
# Convert value from km to m
origin.depth = float(depth) * 1000
except ValueError:
pass
try:
origin.depth_type = DEPTH_TYPES[depth_fixed_flag]
except KeyError:
origin.depth_type = OriginDepthType('from location')
try:
origin.quality.used_phase_count = int(phase_count)
origin.quality.associated_phase_count = int(phase_count)
except ValueError:
pass
try:
origin.quality.used_station_count = int(station_count)
origin.quality.associated_station_count = int(station_count)
except ValueError:
pass
try:
origin.quality.azimuthal_gap = float(azimuthal_gap)
except ValueError:
pass
self.author = author
origin.creation_info = self._get_creation_info()
public_id = "origin/%s" % origin_id
origin_res_id = self._get_res_id(public_id)
for i in range(3):
try:
magnitude = Magnitude()
magnitude.creation_info = self._get_creation_info()
magnitude.magnitude_type = magnitude_types[i]
magnitude.mag = float(magnitude_values[i])
magnitude.station_count = int(magnitude_station_counts[i])
magnitude.origin_id = origin_res_id
magnitudes.append(magnitude)
event.magnitudes.append(magnitude)
except ValueError:
# Magnitude can be empty but we need to keep the
# position between mag1, mag2 or mag3.
magnitudes.append(None)
return origin, origin_res_id
def basic_test_event():
"""
Function to generate a basic, full test event
"""
from obspy.core.event import Pick, WaveformStreamID, Arrival, Amplitude
from obspy.core.event import Event, Origin, Magnitude
from obspy.core.event import EventDescription, CreationInfo
from obspy import UTCDateTime
test_event = Event()
test_event.origins.append(Origin())
test_event.origins[0].time = UTCDateTime("2012-03-26") + 1
test_event.event_descriptions.append(EventDescription())
test_event.event_descriptions[0].text = 'LE'
test_event.origins[0].latitude = 45.0
test_event.origins[0].longitude = 25.0
test_event.origins[0].depth = 15000
test_event.creation_info = CreationInfo(agency_id='TES')
test_event.origins[0].time_errors['Time_Residual_RMS'] = 0.01
test_event.magnitudes.append(Magnitude())
test_event.magnitudes[0].mag = 0.1
test_event.magnitudes[0].magnitude_type = 'ML'
test_event.magnitudes[0].creation_info = CreationInfo('TES')
test_event.magnitudes[0].origin_id = test_event.origins[0].resource_id
test_event.magnitudes.append(Magnitude())
test_event.magnitudes[1].mag = 0.5
test_event.magnitudes[1].magnitude_type = 'Mc'
test_event.magnitudes[1].creation_info = CreationInfo('TES')
test_event.magnitudes[1].origin_id = test_event.origins[0].resource_id
test_event.magnitudes.append(Magnitude())
test_event.magnitudes[2].mag = 1.3
test_event.magnitudes[2].magnitude_type = 'Ms'
test_event.magnitudes[2].creation_info = CreationInfo('TES')
test_event.magnitudes[2].origin_id = test_event.origins[0].resource_id
# Define the test pick
_waveform_id = WaveformStreamID(station_code='FOZ',
channel_code='SHZ',
network_code='NZ')
test_event.picks.append(
Pick(waveform_id=_waveform_id,
onset='impulsive',
phase_hint='PN',
polarity='positive',
time=UTCDateTime("2012-03-26") + 1.68,
horizontal_slowness=12,
backazimuth=20))
test_event.amplitudes.append(
Amplitude(generic_amplitude=2.0,
period=0.4,
pick_id=test_event.picks[0].resource_id,
waveform_id=test_event.picks[0].waveform_id,
unit='m'))
test_event.origins[0].arrivals.append(
Arrival(time_weight=2,
phase=test_event.picks[0].phase_hint,
pick_id=test_event.picks[0].resource_id,
backazimuth_residual=5,
time_residual=0.2,
distance=15,
azimuth=25))
return test_event
def full_test_event():
"""
Function to generate a basic, full test event
"""
test_event = Event()
test_event.origins.append(Origin())
test_event.origins[0].time = UTCDateTime("2012-03-26") + 1.2
test_event.event_descriptions.append(EventDescription())
test_event.event_descriptions[0].text = 'LE'
test_event.origins[0].latitude = 45.0
test_event.origins[0].longitude = 25.0
test_event.origins[0].depth = 15000
test_event.creation_info = CreationInfo(agency_id='TES')
test_event.origins[0].quality = OriginQuality(standard_error=0.01)
test_event.magnitudes.append(Magnitude())
test_event.magnitudes[0].mag = 0.1
test_event.magnitudes[0].magnitude_type = 'ML'
test_event.magnitudes[0].creation_info = CreationInfo('TES')
test_event.magnitudes[0].origin_id = test_event.origins[0].resource_id
test_event.magnitudes.append(Magnitude())
test_event.magnitudes[1].mag = 0.5
test_event.magnitudes[1].magnitude_type = 'Mc'
test_event.magnitudes[1].creation_info = CreationInfo('TES')
test_event.magnitudes[1].origin_id = test_event.origins[0].resource_id
test_event.magnitudes.append(Magnitude())
test_event.magnitudes[2].mag = 1.3
test_event.magnitudes[2].magnitude_type = 'Ms'
test_event.magnitudes[2].creation_info = CreationInfo('TES')
test_event.magnitudes[2].origin_id = test_event.origins[0].resource_id
# Define the test pick
_waveform_id_1 = WaveformStreamID(station_code='FOZ', channel_code='SHZ',
network_code='NZ')
_waveform_id_2 = WaveformStreamID(station_code='WTSZ', channel_code='BH1',
network_code=' ')
# Pick to associate with amplitude - 0
test_event.picks = [
Pick(waveform_id=_waveform_id_1, phase_hint='IAML',
polarity='undecidable', time=UTCDateTime("2012-03-26") + 1.68,
evaluation_mode="manual"),
Pick(waveform_id=_waveform_id_1, onset='impulsive', phase_hint='PN',
polarity='positive', time=UTCDateTime("2012-03-26") + 1.68,
evaluation_mode="manual"),
Pick(waveform_id=_waveform_id_1, phase_hint='IAML',
polarity='undecidable', time=UTCDateTime("2012-03-26") + 1.68,
evaluation_mode="manual"),
Pick(waveform_id=_waveform_id_2, onset='impulsive', phase_hint='SG',
polarity='undecidable', time=UTCDateTime("2012-03-26") + 1.72,
evaluation_mode="manual"),
Pick(waveform_id=_waveform_id_2, onset='impulsive', phase_hint='PN',
polarity='undecidable', time=UTCDateTime("2012-03-26") + 1.62,
evaluation_mode="automatic")]
# Test a generic local magnitude amplitude pick
test_event.amplitudes = [
Amplitude(generic_amplitude=2.0, period=0.4,
pick_id=test_event.picks[0].resource_id,
waveform_id=test_event.picks[0].waveform_id, unit='m',
magnitude_hint='ML', category='point', type='AML'),
Amplitude(generic_amplitude=10,
pick_id=test_event.picks[1].resource_id,
waveform_id=test_event.picks[1].waveform_id, type='END',
category='duration', unit='s', magnitude_hint='Mc',
snr=2.3),
Amplitude(generic_amplitude=5.0, period=0.6,
pick_id=test_event.picks[2].resource_id,
waveform_id=test_event.picks[0].waveform_id, unit='m',
category='point', type='AML')]
test_event.origins[0].arrivals = [
Arrival(time_weight=0, phase=test_event.picks[1].phase_hint,
pick_id=test_event.picks[1].resource_id),
Arrival(time_weight=2, phase=test_event.picks[3].phase_hint,
pick_id=test_event.picks[3].resource_id,
backazimuth_residual=5, time_residual=0.2, distance=15,
azimuth=25),
Arrival(time_weight=2, phase=test_event.picks[4].phase_hint,
pick_id=test_event.picks[4].resource_id,
backazimuth_residual=5, time_residual=0.2, distance=15,
azimuth=25)]
return test_event
out_lat=out[i][6::11] #all lats
out_long=out[i][7::11] # all lons
if len(out_et) > 1:
et = UTCDateTime(out_et[0])
lats = out_lat[0]
lons = out_long[0]
if str(out[i][0]) == str(ev):
out_3.append(out[i])
db_catalog = Catalog() # start empty catalog
#Append picks and events from db to Catalog
for i, events in enumerate(out_3):
event=Event()
picks=Pick()
origin=Origin()
arrival=Arrival()
e_time=out_3[i][1::33]
sta = out_3[i][2::33]
cha = out_3[i][3::33]
phase = out_3[i][4::33]
pick_time = out_3[i][5::33] #phase pick time
lat = out_3[i][6::33]
lon = out_3[i][7::33]
orid=out_3[i][8::33]
dep = out_3[i][9::33]
ml=out_3[i][10::33]
for x, times in enumerate(pick_time):
event.resource_id=str(out_3[i][0]) #assign evid
rd = str(out_3[i][0])
picks = Pick(resource_id=rd, time=UTCDateTime(pick_time[x]),
def _internal_read_single_cmtsolution(buf):
"""
Reads a single CMTSOLUTION file to a :class:`~obspy.core.event.Catalog`
object.
:param buf: File to read.
:type buf: open file or file-like object
"""
# The first line encodes the preliminary epicenter.
line = buf.readline()
hypocenter_catalog = line[:5].strip().decode()
origin_time = line[5:].strip().split()[:6]
values = list(map(int, origin_time[:-1])) + \
[float(origin_time[-1])]
try:
origin_time = UTCDateTime(*values)
except (TypeError, ValueError):
warnings.warn("Could not determine origin time from line: %s. Will "
"be set to zero." % line)
origin_time = UTCDateTime(0)
line = line[28:].split()
latitude, longitude, depth, body_wave_mag, surface_wave_mag = \
map(float, line[:5])
# The rest encodes the centroid solution.
event_name = buf.readline().strip().split()[-1].decode()
preliminary_origin = Origin(
resource_id=_get_resource_id(event_name, "origin", tag="prelim"),
time=origin_time,
longitude=longitude,
latitude=latitude,
# Depth is in meters.
depth=depth * 1000.0,
origin_type="hypocenter",
region=_fe.get_region(longitude=longitude, latitude=latitude),
evaluation_status="preliminary")
preliminary_bw_magnitude = Magnitude(
resource_id=_get_resource_id(event_name, "magnitude", tag="prelim_bw"),
mag=body_wave_mag,
magnitude_type="Mb",
evaluation_status="preliminary",
origin_id=preliminary_origin.resource_id)
preliminary_sw_magnitude = Magnitude(
resource_id=_get_resource_id(event_name, "magnitude", tag="prelim_sw"),
mag=surface_wave_mag,
magnitude_type="MS",
evaluation_status="preliminary",
origin_id=preliminary_origin.resource_id)
values = [
"time_shift", "half_duration", "latitude", "longitude", "depth",
"m_rr", "m_tt", "m_pp", "m_rt", "m_rp", "m_tp"
]
cmt_values = {
_i: float(buf.readline().strip().split()[-1])
for _i in values
}
# Moment magnitude calculation in dyne * cm.
m_0 = 1.0 / math.sqrt(2.0) * math.sqrt(
cmt_values["m_rr"]**2 + cmt_values["m_tt"]**2 + cmt_values["m_pp"]**2 +
2.0 * cmt_values["m_rt"]**2 + 2.0 * cmt_values["m_rp"]**2 +
2.0 * cmt_values["m_tp"]**2)
m_w = 2.0 / 3.0 * (math.log10(m_0) - 16.1)
# Convert to meters.
cmt_values["depth"] *= 1000.0
# Convert to Newton meter.
values = ["m_rr", "m_tt", "m_pp", "m_rt", "m_rp", "m_tp"]
for value in values:
cmt_values[value] /= 1E7
cmt_origin = Origin(
resource_id=_get_resource_id(event_name, "origin", tag="cmt"),
time=origin_time + cmt_values["time_shift"],
longitude=cmt_values["longitude"],
latitude=cmt_values["latitude"],
depth=cmt_values["depth"],
origin_type="centroid",
# Could rarely be different than the epicentral region.
region=_fe.get_region(longitude=cmt_values["longitude"],
latitude=cmt_values["latitude"])
# No evaluation status as it could be any of several and the file
# format does not provide that information.
)
cmt_mag = Magnitude(
resource_id=_get_resource_id(event_name, "magnitude", tag="mw"),
# Round to 2 digits.
mag=round(m_w, 2),
magnitude_type="mw",
origin_id=cmt_origin.resource_id)
foc_mec = FocalMechanism(
resource_id=_get_resource_id(event_name, "focal_mechanism"),
# The preliminary origin most likely triggered the focal mechanism
# determination.
triggering_origin_id=preliminary_origin.resource_id)
tensor = Tensor(m_rr=cmt_values["m_rr"],
m_pp=cmt_values["m_pp"],
m_tt=cmt_values["m_tt"],
m_rt=cmt_values["m_rt"],
m_rp=cmt_values["m_rp"],
m_tp=cmt_values["m_tp"])
# Source time function is a triangle, according to the SPECFEM manual.
stf = SourceTimeFunction(
type="triangle",
# The duration is twice the half duration.
duration=2.0 * cmt_values["half_duration"])
mt = MomentTensor(
resource_id=_get_resource_id(event_name, "moment_tensor"),
derived_origin_id=cmt_origin.resource_id,
moment_magnitude_id=cmt_mag.resource_id,
# Convert to Nm.
scalar_moment=m_0 / 1E7,
tensor=tensor,
source_time_function=stf)
# Assemble everything.
foc_mec.moment_tensor = mt
ev = Event(resource_id=_get_resource_id(event_name, "event"),
event_type="earthquake")
ev.event_descriptions.append(
EventDescription(text=event_name, type="earthquake name"))
ev.comments.append(
Comment(text="Hypocenter catalog: %s" % hypocenter_catalog,
force_resource_id=False))
ev.origins.append(cmt_origin)
ev.origins.append(preliminary_origin)
ev.magnitudes.append(cmt_mag)
ev.magnitudes.append(preliminary_bw_magnitude)
ev.magnitudes.append(preliminary_sw_magnitude)
ev.focal_mechanisms.append(foc_mec)
# Set the preferred items.
ev.preferred_origin_id = cmt_origin.resource_id.id
ev.preferred_magnitude_id = cmt_mag.resource_id.id
ev.preferred_focal_mechanism_id = foc_mec.resource_id.id
ev.scope_resource_ids()
return ev
f = open(fmt_cat_uturuncu, "r")
lines = f.readlines()[skip_headers:]
f.close()
# NOTE this loop sends a request for each line in the catalog (63 events)
for line in lines:
line_elements = line.split()
eid = line_elements[-1]
otime = uh.eid2otime(eid)
elon = line_elements[6]
elat = line_elements[7]
edep = float(line_elements[8]) * 1000.0 # meters
emag = line_elements[16]
# create event object
orig = Origin()
orig.longitude = elon
orig.latitude = elat
orig.depth = edep
orig.time = otime
mag = Magnitude()
mag.mag = emag
mag.magnitude_type = "Mw"
ev = Event()
ev.origins.append(orig)
ev.magnitudes.append(mag)
if send_request:
# get waveforms
client = Client("IRIS")
getwaveform_iris.run_get_waveform(c=client,
def _dbs_associator(start_time,
end_time,
moving_window,
tbl,
pair_n,
save_dir,
station_list,
consider_combination=False):
if consider_combination == True:
if platform.system() == 'Windows':
Y2000_writer = open(save_dir + "\\" + "Y2000.phs", "w")
else:
Y2000_writer = open(save_dir + "/" + "Y2000.phs", "w")
traceNmae_dic = dict()
st = datetime.strptime(start_time, '%Y-%m-%d %H:%M:%S.%f')
et = datetime.strptime(end_time, '%Y-%m-%d %H:%M:%S.%f')
total_t = et - st
evid = 0
tt = st
pbar = tqdm(total=int(np.ceil(total_t.total_seconds() /
moving_window)),
ncols=100)
while tt < et:
detections = tbl[(tbl.event_start_time >= tt) & (
tbl.event_start_time < tt + timedelta(seconds=moving_window))]
pbar.update()
if len(detections) >= pair_n:
evid += 1
yr = "{:>4}".format(
str(detections.iloc[0]['event_start_time']).split(' ')
[0].split('-')[0])
mo = "{:>2}".format(
str(detections.iloc[0]['event_start_time']).split(' ')
[0].split('-')[1])
dy = "{:>2}".format(
str(detections.iloc[0]['event_start_time']).split(' ')
[0].split('-')[2])
hr = "{:>2}".format(
str(detections.iloc[0]['event_start_time']).split(' ')
[1].split(':')[0])
mi = "{:>2}".format(
str(detections.iloc[0]['event_start_time']).split(' ')
[1].split(':')[1])
sec = "{:>4}".format(
str(detections.iloc[0]['event_start_time']).split(' ')
[1].split(':')[2])
st_lat_DMS = _decimalDegrees2DMS(
float(detections.iloc[0]['stlat']), "Latitude")
st_lon_DMS = _decimalDegrees2DMS(
float(detections.iloc[0]['stlon']), "Longitude")
depth = 5.0
mag = 0.0
# QuakeML
print(detections.iloc[0]['event_start_time'])
if len(detections) / pair_n <= 2:
ch = pair_n
else:
ch = int(len(detections) - pair_n)
picks = []
for ns in range(ch, len(detections) + 1):
comb = 0
for ind in list(combinations(detections.index, ns)):
comb += 1
selected_detections = detections.loc[ind, :]
sorted_detections = selected_detections.sort_values(
'p_arrival_time')
Y2000_writer.write(
"%4d%2d%2d%2d%2d%4.2f%2.0f%1s%4.2f%3.0f%1s%4.2f%5.2f%3.2f\n"
% (int(yr), int(mo), int(dy), int(hr), int(mi),
float(sec), float(st_lat_DMS[0]),
str(st_lat_DMS[1]), float(st_lat_DMS[2]),
float(st_lon_DMS[0]), str(st_lon_DMS[1]),
float(st_lon_DMS[2]), float(depth), float(mag)))
station_buffer = []
row_buffer = []
tr_names = []
tr_names2 = []
for _, row in sorted_detections.iterrows():
trace_name = row['traceID'] + '*' + row[
'station'] + '*' + str(row['event_start_time'])
p_unc = row['p_unc']
p_prob = row['p_prob']
s_unc = row['s_unc']
s_prob = row['s_prob']
if p_unc:
Pweihgt = _weighcalculator_prob(p_prob *
(1 - p_unc))
else:
Pweihgt = _weighcalculator_prob(p_prob)
try:
Pweihgt = int(Pweihgt)
except Exception:
Pweihgt = 4
if s_unc:
Sweihgt = _weighcalculator_prob(s_prob *
(1 - s_unc))
else:
Sweihgt = _weighcalculator_prob(s_prob)
try:
Sweihgt = int(Sweihgt)
except Exception:
Sweihgt = 4
station = "{:<5}".format(row['station'])
network = "{:<2}".format(row['network'])
try:
yrp = "{:>4}".format(
str(row['p_arrival_time']).split(' ')
[0].split('-')[0])
mop = "{:>2}".format(
str(row['p_arrival_time']).split(' ')
[0].split('-')[1])
dyp = "{:>2}".format(
str(row['p_arrival_time']).split(' ')
[0].split('-')[2])
hrp = "{:>2}".format(
str(row['p_arrival_time']).split(' ')
[1].split(':')[0])
mip = "{:>2}".format(
str(row['p_arrival_time']).split(' ')
[1].split(':')[1])
sec_p = "{:>4}".format(
str(row['p_arrival_time']).split(' ')
[1].split(':')[2])
p = Pick(time=UTCDateTime(
row['p_arrival_time']),
waveform_id=WaveformStreamID(
network_code=network,
station_code=station.rstrip()),
phase_hint="P")
picks.append(p)
except Exception:
sec_p = None
try:
yrs = "{:>4}".format(
str(row['s_arrival_time']).split(' ')
[0].split('-')[0])
mos = "{:>2}".format(
str(row['s_arrival_time']).split(' ')
[0].split('-')[1])
dys = "{:>2}".format(
str(row['s_arrival_time']).split(' ')
[0].split('-')[2])
hrs = "{:>2}".format(
str(row['s_arrival_time']).split(' ')
[1].split(':')[0])
mis = "{:>2}".format(
str(row['s_arrival_time']).split(' ')
[1].split(':')[1])
sec_s = "{:>4}".format(
str(row['s_arrival_time']).split(' ')
[1].split(':')[2])
p = Pick(time=UTCDateTime(
row['p_arrival_time']),
waveform_id=WaveformStreamID(
network_code=network,
station_code=station.rstrip()),
phase_hint="S")
picks.append(p)
except Exception:
sec_s = None
if row['station'] not in station_buffer:
tr_names.append(trace_name)
station_buffer.append(row['station'])
if sec_s:
Y2000_writer.write(
"%5s%2s HHE %4d%2d%2d%2d%2d%5.2f %5.2fES %1d\n"
%
(station, network, int(yrs), int(mos),
int(dys), int(hrs), int(mis),
float(0.0), float(sec_s), Sweihgt))
if sec_p:
Y2000_writer.write(
"%5s%2s HHZ IP %1d%4d%2d%2d%2d%2d%5.2f %5.2f 0\n"
% (station, network, Pweihgt, int(yrp),
int(mop), int(dyp), int(hrp),
int(mip), float(sec_p), float(0.0)))
else:
tr_names2.append(trace_name)
if sec_s:
row_buffer.append(
"%5s%2s HHE %4d%2d%2d%2d%2d%5.2f %5.2fES %1d\n"
%
(station, network, int(yrs), int(mos),
int(dys), int(hrs), int(mis), 0.0,
float(sec_s), Sweihgt))
if sec_p:
row_buffer.append(
"%5s%2s HHZ IP %1d%4d%2d%2d%2d%2d%5.2f %5.2f 0\n"
% (station, network, Pweihgt, int(yrp),
int(mop), int(dyp), int(hrp),
int(mip), float(sec_p), float(0.0)))
Y2000_writer.write("{:<62}".format(' ') + "%10d" %
(evid) + '\n')
traceNmae_dic[str(evid)] = tr_names
if len(row_buffer) >= 2 * pair_n:
Y2000_writer.write(
"%4d%2d%2d%2d%2d%4.2f%2.0f%1s%4.2f%3.0f%1s%4.2f%5.2f%3.2f\n"
% (int(yr), int(mo), int(dy), int(hr), int(mi),
float(sec), float(st_lat_DMS[0]), str(
st_lat_DMS[1]), float(st_lat_DMS[2]),
float(st_lon_DMS[0]), str(st_lon_DMS[1]),
float(st_lon_DMS[2]), float(depth), float(mag)))
for rr in row_buffer:
Y2000_writer.write(rr)
Y2000_writer.write("{:<62}".format(' ') + "%10d" % (evid) +
'\n')
traceNmae_dic[str(evid)] = tr_names2
tt += timedelta(seconds=moving_window)
# plt.scatter(LTTP, TTP, s=10, marker='o', c='b', alpha=0.4, label='P')
# plt.scatter(LTTS, TTS, s=10, marker='o', c='r', alpha=0.4, label='S')
# plt.legend('upper right')
# plt.show()
print('The Number of Realizations: ' + str(evid) + '\n', flush=True)
jj = json.dumps(traceNmae_dic)
if platform.system() == 'Windows':
f = open(save_dir + "\\" + "traceNmae_dic.json", "w")
else:
f = open(save_dir + "/" + "traceNmae_dic.json", "w")
f.write(jj)
f.close()
else:
if platform.system() == 'Windows':
Y2000_writer = open(save_dir + "\\" + "Y2000.phs", "w")
else:
Y2000_writer = open(save_dir + "/" + "Y2000.phs", "w")
cat = Catalog()
traceNmae_dic = dict()
st = datetime.strptime(start_time, '%Y-%m-%d %H:%M:%S.%f')
et = datetime.strptime(end_time, '%Y-%m-%d %H:%M:%S.%f')
total_t = et - st
evid = 200000
evidd = 100000
tt = st
pbar = tqdm(total=int(np.ceil(total_t.total_seconds() /
moving_window)))
while tt < et:
detections = tbl[(tbl.event_start_time >= tt) & (
tbl.event_start_time < tt + timedelta(seconds=moving_window))]
pbar.update()
if len(detections) >= pair_n:
yr = "{:>4}".format(
str(detections.iloc[0]['event_start_time']).split(' ')
[0].split('-')[0])
mo = "{:>2}".format(
str(detections.iloc[0]['event_start_time']).split(' ')
[0].split('-')[1])
dy = "{:>2}".format(
str(detections.iloc[0]['event_start_time']).split(' ')
[0].split('-')[2])
hr = "{:>2}".format(
str(detections.iloc[0]['event_start_time']).split(' ')
[1].split(':')[0])
mi = "{:>2}".format(
str(detections.iloc[0]['event_start_time']).split(' ')
[1].split(':')[1])
sec = "{:>4}".format(
str(detections.iloc[0]['event_start_time']).split(' ')
[1].split(':')[2])
st_lat_DMS = _decimalDegrees2DMS(
float(detections.iloc[0]['stlat']), "Latitude")
st_lon_DMS = _decimalDegrees2DMS(
float(detections.iloc[0]['stlon']), "Longitude")
depth = 5.0
mag = 0.0
Y2000_writer.write(
"%4d%2d%2d%2d%2d%4.2f%2.0f%1s%4.2f%3.0f%1s%4.2f%5.2f%3.2f\n"
% (int(yr), int(mo), int(dy), int(hr), int(mi), float(sec),
float(st_lat_DMS[0]), str(st_lat_DMS[1]),
float(st_lat_DMS[2]), float(st_lon_DMS[0]),
str(st_lon_DMS[1]), float(
st_lon_DMS[2]), float(depth), float(mag)))
event = Event()
origin = Origin(time=UTCDateTime(
detections.iloc[0]['event_start_time']),
longitude=detections.iloc[0]['stlon'],
latitude=detections.iloc[0]['stlat'],
method="EqTransformer")
event.origins.append(origin)
station_buffer = []
row_buffer = []
sorted_detections = detections.sort_values('p_arrival_time')
tr_names = []
tr_names2 = []
picks = []
for _, row in sorted_detections.iterrows():
trace_name = row['traceID'] + '*' + row[
'station'] + '*' + str(row['event_start_time'])
p_unc = row['p_unc']
p_prob = row['p_prob']
s_unc = row['s_unc']
s_prob = row['s_prob']
if p_unc:
Pweihgt = _weighcalculator_prob(p_prob * (1 - p_unc))
else:
Pweihgt = _weighcalculator_prob(p_prob)
try:
Pweihgt = int(Pweihgt)
except Exception:
Pweihgt = 4
if s_unc:
Sweihgt = _weighcalculator_prob(s_prob * (1 - s_unc))
else:
Sweihgt = _weighcalculator_prob(s_prob)
try:
Sweihgt = int(Sweihgt)
except Exception:
Sweihgt = 4
station = "{:<5}".format(row['station'])
network = "{:<2}".format(row['network'])
try:
yrp = "{:>4}".format(
str(row['p_arrival_time']).split(' ')[0].split('-')
[0])
mop = "{:>2}".format(
str(row['p_arrival_time']).split(' ')[0].split('-')
[1])
dyp = "{:>2}".format(
str(row['p_arrival_time']).split(' ')[0].split('-')
[2])
hrp = "{:>2}".format(
str(row['p_arrival_time']).split(' ')[1].split(':')
[0])
mip = "{:>2}".format(
str(row['p_arrival_time']).split(' ')[1].split(':')
[1])
sec_p = "{:>4}".format(
str(row['p_arrival_time']).split(' ')[1].split(':')
[2])
p = Pick(time=UTCDateTime(row['p_arrival_time']),
waveform_id=WaveformStreamID(
network_code=network,
station_code=station.rstrip()),
phase_hint="P",
method_id="EqTransformer")
picks.append(p)
except Exception:
sec_p = None
try:
yrs = "{:>4}".format(
str(row['s_arrival_time']).split(' ')[0].split('-')
[0])
mos = "{:>2}".format(
str(row['s_arrival_time']).split(' ')[0].split('-')
[1])
dys = "{:>2}".format(
str(row['s_arrival_time']).split(' ')[0].split('-')
[2])
hrs = "{:>2}".format(
str(row['s_arrival_time']).split(' ')[1].split(':')
[0])
mis = "{:>2}".format(
str(row['s_arrival_time']).split(' ')[1].split(':')
[1])
sec_s = "{:>4}".format(
str(row['s_arrival_time']).split(' ')[1].split(':')
[2])
p = Pick(time=UTCDateTime(row['s_arrival_time']),
waveform_id=WaveformStreamID(
network_code=network,
station_code=station.rstrip()),
phase_hint="S",
method_id="EqTransformer")
picks.append(p)
except Exception:
sec_s = None
if row['station'] not in station_buffer:
tr_names.append(trace_name)
station_buffer.append(row['station'])
if sec_s:
Y2000_writer.write(
"%5s%2s HHE %4d%2d%2d%2d%2d%5.2f %5.2fES %1d\n"
% (station, network, int(yrs), int(mos),
int(dys), int(hrs), int(mis), float(0.0),
float(sec_s), Sweihgt))
if sec_p:
Y2000_writer.write(
"%5s%2s HHZ IP %1d%4d%2d%2d%2d%2d%5.2f %5.2f 0\n"
% (station, network, Pweihgt, int(yrp),
int(mop), int(dyp), int(hrp), int(mip),
float(sec_p), float(0.0)))
else:
tr_names2.append(trace_name)
if sec_s:
row_buffer.append(
"%5s%2s HHE %4d%2d%2d%2d%2d%5.2f %5.2fES %1d\n"
% (station, network, int(yrs), int(mos),
int(dys), int(hrs), int(mis), 0.0,
float(sec_s), Sweihgt))
if sec_p:
row_buffer.append(
"%5s%2s HHZ IP %1d%4d%2d%2d%2d%2d%5.2f %5.2f 0\n"
% (station, network, Pweihgt, int(yrp),
int(mop), int(dyp), int(hrp), int(mip),
float(sec_p), float(0.0)))
event.picks = picks
event.preferred_origin_id = event.origins[0].resource_id
cat.append(event)
evid += 1
Y2000_writer.write("{:<62}".format(' ') + "%10d" % (evid) +
'\n')
traceNmae_dic[str(evid)] = tr_names
if len(row_buffer) >= 2 * pair_n:
Y2000_writer.write(
"%4d%2d%2d%2d%2d%4.2f%2.0f%1s%4.2f%3.0f%1s%4.2f%5.2f%3.2f\n"
% (int(yr), int(mo), int(dy), int(hr), int(mi),
float(sec), float(st_lat_DMS[0]), str(
st_lat_DMS[1]), float(st_lat_DMS[2]),
float(st_lon_DMS[0]), str(st_lon_DMS[1]),
float(st_lon_DMS[2]), float(depth), float(mag)))
for rr in row_buffer:
Y2000_writer.write(rr)
evid += 1
Y2000_writer.write("{:<62}".format(' ') + "%10d" % (evid) +
'\n')
traceNmae_dic[str(evid)] = tr_names2
elif len(row_buffer) < pair_n and len(row_buffer) != 0:
evidd += 1
traceNmae_dic[str(evidd)] = tr_names2
elif len(detections) < pair_n and len(detections) != 0:
tr_names = []
for _, row in detections.iterrows():
trace_name = row['traceID']
tr_names.append(trace_name)
evidd += 1
traceNmae_dic[str(evidd)] = tr_names
tt += timedelta(seconds=moving_window)
print('The Number of Associated Events: ' + str(evid - 200000) + '\n',
flush=True)
jj = json.dumps(traceNmae_dic)
if platform.system() == 'Windows':
f = open(save_dir + "\\" + "traceNmae_dic.json", "w")
else:
f = open(save_dir + "/" + "traceNmae_dic.json", "w")
f.write(jj)
f.close()
print(cat.__str__(print_all=True))
cat.write(save_dir + "/associations.xml", format="QUAKEML")
def test_creating_minimal_quakeml_with_mt(self):
"""
Tests the creation of a minimal QuakeML containing origin, magnitude
and moment tensor.
"""
# Rotate into physical domain
lat, lon, depth, org_time = 10.0, -20.0, 12000, UTCDateTime(2012, 1, 1)
mrr, mtt, mpp, mtr, mpr, mtp = 1E18, 2E18, 3E18, 3E18, 2E18, 1E18
scalar_moment = math.sqrt(
mrr ** 2 + mtt ** 2 + mpp ** 2 + mtr ** 2 + mpr ** 2 + mtp ** 2)
moment_magnitude = 0.667 * (math.log10(scalar_moment) - 9.1)
# Initialise event
ev = Event(event_type="earthquake")
ev_origin = Origin(time=org_time, latitude=lat, longitude=lon,
depth=depth, resource_id=ResourceIdentifier())
ev.origins.append(ev_origin)
# populate event moment tensor
ev_tensor = Tensor(m_rr=mrr, m_tt=mtt, m_pp=mpp, m_rt=mtr, m_rp=mpr,
m_tp=mtp)
ev_momenttensor = MomentTensor(tensor=ev_tensor)
ev_momenttensor.scalar_moment = scalar_moment
ev_momenttensor.derived_origin_id = ev_origin.resource_id
ev_focalmechanism = FocalMechanism(moment_tensor=ev_momenttensor)
ev.focal_mechanisms.append(ev_focalmechanism)
# populate event magnitude
ev_magnitude = Magnitude()
ev_magnitude.mag = moment_magnitude
ev_magnitude.magnitude_type = 'Mw'
ev_magnitude.evaluation_mode = 'automatic'
ev.magnitudes.append(ev_magnitude)
# write QuakeML file
cat = Catalog(events=[ev])
memfile = io.BytesIO()
cat.write(memfile, format="quakeml", validate=IS_RECENT_LXML)
memfile.seek(0, 0)
new_cat = _read_quakeml(memfile)
self.assertEqual(len(new_cat), 1)
event = new_cat[0]
self.assertEqual(len(event.origins), 1)
self.assertEqual(len(event.magnitudes), 1)
self.assertEqual(len(event.focal_mechanisms), 1)
org = event.origins[0]
mag = event.magnitudes[0]
fm = event.focal_mechanisms[0]
self.assertEqual(org.latitude, lat)
self.assertEqual(org.longitude, lon)
self.assertEqual(org.depth, depth)
self.assertEqual(org.time, org_time)
# Moment tensor.
mt = fm.moment_tensor.tensor
self.assertTrue((fm.moment_tensor.scalar_moment - scalar_moment) /
scalar_moment < scalar_moment * 1E-10)
self.assertEqual(mt.m_rr, mrr)
self.assertEqual(mt.m_pp, mpp)
self.assertEqual(mt.m_tt, mtt)
self.assertEqual(mt.m_rt, mtr)
self.assertEqual(mt.m_rp, mpr)
self.assertEqual(mt.m_tp, mtp)
# Mag
self.assertAlmostEqual(mag.mag, moment_magnitude)
self.assertEqual(mag.magnitude_type, "Mw")
self.assertEqual(mag.evaluation_mode, "automatic")
def sdxtoquakeml(sdx_dir,
out_xml,
time_uncertainties=[0.1, 0.2, 0.5, 0.8, 1.5],
catalog_description="",
catalog_version="",
agency_id="",
author="",
vel_mod_id=""):
"""
Convert SDX to QuakeML format using ObsPy inventory structure.
SDX filename prefix is stored under event description.
Input parameters:
- sdx_dir: directory containing sdx files (required)
- out_xml: Filename of quakeML file (required)
- time_uncertainties: List containing time uncertainities in seconds
for mapping from weights 0-4, respectively (optional)
- catalog_description (optional)
- cat_agency_id (optional)
- author (optional)
- vel_mod_id (optional)
Output:
- xml catalog in QuakeML format.
"""
# Prepare catalog
cat = Catalog(description=catalog_description,
creation_info=CreationInfo(author=author,
agency_id=agency_id,
version=catalog_version))
# Read in sdx files in directory, recursively
files = glob.glob("{:}/**/*.sdx".format(sdx_dir), recursive=True)
if len(files) == 0:
print("No SDX files found in path. Exiting")
for sdx_file_path in files:
print("Working on ", sdx_file_path.split('/')[-1])
# Set-up event
evt_id = (sdx_file_path.split('/')[-1])[:-4]
event = Event(event_type="earthquake",
creation_info=CreationInfo(author=author,
agency_id=agency_id),
event_descriptions=[EventDescription(text=evt_id)])
# Get station details, append to arrays
sdx_file = open(sdx_file_path, "r")
stations = []
for line in sdx_file:
if line.rstrip() == "station":
sdxstation = list(islice(sdx_file, 5))
stations.append([
sdxstation[1].split()[0],
float(sdxstation[2].split()[0]),
float(sdxstation[3].split()[0]),
float(sdxstation[4].split()[0])
])
sdx_file.close()
# Find origin details, append to origin object
sdx_file = open(sdx_file_path, "r")
found_origin = False
for line in sdx_file:
if line.rstrip() == "origin":
found_origin = True
sdxorigin = list(islice(sdx_file, 17))
orig_time = ("{:}T{:}".format(
sdxorigin[1][0:10].replace(".", "-"), sdxorigin[1][11:23]))
evt_lat = float(sdxorigin[2].split()[0])
evt_lon = float(sdxorigin[3].split()[0])
evt_depth = float(sdxorigin[4].split()[0])
creation_time = UTCDateTime("{:}T{:}".format(
sdxorigin[16].split()[6][0:10].replace(".", "-"),
sdxorigin[16].split()[6][11:23]))
num_arrivals = int(sdxorigin[12].split()[0])
num_arrivals_p = (int(sdxorigin[12].split()[0]) -
int(sdxorigin[12].split()[1]))
min_dist = float(sdxorigin[12].split()[9])
max_dist = float(sdxorigin[12].split()[10])
med_dist = float(sdxorigin[12].split()[11])
max_az_gap = float(sdxorigin[12].split()[6])
origin = Origin(time=UTCDateTime(orig_time),
longitude=evt_lon,
latitude=evt_lat,
depth=evt_depth * -1000,
earth_model_id=vel_mod_id,
origin_type="hypocenter",
evaluation_mode="manual",
evaluation_status="confirmed",
method_id=ResourceIdentifier(id="SDX_hypo71"),
creation_info=CreationInfo(
creation_time=creation_time,
author=author,
agency_id=agency_id),
quality=OriginQuality(
associated_phase_count=num_arrivals,
used_phase_count=num_arrivals,
associated_station_count=num_arrivals_p,
used_station_count=num_arrivals_p,
azimuthal_gap=max_az_gap,
minimum_distance=min_dist,
maximum_distance=max_dist,
median_distance=med_dist))
event.origins.append(origin)
sdx_file.close()
# Skip event if no computed origin
if found_origin is False:
print("No origin found ... skipping event")
continue
# Get pick details, append to pick and arrival objects
sdx_file = open(sdx_file_path, "r")
found_pick = False
for line in sdx_file:
if line.rstrip() == "pick":
found_pick = True
sdxpick = list(islice(sdx_file, 15))
pick_time = UTCDateTime("{:}T{:}".format(
sdxpick[1][0:10].replace(".", "-"), sdxpick[1][11:23]))
network = sdxpick[2].split()[0]
station = sdxpick[2].split()[1]
location = sdxpick[2].split()[2]
if "NOT_SET" in location:
location = ""
channel = sdxpick[2].split()[3]
onset = sdxpick[8].split()[0]
if onset == "0":
pickonset = "emergent"
elif onset == "1":
pickonset = "impulsive"
elif onset == "2":
pickonset = "questionable"
phase = sdxpick[9].split()[0]
polarity = sdxpick[10].split()[0]
if polarity == "0":
pol = "positive"
elif polarity == "1":
pol = "negative"
elif polarity == "2":
pol = "undecidable"
weight = int(sdxpick[11].split()[0])
creation_time = UTCDateTime("{:}T{:}".format(
sdxpick[14].split()[6][0:10].replace(".", "-"),
sdxpick[14].split()[6][11:23]))
pick = Pick(
time=pick_time,
waveform_id=WaveformStreamID(network_code=network,
station_code=station,
location_code=location,
channel_code=channel),
time_errors=time_uncertainties[weight],
evaluation_mode="manual",
evaluation_status="confirmed",
onset=pickonset,
phase_hint=phase,
polarity=pol,
method_id=ResourceIdentifier(id="SDX"),
creation_info=CreationInfo(creation_time=creation_time))
event.picks.append(pick)
# Compute azimuth, distance, append to arrival object
for i in range(0, len(stations)):
if stations[i][0] == station:
azimuth = (gps2dist_azimuth(evt_lat, evt_lon,
stations[i][1],
stations[i][2])[1])
dist_deg = locations2degrees(evt_lat, evt_lon,
stations[i][1],
stations[i][2])
arrival = Arrival(phase=phase,
pick_id=pick.resource_id,
azimuth=azimuth,
distance=dist_deg,
time_weight=1.00)
event.origins[0].arrivals.append(arrival)
# Skip event if no picks
if found_pick is False:
print("No picks found ... skipping event")
continue
# Set preferred origin and append event to catalogue
event.preferred_origin_id = event.origins[0].resource_id
cat.events.append(event)
sdx_file.close()
cat.write(out_xml, format="QUAKEML")
