def _parseRecordM(self, line, event, pick):
"""
Parses the 'surface wave record' M
"""
#unused: Z_comp = line[7]
Z_period = self._float(line[9:13])
# note: according to the format documentation,
# column 20 should be blank. However, it seems that
# Z_amplitude includes that column
Z_amplitude = self._float(line[13:21]) # micrometers
#TODO: N_comp and E_comp seems to be never there
MSZ_mag = line[49:52]
Ms_mag = self._float(line[53:56])
#unused: Ms_usage_flag = line[56]
evid = event.resource_id.id.split('/')[-1]
station_string =\
pick.waveform_id.getSEEDString()\
.replace(' ', '-').replace('.', '_').lower()
amplitude = None
if Z_amplitude is not None:
amplitude = Amplitude()
prefix = '/'.join((res_id_prefix, 'amp', evid, station_string))
amplitude.resource_id = ResourceIdentifier(prefix=prefix)
amplitude.generic_amplitude = Z_amplitude * 1E-6
amplitude.unit = 'm'
amplitude.period = Z_period
amplitude.type = 'AS'
amplitude.magnitude_hint = 'Ms'
amplitude.pick_id = pick.resource_id
event.amplitudes.append(amplitude)
if MSZ_mag is not None:
station_magnitude = StationMagnitude()
prefix = '/'.join(
(res_id_prefix, 'stationmagntiude', evid, station_string))
station_magnitude.resource_id = ResourceIdentifier(prefix=prefix)
station_magnitude.origin_id = event.origins[0].resource_id
station_magnitude.mag = Ms_mag
station_magnitude.station_magnitude_type = 'Ms'
if amplitude is not None:
station_magnitude.amplitude_id = amplitude.resource_id
event.station_magnitudes.append(station_magnitude)
def _parse_record_m(self, line, event, pick):
"""
Parses the 'surface wave record' M
"""
# unused: Z_comp = line[7]
z_period = self._float(line[9:13])
# note: according to the format documentation,
# column 20 should be blank. However, it seems that
# z_amplitude includes that column
z_amplitude = self._float(line[13:21]) # micrometers
# TODO: N_comp and E_comp seems to be never there
msz_mag = line[49:52]
ms_mag = self._float(line[53:56])
# unused: Ms_usage_flag = line[56]
evid = event.resource_id.id.split('/')[-1]
station_string = \
pick.waveform_id.get_seed_string()\
.replace(' ', '-').replace('.', '_').lower()
amplitude = None
if z_amplitude is not None:
amplitude = Amplitude()
prefix = '/'.join((res_id_prefix, 'amp', evid, station_string))
amplitude.resource_id = ResourceIdentifier(prefix=prefix)
amplitude.generic_amplitude = z_amplitude * 1E-6
amplitude.unit = 'm'
amplitude.period = z_period
amplitude.type = 'AS'
amplitude.magnitude_hint = 'Ms'
amplitude.pick_id = pick.resource_id
event.amplitudes.append(amplitude)
if msz_mag is not None:
station_magnitude = StationMagnitude()
prefix = '/'.join((res_id_prefix, 'stationmagntiude',
evid, station_string))
station_magnitude.resource_id = ResourceIdentifier(prefix=prefix)
station_magnitude.origin_id = event.origins[0].resource_id
station_magnitude.mag = ms_mag
station_magnitude.station_magnitude_type = 'Ms'
if amplitude is not None:
station_magnitude.amplitude_id = amplitude.resource_id
event.station_magnitudes.append(station_magnitude)
def _parseRecordM(self, line, event, pick):
"""
Parses the 'surface wave record' M
"""
# unused: Z_comp = line[7]
Z_period = self._float(line[9:13])
# note: according to the format documentation,
# column 20 should be blank. However, it seems that
# Z_amplitude includes that column
Z_amplitude = self._float(line[13:21]) # micrometers
# TODO: N_comp and E_comp seems to be never there
MSZ_mag = line[49:52]
Ms_mag = self._float(line[53:56])
# unused: Ms_usage_flag = line[56]
evid = event.resource_id.id.split("/")[-1]
station_string = pick.waveform_id.getSEEDString().replace(" ", "-").replace(".", "_").lower()
amplitude = None
if Z_amplitude is not None:
amplitude = Amplitude()
prefix = "/".join((res_id_prefix, "amp", evid, station_string))
amplitude.resource_id = ResourceIdentifier(prefix=prefix)
amplitude.generic_amplitude = Z_amplitude * 1e-6
amplitude.unit = "m"
amplitude.period = Z_period
amplitude.type = "AS"
amplitude.magnitude_hint = "Ms"
amplitude.pick_id = pick.resource_id
event.amplitudes.append(amplitude)
if MSZ_mag is not None:
station_magnitude = StationMagnitude()
prefix = "/".join((res_id_prefix, "stationmagntiude", evid, station_string))
station_magnitude.resource_id = ResourceIdentifier(prefix=prefix)
station_magnitude.origin_id = event.origins[0].resource_id
station_magnitude.mag = Ms_mag
station_magnitude.station_magnitude_type = "Ms"
if amplitude is not None:
station_magnitude.amplitude_id = amplitude.resource_id
event.station_magnitudes.append(station_magnitude)
def _parseRecordP(self, line, event):
"""
Parses the 'primary phase record' P
The primary phase is the first phase of the reading,
regardless its type.
"""
station = line[2:7].strip()
phase = line[7:15]
arrival_time = line[15:24]
residual = self._float(line[25:30])
#unused: residual_flag = line[30]
distance = self._float(line[32:38]) # degrees
azimuth = self._float(line[39:44])
backazimuth = round(azimuth % -360 + 180, 1)
mb_period = self._float(line[44:48])
mb_amplitude = self._float(line[48:55]) # nanometers
mb_magnitude = self._float(line[56:59])
#unused: mb_usage_flag = line[59]
origin = event.origins[0]
evid = event.resource_id.id.split('/')[-1]
waveform_id = WaveformStreamID()
waveform_id.station_code = station
#network_code is required for QuakeML validation
waveform_id.network_code = ' '
station_string =\
waveform_id.getSEEDString()\
.replace(' ', '-').replace('.', '_').lower()
prefix = '/'.join(
(res_id_prefix, 'waveformstream', evid, station_string))
waveform_id.resource_uri = ResourceIdentifier(prefix=prefix)
pick = Pick()
prefix = '/'.join((res_id_prefix, 'pick', evid, station_string))
pick.resource_id = ResourceIdentifier(prefix=prefix)
date = origin.time.strftime('%Y%m%d')
pick.time = UTCDateTime(date + arrival_time)
#Check if pick is on the next day:
if pick.time < origin.time:
pick.time += timedelta(days=1)
pick.waveform_id = waveform_id
pick.backazimuth = backazimuth
onset = phase[0]
if onset == 'e':
pick.onset = 'emergent'
phase = phase[1:]
elif onset == 'i':
pick.onset = 'impulsive'
phase = phase[1:]
elif onset == 'q':
pick.onset = 'questionable'
phase = phase[1:]
pick.phase_hint = phase.strip()
event.picks.append(pick)
if mb_amplitude is not None:
amplitude = Amplitude()
prefix = '/'.join((res_id_prefix, 'amp', evid, station_string))
amplitude.resource_id = ResourceIdentifier(prefix=prefix)
amplitude.generic_amplitude = mb_amplitude * 1E-9
amplitude.unit = 'm'
amplitude.period = mb_period
amplitude.type = 'AB'
amplitude.magnitude_hint = 'Mb'
amplitude.pick_id = pick.resource_id
amplitude.waveform_id = pick.waveform_id
event.amplitudes.append(amplitude)
station_magnitude = StationMagnitude()
prefix = '/'.join(
(res_id_prefix, 'stationmagntiude', evid, station_string))
station_magnitude.resource_id = ResourceIdentifier(prefix=prefix)
station_magnitude.origin_id = origin.resource_id
station_magnitude.mag = mb_magnitude
#station_magnitude.mag_errors['uncertainty'] = 0.0
station_magnitude.station_magnitude_type = 'Mb'
station_magnitude.amplitude_id = amplitude.resource_id
station_magnitude.waveform_id = pick.waveform_id
res_id = '/'.join(
(res_id_prefix, 'magnitude/generic/body_wave_magnitude'))
station_magnitude.method_id =\
ResourceIdentifier(id=res_id)
event.station_magnitudes.append(station_magnitude)
arrival = Arrival()
prefix = '/'.join((res_id_prefix, 'arrival', evid, station_string))
arrival.resource_id = ResourceIdentifier(prefix=prefix)
arrival.pick_id = pick.resource_id
arrival.phase = pick.phase_hint
arrival.azimuth = azimuth
arrival.distance = distance
arrival.time_residual = residual
res_id = '/'.join((res_id_prefix, 'earthmodel/ak135'))
arrival.earth_model_id = ResourceIdentifier(id=res_id)
origin.arrivals.append(arrival)
origin.quality.minimum_distance = min(
d for d in (arrival.distance, origin.quality.minimum_distance)
if d is not None)
origin.quality.maximum_distance =\
max(arrival.distance, origin.quality.minimum_distance)
origin.quality.associated_phase_count += 1
return pick, arrival
def _parse_arrivals(self, event, origin, origin_res_id):
# Skip header of arrivals
next(self.lines)
# Stop the loop after 2 empty lines (according to the standard).
previous_line_empty = False
for line in self.lines:
line_empty = not line or line.isspace()
if not self.event_point_separator:
# Event are separated by two empty lines
if line_empty and previous_line_empty:
break
else:
# Event are separated by '.'
if line.startswith('.'):
break
previous_line_empty = line_empty
if line_empty:
# Skip empty lines when the loop should be stopped by
# point
continue
magnitude_types = []
magnitude_values = []
fields = self.fields['arrival']
station = line[fields['sta']].strip()
distance = line[fields['dist']].strip()
event_azimuth = line[fields['ev_az']].strip()
evaluation_mode = line[fields['picktype']].strip()
direction = line[fields['direction']].strip()
onset = line[fields['detchar']].strip()
phase = line[fields['phase']].strip()
time = line[fields['time']].strip().replace('/', '-')
time_residual = line[fields['t_res']].strip()
arrival_azimuth = line[fields['azim']].strip()
azimuth_residual = line[fields['az_res']].strip()
slowness = line[fields['slow']].strip()
slowness_residual = line[fields['s_res']].strip()
time_defining_flag = line[fields['t_def']].strip()
azimuth_defining_flag = line[fields['a_def']].strip()
slowness_defining_flag = line[fields['s_def']].strip()
snr = line[fields['snr']].strip()
amplitude_value = line[fields['amp']].strip()
period = line[fields['per']].strip()
magnitude_types.append(line[fields['mag_type_1']].strip())
magnitude_values.append(line[fields['mag_1']].strip())
magnitude_types.append(line[fields['mag_type_2']].strip())
magnitude_values.append(line[fields['mag_2']].strip())
line_id = line[fields['id']].strip()
# Don't take pick and arrival with wrong time residual
if '*' in time_residual:
continue
try:
pick = Pick()
pick.creation_info = self._get_creation_info()
pick.waveform_id = WaveformStreamID()
pick.waveform_id.station_code = station
pick.time = UTCDateTime(time)
network_code = self.default_network_code
location_code = self.default_location_code
channel_code = self.default_channel_code
try:
network_code, channel = self._get_channel(
station, pick.time)
if channel:
channel_code = channel.code
location_code = channel.location_code
except TypeError:
pass
pick.waveform_id.network_code = network_code
pick.waveform_id.channel_code = channel_code
if location_code:
pick.waveform_id.location_code = location_code
try:
ev_mode = EVALUATION_MODES[evaluation_mode]
pick.evaluation_mode = ev_mode
except KeyError:
pass
try:
pick.polarity = PICK_POLARITIES[direction]
except KeyError:
pass
try:
pick.onset = PICK_ONSETS[onset]
except KeyError:
pass
pick.phase_hint = phase
try:
pick.backazimuth = float(arrival_azimuth)
except ValueError:
pass
try:
pick.horizontal_slowness = float(slowness)
except ValueError:
pass
public_id = "pick/%s" % line_id
pick.resource_id = self._get_res_id(public_id)
event.picks.append(pick)
except (TypeError, ValueError, AttributeError):
# Can't parse pick, skip arrival and amplitude parsing
continue
arrival = Arrival()
arrival.creation_info = self._get_creation_info()
try:
arrival.pick_id = pick.resource_id.id
except AttributeError:
pass
arrival.phase = phase
try:
arrival.azimuth = float(event_azimuth)
except ValueError:
pass
try:
arrival.distance = float(distance)
except ValueError:
pass
try:
arrival.time_residual = float(time_residual)
except ValueError:
pass
try:
arrival.backazimuth_residual = float(azimuth_residual)
except ValueError:
pass
try:
arrival.horizontal_slowness_residual = float(slowness_residual)
except ValueError:
pass
if time_defining_flag == 'T':
arrival.time_weight = 1
if azimuth_defining_flag == 'A':
arrival.backazimuth_weight = 1
if slowness_defining_flag == 'S':
arrival.horizontal_slowness_weight = 1
public_id = "arrival/%s" % line_id
arrival.resource_id = self._get_res_id(public_id,
parent_res_id=origin_res_id)
origin.arrivals.append(arrival)
try:
amplitude = Amplitude()
amplitude.creation_info = self._get_creation_info()
amplitude.generic_amplitude = float(amplitude_value)
try:
amplitude.pick_id = pick.resource_id
amplitude.waveform_id = pick.waveform_id
except AttributeError:
pass
try:
amplitude.period = float(period)
except ValueError:
pass
try:
amplitude.snr = float(snr)
except ValueError:
pass
for i in [0, 1]:
if magnitude_types[i] and not magnitude_types[i].isspace():
amplitude.magnitude_hint = magnitude_types[i]
public_id = "amplitude/%s" % line_id
amplitude.resource_id = self._get_res_id(public_id)
event.amplitudes.append(amplitude)
for i in [0, 1]:
sta_mag = StationMagnitude()
sta_mag.creation_info = self._get_creation_info()
sta_mag.origin_id = origin_res_id
sta_mag.amplitude_id = amplitude.resource_id
sta_mag.station_magnitude_type = magnitude_types[i]
sta_mag.mag = magnitude_values[i]
sta_mag.waveform_id = pick.waveform_id
public_id = "magnitude/station/%s/%s" % (line_id, i)
sta_mag.resource_id = self._get_res_id(public_id)
event.station_magnitudes.append(sta_mag)
# Associate station mag with network mag of same type
mag = self._find_magnitude_by_type(event, origin_res_id,
magnitude_types[i])
if mag:
contrib = StationMagnitudeContribution()
contrib.station_magnitude_id = sta_mag.resource_id
contrib.weight = 1.0
mag.station_magnitude_contributions.append(contrib)
except ValueError:
pass
def __toAmplitude(parser, el):
"""
"""
amp = Amplitude()
amp.resource_id = ResourceIdentifier(
prefix="/".join([RESOURCE_ROOT, "amplitude"]))
if CURRENT_TYPE == "obspyck":
amp.method_id = "%s/amplitude_method/obspyck/1" % RESOURCE_ROOT
else:
msg = "encountered non-obspyck amplitude!"
raise Exception(msg)
amp.generic_amplitude, amp.generic_amplitude_errors = \
__toFloatQuantity(parser, el, "genericAmplitude")
amp.unit = parser.xpath2obj('unit', el, str)
waveform = el.xpath("waveform")[0]
network = waveform.get("networkCode")
station = fix_station_name(waveform.get("stationCode"))
# Map some station names.
if station in STATION_DICT:
station = STATION_DICT[station]
if not network:
network = NETWORK_DICT[station]
location = waveform.get("locationCode") or ""
channel = waveform.get("channelCode") or ""
amp.waveform_id = WaveformStreamID(
network_code=network,
station_code=station,
channel_code=channel,
location_code=location)
# Amplitudes without generic_amplitude are not quakeml conform
if amp.generic_amplitude is None:
print ("Amplitude has no generic_amplitude value and is "
"ignored: %s" % station)
return None
# generate time_window
amp.time_window = TimeWindow()
t_min = parser.xpath2obj('timeWindow/reference', el, UTCDateTime)
t_max = t_min + parser.xpath2obj('timeWindow/end', el, float)
dt_abs = abs(t_max - t_min)
amp.time_window.reference = t_min
if t_min < t_max:
amp.time_window.begin = 0.0
amp.time_window.end = dt_abs
else:
amp.time_window.begin = dt_abs
amp.time_window.end = 0.0
# we have so far saved frequency in Hz as "period" tag
# use two times dt instead
##amp.period = 1.0 / parser.xpath2obj('period', el, float)
amp.period = 2.0 * dt_abs
t = ("PGV; reference time is time of minimum amplitude. if minimum comes "
"before maximum, start is 0 and end is relative time of maximum. "
"otherwise end is 0, start is relative time of minimum.")
comment = Comment(force_resource_id=False, resource_id=None, text=t)
amp.comments.append(comment)
return amp
def _parse_arrivals(self, event, origin, origin_res_id):
# Skip header of arrivals
next(self.lines)
# Stop the loop after 2 empty lines (according to the standard).
previous_line_empty = False
for line in self.lines:
line_empty = not line or line.isspace()
if not self.event_point_separator:
# Event are separated by two empty lines
if line_empty and previous_line_empty:
break
else:
# Event are separated by '.'
if line.startswith('.'):
break
previous_line_empty = line_empty
if line_empty:
# Skip empty lines when the loop should be stopped by
# point
continue
magnitude_types = []
magnitude_values = []
fields = self.fields['arrival']
station = line[fields['sta']].strip()
distance = line[fields['dist']].strip()
event_azimuth = line[fields['ev_az']].strip()
evaluation_mode = line[fields['picktype']].strip()
direction = line[fields['direction']].strip()
onset = line[fields['detchar']].strip()
phase = line[fields['phase']].strip()
time = line[fields['time']].strip().replace('/', '-')
time_residual = line[fields['t_res']].strip()
arrival_azimuth = line[fields['azim']].strip()
azimuth_residual = line[fields['az_res']].strip()
slowness = line[fields['slow']].strip()
slowness_residual = line[fields['s_res']].strip()
time_defining_flag = line[fields['t_def']].strip()
azimuth_defining_flag = line[fields['a_def']].strip()
slowness_defining_flag = line[fields['s_def']].strip()
snr = line[fields['snr']].strip()
amplitude_value = line[fields['amp']].strip()
period = line[fields['per']].strip()
magnitude_types.append(line[fields['mag_type_1']].strip())
magnitude_values.append(line[fields['mag_1']].strip())
magnitude_types.append(line[fields['mag_type_2']].strip())
magnitude_values.append(line[fields['mag_2']].strip())
line_id = line[fields['id']].strip()
# Don't take pick and arrival with wrong time residual
if '*' in time_residual:
continue
try:
pick = Pick()
pick.creation_info = self._get_creation_info()
pick.waveform_id = WaveformStreamID()
pick.waveform_id.station_code = station
pick.time = UTCDateTime(time)
network_code = self.default_network_code
location_code = self.default_location_code
channel_code = self.default_channel_code
try:
network_code, channel = self._get_channel(station,
pick.time)
if channel:
channel_code = channel.code
location_code = channel.location_code
except TypeError:
pass
pick.waveform_id.network_code = network_code
pick.waveform_id.channel_code = channel_code
if location_code:
pick.waveform_id.location_code = location_code
try:
ev_mode = EVALUATION_MODES[evaluation_mode]
pick.evaluation_mode = ev_mode
except KeyError:
pass
try:
pick.polarity = PICK_POLARITIES[direction]
except KeyError:
pass
try:
pick.onset = PICK_ONSETS[onset]
except KeyError:
pass
pick.phase_hint = phase
try:
pick.backazimuth = float(arrival_azimuth)
except ValueError:
pass
try:
pick.horizontal_slowness = float(slowness)
except ValueError:
pass
public_id = "pick/%s" % line_id
pick.resource_id = self._get_res_id(public_id)
event.picks.append(pick)
except (TypeError, ValueError, AttributeError):
# Can't parse pick, skip arrival and amplitude parsing
continue
arrival = Arrival()
arrival.creation_info = self._get_creation_info()
try:
arrival.pick_id = pick.resource_id.id
except AttributeError:
pass
arrival.phase = phase
try:
arrival.azimuth = float(event_azimuth)
except ValueError:
pass
try:
arrival.distance = float(distance)
except ValueError:
pass
try:
arrival.time_residual = float(time_residual)
except ValueError:
pass
try:
arrival.backazimuth_residual = float(azimuth_residual)
except ValueError:
pass
try:
arrival.horizontal_slowness_residual = float(slowness_residual)
except ValueError:
pass
if time_defining_flag == 'T':
arrival.time_weight = 1
if azimuth_defining_flag == 'A':
arrival.backazimuth_weight = 1
if slowness_defining_flag == 'S':
arrival.horizontal_slowness_weight = 1
public_id = "arrival/%s" % line_id
arrival.resource_id = self._get_res_id(public_id,
parent_res_id=origin_res_id)
origin.arrivals.append(arrival)
try:
amplitude = Amplitude()
amplitude.creation_info = self._get_creation_info()
amplitude.generic_amplitude = float(amplitude_value)
try:
amplitude.pick_id = pick.resource_id
amplitude.waveform_id = pick.waveform_id
except AttributeError:
pass
try:
amplitude.period = float(period)
except ValueError:
pass
try:
amplitude.snr = float(snr)
except ValueError:
pass
for i in [0, 1]:
if magnitude_types[i] and not magnitude_types[i].isspace():
amplitude.magnitude_hint = magnitude_types[i]
public_id = "amplitude/%s" % line_id
amplitude.resource_id = self._get_res_id(public_id)
event.amplitudes.append(amplitude)
for i in [0, 1]:
sta_mag = StationMagnitude()
sta_mag.creation_info = self._get_creation_info()
sta_mag.origin_id = origin_res_id
sta_mag.amplitude_id = amplitude.resource_id
sta_mag.station_magnitude_type = magnitude_types[i]
sta_mag.mag = magnitude_values[i]
public_id = "magnitude/station/%s/%s" % (line_id, i)
sta_mag.resource_id = self._get_res_id(public_id)
event.station_magnitudes.append(sta_mag)
except ValueError:
pass
def _parse_record_p(self, line, event):
"""
Parses the 'primary phase record' P
The primary phase is the first phase of the reading,
regardless its type.
"""
station = line[2:7].strip()
phase = line[7:15]
arrival_time = line[15:24]
residual = self._float(line[25:30])
# unused: residual_flag = line[30]
distance = self._float(line[32:38]) # degrees
azimuth = self._float(line[39:44])
backazimuth = round(azimuth % -360 + 180, 1)
mb_period = self._float(line[44:48])
mb_amplitude = self._float(line[48:55]) # nanometers
mb_magnitude = self._float(line[56:59])
# unused: mb_usage_flag = line[59]
origin = event.origins[0]
evid = event.resource_id.id.split('/')[-1]
waveform_id = WaveformStreamID()
waveform_id.station_code = station
# network_code is required for QuakeML validation
waveform_id.network_code = ' '
station_string = \
waveform_id.get_seed_string()\
.replace(' ', '-').replace('.', '_').lower()
prefix = '/'.join((res_id_prefix, 'waveformstream',
evid, station_string))
waveform_id.resource_uri = ResourceIdentifier(prefix=prefix)
pick = Pick()
prefix = '/'.join((res_id_prefix, 'pick', evid, station_string))
pick.resource_id = ResourceIdentifier(prefix=prefix)
date = origin.time.strftime('%Y%m%d')
pick.time = UTCDateTime(date + arrival_time)
# Check if pick is on the next day:
if pick.time < origin.time:
pick.time += timedelta(days=1)
pick.waveform_id = waveform_id
pick.backazimuth = backazimuth
onset = phase[0]
if onset == 'e':
pick.onset = 'emergent'
phase = phase[1:]
elif onset == 'i':
pick.onset = 'impulsive'
phase = phase[1:]
elif onset == 'q':
pick.onset = 'questionable'
phase = phase[1:]
pick.phase_hint = phase.strip()
event.picks.append(pick)
if mb_amplitude is not None:
amplitude = Amplitude()
prefix = '/'.join((res_id_prefix, 'amp', evid, station_string))
amplitude.resource_id = ResourceIdentifier(prefix=prefix)
amplitude.generic_amplitude = mb_amplitude * 1E-9
amplitude.unit = 'm'
amplitude.period = mb_period
amplitude.type = 'AB'
amplitude.magnitude_hint = 'Mb'
amplitude.pick_id = pick.resource_id
amplitude.waveform_id = pick.waveform_id
event.amplitudes.append(amplitude)
station_magnitude = StationMagnitude()
prefix = '/'.join((res_id_prefix, 'stationmagntiude',
evid, station_string))
station_magnitude.resource_id = ResourceIdentifier(prefix=prefix)
station_magnitude.origin_id = origin.resource_id
station_magnitude.mag = mb_magnitude
# station_magnitude.mag_errors['uncertainty'] = 0.0
station_magnitude.station_magnitude_type = 'Mb'
station_magnitude.amplitude_id = amplitude.resource_id
station_magnitude.waveform_id = pick.waveform_id
res_id = '/'.join(
(res_id_prefix, 'magnitude/generic/body_wave_magnitude'))
station_magnitude.method_id = \
ResourceIdentifier(id=res_id)
event.station_magnitudes.append(station_magnitude)
arrival = Arrival()
prefix = '/'.join((res_id_prefix, 'arrival', evid, station_string))
arrival.resource_id = ResourceIdentifier(prefix=prefix)
arrival.pick_id = pick.resource_id
arrival.phase = pick.phase_hint
arrival.azimuth = azimuth
arrival.distance = distance
arrival.time_residual = residual
res_id = '/'.join((res_id_prefix, 'earthmodel/ak135'))
arrival.earth_model_id = ResourceIdentifier(id=res_id)
origin.arrivals.append(arrival)
origin.quality.minimum_distance = min(
d for d in (arrival.distance, origin.quality.minimum_distance)
if d is not None)
origin.quality.maximum_distance = \
max(arrival.distance, origin.quality.minimum_distance)
origin.quality.associated_phase_count += 1
return pick, arrival
def __toAmplitude(parser, el):
"""
"""
amp = Amplitude()
amp.resource_id = ResourceIdentifier(
prefix="/".join([RESOURCE_ROOT, "amplitude"]))
if CURRENT_TYPE == "obspyck":
amp.method_id = "%s/amplitude_method/obspyck/1" % RESOURCE_ROOT
else:
msg = "encountered non-obspyck amplitude!"
raise Exception(msg)
amp.generic_amplitude, amp.generic_amplitude_errors = \
__toFloatQuantity(parser, el, "genericAmplitude")
amp.unit = parser.xpath2obj('unit', el, str)
waveform = el.xpath("waveform")[0]
network = waveform.get("networkCode")
station = fix_station_name(waveform.get("stationCode"))
# Map some station names.
if station in STATION_DICT:
station = STATION_DICT[station]
if not network:
network = NETWORK_DICT[station]
location = waveform.get("locationCode") or ""
channel = waveform.get("channelCode") or ""
amp.waveform_id = WaveformStreamID(network_code=network,
station_code=station,
channel_code=channel,
location_code=location)
# Amplitudes without generic_amplitude are not quakeml conform
if amp.generic_amplitude is None:
print(
"Amplitude has no generic_amplitude value and is "
"ignored: %s" % station)
return None
# generate time_window
amp.time_window = TimeWindow()
t_min = parser.xpath2obj('timeWindow/reference', el, UTCDateTime)
t_max = t_min + parser.xpath2obj('timeWindow/end', el, float)
dt_abs = abs(t_max - t_min)
amp.time_window.reference = t_min
if t_min < t_max:
amp.time_window.begin = 0.0
amp.time_window.end = dt_abs
else:
amp.time_window.begin = dt_abs
amp.time_window.end = 0.0
# we have so far saved frequency in Hz as "period" tag
# use two times dt instead
##amp.period = 1.0 / parser.xpath2obj('period', el, float)
amp.period = 2.0 * dt_abs
t = ("PGV; reference time is time of minimum amplitude. if minimum comes "
"before maximum, start is 0 and end is relative time of maximum. "
"otherwise end is 0, start is relative time of minimum.")
comment = Comment(force_resource_id=False, resource_id=None, text=t)
amp.comments.append(comment)
return amp
def _read_single_event(event_file, locate_dir, units, local_mag_ph):
"""
Parse an event file from QuakeMigrate into an obspy Event object.
Parameters
----------
event_file : `pathlib.Path` object
Path to .event file to read.
locate_dir : `pathlib.Path` object
Path to locate directory (contains "events", "picks" etc. directories).
units : {"km", "m"}
Grid projection coordinates for QM LUT (determines units of depths and
uncertainties in the .event files).
local_mag_ph : {"S", "P"}
Amplitude measurement used to calculate local magnitudes.
Returns
-------
event : `obspy.Event` object
Event object populated with all available information output by
:class:`~quakemigrate.signal.scan.locate()`, including event locations
and uncertainties, picks, and amplitudes and magnitudes if available.
"""
# Parse information from event file
event_info = pd.read_csv(event_file).iloc[0]
event_uid = str(event_info["EventID"])
# Set distance conversion factor (from units of QM LUT projection units).
if units == "km":
factor = 1e3
elif units == "m":
factor = 1
else:
raise AttributeError(f"units must be 'km' or 'm'; not {units}")
# Create event object to store origin and pick information
event = Event()
event.extra = AttribDict()
event.resource_id = str(event_info["EventID"])
event.creation_info = CreationInfo(author="QuakeMigrate",
version=quakemigrate.__version__)
# Add COA info to extra
event.extra.coa = {"value": event_info["COA"], "namespace": ns}
event.extra.coa_norm = {"value": event_info["COA_NORM"], "namespace": ns}
event.extra.trig_coa = {"value": event_info["TRIG_COA"], "namespace": ns}
event.extra.dec_coa = {"value": event_info["DEC_COA"], "namespace": ns}
event.extra.dec_coa_norm = {
"value": event_info["DEC_COA_NORM"],
"namespace": ns
}
# Determine location of cut waveform data - add to event object as a
# custom extra attribute.
mseed = locate_dir / "raw_cut_waveforms" / event_uid
event.extra.cut_waveforms_file = {
"value": str(mseed.with_suffix(".m").resolve()),
"namespace": ns
}
if (locate_dir / "real_cut_waveforms").exists():
mseed = locate_dir / "real_cut_waveforms" / event_uid
event.extra.real_cut_waveforms_file = {
"value": str(mseed.with_suffix(".m").resolve()),
"namespace": ns
}
if (locate_dir / "wa_cut_waveforms").exists():
mseed = locate_dir / "wa_cut_waveforms" / event_uid
event.extra.wa_cut_waveforms_file = {
"value": str(mseed.with_suffix(".m").resolve()),
"namespace": ns
}
# Create origin with spline location and set to preferred event origin.
origin = Origin()
origin.method_id = "spline"
origin.longitude = event_info["X"]
origin.latitude = event_info["Y"]
origin.depth = event_info["Z"] * factor
origin.time = UTCDateTime(event_info["DT"])
event.origins = [origin]
event.preferred_origin_id = origin.resource_id
# Create origin with gaussian location and associate with event
origin = Origin()
origin.method_id = "gaussian"
origin.longitude = event_info["GAU_X"]
origin.latitude = event_info["GAU_Y"]
origin.depth = event_info["GAU_Z"] * factor
origin.time = UTCDateTime(event_info["DT"])
event.origins.append(origin)
ouc = OriginUncertainty()
ce = ConfidenceEllipsoid()
ce.semi_major_axis_length = event_info["COV_ErrY"] * factor
ce.semi_intermediate_axis_length = event_info["COV_ErrX"] * factor
ce.semi_minor_axis_length = event_info["COV_ErrZ"] * factor
ce.major_axis_plunge = 0
ce.major_axis_azimuth = 0
ce.major_axis_rotation = 0
ouc.confidence_ellipsoid = ce
ouc.preferred_description = "confidence ellipsoid"
# Set uncertainties for both as the gaussian uncertainties
for origin in event.origins:
origin.longitude_errors.uncertainty = kilometer2degrees(
event_info["GAU_ErrX"] * factor / 1e3)
origin.latitude_errors.uncertainty = kilometer2degrees(
event_info["GAU_ErrY"] * factor / 1e3)
origin.depth_errors.uncertainty = event_info["GAU_ErrZ"] * factor
origin.origin_uncertainty = ouc
# Add OriginQuality info to each origin?
for origin in event.origins:
origin.origin_type = "hypocenter"
origin.evaluation_mode = "automatic"
# --- Handle picks file ---
pick_file = locate_dir / "picks" / event_uid
if pick_file.with_suffix(".picks").is_file():
picks = pd.read_csv(pick_file.with_suffix(".picks"))
else:
return None
for _, pickline in picks.iterrows():
station = str(pickline["Station"])
phase = str(pickline["Phase"])
wid = WaveformStreamID(network_code="", station_code=station)
for method in ["modelled", "autopick"]:
pick = Pick()
pick.extra = AttribDict()
pick.waveform_id = wid
pick.method_id = method
pick.phase_hint = phase
if method == "autopick" and str(pickline["PickTime"]) != "-1":
pick.time = UTCDateTime(pickline["PickTime"])
pick.time_errors.uncertainty = float(pickline["PickError"])
pick.extra.snr = {
"value": float(pickline["SNR"]),
"namespace": ns
}
elif method == "modelled":
pick.time = UTCDateTime(pickline["ModelledTime"])
else:
continue
event.picks.append(pick)
# --- Handle amplitudes file ---
amps_file = locate_dir / "amplitudes" / event_uid
if amps_file.with_suffix(".amps").is_file():
amps = pd.read_csv(amps_file.with_suffix(".amps"))
i = 0
for _, ampsline in amps.iterrows():
wid = WaveformStreamID(seed_string=ampsline["id"])
noise_amp = ampsline["Noise_amp"] / 1000 # mm to m
for phase in ["P_amp", "S_amp"]:
amp = Amplitude()
if pd.isna(ampsline[phase]):
continue
amp.generic_amplitude = ampsline[phase] / 1000 # mm to m
amp.generic_amplitude_errors.uncertainty = noise_amp
amp.unit = "m"
amp.type = "AML"
amp.method_id = phase
amp.period = 1 / ampsline[f"{phase[0]}_freq"]
amp.time_window = TimeWindow(
reference=UTCDateTime(ampsline[f"{phase[0]}_time"]))
# amp.pick_id = ?
amp.waveform_id = wid
# amp.filter_id = ?
amp.magnitude_hint = "ML"
amp.evaluation_mode = "automatic"
amp.extra = AttribDict()
try:
amp.extra.filter_gain = {
"value": ampsline[f"{phase[0]}_filter_gain"],
"namespace": ns
}
amp.extra.avg_amp = {
"value": ampsline[f"{phase[0]}_avg_amp"] / 1000, # m
"namespace": ns
}
except KeyError:
pass
if phase[0] == local_mag_ph and not pd.isna(ampsline["ML"]):
i += 1
stat_mag = StationMagnitude()
stat_mag.extra = AttribDict()
# stat_mag.origin_id = ? local_mag_loc
stat_mag.mag = ampsline["ML"]
stat_mag.mag_errors.uncertainty = ampsline["ML_Err"]
stat_mag.station_magnitude_type = "ML"
stat_mag.amplitude_id = amp.resource_id
stat_mag.extra.picked = {
"value": ampsline["is_picked"],
"namespace": ns
}
stat_mag.extra.epi_dist = {
"value": ampsline["epi_dist"],
"namespace": ns
}
stat_mag.extra.z_dist = {
"value": ampsline["z_dist"],
"namespace": ns
}
event.station_magnitudes.append(stat_mag)
event.amplitudes.append(amp)
mag = Magnitude()
mag.extra = AttribDict()
mag.mag = event_info["ML"]
mag.mag_errors.uncertainty = event_info["ML_Err"]
mag.magnitude_type = "ML"
# mag.origin_id = ?
mag.station_count = i
mag.evaluation_mode = "automatic"
mag.extra.r2 = {"value": event_info["ML_r2"], "namespace": ns}
event.magnitudes = [mag]
event.preferred_magnitude_id = mag.resource_id
return event
