def dummy_cat(self):
scnls1 = ["UK.STA1..HHZ", "UK.STA2..HHZ"]
cat = ev.Catalog()
eve1 = ev.Event()
eve1.origins.append(ev.Origin(time=UTCDateTime()))
eve1.amplitudes = make_amplitudes(scnls1)
eve1.station_magnitudes = sm_generator(amplitudes=eve1.amplitudes)
scnls2 = ["UK.STA3..HHZ", "UK.STA4..HHZ", "UK.STA5..HHZ"]
eve2 = ev.Event()
eve2.origins.append(ev.Origin(time=UTCDateTime()))
eve2.station_magnitudes = sm_generator(scnls=scnls2)
cat.events = [eve1, eve2]
return cat
def dummy_cat(self):
scnls1 = ["UK.STA1..HHZ", "UK.STA2..HHZ"]
cat = ev.Catalog()
eve1 = ev.Event()
eve1.origins.append(ev.Origin(time=UTCDateTime()))
eve1.picks = pick_generator(scnls1)
eve1.amplitudes = amp_generator(picks=eve1.picks)
scnls2 = ["UK.STA3..HHZ", "UK.STA4..HHZ", "UK.STA5..HHZ"]
eve2 = ev.Event()
eve2.origins.append(ev.Origin(time=UTCDateTime()))
eve2.amplitudes = amp_generator(scnls=scnls2)
cat.events = [eve1, eve2]
return cat
def dummy_cat(self):
cat = ev.Catalog()
eve = ev.Event()
eve.origins.append(ev.Origin(time=UTCDateTime()))
eve.magnitudes = mag_generator(["ML", "Md", "MW"])
cat.append(eve)
return cat
def strange_picks_added_origins(self, inv):
""" make sure "rejected" picks and oddball phase hints get skipped """
# Pick w/ good phase hint but bad evaluation status
pick1 = ev.Pick(
time=obspy.UTCDateTime(),
phase_hint="P",
evaluation_status="rejected",
waveform_id=ev.WaveformStreamID(seed_string="UU.TMU..HHZ"),
)
# Pick w/ bad phase hint but good evaluation status
pick2 = ev.Pick(
time=obspy.UTCDateTime(),
phase_hint="junk",
evaluation_status="reviewed",
waveform_id=ev.WaveformStreamID(seed_string="UU.CTU..HHZ"),
)
# Pick w/ good phase hint and evaluation status
pick3 = ev.Pick(
time=obspy.UTCDateTime(),
phase_hint="S",
waveform_id=ev.WaveformStreamID(seed_string="UU.SRU..HHN"),
)
eve = ev.Event()
eve.picks = [pick1, pick2, pick3]
return make_origins(events=eve, inventory=inv,
phase_hints=["P", "S"]), pick3
def catalog_no_magnitude(self):
""" get a events with no magnitudes (should just fill with NaN) """
t1 = obspy.UTCDateTime("2099-04-01T00-01-00")
ori = ev.Origin(time=t1, latitude=47.1, longitude=-100.22)
event = ev.Event(origins=[ori])
cat = ev.Catalog(events=[event])
return events_to_df(cat)
def _create_event(ser):
""" create an event from a row from the event dataframe """
event = oe.Event(
resource_id=rid(ser.evid),
creation=oe.CreationInfo(agency_id=ser.auth,
creation_time=UTC(ser.lddate)),
preferred_origin_id=str(ser.prefor),
)
return event
def test_put_new_events(self, bing_ebank):
""" ensure a new event can be put into the bank """
ori = ev.Origin(time=obspy.UTCDateTime("2016-01-01"))
event = ev.Event(origins=[ori])
event.origins[0].depth_errors = None # see obspy 2173
bing_ebank.put_events(event)
event_out = bing_ebank.get_events(event_id=event.resource_id)
assert len(event_out) == 1
assert event_out[0] == event
def dummy_cat(self):
scnls1 = ["UK.STA1..HHZ", "UK.STA2..HHZ"]
cat = ev.Catalog()
eve1 = ev.Event()
eve1.origins.append(ev.Origin(time=UTCDateTime()))
eve1.preferred_origin_id = eve1.origins[0].resource_id
picks = pick_generator(scnls1)
eve1.picks = picks
eve1.preferred_origin().arrivals = make_arrivals(picks)
scnls2 = ["UK.STA3..HHZ", "UK.STA4..HHZ", "UK.STA5..HHZ"]
eve2 = ev.Event()
eve2.origins.append(ev.Origin(time=UTCDateTime()))
eve2.preferred_origin_id = eve2.origins[0].resource_id
picks = pick_generator(scnls2)
eve2.picks = picks
eve2.preferred_origin().arrivals = make_arrivals(picks)
cat.events = [eve1, eve2]
return cat
def event_rejected_pick(self):
""" Create an event with a rejected pick. """
wid = ev.WaveformStreamID(seed_string="UU.TMU.01.ENZ")
time = obspy.UTCDateTime("2019-01-01")
pick1 = ev.Pick(
time=time, waveform_id=wid, phase_hint="P", evaluation_status="rejected"
)
pick2 = ev.Pick(time=time, waveform_id=wid, phase_hint="P")
return ev.Event(picks=[pick1, pick2])
def _saveCatalog(self, filename=None):
'''
Saves the catalog to filename
'''
if self.savefile is None and filename is None:
return self._saveCatalogDlg()
if filename is not None:
savefile = filename
else:
savefile = self.savefile
cat = event.Catalog()
cat.events.append(event.Event(picks=self._picks))
def dummy_mag(self):
scnls = ["UK.STA1..HHZ", "UK.STA2..HHZ"]
eve = ev.Event()
sms = sm_generator(scnls=scnls)
smcs = []
for sm in sms:
smcs.append(
ev.StationMagnitudeContribution(
station_magnitude_id=sm.resource_id))
mag = ev.Magnitude(mag=1, station_magnitude_contributions=smcs)
eve.magnitudes = [mag]
eve.station_magnitudes = sms
return eve
def picks_no_origin(self):
""" create a events that has picks but no origin """
t0 = UTCDateTime("2016-01-01T10:12:15.222")
def wave_id(seed_str):
return ev.WaveformStreamID(seed_string=seed_str)
picks = [
ev.Pick(time=t0 + 2, waveform_id=wave_id("UU.TMU..HHZ")),
ev.Pick(time=t0 + 1.2, waveform_id=wave_id("UU.BOB.01.ELZ")),
ev.Pick(time=t0 + 3.2, waveform_id=wave_id("UU.TEX..EHZ")),
]
return picks_to_dataframe(ev.Event(picks=picks))
def _saveCatalog(self, filename=None):
'''
Saves the catalog to filename
'''
if self.savefile is None and filename is None:
return self._saveCatalogDlg()
if filename is not None:
savefile = filename
else:
savefile = self.savefile
cat = event.Catalog()
cat.events.append(event.Event(picks=self._picks))
cat.write(savefile, format='QUAKEML')
print 'Picks saved as %s' % savefile
def create_event(origintime,
cinfo,
originloc=None,
etype='earthquake',
resID=None,
authority_id=None):
'''
create_event - funtion to create an ObsPy Event
:param origintime: the events origintime
:type origintime: :class: `~obspy.core.utcdatetime.UTCDateTime` object
:param cinfo: An ObsPy :class: `~obspy.core.event.CreationInfo` object
holding information on the creation of the returned object
:type cinfo: :class: `~obspy.core.event.CreationInfo` object
:param originloc: tuple containing the location of the origin
(LAT, LON, DEP) affiliated with the event which is created
:type originloc: tuple, list
:param etype: Event type str object. converted via ObsPy to a valid event
type string.
:type etype: str
:param resID: Resource identifier of the created event
:type resID: :class: `~obspy.core.event.ResourceIdentifier` object, str
:param authority_id: name of the institution carrying out the processing
:type authority_id: str
:return: An ObsPy :class: `~obspy.core.event.Event` object
'''
if originloc is not None:
o = create_origin(origintime, cinfo, originloc[0], originloc[1],
originloc[2])
else:
o = None
if not resID:
resID = create_resourceID(origintime, etype, authority_id)
elif isinstance(resID, str):
resID = create_resourceID(origintime, etype, authority_id, resID)
elif not isinstance(resID, ope.ResourceIdentifier):
raise TypeError("unsupported type(resID) for resource identifier "
"generation: %s" % type(resID))
event = ope.Event(resource_id=resID)
event.creation_info = cinfo
event.event_type = etype
if o:
event.origins = [o]
return event
def _create_event():
event = ev.Event(
event_type='mining explosion',
event_descriptions=[_get_event_description()],
picks=[_create_pick()],
origins=[_create_origins()],
station_magnitudes=[_get_station_mag()],
magnitudes=[_create_magnitudes()],
amplitudes=[_get_amplitudes()],
focal_mechanisms=[_get_focal_mechanisms()],
)
# set preferred origin, focal mechanism, magnitude
preferred_objects = dict(
origin=event.origins[-1].resource_id,
focal_mechanism=event.focal_mechanisms[-1].resource_id,
magnitude=event.magnitudes[-1].resource_id,
)
for item, value in preferred_objects.items():
setattr(event, 'preferred_' + item + '_id', value)
event.scope_resource_ids()
return event
def make_resouce_id():
some_obj = event.Event()
return ResourceIdentifier(referred_object=some_obj)
def catalog_empty(self):
""" get a with one blank event """
event = ev.Event()
cat = ev.Catalog(events=[event])
return events_to_df(cat)
def event_only_picks(self, picks):
return ev.Event(picks=picks)
def no_origin(self):
cat = ev.Catalog()
cat.append(ev.Event())
return cat
def empty_catalog():
""" run an empty events through the picks_to_df function """
event = ev.Event()
cat = obspy.Catalog(events=[event])
return picks_to_dataframe(cat)
def event_only_picks(self, picks):
"""Return an event with only picks."""
return ev.Event(picks=picks)
def reassess_pilot_event(root_dir,
db_dir,
event_id,
out_dir=None,
fn_param=None,
verbosity=0):
from obspy import read
from pylot.core.io.inputs import PylotParameter
from pylot.core.pick.utils import earllatepicker
if fn_param is None:
fn_param = defaults.AUTOMATIC_DEFAULTS
default = PylotParameter(fn_param, verbosity)
search_base = os.path.join(root_dir, db_dir, event_id)
phases_file = glob.glob(os.path.join(search_base, 'PHASES.mat'))
if not phases_file:
return
if verbosity > 1:
print('Opening PILOT phases file: {fn}'.format(fn=phases_file[0]))
picks_dict = picksdict_from_pilot(phases_file[0])
if verbosity > 0:
print('Dictionary read from PHASES.mat:\n{0}'.format(picks_dict))
datacheck = list()
info = None
for station in picks_dict.keys():
fn_pattern = os.path.join(search_base, '{0}*'.format(station))
try:
st = read(fn_pattern)
except TypeError as e:
if 'Unknown format for file' in e.message:
try:
st = read(fn_pattern, format='GSE2')
except ValueError as e:
if e.message == 'second must be in 0..59':
info = 'A known Error was raised. Please find the list of corrupted files and double-check these files.'
datacheck.append(fn_pattern + ' (time info)\n')
continue
else:
raise ValueError(e.message)
except Exception as e:
if 'No file matching file pattern:' in e.message:
if verbosity > 0:
warnings.warn(
'no waveform data found for station {station}'.
format(station=station), RuntimeWarning)
datacheck.append(fn_pattern + ' (no data)\n')
continue
else:
raise e
else:
raise e
for phase in picks_dict[station].keys():
try:
mpp = picks_dict[station][phase]['mpp']
except KeyError as e:
print(e.message, station)
continue
sel_st = select_for_phase(st, phase)
if not sel_st:
msg = 'no waveform data found for station {station}'.format(
station=station)
warnings.warn(msg, RuntimeWarning)
continue
stime, etime = full_range(sel_st)
rel_pick = mpp - stime
epp, lpp, spe = earllatepicker(
sel_st,
default.get('nfac{0}'.format(phase)),
default.get('tsnrz' if phase == 'P' else 'tsnrh'),
Pick1=rel_pick,
iplot=0,
verbosity=0)
if epp is None or lpp is None:
continue
epp = stime + epp
lpp = stime + lpp
min_diff = 3 * st[0].stats.delta
if lpp - mpp < min_diff:
lpp = mpp + min_diff
if mpp - epp < min_diff:
epp = mpp - min_diff
picks_dict[station][phase] = dict(epp=epp,
mpp=mpp,
lpp=lpp,
spe=spe)
if datacheck:
if info:
if verbosity > 0:
print(info + ': {0}'.format(search_base))
fncheck = open(os.path.join(search_base, 'datacheck_list'), 'w')
fncheck.writelines(datacheck)
fncheck.close()
del datacheck
# create Event object for export
evt = ope.Event(resource_id=event_id)
evt.picks = picks_from_picksdict(picks_dict)
# write phase information to file
if not out_dir:
fnout_prefix = os.path.join(root_dir, db_dir, event_id,
'PyLoT_{0}.'.format(event_id))
else:
out_dir = os.path.join(out_dir, db_dir)
if not os.path.isdir(out_dir):
os.makedirs(out_dir)
fnout_prefix = os.path.join(out_dir, 'PyLoT_{0}.'.format(event_id))
evt.write(fnout_prefix + 'xml', format='QUAKEML')
def no_origin(self):
"""Return a catalog with no origin."""
cat = ev.Catalog()
cat.append(ev.Event())
return cat
def bingham_cat_only_picks(self, bingham_dataset):
""" return bingham_test catalog with everything but picks removed """
events = []
for eve in bingham_dataset.event_client.get_events().copy():
events.append(ev.Event(picks=eve.picks))
return obspy.Catalog(events=events)
def test_empty_event_raises(self):
"""ensure an empty event will raise"""
event = ev.Event()
with pytest.raises(ValueError):
get_reference_time(event)
def cat_w_two_events(self, empty_cat):
"""Return a catalog with two empty events"""
empty_cat.append(ev.Event())
empty_cat.append(ev.Event())
return empty_cat
