def _map_fplane2focalmech(self, db):
"""
Return an obspy FocalMechanism from an dict of CSS key/values
corresponding to one record. See the 'Join' section for the implied
database join expected.
Inputs
======
db : dict of key/values of CSS fields from the 'fplane' table
Returns
=======
obspy.core.event.FocalMechanism
Notes
=====
Any object that supports the dict 'get' method can be passed as
input, e.g. OrderedDict, custom classes, etc.
"""
#
# NOTE: Antelope schema for this is wrong, no nulls defined
#
fm = FocalMechanism()
nps = NodalPlanes()
nps.nodal_plane_1 = NodalPlane(db.get('str1'), db.get('dip1'), db.get('rake1'))
nps.nodal_plane_2 = NodalPlane(db.get('str2'), db.get('dip2'), db.get('rake2'))
nps.preferred_plane = 1
prin_ax = PrincipalAxes()
prin_ax.t_axis = Axis(db.get('taxazm'),db.get('taxplg'))
prin_ax.p_axis = Axis(db.get('paxazm'),db.get('paxplg'))
fm.nodal_planes = nps
fm.principal_axes = prin_ax
author_string = ':'.join([db['algorithm'], db['auth']])
fm.creation_info = CreationInfo(
version = db.get('mechid'),
creation_time = UTCDateTime(db['lddate']),
agency_id = self.agency,
author = author_string,
)
fm.resource_id = self._rid(fm)
return fm
def __toFocalMechanism(parser, focmec_el):
"""
"""
global CURRENT_TYPE
focmec = FocalMechanism()
focmec.resource_id = ResourceIdentifier(
prefix="/".join([RESOURCE_ROOT, "focal_mechanism"]))
if CURRENT_TYPE == "obspyck":
focmec.method_id = "%s/focal_mechanism_method/focmec/1" % RESOURCE_ROOT
else:
focmec.method_id = "%s/focal_mechanism_method/%s/1" % (
RESOURCE_ROOT, parser.xpath2obj('program', focmec_el))
if str(focmec.method_id).lower().endswith("none"):
focmec.method_id = None
focmec.station_polarity_count = parser.xpath2obj("stationPolarityCount",
focmec_el, int)
if focmec.station_polarity_count:
focmec.misfit = parser.xpath2obj("stationPolarityErrorCount",
focmec_el, int) / float(
focmec.station_polarity_count)
focmec.nodal_planes = NodalPlanes()
focmec.nodal_planes.nodal_plane_1 = NodalPlane()
nodal_plane = focmec_el.find("nodalPlanes")
if nodal_plane is None or not len(nodal_plane):
return None
n_p = focmec.nodal_planes.nodal_plane_1
# There is always only one nodal plane, called nodalPlane1
n_p.strike, strike_uncertainty = __toFloatQuantity(
parser, focmec_el, "nodalPlanes/nodalPlane1/strike")
n_p.dip, dip_uncertainty = __toFloatQuantity(
parser, focmec_el, "nodalPlanes/nodalPlane1/dip")
n_p.rake, rake_uncertainty = __toFloatQuantity(
parser, focmec_el, "nodalPlanes/nodalPlane1/rake")
if hasattr(strike_uncertainty, "uncertainty"):
n_p.strike_errors.uncertainty = strike_uncertainty["uncertainty"]
if hasattr(dip_uncertainty, "uncertainty"):
n_p.dip_errors.uncertainty = dip_uncertainty["uncertainty"]
if hasattr(rake_uncertainty, "uncertainty"):
n_p.rake_errors.uncertainty = rake_uncertainty["uncertainty"]
solution_count = parser.xpath2obj("possibleSolutionCount", focmec_el, int)
if solution_count:
focmec.comments.append(
Comment(force_resource_id=False,
resource_id=None,
text="Possible Solution Count: %i" % solution_count))
return focmec
def __toFocalMechanism(parser, focmec_el):
"""
"""
global CURRENT_TYPE
focmec = FocalMechanism()
focmec.resource_id = ResourceIdentifier(prefix="/".join([RESOURCE_ROOT, "focal_mechanism"]))
if CURRENT_TYPE == "obspyck":
focmec.method_id = "%s/focal_mechanism_method/focmec/1" % RESOURCE_ROOT
else:
focmec.method_id = "%s/focal_mechanism_method/%s/1" % (RESOURCE_ROOT,
parser.xpath2obj('program', focmec_el))
if str(focmec.method_id).lower().endswith("none"):
focmec.method_id = None
focmec.station_polarity_count = parser.xpath2obj("stationPolarityCount",
focmec_el, int)
if focmec.station_polarity_count:
focmec.misfit = parser.xpath2obj("stationPolarityErrorCount",
focmec_el, int) / float(focmec.station_polarity_count)
focmec.nodal_planes = NodalPlanes()
focmec.nodal_planes.nodal_plane_1 = NodalPlane()
nodal_plane = focmec_el.find("nodalPlanes")
if nodal_plane is None or not len(nodal_plane):
return None
n_p = focmec.nodal_planes.nodal_plane_1
# There is always only one nodal plane, called nodalPlane1
n_p.strike, strike_uncertainty = __toFloatQuantity(parser,
focmec_el, "nodalPlanes/nodalPlane1/strike")
n_p.dip, dip_uncertainty = __toFloatQuantity(parser, focmec_el,
"nodalPlanes/nodalPlane1/dip")
n_p.rake, rake_uncertainty = __toFloatQuantity(parser,
focmec_el, "nodalPlanes/nodalPlane1/rake")
if hasattr(strike_uncertainty, "uncertainty"):
n_p.strike_errors.uncertainty = strike_uncertainty["uncertainty"]
if hasattr(dip_uncertainty, "uncertainty"):
n_p.dip_errors.uncertainty = dip_uncertainty["uncertainty"]
if hasattr(rake_uncertainty, "uncertainty"):
n_p.rake_errors.uncertainty = rake_uncertainty["uncertainty"]
solution_count = parser.xpath2obj("possibleSolutionCount", focmec_el, int)
if solution_count:
focmec.comments.append(Comment(
force_resource_id=False, resource_id=None,
text="Possible Solution Count: %i" % solution_count))
return focmec
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 __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 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 outputOBSPY(hp, event=None, only_fm_picks=False):
"""
Make an Event which includes the current focal mechanism information from HASH
Use the 'only_fm_picks' flag to only include the picks HASH used for the FocalMechanism.
This flag will replace the 'picks' and 'arrivals' lists of existing events with new ones.
Inputs
-------
hp : hashpy.HashPype instance
event : obspy.core.event.Event
only_fm_picks : bool of whether to overwrite the picks/arrivals lists
Returns
-------
obspy.core.event.Event
Event will be new if no event was input, FocalMech added to existing event
"""
# Returns new (or updates existing) Event with HASH solution
n = hp.npol
if event is None:
event = Event(focal_mechanisms=[], picks=[], origins=[])
origin = Origin(arrivals=[])
origin.time = UTCDateTime(hp.tstamp)
origin.latitude = hp.qlat
origin.longitude = hp.qlon
origin.depth = hp.qdep
origin.creation_info = CreationInfo(version=hp.icusp)
origin.resource_id = ResourceIdentifier('smi:hash/Origin/{0}'.format(
hp.icusp))
for _i in range(n):
p = Pick()
p.creation_info = CreationInfo(version=hp.arid[_i])
p.resource_id = ResourceIdentifier('smi:nsl/Pick/{0}'.format(
p.creation_info.version))
p.waveform_id = WaveformStreamID(network_code=hp.snet[_i],
station_code=hp.sname[_i],
channel_code=hp.scomp[_i])
if hp.p_pol[_i] > 0:
p.polarity = 'positive'
else:
p.polarity = 'negative'
a = Arrival()
a.creation_info = CreationInfo(version=hp.arid[_i])
a.resource_id = ResourceIdentifier('smi:nsl/Arrival/{0}'.format(
p.creation_info.version))
a.azimuth = hp.p_azi_mc[_i, 0]
a.takeoff_angle = 180. - hp.p_the_mc[_i, 0]
a.pick_id = p.resource_id
origin.arrivals.append(a)
event.picks.append(p)
event.origins.append(origin)
event.preferred_origin_id = origin.resource_id.resource_id
else: # just update the changes
origin = event.preferred_origin()
picks = []
arrivals = []
for _i in range(n):
ind = hp.p_index[_i]
a = origin.arrivals[ind]
p = a.pick_id.getReferredObject()
a.takeoff_angle = hp.p_the_mc[_i, 0]
picks.append(p)
arrivals.append(a)
if only_fm_picks:
origin.arrivals = arrivals
event.picks = picks
# Use me double couple calculator and populate planes/axes etc
x = hp._best_quality_index
# Put all the mechanisms into the 'focal_mechanisms' list, mark "best" as preferred
for s in range(hp.nmult):
dc = DoubleCouple([hp.str_avg[s], hp.dip_avg[s], hp.rak_avg[s]])
ax = dc.axis
focal_mech = FocalMechanism()
focal_mech.creation_info = CreationInfo(creation_time=UTCDateTime(),
author=hp.author)
focal_mech.triggering_origin_id = origin.resource_id
focal_mech.resource_id = ResourceIdentifier(
'smi:hash/FocalMechanism/{0}/{1}'.format(hp.icusp, s + 1))
focal_mech.method_id = ResourceIdentifier('HASH')
focal_mech.nodal_planes = NodalPlanes()
focal_mech.nodal_planes.nodal_plane_1 = NodalPlane(*dc.plane1)
focal_mech.nodal_planes.nodal_plane_2 = NodalPlane(*dc.plane2)
focal_mech.principal_axes = PrincipalAxes()
focal_mech.principal_axes.t_axis = Axis(azimuth=ax['T']['azimuth'],
plunge=ax['T']['dip'])
focal_mech.principal_axes.p_axis = Axis(azimuth=ax['P']['azimuth'],
plunge=ax['P']['dip'])
focal_mech.station_polarity_count = n
focal_mech.azimuthal_gap = hp.magap
focal_mech.misfit = hp.mfrac[s]
focal_mech.station_distribution_ratio = hp.stdr[s]
focal_mech.comments.append(
Comment(
hp.qual[s],
resource_id=ResourceIdentifier(
focal_mech.resource_id.resource_id + '/comment/quality')))
#----------------------------------------
event.focal_mechanisms.append(focal_mech)
if s == x:
event.preferred_focal_mechanism_id = focal_mech.resource_id.resource_id
return event
def outputOBSPY(hp, event=None, only_fm_picks=False):
"""
Make an Event which includes the current focal mechanism information from HASH
Use the 'only_fm_picks' flag to only include the picks HASH used for the FocalMechanism.
This flag will replace the 'picks' and 'arrivals' lists of existing events with new ones.
Inputs
-------
hp : hashpy.HashPype instance
event : obspy.core.event.Event
only_fm_picks : bool of whether to overwrite the picks/arrivals lists
Returns
-------
obspy.core.event.Event
Event will be new if no event was input, FocalMech added to existing event
"""
# Returns new (or updates existing) Event with HASH solution
n = hp.npol
if event is None:
event = Event(focal_mechanisms=[], picks=[], origins=[])
origin = Origin(arrivals=[])
origin.time = UTCDateTime(hp.tstamp)
origin.latitude = hp.qlat
origin.longitude = hp.qlon
origin.depth = hp.qdep
origin.creation_info = CreationInfo(version=hp.icusp)
origin.resource_id = ResourceIdentifier('smi:hash/Origin/{0}'.format(hp.icusp))
for _i in range(n):
p = Pick()
p.creation_info = CreationInfo(version=hp.arid[_i])
p.resource_id = ResourceIdentifier('smi:hash/Pick/{0}'.format(p.creation_info.version))
p.waveform_id = WaveformStreamID(network_code=hp.snet[_i], station_code=hp.sname[_i], channel_code=hp.scomp[_i])
if hp.p_pol[_i] > 0:
p.polarity = 'positive'
else:
p.polarity = 'negative'
a = Arrival()
a.creation_info = CreationInfo(version=hp.arid[_i])
a.resource_id = ResourceIdentifier('smi:hash/Arrival/{0}'.format(p.creation_info.version))
a.azimuth = hp.p_azi_mc[_i,0]
a.takeoff_angle = 180. - hp.p_the_mc[_i,0]
a.pick_id = p.resource_id
origin.arrivals.append(a)
event.picks.append(p)
event.origins.append(origin)
event.preferred_origin_id = str(origin.resource_id)
else: # just update the changes
origin = event.preferred_origin()
picks = []
arrivals = []
for _i in range(n):
ind = hp.p_index[_i]
a = origin.arrivals[ind]
p = a.pick_id.getReferredObject()
a.takeoff_angle = hp.p_the_mc[_i,0]
picks.append(p)
arrivals.append(a)
if only_fm_picks:
origin.arrivals = arrivals
event.picks = picks
# Use me double couple calculator and populate planes/axes etc
x = hp._best_quality_index
# Put all the mechanisms into the 'focal_mechanisms' list, mark "best" as preferred
for s in range(hp.nmult):
dc = DoubleCouple([hp.str_avg[s], hp.dip_avg[s], hp.rak_avg[s]])
ax = dc.axis
focal_mech = FocalMechanism()
focal_mech.creation_info = CreationInfo(creation_time=UTCDateTime(), author=hp.author)
focal_mech.triggering_origin_id = origin.resource_id
focal_mech.resource_id = ResourceIdentifier('smi:hash/FocalMechanism/{0}/{1}'.format(hp.icusp, s+1))
focal_mech.method_id = ResourceIdentifier('HASH')
focal_mech.nodal_planes = NodalPlanes()
focal_mech.nodal_planes.nodal_plane_1 = NodalPlane(*dc.plane1)
focal_mech.nodal_planes.nodal_plane_2 = NodalPlane(*dc.plane2)
focal_mech.principal_axes = PrincipalAxes()
focal_mech.principal_axes.t_axis = Axis(azimuth=ax['T']['azimuth'], plunge=ax['T']['dip'])
focal_mech.principal_axes.p_axis = Axis(azimuth=ax['P']['azimuth'], plunge=ax['P']['dip'])
focal_mech.station_polarity_count = n
focal_mech.azimuthal_gap = hp.magap
focal_mech.misfit = hp.mfrac[s]
focal_mech.station_distribution_ratio = hp.stdr[s]
focal_mech.comments.append(
Comment(hp.qual[s], resource_id=ResourceIdentifier(str(focal_mech.resource_id) + '/comment/quality'))
)
#----------------------------------------
event.focal_mechanisms.append(focal_mech)
if s == x:
event.preferred_focal_mechanism_id = str(focal_mech.resource_id)
return event
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 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
