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_single_hypocenter(lines, coordinate_converter, original_picks):
"""
Given a list of lines (starting with a 'NLLOC' line and ending with a
'END_NLLOC' line), parse them into an Event.
"""
try:
# some paranoid checks..
assert lines[0].startswith("NLLOC ")
assert lines[-1].startswith("END_NLLOC")
for line in lines[1:-1]:
assert not line.startswith("NLLOC ")
assert not line.startswith("END_NLLOC")
except Exception:
msg = ("This should not have happened, please report this as a bug at "
"https://github.com/obspy/obspy/issues.")
raise Exception(msg)
indices_phases = [None, None]
for i, line in enumerate(lines):
if line.startswith("PHASE "):
indices_phases[0] = i
elif line.startswith("END_PHASE"):
indices_phases[1] = i
# extract PHASES lines (if any)
if any(indices_phases):
if not all(indices_phases):
msg = ("NLLOC HYP file seems corrupt, 'PHASE' block is corrupt.")
raise RuntimeError(msg)
i1, i2 = indices_phases
lines, phases_lines = lines[:i1] + lines[i2 + 1:], lines[i1 + 1:i2]
else:
phases_lines = []
lines = dict([line.split(None, 1) for line in lines[:-1]])
line = lines["SIGNATURE"]
line = line.rstrip().split('"')[1]
signature, version, date, time = line.rsplit(" ", 3)
# new NLLoc > 6.0 seems to add prefix 'run:' before date
if date.startswith('run:'):
date = date[4:]
signature = signature.strip()
creation_time = UTCDateTime.strptime(date + time, str("%d%b%Y%Hh%Mm%S"))
if coordinate_converter:
# maximum likelihood origin location in km info line
line = lines["HYPOCENTER"]
x, y, z = coordinate_converter(*map(float, line.split()[1:7:2]))
else:
# maximum likelihood origin location lon lat info line
line = lines["GEOGRAPHIC"]
y, x, z = map(float, line.split()[8:13:2])
# maximum likelihood origin time info line
line = lines["GEOGRAPHIC"]
year, mon, day, hour, min = map(int, line.split()[1:6])
seconds = float(line.split()[6])
time = UTCDateTime(year, mon, day, hour, min, seconds, strict=False)
# distribution statistics line
line = lines["STATISTICS"]
covariance_xx = float(line.split()[7])
covariance_yy = float(line.split()[13])
covariance_zz = float(line.split()[17])
stats_info_string = str(
"Note: Depth/Latitude/Longitude errors are calculated from covariance "
"matrix as 1D marginal (Lon/Lat errors as great circle degrees) "
"while OriginUncertainty min/max horizontal errors are calculated "
"from 2D error ellipsoid and are therefore seemingly higher compared "
"to 1D errors. Error estimates can be reconstructed from the "
"following original NonLinLoc error statistics line:\nSTATISTICS " +
lines["STATISTICS"])
# goto location quality info line
line = lines["QML_OriginQuality"].split()
(assoc_phase_count, used_phase_count, assoc_station_count,
used_station_count, depth_phase_count) = map(int, line[1:11:2])
stderr, az_gap, sec_az_gap = map(float, line[11:17:2])
gt_level = line[17]
min_dist, max_dist, med_dist = map(float, line[19:25:2])
# goto location quality info line
line = lines["QML_OriginUncertainty"]
if "COMMENT" in lines:
comment = lines["COMMENT"].strip()
comment = comment.strip('\'"')
comment = comment.strip()
hor_unc, min_hor_unc, max_hor_unc, hor_unc_azim = \
map(float, line.split()[1:9:2])
# assign origin info
event = Event()
o = Origin()
event.origins = [o]
event.preferred_origin_id = o.resource_id
o.origin_uncertainty = OriginUncertainty()
o.quality = OriginQuality()
ou = o.origin_uncertainty
oq = o.quality
o.comments.append(Comment(text=stats_info_string, force_resource_id=False))
event.comments.append(Comment(text=comment, force_resource_id=False))
# SIGNATURE field's first item is LOCSIG, which is supposed to be
# 'Identification of an individual, institiution or other entity'
# according to
# http://alomax.free.fr/nlloc/soft6.00/control.html#_NLLoc_locsig_
# so use it as author in creation info
event.creation_info = CreationInfo(creation_time=creation_time,
version=version,
author=signature)
o.creation_info = CreationInfo(creation_time=creation_time,
version=version,
author=signature)
# negative values can appear on diagonal of covariance matrix due to a
# precision problem in NLLoc implementation when location coordinates are
# large compared to the covariances.
o.longitude = x
try:
o.longitude_errors.uncertainty = kilometer2degrees(sqrt(covariance_xx))
except ValueError:
if covariance_xx < 0:
msg = ("Negative value in XX value of covariance matrix, not "
"setting longitude error (epicentral uncertainties will "
"still be set in origin uncertainty).")
warnings.warn(msg)
else:
raise
o.latitude = y
try:
o.latitude_errors.uncertainty = kilometer2degrees(sqrt(covariance_yy))
except ValueError:
if covariance_yy < 0:
msg = ("Negative value in YY value of covariance matrix, not "
"setting longitude error (epicentral uncertainties will "
"still be set in origin uncertainty).")
warnings.warn(msg)
else:
raise
o.depth = z * 1e3 # meters!
o.depth_errors.uncertainty = sqrt(covariance_zz) * 1e3 # meters!
o.depth_errors.confidence_level = 68
o.depth_type = str("from location")
o.time = time
ou.horizontal_uncertainty = hor_unc
ou.min_horizontal_uncertainty = min_hor_unc
ou.max_horizontal_uncertainty = max_hor_unc
# values of -1 seem to be used for unset values, set to None
for field in ("horizontal_uncertainty", "min_horizontal_uncertainty",
"max_horizontal_uncertainty"):
if ou.get(field, -1) == -1:
ou[field] = None
else:
ou[field] *= 1e3 # meters!
ou.azimuth_max_horizontal_uncertainty = hor_unc_azim
ou.preferred_description = str("uncertainty ellipse")
ou.confidence_level = 68 # NonLinLoc in general uses 1-sigma (68%) level
oq.standard_error = stderr
oq.azimuthal_gap = az_gap
oq.secondary_azimuthal_gap = sec_az_gap
oq.used_phase_count = used_phase_count
oq.used_station_count = used_station_count
oq.associated_phase_count = assoc_phase_count
oq.associated_station_count = assoc_station_count
oq.depth_phase_count = depth_phase_count
oq.ground_truth_level = gt_level
oq.minimum_distance = kilometer2degrees(min_dist)
oq.maximum_distance = kilometer2degrees(max_dist)
oq.median_distance = kilometer2degrees(med_dist)
# go through all phase info lines
for line in phases_lines:
line = line.split()
arrival = Arrival()
o.arrivals.append(arrival)
station = str(line[0])
phase = str(line[4])
arrival.phase = phase
arrival.distance = kilometer2degrees(float(line[21]))
arrival.azimuth = float(line[23])
arrival.takeoff_angle = float(line[24])
arrival.time_residual = float(line[16])
arrival.time_weight = float(line[17])
pick = Pick()
# network codes are not used by NonLinLoc, so they can not be known
# when reading the .hyp file.. to conform with QuakeML standard set an
# empty network code
wid = WaveformStreamID(network_code="", station_code=station)
# have to split this into ints for overflow to work correctly
date, hourmin, sec = map(str, line[6:9])
ymd = [int(date[:4]), int(date[4:6]), int(date[6:8])]
hm = [int(hourmin[:2]), int(hourmin[2:4])]
t = UTCDateTime(*(ymd + hm), strict=False) + float(sec)
pick.waveform_id = wid
pick.time = t
pick.time_errors.uncertainty = float(line[10])
pick.phase_hint = phase
pick.onset = ONSETS.get(line[3].lower(), None)
pick.polarity = POLARITIES.get(line[5].lower(), None)
# try to determine original pick for each arrival
for pick_ in original_picks:
wid = pick_.waveform_id
if station == wid.station_code and phase == pick_.phase_hint:
pick = pick_
break
else:
# warn if original picks were specified and we could not associate
# the arrival correctly
if original_picks:
msg = ("Could not determine corresponding original pick for "
"arrival. "
"Falling back to pick information in NonLinLoc "
"hypocenter-phase file.")
warnings.warn(msg)
event.picks.append(pick)
arrival.pick_id = pick.resource_id
event.scope_resource_ids()
return event
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 read_nlloc_hyp(filename, coordinate_converter=None, picks=None, **kwargs):
"""
Reads a NonLinLoc Hypocenter-Phase file to a
:class:`~obspy.core.event.Catalog` object.
.. note::
Coordinate conversion from coordinate frame of NonLinLoc model files /
location run to WGS84 has to be specified explicitly by the user if
necessary.
.. note::
An example can be found on the :mod:`~obspy.nlloc` submodule front
page in the documentation pages.
:param filename: File or file-like object in text mode.
:type coordinate_converter: func
:param coordinate_converter: Function to convert (x, y, z)
coordinates of NonLinLoc output to geographical coordinates and depth
in meters (longitude, latitude, depth in kilometers).
If left `None` NonLinLoc (x, y, z) output is left unchanged (e.g. if
it is in geographical coordinates already like for NonLinLoc in
global mode).
The function should accept three arguments x, y, z and return a
tuple of three values (lon, lat, depth in kilometers).
:type picks: list of :class:`~obspy.core.event.Pick`
:param picks: Original picks used to generate the NonLinLoc location.
If provided, the output event will include the original picks and the
arrivals in the output origin will link to them correctly (with their
`pick_id` attribute). If not provided, the output event will include
(the rather basic) pick information that can be reconstructed from the
NonLinLoc hypocenter-phase file.
:rtype: :class:`~obspy.core.event.Catalog`
"""
if not hasattr(filename, "read"):
# Check if it exists, otherwise assume its a string.
try:
with open(filename, "rt") as fh:
data = fh.read()
except:
try:
data = filename.decode()
except:
data = str(filename)
data = data.strip()
else:
data = filename.read()
if hasattr(data, "decode"):
data = data.decode()
lines = data.splitlines()
# remember picks originally used in location, if provided
original_picks = picks
if original_picks is None:
original_picks = []
# determine indices of block start/end of the NLLOC output file
indices_hyp = [None, None]
indices_phases = [None, None]
for i, line in enumerate(lines):
if line.startswith("NLLOC "):
indices_hyp[0] = i
elif line.startswith("END_NLLOC"):
indices_hyp[1] = i
elif line.startswith("PHASE "):
indices_phases[0] = i
elif line.startswith("END_PHASE"):
indices_phases[1] = i
if any([i is None for i in indices_hyp]):
msg = ("NLLOC HYP file seems corrupt,"
" could not detect 'NLLOC' and 'END_NLLOC' lines.")
raise RuntimeError(msg)
# strip any other lines around NLLOC block
lines = lines[indices_hyp[0]:indices_hyp[1]]
# extract PHASES lines (if any)
if any(indices_phases):
if not all(indices_phases):
msg = ("NLLOC HYP file seems corrupt, 'PHASE' block is corrupt.")
raise RuntimeError(msg)
i1, i2 = indices_phases
lines, phases_lines = lines[:i1] + lines[i2 + 1:], lines[i1 + 1:i2]
else:
phases_lines = []
lines = dict([line.split(None, 1) for line in lines])
line = lines["SIGNATURE"]
line = line.rstrip().split('"')[1]
signature, version, date, time = line.rsplit(" ", 3)
creation_time = UTCDateTime().strptime(date + time, str("%d%b%Y%Hh%Mm%S"))
# maximum likelihood origin location info line
line = lines["HYPOCENTER"]
x, y, z = map(float, line.split()[1:7:2])
if coordinate_converter:
x, y, z = coordinate_converter(x, y, z)
# origin time info line
line = lines["GEOGRAPHIC"]
year, month, day, hour, minute = map(int, line.split()[1:6])
seconds = float(line.split()[6])
time = UTCDateTime(year, month, day, hour, minute, seconds)
# distribution statistics line
line = lines["STATISTICS"]
covariance_XX = float(line.split()[7])
covariance_YY = float(line.split()[13])
covariance_ZZ = float(line.split()[17])
stats_info_string = str(
"Note: Depth/Latitude/Longitude errors are calculated from covariance "
"matrix as 1D marginal (Lon/Lat errors as great circle degrees) "
"while OriginUncertainty min/max horizontal errors are calculated "
"from 2D error ellipsoid and are therefore seemingly higher compared "
"to 1D errors. Error estimates can be reconstructed from the "
"following original NonLinLoc error statistics line:\nSTATISTICS " +
lines["STATISTICS"])
# goto location quality info line
line = lines["QML_OriginQuality"].split()
(assoc_phase_count, used_phase_count, assoc_station_count,
used_station_count, depth_phase_count) = map(int, line[1:11:2])
stderr, az_gap, sec_az_gap = map(float, line[11:17:2])
gt_level = line[17]
min_dist, max_dist, med_dist = map(float, line[19:25:2])
# goto location quality info line
line = lines["QML_OriginUncertainty"]
hor_unc, min_hor_unc, max_hor_unc, hor_unc_azim = \
map(float, line.split()[1:9:2])
# assign origin info
event = Event()
cat = Catalog(events=[event])
o = Origin()
event.origins = [o]
o.origin_uncertainty = OriginUncertainty()
o.quality = OriginQuality()
ou = o.origin_uncertainty
oq = o.quality
o.comments.append(Comment(text=stats_info_string))
cat.creation_info.creation_time = UTCDateTime()
cat.creation_info.version = "ObsPy %s" % __version__
event.creation_info = CreationInfo(creation_time=creation_time,
version=version)
event.creation_info.version = version
o.creation_info = CreationInfo(creation_time=creation_time,
version=version)
# negative values can appear on diagonal of covariance matrix due to a
# precision problem in NLLoc implementation when location coordinates are
# large compared to the covariances.
o.longitude = x
try:
o.longitude_errors.uncertainty = kilometer2degrees(sqrt(covariance_XX))
except ValueError:
if covariance_XX < 0:
msg = ("Negative value in XX value of covariance matrix, not "
"setting longitude error (epicentral uncertainties will "
"still be set in origin uncertainty).")
warnings.warn(msg)
else:
raise
o.latitude = y
try:
o.latitude_errors.uncertainty = kilometer2degrees(sqrt(covariance_YY))
except ValueError:
if covariance_YY < 0:
msg = ("Negative value in YY value of covariance matrix, not "
"setting longitude error (epicentral uncertainties will "
"still be set in origin uncertainty).")
warnings.warn(msg)
else:
raise
o.depth = z * 1e3 # meters!
o.depth_errors.uncertainty = sqrt(covariance_ZZ) * 1e3 # meters!
o.depth_errors.confidence_level = 68
o.depth_type = str("from location")
o.time = time
ou.horizontal_uncertainty = hor_unc
ou.min_horizontal_uncertainty = min_hor_unc
ou.max_horizontal_uncertainty = max_hor_unc
# values of -1 seem to be used for unset values, set to None
for field in ("horizontal_uncertainty", "min_horizontal_uncertainty",
"max_horizontal_uncertainty"):
if ou.get(field, -1) == -1:
ou[field] = None
else:
ou[field] *= 1e3 # meters!
ou.azimuth_max_horizontal_uncertainty = hor_unc_azim
ou.preferred_description = str("uncertainty ellipse")
ou.confidence_level = 68 # NonLinLoc in general uses 1-sigma (68%) level
oq.standard_error = stderr
oq.azimuthal_gap = az_gap
oq.secondary_azimuthal_gap = sec_az_gap
oq.used_phase_count = used_phase_count
oq.used_station_count = used_station_count
oq.associated_phase_count = assoc_phase_count
oq.associated_station_count = assoc_station_count
oq.depth_phase_count = depth_phase_count
oq.ground_truth_level = gt_level
oq.minimum_distance = kilometer2degrees(min_dist)
oq.maximum_distance = kilometer2degrees(max_dist)
oq.median_distance = kilometer2degrees(med_dist)
# go through all phase info lines
for line in phases_lines:
line = line.split()
arrival = Arrival()
o.arrivals.append(arrival)
station = str(line[0])
phase = str(line[4])
arrival.phase = phase
arrival.distance = kilometer2degrees(float(line[21]))
arrival.azimuth = float(line[23])
arrival.takeoff_angle = float(line[24])
arrival.time_residual = float(line[16])
arrival.time_weight = float(line[17])
pick = Pick()
wid = WaveformStreamID(station_code=station)
date, hourmin, sec = map(str, line[6:9])
t = UTCDateTime().strptime(date + hourmin, "%Y%m%d%H%M") + float(sec)
pick.waveform_id = wid
pick.time = t
pick.time_errors.uncertainty = float(line[10])
pick.phase_hint = phase
pick.onset = ONSETS.get(line[3].lower(), None)
pick.polarity = POLARITIES.get(line[5].lower(), None)
# try to determine original pick for each arrival
for pick_ in original_picks:
wid = pick_.waveform_id
if station == wid.station_code and phase == pick_.phase_hint:
pick = pick_
break
else:
# warn if original picks were specified and we could not associate
# the arrival correctly
if original_picks:
msg = ("Could not determine corresponding original pick for "
"arrival. "
"Falling back to pick information in NonLinLoc "
"hypocenter-phase file.")
warnings.warn(msg)
event.picks.append(pick)
arrival.pick_id = pick.resource_id
return cat
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 _read_single_hypocenter(lines, coordinate_converter, original_picks):
"""
Given a list of lines (starting with a 'NLLOC' line and ending with a
'END_NLLOC' line), parse them into an Event.
"""
try:
# some paranoid checks..
assert lines[0].startswith("NLLOC ")
assert lines[-1].startswith("END_NLLOC")
for line in lines[1:-1]:
assert not line.startswith("NLLOC ")
assert not line.startswith("END_NLLOC")
except Exception:
msg = ("This should not have happened, please report this as a bug at "
"https://github.com/obspy/obspy/issues.")
raise Exception(msg)
indices_phases = [None, None]
for i, line in enumerate(lines):
if line.startswith("PHASE "):
indices_phases[0] = i
elif line.startswith("END_PHASE"):
indices_phases[1] = i
# extract PHASES lines (if any)
if any(indices_phases):
if not all(indices_phases):
msg = ("NLLOC HYP file seems corrupt, 'PHASE' block is corrupt.")
raise RuntimeError(msg)
i1, i2 = indices_phases
lines, phases_lines = lines[:i1] + lines[i2 + 1:], lines[i1 + 1:i2]
else:
phases_lines = []
lines = dict([line.split(None, 1) for line in lines[:-1]])
line = lines["SIGNATURE"]
line = line.rstrip().split('"')[1]
signature, version, date, time = line.rsplit(" ", 3)
# new NLLoc > 6.0 seems to add prefix 'run:' before date
if date.startswith('run:'):
date = date[4:]
signature = signature.strip()
creation_time = UTCDateTime.strptime(date + time, str("%d%b%Y%Hh%Mm%S"))
if coordinate_converter:
# maximum likelihood origin location in km info line
line = lines["HYPOCENTER"]
x, y, z = coordinate_converter(*map(float, line.split()[1:7:2]))
else:
# maximum likelihood origin location lon lat info line
line = lines["GEOGRAPHIC"]
y, x, z = map(float, line.split()[8:13:2])
# maximum likelihood origin time info line
line = lines["GEOGRAPHIC"]
year, mon, day, hour, min = map(int, line.split()[1:6])
seconds = float(line.split()[6])
time = UTCDateTime(year, mon, day, hour, min, seconds, strict=False)
# distribution statistics line
line = lines["STATISTICS"]
covariance_xx = float(line.split()[7])
covariance_yy = float(line.split()[13])
covariance_zz = float(line.split()[17])
stats_info_string = str(
"Note: Depth/Latitude/Longitude errors are calculated from covariance "
"matrix as 1D marginal (Lon/Lat errors as great circle degrees) "
"while OriginUncertainty min/max horizontal errors are calculated "
"from 2D error ellipsoid and are therefore seemingly higher compared "
"to 1D errors. Error estimates can be reconstructed from the "
"following original NonLinLoc error statistics line:\nSTATISTICS " +
lines["STATISTICS"])
# goto location quality info line
line = lines["QML_OriginQuality"].split()
(assoc_phase_count, used_phase_count, assoc_station_count,
used_station_count, depth_phase_count) = map(int, line[1:11:2])
stderr, az_gap, sec_az_gap = map(float, line[11:17:2])
gt_level = line[17]
min_dist, max_dist, med_dist = map(float, line[19:25:2])
# goto location quality info line
line = lines["QML_OriginUncertainty"]
if "COMMENT" in lines:
comment = lines["COMMENT"].strip()
comment = comment.strip('\'"')
comment = comment.strip()
hor_unc, min_hor_unc, max_hor_unc, hor_unc_azim = \
map(float, line.split()[1:9:2])
# assign origin info
event = Event()
o = Origin()
event.origins = [o]
event.preferred_origin_id = o.resource_id
o.origin_uncertainty = OriginUncertainty()
o.quality = OriginQuality()
ou = o.origin_uncertainty
oq = o.quality
o.comments.append(Comment(text=stats_info_string, force_resource_id=False))
event.comments.append(Comment(text=comment, force_resource_id=False))
# SIGNATURE field's first item is LOCSIG, which is supposed to be
# 'Identification of an individual, institiution or other entity'
# according to
# http://alomax.free.fr/nlloc/soft6.00/control.html#_NLLoc_locsig_
# so use it as author in creation info
event.creation_info = CreationInfo(creation_time=creation_time,
version=version,
author=signature)
o.creation_info = CreationInfo(creation_time=creation_time,
version=version,
author=signature)
# negative values can appear on diagonal of covariance matrix due to a
# precision problem in NLLoc implementation when location coordinates are
# large compared to the covariances.
o.longitude = x
try:
o.longitude_errors.uncertainty = kilometer2degrees(sqrt(covariance_xx))
except ValueError:
if covariance_xx < 0:
msg = ("Negative value in XX value of covariance matrix, not "
"setting longitude error (epicentral uncertainties will "
"still be set in origin uncertainty).")
warnings.warn(msg)
else:
raise
o.latitude = y
try:
o.latitude_errors.uncertainty = kilometer2degrees(sqrt(covariance_yy))
except ValueError:
if covariance_yy < 0:
msg = ("Negative value in YY value of covariance matrix, not "
"setting longitude error (epicentral uncertainties will "
"still be set in origin uncertainty).")
warnings.warn(msg)
else:
raise
o.depth = z * 1e3 # meters!
o.depth_errors.uncertainty = sqrt(covariance_zz) * 1e3 # meters!
o.depth_errors.confidence_level = 68
o.depth_type = str("from location")
o.time = time
ou.horizontal_uncertainty = hor_unc
ou.min_horizontal_uncertainty = min_hor_unc
ou.max_horizontal_uncertainty = max_hor_unc
# values of -1 seem to be used for unset values, set to None
for field in ("horizontal_uncertainty", "min_horizontal_uncertainty",
"max_horizontal_uncertainty"):
if ou.get(field, -1) == -1:
ou[field] = None
else:
ou[field] *= 1e3 # meters!
ou.azimuth_max_horizontal_uncertainty = hor_unc_azim
ou.preferred_description = str("uncertainty ellipse")
ou.confidence_level = 68 # NonLinLoc in general uses 1-sigma (68%) level
oq.standard_error = stderr
oq.azimuthal_gap = az_gap
oq.secondary_azimuthal_gap = sec_az_gap
oq.used_phase_count = used_phase_count
oq.used_station_count = used_station_count
oq.associated_phase_count = assoc_phase_count
oq.associated_station_count = assoc_station_count
oq.depth_phase_count = depth_phase_count
oq.ground_truth_level = gt_level
oq.minimum_distance = kilometer2degrees(min_dist)
oq.maximum_distance = kilometer2degrees(max_dist)
oq.median_distance = kilometer2degrees(med_dist)
# go through all phase info lines
for line in phases_lines:
line = line.split()
arrival = Arrival()
o.arrivals.append(arrival)
station = str(line[0])
phase = str(line[4])
arrival.phase = phase
arrival.distance = kilometer2degrees(float(line[21]))
arrival.azimuth = float(line[23])
arrival.takeoff_angle = float(line[24])
arrival.time_residual = float(line[16])
arrival.time_weight = float(line[17])
pick = Pick()
# network codes are not used by NonLinLoc, so they can not be known
# when reading the .hyp file.. to conform with QuakeML standard set an
# empty network code
wid = WaveformStreamID(network_code="", station_code=station)
# have to split this into ints for overflow to work correctly
date, hourmin, sec = map(str, line[6:9])
ymd = [int(date[:4]), int(date[4:6]), int(date[6:8])]
hm = [int(hourmin[:2]), int(hourmin[2:4])]
t = UTCDateTime(*(ymd + hm), strict=False) + float(sec)
pick.waveform_id = wid
pick.time = t
pick.time_errors.uncertainty = float(line[10])
pick.phase_hint = phase
pick.onset = ONSETS.get(line[3].lower(), None)
pick.polarity = POLARITIES.get(line[5].lower(), None)
# try to determine original pick for each arrival
for pick_ in original_picks:
wid = pick_.waveform_id
if station == wid.station_code and phase == pick_.phase_hint:
pick = pick_
break
else:
# warn if original picks were specified and we could not associate
# the arrival correctly
if original_picks:
msg = ("Could not determine corresponding original pick for "
"arrival. "
"Falling back to pick information in NonLinLoc "
"hypocenter-phase file.")
warnings.warn(msg)
event.picks.append(pick)
arrival.pick_id = pick.resource_id
event.scope_resource_ids()
return event
def read_nlloc_hyp(filename, coordinate_converter=None, picks=None, **kwargs):
"""
Reads a NonLinLoc Hypocenter-Phase file to a
:class:`~obspy.core.event.Catalog` object.
.. note::
Coordinate conversion from coordinate frame of NonLinLoc model files /
location run to WGS84 has to be specified explicitly by the user if
necessary.
.. note::
An example can be found on the :mod:`~obspy.io.nlloc` submodule front
page in the documentation pages.
:param filename: File or file-like object in text mode.
:type coordinate_converter: func
:param coordinate_converter: Function to convert (x, y, z)
coordinates of NonLinLoc output to geographical coordinates and depth
in meters (longitude, latitude, depth in kilometers).
If left ``None``, NonLinLoc (x, y, z) output is left unchanged (e.g. if
it is in geographical coordinates already like for NonLinLoc in
global mode).
The function should accept three arguments x, y, z (each of type
:class:`numpy.ndarray`) and return a tuple of three
:class:`numpy.ndarray` (lon, lat, depth in kilometers).
:type picks: list of :class:`~obspy.core.event.Pick`
:param picks: Original picks used to generate the NonLinLoc location.
If provided, the output event will include the original picks and the
arrivals in the output origin will link to them correctly (with their
``pick_id`` attribute). If not provided, the output event will include
(the rather basic) pick information that can be reconstructed from the
NonLinLoc hypocenter-phase file.
:rtype: :class:`~obspy.core.event.Catalog`
"""
if not hasattr(filename, "read"):
# Check if it exists, otherwise assume its a string.
try:
with open(filename, "rt") as fh:
data = fh.read()
except:
try:
data = filename.decode()
except:
data = str(filename)
data = data.strip()
else:
data = filename.read()
if hasattr(data, "decode"):
data = data.decode()
lines = data.splitlines()
# remember picks originally used in location, if provided
original_picks = picks
if original_picks is None:
original_picks = []
# determine indices of block start/end of the NLLOC output file
indices_hyp = [None, None]
indices_phases = [None, None]
for i, line in enumerate(lines):
if line.startswith("NLLOC "):
indices_hyp[0] = i
elif line.startswith("END_NLLOC"):
indices_hyp[1] = i
elif line.startswith("PHASE "):
indices_phases[0] = i
elif line.startswith("END_PHASE"):
indices_phases[1] = i
if any([i is None for i in indices_hyp]):
msg = ("NLLOC HYP file seems corrupt,"
" could not detect 'NLLOC' and 'END_NLLOC' lines.")
raise RuntimeError(msg)
# strip any other lines around NLLOC block
lines = lines[indices_hyp[0]:indices_hyp[1]]
# extract PHASES lines (if any)
if any(indices_phases):
if not all(indices_phases):
msg = ("NLLOC HYP file seems corrupt, 'PHASE' block is corrupt.")
raise RuntimeError(msg)
i1, i2 = indices_phases
lines, phases_lines = lines[:i1] + lines[i2 + 1:], lines[i1 + 1:i2]
else:
phases_lines = []
lines = dict([line.split(None, 1) for line in lines])
line = lines["SIGNATURE"]
line = line.rstrip().split('"')[1]
signature, version, date, time = line.rsplit(" ", 3)
creation_time = UTCDateTime().strptime(date + time, str("%d%b%Y%Hh%Mm%S"))
# maximum likelihood origin location info line
line = lines["HYPOCENTER"]
x, y, z = map(float, line.split()[1:7:2])
if coordinate_converter:
x, y, z = coordinate_converter(x, y, z)
# origin time info line
line = lines["GEOGRAPHIC"]
year, month, day, hour, minute = map(int, line.split()[1:6])
seconds = float(line.split()[6])
time = UTCDateTime(year, month, day, hour, minute, seconds)
# distribution statistics line
line = lines["STATISTICS"]
covariance_xx = float(line.split()[7])
covariance_yy = float(line.split()[13])
covariance_zz = float(line.split()[17])
stats_info_string = str(
"Note: Depth/Latitude/Longitude errors are calculated from covariance "
"matrix as 1D marginal (Lon/Lat errors as great circle degrees) "
"while OriginUncertainty min/max horizontal errors are calculated "
"from 2D error ellipsoid and are therefore seemingly higher compared "
"to 1D errors. Error estimates can be reconstructed from the "
"following original NonLinLoc error statistics line:\nSTATISTICS " +
lines["STATISTICS"])
# goto location quality info line
line = lines["QML_OriginQuality"].split()
(assoc_phase_count, used_phase_count, assoc_station_count,
used_station_count, depth_phase_count) = map(int, line[1:11:2])
stderr, az_gap, sec_az_gap = map(float, line[11:17:2])
gt_level = line[17]
min_dist, max_dist, med_dist = map(float, line[19:25:2])
# goto location quality info line
line = lines["QML_OriginUncertainty"]
hor_unc, min_hor_unc, max_hor_unc, hor_unc_azim = \
map(float, line.split()[1:9:2])
# assign origin info
event = Event()
cat = Catalog(events=[event])
o = Origin()
event.origins = [o]
o.origin_uncertainty = OriginUncertainty()
o.quality = OriginQuality()
ou = o.origin_uncertainty
oq = o.quality
o.comments.append(Comment(text=stats_info_string))
cat.creation_info.creation_time = UTCDateTime()
cat.creation_info.version = "ObsPy %s" % __version__
event.creation_info = CreationInfo(creation_time=creation_time,
version=version)
event.creation_info.version = version
o.creation_info = CreationInfo(creation_time=creation_time,
version=version)
# negative values can appear on diagonal of covariance matrix due to a
# precision problem in NLLoc implementation when location coordinates are
# large compared to the covariances.
o.longitude = x
try:
o.longitude_errors.uncertainty = kilometer2degrees(sqrt(covariance_xx))
except ValueError:
if covariance_xx < 0:
msg = ("Negative value in XX value of covariance matrix, not "
"setting longitude error (epicentral uncertainties will "
"still be set in origin uncertainty).")
warnings.warn(msg)
else:
raise
o.latitude = y
try:
o.latitude_errors.uncertainty = kilometer2degrees(sqrt(covariance_yy))
except ValueError:
if covariance_yy < 0:
msg = ("Negative value in YY value of covariance matrix, not "
"setting longitude error (epicentral uncertainties will "
"still be set in origin uncertainty).")
warnings.warn(msg)
else:
raise
o.depth = z * 1e3 # meters!
o.depth_errors.uncertainty = sqrt(covariance_zz) * 1e3 # meters!
o.depth_errors.confidence_level = 68
o.depth_type = str("from location")
o.time = time
ou.horizontal_uncertainty = hor_unc
ou.min_horizontal_uncertainty = min_hor_unc
ou.max_horizontal_uncertainty = max_hor_unc
# values of -1 seem to be used for unset values, set to None
for field in ("horizontal_uncertainty", "min_horizontal_uncertainty",
"max_horizontal_uncertainty"):
if ou.get(field, -1) == -1:
ou[field] = None
else:
ou[field] *= 1e3 # meters!
ou.azimuth_max_horizontal_uncertainty = hor_unc_azim
ou.preferred_description = str("uncertainty ellipse")
ou.confidence_level = 68 # NonLinLoc in general uses 1-sigma (68%) level
oq.standard_error = stderr
oq.azimuthal_gap = az_gap
oq.secondary_azimuthal_gap = sec_az_gap
oq.used_phase_count = used_phase_count
oq.used_station_count = used_station_count
oq.associated_phase_count = assoc_phase_count
oq.associated_station_count = assoc_station_count
oq.depth_phase_count = depth_phase_count
oq.ground_truth_level = gt_level
oq.minimum_distance = kilometer2degrees(min_dist)
oq.maximum_distance = kilometer2degrees(max_dist)
oq.median_distance = kilometer2degrees(med_dist)
# go through all phase info lines
for line in phases_lines:
line = line.split()
arrival = Arrival()
o.arrivals.append(arrival)
station = str(line[0])
phase = str(line[4])
arrival.phase = phase
arrival.distance = kilometer2degrees(float(line[21]))
arrival.azimuth = float(line[23])
arrival.takeoff_angle = float(line[24])
arrival.time_residual = float(line[16])
arrival.time_weight = float(line[17])
pick = Pick()
wid = WaveformStreamID(station_code=station)
date, hourmin, sec = map(str, line[6:9])
t = UTCDateTime().strptime(date + hourmin, "%Y%m%d%H%M") + float(sec)
pick.waveform_id = wid
pick.time = t
pick.time_errors.uncertainty = float(line[10])
pick.phase_hint = phase
pick.onset = ONSETS.get(line[3].lower(), None)
pick.polarity = POLARITIES.get(line[5].lower(), None)
# try to determine original pick for each arrival
for pick_ in original_picks:
wid = pick_.waveform_id
if station == wid.station_code and phase == pick_.phase_hint:
pick = pick_
break
else:
# warn if original picks were specified and we could not associate
# the arrival correctly
if original_picks:
msg = ("Could not determine corresponding original pick for "
"arrival. "
"Falling back to pick information in NonLinLoc "
"hypocenter-phase file.")
warnings.warn(msg)
event.picks.append(pick)
arrival.pick_id = pick.resource_id
return cat
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 __toPick(parser, pick_el, evaluation_mode):
"""
"""
pick = Pick()
pick.resource_id = ResourceIdentifier(prefix="/".join([RESOURCE_ROOT, "pick"]))
# Raise a warnings if there is a phase delay
phase_delay = parser.xpath2obj("phase_delay", pick_el, float)
if phase_delay is not None:
msg = "The pick has a phase_delay!"
raise Exception(msg)
waveform = pick_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 ""
pick.waveform_id = WaveformStreamID(
network_code=network,
station_code=station,
channel_code=channel,
location_code=location)
pick.time, pick.time_errors = __toTimeQuantity(parser, pick_el, "time")
# Picks without time are not quakeml conform
if pick.time is None:
print "Pick has no time and is ignored: %s" % station
return None
pick.phase_hint = parser.xpath2obj('phaseHint', pick_el, str)
onset = parser.xpath2obj('onset', pick_el)
# Fixing bad and old typo ...
if onset == "implusive":
onset = "impulsive"
if onset:
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',
'forward': 'positive',
'forwards': 'positive',
'right': 'positive',
'backward': 'negative',
'backwards': 'negative',
'left': 'negative',
'down': 'negative', 'negative': 'negative',
'undecidable': 'undecidable',
'poorup': 'positive',
'poordown': 'negative'}
if polarity:
if polarity.lower() in pol_map_dict:
pick.polarity = pol_map_dict[polarity.lower()]
else:
pick.polarity = polarity.lower()
pick_weight = parser.xpath2obj('weight', pick_el, int)
if pick_weight is not None:
pick.extra = AttribDict()
pick.extra.weight = {'value': pick_weight, 'namespace': NAMESPACE}
return pick
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 __toPick(parser, pick_el, evaluation_mode):
"""
"""
pick = Pick()
pick.resource_id = ResourceIdentifier(
prefix="/".join([RESOURCE_ROOT, "pick"]))
# Raise a warnings if there is a phase delay
phase_delay = parser.xpath2obj("phase_delay", pick_el, float)
if phase_delay is not None:
msg = "The pick has a phase_delay!"
raise Exception(msg)
waveform = pick_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 ""
pick.waveform_id = WaveformStreamID(network_code=network,
station_code=station,
channel_code=channel,
location_code=location)
pick.time, pick.time_errors = __toTimeQuantity(parser, pick_el, "time")
# Picks without time are not quakeml conform
if pick.time is None:
print "Pick has no time and is ignored: %s" % station
return None
pick.phase_hint = parser.xpath2obj('phaseHint', pick_el, str)
onset = parser.xpath2obj('onset', pick_el)
# Fixing bad and old typo ...
if onset == "implusive":
onset = "impulsive"
if onset:
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',
'forward': 'positive',
'forwards': 'positive',
'right': 'positive',
'backward': 'negative',
'backwards': 'negative',
'left': 'negative',
'down': 'negative',
'negative': 'negative',
'undecidable': 'undecidable',
'poorup': 'positive',
'poordown': 'negative'
}
if polarity:
if polarity.lower() in pol_map_dict:
pick.polarity = pol_map_dict[polarity.lower()]
else:
pick.polarity = polarity.lower()
pick_weight = parser.xpath2obj('weight', pick_el, int)
if pick_weight is not None:
pick.extra = AttribDict()
pick.extra.weight = {'value': pick_weight, 'namespace': NAMESPACE}
return pick
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
