def __toPick(parser, pick_el, evaluation_mode):
"""
"""
pick = Pick()
waveform = pick_el.xpath("waveform")[0]
pick.waveform_id = WaveformStreamID(\
network_code=waveform.get("networkCode"),
station_code=waveform.get("stationCode"),
channel_code=waveform.get("channelCode"),
location_code=waveform.get("locationCode"))
pick.time, pick.time_errors = __toTimeQuantity(parser, pick_el, "time")
pick.phase_hint = parser.xpath2obj('phaseHint', pick_el)
onset = parser.xpath2obj('onset', pick_el)
if onset and onset.lower() in ["emergent", "impulsive", "questionable"]:
pick.onset = onset.lower()
# Evaluation mode of a pick is global in the SeisHub Event file format.
pick.evaluation_mode = evaluation_mode
# The polarity needs to be mapped.
polarity = parser.xpath2obj('polarity', pick_el)
pol_map_dict = {'up': 'positive', 'positive': 'positive',
'down': 'negative', 'negative': 'negative',
'undecidable': 'undecidable'}
if polarity and polarity.lower() in pol_map_dict:
pick.polarity = pol_map_dict[polarity.lower()]
# Convert azimuth to backazmith
azimuth = __toFloatQuantity(parser, pick_el, "azimuth")
if len(azimuth) == 2 and azimuth[0] and azimuth[1]:
# Convert to backazimuth
pick.backazimuth = (azimuth[0] + 180.0) % 360.0
pick.backzimuth_errors = azimuth[1]
return pick
def _read_picks(f, new_event):
"""
Internal pick reader. Use read_nordic instead.
:type f: file
:param f: File open in read mode
:type wav_names: list
:param wav_names: List of waveform files in the sfile
:type new_event: :class:`~obspy.core.event.event.Event`
:param new_event: event to associate picks with.
:returns: :class:`~obspy.core.event.event.Event`
"""
f.seek(0)
evtime = new_event.origins[0].time
pickline = []
# Set a default, ignored later unless overwritten
snr = None
for lineno, line in enumerate(f):
if line[79] == '7':
header = line
break
for lineno, line in enumerate(f):
if len(line.rstrip('\n').rstrip('\r')) in [80, 79] and \
line[79] in ' 4\n':
pickline += [line]
for line in pickline:
if line[18:28].strip() == '': # If line is empty miss it
continue
weight = line[14]
if weight == '_':
phase = line[10:17]
weight = 0
polarity = ''
else:
phase = line[10:14].strip()
polarity = line[16]
if weight == ' ':
weight = 0
polarity_maps = {"": "undecidable", "C": "positive", "D": "negative"}
try:
polarity = polarity_maps[polarity]
except KeyError:
polarity = "undecidable"
# It is valid nordic for the origin to be hour 23 and picks to be hour
# 00 or 24: this signifies a pick over a day boundary.
if int(line[18:20]) == 0 and evtime.hour == 23:
day_add = 86400
pick_hour = 0
elif int(line[18:20]) == 24:
day_add = 86400
pick_hour = 0
else:
day_add = 0
pick_hour = int(line[18:20])
try:
time = UTCDateTime(evtime.year, evtime.month, evtime.day,
pick_hour, int(line[20:22]),
float(line[23:28])) + day_add
except ValueError:
time = UTCDateTime(evtime.year, evtime.month, evtime.day,
int(line[18:20]), pick_hour,
float("0." + line[23:38].split('.')[1])) +\
60 + day_add
# Add 60 seconds on to the time, this copes with s-file
# preference to write seconds in 1-60 rather than 0-59 which
# datetime objects accept
if header[57:60] == 'AIN':
ain = _float_conv(line[57:60])
warnings.warn('AIN: %s in header, currently unsupported' % ain)
elif header[57:60] == 'SNR':
snr = _float_conv(line[57:60])
else:
warnings.warn('%s is not currently supported' % header[57:60])
# finalweight = _int_conv(line[68:70])
# Create a new obspy.event.Pick class for this pick
_waveform_id = WaveformStreamID(station_code=line[1:6].strip(),
channel_code=line[6:8].strip(),
network_code='NA')
pick = Pick(waveform_id=_waveform_id, phase_hint=phase,
polarity=polarity, time=time)
try:
pick.onset = onsets[line[9]]
except KeyError:
pass
if line[15] == 'A':
pick.evaluation_mode = 'automatic'
else:
pick.evaluation_mode = 'manual'
# Note these two are not always filled - velocity conversion not yet
# implemented, needs to be converted from km/s to s/deg
# if not velocity == 999.0:
# new_event.picks[pick_index].horizontal_slowness = 1.0 / velocity
if _float_conv(line[46:51]) is not None:
pick.backazimuth = _float_conv(line[46:51])
# Create new obspy.event.Amplitude class which references above Pick
# only if there is an amplitude picked.
if _float_conv(line[33:40]) is not None:
_amplitude = Amplitude(generic_amplitude=_float_conv(line[33:40]),
period=_float_conv(line[41:45]),
pick_id=pick.resource_id,
waveform_id=pick.waveform_id)
if pick.phase_hint == 'IAML':
# Amplitude for local magnitude
_amplitude.type = 'AML'
# Set to be evaluating a point in the trace
_amplitude.category = 'point'
# Default AML unit in seisan is nm (Page 139 of seisan
# documentation, version 10.0)
_amplitude.generic_amplitude /= 1e9
_amplitude.unit = 'm'
_amplitude.magnitude_hint = 'ML'
else:
# Generic amplitude type
_amplitude.type = 'A'
if snr:
_amplitude.snr = snr
new_event.amplitudes.append(_amplitude)
elif _int_conv(line[28:33]) is not None:
# Create an amplitude instance for code duration also
_amplitude = Amplitude(generic_amplitude=_int_conv(line[28:33]),
pick_id=pick.resource_id,
waveform_id=pick.waveform_id)
# Amplitude for coda magnitude
_amplitude.type = 'END'
# Set to be evaluating a point in the trace
_amplitude.category = 'duration'
_amplitude.unit = 's'
_amplitude.magnitude_hint = 'Mc'
if snr is not None:
_amplitude.snr = snr
new_event.amplitudes.append(_amplitude)
# Create new obspy.event.Arrival class referencing above Pick
if _float_conv(line[33:40]) is None:
arrival = Arrival(phase=pick.phase_hint, pick_id=pick.resource_id)
if weight is not None:
arrival.time_weight = weight
if _int_conv(line[60:63]) is not None:
arrival.backazimuth_residual = _int_conv(line[60:63])
if _float_conv(line[63:68]) is not None:
arrival.time_residual = _float_conv(line[63:68])
if _float_conv(line[70:75]) is not None:
arrival.distance = kilometers2degrees(_float_conv(line[70:75]))
if _int_conv(line[76:79]) is not None:
arrival.azimuth = _int_conv(line[76:79])
new_event.origins[0].arrivals.append(arrival)
new_event.picks.append(pick)
return new_event
def _parseRecordS(self, line, event, p_pick, p_arrival):
"""
Parses the 'secondary phases' record S
Secondary phases are following phases of the reading,
and can be P-type or S-type.
"""
arrivals = []
phase = line[7:15].strip()
arrival_time = line[15:24]
if phase:
arrivals.append((phase, arrival_time))
phase = line[25:33].strip()
arrival_time = line[33:42]
if phase:
arrivals.append((phase, arrival_time))
phase = line[43:51].strip()
arrival_time = line[51:60]
if phase:
arrivals.append((phase, arrival_time))
evid = event.resource_id.id.split('/')[-1]
station_string =\
p_pick.waveform_id.getSEEDString()\
.replace(' ', '-').replace('.', '_').lower()
origin = event.origins[0]
for phase, arrival_time in arrivals:
if phase[0:2] == 'D=':
#unused: depth = self._float(phase[2:7])
try:
depth_usage_flag = phase[7]
except IndexError:
#usage flag is not defined
depth_usage_flag = None
#FIXME: I'm not sure that 'X' actually
#means 'used'
if depth_usage_flag == 'X':
#FIXME: is this enough to say that
#the event is constained by depth pahses?
origin.depth_type = 'constrained by depth phases'
origin.quality.depth_phase_count += 1
else:
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 = p_pick.waveform_id
pick.backazimuth = p_pick.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)
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 = p_arrival.azimuth
arrival.distance = p_arrival.distance
origin.quality.associated_phase_count += 1
origin.arrivals.append(arrival)
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 _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_s(self, line, event, p_pick, p_arrival):
"""
Parses the 'secondary phases' record S
Secondary phases are following phases of the reading,
and can be P-type or S-type.
"""
arrivals = []
phase = line[7:15].strip()
arrival_time = line[15:24]
if phase:
arrivals.append((phase, arrival_time))
phase = line[25:33].strip()
arrival_time = line[33:42]
if phase:
arrivals.append((phase, arrival_time))
phase = line[43:51].strip()
arrival_time = line[51:60]
if phase:
arrivals.append((phase, arrival_time))
evid = event.resource_id.id.split('/')[-1]
station_string = \
p_pick.waveform_id.get_seed_string()\
.replace(' ', '-').replace('.', '_').lower()
origin = event.origins[0]
for phase, arrival_time in arrivals:
if phase[0:2] == 'D=':
# unused: depth = self._float(phase[2:7])
try:
depth_usage_flag = phase[7]
except IndexError:
# usage flag is not defined
depth_usage_flag = None
# FIXME: I'm not sure that 'X' actually
# means 'used'
if depth_usage_flag == 'X':
# FIXME: is this enough to say that
# the event is constrained by depth phases?
origin.depth_type = 'constrained by depth phases'
origin.quality.depth_phase_count += 1
else:
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 = p_pick.waveform_id
pick.backazimuth = p_pick.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)
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 = p_arrival.azimuth
arrival.distance = p_arrival.distance
origin.quality.associated_phase_count += 1
origin.arrivals.append(arrival)
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 _read_picks(f, new_event):
"""
Internal pick reader. Use read_nordic instead.
:type f: file
:param f: File open in read mode
:type wav_names: list
:param wav_names: List of waveform files in the sfile
:type new_event: :class:`~obspy.core.event.event.Event`
:param new_event: event to associate picks with.
:returns: :class:`~obspy.core.event.event.Event`
"""
f.seek(0)
evtime = new_event.origins[0].time
pickline = []
# Set a default, ignored later unless overwritten
snr = None
for line in f:
if line[79] == '7':
header = line
break
for line in f:
if len(line.rstrip('\n').rstrip('\r')) in [80, 79] and \
line[79] in ' 4\n':
pickline += [line]
for line in pickline:
if line[18:28].strip() == '': # If line is empty miss it
continue
weight = line[14]
if weight == '_':
phase = line[10:17]
weight = 0
polarity = ''
else:
phase = line[10:14].strip()
polarity = line[16]
if weight == ' ':
weight = 0
polarity_maps = {"": "undecidable", "C": "positive", "D": "negative"}
try:
polarity = polarity_maps[polarity]
except KeyError:
polarity = "undecidable"
# It is valid nordic for the origin to be hour 23 and picks to be hour
# 00 or 24: this signifies a pick over a day boundary.
if int(line[18:20]) == 0 and evtime.hour == 23:
day_add = 86400
pick_hour = 0
elif int(line[18:20]) == 24:
day_add = 86400
pick_hour = 0
else:
day_add = 0
pick_hour = int(line[18:20])
try:
time = UTCDateTime(evtime.year, evtime.month,
evtime.day, pick_hour, int(line[20:22]),
float(line[23:28])) + day_add
except ValueError:
time = UTCDateTime(evtime.year, evtime.month, evtime.day,
int(line[18:20]), pick_hour,
float("0." + line[23:38].split('.')[1])) +\
60 + day_add
# Add 60 seconds on to the time, this copes with s-file
# preference to write seconds in 1-60 rather than 0-59 which
# datetime objects accept
if header[57:60] == 'AIN':
ain = _float_conv(line[57:60])
warnings.warn('AIN: %s in header, currently unsupported' % ain)
elif header[57:60] == 'SNR':
snr = _float_conv(line[57:60])
else:
warnings.warn('%s is not currently supported' % header[57:60])
# finalweight = _int_conv(line[68:70])
# Create a new obspy.event.Pick class for this pick
_waveform_id = WaveformStreamID(station_code=line[1:6].strip(),
channel_code=line[6:8].strip(),
network_code='NA')
pick = Pick(waveform_id=_waveform_id,
phase_hint=phase,
polarity=polarity,
time=time)
try:
pick.onset = onsets[line[9]]
except KeyError:
pass
if line[15] == 'A':
pick.evaluation_mode = 'automatic'
else:
pick.evaluation_mode = 'manual'
# Note these two are not always filled - velocity conversion not yet
# implemented, needs to be converted from km/s to s/deg
# if not velocity == 999.0:
# new_event.picks[pick_index].horizontal_slowness = 1.0 / velocity
if _float_conv(line[46:51]) is not None:
pick.backazimuth = _float_conv(line[46:51])
# Create new obspy.event.Amplitude class which references above Pick
# only if there is an amplitude picked.
if _float_conv(line[33:40]) is not None:
_amplitude = Amplitude(generic_amplitude=_float_conv(line[33:40]),
period=_float_conv(line[41:45]),
pick_id=pick.resource_id,
waveform_id=pick.waveform_id)
if pick.phase_hint == 'IAML':
# Amplitude for local magnitude
_amplitude.type = 'AML'
# Set to be evaluating a point in the trace
_amplitude.category = 'point'
# Default AML unit in seisan is nm (Page 139 of seisan
# documentation, version 10.0)
_amplitude.generic_amplitude /= 1e9
_amplitude.unit = 'm'
_amplitude.magnitude_hint = 'ML'
else:
# Generic amplitude type
_amplitude.type = 'A'
if snr:
_amplitude.snr = snr
new_event.amplitudes.append(_amplitude)
elif _int_conv(line[28:33]) is not None:
# Create an amplitude instance for code duration also
_amplitude = Amplitude(generic_amplitude=_int_conv(line[28:33]),
pick_id=pick.resource_id,
waveform_id=pick.waveform_id)
# Amplitude for coda magnitude
_amplitude.type = 'END'
# Set to be evaluating a point in the trace
_amplitude.category = 'duration'
_amplitude.unit = 's'
_amplitude.magnitude_hint = 'Mc'
if snr is not None:
_amplitude.snr = snr
new_event.amplitudes.append(_amplitude)
# Create new obspy.event.Arrival class referencing above Pick
if _float_conv(line[33:40]) is None:
arrival = Arrival(phase=pick.phase_hint, pick_id=pick.resource_id)
if weight is not None:
arrival.time_weight = weight
if _int_conv(line[60:63]) is not None:
arrival.backazimuth_residual = _int_conv(line[60:63])
if _float_conv(line[63:68]) is not None:
arrival.time_residual = _float_conv(line[63:68])
if _float_conv(line[70:75]) is not None:
arrival.distance = kilometers2degrees(_float_conv(line[70:75]))
if _int_conv(line[76:79]) is not None:
arrival.azimuth = _int_conv(line[76:79])
new_event.origins[0].arrivals.append(arrival)
new_event.picks.append(pick)
return new_event
def _map_join2phase(self, db):
"""
Return an obspy Arrival and Pick from an dict of CSS key/values
corresponding to one record. See the 'Join' section for the implied
database table join expected.
Inputs
======
db : dict of key/values of CSS fields related to the phases (see Join)
Returns
=======
obspy.core.event.Pick, obspy.core.event.Arrival
Notes
=====
Any object that supports the dict 'get' method can be passed as
input, e.g. OrderedDict, custom classes, etc.
Join
----
assoc <- arrival <- affiliation (outer) <- schanloc [sta chan] (outer)
"""
p = Pick()
p.time = _utc(db.get('time'))
def_net = self.agency[:2].upper()
css_sta = db.get('sta')
css_chan = db.get('chan')
p.waveform_id = WaveformStreamID(
station_code = db.get('fsta') or css_sta,
channel_code = db.get('fchan') or css_chan,
network_code = db.get('snet') or def_net,
location_code = db.get('loc'),
)
p.horizontal_slowness = db.get('slow')
#p.horizontal_slowness_errors = self._create_dict(db, 'delslo')
p.backazimuth = db.get('azimuth')
#p.backazimuth_errors = self._create_dict(db, 'delaz')
on_qual = _str(db.get('qual')).lower()
if 'i' in on_qual:
p.onset = "impulsive"
elif 'e' in on_qual:
p.onset = "emergent"
elif 'w' in on_qual:
p.onset = "questionable"
else:
p.onset = None
p.phase_hint = db.get('iphase')
pol = _str(db.get('fm')).lower()
if 'c' in pol or 'u' in pol:
p.polarity = "positive"
elif 'd' in pol or 'r' in pol:
p.polarity = "negative"
elif '.' in pol:
p.polarity = "undecidable"
else:
p.polarity = None
p.evaluation_mode = "automatic"
if 'orbassoc' not in _str(db.get('auth')):
p.evaluation_mode = "manual"
p.evaluation_status = "preliminary"
if p.evaluation_mode is "manual":
p.evaluation_status = "reviewed"
p.creation_info = CreationInfo(
version = db.get('arid'),
creation_time = _utc(db.get('arrival.lddate')),
agency_id = self.agency,
author = db.get('auth'),
)
p.resource_id = self._rid(p)
a = Arrival()
a.pick_id = ResourceIdentifier(str(p.resource_id), referred_object=p)
a.phase = db.get('phase')
a.azimuth = db.get('esaz')
a.distance = db.get('delta')
a.takeoff_angle = db.get('ema')
#a.takeoff_angle_errors = self._create_dict(db, 'emares')
a.time_residual = db.get('timeres')
a.horizontal_slowness_residual = db.get('slores')
a.time_weight = db.get('wgt')
a.earth_model_id = ResourceIdentifier(self._prefix+'/VelocityModel/'+_str(db.get('vmodel')))
a.creation_info = CreationInfo(
version = db.get('arid'),
creation_time = _utc(db.get('lddate')),
agency_id = self.agency,
)
a.extra = {}
a.extra['timedef'] = {
'value': _str(db.get('timedef')),
'namespace': CSS_NAMESPACE
}
a.resource_id = self._rid(a)
return p, a
