def _parse_waveform_data(self, metadata, wfid):
"""
Parse the waveform data
"""
late_trigger = valid.vint(metadata["late_triggered_flag_01"],
"late_triggered_flag_01")
# U channel - usually east
xorientation = metadata["U_channel_code"].strip()
xazimuth = valid.vfloat(metadata["U_azimuth_deg"], "U_azimuth_deg")
xfilter = {"Low-Cut": valid.vfloat(metadata["U_hp"], "U_hp"),
"High-Cut": valid.vfloat(metadata["U_lp"], "U_lp")}
xcomp = Component(wfid, xazimuth, waveform_filter=xfilter,
units="cm/s/s")
xcomp.late_trigger = late_trigger
# V channel - usually North
vorientation = metadata["V_channel_code"].strip()
vazimuth = valid.vfloat(metadata["V_azimuth_deg"], "V_azimuth_deg")
vfilter = {"Low-Cut": valid.vfloat(metadata["V_hp"], "V_hp"),
"High-Cut": valid.vfloat(metadata["V_lp"], "V_lp")}
vcomp = Component(wfid, vazimuth, waveform_filter=vfilter,
units="cm/s/s")
vcomp.late_trigger = late_trigger
zorientation = metadata["W_channel_code"].strip()
if zorientation:
zfilter = {"Low-Cut": valid.vfloat(metadata["W_hp"], "W_hp"),
"High-Cut": valid.vfloat(metadata["W_lp"], "W_lp")}
zcomp = Component(wfid, None, waveform_filter=zfilter,
units="cm/s/s")
zcomp.late_trigger = late_trigger
else:
zcomp = None
return xcomp, vcomp, zcomp
def _parse_distances(self, metadata, hypo_depth):
"""
Parse the distances
"""
repi = valid.positive_float(metadata["epi_dist"], "epi_dist")
razim = valid.positive_float(metadata["epi_az"], "epi_az")
rjb = valid.positive_float(metadata["JB_dist"], "JB_dist")
rrup = valid.positive_float(metadata["rup_dist"], "rup_dist")
r_x = valid.vfloat(metadata["Rx_dist"], "Rx_dist")
ry0 = valid.positive_float(metadata["Ry0_dist"], "Ry0_dist")
rhypo = sqrt(repi**2. + hypo_depth**2.)
if not isinstance(rjb, float):
# In the first case Rjb == Repi
rjb = copy.copy(repi)
if not isinstance(rrup, float):
# In the first case Rrup == Rhypo
rrup = copy.copy(rhypo)
if not isinstance(r_x, float):
# In the first case Rx == -Repi (collapse to point and turn off
# any hanging wall effect)
r_x = copy.copy(-repi)
if not isinstance(ry0, float):
# In the first case Ry0 == Repi
ry0 = copy.copy(repi)
distances = RecordDistance(repi, rhypo, rjb, rrup, r_x, ry0)
distances.azimuth = razim
return distances
def _parse_distances(self, metadata, hypo_depth):
"""
Parse the distances
"""
repi = valid.positive_float(metadata["epi_dist"], "epi_dist")
razim = valid.positive_float(metadata["epi_az"], "epi_az")
rjb = valid.positive_float(metadata["JB_dist"], "JB_dist")
rrup = valid.positive_float(metadata["rup_dist"], "rup_dist")
r_x = valid.vfloat(metadata["Rx_dist"], "Rx_dist")
ry0 = valid.positive_float(metadata["Ry0_dist"], "Ry0_dist")
rhypo = sqrt(repi ** 2. + hypo_depth ** 2.)
if not isinstance(rjb, float):
# In the first case Rjb == Repi
rjb = copy.copy(repi)
if not isinstance(rrup, float):
# In the first case Rrup == Rhypo
rrup = copy.copy(rhypo)
if not isinstance(r_x, float):
# In the first case Rx == -Repi (collapse to point and turn off
# any hanging wall effect)
r_x = copy.copy(-repi)
if not isinstance(ry0, float):
# In the first case Ry0 == Repi
ry0 = copy.copy(repi)
distances = RecordDistance(repi, rhypo, rjb, rrup, r_x, ry0)
distances.azimuth = razim
return distances
def _parse_site_data(self, metadata):
"""
Parses the site information
"""
network_code = metadata["network_code"].strip()
station_code = metadata["station_code"].strip()
site_id = "{:s}-{:s}".format(network_code, station_code)
location_code = metadata["location_code"].strip()
site_lon = valid.longitude(metadata["st_longitude"])
site_lat = valid.latitude(metadata["st_latitude"])
elevation = valid.vfloat(metadata["st_elevation"], "st_elevation")
vs30 = valid.vfloat(metadata["vs30_m_sec"], "vs30_m_sec")
vs30_topo = valid.vfloat(metadata["vs30_m_sec_WA"], "vs30_m_sec_WA")
if vs30:
vs30_measured = True
elif vs30_topo:
vs30 = vs30_topo
vs30_measured = False
else:
vs30_measured = False
st_nation_code = metadata["st_nation_code"].strip()
if st_nation_code:
st_country = COUNTRY_CODES[st_nation_code]
else:
st_country = None
site = RecordSite(site_id,
station_code,
station_code,
site_lon,
site_lat,
elevation,
vs30,
vs30_measured,
network_code=network_code,
country=st_country)
site.slope = valid.vfloat(metadata["slope_deg"], "slope_deg")
site.sensor_depth = valid.vfloat(metadata["sensor_depth_m"],
"sensor_depth_m")
site.instrument_type = metadata["instrument_code"].strip()
if site.vs30:
site.z1pt0 = vs30_to_z1pt0_cy14(vs30)
site.z2pt5 = vs30_to_z2pt5_cb14(vs30)
housing_code = metadata["housing_code"].strip()
if housing_code and (housing_code in HOUSING):
site.building_structure = HOUSING[housing_code]
return site
def _parse_site_data(self, metadata):
"""
Parses the site information
"""
network_code = metadata["network_code"].strip()
station_code = metadata["station_code"].strip()
site_id = "{:s}-{:s}".format(network_code, station_code)
location_code = metadata["location_code"].strip()
site_lon = valid.longitude(metadata["st_longitude"])
site_lat = valid.latitude(metadata["st_latitude"])
elevation = valid.vfloat(metadata["st_elevation"], "st_elevation")
vs30 = valid.vfloat(metadata["vs30_m_sec"], "vs30_m_sec")
vs30_topo = valid.vfloat(metadata["vs30_m_sec_WA"], "vs30_m_sec_WA")
if vs30:
vs30_measured = True
elif vs30_topo:
vs30 = vs30_topo
vs30_measured = False
else:
vs30_measured = False
st_nation_code = metadata["st_nation_code"].strip()
if st_nation_code:
st_country = COUNTRY_CODES[st_nation_code]
else:
st_country = None
site = RecordSite(site_id, station_code, station_code, site_lon,
site_lat, elevation, vs30, vs30_measured,
network_code=network_code,
country=st_country)
site.slope = valid.vfloat(metadata["slope_deg"], "slope_deg")
site.sensor_depth = valid.vfloat(metadata["sensor_depth_m"],
"sensor_depth_m")
site.instrument_type = metadata["instrument_code"].strip()
if site.vs30:
site.z1pt0 = vs30_to_z1pt0_cy14(vs30)
site.z2pt5 = vs30_to_z2pt5_cb14(vs30)
housing_code = metadata["housing_code"].strip()
if housing_code and (housing_code in HOUSING):
site.building_structure = HOUSING[housing_code]
return site
def _parse_waveform_data(self, metadata, wfid):
"""
Parse the waveform data
"""
late_trigger = valid.vint(metadata["late_triggered_flag_01"],
"late_triggered_flag_01")
# U channel - usually east
xorientation = metadata["U_channel_code"].strip()
xazimuth = valid.vfloat(metadata["U_azimuth_deg"], "U_azimuth_deg")
xfilter = {
"Low-Cut": valid.vfloat(metadata["U_hp"], "U_hp"),
"High-Cut": valid.vfloat(metadata["U_lp"], "U_lp")
}
xcomp = Component(wfid,
xazimuth,
waveform_filter=xfilter,
units="cm/s/s")
xcomp.late_trigger = late_trigger
# V channel - usually North
vorientation = metadata["V_channel_code"].strip()
vazimuth = valid.vfloat(metadata["V_azimuth_deg"], "V_azimuth_deg")
vfilter = {
"Low-Cut": valid.vfloat(metadata["V_hp"], "V_hp"),
"High-Cut": valid.vfloat(metadata["V_lp"], "V_lp")
}
vcomp = Component(wfid,
vazimuth,
waveform_filter=vfilter,
units="cm/s/s")
vcomp.late_trigger = late_trigger
zorientation = metadata["W_channel_code"].strip()
if zorientation:
zfilter = {
"Low-Cut": valid.vfloat(metadata["W_hp"], "W_hp"),
"High-Cut": valid.vfloat(metadata["W_lp"], "W_lp")
}
zcomp = Component(wfid,
None,
waveform_filter=zfilter,
units="cm/s/s")
zcomp.late_trigger = late_trigger
else:
zcomp = None
return xcomp, vcomp, zcomp
def _parse_rupture_mechanism(self, metadata, eq_id, eq_name, mag, depth):
"""
If rupture data is available - parse it, otherwise return None
"""
sof = metadata["fm_type_code"]
if not metadata["event_source_id"].strip():
# No rupture model available. Mechanism is limited to a style
# of faulting only
rupture = Rupture(eq_id, eq_name, mag, 5., 5., depth)
mechanism = FocalMechanism(eq_id,
eq_name,
GCMTNodalPlanes(),
None,
mechanism_type=MECHANISM_TYPE[sof])
# See if focal mechanism exists
fm_set = []
for key in ["strike_1", "dip_1", "rake_1"]:
if key in metadata:
fm_param = valid.vfloat(metadata[key], key)
if fm_param is not None:
fm_set.append(fm_param)
if len(fm_set) == 3:
# Have one valid focal mechanism
mechanism.nodal_planes.nodal_plane_1 = {
"strike": fm_set[0],
"dip": fm_set[1],
"rake": fm_set[2]
}
fm_set = []
for key in ["strike_2", "dip_2", "rake_2"]:
if key in metadata:
fm_param = valid.vfloat(metadata[key], key)
if fm_param is not None:
fm_set.append(fm_param)
if len(fm_set) == 3:
# Have one valid focal mechanism
mechanism.nodal_planes.nodal_plane_2 = {
"strike": fm_set[0],
"dip": fm_set[1],
"rake": fm_set[2]
}
if not mechanism.nodal_planes.nodal_plane_1 and not\
mechanism.nodal_planes.nodal_plane_2:
# Absolutely no information - base on stye-of-faulting
mechanism.nodal_planes.nodal_plane_1 = {
"strike": 0.0, # Basically unused
"dip": DIP_TYPE[sof],
"rake": MECHANISM_TYPE[sof]
}
return rupture, mechanism
#print(metadata["es_strike"], metadata["es_dip"], metadata["es_rake"])
strike = valid.strike(metadata["es_strike"])
dip = valid.dip(metadata["es_dip"])
rake = valid.rake(metadata["es_rake"])
ztor = valid.positive_float(metadata["es_z_top"], "es_z_top")
length = valid.positive_float(metadata["es_length"], "es_length")
width = valid.positive_float(metadata["es_width"], "es_width")
rupture = Rupture(eq_id, eq_name, mag, length, width, ztor)
# Get mechanism type and focal mechanism
# No nodal planes, eigenvalues moment tensor initially
mechanism = FocalMechanism(
eq_id,
eq_name,
GCMTNodalPlanes(),
None,
mechanism_type=MECHANISM_TYPE[metadata["fm_type_code"]])
if strike is None:
strike = 0.0
if dip is None:
dip = DIP_TYPE[sof]
if rake is None:
rake = MECHANISM_TYPE[sof]
#if strike is not None and dip is not None and rake is not None:
mechanism.nodal_planes.nodal_plane_1 = {
"strike": strike,
"dip": dip,
"rake": rake
}
return rupture, mechanism
def _parse_rupture_mechanism(self, metadata, eq_id, eq_name, mag, depth):
"""
If rupture data is available - parse it, otherwise return None
"""
sof = metadata["fm_type_code"]
if not metadata["event_source_id"].strip():
# No rupture model available. Mechanism is limited to a style
# of faulting only
rupture = Rupture(eq_id, eq_name, mag, None, None, depth)
mechanism = FocalMechanism(
eq_id, eq_name, GCMTNodalPlanes(), None,
mechanism_type=sof)
# See if focal mechanism exists
fm_set = []
for key in ["strike_1", "dip_1", "rake_1"]:
if key in metadata:
fm_param = valid.vfloat(metadata[key], key)
if fm_param is not None:
fm_set.append(fm_param)
if len(fm_set) == 3:
# Have one valid focal mechanism
mechanism.nodal_planes.nodal_plane_1 = {"strike": fm_set[0],
"dip": fm_set[1],
"rake": fm_set[2]}
fm_set = []
for key in ["strike_2", "dip_2", "rake_2"]:
if key in metadata:
fm_param = valid.vfloat(metadata[key], key)
if fm_param is not None:
fm_set.append(fm_param)
if len(fm_set) == 3:
# Have one valid focal mechanism
mechanism.nodal_planes.nodal_plane_2 = {"strike": fm_set[0],
"dip": fm_set[1],
"rake": fm_set[2]}
if not mechanism.nodal_planes.nodal_plane_1 and not\
mechanism.nodal_planes.nodal_plane_2:
# Absolutely no information - base on stye-of-faulting
mechanism.nodal_planes.nodal_plane_1 = {
"strike": 0.0, # Basically unused
"dip": DIP_TYPE[sof],
"rake": MECHANISM_TYPE[sof]
}
return rupture, mechanism
strike = valid.strike(metadata["es_strike"])
dip = valid.dip(metadata["es_dip"])
rake = valid.rake(metadata["es_rake"])
ztor = valid.positive_float(metadata["es_z_top"], "es_z_top")
length = valid.positive_float(metadata["es_length"], "es_length")
width = valid.positive_float(metadata["es_width"], "es_width")
rupture = Rupture(eq_id, eq_name, mag, length, width, ztor)
# Get mechanism type and focal mechanism
# No nodal planes, eigenvalues moment tensor initially
mechanism = FocalMechanism(
eq_id, eq_name, GCMTNodalPlanes(), None,
mechanism_type=metadata["fm_type_code"])
if strike is None:
strike = 0.0
if dip is None:
dip = DIP_TYPE[sof]
if rake is None:
rake = MECHANISM_TYPE[sof]
# if strike is not None and dip is not None and rake is not None:
mechanism.nodal_planes.nodal_plane_1 = {"strike": strike,
"dip": dip,
"rake": rake}
return rupture, mechanism
