def _processRequest(self, req, ro, dbq, exp):
if req._disconnected:
return False
DataModel.PublicObject.SetRegistrationEnabled(False)
# query event(s)
ep = DataModel.EventParameters()
if ro.eventIDs:
for eID in ro.eventIDs:
obj = dbq.getEventByPublicID(eID)
e = DataModel.Event.Cast(obj)
if not e:
continue
if self._eventTypeWhitelist or self._eventTypeBlacklist:
eType = -1
try:
eType = e.type()
except ValueError:
pass
if self._eventTypeWhitelist and \
not eType in self._eventTypeWhitelist:
continue
if self._eventTypeBlacklist and \
eType in self._eventTypeBlacklist:
continue
if self._evaluationMode is not None:
obj = dbq.getObject(DataModel.Origin.TypeInfo(),
e.preferredOriginID())
o = DataModel.Origin.Cast(obj)
try:
if o is None or \
o.evaluationMode() != self._evaluationMode:
continue
except ValueError:
continue
ep.add(e)
else:
self._findEvents(ep, ro, dbq)
if ep.eventCount() == 0:
msg = "no matching events found"
self.writeErrorPage(req, http.NO_CONTENT, msg, ro)
return True
Logging.debug("events found: %i" % ep.eventCount())
if ro.format == 'csv' or not exp:
req.setHeader('Content-Type', 'text/plain')
else:
req.setHeader('Content-Type', 'application/xml')
if exp:
return self._processRequestExp(req, ro, dbq, exp, ep)
return self._processRequestText(req, ro, dbq, ep)
def __init__(self, xmlOut):
self.ar = scio.XMLArchive() # seiscomp xml creator
self.ar.setFormattedOutput(True) # output formatted xml file
self.xmlOut = xmlOut
self.eparams = scdatamodel.EventParameters()
self.eparams.SetIdGeneration(True)
self.eparams.SetIdPattern('@classname@#@time/%Y%m%d%H%M%S.%f@.@id@')
self._stage = 2
self.Eid = '0'
def loadEventParametersObject(self, publicID):
for tp in \
DataModel.Pick, DataModel.Amplitude, DataModel.Origin, \
DataModel.Event, DataModel.FocalMechanism, \
DataModel.Magnitude, DataModel.StationMagnitude:
obj = self.query().loadObject(tp.TypeInfo(), publicID)
obj = tp.Cast(obj)
if obj:
ep = DataModel.EventParameters()
ep.add(obj)
return ep
def process(self, line):
# parse one input line and send the resulting pick
ep = DataModel.EventParameters()
DataModel.Notifier.Enable()
pick = self.parse(line)
ep.add(pick)
msg = DataModel.Notifier.GetMessage()
if self.commandline().hasOption("test"):
print("I would now send pick", pick.publicID())
else:
if self.connection().send(msg):
print("Succeeded to send pick", pick.publicID())
else:
print("Failed to send pick", pick.publicID())
DataModel.Notifier.Disable()
def run(self):
""" Things to do:
* load event
* load preferred origin without arrivals
* load at least the preferred magnitude if available, all magnitudes if requested
* load focal mechanism incl. moment tensor depending on availability, incl. Mw from derived origin
"""
evid = self.commandline().optionString("event")
# Load event and preferred origin. This is the minimum
# required info and if it can't be loaded, give up.
event = self._loadEvent(evid)
if event is None:
raise ValueError, "unknown event '" + evid + "'"
# preferredOrigin = self._loadOrigin(event.preferredOriginID())
preferredOrigin = self.query().getObject(DataModel.Origin.TypeInfo(),
event.preferredOriginID())
preferredOrigin = DataModel.Origin.Cast(preferredOrigin)
if preferredOrigin is None:
raise ValueError, "unknown origin '" + event.preferredOriginID(
) + "'"
# take care of origin references and leave just one for the preferred origin
while (event.originReferenceCount() > 0):
event.removeOriginReference(0)
if preferredOrigin:
event.add(DataModel.OriginReference(preferredOrigin.publicID()))
if self.commandline().hasOption("comments"):
self.query().loadComments(preferredOrigin)
# load all magnitudes for preferredOrigin
if self.commandline().hasOption("all-magnitudes"):
self.query().loadMagnitudes(preferredOrigin)
magnitudes = [
preferredOrigin.magnitude(i)
for i in range(preferredOrigin.magnitudeCount())
]
else:
magnitudes = []
if event.preferredMagnitudeID():
# try to load from memory
for mag in magnitudes:
if mag.publicID() == event.preferredMagnitudeID():
preferredMagnitude = mag
break
# preferredMagnitude = DataModel.Magnitude.Find(event.preferredMagnitudeID())
else:
# try to load it from database
preferredMagnitude = self._loadMagnitude(
event.preferredMagnitudeID())
else:
preferredMagnitude = None
# try to load focal mechanism, moment tensor, moment magnitude and related origins
momentTensor = momentMagnitude = derivedOrigin = triggeringOrigin = None # default
focalMechanism = self._loadFocalMechanism(
event.preferredFocalMechanismID())
if focalMechanism:
if focalMechanism.triggeringOriginID():
if event.preferredOriginID(
) == focalMechanism.triggeringOriginID():
triggeringOrigin = preferredOrigin
else:
triggeringOrigin = self.query().getObject(
DataModel.Origin.TypeInfo(),
focalMechanism.triggeringOriginID())
triggeringOrigin = DataModel.Origin.Cast(triggeringOrigin)
if focalMechanism.momentTensorCount() > 0:
momentTensor = focalMechanism.momentTensor(
0) # FIXME What if there is more than one MT?
if momentTensor.derivedOriginID():
derivedOrigin = self.query().getObject(
DataModel.Origin.TypeInfo(),
momentTensor.derivedOriginID())
derivedOrigin = DataModel.Origin.Cast(derivedOrigin)
if momentTensor.momentMagnitudeID():
if momentTensor.momentMagnitudeID(
) == event.preferredMagnitudeID():
momentMagnitude = preferredMagnitude
else:
momentMagnitude = self._loadMagnitude(
momentTensor.momentMagnitudeID())
# take care of FocalMechanism and related references
if derivedOrigin:
event.add(DataModel.OriginReference(derivedOrigin.publicID()))
if triggeringOrigin:
if event.preferredOriginID() != triggeringOrigin.publicID():
event.add(
DataModel.OriginReference(triggeringOrigin.publicID()))
while (event.focalMechanismReferenceCount() > 0):
event.removeFocalMechanismReference(0)
if focalMechanism:
event.add(
DataModel.FocalMechanismReference(
focalMechanism.publicID()))
self._removeCommentsIfRequested(focalMechanism)
# strip creation info
if not self.commandline().hasOption("include-full-creation-info"):
self._stripCreationInfo(event)
if focalMechanism:
self._stripCreationInfo(focalMechanism)
for i in xrange(focalMechanism.momentTensorCount()):
self._stripCreationInfo(focalMechanism.momentTensor(i))
for org in [preferredOrigin, triggeringOrigin, derivedOrigin]:
if org is not None:
self._stripCreationInfo(org)
for i in xrange(org.magnitudeCount()):
self._stripCreationInfo(org.magnitude(i))
# populate EventParameters instance
ep = DataModel.EventParameters()
ep.add(event)
if preferredMagnitude and preferredMagnitude is not momentMagnitude:
preferredOrigin.add(preferredMagnitude)
ep.add(preferredOrigin)
if focalMechanism:
if triggeringOrigin:
if triggeringOrigin is not preferredOrigin:
ep.add(triggeringOrigin)
if derivedOrigin:
if momentMagnitude:
derivedOrigin.add(momentMagnitude)
ep.add(derivedOrigin)
ep.add(focalMechanism)
# finally dump event parameters as formatted XML archive to stdout
ar = IO.XMLArchive()
ar.setFormattedOutput(True)
ar.create("-")
ar.writeObject(ep)
ar.close()
del ep
def run(self):
if not self._processCommandLineOptions():
return False
dbq = self.query()
ep = DataModel.EventParameters()
# If we got an event ID as command-line argument...
if self._evid:
# Retrieve event from DB
evt = dbq.loadObject(DataModel.Event.TypeInfo(), self._evid)
evt = DataModel.Event.Cast(evt)
if evt is None:
raise TypeError, "unknown event '" + self._evid + "'"
# If start time was not specified, compute it from origin time.
if self._startTime is None:
orid = evt.preferredOriginID()
org = dbq.loadObject(DataModel.Origin.TypeInfo(), orid)
org = DataModel.Origin.Cast(org)
t0 = org.time().value()
self._startTime = t0 + Core.TimeSpan(-before)
self._endTime = t0 + Core.TimeSpan(after)
print >> sys.stderr, "time window: %s ... %s" % (
self._startTime, self._endTime)
if not self.commandline().hasOption("no-origins"):
# Loop over all origins of the event
for org in dbq.getOrigins(self._evid):
org = DataModel.Origin.Cast(org)
# We only look for manual events.
if org.evaluationMode() != DataModel.MANUAL:
continue
self._orids.append(org.publicID())
# FIRST the pick query loop, THEN the amplitude query loop!
# NESTED QUERY LOOPS ARE NOT ALLOWED!!!
picks = []
for obj in dbq.getPicks(self._startTime, self._endTime):
pick = DataModel.Pick.Cast(obj)
if pick:
if pick.evaluationMode(
) == DataModel.MANUAL and self.commandline().hasOption(
"no-manual-picks"):
continue
if pick.waveformID().networkCode() in self._networkBlacklist:
continue
picks.append(pick)
ep.add(pick)
print >> sys.stderr, "loaded %d picks " % ep.pickCount(
)
for i, pick in enumerate(picks):
# amplitude query loop for each pick, see above comments.
for obj in dbq.getAmplitudesForPick(pick.publicID()):
ampl = DataModel.Amplitude.Cast(obj)
if ampl:
ep.add(ampl)
sys.stderr.write("loaded amplitudes for %d of %d picks\r" %
(i, len(picks)))
print >> sys.stderr, "loaded %d amplitudes " % ep.amplitudeCount(
)
if not self.commandline().hasOption("no-origins"):
for i, orid in enumerate(self._orids):
# XXX There was occasionally a problem with:
# org = dbq.loadObject(DataModel.Origin.TypeInfo(), orid)
# org = DataModel.Origin.Cast(org)
# NOTE when org was directly overwritten.
# resulting in a segfault. The reason is not clear, but
# is most probably in the Python wrapper. The the segfault
# can be avoided by creating an intermediate object 'obj'.
obj = dbq.loadObject(DataModel.Origin.TypeInfo(), orid)
org = DataModel.Origin.Cast(obj)
ep.add(org)
sys.stderr.write("loaded %d of %d manual origins\r" %
(i, len(self._orids)))
print >> sys.stderr, "loaded %d manual origins " % ep.originCount(
)
# finally dump event parameters as formatted XML archive to stdout
ar = IO.XMLArchive()
ar.setFormattedOutput(True)
ar.create("-")
ar.writeObject(ep)
ar.close()
del ep
return True
def sh2proc(self, file):
ep = DataModel.EventParameters()
origin = DataModel.Origin.Create()
event = DataModel.Event.Create()
origin.setCreationInfo(DataModel.CreationInfo())
origin.creationInfo().setCreationTime(Core.Time.GMT())
originQuality = None
originCE = None
latFound = False
lonFound = False
depthError = None
originComments = {}
# variables, reset after 'end of phase'
pick = None
stationMag = None
staCode = None
compCode = None
stationMagBB = None
amplitudeDisp = None
amplitudeVel = None
amplitudeSNR = None
amplitudeBB = None
magnitudeMB = None
magnitudeML = None
magnitudeMS = None
magnitudeBB = None
km2degFac = 1.0 / Math.deg2km(1.0)
# read file line by line, split key and value at colon
iLine = 0
for line in file:
iLine += 1
a = line.split(':', 1)
key = a[0].strip()
keyLower = key.lower()
value = None
# empty line
if len(keyLower) == 0:
continue
# end of phase
elif keyLower == '--- end of phase ---':
if pick is None:
Logging.warning('Line %i: found empty phase block' % iLine)
continue
if staCode is None or compCode is None:
Logging.warning('Line %i: end of phase, stream code '
'incomplete' % iLine)
continue
if staCode not in self.streams:
Logging.warning('Line %i: end of phase, station code %s '
'not found in inventory' % (iLine, staCode))
continue
if compCode not in self.streams[staCode]:
Logging.warning('Line %i: end of phase, component %s of '
'station %s not found in inventory' % (
iLine, compCode, staCode))
continue
streamID = self.streams[staCode][compCode]
pick.setWaveformID(streamID)
ep.add(pick)
arrival.setPickID(pick.publicID())
arrival.setPhase(phase)
origin.add(arrival)
if amplitudeSNR is not None:
amplitudeSNR.setPickID(pick.publicID())
amplitudeSNR.setWaveformID(streamID)
ep.add(amplitudeSNR)
if amplitudeBB is not None:
amplitudeBB.setPickID(pick.publicID())
amplitudeBB.setWaveformID(streamID)
ep.add(amplitudeBB)
if stationMagBB is not None:
stationMagBB.setWaveformID(streamID)
origin.add(stationMagBB)
stationMagContrib = DataModel.StationMagnitudeContribution()
stationMagContrib.setStationMagnitudeID(
stationMagBB.publicID())
if magnitudeBB is None:
magnitudeBB = DataModel.Magnitude.Create()
magnitudeBB.add(stationMagContrib)
if stationMag is not None:
if stationMag.type() in ['mb', 'ML'] and amplitudeDisp is not None:
amplitudeDisp.setPickID(pick.publicID())
amplitudeDisp.setWaveformID(streamID)
amplitudeDisp.setPeriod(
DataModel.RealQuantity(ampPeriod))
amplitudeDisp.setType(stationMag.type())
ep.add(amplitudeDisp)
if stationMag.type() in ['Ms(BB)'] and amplitudeVel is not None:
amplitudeVel.setPickID(pick.publicID())
amplitudeVel.setWaveformID(streamID)
amplitudeVel.setPeriod(
DataModel.RealQuantity(ampPeriod))
amplitudeVel.setType(stationMag.type())
ep.add(amplitudeVel)
stationMag.setWaveformID(streamID)
origin.add(stationMag)
stationMagContrib = DataModel.StationMagnitudeContribution()
stationMagContrib.setStationMagnitudeID(
stationMag.publicID())
magType = stationMag.type()
if magType == 'ML':
if magnitudeML is None:
magnitudeML = DataModel.Magnitude.Create()
magnitudeML.add(stationMagContrib)
elif magType == 'Ms(BB)':
if magnitudeMS is None:
magnitudeMS = DataModel.Magnitude.Create()
magnitudeMS.add(stationMagContrib)
elif magType == 'mb':
if magnitudeMB is None:
magnitudeMB = DataModel.Magnitude.Create()
magnitudeMB.add(stationMagContrib)
pick = None
staCode = None
compCode = None
stationMag = None
stationMagBB = None
amplitudeDisp = None
amplitudeVel = None
amplitudeSNR = None
amplitudeBB = None
continue
# empty key
elif len(a) == 1:
Logging.warning('Line %i: key without value' % iLine)
continue
value = a[1].strip()
if pick is None:
pick = DataModel.Pick.Create()
arrival = DataModel.Arrival()
try:
##############################################################
# station parameters
# station code
if keyLower == 'station code':
staCode = value
# pick time
elif keyLower == 'onset time':
pick.setTime(DataModel.TimeQuantity(self.parseTime(value)))
# pick onset type
elif keyLower == 'onset type':
found = False
for onset in [DataModel.EMERGENT, DataModel.IMPULSIVE,
DataModel.QUESTIONABLE]:
if value == DataModel.EPickOnsetNames_name(onset):
pick.setOnset(onset)
found = True
break
if not found:
raise Exception('Unsupported onset value')
# phase code
elif keyLower == 'phase name':
phase = DataModel.Phase()
phase.setCode(value)
pick.setPhaseHint(phase)
# event type
elif keyLower == 'event type':
evttype = EventTypes[value]
event.setType(evttype)
originComments[key] = value
# filter ID
elif keyLower == 'applied filter':
pick.setFilterID(value)
# channel code, prepended by configured Channel prefix if only
# one character is found
elif keyLower == 'component':
compCode = value
# pick evaluation mode
elif keyLower == 'pick type':
found = False
for mode in [DataModel.AUTOMATIC, DataModel.MANUAL]:
if value == DataModel.EEvaluationModeNames_name(mode):
pick.setEvaluationMode(mode)
found = True
break
if not found:
raise Exception('Unsupported evaluation mode value')
# pick author
elif keyLower == 'analyst':
creationInfo = DataModel.CreationInfo()
creationInfo.setAuthor(value)
pick.setCreationInfo(creationInfo)
# pick polarity
# isn't tested
elif keyLower == 'sign':
if value == 'positive':
sign = '0' # positive
elif value == 'negative':
sign = '1' # negative
else:
sign = '2' # unknown
pick.setPolarity(float(sign))
# arrival weight
elif keyLower == 'weight':
arrival.setWeight(float(value))
# arrival azimuth
elif keyLower == 'theo. azimuth (deg)':
arrival.setAzimuth(float(value))
# pick theo backazimuth
elif keyLower == 'theo. backazimuth (deg)':
if pick.slownessMethodID() == 'corrected':
Logging.debug('Line %i: ignoring parameter: %s' % (
iLine, key))
else:
pick.setBackazimuth(
DataModel.RealQuantity(float(value)))
pick.setSlownessMethodID('theoretical')
# pick beam slowness
elif keyLower == 'beam-slowness (sec/deg)':
if pick.slownessMethodID() == 'corrected':
Logging.debug('Line %i: ignoring parameter: %s' % (
iLine, key))
else:
pick.setHorizontalSlowness(
DataModel.RealQuantity(float(value)))
pick.setSlownessMethodID('Array Beam')
# pick beam backazimuth
elif keyLower == 'beam-azimuth (deg)':
if pick.slownessMethodID() == 'corrected':
Logging.debug('Line %i: ignoring parameter: %s' % (
iLine, key))
else:
pick.setBackazimuth(
DataModel.RealQuantity(float(value)))
# pick epi slowness
elif keyLower == 'epi-slowness (sec/deg)':
pick.setHorizontalSlowness(
DataModel.RealQuantity(float(value)))
pick.setSlownessMethodID('corrected')
# pick epi backazimuth
elif keyLower == 'epi-azimuth (deg)':
pick.setBackazimuth(DataModel.RealQuantity(float(value)))
# arrival distance degree
elif keyLower == 'distance (deg)':
arrival.setDistance(float(value))
# arrival distance km, recalculates for degree
elif keyLower == 'distance (km)':
if isinstance(arrival.distance(), float):
Logging.debug('Line %i: ignoring parameter: %s' % (
iLine-1, 'distance (deg)'))
arrival.setDistance(float(value) * km2degFac)
# arrival time residual
elif keyLower == 'residual time':
arrival.setTimeResidual(float(value))
# amplitude snr
elif keyLower == 'signal/noise':
amplitudeSNR = DataModel.Amplitude.Create()
amplitudeSNR.setType('SNR')
amplitudeSNR.setAmplitude(
DataModel.RealQuantity(float(value)))
# amplitude period
elif keyLower.startswith('period'):
ampPeriod = float(value)
# amplitude value for displacement
elif keyLower == 'amplitude (nm)':
amplitudeDisp = DataModel.Amplitude.Create()
amplitudeDisp.setAmplitude(
DataModel.RealQuantity(float(value)))
amplitudeDisp.setUnit('nm')
# amplitude value for velocity
elif keyLower.startswith('vel. amplitude'):
amplitudeVel = DataModel.Amplitude.Create()
amplitudeVel.setAmplitude(
DataModel.RealQuantity(float(value)))
amplitudeVel.setUnit('nm/s')
elif keyLower == 'bb amplitude (nm/sec)':
amplitudeBB = DataModel.Amplitude.Create()
amplitudeBB.setAmplitude(
DataModel.RealQuantity(float(value)))
amplitudeBB.setType('mB')
amplitudeBB.setUnit('nm/s')
amplitudeBB.setPeriod(DataModel.RealQuantity(ampBBPeriod))
elif keyLower == 'bb period (sec)':
ampBBPeriod = float(value)
elif keyLower == 'broadband magnitude':
magType = self.parseMagType('bb')
stationMagBB = DataModel.StationMagnitude.Create()
stationMagBB.setMagnitude(
DataModel.RealQuantity(float(value)))
stationMagBB.setType(magType)
stationMagBB.setAmplitudeID(amplitudeBB.publicID())
# ignored
elif keyLower == 'quality number':
Logging.debug('Line %i: ignoring parameter: %s' % (
iLine, key))
# station magnitude value and type
elif keyLower.startswith('magnitude '):
magType = self.parseMagType(key[10:])
stationMag = DataModel.StationMagnitude.Create()
stationMag.setMagnitude(
DataModel.RealQuantity(float(value)))
if len(magType) > 0:
stationMag.setType(magType)
if magType == 'mb':
stationMag.setAmplitudeID(amplitudeDisp.publicID())
elif magType == 'MS(BB)':
stationMag.setAmplitudeID(amplitudeVel.publicID())
else:
Logging.debug('Line %i: Magnitude Type not known %s.' % (
iLine, magType))
###############################################################
# origin parameters
# event ID, added as origin comment later on
elif keyLower == 'event id':
originComments[key] = value
# magnitude value and type
elif keyLower == 'mean bb magnitude':
magType = self.parseMagType('bb')
if magnitudeBB is None:
magnitudeBB = DataModel.Magnitude.Create()
magnitudeBB.setMagnitude(
DataModel.RealQuantity(float(value)))
magnitudeBB.setType(magType)
elif keyLower.startswith('mean magnitude '):
magType = self.parseMagType(key[15:])
if magType == 'ML':
if magnitudeML is None:
magnitudeML = DataModel.Magnitude.Create()
magnitudeML.setMagnitude(
DataModel.RealQuantity(float(value)))
magnitudeML.setType(magType)
elif magType == 'Ms(BB)':
if magnitudeMS is None:
magnitudeMS = DataModel.Magnitude.Create()
magnitudeMS.setMagnitude(
DataModel.RealQuantity(float(value)))
magnitudeMS.setType(magType)
elif magType == 'mb':
if magnitudeMB is None:
magnitudeMB = DataModel.Magnitude.Create()
magnitudeMB.setMagnitude(
DataModel.RealQuantity(float(value)))
magnitudeMB.setType(magType)
else:
Logging.warning('Line %i: Magnitude type %s not defined yet.' % (
iLine, magType))
# latitude
elif keyLower == 'latitude':
origin.latitude().setValue(float(value))
latFound = True
elif keyLower == 'error in latitude (km)':
origin.latitude().setUncertainty(float(value))
# longitude
elif keyLower == 'longitude':
origin.longitude().setValue(float(value))
lonFound = True
elif keyLower == 'error in longitude (km)':
origin.longitude().setUncertainty(float(value))
# depth
elif keyLower == 'depth (km)':
origin.setDepth(DataModel.RealQuantity(float(value)))
if depthError is not None:
origin.depth().setUncertainty(depthError)
elif keyLower == 'depth type':
Logging.debug('Line %i: ignoring parameter: %s' % (
iLine, key))
elif keyLower == 'error in depth (km)':
depthError = float(value)
try:
origin.depth().setUncertainty(depthError)
except Core.ValueException:
pass
# time
elif keyLower == 'origin time':
origin.time().setValue(self.parseTime(value))
elif keyLower == 'error in origin time':
origin.time().setUncertainty(float(value))
# location method
elif keyLower == 'location method':
origin.setMethodID(str(value))
# region table, added as origin comment later on
elif keyLower == 'region table':
originComments[key] = value
# region table, added as origin comment later on
elif keyLower == 'region id':
originComments[key] = value
# source region, added as origin comment later on
elif keyLower == 'source region':
originComments[key] = value
# used station count
elif keyLower == 'no. of stations used':
if originQuality is None:
originQuality = DataModel.OriginQuality()
originQuality.setUsedStationCount(int(value))
# ignored
elif keyLower == 'reference location name':
Logging.debug('Line %i: ignoring parameter: %s' % (
iLine, key))
# confidence ellipsoid major axis
elif keyLower == 'error ellipse major':
if originCE is None:
originCE = DataModel.ConfidenceEllipsoid()
originCE.setSemiMajorAxisLength(float(value))
# confidence ellipsoid minor axis
elif keyLower == 'error ellipse minor':
if originCE is None:
originCE = DataModel.ConfidenceEllipsoid()
originCE.setSemiMinorAxisLength(float(value))
# confidence ellipsoid rotation
elif keyLower == 'error ellipse strike':
if originCE is None:
originCE = DataModel.ConfidenceEllipsoid()
originCE.setMajorAxisRotation(float(value))
# azimuthal gap
elif keyLower == 'max azimuthal gap (deg)':
if originQuality is None:
originQuality = DataModel.OriginQuality()
originQuality.setAzimuthalGap(float(value))
# creation info author
elif keyLower == 'author':
origin.creationInfo().setAuthor(value)
# creation info agency
elif keyLower == 'source of information':
origin.creationInfo().setAgencyID(value)
# earth model id
elif keyLower == 'velocity model':
origin.setEarthModelID(value)
# standard error
elif keyLower == 'rms of residuals (sec)':
if originQuality is None:
originQuality = DataModel.OriginQuality()
originQuality.setStandardError(float(value))
# ignored
elif keyLower == 'phase flags':
Logging.debug('Line %i: ignoring parameter: %s' % (
iLine, key))
# ignored
elif keyLower == 'location input params':
Logging.debug('Line %i: ignoring parameter: %s' % (
iLine, key))
# missing keys
elif keyLower == 'ampl&period source':
Logging.debug('Line %i: ignoring parameter: %s' % (
iLine, key))
elif keyLower == 'location quality':
Logging.debug('Line %i: ignoring parameter: %s' % (
iLine, key))
elif keyLower == 'reference latitude':
Logging.debug('Line %i: ignoring parameter: %s' % (
iLine, key))
elif keyLower == 'reference longitude':
Logging.debug('Line %i: ignoring parameter: %s' % (
iLine, key))
elif keyLower.startswith('amplitude time'):
Logging.debug('Line %i: ignoring parameter: %s' % (
iLine, key))
# unknown key
else:
Logging.warning('Line %i: ignoring unknown parameter: %s'
% (iLine, key))
except ValueError as ve:
Logging.warning('Line %i: can not parse %s value' % (
iLine, key))
except Exception:
Logging.error('Line %i: %s' % (iLine,
str(traceback.format_exc())))
return None
# check
if not latFound:
Logging.warning('could not add origin, missing latitude parameter')
elif not lonFound:
Logging.warning(
'could not add origin, missing longitude parameter')
elif not origin.time().value().valid():
Logging.warning(
'could not add origin, missing origin time parameter')
else:
if magnitudeMB is not None:
origin.add(magnitudeMB)
if magnitudeML is not None:
origin.add(magnitudeML)
if magnitudeMS is not None:
origin.add(magnitudeMS)
if magnitudeBB is not None:
origin.add(magnitudeBB)
ep.add(event)
ep.add(origin)
if originQuality is not None:
origin.setQuality(originQuality)
if originCE is not None:
uncertainty = DataModel.OriginUncertainty()
uncertainty.setConfidenceEllipsoid(originCE)
origin.setUncertainty(uncertainty)
for k, v in originComments.items():
comment = DataModel.Comment()
comment.setId(k)
comment.setText(v)
origin.add(comment)
return ep
def _runBatchMode(self):
ep = self._readEventParametersFromXML()
# collect the objects
objs = []
while ep.pickCount() > 0:
# FIXME: The cast hack forces the SC3 refcounter to be increased.
pick = DataModel.Pick.Cast(ep.pick(0))
ep.removePick(0)
objs.append(pick)
while ep.amplitudeCount() > 0:
# FIXME: The cast hack forces the SC3 refcounter to be increased.
ampl = DataModel.Amplitude.Cast(ep.amplitude(0))
ep.removeAmplitude(0)
objs.append(ampl)
while ep.originCount() > 0:
# FIXME: The cast hack forces the SC3 refcounter to be increased.
origin = DataModel.Origin.Cast(ep.origin(0))
ep.removeOrigin(0)
objs.append(origin)
del ep
# DSU sort all objects by object creation time
sortlist = []
for obj in objs:
# discard objects that have no creationInfo attribute
try:
t = obj.creationInfo().creationTime()
except:
continue
if self._startTime is not None and t < self._startTime:
continue
if self._endTime is not None and t > self._endTime:
continue
sortlist.append((t, obj))
sortlist.sort()
time_of_1st_object, obj = sortlist[0]
time_of_playback_start = Core.Time.GMT()
ep = DataModel.EventParameters()
pickampl = {}
# go through the sorted list of object and process them sequentially
for t, obj in sortlist:
if self.isExitRequested(): return
if self.speed:
t = time_of_playback_start + Core.TimeSpan(
float(t - time_of_1st_object) / self.speed)
while t > Core.Time.GMT():
time.sleep(0.1)
if obj.ClassName() not in ["Pick", "Amplitude", "Origin"]:
continue
DataModel.Notifier.Enable()
ep.add(obj)
msg = DataModel.Notifier.GetMessage()
if self.commandline().hasOption("test"):
sys.stderr.write("Test mode - not sending %-10s %s\n" %
(obj.ClassName(), obj.publicID()))
else:
if self.connection().send(msg):
sys.stderr.write("Sent %s %s\n" %
(obj.ClassName(), obj.publicID()))
else:
sys.stderr.write("Failed to send %-10s %s\n" %
(obj.ClassName(), obj.publicID()))
DataModel.Notifier.Disable()
self.sync()
return
def sh2proc(self, file):
ep = DataModel.EventParameters()
magnitude = DataModel.Magnitude.Create()
origin = DataModel.Origin.Create()
origin.setCreationInfo(DataModel.CreationInfo())
origin.creationInfo().setCreationTime(Core.Time.GMT())
originQuality = None
originCE = None
latFound = False
lonFound = False
depthError = None
originComments = {}
# phase variables, reset after 'end of phase'
pick = None
stationMag = None
staCode = None
compCode = None
# read file line by line, split key and value at colon
iLine = 0
for line in file:
iLine += 1
a = line.split(':', 1)
key = a[0].strip()
keyLower = key.lower()
value = None
# empty line
if len(keyLower) == 0:
continue
# end of phase
elif keyLower == '--- end of phase ---':
if pick is None:
Logging.warning('Line %i: found empty phase block' % iLine)
continue
if staCode is None or compCode is None:
Logging.warning('Line %i: end of phase, stream code ' \
'incomplete' % iLine)
continue
if not self.streams.has_key(staCode):
Logging.warning('Line %i: end of phase, station code %s ' \
'not found in inventory' % (iLine, staCode))
continue
if not self.streams[staCode].has_key(compCode):
Logging.warning('Line %i: end of phase, component %s of ' \
'station %s not found in inventory' % (
iLine, compCode, staCode))
continue
streamID = self.streams[staCode][compCode]
pick.setWaveformID(streamID)
ep.add(pick)
arrival.setPickID(pick.publicID())
origin.add(arrival)
amplitude.setPickID(pick.publicID())
ep.add(amplitude)
if stationMag is not None:
stationMag.setWaveformID(streamID)
origin.add(stationMag)
stationMagContrib = DataModel.StationMagnitudeContribution(
)
stationMagContrib.setStationMagnitudeID(
stationMag.publicID())
magnitude.add(stationMagContrib)
pick = None
staCode = None
compCode = None
stationMag = None
continue
# empty key
elif len(a) == 1:
Logging.warning('Line %i: key without value' % iLine)
continue
value = a[1].strip()
if pick is None:
pick = DataModel.Pick.Create()
arrival = DataModel.Arrival()
amplitude = DataModel.Amplitude.Create()
try:
##############################################################
# station parameters
# station code
if keyLower == 'station code':
staCode = value
# pick time
elif keyLower == 'onset time':
pick.setTime(DataModel.TimeQuantity(self.parseTime(value)))
# pick onset type
elif keyLower == 'onset type':
found = False
for onset in [
DataModel.EMERGENT, DataModel.IMPULSIVE,
DataModel.QUESTIONABLE
]:
if value == DataModel.EPickOnsetNames_name(onset):
pick.setOnset(onset)
found = True
break
if not found:
raise Exception('Unsupported onset value')
# phase code
elif keyLower == 'phase name':
phase = DataModel.Phase()
phase.setCode(value)
pick.setPhaseHint(phase)
arrival.setPhase(phase)
# event type, added as origin comment later on
elif keyLower == 'event type':
originComments[key] = value
# filter ID
elif keyLower == 'applied filter':
pick.setFilterID(value)
# channel code, prepended by configured Channel prefix if only
# one character is found
elif keyLower == 'component':
compCode = value
# pick evaluation mode
elif keyLower == 'pick type':
found = False
for mode in [DataModel.AUTOMATIC, DataModel.MANUAL]:
if value == DataModel.EEvaluationModeNames_name(mode):
pick.setEvaluationMode(mode)
found = True
break
if not found:
raise Exception('Unsupported evaluation mode value')
# arrival weight
elif keyLower == 'weight':
arrival.setWeight(float(value))
# arrival azimuth
elif keyLower == 'theo. azimuth (deg)':
arrival.setAzimuth(float(value))
# arrival backazimuth
elif keyLower == 'theo. backazimuth (deg)':
pick.setBackazimuth(DataModel.RealQuantity(float(value)))
# arrival distance
elif keyLower == 'distance (deg)':
arrival.setDistance(float(value))
# ignored
elif keyLower == 'distance (km)':
Logging.debug('Line %i: ignoring parameter: %s' %
(iLine, key))
# arrival time residual
elif keyLower == 'residual time':
arrival.setTimeResidual(float(value))
# ignored
elif keyLower == 'quality number':
Logging.debug('Line %i: ignoring parameter: %s' %
(iLine, key))
# station magnitude value and type
elif keyLower.startswith('magnitude '):
stationMag = DataModel.StationMagnitude.Create()
stationMag.setAmplitudeID(amplitude.publicID())
stationMag.setMagnitude(
DataModel.RealQuantity(float(value)))
magType = self.parseMagType(key[10:])
if len(magType) > 0:
stationMag.setType(magType)
amplitude.setType(magType)
###############################################################
# origin parameters
# event ID, added as origin comment later on
elif keyLower == 'event id':
originComments[key] = value
# magnitude value and type
elif keyLower.startswith('mean magnitude '):
magnitude.setMagnitude(DataModel.RealQuantity(
float(value)))
magType = self.parseMagType(key[15:])
if len(magType) > 0:
magnitude.setType(magType)
# latitude
elif keyLower == 'latitude':
origin.latitude().setValue(float(value))
latFound = True
elif keyLower == 'error in latitude (km)':
origin.latitude().setUncertainty(float(value))
# longitude
elif keyLower == 'longitude':
origin.longitude().setValue(float(value))
lonFound = True
elif keyLower == 'error in longitude (km)':
origin.longitude().setUncertainty(float(value))
# depth
elif keyLower == 'depth (km)':
origin.setDepth(DataModel.RealQuantity(float(value)))
if depthError is not None:
origin.depth().setUncertainty(depthError)
elif keyLower == 'depth type':
Logging.debug('Line %i: ignoring parameter: %s' %
(iLine, key))
elif keyLower == 'error in depth (km)':
depthError = float(value)
try:
origin.depth().setUncertainty(depthError)
except Core.ValueException:
pass
# time
elif keyLower == 'origin time':
origin.time().setValue(self.parseTime(value))
elif keyLower == 'error in origin time':
origin.time().setUncertainty(float(value))
# region table, added as origin comment later on
elif keyLower == 'region table':
originComments[key] = value
# region table, added as origin comment later on
elif keyLower == 'region id':
originComments[key] = value
# source region, added as origin comment later on
elif keyLower == 'source region':
originComments[key] = value
# used station count
elif keyLower == 'no. of stations used':
if originQuality is None:
originQuality = DataModel.OriginQuality()
originQuality.setUsedStationCount(int(value))
# ignored
elif keyLower == 'reference location name':
Logging.debug('Line %i: ignoring parameter: %s' %
(iLine, key))
# confidence ellipsoid major axis
elif keyLower == 'error ellipse major':
if originCE is None:
originCE = DataModel.ConfidenceEllipsoid()
originCE.setSemiMajorAxisLength(float(value))
# confidence ellipsoid minor axis
elif keyLower == 'error ellipse minor':
if originCE is None:
originCE = DataModel.ConfidenceEllipsoid()
originCE.setSemiMinorAxisLength(float(value))
# confidence ellipsoid rotation
elif keyLower == 'error ellipse strike':
if originCE is None:
originCE = DataModel.ConfidenceEllipsoid()
originCE.setMajorAxisRotation(float(value))
# azimuthal gap
elif keyLower == 'max azimuthal gap (deg)':
if originQuality is None:
originQuality = DataModel.OriginQuality()
originQuality.setAzimuthalGap(float(value))
# creation info author
elif keyLower == 'author':
origin.creationInfo().setAuthor(value)
# creation info agency
elif keyLower == 'agency':
origin.creationInfo().setAgencyID(value)
# earth model id
elif keyLower == 'velocity model':
origin.setEarthModelID(value)
# standard error
elif keyLower == 'rms of residuals (sec)':
if originQuality is None:
originQuality = DataModel.OriginQuality()
originQuality.setStandardError(float(value))
# ignored
elif keyLower == 'phase flags':
Logging.debug('Line %i: ignoring parameter: %s' %
(iLine, key))
# ignored
elif keyLower == 'location input params':
Logging.debug('Line %i: ignoring parameter: %s' %
(iLine, key))
# unknown key
else:
Logging.warning('Line %i: ignoring unknown parameter: %s' \
% (iLine, key))
except ValueError, ve:
Logging.warning('Line %i: can not parse %s value' %
(iLine, key))
except Exception:
Logging.error('Line %i: %s' %
(iLine, str(traceback.format_exc())))
return None
