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 readSeishubEventFile(filename):
"""
Reads a Seishub event file and returns a ObsPy Catalog object.
.. warning::
This function should NOT be called directly, it registers via the
ObsPy :func:`~obspy.core.event.readEvents` function, call this instead.
:type filename: str
:param filename: Seishub event file to be read.
:rtype: :class:`~obspy.core.event.Catalog`
:return: A ObsPy Catalog object.
.. rubric:: Example
"""
global CURRENT_TYPE
base_name = os.path.basename(filename)
if base_name.lower().startswith("baynet"):
CURRENT_TYPE = "baynet"
elif base_name.lower().startswith("earthworm"):
CURRENT_TYPE = "earthworm"
elif base_name.lower().startswith("gof"):
CURRENT_TYPE = "seiscomp3"
elif base_name.lower().startswith("obspyck") or base_name == "5622":
CURRENT_TYPE = "obspyck"
elif base_name.lower().startswith("toni"):
CURRENT_TYPE = "toni"
else:
print "AAAAAAAAAAAAAAAAAAAAAAAAAAHHHHHHHHHHHHHHHHHHH"
raise Exception
# Just init the parser, the SeisHub event file format has no namespaces.
parser = XMLParser(filename)
# Create new Event object.
public_id = parser.xpath('event_id/value')[0].text
# A Seishub event just specifies a single event so Catalog information is
# not really given.
catalog = Catalog()
catalog.resource_id = "/".join([RESOURCE_ROOT, "catalog", public_id])
# Read the event_type tag.
account = parser.xpath2obj('event_type/account', parser, str)
user = parser.xpath2obj('event_type/user', parser, str)
global_evaluation_mode = parser.xpath2obj('event_type/value', parser, str)
public = parser.xpath2obj('event_type/public', parser, str)
public = {"True": True, "False": False}.get(public, None)
if account is not None and account.lower() != "sysop":
public = False
# The author will be stored in the CreationInfo object. This will be the
# creation info of the event as well as on all picks.
author = user
if CURRENT_TYPE in ["seiscomp3", "earthworm"]:
author = CURRENT_TYPE
creation_info = {"author": author,
"agency_id": "Erdbebendienst Bayern",
"agency_uri": "%s/agency" % RESOURCE_ROOT,
"creation_time": NOW}
# Create the event object.
event = Event(resource_id="/".join([RESOURCE_ROOT, "event", public_id]),
creation_info=creation_info)
# If account is None or 'sysop' and public is true, write 'public in the
# comment, 'private' otherwise.
event.extra = AttribDict()
event.extra.public = {'value': public, 'namespace': NAMESPACE}
event.extra.evaluationMode = {'value': global_evaluation_mode, 'namespace': NAMESPACE}
event_type = parser.xpath2obj('type', parser, str)
if event_type is not None:
if event_type == "induced earthquake":
event_type = "induced or triggered event"
if event_type != "null":
event.event_type = event_type
# Parse the origins.
origins = parser.xpath("origin")
if len(origins) > 1:
msg = "Only files with a single origin are currently supported"
raise Exception(msg)
for origin_el in parser.xpath("origin"):
origin = __toOrigin(parser, origin_el)
event.origins.append(origin)
# Parse the magnitudes.
for magnitude_el in parser.xpath("magnitude"):
magnitude = __toMagnitude(parser, magnitude_el, origin)
if magnitude.mag is None:
continue
event.magnitudes.append(magnitude)
# Parse the picks. Pass the global evaluation mode (automatic, manual)
for pick_el in parser.xpath("pick"):
pick = __toPick(parser, pick_el, global_evaluation_mode)
if pick is None:
continue
event.picks.append(pick)
# The arrival object gets the following things from the Seishub.pick
# objects
# arrival.time_weight = pick.phase_weight
# arrival.time_residual = pick.phase_res
# arrival.azimuth = pick.azimuth
# arrival.take_off_angle = pick.incident
# arrival.distance = hyp_dist
arrival = __toArrival(parser, pick_el, global_evaluation_mode, pick)
if event.origins:
event.origins[0].arrivals.append(arrival)
for mag in event.station_magnitudes:
mag.origin_id = event.origins[0].resource_id
# Parse the station magnitudes.
for stat_magnitude_el in parser.xpath("stationMagnitude"):
stat_magnitude = __toStationMagnitude(parser, stat_magnitude_el)
event.station_magnitudes.append(stat_magnitude)
# Parse the amplitudes
# we don't reference their id in the corresponding station magnitude,
# because we use one amplitude measurement for each component
for el in parser.xpath("stationMagnitude/amplitude"):
event.amplitudes.append(__toAmplitude(parser, el))
for mag in event.station_magnitudes:
mag.origin_id = event.origins[0].resource_id
for _i, stat_mag in enumerate(event.station_magnitudes):
contrib = StationMagnitudeContribution()
weight = None
# The order of station magnitude objects is the same as in the xml
# file.
weight = parser.xpath2obj("weight",
parser.xpath("stationMagnitude")[_i], float)
if weight is not None:
contrib.weight = weight
contrib.station_magnitude_id = stat_mag.resource_id
event.magnitudes[0].station_magnitude_contributions.append(contrib)
for foc_mec_el in parser.xpath("focalMechanism"):
foc_mec = __toFocalMechanism(parser, foc_mec_el)
if foc_mec is not None:
event.focal_mechanisms.append(foc_mec)
# Set the origin id for the focal mechanisms. There is only one origin per
# SeisHub event file.
for focmec in event.focal_mechanisms:
focmec.triggering_origin_id = event.origins[0].resource_id
# Add the event to the catalog
catalog.append(event)
return catalog
def readSeishubEventFile(filename):
"""
Reads a Seishub event file and returns a ObsPy Catalog object.
.. warning::
This function should NOT be called directly, it registers via the
ObsPy :func:`~obspy.core.event.readEvents` function, call this instead.
:type filename: str
:param filename: Seishub event file to be read.
:rtype: :class:`~obspy.core.event.Catalog`
:return: A ObsPy Catalog object.
.. rubric:: Example
"""
global CURRENT_TYPE
base_name = os.path.basename(filename)
if base_name.lower().startswith("baynet"):
CURRENT_TYPE = "baynet"
elif base_name.lower().startswith("earthworm"):
CURRENT_TYPE = "earthworm"
elif base_name.lower().startswith("gof"):
CURRENT_TYPE = "seiscomp3"
elif base_name.lower().startswith("obspyck") or base_name == "5622":
CURRENT_TYPE = "obspyck"
elif base_name.lower().startswith("toni"):
CURRENT_TYPE = "toni"
else:
print "AAAAAAAAAAAAAAAAAAAAAAAAAAHHHHHHHHHHHHHHHHHHH"
raise Exception
# Just init the parser, the SeisHub event file format has no namespaces.
parser = XMLParser(filename)
# Create new Event object.
public_id = parser.xpath('event_id/value')[0].text
# A Seishub event just specifies a single event so Catalog information is
# not really given.
catalog = Catalog()
catalog.resource_id = "/".join([RESOURCE_ROOT, "catalog", public_id])
# Read the event_type tag.
account = parser.xpath2obj('event_type/account', parser, str)
user = parser.xpath2obj('event_type/user', parser, str)
global_evaluation_mode = parser.xpath2obj('event_type/value', parser, str)
public = parser.xpath2obj('event_type/public', parser, str)
public = {
"True": True,
"False": False,
"true": True,
"false": False
}.get(public, None)
if account is not None and account.lower() != "sysop":
public = False
# The author will be stored in the CreationInfo object. This will be the
# creation info of the event as well as on all picks.
author = user
if CURRENT_TYPE in ["seiscomp3", "earthworm"]:
public = False
author = CURRENT_TYPE
global_evaluation_mode = "automatic"
elif CURRENT_TYPE in ["baynet", "toni"]:
public = True
author = CURRENT_TYPE
global_evaluation_mode = "manual"
creation_info = {
"author": author,
"agency_id": "Erdbebendienst Bayern",
"agency_uri": "%s/agency" % RESOURCE_ROOT,
"creation_time": NOW
}
# Create the event object.
event = Event(resource_id="/".join([RESOURCE_ROOT, "event", public_id]),
creation_info=creation_info)
# If account is None or 'sysop' and public is true, write 'public in the
# comment, 'private' otherwise.
event.extra = AttribDict()
event.extra.public = {'value': public, 'namespace': NAMESPACE}
event.extra.evaluationMode = {
'value': global_evaluation_mode,
'namespace': NAMESPACE
}
event_type = parser.xpath2obj('type', parser, str)
if event_type is not None:
if event_type == "induced earthquake":
event_type = "induced or triggered event"
if event_type != "null":
event.event_type = event_type
# Parse the origins.
origins = parser.xpath("origin")
if len(origins) > 1:
msg = "Only files with a single origin are currently supported"
raise Exception(msg)
for origin_el in parser.xpath("origin"):
origin = __toOrigin(parser, origin_el)
event.origins.append(origin)
# Parse the magnitudes.
for magnitude_el in parser.xpath("magnitude"):
magnitude = __toMagnitude(parser, magnitude_el, origin)
if magnitude.mag is None:
continue
event.magnitudes.append(magnitude)
# Parse the picks. Pass the global evaluation mode (automatic, manual)
for pick_el in parser.xpath("pick"):
pick = __toPick(parser, pick_el, global_evaluation_mode)
if pick is None:
continue
event.picks.append(pick)
# The arrival object gets the following things from the Seishub.pick
# objects
# arrival.time_weight = pick.phase_weight
# arrival.time_residual = pick.phase_res
# arrival.azimuth = pick.azimuth
# arrival.take_off_angle = pick.incident
# arrival.distance = hyp_dist
arrival = __toArrival(parser, pick_el, global_evaluation_mode, pick)
if event.origins:
event.origins[0].arrivals.append(arrival)
for mag in event.station_magnitudes:
mag.origin_id = event.origins[0].resource_id
# Parse the station magnitudes.
for stat_magnitude_el in parser.xpath("stationMagnitude"):
stat_magnitude = __toStationMagnitude(parser, stat_magnitude_el)
event.station_magnitudes.append(stat_magnitude)
# Parse the amplitudes
# we don't reference their id in the corresponding station magnitude,
# because we use one amplitude measurement for each component
for el in parser.xpath("stationMagnitude/amplitude"):
event.amplitudes.append(__toAmplitude(parser, el))
for mag in event.station_magnitudes:
mag.origin_id = event.origins[0].resource_id
for _i, stat_mag in enumerate(event.station_magnitudes):
contrib = StationMagnitudeContribution()
weight = None
# The order of station magnitude objects is the same as in the xml
# file.
weight = parser.xpath2obj("weight",
parser.xpath("stationMagnitude")[_i], float)
if weight is not None:
contrib.weight = weight
contrib.station_magnitude_id = stat_mag.resource_id
event.magnitudes[0].station_magnitude_contributions.append(contrib)
for foc_mec_el in parser.xpath("focalMechanism"):
foc_mec = __toFocalMechanism(parser, foc_mec_el)
if foc_mec is not None:
event.focal_mechanisms.append(foc_mec)
# Set the origin id for the focal mechanisms. There is only one origin per
# SeisHub event file.
for focmec in event.focal_mechanisms:
focmec.triggering_origin_id = event.origins[0].resource_id
# Add the event to the catalog
catalog.append(event)
return catalog
def relative_magnitudes(self,
stream,
pre_processed,
process_cores=1,
ignore_bad_data=False,
parallel=False,
min_cc=0.4,
**kwargs):
"""
Compute relative magnitudes for the detections.
Works in place on events in the Family
:type stream: obspy.core.stream.Stream
:param stream:
All the data needed to cut from - can be a gappy Stream.
:type pre_processed: bool
:param pre_processed:
Whether the stream has been pre-processed or not to match the
templates. See note below.
:param parallel: Turn parallel processing on or off.
:type process_cores: int
:param process_cores:
Number of processes to use for pre-processing (if different to
`cores`).
:type ignore_bad_data: bool
:param ignore_bad_data:
If False (default), errors will be raised if data are excessively
gappy or are mostly zeros. If True then no error will be raised,
but an empty trace will be returned (and not used in detection).
:type min_cc: float
:param min_cc: Minimum correlation for magnitude to be computed.
:param kwargs:
Keyword arguments passed to `utils.mag_calc.relative_mags`
.. Note::
Note on pre-processing: You can provide a pre-processed stream,
which may be beneficial for detections over large time periods
(the stream can have gaps, which reduces memory usage). However,
in this case the processing steps are not checked, so you must
ensure that the template in the Family has the same sampling
rate and filtering as the stream.
If pre-processing has not be done then the data will be processed
according to the parameters in the template.
"""
processed_stream = self._process_streams(
stream=stream,
pre_processed=pre_processed,
process_cores=process_cores,
parallel=parallel,
ignore_bad_data=ignore_bad_data)
for detection in self.detections:
event = detection.event
if event is None:
continue
corr_dict = {
p.waveform_id.get_seed_string():
float(p.comments[0].text.split("=")[-1])
for p in event.picks
}
template = self.template
try:
t_mag = (template.event.preferred_magnitude()
or template.event.magnitudes[0])
except IndexError:
Logger.info("No template magnitude, relative magnitudes cannot"
" be computed for {0}".format(event.resource_id))
continue
# Set the signal-window to be the template length
signal_window = (
-template.prepick,
min([tr.stats.npts * tr.stats.delta
for tr in template.st]) - template.prepick)
delta_mag = relative_magnitude(st1=template.st,
st2=processed_stream,
event1=template.event,
event2=event,
correlations=corr_dict,
min_cc=min_cc,
signal_window=signal_window,
**kwargs)
# Add station magnitudes
sta_contrib = []
av_mag = 0.0
for seed_id, _delta_mag in delta_mag.items():
sta_mag = StationMagnitude(
mag=t_mag.mag + _delta_mag,
magnitude_type=t_mag.magnitude_type,
method_id=ResourceIdentifier("relative"),
waveform_id=WaveformStreamID(seed_string=seed_id),
creation_info=CreationInfo(author="EQcorrscan",
creation_time=UTCDateTime()))
event.station_magnitudes.append(sta_mag)
sta_contrib.append(
StationMagnitudeContribution(
station_magnitude_id=sta_mag.resource_id, weight=1.))
av_mag += sta_mag.mag
if len(delta_mag) > 0:
av_mag /= len(delta_mag)
# Compute average magnitude
event.magnitudes.append(
Magnitude(mag=av_mag,
magnitude_type=t_mag.magnitude_type,
method_id=ResourceIdentifier("relative"),
station_count=len(delta_mag),
evaluation_mode="manual",
station_magnitude_contributions=sta_contrib,
creation_info=CreationInfo(
author="EQcorrscan",
creation_time=UTCDateTime())))
return self.catalog
def write_qml(config, sourcepar):
if not config.options.qml_file:
return
qml_file = config.options.qml_file
cat = read_events(qml_file)
evid = config.hypo.evid
try:
ev = [e for e in cat if evid in str(e.resource_id)][0]
except Exception:
logging.warning('Unable to find evid "{}" in QuakeML file. '
'QuakeML output will not be written.'.format(evid))
origin = ev.preferred_origin()
if origin is None:
origin = ev.origins[0]
origin_id = origin.resource_id
origin_id_strip = origin_id.id.split('/')[-1]
origin_id_strip = origin_id_strip.replace(config.smi_strip_from_origin_id,
'')
# Common parameters
ssp_version = get_versions()['version']
method_id = config.smi_base + '/sourcespec/' + ssp_version
cr_info = CreationInfo()
cr_info.agency_id = config.agency_id
if config.author is None:
author = '{}@{}'.format(getuser(), gethostname())
else:
author = config.author
cr_info.author = author
cr_info.creation_time = UTCDateTime()
means = sourcepar.means_weight
errors = sourcepar.errors_weight
stationpar = sourcepar.station_parameters
# Magnitude
mag = Magnitude()
_id = config.smi_magnitude_template.replace('$SMI_BASE', config.smi_base)
_id = _id.replace('$ORIGIN_ID', origin_id_strip)
mag.resource_id = ResourceIdentifier(id=_id)
mag.method_id = ResourceIdentifier(id=method_id)
mag.origin_id = origin_id
mag.magnitude_type = 'Mw'
mag.mag = means['Mw']
mag_err = QuantityError()
mag_err.uncertainty = errors['Mw']
mag_err.confidence_level = 68.2
mag.mag_errors = mag_err
mag.station_count = len([_s for _s in stationpar.keys()])
mag.evaluation_mode = 'automatic'
mag.creation_info = cr_info
# Seismic moment -- It has to be stored in a MomentTensor object
# which, in turn, is part of a FocalMechanism object
mt = MomentTensor()
_id = config.smi_moment_tensor_template.replace('$SMI_BASE',
config.smi_base)
_id = _id.replace('$ORIGIN_ID', origin_id_strip)
mt.resource_id = ResourceIdentifier(id=_id)
mt.derived_origin_id = origin_id
mt.moment_magnitude_id = mag.resource_id
mt.scalar_moment = means['Mo']
mt_err = QuantityError()
mt_err.lower_uncertainty = errors['Mo'][0]
mt_err.upper_uncertainty = errors['Mo'][1]
mt_err.confidence_level = 68.2
mt.scalar_moment_errors = mt_err
mt.method_id = method_id
mt.creation_info = cr_info
# And here is the FocalMechanism object
fm = FocalMechanism()
_id = config.smi_focal_mechanism_template.replace('$SMI_BASE',
config.smi_base)
_id = _id.replace('$ORIGIN_ID', origin_id_strip)
fm.resource_id = ResourceIdentifier(id=_id)
fm.triggering_origin_id = origin_id
fm.method_id = ResourceIdentifier(id=method_id)
fm.moment_tensor = mt
fm.creation_info = cr_info
ev.focal_mechanisms.append(fm)
# Station magnitudes
for statId in sorted(stationpar.keys()):
par = stationpar[statId]
st_mag = StationMagnitude()
seed_id = statId.split()[0]
_id = config.smi_station_magnitude_template.replace(
'$SMI_MAGNITUDE_TEMPLATE', config.smi_magnitude_template)
_id = _id.replace('$ORIGIN_ID', origin_id_strip)
_id = _id.replace('$SMI_BASE', config.smi_base)
_id = _id.replace('$WAVEFORM_ID', seed_id)
st_mag.resource_id = ResourceIdentifier(id=_id)
st_mag.origin_id = origin_id
st_mag.mag = par['Mw']
st_mag.station_magnitude_type = 'Mw'
st_mag.method_id = mag.method_id
st_mag.creation_info = cr_info
st_mag.waveform_id = WaveformStreamID(seed_string=seed_id)
st_mag.extra = SSPExtra()
st_mag.extra.moment = SSPTag(par['Mo'])
st_mag.extra.corner_frequency = SSPTag(par['fc'])
st_mag.extra.t_star = SSPTag(par['t_star'])
ev.station_magnitudes.append(st_mag)
st_mag_contrib = StationMagnitudeContribution()
st_mag_contrib.station_magnitude_id = st_mag.resource_id
mag.station_magnitude_contributions.append(st_mag_contrib)
ev.magnitudes.append(mag)
# Write other average parameters as custom tags
ev.extra = SSPExtra()
ev.extra.corner_frequency = SSPContainerTag()
ev.extra.corner_frequency.value.value = SSPTag(means['fc'])
ev.extra.corner_frequency.value.lower_uncertainty =\
SSPTag(errors['fc'][0])
ev.extra.corner_frequency.value.upper_uncertainty =\
SSPTag(errors['fc'][1])
ev.extra.corner_frequency.value.confidence_level = SSPTag(68.2)
ev.extra.t_star = SSPContainerTag()
ev.extra.t_star.value.value = SSPTag(means['t_star'])
ev.extra.t_star.value.uncertainty = SSPTag(errors['t_star'])
ev.extra.t_star.value.confidence_level = SSPTag(68.2)
ev.extra.source_radius = SSPContainerTag()
ev.extra.source_radius.value.value = SSPTag(means['ra'])
ev.extra.source_radius.value.lower_uncertainty =\
SSPTag(errors['ra'][0])
ev.extra.source_radius.value.upper_uncertainty =\
SSPTag(errors['ra'][1])
ev.extra.source_radius.value.confidence_level = SSPTag(68.2)
ev.extra.stress_drop = SSPContainerTag()
ev.extra.stress_drop.value.value = SSPTag(means['bsd'])
ev.extra.stress_drop.value.lower_uncertainty =\
SSPTag(errors['bsd'][0])
ev.extra.stress_drop.value.upper_uncertainty =\
SSPTag(errors['bsd'][1])
ev.extra.stress_drop.value.confidence_level = SSPTag(68.2)
if config.set_preferred_magnitude:
ev.preferred_magnitude_id = mag.resource_id.id
qml_file_out = os.path.join(config.options.outdir, evid + '.xml')
ev.write(qml_file_out, format='QUAKEML')
logging.info('QuakeML file written to: ' + qml_file_out)