Merge branch 'feature/magnitude4QtPyLoT' into develop

Conflicts:
	pylot/core/analysis/magnitude.py
	pylot/core/util/widgets.py

pylot/RELEASE-VERSION

@@ -1 +1 @@
-55a58-dirty
+5f92-dirty

pylot/core/active/seismicArrayPreparation.py

@@ -3,6 +3,41 @@ import sys
 import numpy as np
 from scipy.interpolate import griddata
 
+def readMygridNlayers(filename):
+    infile = open(filename, 'r')
+    nlayers = len(infile.readlines()) / 2
+    infile.close()
+
+    return nlayers
+
+def readMygrid(filename):
+    ztop = [];
+    zbot = [];
+    vtop = [];
+    vbot = []
+    infile = open(filename, 'r')
+    nlayers = readMygridNlayers(filename)
+
+    print('\nreadMygrid: Reading file %s.' % filename)
+    for index in range(nlayers):
+        line1 = infile.readline()
+        line2 = infile.readline()
+        ztop.append(float(line1.split()[0]))
+        vtop.append(float(line1.split()[1]))
+        zbot.append(float(line2.split()[0]))
+        vbot.append(float(line2.split()[1]))
+        print('Layer %s:\n[Top: v = %s [km/s], z = %s [m]]'
+              '\n[Bot: v = %s [km/s], z = %s [m]]'
+              % (index + 1, vtop[index], ztop[index],
+                 vbot[index], zbot[index]))
+
+    if not ztop[0] == 0:
+        print('ERROR: there must be a velocity set for z = 0 in the file %s' % filename)
+        print('e.g.:\n0    0.33\n-5    1.0\netc.')
+
+    infile.close()
+    return ztop, zbot, vtop, vbot
+
 
 class SeisArray(object):
     '''
@@ -714,41 +749,6 @@ class SeisArray(object):
         #     rad = angle / 180 * PI
         #     return rad
 
-        def readMygridNlayers(filename):
-            infile = open(filename, 'r')
-            nlayers = len(infile.readlines()) / 2
-            infile.close()
-
-            return nlayers
-
-        def readMygrid(filename):
-            ztop = [];
-            zbot = [];
-            vtop = [];
-            vbot = []
-            infile = open(filename, 'r')
-            nlayers = readMygridNlayers(filename)
-
-            print('\nreadMygrid: Reading file %s.' % filename)
-            for index in range(nlayers):
-                line1 = infile.readline()
-                line2 = infile.readline()
-                ztop.append(float(line1.split()[0]))
-                vtop.append(float(line1.split()[1]))
-                zbot.append(float(line2.split()[0]))
-                vbot.append(float(line2.split()[1]))
-                print('Layer %s:\n[Top: v = %s [km/s], z = %s [m]]'
-                      '\n[Bot: v = %s [km/s], z = %s [m]]'
-                      % (index + 1, vtop[index], ztop[index],
-                         vbot[index], zbot[index]))
-
-            if not ztop[0] == 0:
-                print('ERROR: there must be a velocity set for z = 0 in the file %s' % filename)
-                print('e.g.:\n0    0.33\n-5    1.0\netc.')
-
-            infile.close()
-            return ztop, zbot, vtop, vbot
-
         R = 6371.
         vmin = 0.34
         decm = 0.3  # diagonal elements of the covariance matrix (grid3dg's default value is 0.3)

pylot/core/analysis/magnitude.py

@@ -6,214 +6,261 @@ Created autumn/winter 2015.
 :author: Ludger Küperkoch / MAGS2 EP3 working group
 """
 import os
+
 import matplotlib.pyplot as plt
 import numpy as np
-from obspy.core import Stream, UTCDateTime
-from pylot.core.pick.utils import getsignalwin, crossings_nonzero_all
-from pylot.core.util.utils import getPatternLine
-from scipy.optimize import curve_fit
+import obspy.core.event as ope
+from obspy.geodetics import degrees2kilometers
 from scipy import integrate, signal
-from pylot.core.io.data import Data
-from pylot.core.util.dataprocessing import restitute_data, read_metadata
+from scipy.optimize import curve_fit
+
+from pylot.core.pick.utils import getsignalwin, crossings_nonzero_all, \
+    select_for_phase
 from pylot.core.util.utils import common_range, fit_curve
 
+
 def richter_magnitude_scaling(delta):
     relation = np.loadtxt(os.path.join(os.path.expanduser('~'),
-                            '.pylot', 'richter_scaling.data'))
+                                       '.pylot', 'richter_scaling.data'))
     # prepare spline interpolation to calculate return value
-    func, params = fit_curve(relation[:,0], relation[:, 1])
+    func, params = fit_curve(relation[:, 0], relation[:, 1])
     return func(delta, params)
 
+
 class Magnitude(object):
-    '''
-    Superclass for calculating Wood-Anderson peak-to-peak
-    amplitudes, local magnitudes, source spectra, seismic moments
-    and moment magnitudes.
-    '''
+    """
+    Base class object for Magnitude calculation within PyLoT.
+    """
 
-    def __init__(self, wfstream, To, pwin, iplot, NLLocfile=None, \
-                 picks=None, rho=None, vp=None, Qp=None, invdir=None):
-        '''
-        :param: wfstream
-        :type: `~obspy.core.stream.Stream
+    def __init__(self, stream, event, verbosity=False, iplot=0):
+        self._type = "M"
+        self._plot_flag = iplot
+        self._verbosity = verbosity
+        self._event = event
+        self._stream = stream
+        self._magnitudes = dict()
 
-        :param: To, onset time, P- or S phase
-        :type:  float
+    def __str__(self):
+        print(
+        'number of stations used: {0}\n'.format(len(self.magnitudes.values())))
+        print('\tstation\tmagnitude')
+        for s, m in self.magnitudes.items(): print('\t{0}\t{1}'.format(s, m))
 
-        :param: pwin, pick window [To To+pwin] to get maximum
-                peak-to-peak amplitude (WApp) or to calculate
-                source spectrum (DCfc) around P onset
-        :type:  float
+    def __nonzero__(self):
+        return bool(self.magnitudes)
 
-        :param: iplot, no. of figure window for plotting interims results
-        :type:  integer
+    @property
+    def type(self):
+        return self._type
 
-        :param: NLLocfile, name and full path to NLLoc-location file
-                needed when calling class MoMw
-        :type:  string
+    @property
+    def plot_flag(self):
+        return self._plot_flag
 
-        :param: picks, dictionary containing picking results
-        :type:  dictionary
+    @plot_flag.setter
+    def plot_flag(self, value):
+        self._plot_flag = value
 
-        :param: rho [kg/m³], rock density, parameter from autoPyLoT.in
-        :type:  integer
+    @property
+    def verbose(self):
+        return self._verbosity
 
-        :param: vp [m/s], P-velocity
-        :param: integer
+    @verbose.setter
+    def verbose(self, value):
+        if not isinstance(value, bool):
+            print('WARNING: only boolean values accepted...\n')
+            value = bool(value)
+        self._verbosity = value
 
-        :param: invdir, name and path to inventory or dataless-SEED file
-        :type:  string
-        '''
+    @property
+    def stream(self):
+        return self._stream
 
-        assert isinstance(wfstream, Stream), "%s is not a stream object" % str(wfstream)
+    @stream.setter
+    def stream(self, value):
+        self._stream = value
 
-        self.setwfstream(wfstream)
-        self.setTo(To)
-        self.setpwin(pwin)
-        self.setiplot(iplot)
-        self.setNLLocfile(NLLocfile)
-        self.setrho(rho)
-        self.setpicks(picks)
-        self.setvp(vp)
-        self.setQp(Qp)
-        self.setinvdir(invdir)
-        self.calcwapp()
-        self.calcsourcespec()
-        self.run_calcMoMw()
+    @property
+    def event(self):
+        return self._event
 
-    def getwfstream(self):
-        return self.wfstream
+    @property
+    def origin_id(self):
+        return self._event.origins[0].resource_id
 
-    def setwfstream(self, wfstream):
-        self.wfstream = wfstream
+    @property
+    def arrivals(self):
+        return self._event.origins[0].arrivals
 
-    def getTo(self):
-        return self.To
+    @property
+    def magnitudes(self):
+        return self._magnitudes
 
-    def setTo(self, To):
-        self.To = To
+    @magnitudes.setter
+    def magnitudes(self, value):
+        """
+        takes a tuple and saves the key value pair to private
+        attribute _magnitudes
+        :param value: station, magnitude value pair
+        :type value: tuple or list
+        :return:
+        """
+        station, magnitude = value
+        self._magnitudes[station] = magnitude
 
-    def getpwin(self):
-        return self.pwin
+    def calc(self):
+        pass
 
-    def setpwin(self, pwin):
-        self.pwin = pwin
+    def updated_event(self):
+        self.event.magnitudes.append(self.net_magnitude())
+        return self.event
 
-    def getiplot(self):
-        return self.iplot
-
-    def setiplot(self, iplot):
-        self.iplot = iplot
-
-    def setNLLocfile(self, NLLocfile):
-        self.NLLocfile = NLLocfile
-
-    def getNLLocfile(self):
-        return self.NLLocfile
-
-    def setrho(self, rho):
-        self.rho = rho
-
-    def getrho(self):
-        return self.rho
-
-    def setvp(self, vp):
-        self.vp = vp
-
-    def getvp(self):
-        return self.vp
-
-    def setQp(self, Qp):
-        self.Qp = Qp
-
-    def getQp(self):
-        return self.Qp
-
-    def setpicks(self, picks):
-        self.picks = picks
-
-    def getpicks(self):
-        return self.picks
-
-    def getwapp(self):
-        return self.wapp
-
-    def getw0(self):
-        return self.w0
-
-    def getfc(self):
-        return self.fc
-
-    def setinvdir(self, invdir):
-        self.invdir = invdir
-
-    def get_metadata(self):
-        return read_metadata(self.invdir)
-
-    def getpicdic(self):
-        return self.picdic
-
-    def calcwapp(self):
-        self.wapp = None
-
-    def calcsourcespec(self):
-        self.sourcespek = None
-
-    def run_calcMoMw(self):
-        self.pickdic = None
+    def net_magnitude(self):
+        if self:
+            # TODO if an average Magnitude instead of the median is calculated
+            # StationMagnitudeContributions should be added to the returned
+            # Magnitude object
+            # mag_error => weights (magnitude error estimate from peak_to_peak, calcsourcespec?)
+            # weights => StationMagnitdeContribution
+            mag = ope.Magnitude(
+                mag=np.median([M.mag for M in self.magnitudes.values()]),
+                magnitude_type=self.type,
+                origin_id=self.origin_id,
+                station_count=len(self.magnitudes),
+                azimuthal_gap=self.origin_id.get_referred_object().quality.azimuthal_gap)
+            return mag
+        return None
 
 
-class WApp(Magnitude):
-    '''
+class RichterMagnitude(Magnitude):
+    """
     Method to derive peak-to-peak amplitude as seen on a Wood-Anderson-
     seismograph. Has to be derived from instrument corrected traces!
-    '''
+    """
 
-    def calcwapp(self):
-        print ("Getting Wood-Anderson peak-to-peak amplitude ...")
-        print ("Simulating Wood-Anderson seismograph ...")
+    # poles, zeros and sensitivity of WA seismograph
+    # (see Uhrhammer & Collins, 1990, BSSA, pp. 702-716)
+    _paz = {
+        'poles': [5.6089 - 5.4978j, -5.6089 - 5.4978j],
+        'zeros': [0j, 0j],
+        'gain': 2080,
+        'sensitivity': 1
+    }
 
-        self.wapp = None
-        stream = self.getwfstream()
+    _amplitudes = dict()
 
-        # poles, zeros and sensitivity of WA seismograph
-        # (see Uhrhammer & Collins, 1990, BSSA, pp. 702-716)
-        paz_wa = {
-            'poles': [5.6089 - 5.4978j, -5.6089 - 5.4978j],
-            'zeros': [0j, 0j],
-            'gain': 2080,
-            'sensitivity': 1}
+    def __init__(self, stream, event, calc_win, verbosity=False, iplot=0):
+        super(RichterMagnitude, self).__init__(stream, event, verbosity, iplot)
 
-        stream.simulate(paz_remove=None, paz_simulate=paz_wa)
+        self._calc_win = calc_win
+        self._type = 'ML'
+        self.calc()
+
+    @property
+    def calc_win(self):
+        return self._calc_win
+
+    @calc_win.setter
+    def calc_win(self, value):
+        self._calc_win = value
+
+    @property
+    def amplitudes(self):
+        return self._amplitudes
+
+    @amplitudes.setter
+    def amplitudes(self, value):
+        station, a0 = value
+        self._amplitudes[station] = a0
+
+    def peak_to_peak(self, st, t0):
+
+        # simulate Wood-Anderson response
+        st.simulate(paz_remove=None, paz_simulate=self._paz)
+
+        # trim waveform to common range
+        stime, etime = common_range(st)
+        st.trim(stime, etime)
+
+        # get time delta from waveform data
+        dt = st[0].stats.delta
+
+        power = [np.power(tr.data, 2) for tr in st if tr.stats.channel[-1] not
+                 in 'Z3']
+        if len(power) != 2:
+            raise ValueError('Wood-Anderson amplitude defintion only valid for '
+                             'two horizontals: {0} given'.format(len(power)))
+        power_sum = power[0] + power[1]
+        #
+        sqH = np.sqrt(power_sum)
 
-        trH1 = stream[0].data
-        trH2 = stream[1].data
-        ilen = min([len(trH1), len(trH2)])
-        # get RMS of both horizontal components
-        sqH = np.sqrt(np.power(trH1[0:ilen], 2) + np.power(trH2[0:ilen], 2))
         # get time array
-        th = np.arange(0, len(sqH) * stream[0].stats.delta, stream[0].stats.delta)
+        th = np.arange(0, len(sqH) * dt, dt)
         # get maximum peak within pick window
-        iwin = getsignalwin(th, self.getTo(), self.getpwin())
-        self.wapp = np.max(sqH[iwin])
-        print ("Determined Wood-Anderson peak-to-peak amplitude: %f mm") % self.wapp
+        iwin = getsignalwin(th, t0 - stime, self.calc_win)
+        wapp = np.max(sqH[iwin])
+        if self.verbose:
+            print("Determined Wood-Anderson peak-to-peak amplitude: {0} "
+                  "mm".format(wapp))
 
-        if self.getiplot() > 1:
-            stream.plot()
+        # check for plot flag (for debugging only)
+        if self.plot_flag > 1:
+            st.plot()
             f = plt.figure(2)
             plt.plot(th, sqH)
             plt.plot(th[iwin], sqH[iwin], 'g')
-            plt.plot([self.getTo(), self.getTo()], [0, max(sqH)], 'r', linewidth=2)
-            plt.title('Station %s, RMS Horizontal Traces, WA-peak-to-peak=%4.1f mm' \
-                      % (stream[0].stats.station, self.wapp))
+            plt.plot([t0, t0], [0, max(sqH)], 'r', linewidth=2)
+            plt.title(
+                'Station %s, RMS Horizontal Traces, WA-peak-to-peak=%4.1f mm' \
+                % (st[0].stats.station, wapp))
             plt.xlabel('Time [s]')
             plt.ylabel('Displacement [mm]')
             plt.show()
             raw_input()
             plt.close(f)
 
+        return wapp
 
-class M0Mw(Magnitude):
+    def calc(self):
+        for a in self.arrivals:
+            if a.phase not in 'sS':
+                continue
+            pick = a.pick_id.get_referred_object()
+            station = pick.waveform_id.station_code
+            wf = select_for_phase(self.stream.select(
+                station=station), a.phase)
+            if not wf:
+                if self.verbose:
+                    print(
+                    'WARNING: no waveform data found for station {0}'.format(
+                        station))
+                continue
+            delta = degrees2kilometers(a.distance)
+            onset = pick.time
+            a0 = self.peak_to_peak(wf, onset)
+            amplitude = ope.Amplitude(generic_amplitude=a0 * 1e-3)
+            amplitude.unit = 'm'
+            amplitude.category = 'point'
+            amplitude.waveform_id = pick.waveform_id
+            amplitude.magnitude_hint = self.type
+            amplitude.pick_id = pick.resource_id
+            amplitude.type = 'AML'
+            self.event.amplitudes.append(amplitude)
+            self.amplitudes = (station, amplitude)
+            # using standard Gutenberg-Richter relation
+            # TODO make the ML calculation more flexible by allowing
+            # use of custom relation functions
+            magnitude = ope.StationMagnitude(
+                mag=np.log10(a0) + richter_magnitude_scaling(delta))
+            magnitude.origin_id = self.origin_id
+            magnitude.waveform_id = pick.waveform_id
+            magnitude.amplitude_id = amplitude.resource_id
+            magnitude.station_magnitude_type = self.type
+            self.event.station_magnitudes.append(magnitude)
+            self.magnitudes = (station, magnitude)
+
+
+class MomentMagnitude(Magnitude):
     '''
     Method to calculate seismic moment Mo and moment magnitude Mw.
     Requires results of class calcsourcespec for calculating plateau w0
@@ -223,55 +270,82 @@ class M0Mw(Magnitude):
     corresponding moment magntiude Mw.
     '''
 
-    def run_calcMoMw(self):
+    _props = dict()
 
-        picks = self.getpicks()
-        nllocfile = self.getNLLocfile()
-        wfdat = self.getwfstream()
-        self.picdic = None
+    def __init__(self, stream, event, vp, Qp, density, verbosity=False,
+                 iplot=False):
+        super(MomentMagnitude, self).__init__(stream, event, verbosity, iplot)
 
-        for key in picks:
-            if picks[key]['P']['weight'] < 4:
-                # select waveform
-                selwf = wfdat.select(station=key)
-                if len(key) > 4:
-                    Ppattern = '%s  ?    ?    ? P' % key
-                elif len(key) == 4:
-                    Ppattern = '%s   ?    ?    ? P' % key
-                elif len(key) < 4:
-                    Ppattern = '%s    ?    ?    ? P' % key
-                nllocline = getPatternLine(nllocfile, Ppattern)
-                # get hypocentral distance, station azimuth and
-                # angle of incidence from NLLoc-location file
-                delta = float(nllocline.split(None)[21])
-                az = float(nllocline.split(None)[22])
-                inc = float(nllocline.split(None)[24])
-                # call subfunction to estimate source spectrum
-                # and to derive w0 and fc
-                [w0, fc] = calcsourcespec(selwf, picks[key]['P']['mpp'], \
-                                          self.get_metadata(), self.getvp(), delta, az, \
-                                          inc, self.getQp(), self.getiplot())
+        self._vp = vp
+        self._Qp = Qp
+        self._density = density
+        self._type = 'Mw'
+        self.calc()
 
-                if w0 is not None:
-                    # call subfunction to calculate Mo and Mw
-                    zdat = selwf.select(component="Z")
-                    if len(zdat) == 0:  # check for other components
-                        zdat = selwf.select(component="3")
-                    [Mo, Mw] = calcMoMw(zdat, w0, self.getrho(), self.getvp(),
-                                        delta)
-                else:
-                    Mo = None
-                    Mw = None
+    @property
+    def p_velocity(self):
+        return self._vp
 
-                # add w0, fc, Mo and Mw to dictionary
-                picks[key]['P']['w0'] = w0
-                picks[key]['P']['fc'] = fc
-                picks[key]['P']['Mo'] = Mo
-                picks[key]['P']['Mw'] = Mw
-                self.picdic = picks
+    @property
+    def p_attenuation(self):
+        return self._Qp
+
+    @property
+    def rock_density(self):
+        return self._density
+
+    @property
+    def moment_props(self):
+        return self._props
+
+    @moment_props.setter
+    def moment_props(self, value):
+        station, props = value
+        self._props[station] = props
+
+    @property
+    def seismic_moment(self):
+        return self._m0
+
+    @seismic_moment.setter
+    def seismic_moment(self, value):
+        self._m0 = value
+
+    def calc(self):
+        for a in self.arrivals:
+            if a.phase not in 'pP':
+                continue
+            pick = a.pick_id.get_referred_object()
+            station = pick.waveform_id.station_code
+            wf = select_for_phase(self.stream.select(
+                station=station), a.phase)
+            if not wf:
+                continue
+            onset = pick.time
+            distance = degrees2kilometers(a.distance)
+            azimuth = a.azimuth
+            incidence = a.takeoff_angle
+            w0, fc = calcsourcespec(wf, onset, self.p_velocity, distance,
+                                    azimuth,
+                                    incidence, self.p_attenuation,
+                                    self.plot_flag, self.verbose)
+            if w0 is None or fc is None:
+                if self.verbose:
+                    print("WARNING: insufficient frequency information")
+                continue
+            wf = select_for_phase(wf, "P")
+            m0, mw = calcMoMw(wf, w0, self.rock_density, self.p_velocity,
+                              distance, self.verbose)
+            self.moment_props = (station, dict(w0=w0, fc=fc, Mo=m0))
+            magnitude = ope.StationMagnitude(mag=mw)
+            magnitude.origin_id = self.origin_id
+            magnitude.waveform_id = pick.waveform_id
+            magnitude.station_magnitude_type = self.type
+            self.event.station_magnitudes.append(magnitude)
+            self.magnitudes = (station, magnitude)
 
 
-def calcMoMw(wfstream, w0, rho, vp, delta):
+def calcMoMw(wfstream, w0, rho, vp, delta, verbosity=False):
     '''
     Subfunction of run_calcMoMw to calculate individual
     seismic moments and corresponding moment magnitudes.
@@ -295,11 +369,14 @@ def calcMoMw(wfstream, w0, rho, vp, delta):
     tr = wfstream[0]
     delta = delta * 1000  # hypocentral distance in [m]
 
-    print("calcMoMw: Calculating seismic moment Mo and moment magnitude Mw for station %s ..." \
-          % tr.stats.station)
+    if verbosity:
+        print(
+        "calcMoMw: Calculating seismic moment Mo and moment magnitude Mw for station {0} ...".format(
+            tr.stats.station))
 
     # additional common parameters for calculating Mo
-    rP = 2 / np.sqrt(15)  # average radiation pattern of P waves (Aki & Richards, 1980)
+    rP = 2 / np.sqrt(
+        15)  # average radiation pattern of P waves (Aki & Richards, 1980)
     freesurf = 2.0  # free surface correction, assuming vertical incidence
 
     Mo = w0 * 4 * np.pi * rho * np.power(vp, 3) * delta / (rP * freesurf)
@@ -307,13 +384,16 @@ def calcMoMw(wfstream, w0, rho, vp, delta):
     # Mw = np.log10(Mo * 1e07) * 2 / 3 - 10.7 # after Hanks & Kanamori (1979), defined for [dyn*cm]!
     Mw = np.log10(Mo) * 2 / 3 - 6.7  # for metric units
 
-    print("calcMoMw: Calculated seismic moment Mo = %e Nm => Mw = %3.1f " % (Mo, Mw))
+    if verbosity:
+        print(
+        "calcMoMw: Calculated seismic moment Mo = {0} Nm => Mw = {1:3.1f} ".format(
+            Mo, Mw))
 
     return Mo, Mw
 
 
-def calcsourcespec(wfstream, onset, metadata, vp, delta, azimuth, incidence,
-                   qp, iplot):
+def calcsourcespec(wfstream, onset, vp, delta, azimuth, incidence,
+                   qp, iplot=0, verbosity=False):
     '''
     Subfunction to calculate the source spectrum and to derive from that the plateau
     (usually called omega0) and the corner frequency assuming Aki's omega-square
@@ -321,16 +401,12 @@ def calcsourcespec(wfstream, onset, metadata, vp, delta, azimuth, incidence,
     thus restitution and integration necessary! Integrated traces are rotated
     into ray-coordinate system ZNE => LQT using Obspy's rotate modul!
 
-    :param: wfstream
+    :param: wfstream (corrected for instrument)
     :type:  `~obspy.core.stream.Stream`
 
     :param: onset, P-phase onset time
     :type: float
 
-    :param: metadata, tuple or list containing type of inventory and either
-    list of files or inventory object
-    :type:  tuple or list
-
     :param: vp, Vp-wave velocity
     :type:  float
 
@@ -349,169 +425,162 @@ def calcsourcespec(wfstream, onset, metadata, vp, delta, azimuth, incidence,
     :param: iplot, show results (iplot>1) or not (iplot<1)
     :type:  integer
     '''
-    print ("Calculating source spectrum ....")
+    if verbosity:
+        print ("Calculating source spectrum ....")
 
     # get Q value
     Q, A = qp
 
-    delta = delta * 1000  # hypocentral distance in [m]
+    dist = delta * 1000  # hypocentral distance in [m]
 
     fc = None
     w0 = None
-    data = Data()
-    wf_copy = wfstream.copy()
 
-    invtype, inventory = metadata
+    zdat = select_for_phase(wfstream, "P")
 
-    [cordat, restflag] = restitute_data(wf_copy, invtype, inventory)
-    if restflag is True:
-        zdat = cordat.select(component="Z")
-        if len(zdat) == 0:
-            zdat = cordat.select(component="3")
-        cordat_copy = cordat.copy()
-        # get equal time stamps and lengths of traces
-        # necessary for rotation of traces
-        trstart, trend = common_range(cordat_copy)
-        cordat_copy.trim(trstart, trend)
-        try:
-            # rotate into LQT (ray-coordindate-) system using Obspy's rotate
-            # L: P-wave direction
-            # Q: SV-wave direction
-            # T: SH-wave direction
-            LQT = cordat_copy.rotate('ZNE->LQT', azimuth, incidence)
-            ldat = LQT.select(component="L")
-            if len(ldat) == 0:
-                # if horizontal channels are 2 and 3
-                # no azimuth information is available and thus no
-                # rotation is possible!
-                print("calcsourcespec: Azimuth information is missing, "
-                      "no rotation of components possible!")
-                ldat = LQT.select(component="Z")
+    dt = zdat[0].stats.delta
 
-            # integrate to displacement
-            # unrotated vertical component (for copmarison)
-            inttrz = signal.detrend(integrate.cumtrapz(zdat[0].data, None,
-                                                       zdat[0].stats.delta))
-            # rotated component Z => L
-            Ldat = signal.detrend(integrate.cumtrapz(ldat[0].data, None,
-                                                     ldat[0].stats.delta))
+    freq = zdat[0].stats.sampling_rate
 
-            # get window after P pulse for
-            # calculating source spectrum 
-            tstart = UTCDateTime(zdat[0].stats.starttime)
-            tonset = onset.timestamp - tstart.timestamp
-            impickP = tonset * zdat[0].stats.sampling_rate
-            wfzc = Ldat[impickP: len(Ldat) - 1]
-            # get time array
-            t = np.arange(0, len(inttrz) * zdat[0].stats.delta, \
-                          zdat[0].stats.delta)
-            # calculate spectrum using only first cycles of
-            # waveform after P onset!
-            zc = crossings_nonzero_all(wfzc)
-            if np.size(zc) == 0 or len(zc) <= 3:
-                print ("calcsourcespec: Something is wrong with the waveform, "
-                       "no zero crossings derived!")
-                print ("No calculation of source spectrum possible!")
-                plotflag = 0
-            else:
-                plotflag = 1
-                index = min([3, len(zc) - 1])
-                calcwin = (zc[index] - zc[0]) * zdat[0].stats.delta
-                iwin = getsignalwin(t, tonset, calcwin)
-                xdat = Ldat[iwin]
+    # trim traces to common range (for rotation)
+    trstart, trend = common_range(wfstream)
+    wfstream.trim(trstart, trend)
 
-                # fft
-                fny = zdat[0].stats.sampling_rate / 2
-                l = len(xdat) / zdat[0].stats.sampling_rate
-                # number of fft bins after Bath
-                n = zdat[0].stats.sampling_rate * l
-                # find next power of 2 of data length
-                m = pow(2, np.ceil(np.log(len(xdat)) / np.log(2)))
-                N = int(np.power(m, 2))
-                y = zdat[0].stats.delta * np.fft.fft(xdat, N)
-                Y = abs(y[: N / 2])
-                L = (N - 1) / zdat[0].stats.sampling_rate
-                f = np.arange(0, fny, 1 / L)
+    # rotate into LQT (ray-coordindate-) system using Obspy's rotate
+    # L: P-wave direction
+    # Q: SV-wave direction
+    # T: SH-wave direction
+    LQT = wfstream.rotate('ZNE->LQT', azimuth, incidence)
+    ldat = LQT.select(component="L")
+    if len(ldat) == 0:
+        # if horizontal channels are 2 and 3
+        # no azimuth information is available and thus no
+        # rotation is possible!
+        if verbosity:
+            print("calcsourcespec: Azimuth information is missing, "
+                  "no rotation of components possible!")
+        ldat = LQT.select(component="Z")
 
-                # remove zero-frequency and frequencies above
-                # corner frequency of seismometer (assumed
-                # to be 100 Hz)
-                fi = np.where((f >= 1) & (f < 100))
-                F = f[fi]
-                YY = Y[fi]
+    # integrate to displacement
+    # unrotated vertical component (for comparison)
+    inttrz = signal.detrend(integrate.cumtrapz(zdat[0].data, None, dt))
 
-                # correction for attenuation
-                wa = 2 * np.pi * F  # angular frequency
-                D = np.exp((wa * delta) / (2 * vp * Q * F ** A))
-                YYcor = YY.real * D
+    # rotated component Z => L
+    Ldat = signal.detrend(integrate.cumtrapz(ldat[0].data, None, dt))
 
-                # get plateau (DC value) and corner frequency
-                # initial guess of plateau
-                w0in = np.mean(YYcor[0:100])
-                # initial guess of corner frequency
-                # where spectral level reached 50% of flat level
-                iin = np.where(YYcor >= 0.5 * w0in)
-                Fcin = F[iin[0][np.size(iin) - 1]]
+    # get window after P pulse for
+    # calculating source spectrum
+    rel_onset = onset - trstart
+    impickP = int(rel_onset * freq)
+    wfzc = Ldat[impickP: len(Ldat) - 1]
+    # get time array
+    t = np.arange(0, len(inttrz) * dt, dt)
+    # calculate spectrum using only first cycles of
+    # waveform after P onset!
+    zc = crossings_nonzero_all(wfzc)
+    if np.size(zc) == 0 or len(zc) <= 3:
+        if verbosity:
+            print ("calcsourcespec: Something is wrong with the waveform, "
+                   "no zero crossings derived!\n")
+            print ("No calculation of source spectrum possible!")
+        plotflag = 0
+    else:
+        plotflag = 1
+        index = min([3, len(zc) - 1])
+        calcwin = (zc[index] - zc[0]) * dt
+        iwin = getsignalwin(t, rel_onset, calcwin)
+        xdat = Ldat[iwin]
 
-                # use of implicit scipy otimization function
-                fit = synthsourcespec(F, w0in, Fcin)
-                [optspecfit, _] = curve_fit(synthsourcespec, F, YYcor, [w0in,
-                                                                        Fcin])
-                w01 = optspecfit[0]
-                fc1 = optspecfit[1]
-                print ("calcsourcespec: Determined w0-value: %e m/Hz, \n"
-                       "Determined corner frequency: %f Hz" % (w01, fc1))
+        # fft
+        fny = freq / 2
+        l = len(xdat) / freq
+        # number of fft bins after Bath
+        n = freq * l
+        # find next power of 2 of data length
+        m = pow(2, np.ceil(np.log(len(xdat)) / np.log(2)))
+        N = int(np.power(m, 2))
+        y = dt * np.fft.fft(xdat, N)
+        Y = abs(y[: N / 2])
+        L = (N - 1) / freq
+        f = np.arange(0, fny, 1 / L)
 
-                # use of conventional fitting
-                [w02, fc2] = fitSourceModel(F, YYcor, Fcin, iplot)
+        # remove zero-frequency and frequencies above
+        # corner frequency of seismometer (assumed
+        # to be 100 Hz)
+        fi = np.where((f >= 1) & (f < 100))
+        F = f[fi]
+        YY = Y[fi]
 
-                # get w0 and fc as median of both
-                # source spectrum fits
-                w0 = np.median([w01, w02])
-                fc = np.median([fc1, fc2])
-                print("calcsourcespec: Using w0-value = %e m/Hz and fc = %f Hz" % (w0, fc))
+        # correction for attenuation
+        wa = 2 * np.pi * F  # angular frequency
+        D = np.exp((wa * dist) / (2 * vp * Q * F ** A))
+        YYcor = YY.real * D
 
-        except TypeError as er:
-            raise TypeError('''{0}'''.format(er))
+        # get plateau (DC value) and corner frequency
+        # initial guess of plateau
+        w0in = np.mean(YYcor[0:100])
+        # initial guess of corner frequency
+        # where spectral level reached 50% of flat level
+        iin = np.where(YYcor >= 0.5 * w0in)
+        Fcin = F[iin[0][np.size(iin) - 1]]
 
-        if iplot > 1:
-            f1 = plt.figure()
-            tLdat = np.arange(0, len(Ldat) * zdat[0].stats.delta, \
-                              zdat[0].stats.delta)
-            plt.subplot(2, 1, 1)
-            # show displacement in mm
-            p1, = plt.plot(t, np.multiply(inttrz, 1000), 'k')
-            p2, = plt.plot(tLdat, np.multiply(Ldat, 1000))
-            plt.legend([p1, p2], ['Displacement', 'Rotated Displacement'])
-            if plotflag == 1:
-                plt.plot(t[iwin], np.multiply(xdat, 1000), 'g')
-                plt.title('Seismogram and P Pulse, Station %s-%s' \
-                          % (zdat[0].stats.station, zdat[0].stats.channel))
-            else:
-                plt.title('Seismogram, Station %s-%s' \
-                          % (zdat[0].stats.station, zdat[0].stats.channel))
-            plt.xlabel('Time since %s' % zdat[0].stats.starttime)
-            plt.ylabel('Displacement [mm]')
+        # use of implicit scipy otimization function
+        fit = synthsourcespec(F, w0in, Fcin)
+        [optspecfit, _] = curve_fit(synthsourcespec, F, YYcor, [w0in, Fcin])
+        w01 = optspecfit[0]
+        fc1 = optspecfit[1]
+        if verbosity:
+            print ("calcsourcespec: Determined w0-value: %e m/Hz, \n"
+                   "Determined corner frequency: %f Hz" % (w01, fc1))
 
-            if plotflag == 1:
-                plt.subplot(2, 1, 2)
-                p1, = plt.loglog(f, Y.real, 'k')
-                p2, = plt.loglog(F, YY.real)
-                p3, = plt.loglog(F, YYcor, 'r')
-                p4, = plt.loglog(F, fit, 'g')
-                plt.loglog([fc, fc], [w0 / 100, w0], 'g')
-                plt.legend([p1, p2, p3, p4], ['Raw Spectrum', \
-                                              'Used Raw Spectrum', \
-                                              'Q-Corrected Spectrum', \
-                                              'Fit to Spectrum'])
-                plt.title('Source Spectrum from P Pulse, w0=%e m/Hz, fc=%6.2f Hz' \
-                          % (w0, fc))
-                plt.xlabel('Frequency [Hz]')
-                plt.ylabel('Amplitude [m/Hz]')
-                plt.grid()
-            plt.show()
-            raw_input()
-            plt.close(f1)
+        # use of conventional fitting
+        [w02, fc2] = fitSourceModel(F, YYcor, Fcin, iplot, verbosity)
+
+        # get w0 and fc as median of both
+        # source spectrum fits
+        w0 = np.median([w01, w02])
+        fc = np.median([fc1, fc2])
+        if verbosity:
+            print("calcsourcespec: Using w0-value = %e m/Hz and fc = %f Hz" % (
+            w0, fc))
+
+    if iplot > 1:
+        f1 = plt.figure()
+        tLdat = np.arange(0, len(Ldat) * dt, dt)
+        plt.subplot(2, 1, 1)
+        # show displacement in mm
+        p1, = plt.plot(t, np.multiply(inttrz, 1000), 'k')
+        p2, = plt.plot(tLdat, np.multiply(Ldat, 1000))
+        plt.legend([p1, p2], ['Displacement', 'Rotated Displacement'])
+        if plotflag == 1:
+            plt.plot(t[iwin], np.multiply(xdat, 1000), 'g')
+            plt.title('Seismogram and P Pulse, Station %s-%s' \
+                      % (zdat[0].stats.station, zdat[0].stats.channel))
+        else:
+            plt.title('Seismogram, Station %s-%s' \
+                      % (zdat[0].stats.station, zdat[0].stats.channel))
+        plt.xlabel('Time since %s' % zdat[0].stats.starttime)
+        plt.ylabel('Displacement [mm]')
+
+        if plotflag == 1:
+            plt.subplot(2, 1, 2)
+            p1, = plt.loglog(f, Y.real, 'k')
+            p2, = plt.loglog(F, YY.real)
+            p3, = plt.loglog(F, YYcor, 'r')
+            p4, = plt.loglog(F, fit, 'g')
+            plt.loglog([fc, fc], [w0 / 100, w0], 'g')
+            plt.legend([p1, p2, p3, p4], ['Raw Spectrum', \
+                                          'Used Raw Spectrum', \
+                                          'Q-Corrected Spectrum', \
+                                          'Fit to Spectrum'])
+            plt.title('Source Spectrum from P Pulse, w0=%e m/Hz, fc=%6.2f Hz' \
+                      % (w0, fc))
+            plt.xlabel('Frequency [Hz]')
+            plt.ylabel('Amplitude [m/Hz]')
+            plt.grid()
+        plt.show()
+        raw_input()
+        plt.close(f1)
 
     return w0, fc
 
@@ -537,7 +606,7 @@ def synthsourcespec(f, omega0, fcorner):
     return ssp
 
 
-def fitSourceModel(f, S, fc0, iplot):
+def fitSourceModel(f, S, fc0, iplot, verbosity=False):
     '''
     Calculates synthetic source spectrum by varying corner frequency fc.
     Returns best approximated plateau omega0 and corner frequency, i.e. with least
@@ -591,9 +660,9 @@ def fitSourceModel(f, S, fc0, iplot):
     elif len(STD) == 0:
         fc = fc0
         w0 = max(S)
-
-    print("fitSourceModel: best fc: %fHz, best w0: %e m/Hz" \
-          % (fc, w0))
+    if verbosity:
+        print(
+        "fitSourceModel: best fc: {0} Hz, best w0: {1} m/Hz".format(fc, w0))
 
     if iplot > 1:
         plt.figure(iplot)

pylot/core/io/phases.py

@@ -15,6 +15,24 @@ from pylot.core.pick.utils import select_for_phase
 from pylot.core.util.utils import getOwner, full_range, four_digits
 
 
+def add_amplitudes(event, amplitudes):
+    amplitude_list = []
+    for pick in event.picks:
+        try:
+            a0 = amplitudes[pick.waveform_id.station_code]
+            amplitude = ope.Amplitude(generic_amplitude=a0 * 1e-3)
+            amplitude.unit = 'm'
+            amplitude.category = 'point'
+            amplitude.waveform_id = pick.waveform_id
+            amplitude.magnitude_hint = 'ML'
+            amplitude.pick_id = pick.resource_id
+            amplitude.type = 'AML'
+            amplitude_list.append(amplitude)
+        except KeyError:
+            continue
+    event.amplitudes = amplitude_list
+    return event
+
 def readPILOTEvent(phasfn=None, locfn=None, authority_id='RUB', **kwargs):
     """
     readPILOTEvent - function
@@ -549,4 +567,4 @@ def merge_picks(event, picks):
             if p.waveform_id.station_code == station and p.phase_hint == phase:
                 p.time, p.time_errors = time, err
         del time, err, phase, station
-    return event
+    return event

pylot/core/pick/autopick.py

@@ -17,10 +17,8 @@ from pylot.core.pick.charfuns import CharacteristicFunction
 from pylot.core.pick.charfuns import HOScf, AICcf, ARZcf, ARHcf, AR3Ccf
 from pylot.core.pick.utils import checksignallength, checkZ4S, earllatepicker, \
     getSNR, fmpicker, checkPonsets, wadaticheck
-from pylot.core.util.dataprocessing import restitute_data, read_metadata
 from pylot.core.util.utils import getPatternLine
 from pylot.core.io.data import Data
-from pylot.core.analysis.magnitude import WApp
 
 
 def autopickevent(data, param):
@@ -121,8 +119,6 @@ def autopickstation(wfstream, pickparam, verbose=False):
     # parameter to check for spuriously picked S onset
     zfac = pickparam.get('zfac')
     # path to inventory-, dataless- or resp-files
-    invdir = pickparam.get('invdir')
-    invtype, inventory = read_metadata(invdir)
 
     # initialize output
     Pweight = 4  # weight for P onset
@@ -565,24 +561,6 @@ def autopickstation(wfstream, pickparam, verbose=False):
                 # re-create stream object including both horizontal components
                 hdat = edat.copy()
                 hdat += ndat
-                h_copy = hdat.copy()
-                [cordat, restflag] = restitute_data(h_copy, invtype, inventory)
-                # calculate WA-peak-to-peak amplitude
-                # using subclass WApp of superclass Magnitude
-                if restflag:
-                    if Sweight < 4:
-                        wapp = WApp(cordat, mpickS, mpickP + sstop, iplot)
-                    else:
-                        # use larger window for getting peak-to-peak amplitude
-                        # as the S pick is quite unsure
-                        wapp = WApp(cordat, mpickP, mpickP + sstop +
-                                    (0.5 * (mpickP + sstop)), iplot)
-
-                    Ao = wapp.getwapp()
-                else:
-                    print("Go on processing data without source parameter "
-                          "determination!")
-
         else:
             msg = 'Bad initial (AIC) S-pick, skipping this onset!\n' \
                   'AIC-SNR={0}, AIC-Slope={1}counts/s\n' \
@@ -602,16 +580,6 @@ def autopickstation(wfstream, pickparam, verbose=False):
             # re-create stream object including both horizontal components
             hdat = edat.copy()
             hdat += ndat
-            h_copy = hdat.copy()
-            [cordat, restflag] = restitute_data(h_copy, invtype, inventory)
-            if restflag == 1:
-                # calculate WA-peak-to-peak amplitude
-                # using subclass WApp of superclass Magnitude
-                wapp = WApp(cordat, mpickP, mpickP + sstop + (0.5 * (mpickP
-                                                                     + sstop)),
-                            iplot)
-                Ao = wapp.getwapp()
-
     else:
         print('autopickstation: No horizontal component data available or ' \
               'bad P onset, skipping S picking!')

pylot/core/pick/utils.py

@@ -103,7 +103,7 @@ def earllatepicker(X, nfac, TSNR, Pick1, iplot=None, stealth_mode=False):
     # by weighting latest possible pick two times earliest possible pick
     diffti_tl = LPick - Pick1
     diffti_te = Pick1 - EPick
-    PickError = (diffti_te + 2 * diffti_tl) / 3
+    PickError = symmetrize_error(diffti_te, diffti_tl)
 
     if iplot > 1:
         p = plt.figure(iplot)
@@ -325,6 +325,17 @@ def crossings_nonzero_all(data):
     return ((pos[:-1] & npos[1:]) | (npos[:-1] & pos[1:])).nonzero()[0]
 
 
+def symmetrize_error(dte, dtl):
+    """
+    takes earliest and latest possible pick and returns the symmetrized pick
+    uncertainty value
+    :param dte: relative lower uncertainty
+    :param dtl: relative upper uncertainty
+    :return: symmetrized error
+    """
+    return (dte + 2 * dtl) / 3
+
+
 def getSNR(X, TSNR, t1, tracenum=0):
     '''
     Function to calculate SNR of certain part of seismogram relative to

pylot/core/util/dataprocessing.py

@@ -216,12 +216,8 @@ def restitute_data(data, invtype, inobj, unit='VEL', force=False):
     for tr in data:
         seed_id = tr.get_id()
         # check, whether this trace has already been corrected
-        # TODO read actual value of processing key in Trace's stats instead
-        # of just looking for thr key: if processing is setit doesn't
-        # necessarily mean that the trace has been corrected so far but only
-        # processed in some way, e.g. normalized
         if 'processing' in tr.stats.keys() \
-                and np.all(['remove' in p for p in tr.stats.processing]) \
+                and np.any(['remove' in p for p in tr.stats.processing]) \
                 and not force:
             print("Trace {0} has already been corrected!".format(seed_id))
             continue
@@ -254,7 +250,7 @@ def restitute_data(data, invtype, inobj, unit='VEL', force=False):
                 finv = invlist[0]
             inventory = read_inventory(finv, format='STATIONXML')
         else:
-            restflag.append(False)
+            data.remove(tr)
             continue
         # apply restitution to data
         try:
@@ -270,7 +266,9 @@ def restitute_data(data, invtype, inobj, unit='VEL', force=False):
             if msg0 not in e.message or msg1 not in e.message:
                 raise
             else:
-                restflag.append(False)
+                # restitution done to copies of data thus deleting traces
+                # that failed should not be a problem
+                data.remove(tr)
                 continue
         restflag.append(True)
     # check if ALL traces could be restituted, take care of large datasets

pylot/core/util/errors.py

@@ -24,3 +24,6 @@ class OverwriteError(IOError):
 
 class ParameterError(Exception):
     pass
+
+class ProcessingError(RuntimeError):
+    pass

pylot/core/util/widgets.py

@@ -33,8 +33,8 @@ from pylot.core.pick.compare import Comparison
 from pylot.core.util.defaults import OUTPUTFORMATS, FILTERDEFAULTS, LOCTOOLS, \
     COMPPOSITION_MAP
 from pylot.core.util.utils import prepTimeAxis, full_range, scaleWFData, \
-    demeanTrace, isSorted, findComboBoxIndex, clims, find_horizontals
-
+    demeanTrace, isSorted, findComboBoxIndex, clims
+import icons_rc
 
 def getDataType(parent):
     type = QInputDialog().getItem(parent, "Select phases type", "Type:",
@@ -1377,7 +1377,9 @@ class LocalisationTab(PropTab):
 
     def selectDirectory(self, edit):
         selected_directory = QFileDialog.getExistingDirectory()
-        edit.setText(selected_directory)
+        # check if string is empty
+        if selected_directory:
+            edit.setText(selected_directory)
 
     def getValues(self):
         loctool = self.locToolComboBox.currentText()