def get_event_object(self):
'''
update events otime,lat,lon and mag with IRIS (or any other clients) catalog
'''
# get parameters from the cataog
if self.use_catalog == 1:
print("WARNING using event data from the IRIS catalog")
cat = self.client.get_events(
starttime=self.otime - self.sec_before_after_event,
endtime=self.otime + self.sec_before_after_event)
self.ev = cat[0]
# use catalog parameters
self.otime = self.ev.origins[0].time
self.elat = self.ev.origins[0].latitude
self.elon = self.ev.origins[0].longitude
self.edep = self.ev.origins[0].depth
self.emag = self.ev.magnitudes[0].mag
# use parameters from the input file
else:
print("WARNING using event data from user-defined catalog")
#self.ev = Event()
org = Origin()
org.latitude = self.elat
org.longitude = self.elon
org.depth = self.edep
org.time = self.otime
mag = Magnitude()
mag.mag = self.emag
mag.magnitude_type = "Mw"
self.ev.origins.append(org)
self.ev.magnitudes.append(mag)
def __toMagnitude(parser, magnitude_el, origin):
"""
Parses a given magnitude etree element.
:type parser: :class:`~obspy.core.util.xmlwrapper.XMLParser`
:param parser: Open XMLParser object.
:type magnitude_el: etree.element
:param magnitude_el: magnitude element to be parsed.
:return: A ObsPy :class:`~obspy.core.event.Magnitude` object.
"""
global CURRENT_TYPE
mag = Magnitude()
mag.resource_id = ResourceIdentifier(
prefix="/".join([RESOURCE_ROOT, "magnitude"]))
mag.origin_id = origin.resource_id
mag.mag, mag.mag_errors = __toFloatQuantity(parser, magnitude_el, "mag")
# obspyck used to write variance (instead of std) in magnitude error fields
if CURRENT_TYPE == "obspyck":
if mag.mag_errors.uncertainty is not None:
mag.mag_errors.uncertainty = math.sqrt(mag.mag_errors.uncertainty)
mag.mag_errors.confidence_level = 68.3
mag.magnitude_type = parser.xpath2obj("type", magnitude_el)
mag.station_count = parser.xpath2obj("stationCount", magnitude_el, int)
mag.method_id = "%s/magnitude_method/%s/1" % (
RESOURCE_ROOT, parser.xpath2obj('program', magnitude_el))
if str(mag.method_id).lower().endswith("none"):
mag.method_id = None
return mag
def __toMagnitude(parser, magnitude_el, origin):
"""
Parses a given magnitude etree element.
:type parser: :class:`~obspy.core.util.xmlwrapper.XMLParser`
:param parser: Open XMLParser object.
:type magnitude_el: etree.element
:param magnitude_el: magnitude element to be parsed.
:return: A ObsPy :class:`~obspy.core.event.Magnitude` object.
"""
global CURRENT_TYPE
mag = Magnitude()
mag.resource_id = ResourceIdentifier(prefix="/".join([RESOURCE_ROOT, "magnitude"]))
mag.origin_id = origin.resource_id
mag.mag, mag.mag_errors = __toFloatQuantity(parser, magnitude_el, "mag")
# obspyck used to write variance (instead of std) in magnitude error fields
if CURRENT_TYPE == "obspyck":
if mag.mag_errors.uncertainty is not None:
mag.mag_errors.uncertainty = math.sqrt(mag.mag_errors.uncertainty)
mag.magnitude_type = parser.xpath2obj("type", magnitude_el)
mag.station_count = parser.xpath2obj("stationCount", magnitude_el, int)
mag.method_id = "%s/magnitude_method/%s/1" % (RESOURCE_ROOT,
parser.xpath2obj('program', magnitude_el))
if str(mag.method_id).lower().endswith("none"):
mag.method_id = None
return mag
def _block2event(block, seed_map, id_default, ph2comp, eventid_map):
"""
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()
if eventid_map is not None and id_ in eventid_map:
id_ = eventid_map[id_]
time = UTCDateTime(int(yr),
int(mo),
int(dy),
int(hr),
int(mn),
float(sc),
strict=False)
laterr = None if float(eh) == 0 else float(eh) / DEG2KM
lonerr = (None if laterr is None or float(la) > 89 else laterr /
cos(deg2rad(float(la))))
ez = None if float(ez) == 0 else float(ez) * 1000
rms = None if float(rms) == 0 else float(rms)
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 = OriginQuality(associated_phase_count=len(picks), standard_error=rms)
origin = Origin(arrivals=arrivals,
resource_id="smi:local/origin/" + id_,
quality=qu,
latitude=float(la),
longitude=float(lo),
depth=1000 * float(dp),
latitude_errors=laterr,
longitude_errors=lonerr,
depth_errors=ez,
time=time)
if mg.lower() == 'nan':
magnitudes = []
preferred_magnitude_id = None
else:
magnitude = Magnitude(mag=mg, resource_id="smi:local/magnitude/" + id_)
magnitudes = [magnitude]
preferred_magnitude_id = magnitude.resource_id
event = Event(resource_id="smi:local/event/" + id_,
picks=picks,
origins=[origin],
magnitudes=magnitudes,
preferred_origin_id=origin.resource_id,
preferred_magnitude_id=preferred_magnitude_id)
return event
def plot_some_events():
from obspy.core.event import Catalog, Event, Origin, Magnitude
from obspy.core import UTCDateTime as UTC
eqs = """2008-09-10T16:12:03 6.0 -20.40 -69.40 40
2008-03-24T20:39:06 5.9 -20.10 -69.20 85
2008-03-01T19:51:59 5.7 -20.10 -69.60 15
2008-02-15T16:54:04 5.5 -23.00 -70.20 32
2008-02-04T17:01:30 6.6 -20.20 -70.00 36
2007-12-16T08:09:16 7.1 -22.80 -70.00 14
2007-11-14T15:40:51 7.8 -22.34 -70.06 37""" #GEOFON:-22.30 -69.80
events = []
for eq in eqs.split('\n'):
time, mag, lat, lon, depth = eq.split()
ev = Event(event_type='earthquake', creation_info='GEOFON',
origins=[Origin(time=UTC(time), latitude=float(lat),
longitude=float(lon), depth=float(depth))],
magnitudes=[Magnitude(mag=float(mag), magnitude_type='M')])
events.append(ev)
cat = Catalog(events[::-1])
#print cat
#cat.plot(projection='local')
lons = [ev.origins[0].longitude for ev in cat]
lats = [ev.origins[0].latitude for ev in cat]
dates = [ev.origins[0].time for ev in cat]
mags = [ev.magnitudes[0].mag for ev in cat]
def __toMagnitude(parser, magnitude_el):
"""
Parses a given magnitude etree element.
:type parser: :class:`~obspy.core.util.xmlwrapper.XMLParser`
:param parser: Open XMLParser object.
:type magnitude_el: etree.element
:param magnitude_el: magnitude element to be parsed.
:return: A ObsPy :class:`~obspy.core.event.Magnitude` object.
"""
mag = Magnitude()
mag.mag, mag.mag_errors = __toFloatQuantity(parser, magnitude_el, "mag")
mag.magnitude_type = parser.xpath2obj("type", magnitude_el)
mag.station_count = parser.xpath2obj("stationCount", magnitude_el, int)
mag.method_id = parser.xpath2obj("program", magnitude_el)
return mag
def _map_origin2magnitude(self, db, mtype='ml'):
"""
Return an obspy Magnitude from an dict of CSS key/values
corresponding to one record.
Inputs
======
db : dict of key/values of CSS fields from the 'origin' table
Returns
=======
obspy.core.event.Magnitude
Notes
=====
Any object that supports the dict 'get' method can be passed as
input, e.g. OrderedDict, custom classes, etc.
"""
m = Magnitude()
m.mag = db.get(mtype)
m.magnitude_type = mtype
m.creation_info = CreationInfo(
creation_time = _utc(db.get('lddate')),
agency_id = self.agency,
version = db.get('orid'),
author = db.get('auth'),
)
if m.creation_info.author.startswith('orb'):
m.evaluation_status = "preliminary"
else:
m.evaluation_status = "reviewed"
m.resource_id = self._rid(m)
return m
def setUpClass(cls) -> None:
cls.event = Event(origins=[
Origin(time=UTCDateTime(2019, 1, 1),
latitude=-45.,
longitude=90.0,
depth=10000.)
],
magnitudes=[Magnitude(mag=7.4)])
cls.event.preferred_origin_id = cls.event.origins[0].resource_id
def CUSP_to_SC3_rel_mags(det_cat, temp_cat, selfs):
"""
Take a catalog with relative magnitudes calculated using the Ristau 2009
CUSP equation and correct them using the updated SeisComP3 scale
:param det_cat: Catalog of detections and templates with magnitudes
:param selfs: List of strings for self detection ids
:return:
"""
# Make a dictionary of the CUSP-derived moment, SeisComP M0 for templates
temp_mag_dict = {ev.resource_id.id.split('/')[-1]:
{'Old M0':
local_to_moment(ev.magnitudes[0].mag,
m=0.88, c=0.73),
'New M0':
local_to_moment(ev.magnitudes[0].mag,
m=0.97, c=0.14)}
for ev in temp_cat}
# Now loop the catalog and redo the calculations
for det in det_cat:
# First determine the relative moment (I didn't save these anywhere...)
eid = det.resource_id.id.split('/')[-1]
if eid in selfs:
print('Template event: Adding a Mw magnitude')
det.magnitudes.append(
Magnitude(mag=ML_to_Mw(det.magnitudes[0].mag, m=0.97, c=0.14),
magnitude_type='Mw',
comments=[Comment(text='Ristau et al., 2016 BSSA')]))
continue
tid = det.resource_id.id.split('/')[-1].split('_')[0]
det_mo = Mw_to_M0([m.mag for m in det.magnitudes
if m.magnitude_type == 'Mw'][0])
rel_mo = det_mo / temp_mag_dict[tid]['Old M0']
new_det_mo = rel_mo * temp_mag_dict[tid]['New M0']
new_det_Mw = (2. / 3. * np.log10(new_det_mo)) - 9.
new_det_ML = (0.97 * new_det_Mw) + 0.14
det.magnitudes.append(
Magnitude(mag=new_det_Mw, magnitude_type='Mw',
comments=[Comment(text='rel_mo={}'.format(rel_mo))]))
det.magnitudes.append(
Magnitude(mag=new_det_ML, magnitude_type='ML',
comments=[Comment(text='rel_mo={}'.format(rel_mo))]))
det.preferred_magnitude_id = det.magnitudes[-2].resource_id.id
return
def _deserialize(self, zmap_str):
catalog = Catalog()
for row in zmap_str.split('\n'):
if len(row) == 0:
continue
origin = Origin()
event = Event(origins=[origin])
event.preferred_origin_id = origin.resource_id.id
# Begin value extraction
columns = row.split('\t', 13)[:13] # ignore extra columns
values = dict(zip(_STD_ZMAP_COLUMNS + _EXT_ZMAP_COLUMNS, columns))
# Extract origin
origin.longitude = self._str2num(values.get('lon'))
origin.latitude = self._str2num(values.get('lat'))
depth = self._str2num(values.get('depth'))
if depth is not None:
origin.depth = depth * 1000.0
z_err = self._str2num(values.get('z_err'))
if z_err is not None:
origin.depth_errors.uncertainty = z_err * 1000.0
h_err = self._str2num(values.get('h_err'))
if h_err is not None:
ou = OriginUncertainty()
ou.horizontal_uncertainty = h_err
ou.preferred_description = 'horizontal uncertainty'
origin.origin_uncertainty = ou
year = self._str2num(values.get('year'))
if year is not None:
t_fields = ['year', 'month', 'day', 'hour', 'minute', 'second']
comps = [self._str2num(values.get(f)) for f in t_fields]
if year % 1 != 0:
origin.time = self._decyear2utc(year)
elif any(v > 0 for v in comps[1:]):
# no seconds involved
if len(comps) < 6:
utc_args = [int(v) for v in comps if v is not None]
# we also have to handle seconds
else:
utc_args = [
int(v) if v is not None else 0 for v in comps[:-1]
]
# just leave float seconds as is
utc_args.append(comps[-1])
origin.time = UTCDateTime(*utc_args)
mag = self._str2num(values.get('mag'))
# Extract magnitude
if mag is not None:
magnitude = Magnitude(mag=mag)
m_err = self._str2num(values.get('m_err'))
magnitude.mag_errors.uncertainty = m_err
event.magnitudes.append(magnitude)
event.preferred_magnitude_id = magnitude.resource_id.id
event.scope_resource_ids()
catalog.append(event)
return catalog
def ORNL_events_to_cat(ornl_file):
"""Make Catalog from ORNL locations"""
cat = Catalog()
loc_df = pd.read_csv(ornl_file, infer_datetime_format=True)
loc_df = loc_df.set_index('event_datetime')
eid = 0
for dt, row in loc_df.iterrows():
ot = UTCDateTime(dt)
hmc_east = row['x(m)']
hmc_north = row['y(m)']
hmc_elev = row['z(m)']
errX = row['error_x (m)']
errY = row['error_y (m)']
errZ = row['error_z (m)']
rms = row['rms (millisecond)']
converter = SURF_converter()
lon, lat, elev = converter.to_lonlat((hmc_east, hmc_north,
hmc_elev))
o = Origin(time=ot, latitude=lat, longitude=lon, depth=130 - elev)
o.origin_uncertainty = OriginUncertainty()
o.quality = OriginQuality()
ou = o.origin_uncertainty
oq = o.quality
ou.max_horizontal_uncertainty = np.max([errX, errY])
ou.min_horizontal_uncertainty = np.min([errX, errY])
o.depth_errors.uncertainty = errZ
oq.standard_error = rms * 1e3
extra = AttribDict({
'hmc_east': {
'value': hmc_east,
'namespace': 'smi:local/hmc'
},
'hmc_north': {
'value': hmc_north,
'namespace': 'smi:local/hmc'
},
'hmc_elev': {
'value': hmc_elev,
'namespace': 'smi:local/hmc'
},
'hmc_eid': {
'value': eid,
'namespace': 'smi:local/hmc'
}
})
o.extra = extra
rid = ResourceIdentifier(id=ot.strftime('%Y%m%d%H%M%S%f'))
# Dummy magnitude of 1. for all events until further notice
mag = Magnitude(mag=1., mag_errors=QuantityError(uncertainty=1.))
ev = Event(origins=[o], magnitudes=[mag], resource_id=rid)
ev.preferred_origin_id = o.resource_id.id
cat.events.append(ev)
eid += 1
return cat
def setUpClass(cls) -> None:
cls.client = Client("GEONET")
cls.tribe = read_tribe(
os.path.join(
os.path.abspath(os.path.dirname(os.path.dirname(__file__))),
"test_data", "test_tribe.tgz"))
cls.trigger_event = Event(origins=[
Origin(time=UTCDateTime(2019, 1, 1),
latitude=-45.,
longitude=178.0,
depth=10000.)
],
magnitudes=[Magnitude(mag=7.4)])
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 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),
strict=False)
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)
if mg.lower() == 'nan':
magnitudes = []
preferred_magnitude_id = None
else:
magnitude = Magnitude(mag=mg, resource_id="smi:local/magnitude/" + id_)
magnitudes = [magnitude]
preferred_magnitude_id = magnitude.resource_id
event = Event(resource_id="smi:local/event/" + id_,
picks=picks,
origins=[origin],
magnitudes=magnitudes,
preferred_origin_id=origin.resource_id,
preferred_magnitude_id=preferred_magnitude_id)
return event
def _parse_magnitude(self, line):
# 1-5 a5 magnitude type (mb, Ms, ML, mbmle, msmle)
magnitude_type = line[0:5].strip()
# 6 a1 min max indicator (<, >, or blank)
# TODO figure out the meaning of this min max indicator
min_max_indicator = line[5:6].strip()
# 7-10 f4.1 magnitude value
mag = float_or_none(line[6:10])
# 12-14 f3.1 standard magnitude error
mag_errors = float_or_none(line[11:14])
# 16-19 i4 number of stations used to calculate magni-tude
station_count = int_or_none(line[15:19])
# 21-29 a9 author of the origin
author = line[20:29].strip()
# 31-38 a8 origin identification
origin_id = line[30:38].strip()
# process items
if author:
creation_info = CreationInfo(author=author)
else:
creation_info = None
mag_errors = mag_errors and QuantityError(uncertainty=mag_errors)
if origin_id:
origin_id = self._construct_id(['origin', origin_id])
else:
origin_id = None
if not magnitude_type:
magnitude_type = None
# magnitudes have no id field, so construct a unique one at least
resource_id = self._construct_id(['magnitude'], add_hash=True)
if min_max_indicator:
msg = 'Magnitude min/max indicator field not yet implemented'
warnings.warn(msg)
# combine and return
mag = Magnitude(magnitude_type=magnitude_type,
mag=mag,
station_count=station_count,
creation_info=creation_info,
mag_errors=mag_errors,
origin_id=origin_id,
resource_id=resource_id)
# event init always sets an empty QuantityError, even when specifying
# None, which is strange
for key in ['mag_errors']:
setattr(mag, key, None)
return mag
def create_simple_magnitudes(
self,
events: Union[Event, Catalog],
waveforms: Optional[Union[WaveformClient, Stream]] = None,
restrict_to_arrivals: bool = False,
author: Optional[str] = None,
agency_id: Optional[str] = None,
evaluation_mode: EvaluationModeType = "automatic",
evaluation_status: EvaluationStatusType = "preliminary",
) -> Dict[Tuple[str, str], Magnitude]:
"""
Create magnitude objects from calculated source params.
Returns a dict of {(event_id, magnitude_type): Magnitude}
Parameters
----------
{ew_params}
restrict_to_arrivals
If True, restrict calculations to only include phases associated
with the arrivals on the origin
author
Name of the person generating the magnitudes
agency_id
Name of the agency generating the magnitudes
evaluation_mode
Evaluation mode of the magnitudes
evaluation_status
Evaluation status of the magnitudes
"""
df = self.calc_source_parameters(
events, waveforms, restrict_to_arrivals=restrict_to_arrivals)
eids = set(df.index)
out = {}
for eid in eids:
for col_name, mag_type in self._mag_type_map.items():
log = "log" in mag_type
value = df.loc[eid, col_name]
if not pd.isnull(value):
mag = Magnitude(
magnitude_type=mag_type,
method_id=self._method_uri,
creation_info=self._create_info(author, agency_id),
mag=np.log10(value) if log else value,
evaluation_mode=evaluation_mode,
evaluation_status=evaluation_status,
)
out[(eid, mag_type)] = mag
return out
def read_header_line(string_line):
new_event = Event()
line = string_line
param_event = line.split()[1:]
### check if line as required number of arguments
if len(param_event) != 14:
return new_event
### Get parameters
year, month, day = [int(x) for x in param_event[0:3]]
hour, minu = [int(x) for x in param_event[3:5]]
sec = float(param_event[5])
if sec >= 60:
sec = 59.999
lat, lon, z = [float(x) for x in param_event[6:9]]
mag = float(param_event[9])
errh, errz, rms = [float(x) for x in param_event[10:13]]
_time = UTCDateTime(year, month, day, hour, minu, sec)
_origin_quality = OriginQuality(standard_error=rms)
# change what's next to handle origin with no errors estimates
origin = Origin(time=_time,
longitude=lon,
latitude=lat,
depth=z,
longitude_errors=QuantityError(uncertainty=errh),
latitude_errors=QuantityError(uncertainty=errh),
depth_errors=QuantityError(uncertainty=errz),
quality=_origin_quality)
magnitude = Magnitude(mag=mag, origin_id=origin.resource_id)
### Return
new_event.origins.append(origin)
new_event.magnitudes.append(magnitude)
new_event.preferred_origin_id = origin.resource_id
new_event.preferred_magnitude_id = magnitude.resource_id
return new_event
def _phase_to_event(event_text):
"""
Function to convert the text for one event in hypoDD phase format to \
event object.
:type event_text: dict
:param event_text: dict of two elements, header and picks, header is a \
str, picks is a list of str.
:returns: obspy.core.event.Event
"""
from obspy.core.event import Event, Origin, Magnitude
from obspy.core.event import Pick, WaveformStreamID, Arrival
from obspy import UTCDateTime
ph_event = Event()
# Extract info from header line
# YR, MO, DY, HR, MN, SC, LAT, LON, DEP, MAG, EH, EZ, RMS, ID
header = event_text['header'].split()
ph_event.origins.append(Origin())
ph_event.origins[0].time = UTCDateTime(
year=int(header[1]),
month=int(header[2]),
day=int(header[3]),
hour=int(header[4]),
minute=int(header[5]),
second=int(header[6].split('.')[0]),
microsecond=int(float(('0.' + header[6].split('.')[1])) * 1000000))
ph_event.origins[0].latitude = float(header[7])
ph_event.origins[0].longitude = float(header[8])
ph_event.origins[0].depth = float(header[9]) * 1000
ph_event.origins[0].time_errors['Time_Residual_RMS'] = float(header[13])
ph_event.magnitudes.append(Magnitude())
ph_event.magnitudes[0].mag = float(header[10])
ph_event.magnitudes[0].magnitude_type = 'M'
# Extract arrival info from picks!
for i, pick_line in enumerate(event_text['picks']):
pick = pick_line.split()
_waveform_id = WaveformStreamID(station_code=pick[0])
pick_time = ph_event.origins[0].time + float(pick[1])
ph_event.picks.append(
Pick(waveform_id=_waveform_id, phase_hint=pick[3], time=pick_time))
ph_event.origins[0].arrivals.append(
Arrival(phase=ph_event.picks[i],
pick_id=ph_event.picks[i].resource_id))
ph_event.origins[0].arrivals[i].time_weight = float(pick[2])
return ph_event
def test_reactor_spin_up(self):
reactor = Reactor(client=Client("GEONET"),
listener=self.listener,
trigger_func=self.trigger_func,
template_database=self.template_bank,
config=self.config)
trigger_event = Event(origins=[
Origin(time=UTCDateTime(2019, 1, 1),
latitude=-45.,
longitude=178.0,
depth=10000.)
],
magnitudes=[Magnitude(mag=7.4)])
reactor.spin_up(triggering_event=trigger_event)
time.sleep(10)
with self.assertRaises(SystemExit):
reactor.stop()
def _on_file_save(self):
"""
Creates a new obspy.core.event.Magnitude object and writes the moment
magnitude to it.
"""
# Get the save filename.
filename = QtGui.QFileDialog.getSaveFileName(caption="Save as...")
filename = os.path.abspath(str(filename))
mag = Magnitude()
mag.mag = self.final_result["moment_magnitude"]
mag.magnitude_type = "Mw"
mag.station_count = self.final_result["station_count"]
mag.evaluation_mode = "manual"
# Link to the used origin.
mag.origin_id = self.current_state["event"].origins[0].resource_id
mag.method_id = "Magnitude picker Krischer"
# XXX: Potentially change once this program gets more stable.
mag.evaluation_status = "preliminary"
# Write the other results as Comments.
mag.comments.append( \
Comment("Seismic moment in Nm: %g" % \
self.final_result["seismic_moment"]))
mag.comments.append( \
Comment("Circular source radius in m: %.2f" % \
self.final_result["source_radius"]))
mag.comments.append( \
Comment("Stress drop in Pa: %.2f" % \
self.final_result["stress_drop"]))
mag.comments.append( \
Comment("Very rough Q estimation: %.1f" % \
self.final_result["quality_factor"]))
event = copy.deepcopy(self.current_state["event"])
event.magnitudes.append(mag)
cat = Catalog()
cat.events.append(event)
cat.write(filename, format="quakeml")
def read_regex(event_file, regex=regex_GEOFON, creation_info='GEOFON'):
"""
Read events from event_file with the help of given regular expression.
"""
with open(event_file, 'r') as f:
filedata = f.read()
event_matches = re.finditer(regex, filedata, re.VERBOSE + re.MULTILINE)
list_ = [i.groupdict() for i in event_matches]
events = []
for event in list_:
# convert numbers to float and int types
for key, item in event.iteritems():
if util.isint(item):
event[key] = int(item)
elif util.isfloat(item):
event[key] = float(item)
else:
event[key] = item.strip()
if 'latitude_sign' in event and event['latitude_sign'] == 'S':
event['latitude'] = -event['latitude']
if 'longitude_sign' in event and event['longitude_sign'] == 'W':
event['longitude'] = -event['longitude']
if 'AM' in event:
ci = creation_info + (' automatic'
if event['AM'] == 'A' else ' manual')
else:
ci = creation_info
ev = Event(
event_type='earthquake',
creation_info=ci,
origins=[
Origin(time=UTC(event['time']),
latitude=event['latitude'],
longitude=event['longitude'],
depth=event['depth'])
],
magnitudes=[Magnitude(mag=event['magnitude'], magnitude_type='M')],
event_descriptions=[
EventDescription(event['flinn'], 'flinn-engdahl region')
] if 'flinn' in event else None)
events.append(ev)
events.sort(key=lambda x: x.origins[0].time)
return Catalog(events)
def ncedc_dd_to_cat(path):
"""
Read csv of ncedc dd locations to catalog
:param path:
:return:
"""
cat = Catalog()
with open(path, 'r') as f:
next(f)
for ln in f:
ot, lat, lon, dp, mag, mt, _, _, _, _, _, eid = ln.split(',')
ot = UTCDateTime('T'.join(ot.split()))
o = Origin(latitude=lat, longitude=lon,
depth=float(dp) * 1000, time=ot)
m = Magnitude(mag=mag, magnitude_type=mt)
ev = Event(origins=[o], magnitudes=[m],
resource_id=ResourceIdentifier(id=eid))
cat.events.append(ev)
return cat
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 _mags(obj, evid, stamag=False, wid=None):
mags = []
pm = None
for magtype1, magtype2 in MAG_MAP.items():
magkey = 'mean ' * (not stamag) + 'magnitude ' + magtype1
if magkey in obj:
magv = obj[magkey]
if 'inf' in magv:
warn('invalid value for magnitude: %s (event id %s)'
% (magv, evid))
else:
magv = float(magv)
mag = (StationMagnitude(station_magnitude_type=magtype2,
mag=magv, waveform_id=wid)
if stamag else
Magnitude(magnitude_type=magtype2, mag=magv))
mags.append(mag)
if len(mags) == 1:
pm = mags[0].resource_id
return mags, pm
def test_more_than_three_mags(self):
cat = Catalog()
cat += full_test_event()
cat[0].magnitudes.append(
Magnitude(mag=0.9,
magnitude_type='MS',
creation_info=CreationInfo('TES'),
origin_id=cat[0].origins[0].resource_id))
with NamedTemporaryFile(suffix='.out') as tf:
# raises UserWarning: mb is not convertible
with warnings.catch_warnings():
warnings.simplefilter('ignore', UserWarning)
cat.write(tf.name, format='nordic')
# raises "UserWarning: AIN in header, currently unsupported"
with warnings.catch_warnings():
warnings.simplefilter('ignore', UserWarning)
cat_back = read_events(tf.name)
for event_1, event_2 in zip(cat, cat_back):
self.assertTrue(
len(event_1.magnitudes) == len(event_2.magnitudes))
_assert_similarity(event_1, event_2)
def _map_netmag2magnitude(self, db):
"""
Return an obspy Magnitude from an dict of CSS key/values
corresponding to one record.
Inputs
======
db : dict of key/values of CSS fields from the 'netmag' table
Returns
=======
obspy.core.event.Magnitude
Notes
=====
Any object that supports the dict 'get' method can be passed as
input, e.g. OrderedDict, custom classes, etc.
"""
m = Magnitude()
m.mag = db.get('magnitude')
m.magnitude_type = db.get('magtype')
m.mag_errors.uncertainty = db.get('uncertainty')
m.station_count = db.get('nsta')
posted_author = _str(db.get('auth'))
mode, status = self.get_event_status(posted_author)
m.evaluation_mode = mode
m.evaluation_status = status
m.creation_info = CreationInfo(
creation_time = _utc(db.get('lddate')),
agency_id = self.agency,
version = db.get('magid'),
author = posted_author,
)
m.resource_id = self._rid(m)
return m
def _on_file_save(self):
"""
Creates a new obspy.core.event.Magnitude object and writes the moment
magnitude to it.
"""
# Get the save filename.
filename = QtGui.QFileDialog.getSaveFileName(caption="Save as...")
filename = os.path.abspath(str(filename))
mag = Magnitude()
mag.mag = self.final_result["moment_magnitude"]
mag.magnitude_type = "Mw"
mag.station_count = self.final_result["station_count"]
mag.evaluation_mode = "manual"
# Link to the used origin.
mag.origin_id = self.current_state["event"].origins[0].resource_id
mag.method_id = "Magnitude picker Krischer"
# XXX: Potentially change once this program gets more stable.
mag.evaluation_status = "preliminary"
# Write the other results as Comments.
mag.comments.append( \
Comment("Seismic moment in Nm: %g" % \
self.final_result["seismic_moment"]))
mag.comments.append( \
Comment("Circular source radius in m: %.2f" % \
self.final_result["source_radius"]))
mag.comments.append( \
Comment("Stress drop in Pa: %.2f" % \
self.final_result["stress_drop"]))
mag.comments.append( \
Comment("Very rough Q estimation: %.1f" % \
self.final_result["quality_factor"]))
event = copy.deepcopy(self.current_state["event"])
event.magnitudes.append(mag)
cat = Catalog()
cat.events.append(event)
cat.write(filename, format="quakeml")
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 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 _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:
try:
data = filename.decode()
except:
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(itertools.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 _parseRecordE(self, line, event):
"""
Parses the 'error and magnitude' record E
"""
orig_time_stderr = self._float(line[2:7])
latitude_stderr = self._float(line[8:14])
longitude_stderr = self._float(line[15:21])
depth_stderr = self._float(line[22:27])
mb_mag = self._float(line[28:31])
mb_nsta = self._int(line[32:35])
Ms_mag = self._float(line[36:39])
Ms_nsta = self._int(line[39:42])
mag1 = self._float(line[42:45])
mag1_type = line[45:47]
mag1_source_code = line[47:51].strip()
mag2 = self._float(line[51:54])
mag2_type = line[54:56]
mag2_source_code = line[56:60].strip()
evid = event.resource_id.id.split("/")[-1]
origin = event.origins[0]
self._storeUncertainty(origin.time_errors, orig_time_stderr)
self._storeUncertainty(origin.latitude_errors, self._latErrToDeg(latitude_stderr))
self._storeUncertainty(origin.longitude_errors, self._lonErrToDeg(longitude_stderr, origin.latitude))
self._storeUncertainty(origin.depth_errors, depth_stderr, scale=1000)
if mb_mag is not None:
mag = Magnitude()
res_id = "/".join((res_id_prefix, "magnitude", evid, "mb"))
mag.resource_id = ResourceIdentifier(id=res_id)
mag.creation_info = CreationInfo(agency_id="USGS-NEIC")
mag.mag = mb_mag
mag.magnitude_type = "Mb"
mag.station_count = mb_nsta
mag.origin_id = origin.resource_id
event.magnitudes.append(mag)
if Ms_mag is not None:
mag = Magnitude()
res_id = "/".join((res_id_prefix, "magnitude", evid, "ms"))
mag.resource_id = ResourceIdentifier(id=res_id)
mag.creation_info = CreationInfo(agency_id="USGS-NEIC")
mag.mag = Ms_mag
mag.magnitude_type = "Ms"
mag.station_count = Ms_nsta
mag.origin_id = origin.resource_id
event.magnitudes.append(mag)
if mag1 is not None:
mag = Magnitude()
mag1_id = mag1_type.lower()
res_id = "/".join((res_id_prefix, "magnitude", evid, mag1_id))
mag.resource_id = ResourceIdentifier(id=res_id)
mag.creation_info = CreationInfo(agency_id=mag1_source_code)
mag.mag = mag1
mag.magnitude_type = mag1_type
mag.origin_id = origin.resource_id
event.magnitudes.append(mag)
if mag2 is not None:
mag = Magnitude()
mag2_id = mag2_type.lower()
if mag2_id == mag1_id:
mag2_id += "2"
res_id = "/".join((res_id_prefix, "magnitude", evid, mag2_id))
mag.resource_id = ResourceIdentifier(id=res_id)
mag.creation_info = CreationInfo(agency_id=mag2_source_code)
mag.mag = mag2
mag.magnitude_type = mag2_type
mag.origin_id = origin.resource_id
event.magnitudes.append(mag)
def __read_single_fnetmt_entry(line, **kwargs):
"""
Reads a single F-net moment tensor solution to a
:class:`~obspy.core.event.Event` object.
:param line: String containing moment tensor information.
:type line: str.
"""
a = line.split()
try:
ot = UTCDateTime().strptime(a[0], '%Y/%m/%d,%H:%M:%S.%f')
except ValueError:
ot = UTCDateTime().strptime(a[0], '%Y/%m/%d,%H:%M:%S')
lat, lon, depjma, magjma = map(float, a[1:5])
depjma *= 1000
region = a[5]
strike = tuple(map(int, a[6].split(';')))
dip = tuple(map(int, a[7].split(';')))
rake = tuple(map(int, a[8].split(';')))
mo = float(a[9])
depmt = float(a[10]) * 1000
magmt = float(a[11])
var_red = float(a[12])
mxx, mxy, mxz, myy, myz, mzz, unit = map(float, a[13:20])
event_name = util.gen_sc3_id(ot)
e = Event(event_type="earthquake")
e.resource_id = _get_resource_id(event_name, 'event')
# Standard JMA solution
o_jma = Origin(time=ot, latitude=lat, longitude=lon,
depth=depjma, depth_type="from location",
region=region)
o_jma.resource_id = _get_resource_id(event_name,
'origin', 'JMA')
m_jma = Magnitude(mag=magjma, magnitude_type='ML',
origin_id=o_jma.resource_id)
m_jma.resource_id = _get_resource_id(event_name,
'magnitude', 'JMA')
# MT solution
o_mt = Origin(time=ot, latitude=lat, longitude=lon,
depth=depmt, region=region,
depth_type="from moment tensor inversion")
o_mt.resource_id = _get_resource_id(event_name,
'origin', 'MT')
m_mt = Magnitude(mag=magmt, magnitude_type='Mw',
origin_id=o_mt.resource_id)
m_mt.resource_id = _get_resource_id(event_name,
'magnitude', 'MT')
foc_mec = FocalMechanism(triggering_origin_id=o_jma.resource_id)
foc_mec.resource_id = _get_resource_id(event_name,
"focal_mechanism")
nod1 = NodalPlane(strike=strike[0], dip=dip[0], rake=rake[0])
nod2 = NodalPlane(strike=strike[1], dip=dip[1], rake=rake[1])
nod = NodalPlanes(nodal_plane_1=nod1, nodal_plane_2=nod2)
foc_mec.nodal_planes = nod
tensor = Tensor(m_rr=mxx, m_tt=myy, m_pp=mzz, m_rt=mxy, m_rp=mxz, m_tp=myz)
cm = Comment(text="Basis system: North,East,Down (Jost and \
Herrmann 1989")
cm.resource_id = _get_resource_id(event_name, 'comment', 'mt')
mt = MomentTensor(derived_origin_id=o_mt.resource_id,
moment_magnitude_id=m_mt.resource_id,
scalar_moment=mo, comments=[cm],
tensor=tensor, variance_reduction=var_red)
mt.resource_id = _get_resource_id(event_name,
'moment_tensor')
foc_mec.moment_tensor = mt
e.origins = [o_jma, o_mt]
e.magnitudes = [m_jma, m_mt]
e.focal_mechanisms = [foc_mec]
e.preferred_magnitude_id = m_mt.resource_id.id
e.preferred_origin_id = o_mt.resource_id.id
e.preferred_focal_mechanism_id = foc_mec.resource_id.id
return e
def _parse_record_e(self, line, event):
"""
Parses the 'error and magnitude' record E
"""
orig_time_stderr = self._float(line[2:7])
latitude_stderr = self._float(line[8:14])
longitude_stderr = self._float(line[15:21])
depth_stderr = self._float(line[22:27])
mb_mag = self._float(line[28:31])
mb_nsta = self._int(line[32:35])
ms_mag = self._float(line[36:39])
ms_nsta = self._int(line[39:42])
mag1 = self._float(line[42:45])
mag1_type = line[45:47]
mag1_source_code = line[47:51].strip()
mag2 = self._float(line[51:54])
mag2_type = line[54:56]
mag2_source_code = line[56:60].strip()
evid = event.resource_id.id.split('/')[-1]
origin = event.origins[0]
self._store_uncertainty(origin.time_errors, orig_time_stderr)
self._store_uncertainty(origin.latitude_errors,
self._lat_err_to_deg(latitude_stderr))
self._store_uncertainty(origin.longitude_errors,
self._lon_err_to_deg(longitude_stderr,
origin.latitude))
self._store_uncertainty(origin.depth_errors, depth_stderr, scale=1000)
if mb_mag is not None:
mag = Magnitude()
res_id = '/'.join((res_id_prefix, 'magnitude', evid, 'mb'))
mag.resource_id = ResourceIdentifier(id=res_id)
mag.creation_info = CreationInfo(agency_id='USGS-NEIC')
mag.mag = mb_mag
mag.magnitude_type = 'Mb'
mag.station_count = mb_nsta
mag.origin_id = origin.resource_id
event.magnitudes.append(mag)
if ms_mag is not None:
mag = Magnitude()
res_id = '/'.join((res_id_prefix, 'magnitude', evid, 'ms'))
mag.resource_id = ResourceIdentifier(id=res_id)
mag.creation_info = CreationInfo(agency_id='USGS-NEIC')
mag.mag = ms_mag
mag.magnitude_type = 'Ms'
mag.station_count = ms_nsta
mag.origin_id = origin.resource_id
event.magnitudes.append(mag)
if mag1 is not None:
mag = Magnitude()
mag1_id = mag1_type.lower()
res_id = '/'.join((res_id_prefix, 'magnitude', evid, mag1_id))
mag.resource_id = ResourceIdentifier(id=res_id)
mag.creation_info = CreationInfo(agency_id=mag1_source_code)
mag.mag = mag1
mag.magnitude_type = mag1_type
mag.origin_id = origin.resource_id
event.magnitudes.append(mag)
if mag2 is not None:
mag = Magnitude()
mag2_id = mag2_type.lower()
if mag2_id == mag1_id:
mag2_id += '2'
res_id = '/'.join((res_id_prefix, 'magnitude', evid, mag2_id))
mag.resource_id = ResourceIdentifier(id=res_id)
mag.creation_info = CreationInfo(agency_id=mag2_source_code)
mag.mag = mag2
mag.magnitude_type = mag2_type
mag.origin_id = origin.resource_id
event.magnitudes.append(mag)
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]),
waveform_id = WaveformStreamID(network_code="CI", station_code=str(sta[x]), channel_code=str(cha[x])), phase_hint=str(phase[x]))
origin = Origin(resource_id=(str(orid[x])),
time = UTCDateTime(e_time[x]),
longitude= str(lon[x]),
latitude=str(lat[x]),
depth=str(dep[x]))
magnitude = Magnitude(mag = ml[x], magnitude_type = "M", origin_id = (str(orid[x])))
arrival = Arrival(pick_id = rd, phase = str(phase[x]))
event.picks.append(picks)
event.origins.append(origin)
origin.arrivals.append(arrival)
event.magnitudes.append(magnitude)
db_catalog.append(event)
#Only include picks for stations used
all_picks=[]
for event in db_catalog:
stations = ['KCT', 'KMPB', 'KCR', 'KHMB', 'KCS', 'KCO', 'KMR', 'KPP']
event.picks = [pick for pick in event.picks if pick.waveform_id.station_code in stations]
all_picks+= [(pick.waveform_id.station_code, pick.waveform_id.channel_code) for pick in event.picks]
def calculate_moment_magnitudes(cat, output_file):
"""
:param cat: obspy.core.event.Catalog object.
"""
Mws = []
Mls = []
Mws_std = []
for event in cat:
if not event.origins:
print "No origin for event %s" % event.resource_id
continue
if not event.magnitudes:
print "No magnitude for event %s" % event.resource_id
continue
origin_time = event.origins[0].time
local_magnitude = event.magnitudes[0].mag
#if local_magnitude < 1.0:
#continue
moments = []
source_radii = []
corner_frequencies = []
for pick in event.picks:
# Only p phase picks.
if pick.phase_hint.lower() == "p":
radiation_pattern = 0.52
velocity = V_P
k = 0.32
elif pick.phase_hint.lower() == "s":
radiation_pattern = 0.63
velocity = V_S
k = 0.21
else:
continue
distance = (pick.time - origin_time) * velocity
if distance <= 0.0:
continue
stream = get_corresponding_stream(pick.waveform_id, pick.time,
PADDING)
if stream is None or len(stream) != 3:
continue
omegas = []
corner_freqs = []
for trace in stream:
# Get the index of the pick.
pick_index = int(round((pick.time - trace.stats.starttime) / \
trace.stats.delta))
# Choose date window 0.5 seconds before and 1 second after pick.
data_window = trace.data[pick_index - \
int(TIME_BEFORE_PICK * trace.stats.sampling_rate): \
pick_index + int(TIME_AFTER_PICK * trace.stats.sampling_rate)]
# Calculate the spectrum.
spec, freq = mtspec.mtspec(data_window, trace.stats.delta, 2)
try:
fit = fit_spectrum(spec, freq, pick.time - origin_time,
spec.max(), 10.0)
except:
continue
if fit is None:
continue
Omega_0, f_c, err, _ = fit
Omega_0 = np.sqrt(Omega_0)
omegas.append(Omega_0)
corner_freqs.append(f_c)
M_0 = 4.0 * np.pi * DENSITY * velocity ** 3 * distance * \
np.sqrt(omegas[0] ** 2 + omegas[1] ** 2 + omegas[2] ** 2) / \
radiation_pattern
r = 3 * k * V_S / sum(corner_freqs)
moments.append(M_0)
source_radii.append(r)
corner_frequencies.extend(corner_freqs)
if not len(moments):
print "No moments could be calculated for event %s" % \
event.resource_id.resource_id
continue
# Calculate the seismic moment via basic statistics.
moments = np.array(moments)
moment = moments.mean()
moment_std = moments.std()
corner_frequencies = np.array(corner_frequencies)
corner_frequency = corner_frequencies.mean()
corner_frequency_std = corner_frequencies.std()
# Calculate the source radius.
source_radii = np.array(source_radii)
source_radius = source_radii.mean()
source_radius_std = source_radii.std()
# Calculate the stress drop of the event based on the average moment and
# source radii.
stress_drop = (7 * moment) / (16 * source_radius ** 3)
stress_drop_std = np.sqrt((stress_drop ** 2) * \
(((moment_std ** 2) / (moment ** 2)) + \
(9 * source_radius * source_radius_std ** 2)))
if source_radius > 0 and source_radius_std < source_radius:
print "Source radius:", source_radius, " Std:", source_radius_std
print "Stress drop:", stress_drop / 1E5, " Std:", stress_drop_std / 1E5
Mw = 2.0 / 3.0 * (np.log10(moment) - 9.1)
Mw_std = 2.0 / 3.0 * moment_std / (moment * np.log(10))
Mws_std.append(Mw_std)
Mws.append(Mw)
Mls.append(local_magnitude)
calc_diff = abs(Mw - local_magnitude)
Mw = ("%.3f" % Mw).rjust(7)
Ml = ("%.3f" % local_magnitude).rjust(7)
diff = ("%.3e" % calc_diff).rjust(7)
ret_string = colorama.Fore.GREEN + \
"For event %s: Ml=%s | Mw=%s | " % (event.resource_id.resource_id,
Ml, Mw)
if calc_diff >= 1.0:
ret_string += colorama.Fore.RED
ret_string += "Diff=%s" % diff
ret_string += colorama.Fore.GREEN
ret_string += " | Determined at %i stations" % len(moments)
ret_string += colorama.Style.RESET_ALL
print ret_string
mag = Magnitude()
mag.mag = Mw
mag.mag_errors.uncertainty = Mw_std
mag.magnitude_type = "Mw"
mag.origin_id = event.origins[0].resource_id
mag.method_id = "smi:com.github/krischer/moment_magnitude_calculator/automatic/1"
mag.station_count = len(moments)
mag.evaluation_mode = "automatic"
mag.evaluation_status = "preliminary"
mag.comments.append(Comment( \
"Seismic Moment=%e Nm; standard deviation=%e" % (moment,
moment_std)))
mag.comments.append(Comment("Custom fit to Boatwright spectrum"))
if source_radius > 0 and source_radius_std < source_radius:
mag.comments.append(Comment( \
"Source radius=%.2fm; standard deviation=%.2f" % (source_radius,
source_radius_std)))
event.magnitudes.append(mag)
print "Writing output file..."
cat.write(output_file, format="quakeml")
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 request_gcmt(starttime, endtime, minmagnitude=None, mindepth=None, maxdepth=None, minlatitude=None, maxlatitude=None, minlongitude=None, maxlongitude=None):
import mechanize
from mechanize import Browser
import re
"""
Description
I am using mechanize. My attempt is just preliminary, for the current globalcmt.org site.
"""
#Split numbers and text
r = re.compile("([a-zA-Z]+)([0-9]+)")
br = Browser()
br.open('http://www.globalcmt.org/CMTsearch.html')
#Site has just one form
br.select_form(nr=0)
br.form['yr'] = str(starttime.year)
br.form['mo'] = str(starttime.month)
br.form['day'] = str(starttime.day)
br.form['oyr'] = str(endtime.year)
br.form['omo'] = str(endtime.month)
br.form['oday'] = str(endtime.day)
br.form['list'] = ['4']
br.form['itype'] = ['ymd']
br.form['otype'] = ['ymd']
if minmagnitude: br.form['lmw'] = str(minmagnitude)
if minlatitude : br.form['llat'] = str(minlatitude)
if maxlatitude : br.form['ulat'] = str(maxlatitude)
if minlongitude: br.form['llon'] = str(minlongitude)
if maxlongitude: br.form['ulon'] = str(maxlongitude)
if mindepth : br.form['lhd'] = str(mindepth)
if maxdepth : br.form['uhd'] = str(maxdepth)
print("Submitting parameters to globalcmt.")
req = br.submit()
print("Retrieving data, creating catalog.")
data = []
for line in req:
data.append(line)
data_chunked = _chunking_list(keyword='\n', list=data)
origins = []
magnitudes = []
tensor = []
for line in data_chunked:
for element in line:
if 'event name' in element:
for content in element:
org = line[1].split()
year = int(r.match(org[0]).groups()[1])
mon = int(org[1])
day = int(org[2])
hour = int(org[3])
minute = int(org[4])
sec_temp = int(org[5].split('.')[0])
msec_temp = int(org[5].split('.')[1])
origins_temp = UTCDateTime(year, mon, day, hour, minute, sec_temp, msec_temp)
#adding time shift located in line[3]
origin = origins_temp + float(line[3].split()[2])
magnitude = float(line[1].split()[10])
latitude = float(line[5].split()[1])
longitude = float(line[6].split()[1])
depth = 1000. * float(line[7].split()[1])
m_rr = float(line[8].split()[1])
m_tt = float(line[9].split()[1])
m_pp = float(line[10].split()[1])
m_rt = float(line[11].split()[1])
m_rp = float(line[12].split()[1])
m_tp = float(line[13].split()[1])
magnitudes.append( ("Mw", magnitude) )
origins.append( (latitude, longitude, depth, origin) )
tensor.append( (m_rr, m_tt, m_pp, m_rt, m_rp, m_tp) )
cat = Catalog()
for mag, org, ten in zip(magnitudes, origins, tensor):
# Create magnitude object.
magnitude = Magnitude()
magnitude.magnitude_type = mag[0]
magnitude.mag = mag[1]
# Write origin object.
origin = Origin()
origin.latitude = org[0]
origin.longitude = org[1]
origin.depth = org[2]
origin.time = org[3]
# Create event object and append to catalog object.
event = Event()
event.magnitudes.append(magnitude)
event.origins.append(origin)
event.MomentTensor = MomentTensor()
event.MomentTensor.m_rr = ten[0]
event.MomentTensor.m_tt = ten[1]
event.MomentTensor.m_pp = ten[2]
event.MomentTensor.m_rt = ten[3]
event.MomentTensor.m_rp = ten[4]
event.MomentTensor.m_tp = ten[5]
cat.append(event)
return cat
def _parse_record_ae(self, line, event):
"""
Parses the 'additional hypocenter error and magnitude record' AE
"""
orig_time_stderr = self._float_unused(line[2:7])
latitude_stderr = self._float_unused(line[8:14])
longitude_stderr = self._float_unused(line[15:21])
depth_stderr = self._float_unused(line[22:27])
gap = self._float_unused(line[28:33])
mag1 = self._float(line[33:36])
mag1_type = line[36:38]
mag2 = self._float(line[43:46])
mag2_type = line[46:48]
evid = event.resource_id.id.split('/')[-1]
# this record is to be associated to the latest origin
origin = event.origins[-1]
self._store_uncertainty(origin.time_errors, orig_time_stderr)
self._store_uncertainty(origin.latitude_errors,
self._lat_err_to_deg(latitude_stderr))
self._store_uncertainty(origin.longitude_errors,
self._lon_err_to_deg(longitude_stderr,
origin.latitude))
self._store_uncertainty(origin.depth_errors, depth_stderr, scale=1000)
origin.quality.azimuthal_gap = gap
if mag1 > 0:
mag = Magnitude()
mag1_id = mag1_type.lower()
res_id = '/'.join((res_id_prefix, 'magnitude', evid, mag1_id))
mag.resource_id = ResourceIdentifier(id=res_id)
mag.creation_info = CreationInfo(
agency_id=origin.creation_info.agency_id)
mag.mag = mag1
mag.magnitude_type = mag1_type
mag.origin_id = origin.resource_id
event.magnitudes.append(mag)
if mag2 > 0:
mag = Magnitude()
mag2_id = mag2_type.lower()
if mag2_id == mag1_id:
mag2_id += '2'
res_id = '/'.join((res_id_prefix, 'magnitude', evid, mag2_id))
mag.resource_id = ResourceIdentifier(id=res_id)
mag.creation_info = CreationInfo(
agency_id=origin.creation_info.agency_id)
mag.mag = mag2
mag.magnitude_type = mag2_type
mag.origin_id = origin.resource_id
event.magnitudes.append(mag)
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 _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 iris2quakeml(url, output_folder=None):
if not "/spudservice/" in url:
url = url.replace("/spud/", "/spudservice/")
if url.endswith("/"):
url += "quakeml"
else:
url += "/quakeml"
print "Downloading %s..." % url
r = requests.get(url)
if r.status_code != 200:
msg = "Error Downloading file!"
raise Exception(msg)
# For some reason the quakeml file is escaped HTML.
h = HTMLParser.HTMLParser()
data = h.unescape(r.content)
# Replace some XML tags.
data = data.replace("long-period body waves", "body waves")
data = data.replace("intermediate-period surface waves", "surface waves")
data = data.replace("long-period mantle waves", "mantle waves")
data = data.replace("<html><body><pre>", "")
data = data.replace("</pre></body></html>", "")
# Change the resource identifiers. Colons are not allowed in QuakeML.
pattern = r"(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})\.(\d{6})"
data = re.sub(pattern, r"\1-\2-\3T\4-\5-\6.\7", data)
data = StringIO(data)
try:
cat = readEvents(data)
except:
msg = "Could not read downloaded event data"
raise ValueError(msg)
# Parse the event, and use only one origin, magnitude and focal mechanism.
# Only the first event is used. Should not be a problem for the chosen
# global cmt application.
ev = cat[0]
if ev.preferred_origin():
ev.origins = [ev.preferred_origin()]
else:
ev.origins = [ev.origins[0]]
if ev.preferred_focal_mechanism():
ev.focal_mechanisms = [ev.preferred_focal_mechanism()]
else:
ev.focal_mechanisms = [ev.focal_mechanisms[0]]
try:
mt = ev.focal_mechanisms[0].moment_tensor
except:
msg = "No moment tensor found in file."
raise ValueError
seismic_moment_in_dyn_cm = mt.scalar_moment
if not seismic_moment_in_dyn_cm:
msg = "No scalar moment found in file."
raise ValueError(msg)
# Create a new magnitude object with the moment magnitude calculated from
# the given seismic moment.
mag = Magnitude()
mag.magnitude_type = "Mw"
mag.origin_id = ev.origins[0].resource_id
# This is the formula given on the GCMT homepage.
mag.mag = (2.0 / 3.0) * (math.log10(seismic_moment_in_dyn_cm) - 16.1)
mag.resource_id = ev.origins[0].resource_id.resource_id.replace("Origin",
"Magnitude")
ev.magnitudes = [mag]
ev.preferred_magnitude_id = mag.resource_id
# Convert the depth to meters.
org = ev.origins[0]
org.depth *= 1000.0
if org.depth_errors.uncertainty:
org.depth_errors.uncertainty *= 1000.0
# Ugly asserts -- this is just a simple script.
assert(len(ev.magnitudes) == 1)
assert(len(ev.origins) == 1)
assert(len(ev.focal_mechanisms) == 1)
# All values given in the QuakeML file are given in dyne * cm. Convert them
# to N * m.
for key, value in mt.tensor.iteritems():
if key.startswith("m_") and len(key) == 4:
mt.tensor[key] /= 1E7
if key.endswith("_errors") and hasattr(value, "uncertainty"):
mt.tensor[key].uncertainty /= 1E7
mt.scalar_moment /= 1E7
if mt.scalar_moment_errors.uncertainty:
mt.scalar_moment_errors.uncertainty /= 1E7
p_axes = ev.focal_mechanisms[0].principal_axes
for ax in [p_axes.t_axis, p_axes.p_axis, p_axes.n_axis]:
if ax is None or not ax.length:
continue
ax.length /= 1E7
# Check if it has a source time function
stf = mt.source_time_function
if stf:
if stf.type != "triangle":
msg = ("Source time function type '%s' not yet mapped. Please "
"contact the developers.") % stf.type
raise NotImplementedError(msg)
if not stf.duration:
if not stf.decay_time:
msg = "Not known how to derive duration without decay time."
raise NotImplementedError(msg)
# Approximate the duraction for triangular STF.
stf.duration = 2 * stf.decay_time
# Get the flinn_engdahl region for a nice name.
fe = FlinnEngdahl()
region_name = fe.get_region(ev.origins[0].longitude,
ev.origins[0].latitude)
region_name = region_name.replace(" ", "_")
event_name = "GCMT_event_%s_Mag_%.1f_%s-%s-%s-%s-%s.xml" % \
(region_name, ev.magnitudes[0].mag, ev.origins[0].time.year,
ev.origins[0].time.month, ev.origins[0].time.day,
ev.origins[0].time.hour, ev.origins[0].time.minute)
# Check if the ids of the magnitude and origin contain the corresponding
# tag. Otherwise replace tme.
ev.origins[0].resource_id = ev.origins[0].resource_id.resource_id.replace(
"quakeml/gcmtid", "quakeml/origin/gcmtid")
ev.magnitudes[0].resource_id = \
ev.magnitudes[0].resource_id.resource_id.replace(
"quakeml/gcmtid", "quakeml/magnitude/gcmtid")
# Fix up the moment tensor resource_ids.
mt.derived_origin_id = ev.origins[0].resource_id
mt.resource_id = mt.resource_id.resource_id.replace("focalmechanism",
"momenttensor")
cat = Catalog()
cat.resource_id = ev.origins[0].resource_id.resource_id.replace("origin",
"event_parameters")
cat.append(ev)
if output_folder:
event_name = os.path.join(output_folder, event_name)
cat.write(event_name, format="quakeml", validate=True)
print "Written file", event_name
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,
event=ev,
min_dist=min_dist,
max_dist=max_dist,
before=tbefore_sec,
after=tafter_sec,
def par2quakeml(Par_filename, QuakeML_filename, rotation_axis=[0.0, 1.0, 0.0],
rotation_angle=-57.5, origin_time="2000-01-01 00:00:00.0",
event_type="other event"):
# initialise event
ev = Event()
# open and read Par file
fid = open(Par_filename, 'r')
fid.readline()
fid.readline()
fid.readline()
fid.readline()
lat_old = 90.0 - float(fid.readline().strip().split()[0])
lon_old = float(fid.readline().strip().split()[0])
depth = float(fid.readline().strip().split()[0])
fid.readline()
Mtt_old = float(fid.readline().strip().split()[0])
Mpp_old = float(fid.readline().strip().split()[0])
Mrr_old = float(fid.readline().strip().split()[0])
Mtp_old = float(fid.readline().strip().split()[0])
Mtr_old = float(fid.readline().strip().split()[0])
Mpr_old = float(fid.readline().strip().split()[0])
# rotate event into physical domain
lat, lon = rot.rotate_lat_lon(lat_old, lon_old, rotation_axis,
rotation_angle)
Mrr, Mtt, Mpp, Mtr, Mpr, Mtp = rot.rotate_moment_tensor(
Mrr_old, Mtt_old, Mpp_old, Mtr_old, Mpr_old, Mtp_old, lat_old, lon_old,
rotation_axis, rotation_angle)
# populate event origin data
ev.event_type = event_type
ev_origin = Origin()
ev_origin.time = UTCDateTime(origin_time)
ev_origin.latitude = lat
ev_origin.longitude = lon
ev_origin.depth = depth
ev.origins.append(ev_origin)
# populte event moment tensor
ev_tensor = Tensor()
ev_tensor.m_rr = Mrr
ev_tensor.m_tt = Mtt
ev_tensor.m_pp = Mpp
ev_tensor.m_rt = Mtr
ev_tensor.m_rp = Mpr
ev_tensor.m_tp = Mtp
ev_momenttensor = MomentTensor()
ev_momenttensor.tensor = ev_tensor
ev_momenttensor.scalar_moment = np.sqrt(Mrr ** 2 + Mtt ** 2 + Mpp ** 2 +
Mtr ** 2 + Mpr ** 2 + Mtp ** 2)
ev_focalmechanism = FocalMechanism()
ev_focalmechanism.moment_tensor = ev_momenttensor
ev_focalmechanism.nodal_planes = NodalPlanes().setdefault(0, 0)
ev.focal_mechanisms.append(ev_focalmechanism)
# populate event magnitude
ev_magnitude = Magnitude()
ev_magnitude.mag = 0.667 * (np.log10(ev_momenttensor.scalar_moment) - 9.1)
ev_magnitude.magnitude_type = 'Mw'
ev.magnitudes.append(ev_magnitude)
# write QuakeML file
cat = Catalog()
cat.append(ev)
cat.write(QuakeML_filename, format="quakeml")
# clean up
fid.close()
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 build(self):
"""
Build an obspy moment tensor focal mech event
This makes the tensor output into an Event containing:
1) a FocalMechanism with a MomentTensor, NodalPlanes, and PrincipalAxes
2) a Magnitude of the Mw from the Tensor
Which is what we want for outputting QuakeML using
the (slightly modified) obspy code.
Input
-----
filehandle => open file OR str from filehandle.read()
Output
------
event => instance of Event() class as described above
"""
p = self.parser
event = Event(event_type='earthquake')
origin = Origin()
focal_mech = FocalMechanism()
nodal_planes = NodalPlanes()
moment_tensor = MomentTensor()
principal_ax = PrincipalAxes()
magnitude = Magnitude()
data_used = DataUsed()
creation_info = CreationInfo(agency_id='NN')
ev_mode = 'automatic'
ev_stat = 'preliminary'
evid = None
orid = None
# Parse the entire file line by line.
for n,l in enumerate(p.line):
if 'REVIEWED BY NSL STAFF' in l:
ev_mode = 'manual'
ev_stat = 'reviewed'
if 'Event ID' in l:
evid = p._id(n)
if 'Origin ID' in l:
orid = p._id(n)
if 'Ichinose' in l:
moment_tensor.category = 'regional'
if re.match(r'^\d{4}\/\d{2}\/\d{2}', l):
ev = p._event_info(n)
if 'Depth' in l:
derived_depth = p._depth(n)
if 'Mw' in l:
magnitude.mag = p._mw(n)
magnitude.magnitude_type = 'Mw'
if 'Mo' in l and 'dyne' in l:
moment_tensor.scalar_moment = p._mo(n)
if 'Percent Double Couple' in l:
moment_tensor.double_couple = p._percent(n)
if 'Percent CLVD' in l:
moment_tensor.clvd = p._percent(n)
if 'Epsilon' in l:
moment_tensor.variance = p._epsilon(n)
if 'Percent Variance Reduction' in l:
moment_tensor.variance_reduction = p._percent(n)
if 'Major Double Couple' in l and 'strike' in p.line[n+1]:
np = p._double_couple(n)
nodal_planes.nodal_plane_1 = NodalPlane(*np[0])
nodal_planes.nodal_plane_2 = NodalPlane(*np[1])
nodal_planes.preferred_plane = 1
if 'Spherical Coordinates' in l:
mt = p._mt_sphere(n)
moment_tensor.tensor = Tensor(
m_rr = mt['Mrr'],
m_tt = mt['Mtt'],
m_pp = mt['Mff'],
m_rt = mt['Mrt'],
m_rp = mt['Mrf'],
m_tp = mt['Mtf'],
)
if 'Eigenvalues and eigenvectors of the Major Double Couple' in l:
ax = p._vectors(n)
principal_ax.t_axis = Axis(ax['T']['trend'], ax['T']['plunge'], ax['T']['ev'])
principal_ax.p_axis = Axis(ax['P']['trend'], ax['P']['plunge'], ax['P']['ev'])
principal_ax.n_axis = Axis(ax['N']['trend'], ax['N']['plunge'], ax['N']['ev'])
if 'Number of Stations' in l:
data_used.station_count = p._number_of_stations(n)
if 'Maximum' in l and 'Gap' in l:
focal_mech.azimuthal_gap = p._gap(n)
if re.match(r'^Date', l):
creation_info.creation_time = p._creation_time(n)
# Creation Time
creation_info.version = orid
# Fill in magnitude values
magnitude.evaluation_mode = ev_mode
magnitude.evaluation_status = ev_stat
magnitude.creation_info = creation_info.copy()
magnitude.resource_id = self._rid(magnitude)
# Stub origin
origin.time = ev.get('time')
origin.latitude = ev.get('lat')
origin.longitude = ev.get('lon')
origin.depth = derived_depth * 1000.
origin.depth_type = "from moment tensor inversion"
origin.creation_info = creation_info.copy()
# Unique from true origin ID
_oid = self._rid(origin)
origin.resource_id = ResourceIdentifier(str(_oid) + '/mt')
del _oid
# Make an id for the MT that references this origin
ogid = str(origin.resource_id)
doid = ResourceIdentifier(ogid, referred_object=origin)
# Make an id for the moment tensor mag which references this mag
mrid = str(magnitude.resource_id)
mmid = ResourceIdentifier(mrid, referred_object=magnitude)
# MT todo: could check/use URL for RID if parsing the php file
moment_tensor.evaluation_mode = ev_mode
moment_tensor.evaluation_status = ev_stat
moment_tensor.data_used = data_used
moment_tensor.moment_magnitude_id = mmid
moment_tensor.derived_origin_id = doid
moment_tensor.creation_info = creation_info.copy()
moment_tensor.resource_id = self._rid(moment_tensor)
# Fill in focal_mech values
focal_mech.nodal_planes = nodal_planes
focal_mech.moment_tensor = moment_tensor
focal_mech.principal_axes = principal_ax
focal_mech.creation_info = creation_info.copy()
focal_mech.resource_id = self._rid(focal_mech)
# add mech and new magnitude to event
event.focal_mechanisms = [focal_mech]
event.magnitudes = [magnitude]
event.origins = [origin]
event.creation_info = creation_info.copy()
# If an MT was done, that's the preferred mag/mech
event.preferred_magnitude_id = str(magnitude.resource_id)
event.preferred_focal_mechanism_id = str(focal_mech.resource_id)
if evid:
event.creation_info.version = evid
event.resource_id = self._rid(event)
self.event = event
