release version 0.2

release notes:
==============
Features:
- centralize all functionalities of PyLoT and control them from within the main GUI
- handling multiple events inside GUI with project files (save and load work progress)
- GUI based adjustments of pick parameters and I/O
- interactive tuning of parameters from within the GUI
- call automatic picking algorithm from within the GUI
- comparison of automatic with manual picks for multiple events using clear differentiation of manual picks into 'tune' and 'test-set' (beta)
- manual picking of different (user defined) phase types
- phase onset estimation with ObsPy TauPy

- interactive zoom/scale functionalities in all plots (mousewheel, pan, pan-zoom)
- array map to visualize stations and control onsets (beta feature, switch to manual picks not implemented)

Platform support:
- python 3 support
- Windows support

Performance:
- multiprocessing for automatic picking and restitution of multiple stations
- use pyqtgraph library for better performance on main waveform plot

Visualization:
- pick uncertainty (quality classes) visualization with gradients
- pick color unification for all plots
- new icons and stylesheets

Known Issues:

README.md

@@ -1,92 +1,110 @@
-# PyLoT
-
-version: 0.1a
-
-The Python picking and Localisation Tool
-
-This python library contains a graphical user interfaces for picking
-seismic phases. This software needs [ObsPy][ObsPy]
-and the PySide Qt4 bindings for python to be installed first.
-
-PILOT has originally been developed in Mathworks' MatLab. In order to
-distribute PILOT without facing portability problems, it has been decided
-to redevelop the software package in Python. The great work of the ObsPy
-group allows easy handling of a bunch of seismic data and PyLoT will
-benefit a lot compared to the former MatLab version.
-
-The development of PyLoT is part of the joint research project MAGS2.
-
-##Installation
-
-At the moment there is no automatic installation procedure available for PyLoT.
-Best way to install is to clone the repository and add the path to your Python path.
-
-####prerequisites:
-
-In order to run PyLoT you need to install:
-
-- python
-- scipy
-- numpy
-- matplotlib
-- obspy
-- pyside
-
-####some handwork
-
-PyLoT needs a properties folder on your system to work. It should be situated in your home directory:
-
-    mkdir ~/.pylot
-
-In the next step you have to copy some files to this directory:
-
-    cp path-to-pylot/inputs/pylot.in ~/.pylot/
-
-for local distance seismicity
-
-    cp path-to-pylot/inputs/autoPyLoT_local.in ~/.pylot/autoPyLoT.in
-
-for regional distance seismicity
-
-    cp path-to-pylot/inputs/autoPyLoT_regional.in ~/.pylot/autoPyLoT.in
-
-and some extra information on filtering, error estimates (just needed for reading old PILOT data) and the Richter magnitude scaling relation
-
-    cp path-to-pylot/inputs/filter.in path-to-pylot/inputs/PILOT_TimeErrors.in path-to-pylot/inputs/richter_scaling.data ~/.pylot/
-
-You may need to do some modifications to these files. Especially folder names should be reviewed.
-
-PyLoT has been tested on Mac OSX (10.11) and Debian Linux 8.
-
-
-##release notes:
-==============
-
-#### Features
-
-- consistent manual phase picking through predefined SNR dependant zoom level
-- uniform uncertainty estimation from waveform's properties for automatic and manual picks
-- pdf representation and comparison of picks taking the uncertainty intrinsically into account 
-- Richter and moment magnitude estimation
-- location determination with external installation of [NonLinLoc](http://alomax.free.fr/nlloc/index.html)
-
-#### Known issues
-
-- Magnitude estimation from manual PyLoT takes some time (instrument correction)
-
-We hope to solve these with the next release.
-
-####staff:
-======
-
-original author(s): L. Kueperkoch, S. Wehling-Benatelli, M. Bischoff (PILOT)
-
-developer(s): S. Wehling-Benatelli, L. Kueperkoch, K. Olbert, M. Bischoff,
-              C. Wollin, M. Rische, M. Paffrath
-
-others: A. Bruestle, T. Meier, W. Friederich
-
-
-[ObsPy]: http://github.com/obspy/obspy/wiki
-
-October 2016
+# PyLoT
+
+version: 0.2
+
+The Python picking and Localisation Tool
+
+This python library contains a graphical user interfaces for picking
+seismic phases. This software needs [ObsPy][ObsPy]
+and the PySide Qt4 bindings for python to be installed first.
+
+PILOT has originally been developed in Mathworks' MatLab. In order to
+distribute PILOT without facing portability problems, it has been decided
+to redevelop the software package in Python. The great work of the ObsPy
+group allows easy handling of a bunch of seismic data and PyLoT will
+benefit a lot compared to the former MatLab version.
+
+The development of PyLoT is part of the joint research project MAGS2 and AlpArray.
+
+## Installation
+
+At the moment there is no automatic installation procedure available for PyLoT.
+Best way to install is to clone the repository and add the path to your Python path.
+
+#### Prerequisites:
+
+In order to run PyLoT you need to install:
+
+- python 2 or 3
+- scipy
+- numpy
+- matplotlib
+- obspy
+- pyside
+
+#### Some handwork:
+
+PyLoT needs a properties folder on your system to work. It should be situated in your home directory 
+(on Windows usually C:/Users/*username*):
+
+    mkdir ~/.pylot
+
+In the next step you have to copy some files to this directory:
+
+*for local distance seismicity*
+
+    cp path-to-pylot/inputs/pylot_local.in ~/.pylot/pylot.in
+
+*for regional distance seismicity*
+
+    cp path-to-pylot/inputs/pylot_regional.in ~/.pylot/pylot.in
+
+*for global distance seismicity*
+
+    cp path-to-pylot/inputs/pylot_global.in ~/.pylot/pylot.in
+
+and some extra information on error estimates (just needed for reading old PILOT data) and the Richter magnitude scaling relation
+
+    cp path-to-pylot/inputs/PILOT_TimeErrors.in path-to-pylot/inputs/richter_scaling.data ~/.pylot/
+
+You may need to do some modifications to these files. Especially folder names should be reviewed.
+
+PyLoT has been tested on Mac OSX (10.11), Debian Linux 8 and on Windows 10.
+
+
+## Release notes
+
+#### Features:
+
+- centralize all functionalities of PyLoT and control them from within the main GUI
+- handling multiple events inside GUI with project files (save and load work progress)
+- GUI based adjustments of pick parameters and I/O
+- interactive tuning of parameters from within the GUI
+- call automatic picking algorithm from within the GUI
+- comparison of automatic with manual picks for multiple events using clear differentiation of manual picks into 'tune' and 'test-set' (beta)
+- manual picking of different (user defined) phase types
+- phase onset estimation with ObsPy TauPy
+- interactive zoom/scale functionalities in all plots (mousewheel, pan, pan-zoom)
+- array map to visualize stations and control onsets (beta feature, switch to manual picks not implemented)
+
+##### Platform support:
+- Python 3 support
+- Windows support
+
+##### Performance:
+- multiprocessing for automatic picking and restitution of multiple stations
+- use pyqtgraph library for better performance on main waveform plot
+
+##### Visualization:
+- pick uncertainty (quality classes) visualization with gradients
+- pick color unification for all plots
+- new icons and stylesheets
+
+#### Known Issues:
+- some Qt related errors might occur at runtime
+- filter toggle not working in pickDlg
+- PyLoT data structure requires at least three parent directories for waveform data directory
+
+## Staff
+
+Original author(s): L. Kueperkoch, S. Wehling-Benatelli, M. Bischoff (PILOT)
+
+Developer(s): S. Wehling-Benatelli, L. Kueperkoch, M. Paffrath, K. Olbert,
+M. Bischoff, C. Wollin, M. Rische
+
+Others: A. Bruestle, T. Meier, W. Friederich
+
+
+[ObsPy]: http://github.com/obspy/obspy/wiki
+
+September 2017

autoPyLoT.py

@@ -4,61 +4,125 @@
 from __future__ import print_function
 
 import argparse
+import datetime
 import glob
 import os
 
-from obspy import read_events
-
-import pylot.core.loc.hsat as hsat
+import pylot.core.loc.focmec as focmec
+import pylot.core.loc.hash as hash
+import pylot.core.loc.hypo71 as hypo71
+import pylot.core.loc.hypodd as hypodd
+import pylot.core.loc.hyposat as hyposat
 import pylot.core.loc.nll as nll
-from pylot.core.analysis.magnitude import MomentMagnitude, RichterMagnitude
+import pylot.core.loc.velest as velest
+from obspy import read_events
+from obspy.core.event import ResourceIdentifier
+# from PySide.QtGui import QWidget, QInputDialog
+from pylot.core.analysis.magnitude import MomentMagnitude, LocalMagnitude
 from pylot.core.io.data import Data
-from pylot.core.io.inputs import AutoPickParameter
+from pylot.core.io.inputs import PylotParameter
 from pylot.core.pick.autopick import autopickevent, iteratepicker
-from pylot.core.util.dataprocessing import restitute_data, read_metadata, \
-    remove_underscores
+from pylot.core.util.dataprocessing import restitute_data, read_metadata
+from pylot.core.util.defaults import SEPARATOR
+from pylot.core.util.event import Event
 from pylot.core.util.structure import DATASTRUCTURE
+from pylot.core.util.utils import real_None, remove_underscores, trim_station_components, check4gaps, check4doubled, \
+    check4rotated
 from pylot.core.util.version import get_git_version as _getVersionString
 
 __version__ = _getVersionString()
 
 
-def autoPyLoT(inputfile):
+def autoPyLoT(input_dict=None, parameter=None, inputfile=None, fnames=None, eventid=None, savepath=None,
+              savexml=True, station='all', iplot=0, ncores=0):
     """
     Determine phase onsets automatically utilizing the automatic picking
     algorithms by Kueperkoch et al. 2010/2012.
 
     :param inputfile: path to the input file containing all parameter
     information for automatic picking (for formatting details, see.
-    `~pylot.core.io.inputs.AutoPickParameter`
+    `~pylot.core.io.inputs.PylotParameter`
     :type inputfile: str
     :return:
 
     .. rubric:: Example
 
     """
+
+    if ncores == 1:
+        sp_info = 'autoPyLoT is running serial on 1 cores.'
+    else:
+        if ncores == 0:
+            ncores_readable = 'all available'
+        else:
+            ncores_readable = ncores
+        sp_info = 'autoPyLoT is running in parallel on {} cores.'.format(ncores_readable)
+
     splash = '''************************************\n
                 *********autoPyLoT starting*********\n
                 The Python picking and Location Tool\n
-                Version {version} 2015\n
+                Version {version} 2017\n
                 \n
                 Authors:\n
-                S. Wehling-Benatelli (Ruhr-Universität Bochum)\n
-                L. Küperkoch (BESTEC GmbH, Landau i. d. Pfalz)\n
-                K. Olbert (Christian-Albrechts Universität zu Kiel)\n
-                ***********************************'''.format(version=_getVersionString())
+                L. Kueperkoch (BESTEC GmbH, Landau i. d. Pfalz)\n
+                M. Paffrath (Ruhr-Universitaet Bochum)\n
+                S. Wehling-Benatelli (Ruhr-Universitaet Bochum)\n
+                
+                {sp}
+                ***********************************'''.format(version=_getVersionString(),
+                                                              sp=sp_info)
     print(splash)
 
-    # reading parameter file
 
-    parameter = AutoPickParameter(inputfile)
+    parameter = real_None(parameter)
+    inputfile = real_None(inputfile)
+    eventid = real_None(eventid)
 
-    data = Data()
+    fig_dict = None
+    fig_dict_wadatijack = None
+
+    locflag = 1
+    if input_dict and isinstance(input_dict, dict):
+        if 'parameter' in input_dict:
+            parameter = input_dict['parameter']
+        if 'fig_dict' in input_dict:
+            fig_dict = input_dict['fig_dict']
+        if 'fig_dict_wadatijack' in input_dict:
+            fig_dict_wadatijack = input_dict['fig_dict_wadatijack']
+        if 'station' in input_dict:
+            station = input_dict['station']
+        if 'fnames' in input_dict:
+            fnames = input_dict['fnames']
+        if 'eventid' in input_dict:
+            eventid = input_dict['eventid']
+        if 'iplot' in input_dict:
+            iplot = input_dict['iplot']
+        if 'locflag' in input_dict:
+            locflag = input_dict['locflag']
+        if 'savexml' in input_dict:
+            savexml = input_dict['savexml']
+
+    if not parameter:
+        if inputfile:
+            parameter = PylotParameter(inputfile)
+            #iplot = parameter['iplot']
+        else:
+            infile = os.path.join(os.path.expanduser('~'), '.pylot', 'pylot.in')
+            print('Using default input file {}'.format(infile))
+            parameter = PylotParameter(infile)
+    else:
+        if not type(parameter) == PylotParameter:
+            print('Wrong input type for parameter: {}'.format(type(parameter)))
+            return
+        if inputfile:
+            print('Parameters set and input file given. Choose either of both.')
+            return
 
     evt = None
-    # getting information on data structure
 
+    # reading parameter file
     if parameter.hasParam('datastructure'):
+        # getting information on data structure
         datastructure = DATASTRUCTURE[parameter.get('datastructure')]()
         dsfields = {'root': parameter.get('rootpath'),
                     'dpath': parameter.get('datapath'),
@@ -66,16 +130,15 @@ def autoPyLoT(inputfile):
 
         exf = ['root', 'dpath', 'dbase']
 
-        if parameter.hasParam('eventID'):
-            dsfields['eventID'] = parameter.get('eventID')
+        if parameter['eventID'] is not '*' and fnames == 'None':
+            dsfields['eventID'] = parameter['eventID']
             exf.append('eventID')
 
         datastructure.modifyFields(**dsfields)
         datastructure.setExpandFields(exf)
 
         # check if default location routine NLLoc is available
-        if parameter.hasParam('nllocbin'):
-            locflag = 1
+        if real_None(parameter['nllocbin']) and locflag:
             # get NLLoc-root path
             nllocroot = parameter.get('nllocroot')
             # get path to NLLoc executable
@@ -99,31 +162,122 @@ def autoPyLoT(inputfile):
             print("!!No source parameter estimation possible!!")
             print("                 !!!              ")
 
-        datapath = datastructure.expandDataPath()
-        if not parameter.hasParam('eventID'):
-            # multiple event processing
-            # read each event in database
-            events = [events for events in glob.glob(os.path.join(datapath, '*')) if os.path.isdir(events)]
+        if not input_dict:
+            # started in production mode
+            datapath = datastructure.expandDataPath()
+            if fnames == 'None' and parameter['eventID'] is '*':
+                # multiple event processing
+                # read each event in database
+                events = [events for events in glob.glob(os.path.join(datapath, '*')) if os.path.isdir(events)]
+            elif fnames == 'None' and parameter['eventID'] is not '*' and not type(parameter['eventID']) == list:
+                # single event processing
+                events = glob.glob(os.path.join(datapath, parameter['eventID']))
+            elif fnames == 'None' and type(parameter['eventID']) == list:
+                # multiple event processing
+                events = []
+                for eventID in parameter['eventID']:
+                    events.append(os.path.join(datapath, eventID))
+            else:
+                # autoPyLoT was initialized from GUI
+                events = []
+                events.append(eventid)
+                evID = os.path.split(eventid)[-1]
+                locflag = 2
         else:
-            # single event processing
-            events = glob.glob(os.path.join(datapath, parameter.get('eventID')))
-        for event in events:
-            data.setWFData(glob.glob(os.path.join(datapath, event, '*')))
-            evID = os.path.split(event)[-1]
-            print('Working on event %s' % event)
-            print(data)
+            # started in tune or interactive mode
+            datapath = os.path.join(parameter['rootpath'],
+                                    parameter['datapath'])
+            events = []
+            for eventID in eventid:
+                events.append(os.path.join(datapath,
+                                           parameter['database'],
+                                           eventID))
+
+        if not events:
+            print('autoPyLoT: No events given. Return!')
+            return
+
+        # transform system path separator to '/'
+        for index, eventpath in enumerate(events):
+            eventpath = eventpath.replace(SEPARATOR, '/')
+            events[index] = eventpath
+
+        allpicks = {}
+        glocflag = locflag
+        for eventpath in events:
+            evID = os.path.split(eventpath)[-1]
+            fext = '.xml'
+            filename = os.path.join(eventpath, 'PyLoT_' + evID + fext)
+            try:
+                data = Data(evtdata=filename)
+                data.get_evt_data().path = eventpath
+                print('Reading event data from filename {}...'.format(filename))
+            except Exception as e:
+                print('Could not read event from file {}: {}'.format(filename, e))
+                data = Data()
+                pylot_event = Event(eventpath)  # event should be path to event directory
+                data.setEvtData(pylot_event)
+            if fnames == 'None':
+                data.setWFData(glob.glob(os.path.join(datapath, eventpath, '*')))
+                # the following is necessary because within
+                # multiple event processing no event ID is provided
+                # in autopylot.in
+                try:
+                    parameter.get('eventID')
+                except:
+                    now = datetime.datetime.now()
+                    eventID = '%d%02d%02d%02d%02d' % (now.year,
+                                                      now.month,
+                                                      now.day,
+                                                      now.hour,
+                                                      now.minute)
+                    parameter.setParam(eventID=eventID)
+            else:
+                data.setWFData(fnames)
+
+                eventpath = events[0]
+                # now = datetime.datetime.now()
+                # evID = '%d%02d%02d%02d%02d' % (now.year,
+                #                               now.month,
+                #                               now.day,
+                #                               now.hour,
+                #                               now.minute)
+                parameter.setParam(eventID=eventid)
             wfdat = data.getWFData()  # all available streams
+            if not station == 'all':
+                wfdat = wfdat.select(station=station)
+                if not wfdat:
+                    print('Could not find station {}. STOP!'.format(station))
+                    return
             wfdat = remove_underscores(wfdat)
-            metadata =  read_metadata(parameter.get('invdir'))
-            corr_dat, rest_flag = restitute_data(wfdat.copy(), *metadata)
+            # trim components for each station to avoid problems with different trace starttimes for one station
+            wfdat = check4gaps(wfdat)
+            wfdat = check4doubled(wfdat)
+            wfdat = trim_station_components(wfdat, trim_start=True, trim_end=False)
+            metadata = read_metadata(parameter.get('invdir'))
+            # rotate stations to ZNE
+            wfdat = check4rotated(wfdat, metadata)
+            corr_dat = None
+            if locflag:
+                print("Restitute data ...")
+                corr_dat = restitute_data(wfdat.copy(), *metadata, ncores=ncores)
+            if not corr_dat and locflag:
+                locflag = 2
+            print('Working on event %s. Stations: %s' % (eventpath, station))
+            print(wfdat)
             ##########################################################
             # !automated picking starts here!
-            picks = autopickevent(wfdat, parameter)
+            fdwj = None
+            if fig_dict_wadatijack:
+                fdwj = fig_dict_wadatijack[evID]
+            picks = autopickevent(wfdat, parameter, iplot=iplot, fig_dict=fig_dict,
+                                  fig_dict_wadatijack=fdwj,
+                                  ncores=ncores, metadata=metadata, origin=data.get_evt_data().origins)
             ##########################################################
             # locating
-            if locflag == 1:
+            if locflag > 0:
                 # write phases to NLLoc-phase file
-                nll.export(picks, phasefile)
+                nll.export(picks, phasefile, parameter)
 
                 # For locating the event the NLLoc-control file has to be modified!
                 nllocout = '%s_%s' % (evID, nllocoutpatter)
@@ -132,7 +286,7 @@ def autoPyLoT(inputfile):
                                   ttpat)
 
                 # locate the event
-                nll.locate(ctrfile)
+                nll.locate(ctrfile, inputfile)
 
                 # !iterative picking if traces remained unpicked or occupied with bad picks!
                 # get theoretical onset times for picks with weights >= 4
@@ -154,22 +308,38 @@ def autoPyLoT(inputfile):
                         # get latest NLLoc-location file if several are available
                         nllocfile = max(glob.glob(locsearch), key=os.path.getctime)
                         evt = read_events(nllocfile)[0]
-                        # calculating seismic moment Mo and moment magnitude Mw
+                        # calculate seismic moment Mo and moment magnitude Mw
                         moment_mag = MomentMagnitude(corr_dat, evt, parameter.get('vp'),
                                                      parameter.get('Qp'),
-                                                     parameter.get('rho'), True, 0)
+                                                     parameter.get('rho'), True,
+                                                     iplot)
                         # update pick with moment property values (w0, fc, Mo)
-                        for station, props in moment_mag.moment_props.items():
-                            picks[station]['P'].update(props)
+                        for stats, props in moment_mag.moment_props.items():
+                            picks[stats]['P'].update(props)
                         evt = moment_mag.updated_event()
-                        local_mag = RichterMagnitude(corr_dat, evt,
-                                                     parameter.get('sstop'), True, 0)
-                        for station, amplitude in local_mag.amplitudes.items():
-                            picks[station]['S']['Ao'] = amplitude.generic_amplitude
-                        evt = local_mag.updated_event()
+                        net_mw = moment_mag.net_magnitude()
+                        print("Network moment magnitude: %4.1f" % net_mw.mag)
+                        # calculate local (Richter) magntiude
+                        WAscaling = parameter.get('WAscaling')
+                        magscaling = parameter.get('magscaling')
+                        local_mag = LocalMagnitude(corr_dat, evt,
+                                                   parameter.get('sstop'),
+                                                   WAscaling, True, iplot)
+                        for stats, amplitude in local_mag.amplitudes.items():
+                            picks[stats]['S']['Ao'] = amplitude.generic_amplitude
+                        print("Local station magnitudes scaled with:")
+                        print("log(Ao) + %f * log(r) + %f * r + %f" % (WAscaling[0],
+                                                                       WAscaling[1],
+                                                                       WAscaling[2]))
+                        evt = local_mag.updated_event(magscaling)
+                        net_ml = local_mag.net_magnitude(magscaling)
+                        print("Network local magnitude: %4.1f" % net_ml.mag)
+                        print("Network local magnitude scaled with:")
+                        print("%f * Ml + %f" % (magscaling[0], magscaling[1]))
                     else:
                         print("autoPyLoT: No NLLoc-location file available!")
                         print("No source parameter estimation possible!")
+                        locflag = 9
                 else:
                     # get theoretical P-onset times from NLLoc-location file
                     locsearch = '%s/loc/%s.????????.??????.grid?.loc.hyp' % (nllocroot, nllocout)
@@ -183,13 +353,19 @@ def autoPyLoT(inputfile):
                                 print("autoPyLoT: Number of maximum iterations reached, stop iterative picking!")
                                 break
                             print("autoPyLoT: Starting with iteration No. %d ..." % nlloccounter)
-                            picks = iteratepicker(wfdat, nllocfile, picks, badpicks, parameter)
+                            if input_dict:
+                                if 'fig_dict' in input_dict:
+                                    fig_dict = input_dict['fig_dict']
+                                    picks = iteratepicker(wfdat, nllocfile, picks, badpicks, parameter,
+                                                          fig_dict=fig_dict)
+                            else:
+                                picks = iteratepicker(wfdat, nllocfile, picks, badpicks, parameter)
                             # write phases to NLLoc-phase file
-                            nll.export(picks, phasefile)
+                            nll.export(picks, phasefile, parameter)
                             # remove actual NLLoc-location file to keep only the last
                             os.remove(nllocfile)
                             # locate the event
-                            nll.locate(ctrfile)
+                            nll.locate(ctrfile, inputfile)
                             print("autoPyLoT: Iteration No. %d finished." % nlloccounter)
                             # get updated NLLoc-location file
                             nllocfile = max(glob.glob(locsearch), key=os.path.getctime)
@@ -198,73 +374,132 @@ def autoPyLoT(inputfile):
                             for key in picks:
                                 if picks[key]['P']['weight'] >= 4 or picks[key]['S']['weight'] >= 4:
                                     badpicks.append([key, picks[key]['P']['mpp']])
-                            print("autoPyLoT: After iteration No. %d: %d bad onsets found ..." % (nlloccounter, \
+                            print("autoPyLoT: After iteration No. %d: %d bad onsets found ..." % (nlloccounter,
                                                                                                   len(badpicks)))
                             if len(badpicks) == 0:
                                 print("autoPyLoT: No more bad onsets found, stop iterative picking!")
                                 nlloccounter = maxnumit
                         evt = read_events(nllocfile)[0]
-                        # calculating seismic moment Mo and moment magnitude Mw
-                        moment_mag = MomentMagnitude(corr_dat, evt, parameter.get('vp'),
-                                                     parameter.get('Qp'),
-                                                     parameter.get('rho'), True, 0)
-                        # update pick with moment property values (w0, fc, Mo)
-                        for station, props in moment_mag.moment_props.items():
-                            picks[station]['P'].update(props)
-                        evt = moment_mag.updated_event()
-                        local_mag = RichterMagnitude(corr_dat, evt,
-                                                     parameter.get('sstop'), True, 0)
-                        for station, amplitude in local_mag.amplitudes.items():
-                            picks[station]['S']['Ao'] = amplitude.generic_amplitude
-                        evt = local_mag.updated_event()
-                        net_mw = moment_mag.net_magnitude()
-                        print("Network moment magnitude: %4.1f" % net_mw.mag)
+                        if locflag < 2:
+                            # calculate seismic moment Mo and moment magnitude Mw
+                            moment_mag = MomentMagnitude(corr_dat, evt, parameter.get('vp'),
+                                                         parameter.get('Qp'),
+                                                         parameter.get('rho'), True,
+                                                         iplot)
+                            # update pick with moment property values (w0, fc, Mo)
+                            for stats, props in moment_mag.moment_props.items():
+                                if picks.has_key(stats):
+                                    picks[stats]['P'].update(props)
+                            evt = moment_mag.updated_event()
+                            net_mw = moment_mag.net_magnitude()
+                            print("Network moment magnitude: %4.1f" % net_mw.mag)
+                            # calculate local (Richter) magntiude
+                            WAscaling = parameter.get('WAscaling')
+                            magscaling = parameter.get('magscaling')
+                            local_mag = LocalMagnitude(corr_dat, evt,
+                                                       parameter.get('sstop'),
+                                                       WAscaling, True, iplot)
+                            for stats, amplitude in local_mag.amplitudes.items():
+                                if picks.has_key(stats):
+                                    picks[stats]['S']['Ao'] = amplitude.generic_amplitude
+                            print("Local station magnitudes scaled with:")
+                            print("log(Ao) + %f * log(r) + %f * r + %f" % (WAscaling[0],
+                                                                           WAscaling[1],
+                                                                           WAscaling[2]))
+                            evt = local_mag.updated_event(magscaling)
+                            net_ml = local_mag.net_magnitude(magscaling)
+                            print("Network local magnitude: %4.1f" % net_ml.mag)
+                            print("Network local magnitude scaled with:")
+                            print("%f * Ml + %f" % (magscaling[0], magscaling[1]))
                     else:
                         print("autoPyLoT: No NLLoc-location file available! Stop iteration!")
+                        locflag = 9
             ##########################################################
-            # write phase files for various location routines
-            # HYPO71
-            hypo71file = '%s/autoPyLoT_HYPO71.pha' % event
-            hsat.export(picks, hypo71file)
-            data.applyEVTData(picks)
+            # write phase files for various location 
+            # and fault mechanism calculation routines
+            # ObsPy event object
             if evt is not None:
+                event_id = eventpath.split('/')[-1]
+                evt.resource_id = ResourceIdentifier('smi:local/' + event_id)
                 data.applyEVTData(evt, 'event')
-            fnqml = '%s/autoPyLoT' % event
-            data.exportEvent(fnqml)
+            data.applyEVTData(picks)
+            if savexml:
+                if savepath == 'None' or savepath == None:
+                    saveEvtPath = eventpath
+                else:
+                    saveEvtPath = savepath
+                fnqml = '%s/PyLoT_%s' % (saveEvtPath, evID)
+                data.exportEvent(fnqml, fnext='.xml', fcheck=['auto', 'magnitude', 'origin'])
+            if locflag == 1:
+                # HYPO71
+                hypo71file = '%s/PyLoT_%s_HYPO71_phases' % (eventpath, evID)
+                hypo71.export(picks, hypo71file, parameter)
+                # HYPOSAT
+                hyposatfile = '%s/PyLoT_%s_HYPOSAT_phases' % (eventpath, evID)
+                hyposat.export(picks, hyposatfile, parameter)
+                # VELEST
+                velestfile = '%s/PyLoT_%s_VELEST_phases.cnv' % (eventpath, evID)
+                velest.export(picks, velestfile, evt, parameter)
+                # hypoDD
+                hypoddfile = '%s/PyLoT_%s_hypoDD_phases.pha' % (eventpath, evID)
+                hypodd.export(picks, hypoddfile, parameter, evt)
+                # FOCMEC
+                focmecfile = '%s/PyLoT_%s_FOCMEC.in' % (eventpath, evID)
+                focmec.export(picks, focmecfile, parameter, evt)
+                # HASH
+                hashfile = '%s/PyLoT_%s_HASH' % (eventpath, evID)
+                hash.export(picks, hashfile, parameter, evt)
 
             endsplash = '''------------------------------------------\n'
                            -----Finished event %s!-----\n'
                            ------------------------------------------'''.format \
                             (version=_getVersionString()) % evID
             print(endsplash)
+            locflag = glocflag
             if locflag == 0:
                 print("autoPyLoT was running in non-location mode!")
 
+            # save picks for current event ID to dictionary with ALL picks
+            allpicks[evID] = picks
+
     endsp = '''####################################\n
                ************************************\n
                *********autoPyLoT terminates*******\n
                The Python picking and Location Tool\n
                ************************************'''.format(version=_getVersionString())
     print(endsp)
+    return allpicks
 
 
 if __name__ == "__main__":
-    from pylot.core.util.defaults import AUTOMATIC_DEFAULTS
     # parse arguments
     parser = argparse.ArgumentParser(
         description='''autoPyLoT automatically picks phase onset times using higher order statistics,
-                       autoregressive prediction and AIC''')
+                       autoregressive prediction and AIC followed by locating the seismic events using 
+                       NLLoc''')
 
     parser.add_argument('-i', '-I', '--inputfile', type=str,
                         action='store',
                         help='''full path to the file containing the input
-                        parameters for autoPyLoT''',
-                        default=AUTOMATIC_DEFAULTS
-                        )
-    parser.add_argument('-v', '-V', '--version', action='version',
-                        version='autoPyLoT ' + __version__,
-                        help='show version information and exit')
+                        parameters for autoPyLoT''')
+    parser.add_argument('-p', '-P', '--iplot', type=int, 
+                        action='store',
+                        help='''optional, logical variable for plotting: 0=none, 1=partial, 2=all''') 
+    parser.add_argument('-f', '-F', '--fnames', type=str,
+                        action='store',
+                        help='''optional, list of data file names''')
+    parser.add_argument('-e', '--eventid', type=str,
+                        action='store',
+                        help='''optional, event path incl. event ID''')
+    parser.add_argument('-s', '-S', '--spath', type=str,
+                        action='store',
+                        help='''optional, save path for autoPyLoT output''')
+    parser.add_argument('-c', '-C', '--ncores', type=int,
+                        action='store', default=0,
+                        help='''optional, number of CPU cores used for parallel processing (default: all available(=0))''')
 
     cla = parser.parse_args()
 
-    autoPyLoT(str(cla.inputfile))
+    picks = autoPyLoT(inputfile=str(cla.inputfile), fnames=str(cla.fnames),
+                      eventid=str(cla.eventid), savepath=str(cla.spath),
+                      ncores=cla.ncores, iplot=int(cla.iplot))

help/index.html

@@ -1,17 +1,19 @@
-<html><head><title>PyLoT - the Python picking and Localisation Tool</title></head>
+<html>
+<head><title>PyLoT - the Python picking and Localisation Tool</title></head>
 <body>
 <p><b>PyLoT</b> is a program which is capable of picking seismic phases,
-exporting these as numerous standard phase format and localize the corresponding
-seismic event with external software as, e.g.:</p>
+    exporting these as numerous standard phase format and localize the corresponding
+    seismic event with external software as, e.g.:</p>
 <ul type="circle">
-<li><a href="http://alomax.free.fr/nlloc/index.html">NonLinLoc</a></li>
-<li>HypoInvers</li>
-<li>HypoSat</li>
-<li>whatever you want ...</li>
+    <li><a href="http://alomax.free.fr/nlloc/index.html">NonLinLoc</a></li>
+    <li>HypoInvers</li>
+    <li>HypoSat</li>
+    <li>whatever you want ...</li>
 </ul>
 <p>Read more on the
-<a href="https://ariadne.geophysik.rub.de/trac/PyLoT/wiki/">PyLoT WikiPage</a>.</p>
+    <a href="https://ariadne.geophysik.rub.de/trac/PyLoT/wiki/">PyLoT WikiPage</a>.</p>
 <p>Bug reports are very much appreciated and can also be delivered on our
-<a href="https://ariadne.geophysik.rub.de/trac/PyLoT">PyLoT TracPage</a> after
-successful registration.</p>
-</body></html>
+    <a href="https://ariadne.geophysik.rub.de/trac/PyLoT">PyLoT TracPage</a> after
+    successful registration.</p>
+</body>
+</html>

icons.qrc

@@ -2,10 +2,37 @@
     <qresource>
         <file>icons/pylot.ico</file>
         <file>icons/pylot.png</file>
-        <file>icons/locate.png</file>
+        <file>icons/back.png</file>
+        <file>icons/home.png</file>
+        <file>icons/newfile.png</file>
+        <file>icons/open.png</file>
+        <file>icons/openproject.png</file>
+        <file>icons/add.png</file>
+        <file>icons/save.png</file>
+        <file>icons/saveas.png</file>
+        <file>icons/saveproject.png</file>
+        <file>icons/saveprojectas.png</file>
+        <file>icons/manupicksicon_small.png</file>
+        <file>icons/autopicksicon_small.png</file>
+        <file>icons/tune.png</file>
+        <file>icons/autopylot_button.png</file>
+        <file>icons/pick.png</file>
+        <file>icons/waveform.png</file>
+        <file>icons/openpick.png</file>
+        <file>icons/openpicks.png</file>
+        <file>icons/openpick.png</file>
+        <file>icons/openpicks.png</file>
+        <file>icons/savepicks.png</file>
+        <file>icons/preferences.png</file>
+        <file>icons/parameter.png</file>
+        <file>icons/inventory.png</file>
+        <file>icons/map.png</file>
+        <file>icons/openloc.png</file>
+        <file>icons/compare_button.png</file>
+        <file>icons/locate_button.png</file>
+        <file>icons/Matlab_PILOT_icon.png</file>
         <file>icons/printer.png</file>
         <file>icons/delete.png</file>
-        <file>icons/compare.png</file>
         <file>icons/key_E.png</file>
         <file>icons/key_N.png</file>
         <file>icons/key_P.png</file>

inputs/autoPyLoT.in

@@ -1,100 +0,0 @@
-%This is a parameter input file for autoPyLoT.
-%All main and special settings regarding data handling
-%and picking are to be set here!
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-
-#main settings#
-/DATA/Insheim                       #rootpath#     %project path
-EVENT_DATA/LOCAL		    #datapath#     %data path
-2013.02_Insheim                     #database#     %name of data base
-e0019.048.13                        #eventID#      %certain evnt ID for processing
-True                                #apverbose#
-PILOT				    #datastructure#  %choose data structure
-0                                   #iplot#        %flag for plotting: 0 none, 1, partly, >1 everything
-AUTOPHASES_AIC_HOS4_ARH             #phasefile#    %name of autoPILOT output phase file 
-AUTOLOC_AIC_HOS4_ARH                #locfile#      %name of autoPILOT output location file 
-AUTOFOCMEC_AIC_HOS4_ARH.in          #focmecin#     %name of focmec input file containing polarities
-HYPOSAT                             #locrt#        %location routine used ("HYPOINVERSE" or "HYPOSAT")
-6                                   #pmin#         %minimum required P picks for location
-4                                   #p0min#        %minimum required P picks for location if at least
-                                                   %3 excellent P picks are found
-2                                   #smin#         %minimum required S picks for location
-/home/ludger/bin/run_HYPOSAT4autoPILOT.csh #cshellp# %path and name of c-shell script to run location routine
-7.6 8.5                             #blon#         %longitude bounding for location map
-49 49.4                             #blat#         %lattitude bounding for location map
-#parameters for moment magnitude estimation#
-5000                                #vp#           %average P-wave velocity
-2800                                #vs#           %average S-wave velocity
-2200                                #rho#          %rock density [kg/m^3]
-300                                 #Qp#           %quality factor for P waves
-100                                 #Qs#           %quality factor for S waves
-#common settings picker#
-15                                  #pstart#       %start time [s] for calculating CF for P-picking
-40                                  #pstop#        %end time [s] for calculating CF for P-picking
--1.0                                #sstart#       %start time [s] after or before(-) P-onset for calculating CF for S-picking
-7                                   #sstop#        %end time [s] after P-onset for calculating CF for S-picking
-2 20                                #bpz1#         %lower/upper corner freq. of first band pass filter Z-comp. [Hz]
-2 30                                #bpz2#         %lower/upper corner freq. of second band pass filter Z-comp. [Hz]
-2 15                                #bph1#         %lower/upper corner freq. of first band pass filter H-comp. [Hz]
-2 20                                #bph2#         %lower/upper corner freq. of second band pass filter z-comp. [Hz]
-#special settings for calculating CF#
-%!!Be careful when editing the following!!
-#Z-component#
-HOS                                 #algoP#        %choose algorithm for P-onset determination (HOS, ARZ, or AR3)
-7                                   #tlta#         %for HOS-/AR-AIC-picker, length of LTA window [s] 
-4                                   #hosorder#     %for HOS-picker, order of Higher Order Statistics
-2                                   #Parorder#     %for AR-picker, order of AR process of Z-component
-1.2                                 #tdet1z#       %for AR-picker, length of AR determination window [s] for Z-component, 1st pick
-0.4                                 #tpred1z#      %for AR-picker, length of AR prediction window [s] for Z-component, 1st pick
-0.6                                 #tdet2z#       %for AR-picker, length of AR determination window [s] for Z-component, 2nd pick
-0.2                                 #tpred2z#      %for AR-picker, length of AR prediction window [s] for Z-component, 2nd pick
-0.001                               #addnoise#     %add noise to seismogram for stable AR prediction
-3 0.1 0.5 0.1                       #tsnrz#        %for HOS/AR, window lengths for SNR-and slope estimation [tnoise,tsafetey,tsignal,tslope] [s]
-3                                   #pickwinP#     %for initial AIC pick, length of P-pick window [s]
-8                                   #Precalcwin#   %for HOS/AR, window length [s] for recalculation of CF (relative to 1st pick)
-0                                   #peps4aic#     %for HOS/AR, artificial uplift of samples of AIC-function (P)
-0.2                                 #aictsmooth#   %for HOS/AR, take average of samples for smoothing of AIC-function [s]
-0.1                                 #tsmoothP#     %for HOS/AR, take average of samples for smoothing CF [s]
-0.001                               #ausP#         %for HOS/AR, artificial uplift of samples (aus) of CF (P)
-1.3                                 #nfacP#        %for HOS/AR, noise factor for noise level determination (P)
-#H-components#
-ARH                                 #algoS#        %choose algorithm for S-onset determination (ARH or AR3)
-0.8                                 #tdet1h#       %for HOS/AR, length of AR-determination window [s], H-components, 1st pick
-0.4                                 #tpred1h#      %for HOS/AR, length of AR-prediction window [s], H-components, 1st pick
-0.6                                 #tdet2h#       %for HOS/AR, length of AR-determinaton window [s], H-components, 2nd pick
-0.3                                 #tpred2h#      %for HOS/AR, length of AR-prediction window [s], H-components, 2nd pick
-4                                   #Sarorder#     %for AR-picker, order of AR process of H-components
-6                                   #Srecalcwin#   %for AR-picker, window length [s] for recalculation of CF (2nd pick) (H)
-3                                   #pickwinS#     %for initial AIC pick, length of S-pick window [s]
-2 0.2 1.5 0.5                       #tsnrh#        %for ARH/AR3, window lengths for SNR-and slope estimation [tnoise,tsafetey,tsignal,tslope] [s]
-0.05                                #aictsmoothS#  %for AIC-picker, take average of samples for smoothing of AIC-function [s]
-0.02                                #tsmoothS#     %for AR-picker, take average of samples for smoothing CF [s] (S)
-0.2                                 #pepsS#        %for AR-picker, artificial uplift of samples of CF (S) 
-0.4                                 #ausS#         %for HOS/AR, artificial uplift of samples (aus) of CF (S)
-1.5                                 #nfacS#        %for AR-picker, noise factor for noise level determination (S)
-%first-motion picker%
-1                                   #minfmweight#  %minimum required p weight for first-motion determination
-2                                   #minFMSNR#     %miniumum required SNR for first-motion determination
-0.2                                 #fmpickwin#    %pick window around P onset for calculating zero crossings
-%quality assessment%
-#inital AIC onset#
-0.01 0.02 0.04 0.08                 #timeerrorsP#   %discrete time errors [s] corresponding to picking weights [0 1 2 3] for P
-0.04 0.08 0.16 0.32                 #timeerrorsS#   %discrete time errors [s] corresponding to picking weights [0 1 2 3] for S
-80                                  #minAICPslope#  %below this slope [counts/s] the initial P pick is rejected
-1.2                                 #minAICPSNR#    %below this SNR the initial P pick is rejected
-50                                  #minAICSslope#  %below this slope [counts/s] the initial S pick is rejected
-1.5                                 #minAICSSNR#    %below this SNR the initial S pick is rejected
-#check duration of signal using envelope function#
-1.5                                 #prepickwin#   %pre-signal window length [s] for noise level estimation 
-0.7                                 #minsiglength# %minimum required length of signal [s]
-0.2                                 #sgap#         %safety gap between noise and signal window [s]
-2                                   #noisefactor#  %noiselevel*noisefactor=threshold
-60                                  #minpercent#   %per cent of samples required higher than threshold
-#check for spuriously picked S-onsets#
-3.0                                 #zfac#         %P-amplitude must exceed zfac times RMS-S amplitude 
-#jackknife-processing for P-picks#
-3                                   #thresholdweight#%minimum required weight of picks
-3                                   #dttolerance#  %maximum allowed deviation of P picks from median [s]
-4                                   #minstats#     %minimum number of stations with reliable P picks
-3                                   #Sdttolerance# %maximum allowed deviation from Wadati-diagram
-

inputs/autoPyLoT_local.in

@@ -1,99 +0,0 @@
-%This is a parameter input file for autoPyLoT.
-%All main and special settings regarding data handling
-%and picking are to be set here!
-%Parameters are optimized for local data sets!
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-#main settings#
-/DATA/Insheim                       #rootpath#     %project path
-EVENT_DATA/LOCAL		    #datapath#     %data path
-2016.08_Insheim                     #database#     %name of data base
-e0007.224.16                        #eventID#      %event ID for single event processing
-/DATA/Insheim/STAT_INFO             #invdir#       %full path to inventory or dataless-seed file
-PILOT				    #datastructure#%choose data structure
-0                                   #iplot#        %flag for plotting: 0 none, 1 partly, >1 everything
-True                                #apverbose#    %choose 'True' or 'False' for terminal output
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-#NLLoc settings#
-/home/ludger/NLLOC                  #nllocbin#     %path to NLLoc executable
-/home/ludger/NLLOC/Insheim          #nllocroot#    %root of NLLoc-processing directory
-AUTOPHASES.obs                      #phasefile#    %name of autoPyLoT-output phase file for NLLoc
-                                                   %(in nllocroot/obs)
-Insheim_min1d032016_auto.in         #ctrfile#      %name of autoPyLoT-output control file for NLLoc
-                                                   %(in nllocroot/run)
-ttime                               #ttpatter#     %pattern of NLLoc ttimes from grid
-                                                   %(in nllocroot/times)
-AUTOLOC_nlloc                       #outpatter#    %pattern of NLLoc-output file
-                                                   %(returns 'eventID_outpatter')
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-#parameters for seismic moment estimation#
-3530                                #vp#           %average P-wave velocity
-2500                                #rho#          %average rock density [kg/m^3]
-300 0.8                             #Qp#           %quality factor for P waves ([Qp, ap], Qp*f^a)
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-AUTOFOCMEC_AIC_HOS4_ARH.in          #focmecin#     %name of focmec input file containing derived polarities
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-#common settings picker#
-15.0                                #pstart#       %start time [s] for calculating CF for P-picking
-60.0                                #pstop#        %end time [s] for calculating CF for P-picking
--1.0                                #sstart#       %start time [s] relative to P-onset for calculating CF for S-picking
-10.0                                #sstop#        %end time [s] after P-onset for calculating CF for S-picking
-2 20                                #bpz1#         %lower/upper corner freq. of first band pass filter Z-comp. [Hz]
-2 30                                #bpz2#         %lower/upper corner freq. of second band pass filter Z-comp. [Hz]
-2 15                                #bph1#         %lower/upper corner freq. of first band pass filter H-comp. [Hz]
-2 20                                #bph2#         %lower/upper corner freq. of second band pass filter z-comp. [Hz]
-#special settings for calculating CF#
-%!!Edit the following only if you know what you are doing!!%
-#Z-component#
-HOS                                 #algoP#        %choose algorithm for P-onset determination (HOS, ARZ, or AR3)
-7.0                                 #tlta#         %for HOS-/AR-AIC-picker, length of LTA window [s] 
-4                                   #hosorder#     %for HOS-picker, order of Higher Order Statistics
-2                                   #Parorder#     %for AR-picker, order of AR process of Z-component
-1.2                                 #tdet1z#       %for AR-picker, length of AR determination window [s] for Z-component, 1st pick
-0.4                                 #tpred1z#      %for AR-picker, length of AR prediction window [s] for Z-component, 1st pick
-0.6                                 #tdet2z#       %for AR-picker, length of AR determination window [s] for Z-component, 2nd pick
-0.2                                 #tpred2z#      %for AR-picker, length of AR prediction window [s] for Z-component, 2nd pick
-0.001                               #addnoise#     %add noise to seismogram for stable AR prediction
-3 0.1 0.5 0.5                       #tsnrz#        %for HOS/AR, window lengths for SNR-and slope estimation [tnoise,tsafetey,tsignal,tslope] [s]
-3.0                                 #pickwinP#     %for initial AIC pick, length of P-pick window [s]
-6.0                                 #Precalcwin#   %for HOS/AR, window length [s] for recalculation of CF (relative to 1st pick)
-0.2                                 #aictsmooth#   %for HOS/AR, take average of samples for smoothing of AIC-function [s]
-0.1                                 #tsmoothP#     %for HOS/AR, take average of samples for smoothing CF [s]
-0.001                               #ausP#         %for HOS/AR, artificial uplift of samples (aus) of CF (P)
-1.3                                 #nfacP#        %for HOS/AR, noise factor for noise level determination (P)
-#H-components#
-ARH                                 #algoS#        %choose algorithm for S-onset determination (ARH or AR3)
-0.8                                 #tdet1h#       %for HOS/AR, length of AR-determination window [s], H-components, 1st pick
-0.4                                 #tpred1h#      %for HOS/AR, length of AR-prediction window [s], H-components, 1st pick
-0.6                                 #tdet2h#       %for HOS/AR, length of AR-determinaton window [s], H-components, 2nd pick
-0.3                                 #tpred2h#      %for HOS/AR, length of AR-prediction window [s], H-components, 2nd pick
-4                                   #Sarorder#     %for AR-picker, order of AR process of H-components
-5.0                                 #Srecalcwin#   %for AR-picker, window length [s] for recalculation of CF (2nd pick) (H)
-3.0                                 #pickwinS#     %for initial AIC pick, length of S-pick window [s]
-2 0.2 1.5 0.5                       #tsnrh#        %for ARH/AR3, window lengths for SNR-and slope estimation [tnoise,tsafetey,tsignal,tslope] [s]
-0.5                                 #aictsmoothS#  %for AIC-picker, take average of samples for smoothing of AIC-function [s]
-0.7                                 #tsmoothS#     %for AR-picker, take average of samples for smoothing CF [s] (S)
-0.9                                 #ausS#         %for HOS/AR, artificial uplift of samples (aus) of CF (S)
-1.5                                 #nfacS#        %for AR-picker, noise factor for noise level determination (S)
-%first-motion picker%
-1                                   #minfmweight#  %minimum required P weight for first-motion determination
-2                                   #minFMSNR#     %miniumum required SNR for first-motion determination
-0.2                                 #fmpickwin#    %pick window around P onset for calculating zero crossings
-%quality assessment%
-#inital AIC onset#
-0.01 0.02 0.04 0.08                 #timeerrorsP#   %discrete time errors [s] corresponding to picking weights [0 1 2 3] for P
-0.04 0.08 0.16 0.32                 #timeerrorsS#   %discrete time errors [s] corresponding to picking weights [0 1 2 3] for S
-4                                   #minAICPslope#  %below this slope [counts/s] the initial P pick is rejected
-1.2                                 #minAICPSNR#    %below this SNR the initial P pick is rejected
-2                                   #minAICSslope#  %below this slope [counts/s] the initial S pick is rejected
-1.5                                 #minAICSSNR#    %below this SNR the initial S pick is rejected
-#check duration of signal using envelope function#
-3                                   #minsiglength# %minimum required length of signal [s]
-1.0                                 #noisefactor#  %noiselevel*noisefactor=threshold
-40                                  #minpercent#   %required percentage of samples higher than threshold
-#check for spuriously picked S-onsets#
-2.0                                 #zfac#         %P-amplitude must exceed at least zfac times RMS-S amplitude 
-#check statistics of P onsets#
-2.5                                 #mdttolerance#  %maximum allowed deviation of P picks from median [s]
-#wadati check#
-1.0                                 #wdttolerance# %maximum allowed deviation from Wadati-diagram
-

inputs/autoPyLoT_regional.in

@@ -1,100 +0,0 @@
-%This is a parameter input file for autoPyLoT.
-%All main and special settings regarding data handling
-%and picking are to be set here!
-%Parameters are optimized for regional data sets!
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-
-#main settings#
-/DATA/Egelados                      #rootpath#     %project path
-EVENT_DATA/LOCAL		    #datapath#     %data path
-2006.01_Nisyros                     #database#     %name of data base
-e1412.008.06                        #eventID#      %event ID for single event processing
-/DATA/Egelados/STAT_INFO            #invdir#       %full path to inventory or dataless-seed file
-PILOT				    #datastructure#  %choose data structure
-0                                   #iplot#        %flag for plotting: 0 none, 1, partly, >1 everything
-True                                #apverbose#    %choose 'True' or 'False' for terminal output
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-#NLLoc settings#
-/home/ludger/NLLOC                  #nllocbin#     %path to NLLoc executable
-/home/ludger/NLLOC/Insheim          #nllocroot#    %root of NLLoc-processing directory
-AUTOPHASES.obs                      #phasefile#    %name of autoPyLoT-output phase file for NLLoc
-                                                   %(in nllocroot/obs)
-Insheim_min1d2015_auto.in           #ctrfile#      %name of autoPyLoT-output control file for NLLoc
-                                                   %(in nllocroot/run)
-ttime                               #ttpatter#     %pattern of NLLoc ttimes from grid
-                                                   %(in nllocroot/times)
-AUTOLOC_nlloc                       #outpatter#    %pattern of NLLoc-output file
-                                                   %(returns 'eventID_outpatter')
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-#parameters for seismic moment estimation#
-3530                                #vp#           %average P-wave velocity
-2700                                #rho#          %average rock density [kg/m^3]
-1000f**0.8                          #Qp#           %quality factor for P waves (Qp*f^a)
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-AUTOFOCMEC_AIC_HOS4_ARH.in          #focmecin#     %name of focmec input file containing derived polarities
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-#common settings picker#
-20                                  #pstart#       %start time [s] for calculating CF for P-picking
-100                                 #pstop#        %end time [s] for calculating CF for P-picking
-1.0                                 #sstart#       %start time [s] after or before(-) P-onset for calculating CF for S-picking
-100                                 #sstop#        %end time [s] after P-onset for calculating CF for S-picking
-3 10                                #bpz1#         %lower/upper corner freq. of first band pass filter Z-comp. [Hz]
-3 12                                #bpz2#         %lower/upper corner freq. of second band pass filter Z-comp. [Hz]
-3 8                                 #bph1#         %lower/upper corner freq. of first band pass filter H-comp. [Hz]
-3 6                                 #bph2#         %lower/upper corner freq. of second band pass filter H-comp. [Hz]
-#special settings for calculating CF#
-%!!Be careful when editing the following!!
-#Z-component#
-HOS                                 #algoP#        %choose algorithm for P-onset determination (HOS, ARZ, or AR3)
-7                                   #tlta#         %for HOS-/AR-AIC-picker, length of LTA window [s] 
-4                                   #hosorder#     %for HOS-picker, order of Higher Order Statistics
-2                                   #Parorder#     %for AR-picker, order of AR process of Z-component
-1.2                                 #tdet1z#       %for AR-picker, length of AR determination window [s] for Z-component, 1st pick
-0.4                                 #tpred1z#      %for AR-picker, length of AR prediction window [s] for Z-component, 1st pick
-0.6                                 #tdet2z#       %for AR-picker, length of AR determination window [s] for Z-component, 2nd pick
-0.2                                 #tpred2z#      %for AR-picker, length of AR prediction window [s] for Z-component, 2nd pick
-0.001                               #addnoise#     %add noise to seismogram for stable AR prediction
-5 0.2 3.0 1.5                       #tsnrz#        %for HOS/AR, window lengths for SNR-and slope estimation [tnoise,tsafetey,tsignal,tslope] [s]
-3                                   #pickwinP#     %for initial AIC and refined pick, length of P-pick window [s]
-8                                   #Precalcwin#   %for HOS/AR, window length [s] for recalculation of CF (relative to 1st pick)
-1.0                                 #aictsmooth#   %for HOS/AR, take average of samples for smoothing of AIC-function [s]
-0.3                                 #tsmoothP#     %for HOS/AR, take average of samples for smoothing CF [s]
-0.3                                 #ausP#         %for HOS/AR, artificial uplift of samples (aus) of CF (P)
-1.3                                 #nfacP#        %for HOS/AR, noise factor for noise level determination (P)
-#H-components#
-ARH                                 #algoS#        %choose algorithm for S-onset determination (ARH or AR3)
-0.8                                 #tdet1h#       %for HOS/AR, length of AR-determination window [s], H-components, 1st pick
-0.4                                 #tpred1h#      %for HOS/AR, length of AR-prediction window [s], H-components, 1st pick
-0.6                                 #tdet2h#       %for HOS/AR, length of AR-determinaton window [s], H-components, 2nd pick
-0.3                                 #tpred2h#      %for HOS/AR, length of AR-prediction window [s], H-components, 2nd pick
-4                                   #Sarorder#     %for AR-picker, order of AR process of H-components
-10                                  #Srecalcwin#   %for AR-picker, window length [s] for recalculation of CF (2nd pick) (H)
-25                                  #pickwinS#     %for initial AIC and refined pick, length of S-pick window [s]
-5 0.2 3.0 3.0                       #tsnrh#        %for ARH/AR3, window lengths for SNR-and slope estimation [tnoise,tsafetey,tsignal,tslope] [s]
-3.5                                 #aictsmoothS#  %for AIC-picker, take average of samples for smoothing of AIC-function [s]
-1.0                                 #tsmoothS#     %for AR-picker, take average of samples for smoothing CF [s] (S)
-0.2                                 #ausS#         %for HOS/AR, artificial uplift of samples (aus) of CF (S)
-1.5                                 #nfacS#        %for AR-picker, noise factor for noise level determination (S)
-%first-motion picker%
-1                                   #minfmweight#  %minimum required p weight for first-motion determination
-2                                   #minFMSNR#     %miniumum required SNR for first-motion determination
-6.0                                 #fmpickwin#    %pick window around P onset for calculating zero crossings
-%quality assessment%
-#inital AIC onset#
-0.04 0.08 0.16 0.32                 #timeerrorsP#   %discrete time errors [s] corresponding to picking weights [0 1 2 3] for P
-0.04 0.08 0.16 0.32                 #timeerrorsS#   %discrete time errors [s] corresponding to picking weights [0 1 2 3] for S
-3                                   #minAICPslope#  %below this slope [counts/s] the initial P pick is rejected
-1.2                                 #minAICPSNR#    %below this SNR the initial P pick is rejected
-5                                   #minAICSslope#  %below this slope [counts/s] the initial S pick is rejected
-2.5                                 #minAICSSNR#    %below this SNR the initial S pick is rejected
-#check duration of signal using envelope function#
-30                                  #minsiglength# %minimum required length of signal [s]
-2.5                                 #noisefactor#  %noiselevel*noisefactor=threshold
-60                                  #minpercent#   %required percentage of samples higher than threshold
-#check for spuriously picked S-onsets#
-0.5                                 #zfac#         %P-amplitude must exceed at least zfac times RMS-S amplitude 
-#check statistics of P onsets#
-45                                  #mdttolerance#  %maximum allowed deviation of P picks from median [s]
-#wadati check#
-3.0                                 #wdttolerance# %maximum allowed deviation from Wadati-diagram
-

inputs/filter.in

@@ -1,2 +0,0 @@
-P bandpass 4 2.0 20.0
-S bandpass 4 2.0 15.0

inputs/pylot.in

@@ -1,98 +0,0 @@
-%This is a example parameter input file for PyLoT.
-%All main and special settings regarding data handling
-%and picking are to be set here!
-%Parameters shown here are optimized for local data sets!
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-#main settings#
-/data/Geothermie/Insheim            #rootpath#      %project path
-EVENT_DATA/LOCAL                    #datapath#      %data path
-2013.02_Insheim                     #database#      %name of data base
-e0019.048.13                        #eventID#       %event ID for single event processing
-/data/Geothermie/Insheim/STAT_INFO  #invdir#        %full path to  inventory or dataless-seed file
-PILOT                               #datastructure# %choose data structure
-0                                   #iplot#         %flag for plotting: 0 none, 1 partly, >1 everything
-True                                #apverbose#     %choose 'True' or 'False' for terminal output
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-#NLLoc settings#
-/progs/bin                          #nllocbin#      %path to NLLoc executable
-/data/Geothermie/Insheim/LOCALISATION/NLLoc          #nllocroot#     %root of NLLoc-processing directory
-AUTOPHASES.obs                      #phasefile#     %name of autoPyLoT-output phase file for NLLoc
-                                                    %(in nllocroot/obs)
-Insheim_min1d2015.in           #ctrfile#       %name of PyLoT-output control file for NLLoc
-                                                    %(in nllocroot/run)
-ttime                               #ttpatter#      %pattern of NLLoc ttimes from grid
-                                                    %(in nllocroot/times)
-AUTOLOC_nlloc                       #outpatter#     %pattern of NLLoc-output file
-                                                    %(returns 'eventID_outpatter')
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-#parameters for seismic moment estimation#
-3530                                #vp#            %average P-wave velocity
-2500                                #rho#           %average rock density [kg/m^3]
-300 0.8                           #Qp#            %quality factor for P waves (Qp*f^a); list(Qp, a)
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-AUTOFOCMEC_AIC_HOS4_ARH.in          #focmecin#      %name of focmec input file containing derived polarities
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-#common settings picker#
-15.0                                #pstart#        %start time [s] for calculating CF for P-picking
-60.0                                #pstop#         %end time [s] for calculating CF for P-picking
--1.0                                #sstart#        %start time [s] relative to P-onset for calculating CF for S-picking
-10.0                                #sstop#         %end time [s] after P-onset for calculating CF for S-picking
-2 20                                #bpz1#          %lower/upper corner freq. of first band pass filter Z-comp. [Hz]
-2 30                                #bpz2#          %lower/upper corner freq. of second band pass filter Z-comp. [Hz]
-2 15                                #bph1#          %lower/upper corner freq. of first band pass filter H-comp. [Hz]
-2 20                                #bph2#          %lower/upper corner freq. of second band pass filter z-comp. [Hz]
-#special settings for calculating CF#
-%!!Edit the following only if you know what you are doing!!%
-#Z-component#
-HOS                                 #algoP#         %choose algorithm for P-onset determination (HOS, ARZ, or AR3)
-7.0                                 #tlta#          %for HOS-/AR-AIC-picker, length of LTA window [s]
-4                                   #hosorder#      %for HOS-picker, order of Higher Order Statistics
-2                                   #Parorder#      %for AR-picker, order of AR process of Z-component
-1.2                                 #tdet1z#        %for AR-picker, length of AR determination window [s] for Z-component, 1st pick
-0.4                                 #tpred1z#       %for AR-picker, length of AR prediction window [s] for Z-component, 1st pick
-0.6                                 #tdet2z#        %for AR-picker, length of AR determination window [s] for Z-component, 2nd pick
-0.2                                 #tpred2z#       %for AR-picker, length of AR prediction window [s] for Z-component, 2nd pick
-0.001                               #addnoise#      %add noise to seismogram for stable AR prediction
-3 0.1 0.5 0.5                       #tsnrz#         %for HOS/AR, window lengths for SNR-and slope estimation [tnoise,tsafetey,tsignal,tslope] [s]
-3.0                                 #pickwinP#      %for initial AIC pick, length of P-pick window [s]
-6.0                                 #Precalcwin#    %for HOS/AR, window length [s] for recalculation of CF (relative to 1st pick)
-0.2                                 #aictsmooth#    %for HOS/AR, take average of samples for smoothing of AIC-function [s]
-0.1                                 #tsmoothP#      %for HOS/AR, take average of samples for smoothing CF [s]
-0.001                               #ausP#          %for HOS/AR, artificial uplift of samples (aus) of CF (P)
-1.3                                 #nfacP#         %for HOS/AR, noise factor for noise level determination (P)
-#H-components#
-ARH                                 #algoS#         %choose algorithm for S-onset determination (ARH or AR3)
-0.8                                 #tdet1h#        %for HOS/AR, length of AR-determination window [s], H-components, 1st pick
-0.4                                 #tpred1h#       %for HOS/AR, length of AR-prediction window [s], H-components, 1st pick
-0.6                                 #tdet2h#        %for HOS/AR, length of AR-determinaton window [s], H-components, 2nd pick
-0.3                                 #tpred2h#       %for HOS/AR, length of AR-prediction window [s], H-components, 2nd pick
-4                                   #Sarorder#      %for AR-picker, order of AR process of H-components
-5.0                                 #Srecalcwin#    %for AR-picker, window length [s] for recalculation of CF (2nd pick) (H)
-3.0                                 #pickwinS#      %for initial AIC pick, length of S-pick window [s]
-2 0.2 1.5 0.5                       #tsnrh#         %for ARH/AR3, window lengths for SNR-and slope estimation [tnoise,tsafetey,tsignal,tslope] [s]
-0.5                                 #aictsmoothS#   %for AIC-picker, take average of samples for smoothing of AIC-function [s]
-0.7                                 #tsmoothS#      %for AR-picker, take average of samples for smoothing CF [s] (S)
-0.9                                 #ausS#          %for HOS/AR, artificial uplift of samples (aus) of CF (S)
-1.5                                 #nfacS#         %for AR-picker, noise factor for noise level determination (S)
-%first-motion picker%
-1                                   #minfmweight#   %minimum required P weight for first-motion determination
-2                                   #minFMSNR#      %miniumum required SNR for first-motion determination
-0.2                                 #fmpickwin#     %pick window around P onset for calculating zero crossings
-%quality assessment%
-#inital AIC onset#
-0.01 0.02 0.04 0.08                 #timeerrorsP#   %discrete time errors [s] corresponding to picking weights [0 1 2 3] for P
-0.04 0.08 0.16 0.32                 #timeerrorsS#   %discrete time errors [s] corresponding to picking weights [0 1 2 3] for S
-4                                   #minAICPslope#  %below this slope [counts/s] the initial P pick is rejected
-1.2                                 #minAICPSNR#    %below this SNR the initial P pick is rejected
-2                                   #minAICSslope#  %below this slope [counts/s] the initial S pick is rejected
-1.5                                 #minAICSSNR#    %below this SNR the initial S pick is rejected
-#check duration of signal using envelope function#
-3                                   #minsiglength#  %minimum required length of signal [s]
-1.0                                 #noisefactor#   %noiselevel*noisefactor=threshold
-40                                  #minpercent#    %required percentage of samples higher than threshold
-#check for spuriously picked S-onsets#
-2.0                                 #zfac#          %P-amplitude must exceed at least zfac times RMS-S amplitude
-#check statistics of P onsets#
-2.5                                 #mdttolerance#  %maximum allowed deviation of P picks from median [s]
-#wadati check#
-1.0                                 #wdttolerance#  %maximum allowed deviation from Wadati-diagram

inputs/pylot_global.in

@@ -0,0 +1,100 @@
+%This is a parameter input file for PyLoT/autoPyLoT.
+%All main and special settings regarding data handling
+%and picking are to be set here!
+%Parameters are optimized for %extent data sets!
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+#main settings#
+                                                   #rootpath#       %project path                                                                                        
+                                                   #datapath#       %data path                                                                                           
+                                                   #database#       %name of data base                                                                                   
+                                                   #eventID#        %event ID for single event processing (* for all events found in database)                           
+                                                   #invdir#         %full path to  inventory or dataless-seed file                                                       
+PILOT                                              #datastructure#  %choose data structure                                                                               
+True                                               #apverbose#      %choose 'True' or 'False' for terminal output                                                        
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+#NLLoc settings#
+None                                               #nllocbin#       %path to NLLoc executable                                                                            
+None                                               #nllocroot#      %root of NLLoc-processing directory                                                                  
+None                                               #phasefile#      %name of autoPyLoT-output phase file for NLLoc                                                       
+None                                               #ctrfile#        %name of autoPyLoT-output control file for NLLoc                                                     
+ttime                                              #ttpatter#       %pattern of NLLoc ttimes from grid                                                                   
+AUTOLOC_nlloc                                      #outpatter#      %pattern of NLLoc-output file                                                                        
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+#parameters for seismic moment estimation#
+3530.0                                             #vp#             %average P-wave velocity                                                                             
+2500.0                                             #rho#            %average rock density [kg/m^3]                                                                       
+300.0 0.8                                          #Qp#             %quality factor for P waves (Qp*f^a); list(Qp, a)                                                    
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+#settings local magnitude#
+1.0 1.0 1.0                                        #WAscaling#      %Scaling relation (log(Ao)+Alog(r)+Br+C) of Wood-Anderson amplitude Ao [nm]                           If zeros are set, original Richter magnitude is calculated!
+1.0 1.0                                            #magscaling#     %Scaling relation for derived local magnitude [a*Ml+b].                            If zeros are set, no scaling of network magnitude is applied!
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+#filter settings#
+0.01 0.01                                          #minfreq#        %Lower filter frequency [P, S]                                                                       
+0.3 0.3                                            #maxfreq#        %Upper filter frequency [P, S]                                                                       
+3 3                                                #filter_order#   %filter order [P, S]                                                                                 
+bandpass bandpass                                  #filter_type#    %filter type (bandpass, bandstop, lowpass, highpass) [P, S]                                          
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+#common settings picker#
+global                                             #extent#         %extent of array ("local", "regional" or "global")                                                   
+-150.0                                             #pstart#         %start time [s] for calculating CF for P-picking (if TauPy: seconds relative to estimated onset)     
+600.0                                              #pstop#          %end time [s] for calculating CF for P-picking (if TauPy: seconds relative to estimated onset)       
+200.0                                              #sstart#         %start time [s] relative to P-onset for calculating CF for S-picking                                 
+1150.0                                             #sstop#          %end time [s] after P-onset for calculating CF for S-picking                                         
+True                                               #use_taup#       %use estimated traveltimes from TauPy for calculating windows for CF                                 
+iasp91                                             #taup_model#     %define TauPy model for traveltime estimation. Possible values: 1066a, 1066b, ak135, ak135f, herrin, iasp91, jb, prem, pwdk, sp6
+0.05 0.5                                           #bpz1#           %lower/upper corner freq. of first band pass filter Z-comp. [Hz]                                     
+0.001 0.5                                          #bpz2#           %lower/upper corner freq. of second band pass filter Z-comp. [Hz]                                    
+0.05 0.5                                           #bph1#           %lower/upper corner freq. of first band pass filter H-comp. [Hz]                                     
+0.001 0.5                                          #bph2#           %lower/upper corner freq. of second band pass filter z-comp. [Hz]                                    
+#special settings for calculating CF#
+%!!Edit the following only if you know what you are doing!!%
+#Z-component#
+HOS                                                #algoP#          %choose algorithm for P-onset determination (HOS, ARZ, or AR3)                                       
+150.0                                              #tlta#           %for HOS-/AR-AIC-picker, length of LTA window [s]                                                    
+4                                                  #hosorder#       %for HOS-picker, order of Higher Order Statistics                                                    
+2                                                  #Parorder#       %for AR-picker, order of AR process of Z-component                                                   
+16.0                                               #tdet1z#         %for AR-picker, length of AR determination window [s] for Z-component, 1st pick                      
+10.0                                               #tpred1z#        %for AR-picker, length of AR prediction window [s] for Z-component, 1st pick                         
+12.0                                               #tdet2z#         %for AR-picker, length of AR determination window [s] for Z-component, 2nd pick                      
+6.0                                                #tpred2z#        %for AR-picker, length of AR prediction window [s] for Z-component, 2nd pick                         
+0.001                                              #addnoise#       %add noise to seismogram for stable AR prediction                                                    
+60.0 10.0 40.0 10.0                                #tsnrz#          %for HOS/AR, window lengths for SNR-and slope estimation [tnoise, tsafetey, tsignal, tslope] [s]     
+150.0                                              #pickwinP#       %for initial AIC pick, length of P-pick window [s]                                                   
+35.0                                               #Precalcwin#     %for HOS/AR, window length [s] for recalculation of CF (relative to 1st pick)                        
+6.0                                                #aictsmooth#     %for HOS/AR, take average of samples for smoothing of AIC-function [s]                               
+4.0                                                #tsmoothP#       %for HOS/AR, take average of samples for smoothing CF [s]                                            
+0.001                                              #ausP#           %for HOS/AR, artificial uplift of samples (aus) of CF (P)                                            
+1.1                                                #nfacP#          %for HOS/AR, noise factor for noise level determination (P)                                          
+#H-components#
+ARH                                                #algoS#          %choose algorithm for S-onset determination (ARH or AR3)                                             
+12.0                                               #tdet1h#         %for HOS/AR, length of AR-determination window [s], H-components, 1st pick                           
+6.0                                                #tpred1h#        %for HOS/AR, length of AR-prediction window [s], H-components, 1st pick                              
+8.0                                                #tdet2h#         %for HOS/AR, length of AR-determinaton window [s], H-components, 2nd pick                            
+4.0                                                #tpred2h#        %for HOS/AR, length of AR-prediction window [s], H-components, 2nd pick                              
+4                                                  #Sarorder#       %for AR-picker, order of AR process of H-components                                                  
+30.0                                               #Srecalcwin#     %for AR-picker, window length [s] for recalculation of CF (2nd pick) (H)                             
+195.0                                              #pickwinS#       %for initial AIC pick, length of S-pick window [s]                                                   
+100.0 10.0 45.0 10.0                               #tsnrh#          %for ARH/AR3, window lengths for SNR-and slope estimation [tnoise, tsafetey, tsignal, tslope] [s]    
+22.0                                               #aictsmoothS#    %for AIC-picker, take average of samples for smoothing of AIC-function [s]                           
+10.0                                               #tsmoothS#       %for AR-picker, take average of samples for smoothing CF [s] (S)                                     
+0.001                                              #ausS#           %for HOS/AR, artificial uplift of samples (aus) of CF (S)                                            
+1.2                                                #nfacS#          %for AR-picker, noise factor for noise level determination (S)                                       
+#first-motion picker#
+1                                                  #minfmweight#    %minimum required P weight for first-motion determination                                            
+3.0                                                #minFMSNR#       %miniumum required SNR for first-motion determination                                                
+10.0                                               #fmpickwin#      %pick window around P onset for calculating zero crossings                                           
+#quality assessment#
+1.0 2.0 4.0 8.0                                    #timeerrorsP#    %discrete time errors [s] corresponding to picking weights [0 1 2 3] for P                           
+4.0 8.0 16.0 32.0                                  #timeerrorsS#    %discrete time errors [s] corresponding to picking weights [0 1 2 3] for S                           
+0.5                                                #minAICPslope#   %below this slope [counts/s] the initial P pick is rejected                                          
+1.1                                                #minAICPSNR#     %below this SNR the initial P pick is rejected                                                       
+1.0                                                #minAICSslope#   %below this slope [counts/s] the initial S pick is rejected                                          
+1.3                                                #minAICSSNR#     %below this SNR the initial S pick is rejected                                                       
+5.0                                                #minsiglength#   %length of signal part for which amplitudes must exceed noiselevel [s]                               
+1.0                                                #noisefactor#    %noiselevel*noisefactor=threshold                                                                    
+10.0                                               #minpercent#     %required percentage of amplitudes exceeding threshold                                               
+1.2                                                #zfac#           %P-amplitude must exceed at least zfac times RMS-S amplitude                                         
+25.0                                               #mdttolerance#   %maximum allowed deviation of P picks from median [s]                                                
+50.0                                               #wdttolerance#   %maximum allowed deviation from Wadati-diagram                                                       
+5.0                                                #jackfactor#     %pick is removed if the variance of the subgroup with the pick removed is larger than the mean variance of all subgroups times safety factor

inputs/pylot_local.in

@@ -0,0 +1,100 @@
+%This is a parameter input file for PyLoT/autoPyLoT.
+%All main and special settings regarding data handling
+%and picking are to be set here!
+%Parameters are optimized for %extent data sets!
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+#main settings#
+                                                   #rootpath#       %project path                                                                                        
+                                                   #datapath#       %data path                                                                                           
+                                                   #database#       %name of data base                                                                                   
+                                                   #eventID#        %event ID for single event processing (* for all events found in database)                           
+                                                   #invdir#         %full path to  inventory or dataless-seed file                                                       
+PILOT                                              #datastructure#  %choose data structure                                                                               
+True                                               #apverbose#      %choose 'True' or 'False' for terminal output                                                        
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+#NLLoc settings#
+None                                               #nllocbin#       %path to NLLoc executable                                                                            
+None                                               #nllocroot#      %root of NLLoc-processing directory                                                                  
+None                                               #phasefile#      %name of autoPyLoT-output phase file for NLLoc                                                       
+None                                               #ctrfile#        %name of autoPyLoT-output control file for NLLoc                                                     
+ttime                                              #ttpatter#       %pattern of NLLoc ttimes from grid                                                                   
+AUTOLOC_nlloc                                      #outpatter#      %pattern of NLLoc-output file                                                                        
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+#parameters for seismic moment estimation#
+3530.0                                             #vp#             %average P-wave velocity                                                                             
+2500.0                                             #rho#            %average rock density [kg/m^3]                                                                       
+300.0 0.8                                          #Qp#             %quality factor for P waves (Qp*f^a); list(Qp, a)                                                    
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+#settings local magnitude#
+1.11 0.0009 -2.0                                   #WAscaling#      %Scaling relation (log(Ao)+Alog(r)+Br+C) of Wood-Anderson amplitude Ao [nm]                           If zeros are set, original Richter magnitude is calculated!
+1.0382 -0.447                                      #magscaling#     %Scaling relation for derived local magnitude [a*Ml+b].                            If zeros are set, no scaling of network magnitude is applied!
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+#filter settings#
+1.0 1.0                                            #minfreq#        %Lower filter frequency [P, S]                                                                       
+10.0 10.0                                          #maxfreq#        %Upper filter frequency [P, S]                                                                       
+2 2                                                #filter_order#   %filter order [P, S]                                                                                 
+bandpass bandpass                                  #filter_type#    %filter type (bandpass, bandstop, lowpass, highpass) [P, S]                                          
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+#common settings picker#
+local                                              #extent#         %extent of array ("local", "regional" or "global")                                                   
+15.0                                               #pstart#         %start time [s] for calculating CF for P-picking                                                     
+60.0                                               #pstop#          %end time [s] for calculating CF for P-picking                                                       
+-1.0                                               #sstart#         %start time [s] relative to P-onset for calculating CF for S-picking                                 
+10.0                                               #sstop#          %end time [s] after P-onset for calculating CF for S-picking                                         
+True                                               #use_taup#       %use estimated traveltimes from TauPy for calculating windows for CF                                 
+iasp91                                             #taup_model#     %define TauPy model for traveltime estimation                                                        
+2.0 10.0                                           #bpz1#           %lower/upper corner freq. of first band pass filter Z-comp. [Hz]                                     
+2.0 12.0                                           #bpz2#           %lower/upper corner freq. of second band pass filter Z-comp. [Hz]                                    
+2.0 8.0                                            #bph1#           %lower/upper corner freq. of first band pass filter H-comp. [Hz]                                     
+2.0 10.0                                           #bph2#           %lower/upper corner freq. of second band pass filter z-comp. [Hz]                                    
+#special settings for calculating CF#
+%!!Edit the following only if you know what you are doing!!%
+#Z-component#
+HOS                                                #algoP#          %choose algorithm for P-onset determination (HOS, ARZ, or AR3)                                       
+7.0                                                #tlta#           %for HOS-/AR-AIC-picker, length of LTA window [s]                                                    
+4                                                  #hosorder#       %for HOS-picker, order of Higher Order Statistics                                                    
+2                                                  #Parorder#       %for AR-picker, order of AR process of Z-component                                                   
+1.2                                                #tdet1z#         %for AR-picker, length of AR determination window [s] for Z-component, 1st pick                      
+0.4                                                #tpred1z#        %for AR-picker, length of AR prediction window [s] for Z-component, 1st pick                         
+0.6                                                #tdet2z#         %for AR-picker, length of AR determination window [s] for Z-component, 2nd pick                      
+0.2                                                #tpred2z#        %for AR-picker, length of AR prediction window [s] for Z-component, 2nd pick                         
+0.001                                              #addnoise#       %add noise to seismogram for stable AR prediction                                                    
+3.0 0.1 0.5 1.0                                    #tsnrz#          %for HOS/AR, window lengths for SNR-and slope estimation [tnoise, tsafetey, tsignal, tslope] [s]     
+3.0                                                #pickwinP#       %for initial AIC pick, length of P-pick window [s]                                                   
+6.0                                                #Precalcwin#     %for HOS/AR, window length [s] for recalculation of CF (relative to 1st pick)                        
+0.2                                                #aictsmooth#     %for HOS/AR, take average of samples for smoothing of AIC-function [s]                               
+0.1                                                #tsmoothP#       %for HOS/AR, take average of samples for smoothing CF [s]                                            
+0.001                                              #ausP#           %for HOS/AR, artificial uplift of samples (aus) of CF (P)                                            
+1.3                                                #nfacP#          %for HOS/AR, noise factor for noise level determination (P)                                          
+#H-components#
+ARH                                                #algoS#          %choose algorithm for S-onset determination (ARH or AR3)                                             
+0.8                                                #tdet1h#         %for HOS/AR, length of AR-determination window [s], H-components, 1st pick                           
+0.4                                                #tpred1h#        %for HOS/AR, length of AR-prediction window [s], H-components, 1st pick                              
+0.6                                                #tdet2h#         %for HOS/AR, length of AR-determinaton window [s], H-components, 2nd pick                            
+0.3                                                #tpred2h#        %for HOS/AR, length of AR-prediction window [s], H-components, 2nd pick                              
+4                                                  #Sarorder#       %for AR-picker, order of AR process of H-components                                                  
+5.0                                                #Srecalcwin#     %for AR-picker, window length [s] for recalculation of CF (2nd pick) (H)                             
+4.0                                                #pickwinS#       %for initial AIC pick, length of S-pick window [s]                                                   
+2.0 0.3 1.5 1.0                                    #tsnrh#          %for ARH/AR3, window lengths for SNR-and slope estimation [tnoise, tsafetey, tsignal, tslope] [s]    
+1.0                                                #aictsmoothS#    %for AIC-picker, take average of samples for smoothing of AIC-function [s]                           
+0.7                                                #tsmoothS#       %for AR-picker, take average of samples for smoothing CF [s] (S)                                     
+0.9                                                #ausS#           %for HOS/AR, artificial uplift of samples (aus) of CF (S)                                            
+1.5                                                #nfacS#          %for AR-picker, noise factor for noise level determination (S)                                       
+#first-motion picker#
+1                                                  #minfmweight#    %minimum required P weight for first-motion determination                                            
+2.0                                                #minFMSNR#       %miniumum required SNR for first-motion determination                                                
+0.2                                                #fmpickwin#      %pick window around P onset for calculating zero crossings                                           
+#quality assessment#
+0.02 0.04 0.08 0.16                                #timeerrorsP#    %discrete time errors [s] corresponding to picking weights [0 1 2 3] for P                           
+0.04 0.08 0.16 0.32                                #timeerrorsS#    %discrete time errors [s] corresponding to picking weights [0 1 2 3] for S                           
+0.8                                                #minAICPslope#   %below this slope [counts/s] the initial P pick is rejected                                          
+1.1                                                #minAICPSNR#     %below this SNR the initial P pick is rejected                                                       
+1.0                                                #minAICSslope#   %below this slope [counts/s] the initial S pick is rejected                                          
+1.5                                                #minAICSSNR#     %below this SNR the initial S pick is rejected                                                       
+1.0                                                #minsiglength#   %length of signal part for which amplitudes must exceed noiselevel [s]                               
+1.0                                                #noisefactor#    %noiselevel*noisefactor=threshold                                                                    
+10.0                                               #minpercent#     %required percentage of amplitudes exceeding threshold                                               
+1.5                                                #zfac#           %P-amplitude must exceed at least zfac times RMS-S amplitude                                         
+6.0                                                #mdttolerance#   %maximum allowed deviation of P picks from median [s]                                                
+1.0                                                #wdttolerance#   %maximum allowed deviation from Wadati-diagram                                                       
+5.0                                                #jackfactor#     %pick is removed if the variance of the subgroup with the pick removed is larger than the mean variance of all subgroups times safety factor

inputs/pylot_regional.in

@@ -0,0 +1,100 @@
+%This is a parameter input file for PyLoT/autoPyLoT.
+%All main and special settings regarding data handling
+%and picking are to be set here!
+%Parameters are optimized for %extent data sets!
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+#main settings#
+                                                   #rootpath#       %project path                                                                                        
+                                                   #datapath#       %data path                                                                                           
+                                                   #database#       %name of data base                                                                                   
+                                                   #eventID#        %event ID for single event processing (* for all events found in database)                           
+                                                   #invdir#         %full path to  inventory or dataless-seed file                                                       
+PILOT                                              #datastructure#  %choose data structure                                                                               
+True                                               #apverbose#      %choose 'True' or 'False' for terminal output                                                        
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+#NLLoc settings#
+None                                               #nllocbin#       %path to NLLoc executable                                                                            
+None                                               #nllocroot#      %root of NLLoc-processing directory                                                                  
+None                                               #phasefile#      %name of autoPyLoT-output phase file for NLLoc                                                       
+None                                               #ctrfile#        %name of autoPyLoT-output control file for NLLoc                                                     
+ttime                                              #ttpatter#       %pattern of NLLoc ttimes from grid                                                                   
+AUTOLOC_nlloc                                      #outpatter#      %pattern of NLLoc-output file                                                                        
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+#parameters for seismic moment estimation#
+3530.0                                             #vp#             %average P-wave velocity                                                                             
+2500.0                                             #rho#            %average rock density [kg/m^3]                                                                       
+300.0 0.8                                          #Qp#             %quality factor for P waves (Qp*f^a); list(Qp, a)                                                    
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+#settings local magnitude#
+1.11 0.0009 -2.0                                   #WAscaling#      %Scaling relation (log(Ao)+Alog(r)+Br+C) of Wood-Anderson amplitude Ao [nm]                           If zeros are set, original Richter magnitude is calculated!
+1.0382 -0.447                                      #magscaling#     %Scaling relation for derived local magnitude [a*Ml+b].                            If zeros are set, no scaling of network magnitude is applied!
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+#filter settings#
+1.0 1.0                                            #minfreq#        %Lower filter frequency [P, S]                                                                       
+10.0 10.0                                          #maxfreq#        %Upper filter frequency [P, S]                                                                       
+2 2                                                #filter_order#   %filter order [P, S]                                                                                 
+bandpass bandpass                                  #filter_type#    %filter type (bandpass, bandstop, lowpass, highpass) [P, S]                                          
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+#common settings picker#
+local                                              #extent#         %extent of array ("local", "regional" or "global")                                                   
+15.0                                               #pstart#         %start time [s] for calculating CF for P-picking                                                     
+60.0                                               #pstop#          %end time [s] for calculating CF for P-picking                                                       
+-1.0                                               #sstart#         %start time [s] relative to P-onset for calculating CF for S-picking                                 
+10.0                                               #sstop#          %end time [s] after P-onset for calculating CF for S-picking                                         
+True                                               #use_taup#       %use estimated traveltimes from TauPy for calculating windows for CF                                 
+iasp91                                             #taup_model#     %define TauPy model for traveltime estimation                                                        
+2.0 10.0                                           #bpz1#           %lower/upper corner freq. of first band pass filter Z-comp. [Hz]                                     
+2.0 12.0                                           #bpz2#           %lower/upper corner freq. of second band pass filter Z-comp. [Hz]                                    
+2.0 8.0                                            #bph1#           %lower/upper corner freq. of first band pass filter H-comp. [Hz]                                     
+2.0 10.0                                           #bph2#           %lower/upper corner freq. of second band pass filter z-comp. [Hz]                                    
+#special settings for calculating CF#
+%!!Edit the following only if you know what you are doing!!%
+#Z-component#
+HOS                                                #algoP#          %choose algorithm for P-onset determination (HOS, ARZ, or AR3)                                       
+7.0                                                #tlta#           %for HOS-/AR-AIC-picker, length of LTA window [s]                                                    
+4                                                  #hosorder#       %for HOS-picker, order of Higher Order Statistics                                                    
+2                                                  #Parorder#       %for AR-picker, order of AR process of Z-component                                                   
+1.2                                                #tdet1z#         %for AR-picker, length of AR determination window [s] for Z-component, 1st pick                      
+0.4                                                #tpred1z#        %for AR-picker, length of AR prediction window [s] for Z-component, 1st pick                         
+0.6                                                #tdet2z#         %for AR-picker, length of AR determination window [s] for Z-component, 2nd pick                      
+0.2                                                #tpred2z#        %for AR-picker, length of AR prediction window [s] for Z-component, 2nd pick                         
+0.001                                              #addnoise#       %add noise to seismogram for stable AR prediction                                                    
+3.0 0.1 0.5 1.0                                    #tsnrz#          %for HOS/AR, window lengths for SNR-and slope estimation [tnoise, tsafetey, tsignal, tslope] [s]     
+3.0                                                #pickwinP#       %for initial AIC pick, length of P-pick window [s]                                                   
+6.0                                                #Precalcwin#     %for HOS/AR, window length [s] for recalculation of CF (relative to 1st pick)                        
+0.2                                                #aictsmooth#     %for HOS/AR, take average of samples for smoothing of AIC-function [s]                               
+0.1                                                #tsmoothP#       %for HOS/AR, take average of samples for smoothing CF [s]                                            
+0.001                                              #ausP#           %for HOS/AR, artificial uplift of samples (aus) of CF (P)                                            
+1.3                                                #nfacP#          %for HOS/AR, noise factor for noise level determination (P)                                          
+#H-components#
+ARH                                                #algoS#          %choose algorithm for S-onset determination (ARH or AR3)                                             
+0.8                                                #tdet1h#         %for HOS/AR, length of AR-determination window [s], H-components, 1st pick                           
+0.4                                                #tpred1h#        %for HOS/AR, length of AR-prediction window [s], H-components, 1st pick                              
+0.6                                                #tdet2h#         %for HOS/AR, length of AR-determinaton window [s], H-components, 2nd pick                            
+0.3                                                #tpred2h#        %for HOS/AR, length of AR-prediction window [s], H-components, 2nd pick                              
+4                                                  #Sarorder#       %for AR-picker, order of AR process of H-components                                                  
+5.0                                                #Srecalcwin#     %for AR-picker, window length [s] for recalculation of CF (2nd pick) (H)                             
+4.0                                                #pickwinS#       %for initial AIC pick, length of S-pick window [s]                                                   
+2.0 0.3 1.5 1.0                                    #tsnrh#          %for ARH/AR3, window lengths for SNR-and slope estimation [tnoise, tsafetey, tsignal, tslope] [s]    
+1.0                                                #aictsmoothS#    %for AIC-picker, take average of samples for smoothing of AIC-function [s]                           
+0.7                                                #tsmoothS#       %for AR-picker, take average of samples for smoothing CF [s] (S)                                     
+0.9                                                #ausS#           %for HOS/AR, artificial uplift of samples (aus) of CF (S)                                            
+1.5                                                #nfacS#          %for AR-picker, noise factor for noise level determination (S)                                       
+#first-motion picker#
+1                                                  #minfmweight#    %minimum required P weight for first-motion determination                                            
+2.0                                                #minFMSNR#       %miniumum required SNR for first-motion determination                                                
+0.2                                                #fmpickwin#      %pick window around P onset for calculating zero crossings                                           
+#quality assessment#
+0.02 0.04 0.08 0.16                                #timeerrorsP#    %discrete time errors [s] corresponding to picking weights [0 1 2 3] for P                           
+0.04 0.08 0.16 0.32                                #timeerrorsS#    %discrete time errors [s] corresponding to picking weights [0 1 2 3] for S                           
+0.8                                                #minAICPslope#   %below this slope [counts/s] the initial P pick is rejected                                          
+1.1                                                #minAICPSNR#     %below this SNR the initial P pick is rejected                                                       
+1.0                                                #minAICSslope#   %below this slope [counts/s] the initial S pick is rejected                                          
+1.5                                                #minAICSSNR#     %below this SNR the initial S pick is rejected                                                       
+1.0                                                #minsiglength#   %length of signal part for which amplitudes must exceed noiselevel [s]                               
+1.0                                                #noisefactor#    %noiselevel*noisefactor=threshold                                                                    
+10.0                                               #minpercent#     %required percentage of amplitudes exceeding threshold                                               
+1.5                                                #zfac#           %P-amplitude must exceed at least zfac times RMS-S amplitude                                         
+6.0                                                #mdttolerance#   %maximum allowed deviation of P picks from median [s]                                                
+1.0                                                #wdttolerance#   %maximum allowed deviation from Wadati-diagram                                                       
+5.0                                                #jackfactor#     %pick is removed if the variance of the subgroup with the pick removed is larger than the mean variance of all subgroups times safety factor

makePyLoT.py

@@ -158,24 +158,29 @@ def buildPyLoT(verbosity=None):
 
 
 def installPyLoT(verbosity=None):
-    files_to_copy = {'autoPyLoT_local.in':['~', '.pylot'],
-                     'autoPyLoT_regional.in':['~', '.pylot'],
-                     'filter.in':['~', '.pylot']}
+    files_to_copy = {'pylot_local.in': ['~', '.pylot'],
+                     'pylot_regional.in': ['~', '.pylot'],
+                     'pylot_global.in': ['~', '.pylot']}
     if verbosity > 0:
-        print ('starting installation of PyLoT ...')
+        print('starting installation of PyLoT ...')
     if verbosity > 1:
-        print ('copying input files into destination folder ...')
+        print('copying input files into destination folder ...')
     ans = input('please specify scope of interest '
-                '([0]=local, 1=regional) :') or 0
+                '([0]=local, 1=regional, 2=global) :') or 0
     if not isinstance(ans, int):
         ans = int(ans)
-    ans = 'local' if ans is 0 else 'regional'
+    if ans == 0:
+        ans = 'local'
+    elif ans == 1:
+        ans = 'regional'
+    elif ans == 2:
+        ans = 'global'
     link_dest = []
     for file, destination in files_to_copy.items():
         link_file = ans in file
         if link_file:
             link_dest = copy.deepcopy(destination)
-            link_dest.append('autoPyLoT.in')
+            link_dest.append('pylot.in')
             link_dest = os.path.join(*link_dest)
         destination.append(file)
         destination = os.path.join(*destination)
@@ -183,7 +188,7 @@ def installPyLoT(verbosity=None):
         assert not os.path.isabs(srcfile), 'source files seem to be ' \
                                            'corrupted ...'
         if verbosity > 1:
-            print ('copying file {file} to folder {dest}'.format(file=file, dest=destination))
+            print('copying file {file} to folder {dest}'.format(file=file, dest=destination))
         shutil.copyfile(srcfile, destination)
         if link_file:
             if verbosity:
@@ -191,8 +196,6 @@ def installPyLoT(verbosity=None):
             os.symlink(destination, link_dest)
 
 
-
-
 def cleanUp(verbosity=None):
     if verbosity >= 1:
         print('cleaning up build files...')

pylot/RELEASE-VERSION

@@ -1 +0,0 @@
-0.1a

pylot/core/analysis/magnitude.py

@@ -2,28 +2,33 @@
 # -*- coding: utf-8 -*-
 """
 Created autumn/winter 2015.
+Revised/extended summer 2017.
 
 :author: Ludger Küperkoch / MAGS2 EP3 working group
 """
-import os
-
 import matplotlib.pyplot as plt
 import numpy as np
 import obspy.core.event as ope
 from obspy.geodetics import degrees2kilometers
-from scipy import integrate, signal
-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
+from scipy import integrate, signal
+from scipy.optimize import curve_fit
 
 
 def richter_magnitude_scaling(delta):
-    relation = np.loadtxt(os.path.join(os.path.expanduser('~'),
-                                       '.pylot', 'richter_scaling.data'))
+    distance = np.array([0, 10, 20, 25, 30, 35, 40, 45, 50, 60, 70, 75, 85, 90, 100, 110,
+                         120, 130, 140, 150, 160, 170, 180, 190, 200, 210, 230, 240, 250,
+                         260, 270, 280, 290, 300, 310, 320, 330, 340, 350, 360, 370, 380,
+                         390, 400, 430, 470, 510, 560, 600, 700, 800, 900, 1000])
+    richter_scaling = np.array([1.4, 1.5, 1.7, 1.9, 2.1, 2.3, 2.4, 2.5, 2.6, 2.8, 2.8, 2.9,
+                                2.9, 3.0, 3.1, 3.1, 3.2, 3.2, 3.3, 3.3, 3.4, 3.4, 3.5, 3.5,
+                                3.6, 3.7, 3.7, 3.8, 3.8, 3.9, 3.9, 4.0, 4.0, 4.1, 4.2, 4.2,
+                                4.2, 4.2, 4.3, 4.3, 4.3, 4.4, 4.4, 4.5, 4.6, 4.7, 4.8, 4.9,
+                                5.1, 5.2, 5.4, 5.5, 5.7])
     # prepare spline interpolation to calculate return value
-    func, params = fit_curve(relation[:, 0], relation[:, 1])
+    func, params = fit_curve(distance, richter_scaling)
     return func(delta, params)
 
 
@@ -34,15 +39,15 @@ class Magnitude(object):
 
     def __init__(self, stream, event, verbosity=False, iplot=0):
         self._type = "M"
+        self._stream = stream
         self._plot_flag = iplot
         self._verbosity = verbosity
         self._event = event
-        self._stream = stream
         self._magnitudes = dict()
 
     def __str__(self):
         print(
-        'number of stations used: {0}\n'.format(len(self.magnitudes.values())))
+            '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))
 
@@ -111,28 +116,35 @@ class Magnitude(object):
     def calc(self):
         pass
 
-    def updated_event(self):
-        self.event.magnitudes.append(self.net_magnitude())
+    def updated_event(self, magscaling=None):
+        self.event.magnitudes.append(self.net_magnitude(magscaling))
         return self.event
 
-    def net_magnitude(self):
+    def net_magnitude(self, magscaling=None):
         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)
+            if magscaling is not None and str(magscaling) is not '[0.0, 0.0]':
+                # scaling necessary
+                print("Scaling network magnitude ...")
+                mag = ope.Magnitude(
+                    mag=np.median([M.mag for M in self.magnitudes.values()]) * \
+                        magscaling[0] + magscaling[1],
+                    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)
+            else:
+                # no saling necessary
+                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 RichterMagnitude(Magnitude):
+class LocalMagnitude(Magnitude):
     """
     Method to derive peak-to-peak amplitude as seen on a Wood-Anderson-
     seismograph. Has to be derived from instrument corrected traces!
@@ -149,10 +161,11 @@ class RichterMagnitude(Magnitude):
 
     _amplitudes = dict()
 
-    def __init__(self, stream, event, calc_win, verbosity=False, iplot=0):
-        super(RichterMagnitude, self).__init__(stream, event, verbosity, iplot)
+    def __init__(self, stream, event, calc_win, wascaling, verbosity=False, iplot=0):
+        super(LocalMagnitude, self).__init__(stream, event, verbosity, iplot)
 
         self._calc_win = calc_win
+        self._wascaling = wascaling
         self._type = 'ML'
         self.calc()
 
@@ -164,6 +177,10 @@ class RichterMagnitude(Magnitude):
     def calc_win(self, value):
         self._calc_win = value
 
+    @property
+    def wascaling(self):
+        return self._wascaling
+
     @property
     def amplitudes(self):
         return self._amplitudes
@@ -175,6 +192,14 @@ class RichterMagnitude(Magnitude):
 
     def peak_to_peak(self, st, t0):
 
+        try:
+            iplot = int(self.plot_flag)
+        except:
+            if self.plot_flag == True or self.plot_flag == 'True':
+                iplot = 2
+            else:
+                iplot = 0
+
         # simulate Wood-Anderson response
         st.simulate(paz_remove=None, paz_simulate=self._paz)
 
@@ -198,28 +223,29 @@ class RichterMagnitude(Magnitude):
         th = np.arange(0, len(sqH) * dt, dt)
         # get maximum peak within pick window
         iwin = getsignalwin(th, t0 - stime, self.calc_win)
+        ii = min([iwin[len(iwin) - 1], len(th)])
+        iwin = iwin[0:ii]
         wapp = np.max(sqH[iwin])
         if self.verbose:
-            print("Determined Wood-Anderson peak-to-peak amplitude: {0} "
-                  "mm".format(wapp))
+            print("Determined Wood-Anderson peak-to-peak amplitude for station {0}: {1} "
+                  "mm".format(st[0].stats.station, wapp))
 
         # check for plot flag (for debugging only)
-        if self.plot_flag > 1:
+        fig = None
+        if iplot > 1:
             st.plot()
-            f = plt.figure(2)
-            plt.plot(th, sqH)
-            plt.plot(th[iwin], sqH[iwin], 'g')
-            plt.plot([t0, t0], [0, max(sqH)], 'r', linewidth=2)
-            plt.title(
+            fig = plt.figure()
+            ax = fig.add_subplot(111)
+            ax.plot(th, sqH)
+            ax.plot(th[iwin], sqH[iwin], 'g')
+            ax.plot([t0, t0], [0, max(sqH)], 'r', linewidth=2)
+            ax.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)
+            ax.set_xlabel('Time [s]')
+            ax.set_ylabel('Displacement [mm]')
 
-        return wapp
+        return wapp, fig
 
     def calc(self):
         for a in self.arrivals:
@@ -232,12 +258,12 @@ class RichterMagnitude(Magnitude):
             if not wf:
                 if self.verbose:
                     print(
-                    'WARNING: no waveform data found for station {0}'.format(
-                        station))
+                        '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)
+            a0, self.p2p_fig = self.peak_to_peak(wf, onset)
             amplitude = ope.Amplitude(generic_amplitude=a0 * 1e-3)
             amplitude.unit = 'm'
             amplitude.category = 'point'
@@ -248,10 +274,18 @@ class RichterMagnitude(Magnitude):
             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))
+            # or scale WA amplitude with given scaling relation
+            if str(self.wascaling) == '[0.0, 0.0, 0.0]':
+                print("Calculating original Richter magnitude ...")
+                magnitude = ope.StationMagnitude(mag=np.log10(a0) \
+                                                     + richter_magnitude_scaling(delta))
+            else:
+                print("Calculating scaled local magnitude ...")
+                a0 = a0 * 1e03  # mm to nm (see Havskov & Ottemöller, 2010)
+                magnitude = ope.StationMagnitude(mag=np.log10(a0) \
+                                                     + self.wascaling[0] * np.log10(delta) + self.wascaling[1]
+                                                                                             * delta + self.wascaling[
+                                                         2])
             magnitude.origin_id = self.origin_id
             magnitude.waveform_id = pick.waveform_id
             magnitude.amplitude_id = amplitude.resource_id
@@ -317,8 +351,8 @@ class MomentMagnitude(Magnitude):
                 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)
+            scopy = self.stream.copy()
+            wf = scopy.select(station=station)
             if not wf:
                 continue
             onset = pick.time
@@ -326,15 +360,16 @@ class MomentMagnitude(Magnitude):
             azimuth = a.azimuth
             incidence = a.takeoff_angle
             w0, fc = calcsourcespec(wf, onset, self.p_velocity, distance,
-                                    azimuth,
-                                    incidence, self.p_attenuation,
+                                    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,
+            WF = select_for_phase(self.stream.select(
+                station=station), a.phase)
+            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)
@@ -371,8 +406,8 @@ def calcMoMw(wfstream, w0, rho, vp, delta, verbosity=False):
 
     if verbosity:
         print(
-        "calcMoMw: Calculating seismic moment Mo and moment magnitude Mw for station {0} ...".format(
-            tr.stats.station))
+            "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(
@@ -386,8 +421,8 @@ def calcMoMw(wfstream, w0, rho, vp, delta, verbosity=False):
 
     if verbosity:
         print(
-        "calcMoMw: Calculated seismic moment Mo = {0} Nm => Mw = {1:3.1f} ".format(
-            Mo, Mw))
+            "calcMoMw: Calculated seismic moment Mo = {0} Nm => Mw = {1:3.1f} ".format(
+                Mo, Mw))
 
     return Mo, Mw
 
@@ -426,7 +461,15 @@ def calcsourcespec(wfstream, onset, vp, delta, azimuth, incidence,
     :type:  integer
     '''
     if verbosity:
-        print ("Calculating source spectrum ....")
+        print("Calculating source spectrum for station %s ...." % wfstream[0].stats.station)
+
+    try:
+        iplot = int(iplot)
+    except:
+        if iplot == True or iplot == 'True':
+            iplot = 2
+        else:
+            iplot = 0
 
     # get Q value
     Q, A = qp
@@ -453,18 +496,21 @@ def calcsourcespec(wfstream, onset, vp, delta, azimuth, incidence,
     LQT = wfstream.rotate('ZNE->LQT', azimuth, incidence)
     ldat = LQT.select(component="L")
     if len(ldat) == 0:
-        # if horizontal channels are 2 and 3
+        # if horizontal channels are 1 and 2
         # 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")
+        # instead, use component 3
+        ldat = LQT.select(component="3")
+        if len(ldat) == 0:
+            # maybe component z available
+            ldat = LQT.select(component="Z")
 
     # integrate to displacement
     # unrotated vertical component (for comparison)
     inttrz = signal.detrend(integrate.cumtrapz(zdat[0].data, None, dt))
-
     # rotated component Z => L
     Ldat = signal.detrend(integrate.cumtrapz(ldat[0].data, None, dt))
 
@@ -480,9 +526,9 @@ def calcsourcespec(wfstream, onset, vp, delta, azimuth, incidence,
     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!")
+            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
@@ -527,22 +573,24 @@ def calcsourcespec(wfstream, onset, vp, delta, azimuth, incidence,
         # 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]
+        w0 = optspecfit[0]
+        fc = optspecfit[1]
+        # w01 = optspecfit[0]
+        # fc1 = optspecfit[1]
         if verbosity:
-            print ("calcsourcespec: Determined w0-value: %e m/Hz, \n"
-                   "Determined corner frequency: %f Hz" % (w01, fc1))
+            print("calcsourcespec: Determined w0-value: %e m/Hz, \n"
+                  "calcsourcespec: Determined corner frequency: %f Hz" % (w0, fc))
 
-        # use of conventional fitting
-        [w02, fc2] = fitSourceModel(F, YYcor, Fcin, iplot, verbosity)
+            # 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))
+            # 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()
@@ -569,18 +617,15 @@ def calcsourcespec(wfstream, onset, vp, delta, azimuth, incidence,
             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', \
+            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
 
@@ -622,23 +667,48 @@ def fitSourceModel(f, S, fc0, iplot, verbosity=False):
     :type:   float
     '''
 
+    try:
+        iplot = int(iplot)
+    except:
+        if iplot == True or iplot == 'True':
+            iplot = 2
+        else:
+            iplot = 0
+
     w0 = []
     stdw0 = []
     fc = []
     stdfc = []
     STD = []
-
     # get window around initial corner frequency for trials
-    fcstopl = fc0 - max(1, len(f) / 10)
-    il = np.argmin(abs(f - fcstopl))
-    fcstopl = f[il]
-    fcstopr = fc0 + min(len(f), len(f) / 10)
-    ir = np.argmin(abs(f - fcstopr))
-    fcstopr = f[ir]
-    iF = np.where((f >= fcstopl) & (f <= fcstopr))
+    # left side of initial corner frequency
+    fcstopl = max(f[0], fc0 - max(1, fc0 / 2))
+    il = np.where(f <= fcstopl)
+    il = il[0][np.size(il) - 1]
+    # right side of initial corner frequency
+    fcstopr = min(fc0 + (fc0 / 2), f[len(f) - 1])
+    ir = np.where(f >= fcstopr)
+    # check, if fcstopr is available
+    if np.size(ir) == 0:
+        fcstopr = fc0
+        ir = len(f) - 1
+    else:
+        ir = ir[0][0]
 
     # vary corner frequency around initial point
-    for i in range(il, ir):
+    print("fitSourceModel: Varying corner frequency "
+          "around initial corner frequency ...")
+    # check difference of il and ir in order to
+    # keep calculation time acceptable
+    idiff = ir - il
+    if idiff > 10000:
+        increment = 100
+    elif idiff <= 20:
+        increment = 1
+    else:
+        increment = 10
+
+    for i in range(il, ir, increment):
         FC = f[i]
         indexdc = np.where((f > 0) & (f <= FC))
         dc = np.mean(S[indexdc])
@@ -662,10 +732,10 @@ def fitSourceModel(f, S, fc0, iplot, verbosity=False):
         w0 = max(S)
     if verbosity:
         print(
-        "fitSourceModel: best fc: {0} Hz, best w0: {1} m/Hz".format(fc, w0))
+            "fitSourceModel: best fc: {0} Hz, best w0: {1} m/Hz".format(fc, w0))
 
     if iplot > 1:
-        plt.figure(iplot)
+        plt.figure()  # iplot)
         plt.loglog(f, S, 'k')
         plt.loglog([f[0], fc], [w0, w0], 'g')
         plt.loglog([fc, fc], [w0 / 100, w0], 'g')
@@ -674,7 +744,7 @@ def fitSourceModel(f, S, fc0, iplot, verbosity=False):
         plt.xlabel('Frequency [Hz]')
         plt.ylabel('Amplitude [m/Hz]')
         plt.grid()
-        plt.figure(iplot + 1)
+        plt.figure()  # iplot + 1)
         plt.subplot(311)
         plt.plot(f[il:ir], STD, '*')
         plt.title('Common Standard Deviations')
@@ -687,8 +757,5 @@ def fitSourceModel(f, S, fc0, iplot, verbosity=False):
         plt.plot(f[il:ir], stdfc, '*')
         plt.title('Standard Deviations of Corner Frequencies')
         plt.xlabel('Corner Frequencies [Hz]')
-        plt.show()
-        raw_input()
-        plt.close()
 
     return w0, fc

pylot/core/io/data.py

@@ -3,14 +3,17 @@
 
 import copy
 import os
+
 from obspy import read_events
 from obspy.core import read, Stream, UTCDateTime
-from obspy.core.event import Event
-
+from obspy.core.event import Event as ObsPyEvent
+from obspy.io.sac import SacIOError
 from pylot.core.io.phases import readPILOTEvent, picks_from_picksdict, \
     picksdict_from_pilot, merge_picks
 from pylot.core.util.errors import FormatError, OverwriteError
+from pylot.core.util.event import Event
 from pylot.core.util.utils import fnConstructor, full_range
+import pylot.core.loc.velest as velest
 
 
 class Data(object):
@@ -34,12 +37,12 @@ class Data(object):
             self.comp = 'Z'
             self.wfdata = Stream()
         self._new = False
-        if isinstance(evtdata, Event):
+        if isinstance(evtdata, ObsPyEvent) or isinstance(evtdata, Event):
             pass
         elif isinstance(evtdata, dict):
             evt = readPILOTEvent(**evtdata)
             evtdata = evt
-        elif isinstance(evtdata, basestring):
+        elif isinstance(evtdata, str):
             try:
                 cat = read_events(evtdata)
                 if len(cat) is not 1:
@@ -50,7 +53,7 @@ class Data(object):
                 if 'Unknown format for file' in e.message:
                     if 'PHASES' in evtdata:
                         picks = picksdict_from_pilot(evtdata)
-                        evtdata = Event()
+                        evtdata = ObsPyEvent()
                         evtdata.picks = picks_from_picksdict(picks)
                     elif 'LOC' in evtdata:
                         raise NotImplementedError('PILOT location information '
@@ -62,7 +65,7 @@ class Data(object):
                     raise e
         else:  # create an empty Event object
             self.setNew()
-            evtdata = Event()
+            evtdata = ObsPyEvent()
             evtdata.picks = []
         self.evtdata = evtdata
         self.wforiginal = None
@@ -74,6 +77,8 @@ class Data(object):
 
     def __add__(self, other):
         assert isinstance(other, Data), "operands must be of same type 'Data'"
+        rs_id = self.get_evt_data().get('resource_id')
+        rs_id_other = other.get_evt_data().get('resource_id')
         if other.isNew() and not self.isNew():
             picks_to_add = other.get_evt_data().picks
             old_picks = self.get_evt_data().picks
@@ -85,7 +90,7 @@ class Data(object):
             self.evtdata = new.get_evt_data()
         elif self.isNew() and other.isNew():
             pass
-        elif self.get_evt_data().get('id') == other.get_evt_data().get('id'):
+        elif rs_id == rs_id_other:
             other.setNew()
             return self + other
         else:
@@ -145,16 +150,57 @@ class Data(object):
         # handle forbidden filenames especially on windows systems
         return fnConstructor(str(ID))
 
-    def exportEvent(self, fnout, fnext='.xml'):
+    def checkEvent(self, event, fcheck, forceOverwrite=False):
+        if 'origin' in fcheck:
+            self.replaceOrigin(event, forceOverwrite)
+        if 'magnitude' in fcheck:
+            self.replaceMagnitude(event, forceOverwrite)
+        if 'auto' in fcheck:
+            self.replacePicks(event, 'auto')
+        if 'manual' in fcheck:
+            self.replacePicks(event, 'manual')
+
+    def replaceOrigin(self, event, forceOverwrite=False):
+        if self.get_evt_data().origins or forceOverwrite:
+            if event.origins:
+                print("Found origin, replace it by new origin.")
+            event.origins = self.get_evt_data().origins
+
+    def replaceMagnitude(self, event, forceOverwrite=False):
+        if self.get_evt_data().magnitudes or forceOverwrite:
+            if event.magnitudes:
+                print("Found magnitude, replace it by new magnitude")
+            event.magnitudes = self.get_evt_data().magnitudes
+
+    def replacePicks(self, event, picktype):
+        checkflag = 0
+        picks = event.picks
+        # remove existing picks
+        for j, pick in reversed(list(enumerate(picks))):
+            if picktype in str(pick.method_id.id):
+                picks.pop(j)
+                checkflag = 1
+        if checkflag:
+            print("Found %s pick(s), remove them and append new picks to catalog." % picktype)
+
+        # append new picks
+        for pick in self.get_evt_data().picks:
+            if picktype in str(pick.method_id.id):
+                picks.append(pick)
+
+    def exportEvent(self, fnout, fnext='.xml', fcheck='auto', upperErrors=None):
 
         """
-
-        :param fnout:
-        :param fnext:
-        :raise KeyError:
+        :param fnout: basename of file
+        :param fnext: file extension
+        :param fcheck: check and delete existing information
+        can be a str or a list of strings of ['manual', 'auto', 'origin', 'magnitude']
         """
         from pylot.core.util.defaults import OUTPUTFORMATS
 
+        if not type(fcheck) == list:
+            fcheck = [fcheck]
+
         try:
             evtformat = OUTPUTFORMATS[fnext]
         except KeyError as e:
@@ -162,12 +208,99 @@ class Data(object):
                      'supported'.format(e, fnext)
             raise FormatError(errmsg)
 
-        # try exporting event via ObsPy
-        try:
+        # check for already existing xml-file
+        if fnext == '.xml':
+            if os.path.isfile(fnout + fnext):
+                print("xml-file already exists! Check content ...")
+                cat = read_events(fnout + fnext)
+                if len(cat) > 1:
+                    raise IOError('Ambigious event information in file {}'.format(fnout + fnext))
+                if len(cat) < 1:
+                    raise IOError('No event information in file {}'.format(fnout + fnext))
+                event = cat[0]
+                if not event.resource_id == self.get_evt_data().resource_id:
+                    raise IOError("Missmatching event resource id's: {} and {}".format(event.resource_id,
+                                                                                       self.get_evt_data().resource_id))
+                self.checkEvent(event, fcheck)
+                self.setEvtData(event)
             self.get_evt_data().write(fnout + fnext, format=evtformat)
-        except KeyError as e:
-            raise KeyError('''{0} export format
-                              not implemented: {1}'''.format(evtformat, e))
+        # try exporting event  
+        else:
+            evtdata_org = self.get_evt_data()
+            picks = evtdata_org.picks
+            eventpath = evtdata_org.path
+            picks_copy = copy.deepcopy(picks)
+            evtdata_copy = Event(eventpath)
+            evtdata_copy.picks = picks_copy
+
+            # check for stations picked automatically as well as manually
+            # Prefer manual picks!
+            for i in range(len(picks)):
+                if picks[i].method_id == 'manual':
+                    mstation = picks[i].waveform_id.station_code
+                    mstation_ext = mstation + '_'
+                    for k in range(len(picks_copy)):
+                        if ((picks_copy[k].waveform_id.station_code == mstation) or
+                                (picks_copy[k].waveform_id.station_code == mstation_ext)) and \
+                                (picks_copy[k].method_id == 'auto'):
+                            del picks_copy[k]
+                            break
+            lendiff = len(picks) - len(picks_copy)
+            if lendiff is not 0:
+                print("Manual as well as automatic picks available. Prefered the {} manual ones!".format(lendiff))
+
+            if upperErrors:
+                # check for pick uncertainties exceeding adjusted upper errors
+                # Picks with larger uncertainties will not be saved in output file!
+                for j in range(len(picks)):
+                    for i in range(len(picks_copy)):
+                        if picks_copy[i].phase_hint[0] == 'P':
+                            if (picks_copy[i].time_errors['upper_uncertainty'] >= upperErrors[0]) or \
+                                    (picks_copy[i].time_errors['uncertainty'] == None):
+                                print("Uncertainty exceeds or equal adjusted upper time error!")
+                                print("Adjusted uncertainty: {}".format(upperErrors[0]))
+                                print("Pick uncertainty: {}".format(picks_copy[i].time_errors['uncertainty']))
+                                print("{1} P-Pick of station {0} will not be saved in outputfile".format(
+                                    picks_copy[i].waveform_id.station_code,
+                                    picks_copy[i].method_id))
+                                print("#")
+                                del picks_copy[i]
+                                break
+                        if picks_copy[i].phase_hint[0] == 'S':
+                            if (picks_copy[i].time_errors['upper_uncertainty'] >= upperErrors[1]) or \
+                                    (picks_copy[i].time_errors['uncertainty'] == None):
+                                print("Uncertainty exceeds or equal adjusted upper time error!")
+                                print("Adjusted uncertainty: {}".format(upperErrors[1]))
+                                print("Pick uncertainty: {}".format(picks_copy[i].time_errors['uncertainty']))
+                                print("{1} S-Pick of station {0} will not be saved in outputfile".format(
+                                    picks_copy[i].waveform_id.station_code,
+                                    picks_copy[i].method_id))
+                                print("#")
+                                del picks_copy[i]
+                                break
+
+            if fnext == '.obs':
+                try:
+                    evtdata_copy.write(fnout + fnext, format=evtformat)
+                    # write header afterwards
+                    evid = str(evtdata_org.resource_id).split('/')[1]
+                    header = '# EQEVENT:  Label: EQ%s  Loc:  X 0.00  Y 0.00  Z 10.00  OT 0.00 \n' % evid
+                    nllocfile = open(fnout + fnext)
+                    l = nllocfile.readlines()
+                    nllocfile.close()
+                    l.insert(0, header)
+                    nllocfile = open(fnout + fnext, 'w')
+                    nllocfile.write("".join(l))
+                    nllocfile.close()
+                except KeyError as e:
+                    raise KeyError('''{0} export format
+                                     not implemented: {1}'''.format(evtformat, e))
+            if fnext == '.cnv':
+                try:
+                    velest.export(picks_copy, fnout + fnext, eventinfo=self.get_evt_data())
+                except KeyError as e:
+                    raise KeyError('''{0} export format
+                                     not implemented: {1}'''.format(evtformat, e))
 
     def getComp(self):
         """
@@ -232,6 +365,8 @@ class Data(object):
                     self.wfdata += read(fname, format='GSE2')
                 except Exception as e:
                     warnmsg += '{0}\n{1}\n'.format(fname, e)
+            except SacIOError as se:
+                warnmsg += '{0}\n{1}\n'.format(fname, se)
         if warnmsg:
             warnmsg = 'WARNING: unable to read\n' + warnmsg
             print(warnmsg)
@@ -278,12 +413,12 @@ class Data(object):
     def setEvtData(self, event):
         self.evtdata = event
 
-    def applyEVTData(self, data, type='pick', authority_id='rub'):
+    def applyEVTData(self, data, typ='pick', authority_id='rub'):
 
         """
 
         :param data:
-        :param type:
+        :param typ:
         :param authority_id:
         :raise OverwriteError:
         """
@@ -296,12 +431,20 @@ class Data(object):
             :raise OverwriteError: raises an OverwriteError if the picks list is
              not empty. The GUI will then ask for a decision.
             """
-
-            #firstonset = find_firstonset(picks)
-            if self.get_evt_data().picks:
-                raise OverwriteError('Actual picks would be overwritten!')
-            else:
-                picks = picks_from_picksdict(picks)
+            # firstonset = find_firstonset(picks)
+            # check for automatic picks
+            print("Writing phases to ObsPy-quakeml file")
+            for key in picks:
+                if picks[key]['P']['picker'] == 'auto':
+                    print("Existing picks will be overwritten!")
+                    picks = picks_from_picksdict(picks)
+                    break
+                else:
+                    if self.get_evt_data().picks:
+                        raise OverwriteError('Existing picks would be overwritten!')
+                    else:
+                        picks = picks_from_picksdict(picks)
+                        break
             self.get_evt_data().picks = picks
             # if 'smi:local' in self.getID() and firstonset:
             #     fonset_str = firstonset.strftime('%Y_%m_%d_%H_%M_%S')
@@ -309,26 +452,32 @@ class Data(object):
             #     ID.convertIDToQuakeMLURI(authority_id=authority_id)
             #     self.get_evt_data().resource_id = ID
 
-
         def applyEvent(event):
             """
             takes an `obspy.core.event.Event` object and applies all new
             information on the event to the actual data
             :param event:
             """
-            if not self.isNew():
+            if self.isNew():
                 self.setEvtData(event)
             else:
                 # prevent overwriting original pick information
-                picks =  copy.deepcopy(self.get_evt_data().picks)
-                event = merge_picks(event, picks)
+                event_old = self.get_evt_data()
+                if not event_old.resource_id == event.resource_id:
+                    print("WARNING: Missmatch in event resource id's: {} and {}".format(
+                        event_old.resource_id,
+                        event.resource_id))
+                else:
+                    picks = copy.deepcopy(event_old.picks)
+                    event = merge_picks(event, picks)
                 # apply event information from location
-                self.get_evt_data().update(event)
+                event_old.update(event)
 
         applydata = {'pick': applyPicks,
                      'event': applyEvent}
 
-        applydata[type](data)
+        applydata[typ](data)
+        self._new = False
 
 
 class GenericDataStructure(object):

pylot/core/io/default_parameters.py

@@ -0,0 +1,491 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+defaults = {'rootpath': {'type': str,
+                         'tooltip': 'project path',
+                         'value': '',
+                         'namestring': 'Root path'},
+
+            'datapath': {'type': str,
+                         'tooltip': 'data path',
+                         'value': '',
+                         'namestring': 'Data path'},
+
+            'database': {'type': str,
+                         'tooltip': 'name of data base',
+                         'value': '',
+                         'namestring': 'Database path'},
+
+            'eventID': {'type': str,
+                        'tooltip': 'event ID for single event processing (* for all events found in database)',
+                        'value': '',
+                        'namestring': 'Event ID'},
+
+            'extent': {'type': str,
+                       'tooltip': 'extent of array ("local", "regional" or "global")',
+                       'value': 'local',
+                       'namestring': 'Array extent'},
+
+            'invdir': {'type': str,
+                       'tooltip': 'full path to  inventory or dataless-seed file',
+                       'value': '',
+                       'namestring': 'Inversion dir'},
+
+            'datastructure': {'type': str,
+                              'tooltip': 'choose data structure',
+                              'value': 'PILOT',
+                              'namestring': 'Datastructure'},
+
+            'apverbose': {'type': bool,
+                          'tooltip': "choose 'True' or 'False' for terminal output",
+                          'value': True,
+                          'namestring': 'App. verbosity'},
+
+            'nllocbin': {'type': str,
+                         'tooltip': 'path to NLLoc executable',
+                         'value': '',
+                         'namestring': 'NLLoc bin path'},
+
+            'nllocroot': {'type': str,
+                          'tooltip': 'root of NLLoc-processing directory',
+                          'value': '',
+                          'namestring': 'NLLoc root path'},
+
+            'phasefile': {'type': str,
+                          'tooltip': 'name of autoPyLoT-output phase file for NLLoc',
+                          'value': 'AUTOPHASES.obs',
+                          'namestring': 'Phase filename'},
+
+            'ctrfile': {'type': str,
+                        'tooltip': 'name of autoPyLoT-output control file for NLLoc',
+                        'value': 'Insheim_min1d2015_auto.in',
+                        'namestring': 'Control filename'},
+
+            'ttpatter': {'type': str,
+                         'tooltip': 'pattern of NLLoc ttimes from grid',
+                         'value': 'ttime',
+                         'namestring': 'Traveltime pattern'},
+
+            'outpatter': {'type': str,
+                          'tooltip': 'pattern of NLLoc-output file',
+                          'value': 'AUTOLOC_nlloc',
+                          'namestring': 'NLLoc output pattern'},
+
+            'vp': {'type': float,
+                   'tooltip': 'average P-wave velocity',
+                   'value': 3530.,
+                   'namestring': 'P-velocity'},
+
+            'rho': {'type': float,
+                    'tooltip': 'average rock density [kg/m^3]',
+                    'value': 2500.,
+                    'namestring': 'Density'},
+
+            'Qp': {'type': (float, float),
+                   'tooltip': 'quality factor for P waves (Qp*f^a); list(Qp, a)',
+                   'value': (300., 0.8),
+                   'namestring': ('Quality factor', 'Qp1', 'Qp2')},
+
+            'pstart': {'type': float,
+                       'tooltip': 'start time [s] for calculating CF for P-picking (if TauPy:'
+                                  ' seconds relative to estimated onset)',
+                       'value': 15.0,
+                       'namestring': 'P start'},
+
+            'pstop': {'type': float,
+                      'tooltip': 'end time [s] for calculating CF for P-picking (if TauPy:'
+                                 ' seconds relative to estimated onset)',
+                      'value': 60.0,
+                      'namestring': 'P stop'},
+
+            'sstart': {'type': float,
+                       'tooltip': 'start time [s] relative to P-onset for calculating CF for S-picking',
+                       'value': -1.0,
+                       'namestring': 'S start'},
+
+            'sstop': {'type': float,
+                      'tooltip': 'end time [s] after P-onset for calculating CF for S-picking',
+                      'value': 10.0,
+                      'namestring': 'S stop'},
+
+            'bpz1': {'type': (float, float),
+                     'tooltip': 'lower/upper corner freq. of first band pass filter Z-comp. [Hz]',
+                     'value': (2, 20),
+                     'namestring': ('Z-bandpass 1', 'Lower', 'Upper')},
+
+            'bpz2': {'type': (float, float),
+                     'tooltip': 'lower/upper corner freq. of second band pass filter Z-comp. [Hz]',
+                     'value': (2, 30),
+                     'namestring': ('Z-bandpass 2', 'Lower', 'Upper')},
+
+            'bph1': {'type': (float, float),
+                     'tooltip': 'lower/upper corner freq. of first band pass filter H-comp. [Hz]',
+                     'value': (2, 15),
+                     'namestring': ('H-bandpass 1', 'Lower', 'Upper')},
+
+            'bph2': {'type': (float, float),
+                     'tooltip': 'lower/upper corner freq. of second band pass filter z-comp. [Hz]',
+                     'value': (2, 20),
+                     'namestring': ('H-bandpass 2', 'Lower', 'Upper')},
+
+            'algoP': {'type': str,
+                      'tooltip': 'choose algorithm for P-onset determination (HOS, ARZ, or AR3)',
+                      'value': 'HOS',
+                      'namestring': 'P algorithm'},
+
+            'tlta': {'type': float,
+                     'tooltip': 'for HOS-/AR-AIC-picker, length of LTA window [s]',
+                     'value': 7.0,
+                     'namestring': 'LTA window'},
+
+            'hosorder': {'type': int,
+                         'tooltip': 'for HOS-picker, order of Higher Order Statistics',
+                         'value': 4,
+                         'namestring': 'HOS order'},
+
+            'Parorder': {'type': int,
+                         'tooltip': 'for AR-picker, order of AR process of Z-component',
+                         'value': 2,
+                         'namestring': 'AR order P'},
+
+            'tdet1z': {'type': float,
+                       'tooltip': 'for AR-picker, length of AR determination window [s] for Z-component, 1st pick',
+                       'value': 1.2,
+                       'namestring': 'AR det. window Z 1'},
+
+            'tpred1z': {'type': float,
+                        'tooltip': 'for AR-picker, length of AR prediction window [s] for Z-component, 1st pick',
+                        'value': 0.4,
+                        'namestring': 'AR pred. window Z 1'},
+
+            'tdet2z': {'type': float,
+                       'tooltip': 'for AR-picker, length of AR determination window [s] for Z-component, 2nd pick',
+                       'value': 0.6,
+                       'namestring': 'AR det. window Z 2'},
+
+            'tpred2z': {'type': float,
+                        'tooltip': 'for AR-picker, length of AR prediction window [s] for Z-component, 2nd pick',
+                        'value': 0.2,
+                        'namestring': 'AR pred. window Z 2'},
+
+            'addnoise': {'type': float,
+                         'tooltip': 'add noise to seismogram for stable AR prediction',
+                         'value': 0.001,
+                         'namestring': 'Add noise'},
+
+            'tsnrz': {'type': (float, float, float, float),
+                      'tooltip': 'for HOS/AR, window lengths for SNR-and slope estimation [tnoise, tsafetey, tsignal, tslope] [s]',
+                      'value': (3, 0.1, 0.5, 1.0),
+                      'namestring': ('SNR windows P', 'Noise', 'Safety', 'Signal', 'Slope')},
+
+            'pickwinP': {'type': float,
+                         'tooltip': 'for initial AIC pick, length of P-pick window [s]',
+                         'value': 3.0,
+                         'namestring': 'AIC window P'},
+
+            'Precalcwin': {'type': float,
+                           'tooltip': 'for HOS/AR, window length [s] for recalculation of CF (relative to 1st pick)',
+                           'value': 6.0,
+                           'namestring': 'Recal. window P'},
+
+            'aictsmooth': {'type': float,
+                           'tooltip': 'for HOS/AR, take average of samples for smoothing of AIC-function [s]',
+                           'value': 0.2,
+                           'namestring': 'AIC smooth P'},
+
+            'tsmoothP': {'type': float,
+                         'tooltip': 'for HOS/AR, take average of samples for smoothing CF [s]',
+                         'value': 0.1,
+                         'namestring': 'CF smooth P'},
+
+            'ausP': {'type': float,
+                     'tooltip': 'for HOS/AR, artificial uplift of samples (aus) of CF (P)',
+                     'value': 0.001,
+                     'namestring': 'Artificial uplift P'},
+
+            'nfacP': {'type': float,
+                      'tooltip': 'for HOS/AR, noise factor for noise level determination (P)',
+                      'value': 1.3,
+                      'namestring': 'Noise factor P'},
+
+            'algoS': {'type': str,
+                      'tooltip': 'choose algorithm for S-onset determination (ARH or AR3)',
+                      'value': 'ARH',
+                      'namestring': 'S algorithm'},
+
+            'tdet1h': {'type': float,
+                       'tooltip': 'for HOS/AR, length of AR-determination window [s], H-components, 1st pick',
+                       'value': 0.8,
+                       'namestring': 'AR det. window H 1'},
+
+            'tpred1h': {'type': float,
+                        'tooltip': 'for HOS/AR, length of AR-prediction window [s], H-components, 1st pick',
+                        'value': 0.4,
+                        'namestring': 'AR pred. window H 1'},
+
+            'tdet2h': {'type': float,
+                       'tooltip': 'for HOS/AR, length of AR-determinaton window [s], H-components, 2nd pick',
+                       'value': 0.6,
+                       'namestring': 'AR det. window H 2'},
+
+            'tpred2h': {'type': float,
+                        'tooltip': 'for HOS/AR, length of AR-prediction window [s], H-components, 2nd pick',
+                        'value': 0.3,
+                        'namestring': 'AR pred. window H 2'},
+
+            'Sarorder': {'type': int,
+                         'tooltip': 'for AR-picker, order of AR process of H-components',
+                         'value': 4,
+                         'namestring': 'AR order S'},
+
+            'Srecalcwin': {'type': float,
+                           'tooltip': 'for AR-picker, window length [s] for recalculation of CF (2nd pick) (H)',
+                           'value': 5.0,
+                           'namestring': 'Recal. window S'},
+
+            'pickwinS': {'type': float,
+                         'tooltip': 'for initial AIC pick, length of S-pick window [s]',
+                         'value': 3.0,
+                         'namestring': 'AIC window S'},
+
+            'tsnrh': {'type': (float, float, float, float),
+                      'tooltip': 'for ARH/AR3, window lengths for SNR-and slope estimation [tnoise, tsafetey, tsignal, tslope] [s]',
+                      'value': (2, 0.2, 1.5, 0.5),
+                      'namestring': ('SNR windows S', 'Noise', 'Safety', 'Signal', 'Slope')},
+
+            'aictsmoothS': {'type': float,
+                            'tooltip': 'for AIC-picker, take average of samples for smoothing of AIC-function [s]',
+                            'value': 0.5,
+                            'namestring': 'AIC smooth S'},
+
+            'tsmoothS': {'type': float,
+                         'tooltip': 'for AR-picker, take average of samples for smoothing CF [s] (S)',
+                         'value': 0.7,
+                         'namestring': 'CF smooth S'},
+
+            'ausS': {'type': float,
+                     'tooltip': 'for HOS/AR, artificial uplift of samples (aus) of CF (S)',
+                     'value': 0.9,
+                     'namestring': 'Artificial uplift S'},
+
+            'nfacS': {'type': float,
+                      'tooltip': 'for AR-picker, noise factor for noise level determination (S)',
+                      'value': 1.5,
+                      'namestring': 'Noise factor S'},
+
+            'minfmweight': {'type': int,
+                            'tooltip': 'minimum required P weight for first-motion determination',
+                            'value': 1,
+                            'namestring': 'Min. P weight'},
+
+            'minFMSNR': {'type': float,
+                         'tooltip': 'miniumum required SNR for first-motion determination',
+                         'value': 2.,
+                         'namestring': 'Min SNR'},
+
+            'fmpickwin': {'type': float,
+                          'tooltip': 'pick window around P onset for calculating zero crossings',
+                          'value': 0.2,
+                          'namestring': 'Zero crossings window'},
+
+            'timeerrorsP': {'type': (float, float, float, float),
+                            'tooltip': 'discrete time errors [s] corresponding to picking weights [0 1 2 3] for P',
+                            'value': (0.01, 0.02, 0.04, 0.08),
+                            'namestring': ('Time errors P', '0', '1', '2', '3')},
+
+            'timeerrorsS': {'type': (float, float, float, float),
+                            'tooltip': 'discrete time errors [s] corresponding to picking weights [0 1 2 3] for S',
+                            'value': (0.04, 0.08, 0.16, 0.32),
+                            'namestring': ('Time errors S', '0', '1', '2', '3')},
+
+            'minAICPslope': {'type': float,
+                             'tooltip': 'below this slope [counts/s] the initial P pick is rejected',
+                             'value': 0.8,
+                             'namestring': 'Min. slope P'},
+
+            'minAICPSNR': {'type': float,
+                           'tooltip': 'below this SNR the initial P pick is rejected',
+                           'value': 1.1,
+                           'namestring': 'Min. SNR P'},
+
+            'minAICSslope': {'type': float,
+                             'tooltip': 'below this slope [counts/s] the initial S pick is rejected',
+                             'value': 1.,
+                             'namestring': 'Min. slope S'},
+
+            'minAICSSNR': {'type': float,
+                           'tooltip': 'below this SNR the initial S pick is rejected',
+                           'value': 1.5,
+                           'namestring': 'Min. SNR S'},
+
+            'minsiglength': {'type': float,
+                             'tooltip': 'length of signal part for which amplitudes must exceed noiselevel [s]',
+                             'value': 1.,
+                             'namestring': 'Min. signal length'},
+
+            'noisefactor': {'type': float,
+                            'tooltip': 'noiselevel*noisefactor=threshold',
+                            'value': 1.0,
+                            'namestring': 'Noise factor'},
+
+            'minpercent': {'type': float,
+                           'tooltip': 'required percentage of amplitudes exceeding threshold',
+                           'value': 10.,
+                           'namestring': 'Min amplitude [%]'},
+
+            'zfac': {'type': float,
+                     'tooltip': 'P-amplitude must exceed at least zfac times RMS-S amplitude',
+                     'value': 1.5,
+                     'namestring': 'Z factor'},
+
+            'mdttolerance': {'type': float,
+                             'tooltip': 'maximum allowed deviation of P picks from median [s]',
+                             'value': 6.0,
+                             'namestring': 'Median tolerance'},
+
+            'wdttolerance': {'type': float,
+                             'tooltip': 'maximum allowed deviation from Wadati-diagram',
+                             'value': 1.0,
+                             'namestring': 'Wadati tolerance'},
+
+            'jackfactor': {'type': float,
+                             'tooltip': 'pick is removed if the variance of the subgroup with the pick removed is larger than the mean variance of all subgroups times safety factor',
+                             'value': 5.0,
+                             'namestring': 'Jackknife safety factor'},
+
+            'WAscaling': {'type': (float, float, float),
+                          'tooltip': 'Scaling relation (log(Ao)+Alog(r)+Br+C) of Wood-Anderson amplitude Ao [nm] \
+                          If zeros are set, original Richter magnitude is calculated!',
+                          'value': (0., 0., 0.),
+                          'namestring': ('Wood-Anderson scaling', '', '', '')},
+
+            'magscaling': {'type': (float, float),
+                           'tooltip': 'Scaling relation for derived local magnitude [a*Ml+b]. \
+                           If zeros are set, no scaling of network magnitude is applied!',
+                           'value': (0., 0.),
+                           'namestring': ('Local mag. scaling', '', '')},
+
+            'minfreq': {'type': (float, float),
+                        'tooltip': 'Lower filter frequency [P, S]',
+                        'value': (1.0, 1.0),
+                        'namestring': ('Lower freq.', 'P', 'S')},
+
+            'maxfreq': {'type': (float, float),
+                        'tooltip': 'Upper filter frequency [P, S]',
+                        'value': (10.0, 10.0),
+                        'namestring': ('Upper freq.', 'P', 'S')},
+
+            'filter_order': {'type': (int, int),
+                             'tooltip': 'filter order [P, S]',
+                             'value': (2, 2),
+                             'namestring': ('Order', 'P', 'S')},
+
+            'filter_type': {'type': (str, str),
+                            'tooltip': 'filter type (bandpass, bandstop, lowpass, highpass) [P, S]',
+                            'value': ('bandpass', 'bandpass'),
+                            'namestring': ('Type', 'P', 'S')},
+
+            'use_taup': {'type': bool,
+                         'tooltip': 'use estimated traveltimes from TauPy for calculating windows for CF',
+                         'value': True,
+                         'namestring': 'Use TauPy'},
+
+            'taup_model': {'type': str,
+                           'tooltip': 'define TauPy model for traveltime estimation. Possible values: 1066a, 1066b, ak135, ak135f, herrin, iasp91, jb, prem, pwdk, sp6',
+                           'value': 'iasp91',
+                           'namestring': 'TauPy model'}
+            }
+
+settings_main = {
+    'dirs': [
+        'rootpath',
+        'datapath',
+        'database',
+        'eventID',
+        'invdir',
+        'datastructure',
+        'apverbose'],
+    'nlloc': [
+        'nllocbin',
+        'nllocroot',
+        'phasefile',
+        'ctrfile',
+        'ttpatter',
+        'outpatter'],
+    'smoment': [
+        'vp',
+        'rho',
+        'Qp'],
+    'localmag': [
+        'WAscaling',
+        'magscaling'],
+    'filter': [
+        'minfreq',
+        'maxfreq',
+        'filter_order',
+        'filter_type'],
+    'pick': [
+        'extent',
+        'pstart',
+        'pstop',
+        'sstart',
+        'sstop',
+        'use_taup',
+        'taup_model',
+        'bpz1',
+        'bpz2',
+        'bph1',
+        'bph2']
+}
+
+settings_special_pick = {
+    'z': [
+        'algoP',
+        'tlta',
+        'hosorder',
+        'Parorder',
+        'tdet1z',
+        'tpred1z',
+        'tdet2z',
+        'tpred2z',
+        'addnoise',
+        'tsnrz',
+        'pickwinP',
+        'Precalcwin',
+        'aictsmooth',
+        'tsmoothP',
+        'ausP',
+        'nfacP'],
+    'h': [
+        'algoS',
+        'tdet1h',
+        'tpred1h',
+        'tdet2h',
+        'tpred2h',
+        'Sarorder',
+        'Srecalcwin',
+        'pickwinS',
+        'tsnrh',
+        'aictsmoothS',
+        'tsmoothS',
+        'ausS',
+        'nfacS'],
+    'fm': [
+        'minfmweight',
+        'minFMSNR',
+        'fmpickwin'],
+    'quality': [
+        'timeerrorsP',
+        'timeerrorsS',
+        'minAICPslope',
+        'minAICPSNR',
+        'minAICSslope',
+        'minAICSSNR',
+        'minsiglength',
+        'noisefactor',
+        'minpercent',
+        'zfac',
+        'mdttolerance',
+        'wdttolerance',
+        'jackfactor'],
+}

pylot/core/io/inputs.py

@@ -1,12 +1,13 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
+from pylot.core.io import default_parameters
 from pylot.core.util.errors import ParameterError
 
 
-class AutoPickParameter(object):
+class PylotParameter(object):
     '''
-    AutoPickParameters is a parameter type object capable to read and/or write
+    PylotParameter is a parameter type object capable to read and/or write
     parameter ASCII.
 
     :param fn str: Filename of the input file
@@ -44,48 +45,15 @@ class AutoPickParameter(object):
         contain all parameters.
         '''
 
+        self.__init_default_paras()
+        self.__init_subsettings()
         self.__filename = fnin
-        parFileCont = {}
+        self._verbosity = verbosity
+        self._parFileCont = {}
         # io from parsed arguments alternatively
         for key, val in kwargs.items():
-            parFileCont[key] = val
-
-        if self.__filename is not None:
-            inputFile = open(self.__filename, 'r')
-        else:
-            return
-        try:
-            lines = inputFile.readlines()
-            for line in lines:
-                parspl = line.split('\t')[:2]
-                parFileCont[parspl[0].strip()] = parspl[1]
-        except IndexError as e:
-            if verbosity > 0:
-                self._printParameterError(e)
-            inputFile.seek(0)
-            lines = inputFile.readlines()
-            for line in lines:
-                if not line.startswith(('#', '%', '\n', ' ')):
-                    parspl = line.split('#')[:2]
-                    parFileCont[parspl[1].strip()] = parspl[0].strip()
-        for key, value in parFileCont.items():
-            try:
-                val = int(value)
-            except:
-                try:
-                    val = float(value)
-                except:
-                    if len(value.split(' ')) > 1:
-                        vallist = value.strip().split(' ')
-                        val = []
-                        for val0 in vallist:
-                            val0 = float(val0)
-                            val.append(val0)
-                    else:
-                        val = str(value.strip())
-            parFileCont[key] = val
-        self.__parameter = parFileCont
-
+            self._parFileCont[key] = val
+        self.from_file()
         if fnout:
             self.export2File(fnout)
 
@@ -100,16 +68,28 @@ class AutoPickParameter(object):
             string += 'Empty parameter dictionary.'
         return string
 
+    # Set default values of parameter names
+    def __init_default_paras(self):
+        parameters = default_parameters.defaults
+        self.__defaults = parameters
+
+    def __init_subsettings(self):
+        self._settings_main = default_parameters.settings_main
+        self._settings_special_pick = default_parameters.settings_special_pick
+
     # String representation of the object
     def __repr__(self):
-        return "AutoPickParameter('%s')" % self.__filename
+        return "PylotParameter('%s')" % self.__filename
 
     # Boolean test
     def __nonzero__(self):
-        return self.__parameter
+        return bool(self.__parameter)
 
     def __getitem__(self, key):
-        return self.__parameter[key]
+        try:
+            return self.__parameter[key]
+        except:
+            return None
 
     def __setitem__(self, key, value):
         self.__parameter[key] = value
@@ -128,7 +108,7 @@ class AutoPickParameter(object):
             yield key, value
 
     def hasParam(self, parameter):
-        if self.__parameter.has_key(parameter):
+        if parameter in self.__parameter.keys():
             return True
         return False
 
@@ -147,21 +127,165 @@ class AutoPickParameter(object):
                 self._printParameterError(e)
                 raise ParameterError(e)
 
+    def get_defaults(self):
+        return self.__defaults
+
+    def get_main_para_names(self):
+        return self._settings_main
+
+    def get_special_para_names(self):
+        return self._settings_special_pick
+
+    def get_all_para_names(self):
+        all_names = []
+        all_names += self.get_main_para_names()['dirs']
+        all_names += self.get_main_para_names()['nlloc']
+        all_names += self.get_main_para_names()['smoment']
+        all_names += self.get_main_para_names()['localmag']
+        all_names += self.get_main_para_names()['pick']
+        all_names += self.get_main_para_names()['filter']
+        all_names += self.get_special_para_names()['z']
+        all_names += self.get_special_para_names()['h']
+        all_names += self.get_special_para_names()['fm']
+        all_names += self.get_special_para_names()['quality']
+        return all_names
+
+    def checkValue(self, param, value):
+        is_type = type(value)
+        expect_type = self.get_defaults()[param]['type']
+        if not is_type == expect_type and not is_type == tuple:
+            message = 'Type check failed for param: {}, is type: {}, expected type:{}'
+            message = message.format(param, is_type, expect_type)
+            print(Warning(message))
+
+    def setParamKV(self, param, value):
+        self.__setitem__(param, value)
+
     def setParam(self, **kwargs):
-        for param, value in kwargs.items():
-            self.__setitem__(param, value)
-            # print(self)
+        for key in kwargs:
+            self.__setitem__(key, kwargs[key])
 
     @staticmethod
     def _printParameterError(errmsg):
         print('ParameterError:\n non-existent parameter %s' % errmsg)
 
+    def reset_defaults(self):
+        defaults = self.get_defaults()
+        for param in defaults:
+            self.setParamKV(param, defaults[param]['value'])
+
+    def from_file(self, fnin=None):
+        if not fnin:
+            if self.__filename is not None:
+                fnin = self.__filename
+            else:
+                return
+
+        if isinstance(fnin, (list, tuple)):
+            fnin = fnin[0]
+
+        inputFile = open(fnin, 'r')
+        try:
+            lines = inputFile.readlines()
+            for line in lines:
+                parspl = line.split('\t')[:2]
+                self._parFileCont[parspl[0].strip()] = parspl[1]
+        except IndexError as e:
+            if self._verbosity > 0:
+                self._printParameterError(e)
+            inputFile.seek(0)
+            lines = inputFile.readlines()
+            for line in lines:
+                if not line.startswith(('#', '%', '\n', ' ')):
+                    parspl = line.split('#')[:2]
+                    self._parFileCont[parspl[1].strip()] = parspl[0].strip()
+        for key, value in self._parFileCont.items():
+            try:
+                val = int(value)
+            except:
+                try:
+                    val = float(value)
+                except:
+                    if len(value.split(' ')) > 1:
+                        vallist = value.strip().split(' ')
+                        val = []
+                        for val0 in vallist:
+                            try:
+                                val0 = float(val0)
+                            except:
+                                pass
+                            val.append(val0)
+                    else:
+                        val = str(value.strip())
+            self._parFileCont[key] = val
+        self.__parameter = self._parFileCont
+
     def export2File(self, fnout):
         fid_out = open(fnout, 'w')
         lines = []
-        for key, value in self.iteritems():
-            lines.append('{key}\t{value}'.format(key=key, value=value))
-        fid_out.writelines(lines)
+        # for key, value in self.iteritems():
+        #     lines.append('{key}\t{value}\n'.format(key=key, value=value))
+        # fid_out.writelines(lines)
+        header = ('%This is a parameter input file for PyLoT/autoPyLoT.\n' +
+                  '%All main and special settings regarding data handling\n' +
+                  '%and picking are to be set here!\n' +
+                  '%Parameters are optimized for %{} data sets!\n'.format(self.get_main_para_names()['pick'][0]))
+        separator = '%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n'
+
+        fid_out.write(header)
+        self.write_section(fid_out, self.get_main_para_names()['dirs'],
+                           'main settings', separator)
+        self.write_section(fid_out, self.get_main_para_names()['nlloc'],
+                           'NLLoc settings', separator)
+        self.write_section(fid_out, self.get_main_para_names()['smoment'],
+                           'parameters for seismic moment estimation', separator)
+        self.write_section(fid_out, self.get_main_para_names()['localmag'],
+                           'settings local magnitude', separator)
+        self.write_section(fid_out, self.get_main_para_names()['filter'],
+                           'filter settings', separator)
+        self.write_section(fid_out, self.get_main_para_names()['pick'],
+                           'common settings picker', separator)
+        fid_out.write(('#special settings for calculating CF#\n' +
+                       '%!!Edit the following only if you know what you are doing!!%\n'))
+        self.write_section(fid_out, self.get_special_para_names()['z'],
+                           'Z-component', None)
+        self.write_section(fid_out, self.get_special_para_names()['h'],
+                           'H-components', None)
+        self.write_section(fid_out, self.get_special_para_names()['fm'],
+                           'first-motion picker', None)
+        self.write_section(fid_out, self.get_special_para_names()['quality'],
+                           'quality assessment', None)
+
+    def write_section(self, fid, names, title, separator):
+        if separator:
+            fid.write(separator)
+        fid.write('#{}#\n'.format(title))
+        l_val = 50
+        l_name = 15
+        l_ttip = 100
+        for name in names:
+            value = self[name]
+            if type(value) == list or type(value) == tuple:
+                value_tmp = ''
+                for vl in value:
+                    value_tmp += '{} '.format(vl)
+                value = value_tmp
+            tooltip = self.get_defaults()[name]['tooltip']
+            if not len(str(value)) > l_val:
+                value = '{:<{}} '.format(str(value), l_val)
+            else:
+                value = '{} '.format(str(value))
+            name += '#'
+            if not len(name) > l_name:
+                name = '#{:<{}} '.format(name, l_name)
+            else:
+                name = '#{} '.format(name)
+            if not len(tooltip) > l_ttip:
+                ttip = '%{:<{}}\n'.format(tooltip, l_ttip)
+            else:
+                ttip = '%{}\n'.format(tooltip)
+            line = value + name + ttip
+            fid.write(line)
 
 
 class FilterOptions(object):
@@ -218,12 +342,13 @@ class FilterOptions(object):
     def parseFilterOptions(self):
         if self:
             robject = {'type': self.getFilterType(), 'corners': self.getOrder()}
-            if len(self.getFreq()) > 1:
+            if not self.getFilterType() in ['highpass', 'lowpass']:
                 robject['freqmin'] = self.getFreq()[0]
                 robject['freqmax'] = self.getFreq()[1]
-            else:
-                robject['freq'] = self.getFreq() if type(self.getFreq()) is \
-                                                    float else self.getFreq()[0]
+            elif self.getFilterType() == 'highpass':
+                robject['freq'] = self.getFreq()[0]
+            elif self.getFilterType() == 'lowpass':
+                robject['freq'] = self.getFreq()[1]
             return robject
         return None
 

pylot/core/io/location.py

@@ -217,4 +217,4 @@ def create_resourceID(timetohash, restype, authority_id=None, hrstr=None):
         resID = ope.ResourceIdentifier(restype + '/' + hrstr)
     if authority_id is not None:
         resID.convertIDToQuakeMLURI(authority_id=authority_id)
-    return resID
+    return resID

pylot/core/io/phases.py

@@ -2,15 +2,19 @@
 # -*- coding: utf-8 -*-
 
 import glob
-import obspy.core.event as ope
 import os
-import scipy.io as sio
 import warnings
-from obspy.core import UTCDateTime
 
-from pylot.core.io.inputs import AutoPickParameter
-from pylot.core.io.location import create_arrival, create_event, \
-    create_magnitude, create_origin, create_pick
+import matplotlib.pyplot as plt
+import numpy as np
+import obspy.core.event as ope
+import scipy.io as sio
+from obspy.core import UTCDateTime
+from obspy.core.event import read_events
+from obspy.core.util import AttribDict
+from pylot.core.io.inputs import PylotParameter
+from pylot.core.io.location import create_event, \
+    create_magnitude
 from pylot.core.pick.utils import select_for_phase
 from pylot.core.util.utils import getOwner, full_range, four_digits
 
@@ -33,6 +37,7 @@ def add_amplitudes(event, amplitudes):
     event.amplitudes = amplitude_list
     return event
 
+
 def readPILOTEvent(phasfn=None, locfn=None, authority_id='RUB', **kwargs):
     """
     readPILOTEvent - function
@@ -117,7 +122,7 @@ def picksdict_from_pilot(fn):
     picks = dict()
     phases_pilot = sio.loadmat(fn)
     stations = stations_from_pilot(phases_pilot['stat'])
-    params = AutoPickParameter(TIMEERROR_DEFAULTS)
+    params = PylotParameter(TIMEERROR_DEFAULTS)
     timeerrors = dict(P=params.get('timeerrorsP'),
                       S=params.get('timeerrorsS'))
     for n, station in enumerate(stations):
@@ -189,24 +194,35 @@ def picksdict_from_picks(evt):
     PyLoT
     :param evt: Event object contain all available information
     :type evt: `~obspy.core.event.Event`
-    :return: pick dictionary
+    :return: pick dictionary (auto and manual)
     """
-    picks = {}
+    picksdict = {
+        'manual': {},
+        'auto': {}
+    }
     for pick in evt.picks:
         phase = {}
         station = pick.waveform_id.station_code
-        try:
-            onsets = picks[station]
-        except KeyError as e:
-            #print(e)
-            onsets = {}
+        channel = pick.waveform_id.channel_code
+        network = pick.waveform_id.network_code
         mpp = pick.time
         spe = pick.time_errors.uncertainty
+        try:
+            picker = str(pick.method_id)
+            if picker.startswith('smi:local/'):
+                picker = picker.split('smi:local/')[1]
+        except IndexError:
+            picker = 'manual' # MP MP TODO maybe improve statement
+        try:
+            onsets = picksdict[picker][station]
+        except KeyError as e:
+            # print(e)
+            onsets = {}
         try:
             lpp = mpp + pick.time_errors.upper_uncertainty
             epp = mpp - pick.time_errors.lower_uncertainty
         except TypeError as e:
-            msg = e.message + ',\n falling back to symmetric uncertainties'
+            msg = e + ',\n falling back to symmetric uncertainties'
             warnings.warn(msg)
             lpp = mpp + spe
             epp = mpp - spe
@@ -214,25 +230,27 @@ def picksdict_from_picks(evt):
         phase['epp'] = epp
         phase['lpp'] = lpp
         phase['spe'] = spe
-        try:
-            picker = str(pick.method_id)
-            if picker.startswith('smi:local/'):
-                picker = picker.split('smi:local/')[1]
-            phase['picker'] = picker
-        except IndexError:
-            pass
+        phase['channel'] = channel
+        phase['network'] = network
+        phase['picker'] = picker
 
         onsets[pick.phase_hint] = phase.copy()
-        picks[station] = onsets.copy()
-    return picks
+        picksdict[picker][station] = onsets.copy()
+    return picksdict
+
 
 def picks_from_picksdict(picks, creation_info=None):
     picks_list = list()
     for station, onsets in picks.items():
         for label, phase in onsets.items():
-            if not isinstance(phase, dict):
+            if not isinstance(phase, dict) and not isinstance(phase, AttribDict):
                 continue
             onset = phase['mpp']
+            try:
+                ccode = phase['channel']
+                ncode = phase['network']
+            except:
+                continue
             pick = ope.Pick()
             if creation_info:
                 pick.creation_info = creation_info
@@ -244,8 +262,8 @@ def picks_from_picksdict(picks, creation_info=None):
                 lpp = phase['lpp']
                 pick.time_errors.lower_uncertainty = onset - epp
                 pick.time_errors.upper_uncertainty = lpp - onset
-            except KeyError as e:
-                warnings.warn(e.message, RuntimeWarning)
+            except (KeyError, TypeError) as e:
+                warnings.warn(str(e), RuntimeWarning)
             try:
                 picker = phase['picker']
             except KeyError as e:
@@ -253,7 +271,9 @@ def picks_from_picksdict(picks, creation_info=None):
                 picker = 'Unknown'
             pick.phase_hint = label
             pick.method_id = ope.ResourceIdentifier(id=picker)
-            pick.waveform_id = ope.WaveformStreamID(station_code=station)
+            pick.waveform_id = ope.WaveformStreamID(station_code=station,
+                                                    channel_code=ccode,
+                                                    network_code=ncode)
             try:
                 polarity = phase['fm']
                 if polarity == 'U' or '+':
@@ -263,7 +283,7 @@ def picks_from_picksdict(picks, creation_info=None):
                 else:
                     pick.polarity = 'undecidable'
             except KeyError as e:
-                if 'fm' in e.message: # no polarity information found for this phase
+                if 'fm' in str(e):  # no polarity information found for this phase
                     pass
                 else:
                     raise e
@@ -275,7 +295,7 @@ def reassess_pilot_db(root_dir, db_dir, out_dir=None, fn_param=None, verbosity=0
     import glob
 
     db_root = os.path.join(root_dir, db_dir)
-    evt_list = glob.glob1(db_root,'e????.???.??')
+    evt_list = glob.glob1(db_root, 'e????.???.??')
 
     for evt in evt_list:
         if verbosity > 0:
@@ -283,18 +303,16 @@ def reassess_pilot_db(root_dir, db_dir, out_dir=None, fn_param=None, verbosity=0
         reassess_pilot_event(root_dir, db_dir, evt, out_dir, fn_param, verbosity)
 
 
-
 def reassess_pilot_event(root_dir, db_dir, event_id, out_dir=None, fn_param=None, verbosity=0):
     from obspy import read
 
-    from pylot.core.io.inputs import AutoPickParameter
+    from pylot.core.io.inputs import PylotParameter
     from pylot.core.pick.utils import earllatepicker
 
     if fn_param is None:
-        import pylot.core.util.defaults as defaults
         fn_param = defaults.AUTOMATIC_DEFAULTS
 
-    default = AutoPickParameter(fn_param, verbosity)
+    default = PylotParameter(fn_param, verbosity)
 
     search_base = os.path.join(root_dir, db_dir, event_id)
     phases_file = glob.glob(os.path.join(search_base, 'PHASES.mat'))
@@ -325,7 +343,8 @@ def reassess_pilot_event(root_dir, db_dir, event_id, out_dir=None, fn_param=None
                 except Exception as e:
                     if 'No file matching file pattern:' in e.message:
                         if verbosity > 0:
-                            warnings.warn('no waveform data found for station {station}'.format(station=station), RuntimeWarning)
+                            warnings.warn('no waveform data found for station {station}'.format(station=station),
+                                          RuntimeWarning)
                         datacheck.append(fn_pattern + ' (no data)\n')
                         continue
                     else:
@@ -349,8 +368,8 @@ def reassess_pilot_event(root_dir, db_dir, event_id, out_dir=None, fn_param=None
                                            default.get('nfac{0}'.format(phase)),
                                            default.get('tsnrz' if phase == 'P' else 'tsnrh'),
                                            Pick1=rel_pick,
-                                           iplot=None,
-                                           stealth_mode=True)
+                                           iplot=0,
+                                           verbosity=0)
             if epp is None or lpp is None:
                 continue
             epp = stime + epp
@@ -374,17 +393,17 @@ def reassess_pilot_event(root_dir, db_dir, event_id, out_dir=None, fn_param=None
     evt.picks = picks_from_picksdict(picks_dict)
     # write phase information to file
     if not out_dir:
-        fnout_prefix = os.path.join(root_dir, db_dir, event_id, '{0}.'.format(event_id))
+        fnout_prefix = os.path.join(root_dir, db_dir, event_id, 'PyLoT_{0}.'.format(event_id))
     else:
         out_dir = os.path.join(out_dir, db_dir)
         if not os.path.isdir(out_dir):
             os.makedirs(out_dir)
-        fnout_prefix = os.path.join(out_dir, '{0}.'.format(event_id))
+        fnout_prefix = os.path.join(out_dir, 'PyLoT_{0}.'.format(event_id))
     evt.write(fnout_prefix + 'xml', format='QUAKEML')
-    #evt.write(fnout_prefix + 'cnv', format='VELEST')
+    # evt.write(fnout_prefix + 'cnv', format='VELEST')
 
 
-def writephases(arrivals, fformat, filename):
+def writephases(arrivals, fformat, filename, parameter=None, eventinfo=None):
     """
     Function of methods to write phases to the following standard file
     formats used for locating earthquakes:
@@ -402,17 +421,25 @@ def writephases(arrivals, fformat, filename):
             HYPOINVERSE, and hypoDD
 
     :param: filename, full path and name of phase file
-    :type: string
+    :type:  string
+
+    :param: parameter, all input information
+    :type:  object
+
+    :param: eventinfo, optional, needed for VELEST-cnv file 
+            and FOCMEC- and HASH-input files 
+    :type:  `obspy.core.event.Event` object
     """
 
     if fformat == 'NLLoc':
-        print ("Writing phases to %s for NLLoc" % filename)
+        print("Writing phases to %s for NLLoc" % filename)
         fid = open("%s" % filename, 'w')
         # write header
-        fid.write('# EQEVENT:  Label: EQ001  Loc:  X 0.00  Y 0.00  Z 10.00  OT 0.00 \n')
+        fid.write('# EQEVENT: %s Label: EQ%s  Loc:  X 0.00  Y 0.00  Z 10.00  OT 0.00 \n' %
+                  (parameter.get('database'), parameter.get('eventID')))
         for key in arrivals:
             # P onsets
-            if arrivals[key]['P']:
+            if arrivals[key].has_key('P'):
                 try:
                     fm = arrivals[key]['P']['fm']
                 except KeyError as e:
@@ -429,7 +456,7 @@ def writephases(arrivals, fformat, filename):
                 ss = onset.second
                 ms = onset.microsecond
                 ss_ms = ss + ms / 1000000.0
-                pweight = 1 # use pick
+                pweight = 1  # use pick
                 try:
                     if arrivals[key]['P']['weight'] >= 4:
                         pweight = 0  # do not use pick
@@ -456,7 +483,7 @@ def writephases(arrivals, fformat, filename):
                 ss = onset.second
                 ms = onset.microsecond
                 ss_ms = ss + ms / 1000000.0
-                sweight = 1 # use pick
+                sweight = 1  # use pick
                 try:
                     if arrivals[key]['S']['weight'] >= 4:
                         sweight = 0  # do not use pick
@@ -474,12 +501,16 @@ def writephases(arrivals, fformat, filename):
 
         fid.close()
     elif fformat == 'HYPO71':
-        print ("Writing phases to %s for HYPO71" % filename)
+        print("Writing phases to %s for HYPO71" % filename)
         fid = open("%s" % filename, 'w')
         # write header
-        fid.write('                                                              EQ001\n')
+        fid.write('                                                                %s\n' %
+                  parameter.get('eventID'))
         for key in arrivals:
             if arrivals[key]['P']['weight'] < 4:
+                stat = key
+                if len(stat) > 4:  # HYPO71 handles only 4-string station IDs
+                    stat = stat[1:5]
                 Ponset = arrivals[key]['P']['mpp']
                 Sonset = arrivals[key]['S']['mpp']
                 pweight = arrivals[key]['P']['weight']
@@ -517,35 +548,300 @@ def writephases(arrivals, fformat, filename):
                         sstr = 'I'
                     elif sweight >= 2:
                         sstr = 'E'
-                    fid.write('%s%sP%s%d %02d%02d%02d%02d%02d%5.2f       %s%sS %d   %s\n' % (key,
-                                                                                             pstr,
-                                                                                             fm,
-                                                                                             pweight,
-                                                                                             year,
-                                                                                             month,
-                                                                                             day,
-                                                                                             hh,
-                                                                                             mm,
-                                                                                             ss_ms,
-                                                                                             Sss_ms,
-                                                                                             sstr,
-                                                                                             sweight,
-                                                                                             Ao))
+                    fid.write('%-4s%sP%s%d %02d%02d%02d%02d%02d%5.2f       %s%sS %d   %s\n' % (stat,
+                                                                                               pstr,
+                                                                                               fm,
+                                                                                               pweight,
+                                                                                               year,
+                                                                                               month,
+                                                                                               day,
+                                                                                               hh,
+                                                                                               mm,
+                                                                                               ss_ms,
+                                                                                               Sss_ms,
+                                                                                               sstr,
+                                                                                               sweight,
+                                                                                               Ao))
                 else:
-                    fid.write('%s%sP%s%d %02d%02d%02d%02d%02d%5.2f                  %s\n' % (key,
-                                                                                             pstr,
-                                                                                             fm,
-                                                                                             pweight,
-                                                                                             year,
-                                                                                             month,
-                                                                                             day,
-                                                                                             hh,
-                                                                                             mm,
-                                                                                             ss_ms,
-                                                                                             Ao))
+                    fid.write('%-4s%sP%s%d %02d%02d%02d%02d%02d%5.2f                  %s\n' % (stat,
+                                                                                               pstr,
+                                                                                               fm,
+                                                                                               pweight,
+                                                                                               year,
+                                                                                               month,
+                                                                                               day,
+                                                                                               hh,
+                                                                                               mm,
+                                                                                               ss_ms,
+                                                                                               Ao))
 
         fid.close()
 
+    elif fformat == 'HYPOSAT':
+        print("Writing phases to %s for HYPOSAT" % filename)
+        fid = open("%s" % filename, 'w')
+        # write header
+        fid.write('%s, event %s \n' % (parameter.get('database'), parameter.get('eventID')))
+        for key in arrivals:
+            # P onsets
+            if arrivals[key].has_key('P'):
+                if arrivals[key]['P']['weight'] < 4:
+                    Ponset = arrivals[key]['P']['mpp']
+                    pyear = Ponset.year
+                    pmonth = Ponset.month
+                    pday = Ponset.day
+                    phh = Ponset.hour
+                    pmm = Ponset.minute
+                    pss = Ponset.second
+                    pms = Ponset.microsecond
+                    Pss = pss + pms / 1000000.0
+                    # use symmetrized picking error as std
+                    # (read the HYPOSAT manual)
+                    pstd = arrivals[key]['P']['spe']
+                    fid.write('%-5s P1       %4.0f %02d %02d %02d %02d %05.02f   %5.3f -999.   0.00 -999.  0.00\n'
+                              % (key, pyear, pmonth, pday, phh, pmm, Pss, pstd))
+            # S onsets
+            if arrivals[key].has_key('S') and arrivals[key]['S']:
+                if arrivals[key]['S']['weight'] < 4:
+                    Sonset = arrivals[key]['S']['mpp']
+                    syear = Sonset.year
+                    smonth = Sonset.month
+                    sday = Sonset.day
+                    shh = Sonset.hour
+                    smm = Sonset.minute
+                    sss = Sonset.second
+                    sms = Sonset.microsecond
+                    Sss = sss + sms / 1000000.0
+                    sstd = arrivals[key]['S']['spe']
+                    fid.write('%-5s S1       %4.0f %02d %02d %02d %02d %05.02f   %5.3f -999.   0.00 -999.  0.00\n'
+                              % (key, syear, smonth, sday, shh, smm, Sss, sstd))
+        fid.close()
+
+    elif fformat == 'VELEST':
+        print("Writing phases to %s for VELEST" % filename)
+        fid = open("%s" % filename, 'w')
+        # get informations needed in cnv-file
+        # check, whether latitude is N or S and longitude is E or W
+        try:
+            eventsource = eventinfo.origins[0]
+        except:
+            print("No source origin calculated yet, thus no cnv-file creation possible!")
+            return
+        if eventsource['latitude'] < 0:
+            cns = 'S'
+        else:
+            cns = 'N'
+        if eventsource['longitude'] < 0:
+            cew = 'W'
+        else:
+            cew = 'E'
+        # get last two integers of origin year
+        stime = eventsource['time']
+        if stime.year - 2000 >= 0:
+            syear = stime.year - 2000
+        else:
+            syear = stime.year - 1900
+        ifx = 0  # default value, see VELEST manual, pp. 22-23
+        # write header
+        fid.write('%s%02d%02d %02d%02d %05.2f %7.4f%c %8.4f%c %7.2f %6.2f     %02.0f  0.0 0.03  1.0  1.0\n' % (
+            syear, stime.month, stime.day, stime.hour, stime.minute, stime.second, eventsource['latitude'],
+            cns, eventsource['longitude'], cew, eventsource['depth'], eventinfo.magnitudes[0]['mag'], ifx))
+        n = 0
+        for key in arrivals:
+            # P onsets
+            if arrivals[key].has_key('P'):
+                if arrivals[key]['P']['weight'] < 4:
+                    n += 1
+                    stat = key
+                    if len(stat) > 4:  # VELEST handles only 4-string station IDs
+                        stat = stat[1:5]
+                    Ponset = arrivals[key]['P']['mpp']
+                    Pweight = arrivals[key]['P']['weight']
+                    Prt = Ponset - stime  # onset time relative to source time
+                    if n % 6 is not 0:
+                        fid.write('%-4sP%d%6.2f' % (stat, Pweight, Prt))
+                    else:
+                        fid.write('%-4sP%d%6.2f\n' % (stat, Pweight, Prt))
+                        # S onsets
+            if arrivals[key].has_key('S'):
+                if arrivals[key]['S']['weight'] < 4:
+                    n += 1
+                    stat = key
+                    if len(stat) > 4:  # VELEST handles only 4-string station IDs
+                        stat = stat[1:5]
+                    Sonset = arrivals[key]['S']['mpp']
+                    Sweight = arrivals[key]['S']['weight']
+                    Srt = Ponset - stime  # onset time relative to source time
+                    if n % 6 is not 0:
+                        fid.write('%-4sS%d%6.2f' % (stat, Sweight, Srt))
+                    else:
+                        fid.write('%-4sS%d%6.2f\n' % (stat, Sweight, Srt))
+        fid.close()
+
+    elif fformat == 'hypoDD':
+        print("Writing phases to %s for hypoDD" % filename)
+        fid = open("%s" % filename, 'w')
+        # get event information needed for hypoDD-phase file
+        eventsource = eventinfo.origins[0]
+        stime = eventsource['time']
+        event = parameter.get('eventID')
+        hddID = event.split('.')[0][1:5]
+        # write header
+        fid.write('# %d  %d %d %d %d %5.2f %7.4f +%6.4f %7.4f %4.2f 0.1 0.5 %4.2f      %s\n' % (
+            stime.year, stime.month, stime.day, stime.hour, stime.minute, stime.second,
+            eventsource['latitude'], eventsource['longitude'], eventsource['depth'] / 1000,
+            eventinfo.magnitudes[0]['mag'], eventsource['quality']['standard_error'], hddID))
+        for key in arrivals:
+            if arrivals[key].has_key('P'):
+                # P onsets
+                if arrivals[key]['P']['weight'] < 4:
+                    Ponset = arrivals[key]['P']['mpp']
+                    Prt = Ponset - stime  # onset time relative to source time
+                    fid.write('%s    %6.3f  1  P\n' % (key, Prt))
+                    # S onsets
+                if arrivals[key]['S']['weight'] < 4:
+                    Sonset = arrivals[key]['S']['mpp']
+                    Srt = Sonset - stime  # onset time relative to source time
+                    fid.write('%-5s    %6.3f  1  S\n' % (key, Srt))
+
+        fid.close()
+
+    elif fformat == 'FOCMEC':
+        print("Writing phases to %s for FOCMEC" % filename)
+        fid = open("%s" % filename, 'w')
+        # get event information needed for FOCMEC-input file
+        eventsource = eventinfo.origins[0]
+        stime = eventsource['time']
+        # write header line including event information
+        fid.write('%s %d%02d%02d%02d%02d%02.0f %7.4f %6.4f %3.1f %3.1f\n' % (parameter.get('eventID'),
+                                                                             stime.year, stime.month, stime.day,
+                                                                             stime.hour, stime.minute, stime.second,
+                                                                             eventsource['latitude'],
+                                                                             eventsource['longitude'],
+                                                                             eventsource['depth'] / 1000,
+                                                                             eventinfo.magnitudes[0]['mag']))
+        picks = eventinfo.picks
+        for key in arrivals:
+            if arrivals[key].has_key('P'):
+                if arrivals[key]['P']['weight'] < 4 and arrivals[key]['P']['fm'] is not None:
+                    stat = key
+                    for i in range(len(picks)):
+                        station = picks[i].waveform_id.station_code
+                        if station == stat:
+                            # get resource ID
+                            resid_picks = picks[i].get('resource_id')
+                            # find same ID in eventinfo
+                            # there it is the pick_id!!
+                            for j in range(len(eventinfo.origins[0].arrivals)):
+                                resid_eventinfo = eventinfo.origins[0].arrivals[j].get('pick_id')
+                                if resid_eventinfo == resid_picks and eventinfo.origins[0].arrivals[j].phase == 'P':
+                                    if len(stat) > 4:  # FOCMEC handles only 4-string station IDs
+                                        stat = stat[1:5]
+                                    az = eventinfo.origins[0].arrivals[j].get('azimuth')
+                                    inz = eventinfo.origins[0].arrivals[j].get('takeoff_angle')
+                                    fid.write('%-4s  %6.2f  %6.2f%s \n' % (stat,
+                                                                           az,
+                                                                           inz,
+                                                                           arrivals[key]['P']['fm']))
+                                    break
+
+        fid.close()
+
+    elif fformat == 'HASH':
+        # two different input files for 
+        # HASH-driver 1 and 2 (see HASH manual!)
+        filename1 = filename + 'drv1' + '.phase'
+        filename2 = filename + 'drv2' + '.phase'
+        print("Writing phases to %s for HASH for HASH-driver 1" % filename1)
+        fid1 = open("%s" % filename1, 'w')
+        print("Writing phases to %s for HASH for HASH-driver 2" % filename2)
+        fid2 = open("%s" % filename2, 'w')
+        # get event information needed for HASH-input file
+        eventsource = eventinfo.origins[0]
+        event = parameter.get('eventID')
+        hashID = event.split('.')[0][1:5]
+        latdeg = eventsource['latitude']
+        latmin = eventsource['latitude'] * 60 / 10000
+        londeg = eventsource['longitude']
+        lonmin = eventsource['longitude'] * 60 / 10000
+        erh = 1 / 2 * (eventsource.origin_uncertainty['min_horizontal_uncertainty'] +
+                       eventsource.origin_uncertainty['max_horizontal_uncertainty']) / 1000
+        erz = eventsource.depth_errors['uncertainty']
+        stime = eventsource['time']
+        if stime.year - 2000 >= 0:
+            syear = stime.year - 2000
+        else:
+            syear = stime.year - 1900
+        picks = eventinfo.picks
+        # write header line including event information
+        # for HASH-driver 1
+        fid1.write('%s%02d%02d%02d%02d%5.2f%2dN%5.2f%3dE%5.2f%6.3f%4.2f%5.2f%5.2f%s\n' % (syear,
+                                                                                          stime.month, stime.day,
+                                                                                          stime.hour, stime.minute,
+                                                                                          stime.second,
+                                                                                          latdeg, latmin, londeg,
+                                                                                          lonmin, eventsource['depth'],
+                                                                                          eventinfo.magnitudes[0][
+                                                                                              'mag'], erh, erz,
+                                                                                          hashID))
+        # write header line including event information
+        # for HASH-driver 2
+        fid2.write(
+            '%d%02d%02d%02d%02d%5.2f%dN%5.2f%3dE%6.2f%5.2f    %d                                          %5.2f %5.2f                                        %4.2f      %s \n' % (
+                syear, stime.month, stime.day,
+                stime.hour, stime.minute, stime.second,
+                latdeg, latmin, londeg, lonmin,
+                eventsource['depth'],
+                eventsource['quality']['used_phase_count'],
+                erh, erz, eventinfo.magnitudes[0]['mag'],
+                hashID))
+
+        # write phase lines
+        for key in arrivals:
+            if arrivals[key].has_key('P'):
+                if arrivals[key]['P']['weight'] < 4 and arrivals[key]['P']['fm'] is not None:
+                    stat = key
+                    ccode = arrivals[key]['P']['channel']
+                    ncode = arrivals[key]['P']['network']
+
+                    if arrivals[key]['P']['weight'] < 2:
+                        Pqual = 'I'
+                    else:
+                        Pqual = 'E'
+
+                    for i in range(len(picks)):
+                        station = picks[i].waveform_id.station_code
+                        if station == stat:
+                            # get resource ID
+                            resid_picks = picks[i].get('resource_id')
+                            # find same ID in eventinfo
+                            # there it is the pick_id!!
+                            for j in range(len(eventinfo.origins[0].arrivals)):
+                                resid_eventinfo = eventinfo.origins[0].arrivals[j].get('pick_id')
+                                if resid_eventinfo == resid_picks and eventinfo.origins[0].arrivals[j].phase == 'P':
+                                    if len(stat) > 4:  # HASH handles only 4-string station IDs
+                                        stat = stat[1:5]
+                                    az = eventinfo.origins[0].arrivals[j].get('azimuth')
+                                    inz = eventinfo.origins[0].arrivals[j].get('takeoff_angle')
+                                    dist = eventinfo.origins[0].arrivals[j].get('distance')
+                                    # write phase line for HASH-driver 1
+                                    fid1.write(
+                                        '%-4s%sP%s%d                   0                                   %3.1f          %03d %03d   2     1   %s\n' % (
+                                            stat, Pqual, arrivals[key]['P']['fm'], arrivals[key]['P']['weight'],
+                                            dist, inz, az, ccode))
+                                    # write phase line for HASH-driver 2
+                                    fid2.write('%-4s %s   %s %s %s                    \n' % (
+                                        stat,
+                                        ncode,
+                                        ccode,
+                                        Pqual,
+                                        arrivals[key]['P']['fm']))
+                                    break
+
+        fid1.write('                                    %s' % hashID)
+        fid1.close()
+        fid2.close()
+
 
 def merge_picks(event, picks):
     """
@@ -563,8 +859,158 @@ def merge_picks(event, picks):
         err = pick.time_errors
         phase = pick.phase_hint
         station = pick.waveform_id.station_code
+        network = pick.waveform_id.network_code
+        method = pick.method_id
         for p in 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
+            if p.waveform_id.station_code == station\
+                    and p.waveform_id.network_code == network\
+                    and p.phase_hint == phase\
+                    and (str(p.method_id) in str(method)
+                         or str(method) in str(p.method_id)):
+                p.time, p.time_errors, p.waveform_id.network_code, p.method_id = time, err, network, method
+        del time, err, phase, station, network, method
     return event
+
+
+def getQualitiesfromxml(xmlnames, ErrorsP, ErrorsS, plotflag=1):
+    """
+   Script to get onset uncertainties from Quakeml.xml files created by PyLoT.
+   Uncertainties are tranformed into quality classes and visualized via histogram if desired.
+   Ludger Küperkoch, BESTEC GmbH, 07/2017
+   """
+
+    from pylot.core.pick.utils import getQualityFromUncertainty
+    from pylot.core.util.utils import loopIdentifyPhase, identifyPhase
+
+    # read all onset weights
+    Pw0 = []
+    Pw1 = []
+    Pw2 = []
+    Pw3 = []
+    Pw4 = []
+    Sw0 = []
+    Sw1 = []
+    Sw2 = []
+    Sw3 = []
+    Sw4 = []
+    for names in xmlnames:
+        print("Getting onset weights from {}".format(names))
+        cat = read_events(names)
+        cat_copy = cat.copy()
+        arrivals = cat.events[0].picks
+        arrivals_copy = cat_copy.events[0].picks
+        # Prefere manual picks if qualities are sufficient!
+        for Pick in arrivals:
+            if (Pick.method_id.id).split('/')[1] == 'manual':
+                mstation = Pick.waveform_id.station_code
+                mstation_ext = mstation + '_'
+                for mpick in arrivals_copy:
+                    phase = identifyPhase(loopIdentifyPhase(Pick.phase_hint))
+                    if phase == 'P':
+                        if ((mpick.waveform_id.station_code == mstation) or
+                                (mpick.waveform_id.station_code == mstation_ext)) and \
+                                ((mpick.method_id).split('/')[1] == 'auto') and \
+                                (mpick.time_errors['uncertainty'] <= ErrorsP[3]):
+                            del mpick
+                            break
+                    elif phase == 'S':
+                        if ((mpick.waveform_id.station_code == mstation) or
+                                (mpick.waveform_id.station_code == mstation_ext)) and \
+                                ((mpick.method_id).split('/')[1] == 'auto') and \
+                                (mpick.time_errors['uncertainty'] <= ErrorsS[3]):
+                            del mpick
+                            break
+        lendiff = len(arrivals) - len(arrivals_copy)
+        if lendiff is not 0:
+            print("Found manual as well as automatic picks, prefered the {} manual ones!".format(lendiff))
+
+        for Pick in arrivals_copy:
+            phase = identifyPhase(loopIdentifyPhase(Pick.phase_hint))
+            if phase == 'P':
+                Pqual = getQualityFromUncertainty(Pick.time_errors.uncertainty, ErrorsP)
+                if Pqual == 0:
+                    Pw0.append(Pick.time_errors.uncertainty)
+                elif Pqual == 1:
+                    Pw1.append(Pick.time_errors.uncertainty)
+                elif Pqual == 2:
+                    Pw2.append(Pick.time_errors.uncertainty)
+                elif Pqual == 3:
+                    Pw3.append(Pick.time_errors.uncertainty)
+                elif Pqual == 4:
+                    Pw4.append(Pick.time_errors.uncertainty)
+            elif phase == 'S':
+                Squal = getQualityFromUncertainty(Pick.time_errors.uncertainty, ErrorsS)
+                if Squal == 0:
+                    Sw0.append(Pick.time_errors.uncertainty)
+                elif Squal == 1:
+                    Sw1.append(Pick.time_errors.uncertainty)
+                elif Squal == 2:
+                    Sw2.append(Pick.time_errors.uncertainty)
+                elif Squal == 3:
+                    Sw3.append(Pick.time_errors.uncertainty)
+                elif Squal == 4:
+                    Sw4.append(Pick.time_errors.uncertainty)
+            else:
+                print("Phase hint not defined for picking!")
+                pass
+
+    if plotflag == 0:
+        Punc = [Pw0, Pw1, Pw2, Pw3, Pw4]
+        Sunc = [Sw0, Sw1, Sw2, Sw3, Sw4]
+        return Punc, Sunc
+    else:
+        # get percentage of weights
+        numPweights = np.sum([len(Pw0), len(Pw1), len(Pw2), len(Pw3), len(Pw4)])
+        numSweights = np.sum([len(Sw0), len(Sw1), len(Sw2), len(Sw3), len(Sw4)])
+        if len(Pw0) > 0:
+            P0perc = 100 / numPweights * len(Pw0)
+        else:
+            P0perc = 0
+        if len(Pw1) > 0:
+            P1perc = 100 / numPweights * len(Pw1)
+        else:  
+            P1perc = 0
+        if len(Pw2) > 0:
+            P2perc = 100 / numPweights * len(Pw2)
+        else:  
+            P2perc = 0
+        if len(Pw3) > 0:
+            P3perc = 100 / numPweights * len(Pw3)
+        else:  
+            P3perc = 0
+        if len(Pw4) > 0:
+            P4perc = 100 / numPweights * len(Pw4)
+        else:  
+            P4perc = 0
+        if len(Sw0) > 0:
+            S0perc = 100 / numSweights * len(Sw0)
+        else:
+            S0perc = 0
+        if len(Sw1) > 0:
+            S1perc = 100 / numSweights * len(Sw1)
+        else:  
+            S1perc = 0
+        if len(Sw2) > 0:
+            S2perc = 100 / numSweights * len(Sw2)
+        else:  
+            S2perc = 0
+        if len(Sw3) > 0:
+            S3perc = 100 / numSweights * len(Sw3)
+        else:  
+            S3perc = 0
+        if len(Sw4) > 0:
+            S4perc = 100 / numSweights * len(Sw4)
+        else:  
+            S4perc = 0
+
+        weights = ('0', '1', '2', '3', '4')
+        y_pos = np.arange(len(weights))
+        width = 0.34
+        plt.bar(y_pos - width, [P0perc, P1perc, P2perc, P3perc, P4perc], width, color='black')
+        plt.bar(y_pos, [S0perc, S1perc, S2perc, S3perc, S4perc], width, color='red')
+        plt.ylabel('%')
+        plt.xticks(y_pos, weights)
+        plt.xlim([-0.5, 4.5])
+        plt.xlabel('Qualities')
+        plt.title('{0} P-Qualities, {1} S-Qualities'.format(numPweights, numSweights))
+        plt.show()

pylot/core/loc/focmec.py

@@ -0,0 +1,28 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from pylot.core.io.phases import writephases
+from pylot.core.util.version import get_git_version as _getVersionString
+
+__version__ = _getVersionString()
+
+
+def export(picks, fnout, parameter, eventinfo):
+    '''
+    Take <picks> dictionary and exports picking data to a focmec
+    <phasefile> without creating an ObsPy event object.
+
+    :param picks: picking data dictionary
+    :type picks: dict
+
+    :param fnout: complete path to the exporting obs file
+    :type fnout: str
+    
+    :param: parameter, all input information
+    :type:  object
+
+    :param: eventinfo, source information needed for focmec format
+    :type:  list object
+    '''
+    # write phases to FOCMEC-phase file
+    writephases(picks, 'FOCMEC', fnout, parameter, eventinfo)

pylot/core/loc/hash.py

@@ -0,0 +1,28 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from pylot.core.io.phases import writephases
+from pylot.core.util.version import get_git_version as _getVersionString
+
+__version__ = _getVersionString()
+
+
+def export(picks, fnout, parameter, eventinfo):
+    '''
+    Take <picks> dictionary and exports picking data to a HASH
+    <phasefile> without creating an ObsPy event object.
+
+    :param picks: picking data dictionary
+    :type picks: dict
+
+    :param fnout: complete path to the exporting obs file
+    :type fnout: str
+    
+    :param: parameter, all input information
+    :type:  object
+
+    :param: eventinfo, source information needed for HASH format
+    :type:  list object
+    '''
+    # write phases to HASH-phase file
+    writephases(picks, 'HASH', fnout, parameter, eventinfo)

pylot/core/loc/hypo71.py

@@ -6,9 +6,10 @@ from pylot.core.util.version import get_git_version as _getVersionString
 
 __version__ = _getVersionString()
 
-def export(picks, fnout):
+
+def export(picks, fnout, parameter):
     '''
-    Take <picks> dictionary and exports picking data to a NLLOC-obs
+    Take <picks> dictionary and exports picking data to a HYPO71
     <phasefile> without creating an ObsPy event object.
 
     :param picks: picking data dictionary
@@ -16,6 +17,9 @@ def export(picks, fnout):
 
     :param fnout: complete path to the exporting obs file
     :type fnout: str
+
+    :param: parameter, all input information
+    :type:  object
     '''
-    # write phases to NLLoc-phase file
-    writephases(picks, 'HYPO71', fnout)
+    # write phases to HYPO71-phase file
+    writephases(picks, 'HYPO71', fnout, parameter)

pylot/core/loc/hypodd.py

@@ -0,0 +1,28 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from pylot.core.io.phases import writephases
+from pylot.core.util.version import get_git_version as _getVersionString
+
+__version__ = _getVersionString()
+
+
+def export(picks, fnout, parameter, eventinfo):
+    '''
+    Take <picks> dictionary and exports picking data to a hypoDD
+    <phasefile> without creating an ObsPy event object.
+
+    :param picks: picking data dictionary
+    :type picks: dict
+
+    :param fnout: complete path to the exporting obs file
+    :type fnout: str
+    
+    :param: parameter, all input information
+    :type:  object
+
+    :param: eventinfo, source information needed for hypoDD format
+    :type:  list object
+    '''
+    # write phases to hypoDD-phase file
+    writephases(picks, 'hypoDD', fnout, parameter, eventinfo)

pylot/core/loc/hyposat.py

@@ -0,0 +1,25 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from pylot.core.io.phases import writephases
+from pylot.core.util.version import get_git_version as _getVersionString
+
+__version__ = _getVersionString()
+
+
+def export(picks, fnout, parameter):
+    '''
+    Take <picks> dictionary and exports picking data to a HYPOSAT
+    <phasefile> without creating an ObsPy event object.
+
+    :param picks: picking data dictionary
+    :type picks: dict
+
+    :param fnout: complete path to the exporting obs file
+    :type fnout: str
+    
+    :param: parameter, all input information
+    :type:  object
+    '''
+    # write phases to HYPOSAT-phase file
+    writephases(picks, 'HYPOSAT', fnout, parameter)

pylot/core/loc/nll.py

@@ -1,9 +1,10 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
-import subprocess
-import os
 import glob
+import os
+import subprocess
+
 from obspy import read_events
 from pylot.core.io.phases import writephases
 from pylot.core.util.utils import getPatternLine, runProgram, which
@@ -11,10 +12,12 @@ from pylot.core.util.version import get_git_version as _getVersionString
 
 __version__ = _getVersionString()
 
+
 class NLLocError(EnvironmentError):
     pass
 
-def export(picks, fnout):
+
+def export(picks, fnout, parameter):
     '''
     Take <picks> dictionary and exports picking data to a NLLOC-obs
     <phasefile> without creating an ObsPy event object.
@@ -24,9 +27,12 @@ def export(picks, fnout):
 
     :param fnout: complete path to the exporting obs file
     :type fnout: str
+ 
+    :param: parameter, all input information
+    :type:  object
     '''
     # write phases to NLLoc-phase file
-    writephases(picks, 'NLLoc', fnout)
+    writephases(picks, 'NLLoc', fnout, parameter)
 
 
 def modify_inputs(ctrfn, root, nllocoutn, phasefn, tttn):
@@ -55,7 +61,7 @@ def modify_inputs(ctrfn, root, nllocoutn, phasefn, tttn):
     locfiles = 'LOCFILES %s NLLOC_OBS %s %s 0\n' % (phasefile, tttable, nllocout)
 
     # modification of NLLoc-control file
-    print ("Modifying  NLLoc-control file %s ..." % ctrfile)
+    print("Modifying  NLLoc-control file %s ..." % ctrfile)
     curlocfiles = getPatternLine(ctrfile, 'LOCFILES')
     nllfile = open(ctrfile, 'r')
     filedata = nllfile.read()
@@ -67,14 +73,17 @@ def modify_inputs(ctrfn, root, nllocoutn, phasefn, tttn):
     nllfile.close()
 
 
-def locate(fnin):
+def locate(fnin, infile=None):
     """
     takes an external program name
     :param fnin:
     :return:
     """
 
-    exe_path = which('NLLoc')
+    if infile is None:
+        exe_path = which('NLLoc')
+    else:
+        exe_path = which('NLLoc', infile)
     if exe_path is None:
         raise NLLocError('NonLinLoc executable not found; check your '
                          'environment variables')
@@ -88,7 +97,7 @@ def locate(fnin):
 
 def read_location(fn):
     path, file = os.path.split(fn)
-    file = glob.glob1(path, file +  '.[0-9]*.grid0.loc.hyp')
+    file = glob.glob1(path, file + '.[0-9]*.grid0.loc.hyp')
     if len(file) > 1:
         raise IOError('ambiguous location name {0}'.format(file))
     fn = os.path.join(path, file[0])

pylot/core/loc/velest.py

@@ -1,2 +1,28 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
+
+from pylot.core.io.phases import writephases
+from pylot.core.util.version import get_git_version as _getVersionString
+
+__version__ = _getVersionString()
+
+
+def export(picks, fnout, eventinfo, parameter=None):
+    '''
+    Take <picks> dictionary and exports picking data to a VELEST-cnv
+    <phasefile> without creating an ObsPy event object.
+
+    :param picks: picking data dictionary
+    :type picks: dict
+
+    :param fnout: complete path to the exporting obs file
+    :type fnout: str
+    
+    :param: eventinfo, source time needed for VELEST-cnv format
+    :type:  list object
+
+    :param: parameter, all input information
+    :type:  object
+    '''
+    # write phases to VELEST-phase file
+    writephases(picks, 'VELEST', fnout, parameter, eventinfo)

pylot/core/pick/charfuns.py

@@ -17,7 +17,6 @@ autoregressive prediction: application ot local and regional distances, Geophys.
 :author: MAGS2 EP3 working group
 """
 
-import matplotlib.pyplot as plt
 import numpy as np
 from obspy.core import Stream
 
@@ -27,7 +26,7 @@ class CharacteristicFunction(object):
     SuperClass for different types of characteristic functions.
     '''
 
-    def __init__(self, data, cut, t2=None, order=None, t1=None, fnoise=None, stealthMode=False):
+    def __init__(self, data, cut, t2=None, order=None, t1=None, fnoise=None):
         '''
         Initialize data type object with information from the original
         Seismogram.
@@ -64,7 +63,6 @@ class CharacteristicFunction(object):
         self.calcCF(self.getDataArray())
         self.arpara = np.array([])
         self.xpred = np.array([])
-        self._stealthMode = stealthMode
 
     def __str__(self):
         return '''\n\t{name} object:\n
@@ -138,9 +136,6 @@ class CharacteristicFunction(object):
     def getXCF(self):
         return self.xcf
 
-    def _getStealthMode(self):
-        return self._stealthMode()
-
     def getDataArray(self, cut=None):
         '''
         If cut times are given, time series is cut from cut[0] (start time)
@@ -225,13 +220,11 @@ class AICcf(CharacteristicFunction):
 
     def calcCF(self, data):
 
-        # if self._getStealthMode() is False:
-        #    print 'Calculating AIC ...'
         x = self.getDataArray()
         xnp = x[0].data
-        nn = np.isnan(xnp)
-        if len(nn) > 1:
-            xnp[nn] = 0
+        ind = np.where(~np.isnan(xnp))[0]
+        if ind.size:
+            xnp[:ind[0]] = xnp[ind[0]]
         datlen = len(xnp)
         k = np.arange(1, datlen)
         cf = np.zeros(datlen)
@@ -265,13 +258,9 @@ class HOScf(CharacteristicFunction):
         if len(nn) > 1:
             xnp[nn] = 0
         if self.getOrder() == 3:  # this is skewness
-            # if self._getStealthMode() is False:
-            #    print 'Calculating skewness ...'
             y = np.power(xnp, 3)
             y1 = np.power(xnp, 2)
         elif self.getOrder() == 4:  # this is kurtosis
-            # if self._getStealthMode() is False:
-            #    print 'Calculating kurtosis ...'
             y = np.power(xnp, 4)
             y1 = np.power(xnp, 2)
 
@@ -297,9 +286,12 @@ class HOScf(CharacteristicFunction):
             elif self.getOrder() == 4:
                 LTA[j] = lta / np.power(lta1, 2)
 
-        nn = np.isnan(LTA)
-        if len(nn) > 1:
-            LTA[nn] = 0
+        # remove NaN's with first not-NaN-value,
+        # so autopicker doesnt pick discontinuity at start of the trace
+        ind = np.where(~np.isnan(LTA))[0]
+        if ind.size:
+            first = ind[0]
+            LTA[:first] = LTA[first]
         self.cf = LTA
         self.xcf = x
 
@@ -307,7 +299,7 @@ class HOScf(CharacteristicFunction):
 class ARZcf(CharacteristicFunction):
     def calcCF(self, data):
 
-        print 'Calculating AR-prediction error from single trace ...'
+        print('Calculating AR-prediction error from single trace ...')
         x = self.getDataArray(self.getCut())
         xnp = x[0].data
         nn = np.isnan(xnp)
@@ -343,7 +335,8 @@ class ARZcf(CharacteristicFunction):
         cf = tap * cf
         io = np.where(cf == 0)
         ino = np.where(cf > 0)
-        cf[io] = cf[ino[0][0]]
+        if np.size(ino):
+            cf[io] = cf[ino[0][0]]
 
         self.cf = cf
         self.xcf = x
@@ -430,7 +423,7 @@ class ARZcf(CharacteristicFunction):
 class ARHcf(CharacteristicFunction):
     def calcCF(self, data):
 
-        print 'Calculating AR-prediction error from both horizontal traces ...'
+        print('Calculating AR-prediction error from both horizontal traces ...')
 
         xnp = self.getDataArray(self.getCut())
         n0 = np.isnan(xnp[0].data)
@@ -466,7 +459,7 @@ class ARHcf(CharacteristicFunction):
             # prediction error = CF
             cf[i + lpred] = np.sqrt(np.sum(np.power(self.xpred[0][i:i + lpred] - xnp[0][i:i + lpred], 2) \
                                            + np.power(self.xpred[1][i:i + lpred] - xnp[1][i:i + lpred], 2)) / (
-                                    2 * lpred))
+                                        2 * lpred))
         nn = np.isnan(cf)
         if len(nn) > 1:
             cf[nn] = 0
@@ -475,7 +468,8 @@ class ARHcf(CharacteristicFunction):
         cf = tap * cf
         io = np.where(cf == 0)
         ino = np.where(cf > 0)
-        cf[io] = cf[ino[0][0]]
+        if np.size(ino):
+            cf[io] = cf[ino[0][0]]
 
         self.cf = cf
         self.xcf = xnp
@@ -567,7 +561,7 @@ class ARHcf(CharacteristicFunction):
 class AR3Ccf(CharacteristicFunction):
     def calcCF(self, data):
 
-        print 'Calculating AR-prediction error from all 3 components ...'
+        print('Calculating AR-prediction error from all 3 components ...')
 
         xnp = self.getDataArray(self.getCut())
         n0 = np.isnan(xnp[0].data)
@@ -608,7 +602,7 @@ class AR3Ccf(CharacteristicFunction):
             cf[i + lpred] = np.sqrt(np.sum(np.power(self.xpred[0][i:i + lpred] - xnp[0][i:i + lpred], 2) \
                                            + np.power(self.xpred[1][i:i + lpred] - xnp[1][i:i + lpred], 2) \
                                            + np.power(self.xpred[2][i:i + lpred] - xnp[2][i:i + lpred], 2)) / (
-                                    3 * lpred))
+                                        3 * lpred))
         nn = np.isnan(cf)
         if len(nn) > 1:
             cf[nn] = 0
@@ -617,7 +611,8 @@ class AR3Ccf(CharacteristicFunction):
         cf = tap * cf
         io = np.where(cf == 0)
         ino = np.where(cf > 0)
-        cf[io] = cf[ino[0][0]]
+        if np.size(ino):
+            cf[io] = cf[ino[0][0]]
 
         self.cf = cf
         self.xcf = xnp

pylot/core/pick/compare.py

@@ -4,12 +4,11 @@
 import copy
 import operator
 import os
-import numpy as np
-import glob
+
 import matplotlib.pyplot as plt
-
+import numpy as np
 from obspy import read_events
-
+from obspy.core import AttribDict
 from pylot.core.io.phases import picksdict_from_picks
 from pylot.core.util.pdf import ProbabilityDensityFunction
 from pylot.core.util.utils import find_in_list
@@ -28,16 +27,8 @@ class Comparison(object):
     """
 
     def __init__(self, **kwargs):
-        names = list()
         self._pdfs = dict()
-        for name, fn in kwargs.items():
-            if isinstance(fn, PDFDictionary):
-                self._pdfs[name] = fn
-            elif isinstance(fn, dict):
-                self._pdfs[name] = PDFDictionary(fn)
-            else:
-                self._pdfs[name] = PDFDictionary.from_quakeml(fn)
-            names.append(name)
+        names = self.iter_kwargs(kwargs)
         if len(names) > 2:
             raise ValueError('Comparison is only defined for two '
                              'arguments!')
@@ -49,6 +40,40 @@ class Comparison(object):
             return False
         return True
 
+    def iter_kwargs(self, kwargs):
+        names = list()
+        for name, fn in kwargs.items():
+            if name == 'eventlist':
+                names = self.init_by_eventlist(fn)
+                break
+            if isinstance(fn, PDFDictionary):
+                self._pdfs[name] = fn
+            elif isinstance(fn, dict) or isinstance(fn, AttribDict):
+                self._pdfs[name] = PDFDictionary(fn)
+            else:
+                self._pdfs[name] = PDFDictionary.from_quakeml(fn)
+            names.append(name)
+        return names
+
+    def init_by_eventlist(self, eventlist):
+        # create one dictionary containing all picks for all events (therefore modify station key)
+        global_picksdict = {}
+        for event in eventlist:
+            automanu = {'manu': event.pylot_picks,
+                        'auto': event.pylot_autopicks}
+            for method, picksdict in automanu.items():
+                if not method in global_picksdict.keys():
+                    global_picksdict[method] = {}
+                for station, picks in picksdict.items():
+                    new_picksdict = global_picksdict[method]
+                    # new id combining event and station in one dictionary for all events
+                    id = '{}_{}'.format(event.pylot_id, station)
+                    new_picksdict[id] = picks
+        for method, picksdict in global_picksdict.items():
+            self._pdfs[method] = PDFDictionary(picksdict)
+        names = list(global_picksdict.keys())
+        return names
+
     def get(self, name):
         return self._pdfs[name]
 
@@ -93,8 +118,8 @@ class Comparison(object):
         """
         compare_pdfs = dict()
 
-        pdf_a = self.get(self.names[0]).generate_pdf_data(type)
-        pdf_b = self.get(self.names[1]).generate_pdf_data(type)
+        pdf_a = self.get('auto').generate_pdf_data(type)
+        pdf_b = self.get('manu').generate_pdf_data(type)
 
         for station, phases in pdf_a.items():
             if station in pdf_b.keys():
@@ -155,7 +180,7 @@ class Comparison(object):
     def get_array(self, phase, method_name):
         method = operator.methodcaller(method_name)
         pdf_list = self.get_all(phase)
-        rarray = map(method, pdf_list)
+        rarray = list(map(method, pdf_list))
         return np.array(rarray)
 
     def get_expectation_array(self, phase):
@@ -253,11 +278,7 @@ class PDFDictionary(object):
 
     @classmethod
     def from_quakeml(self, fn):
-        cat = read_events(fn)
-        if len(cat) > 1:
-            raise NotImplementedError('reading more than one event at the same '
-                                      'time is not implemented yet! Sorry!')
-        return PDFDictionary(picksdict_from_picks(cat[0]))
+        return PDFDictionary(fn)
 
     def get_all(self, phase):
         rlist = list()
@@ -289,7 +310,6 @@ class PDFDictionary(object):
                     values['mpp'],
                     values['lpp'],
                     type=type)
-
         return pdf_picks
 
     def plot(self, stations=None):
@@ -336,7 +356,7 @@ class PDFDictionary(object):
                     axarr[l].set_title(phase)
                     if l is 0:
                         axann = axarr[l].annotate(station, xy=(.05, .5),
-                                                     xycoords='axes fraction')
+                                                  xycoords='axes fraction')
                         bbox_props = dict(boxstyle='round', facecolor='lightgrey',
                                           alpha=.7)
                         axann.set_bbox(bbox_props)
@@ -354,7 +374,6 @@ class PDFstatistics(object):
     Takes a path as argument.
     """
 
-
     def __init__(self, directory):
         """Initiates some values needed when dealing with pdfs later"""
         self._rootdir = directory
@@ -451,7 +470,7 @@ class PDFstatistics(object):
         else:
             raise ValueError("for call to method {0} value has to be "
                              "defined but is 'None' ".format(method_options[
-                                                             property.upper()]))
+                                                                 property.upper()]))
 
         for pdf_dict in self:
             # create worklist
@@ -461,7 +480,7 @@ class PDFstatistics(object):
 
         return rlist
 
-    def writeThetaToFile(self,array,out_dir):
+    def writeThetaToFile(self, array, out_dir):
         """
         Method to write array like data to file. Useful since acquiring can take
         serious amount of time when dealing with large databases.
@@ -473,16 +492,16 @@ class PDFstatistics(object):
         """
         fid = open(os.path.join(out_dir), 'w')
         for val in array:
-            fid.write(str(val)+'\n')
+            fid.write(str(val) + '\n')
         fid.close()
 
 
 def main():
-    root_dir ='/home/sebastianp/Codetesting/xmls/'
+    root_dir = '/home/sebastianp/Codetesting/xmls/'
     Insheim = PDFstatistics(root_dir)
     Insheim.curphase = 'p'
     qdlist = Insheim.get('qdf', 0.2)
-    print qdlist
+    print(qdlist)
 
 
 if __name__ == "__main__":
@@ -493,4 +512,4 @@ if __name__ == "__main__":
     main()
     pr.disable()
     # after your program ends
-    pr.print_stats(sort="calls")
+    pr.print_stats(sort="calls")

pylot/core/pick/picker.py

@@ -19,12 +19,14 @@ calculated after Diehl & Kissling (2009).
 :author: MAGS2 EP3 working group / Ludger Kueperkoch
 """
 
-import numpy as np
-import matplotlib.pyplot as plt
-from pylot.core.pick.utils import getnoisewin, getsignalwin
-from pylot.core.pick.charfuns import CharacteristicFunction
 import warnings
 
+import matplotlib.pyplot as plt
+import numpy as np
+from scipy.signal import argrelmax
+from pylot.core.pick.charfuns import CharacteristicFunction
+from pylot.core.pick.utils import getnoisewin, getsignalwin
+
 
 class AutoPicker(object):
     '''
@@ -34,7 +36,7 @@ class AutoPicker(object):
 
     warnings.simplefilter('ignore')
 
-    def __init__(self, cf, TSNR, PickWindow, iplot=None, aus=None, Tsmooth=None, Pick1=None):
+    def __init__(self, cf, TSNR, PickWindow, iplot=0, aus=None, Tsmooth=None, Pick1=None, fig=None, linecolor='k'):
         '''
         :param: cf, characteristic function, on which the picking algorithm is applied
         :type: `~pylot.core.pick.CharFuns.CharacteristicFunction` object
@@ -61,7 +63,8 @@ class AutoPicker(object):
         '''
 
         assert isinstance(cf, CharacteristicFunction), "%s is not a CharacteristicFunction object" % str(cf)
-
+        self._linecolor = linecolor
+        self._pickcolor_p = 'b'
         self.cf = cf.getCF()
         self.Tcf = cf.getTimeArray()
         self.Data = cf.getXCF()
@@ -72,6 +75,7 @@ class AutoPicker(object):
         self.setaus(aus)
         self.setTsmooth(Tsmooth)
         self.setpick1(Pick1)
+        self.fig = fig
         self.calcPick()
 
     def __str__(self):
@@ -152,6 +156,15 @@ class AICPicker(AutoPicker):
         self.Pick = None
         self.slope = None
         self.SNR = None
+        plt_flag = 0
+        try:
+            iplot = int(self.iplot)
+        except:
+            if self.iplot == True or self.iplot == 'True':
+               iplot = 2
+            else:
+               iplot = 0
+
         # find NaN's
         nn = np.isnan(self.cf)
         if len(nn) > 1:
@@ -172,21 +185,14 @@ class AICPicker(AutoPicker):
                     aicsmooth[i] = aicsmooth[i - 1] + (aic[i] - aic[ii1]) / ismooth
                 else:
                     aicsmooth[i] = np.mean(aic[1: i])
-        # remove offset
+        # remove offset in AIC function
         offset = abs(min(aic) - min(aicsmooth))
         aicsmooth = aicsmooth - offset
-        # get maximum of 1st derivative of AIC-CF (more stable!) as starting point
-        diffcf = np.diff(aicsmooth)
-        # find NaN's
-        nn = np.isnan(diffcf)
-        if len(nn) > 1:
-            diffcf[nn] = 0
-        # taper CF to get rid off side maxima
-        tap = np.hanning(len(diffcf))
-        diffcf = tap * diffcf * max(abs(aicsmooth))
-        icfmax = np.argmax(diffcf)
+        # get maximum of HOS/AR-CF as startimg point for searching
+        # minimum in AIC function 
+        icfmax = np.argmax(self.Data[0].data)
 
-        # find minimum in AIC-CF front of maximum
+        # find minimum in AIC-CF front of maximum of HOS/AR-CF
         lpickwindow = int(round(self.PickWindow / self.dt))
         for i in range(icfmax - 1, max([icfmax - lpickwindow, 2]), -1):
             if aicsmooth[i - 1] >= aicsmooth[i]:
@@ -195,6 +201,14 @@ class AICPicker(AutoPicker):
         # if no minimum could be found:
         # search in 1st derivative of AIC-CF
         if self.Pick is None:
+            diffcf = np.diff(aicsmooth)
+            # find NaN's
+            nn = np.isnan(diffcf)
+            if len(nn) > 1:
+                diffcf[nn] = 0
+            # taper CF to get rid off side maxima
+            tap = np.hanning(len(diffcf))
+            diffcf = tap * diffcf * max(abs(aicsmooth))
             for i in range(icfmax - 1, max([icfmax - lpickwindow, 2]), -1):
                 if diffcf[i - 1] >= diffcf[i]:
                     self.Pick = self.Tcf[i]
@@ -206,89 +220,148 @@ class AICPicker(AutoPicker):
             inoise = getnoisewin(self.Tcf, self.Pick, self.TSNR[0], self.TSNR[1])
             # check, if these are counts or m/s, important for slope estimation!
             # this is quick and dirty, better solution?
-            if max(self.Data[0].data < 1e-3):
-                self.Data[0].data = self.Data[0].data * 1000000
+            if max(self.Data[0].data < 1e-3) and max(self.Data[0].data >= 1e-6):
+                self.Data[0].data = self.Data[0].data * 1000000.
+            elif max(self.Data[0].data < 1e-6):
+                self.Data[0].data = self.Data[0].data * 1e13
             # get signal window
             isignal = getsignalwin(self.Tcf, self.Pick, self.TSNR[2])
+            if len(isignal) == 0:
+                return
+            ii = min([isignal[len(isignal) - 1], len(self.Tcf)])
+            isignal = isignal[0:ii]
+            try:
+                self.Data[0].data[isignal]
+            except IndexError as e:
+                msg = "Time series out of bounds! {}".format(e)
+                print(msg)
+                return
             # calculate SNR from CF
-            self.SNR = max(abs(aic[isignal] - np.mean(aic[isignal]))) / \
-                       max(abs(aic[inoise] - np.mean(aic[inoise])))
+            self.SNR = max(abs(self.Data[0].data[isignal] - np.mean(self.Data[0].data[isignal]))) / \
+                       max(abs(self.Data[0].data[inoise] - np.mean(self.Data[0].data[inoise])))
             # calculate slope from CF after initial pick
             # get slope window
             tslope = self.TSNR[3]  # slope determination window
-            islope = np.where((self.Tcf <= min([self.Pick + tslope, len(self.Data[0].data)])) \
-                              & (self.Tcf >= self.Pick))
+            islope = np.where((self.Tcf <= min([self.Pick + tslope, self.Tcf[-1]])) \
+                              & (self.Tcf >= self.Pick)) # TODO: put this in a seperate function like getsignalwin
             # find maximum within slope determination window
             # 'cause slope should be calculated up to first local minimum only!
-            imax = np.argmax(self.Data[0].data[islope])
-            if imax == 0:
-                print('AICPicker: Maximum for slope determination right at the beginning of the window!')
-                print('Choose longer slope determination window!')
-                if self.iplot > 1:
-                    p = plt.figure(self.iplot)
-                    x = self.Data[0].data
-                    p1, = plt.plot(self.Tcf, x / max(x), 'k')
-                    p2, = plt.plot(self.Tcf, aicsmooth / max(aicsmooth), 'r')
-                    plt.legend([p1, p2], ['(HOS-/AR-) Data', 'Smoothed AIC-CF'])
-                    plt.xlabel('Time [s] since %s' % self.Data[0].stats.starttime)
-                    plt.yticks([])
-                    plt.title(self.Data[0].stats.station)
-                    plt.show()
-                    raw_input()
-                    plt.close(p)
+            try:
+                dataslope = self.Data[0].data[islope[0][0:-1]]
+            except IndexError:
+                print("Slope Calculation: empty array islope, check signal window")
                 return
-            islope = islope[0][0:imax]
-            dataslope = self.Data[0].data[islope]
+            if len(dataslope) < 1:
+                print('No data in slope window found!')
+                return
+            imaxs, = argrelmax(dataslope)
+            if imaxs.size:
+                imax = imaxs[0]
+            else:
+                imax = np.argmax(dataslope)
+            iislope = islope[0][0:imax + 1]
+            if len(iislope) < 2:
+                # calculate slope from initial onset to maximum of AIC function
+                print("AICPicker: Not enough data samples left for slope calculation!")
+                print("Calculating slope from initial onset to maximum of AIC function ...")
+                imax = np.argmax(aicsmooth[islope[0][0:-1]])
+                if imax == 0:
+                    print("AICPicker: Maximum for slope determination right at the beginning of the window!")
+                    print("Choose longer slope determination window!")
+                    if self.iplot > 1:
+                        if self.fig == None or self.fig == 'None':
+                            fig = plt.figure()
+                            plt_flag = 1
+                        else:
+                            fig = self.fig
+                        ax = fig.add_subplot(111)
+                        x = self.Data[0].data
+                        ax.plot(self.Tcf, x / max(x), color=self._linecolor, linewidth=0.7, label='(HOS-/AR-) Data')
+                        ax.plot(self.Tcf, aicsmooth / max(aicsmooth), 'r', label='Smoothed AIC-CF')
+                        ax.legend(loc=1)
+                        ax.set_xlabel('Time [s] since %s' % self.Data[0].stats.starttime)
+                        ax.set_yticks([])
+                        ax.set_title(self.Data[0].stats.station)
+                        if plt_flag == 1:
+                            fig.show()
+                            try: input()
+                            except SyntaxError: pass
+                            plt.close(fig)
+                    return
+                iislope = islope[0][0:imax+1]
+            dataslope = self.Data[0].data[iislope]
             # calculate slope as polynomal fit of order 1
             xslope = np.arange(0, len(dataslope), 1)
             P = np.polyfit(xslope, dataslope, 1)
             datafit = np.polyval(P, xslope)
-            if datafit[0] >= datafit[len(datafit) - 1]:
+            if datafit[0] >= datafit[-1]:
                 print('AICPicker: Negative slope, bad onset skipped!')
                 return
-            self.slope = 1 / tslope * (datafit[len(dataslope) - 1] - datafit[0])
+            self.slope = 1 / (len(dataslope) * self.Data[0].stats.delta) * (datafit[-1] - datafit[0])
 
         else:
             self.SNR = None
             self.slope = None
 
-        if self.iplot > 1:
-            p = plt.figure(self.iplot)
-            x = self.Data[0].data
-            p1, = plt.plot(self.Tcf, x / max(x), 'k')
-            p2, = plt.plot(self.Tcf, aicsmooth / max(aicsmooth), 'r')
-            if self.Pick is not None:
-                p3, = plt.plot([self.Pick, self.Pick], [-0.1, 0.5], 'b', linewidth=2)
-                plt.legend([p1, p2, p3], ['(HOS-/AR-) Data', 'Smoothed AIC-CF', 'AIC-Pick'])
+        if iplot > 1:
+            if self.fig == None or self.fig == 'None':
+                fig = plt.figure()  # self.iplot)
+                plt_flag = 1
             else:
-                plt.legend([p1, p2], ['(HOS-/AR-) Data', 'Smoothed AIC-CF'])
-            plt.xlabel('Time [s] since %s' % self.Data[0].stats.starttime)
-            plt.yticks([])
-            plt.title(self.Data[0].stats.station)
+                fig = self.fig
+            fig._tight = True
+            ax1 = fig.add_subplot(211)
+            x = self.Data[0].data
+            if len(self.Tcf) > len(self.Data[0].data): # why? LK
+                self.Tcf = self.Tcf[0:len(self.Tcf)-1]
+            ax1.plot(self.Tcf, x / max(x), color=self._linecolor, linewidth=0.7, label='(HOS-/AR-) Data')
+            ax1.plot(self.Tcf, aicsmooth / max(aicsmooth), 'r', label='Smoothed AIC-CF')
+            if self.Pick is not None:
+                ax1.plot([self.Pick, self.Pick], [-0.1, 0.5], 'b', linewidth=2, label='AIC-Pick')
+            ax1.set_xlabel('Time [s] since %s' % self.Data[0].stats.starttime)
+            ax1.set_yticks([])
+            ax1.legend(loc=1)
 
             if self.Pick is not None:
-                plt.figure(self.iplot + 1)
-                p11, = plt.plot(self.Tcf, x, 'k')
-                p12, = plt.plot(self.Tcf[inoise], self.Data[0].data[inoise])
-                p13, = plt.plot(self.Tcf[isignal], self.Data[0].data[isignal], 'r')
-                p14, = plt.plot(self.Tcf[islope], dataslope, 'g--')
-                p15, = plt.plot(self.Tcf[islope], datafit, 'g', linewidth=2)
-                plt.legend([p11, p12, p13, p14, p15],
-                           ['Data', 'Noise Window', 'Signal Window', 'Slope Window', 'Slope'],
-                           loc='best')
-                plt.title('Station %s, SNR=%7.2f, Slope= %12.2f counts/s' % (self.Data[0].stats.station,
-                                                                             self.SNR, self.slope))
-                plt.xlabel('Time [s] since %s' % self.Data[0].stats.starttime)
-                plt.ylabel('Counts')
-                plt.yticks([])
+                ax2 = fig.add_subplot(2, 1, 2, sharex=ax1)
+                ax2.plot(self.Tcf, x, color=self._linecolor, linewidth=0.7, label='Data')
+                ax1.axvspan(self.Tcf[inoise[0]], self.Tcf[inoise[-1]], color='y', alpha=0.2, lw=0, label='Noise Window')
+                ax1.axvspan(self.Tcf[isignal[0]], self.Tcf[isignal[-1]], color='b', alpha=0.2, lw=0,
+                            label='Signal Window')
+                ax1.axvspan(self.Tcf[iislope[0]], self.Tcf[iislope[-1]], color='g', alpha=0.2, lw=0,
+                            label='Slope Window')
 
-            plt.show()
-            raw_input()
-            plt.close(p)
+                ax2.axvspan(self.Tcf[inoise[0]], self.Tcf[inoise[-1]], color='y', alpha=0.2, lw=0, label='Noise Window')
+                ax2.axvspan(self.Tcf[isignal[0]], self.Tcf[isignal[-1]], color='b', alpha=0.2, lw=0,
+                            label='Signal Window')
+                ax2.axvspan(self.Tcf[iislope[0]], self.Tcf[iislope[-1]], color='g', alpha=0.2, lw=0,
+                            label='Slope Window')
+                ax2.plot(self.Tcf[iislope], datafit, 'g', linewidth=2, label='Slope')
+
+                ax1.set_title('Station %s, SNR=%7.2f, Slope= %12.2f counts/s' % (self.Data[0].stats.station,
+                                                                                 self.SNR, self.slope))
+                ax2.set_xlabel('Time [s] since %s' % self.Data[0].stats.starttime)
+                ax2.set_ylabel('Counts')
+                ax2.set_yticks([])
+                ax2.legend(loc=1)
+                if plt_flag == 1:
+                    fig.show()
+                    try: input()
+                    except SyntaxError: pass
+                    plt.close(fig)
+            else:
+                ax1.set_title(self.Data[0].stats.station)
+                if plt_flag == 1:
+                    fig.show()
+                    try: input()
+                    except SyntaxError: pass
+                    plt.close(fig)
 
         if self.Pick == None:
             print('AICPicker: Could not find minimum, picking window too short?')
 
+        return
+
 
 class PragPicker(AutoPicker):
     '''
@@ -297,6 +370,14 @@ class PragPicker(AutoPicker):
 
     def calcPick(self):
 
+        try:
+            iplot = int(self.getiplot())
+        except:
+            if self.getiplot() == True or self.getiplot() == 'True':
+               iplot = 2
+            else:
+               iplot = 0
+
         if self.getpick1() is not None:
             print('PragPicker: Get most likely pick from HOS- or AR-CF using pragmatic picking algorithm ...')
 
@@ -304,6 +385,7 @@ class PragPicker(AutoPicker):
             self.SNR = None
             self.slope = None
             pickflag = 0
+            plt_flag = 0
             # smooth CF
             ismooth = int(round(self.Tsmooth / self.dt))
             cfsmooth = np.zeros(len(self.cf))
@@ -328,12 +410,19 @@ class PragPicker(AutoPicker):
             ipick1 = np.argmin(abs(self.Tcf - self.getpick1()))
             cfpick1 = 2 * self.cf[ipick1]
 
-            # check trend of CF, i.e. differences of CF and adjust aus regarding this trend
+            # check trend of CF, i.e. differences of CF and adjust aus ("artificial uplift 
+            # of picks") regarding this trend
             # prominent trend: decrease aus
             # flat: use given aus
             cfdiff = np.diff(cfipick)
+            if len(cfdiff)<20:
+                print('PragPicker: Very few samples for CF. Check LTA window dimensions!')
             i0diff = np.where(cfdiff > 0)
             cfdiff = cfdiff[i0diff]
+            if len(cfdiff)<1:
+                print('PragPicker: Negative slope for CF. Check LTA window dimensions! STOP')
+                self.Pick = None
+                return
             minaus = min(cfdiff * (1 + self.aus))
             aus1 = max([minaus, self.aus])
 
@@ -354,15 +443,20 @@ class PragPicker(AutoPicker):
                             break
 
             # now we look to the left
-            for i in range(ipick1, max([ipick1 - lpickwindow + 1, 2]), -1):
-                if self.cf[i + 1] > self.cf[i] and self.cf[i - 1] >= self.cf[i]:
-                    if cfsmooth[i - 1] * (1 + aus1) >= cfsmooth[i]:
-                        if cfpick1 >= self.cf[i]:
-                            pick_l = self.Tcf[i]
-                            self.Pick = pick_l
-                            flagpick_r = 1
-                            cfpick_l = self.cf[i]
-                            break
+            if len(self.cf) > ipick1 +1:
+                for i in range(ipick1, max([ipick1 - lpickwindow + 1, 2]), -1):
+                    if self.cf[i + 1] > self.cf[i] and self.cf[i - 1] >= self.cf[i]:
+                        if cfsmooth[i - 1] * (1 + aus1) >= cfsmooth[i]:
+                            if cfpick1 >= self.cf[i]:
+                                pick_l = self.Tcf[i]
+                                self.Pick = pick_l
+                                flagpick_r = 1
+                                cfpick_l = self.cf[i]
+                                break
+            else:
+                msg ='PragPicker: Initial onset too close to start of CF! \
+                      Stop finalizing pick to the left.'
+                print(msg)
 
             # now decide which pick: left or right?
             if flagpick_l > 0 and flagpick_r > 0 and cfpick_l <= 3 * cfpick_r:
@@ -375,25 +469,34 @@ class PragPicker(AutoPicker):
                 self.Pick = pick_l
                 pickflag = 1
             else:
-                print('PragPicker: Could not find reliable onset!')
+                print("PragPicker: Could not find reliable onset!")
                 self.Pick = None
                 pickflag = 0
 
-            if self.getiplot() > 1:
-                p = plt.figure(self.getiplot())
-                p1, = plt.plot(Tcfpick, cfipick, 'k')
-                p2, = plt.plot(Tcfpick, cfsmoothipick, 'r')
+            if iplot > 1:
+                if self.fig == None or self.fig == 'None':
+                    fig = plt.figure()  # self.getiplot())
+                    plt_flag = 1
+                else:
+                    fig = self.fig
+                fig._tight = True
+                ax = fig.add_subplot(111)
+                ax.plot(Tcfpick, cfipick, color=self._linecolor, linewidth=0.7, label='CF')
+                ax.plot(Tcfpick, cfsmoothipick, 'r', label='Smoothed CF')
                 if pickflag > 0:
-                    p3, = plt.plot([self.Pick, self.Pick], [min(cfipick), max(cfipick)], 'b', linewidth=2)
-                    plt.legend([p1, p2, p3], ['CF', 'Smoothed CF', 'Pick'])
-                plt.xlabel('Time [s] since %s' % self.Data[0].stats.starttime)
-                plt.yticks([])
-                plt.title(self.Data[0].stats.station)
-                plt.show()
-                raw_input()
-                plt.close(p)
+                    ax.plot([self.Pick, self.Pick], [min(cfipick), max(cfipick)], self._pickcolor_p, linewidth=2, label='Pick')
+                ax.set_xlabel('Time [s] since %s' % self.Data[0].stats.starttime)
+                ax.set_yticks([])
+                ax.set_title(self.Data[0].stats.station)
+                ax.legend(loc=1)
+                if plt_flag == 1:
+                    fig.show()
+                    try: input()
+                    except SyntaxError: pass
+                    plt.close(fig)
+                return
 
         else:
-            print('PragPicker: No initial onset time given! Check input!')
+            print("PragPicker: No initial onset time given! Check input!")
             self.Pick = None
             return

pylot/core/util/connection.py

@@ -1,13 +1,16 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
-import urllib2
+try:
+    from urllib2 import urlopen
+except:
+    from urllib.request import urlopen
 
 
-def checkurl(url='https://ariadne.geophysik.rub.de/trac/PyLoT'):
+def checkurl(url='https://ariadne.geophysik.ruhr-uni-bochum.de/trac/PyLoT/'):
     try:
-        urllib2.urlopen(url, timeout=1)
+        urlopen(url, timeout=1)
         return True
-    except urllib2.URLError:
+    except:
         pass
     return False

pylot/core/util/dataprocessing.py

@@ -1,17 +1,15 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
-import os
 import glob
+import os
 import sys
-from obspy.io.xseed import Parser
 
 import numpy as np
-
 from obspy import UTCDateTime, read_inventory, read
 from obspy.io.xseed import Parser
 from pylot.core.util.utils import key_for_set_value, find_in_list, \
-    remove_underscores
+    remove_underscores, gen_Pool
 
 
 def time_from_header(header):
@@ -117,7 +115,7 @@ def make_time_line(line, datetime):
     return newline
 
 
-def evt_head_check(root_dir, out_dir = None):
+def evt_head_check(root_dir, out_dir=None):
     """
     A function to make sure that an arbitrary number of .gse files have correct values in their header.
     :param root_dir: a directory leading to the .gse files.
@@ -169,7 +167,8 @@ def read_metadata(path_to_inventory):
     dlfile = list()
     invfile = list()
     respfile = list()
-    inv = dict(dless=dlfile, xml=invfile, resp=respfile)
+    # possible file extensions specified here:
+    inv = dict(dless=dlfile, xml=invfile, resp=respfile, dseed=dlfile[:])
     if os.path.isfile(path_to_inventory):
         ext = os.path.splitext(path_to_inventory)[1].split('.')[1]
         inv[ext] += [path_to_inventory]
@@ -180,8 +179,10 @@ def read_metadata(path_to_inventory):
     invtype = key_for_set_value(inv)
 
     if invtype is None:
-        raise IOError("Neither dataless-SEED file, inventory-xml file nor "
-                      "RESP-file found!")
+        print("Neither dataless-SEED file, inventory-xml file nor "
+              "RESP-file found!")
+        print("!!WRONG CALCULATION OF SOURCE PARAMETERS!!")
+        robj = None,
     elif invtype == 'dless':  # prevent multiple read of large dlsv
         print("Reading metadata information from dataless-SEED file ...")
         if len(inv[invtype]) == 1:
@@ -195,7 +196,80 @@ def read_metadata(path_to_inventory):
     return invtype, robj
 
 
-def restitute_data(data, invtype, inobj, unit='VEL', force=False):
+def restitute_trace(input_tuple):
+    tr, invtype, inobj, unit, force = input_tuple
+
+    remove_trace = False
+
+    seed_id = tr.get_id()
+    # check, whether this trace has already been corrected
+    if 'processing' in tr.stats.keys() \
+            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))
+        return tr, False
+    stime = tr.stats.starttime
+    prefilt = get_prefilt(tr)
+    if invtype == 'resp':
+        fresp = find_in_list(inobj, seed_id)
+        if not fresp:
+            raise IOError('no response file found '
+                          'for trace {0}'.format(seed_id))
+        fname = fresp
+        seedresp = dict(filename=fname,
+                        date=stime,
+                        units=unit)
+        kwargs = dict(paz_remove=None, pre_filt=prefilt, seedresp=seedresp)
+    elif invtype == 'dless':
+        if type(inobj) is list:
+            fname = Parser(find_in_list(inobj, seed_id))
+        else:
+            fname = inobj
+        seedresp = dict(filename=fname,
+                        date=stime,
+                        units=unit)
+        kwargs = dict(pre_filt=prefilt, seedresp=seedresp)
+    elif invtype == 'xml':
+        invlist = inobj
+        if len(invlist) > 1:
+            finv = find_in_list(invlist, seed_id)
+        else:
+            finv = invlist[0]
+        inventory = read_inventory(finv, format='STATIONXML')
+    elif invtype == None:
+        print("No restitution possible, as there are no station-meta data available!")
+        return tr, True
+    else:
+        remove_trace = True
+    # apply restitution to data
+    print("Correcting instrument at station %s, channel %s" \
+          % (tr.stats.station, tr.stats.channel))
+    try:
+        if invtype in ['resp', 'dless']:
+            try:
+                tr.simulate(**kwargs)
+            except ValueError as e:
+                vmsg = '{0}'.format(e)
+                print(vmsg)
+
+        else:
+            tr.attach_response(inventory)
+            tr.remove_response(output=unit,
+                               pre_filt=prefilt)
+    except ValueError as e:
+        msg0 = 'Response for {0} not found in Parser'.format(seed_id)
+        msg1 = 'evalresp failed to calculate response'
+        if msg0 not in e.message or msg1 not in e.message:
+            raise
+        else:
+            # restitution done to copies of data thus deleting traces
+            # that failed should not be a problem
+            remove_trace = True
+
+    return tr, remove_trace
+
+
+def restitute_data(data, invtype, inobj, unit='VEL', force=False, ncores=0):
     """
     takes a data stream and a path_to_inventory and returns the corrected
     waveform data stream
@@ -214,72 +288,28 @@ def restitute_data(data, invtype, inobj, unit='VEL', force=False):
     data = remove_underscores(data)
 
     # loop over traces
+    input_tuples = []
     for tr in data:
-        seed_id = tr.get_id()
-        # check, whether this trace has already been corrected
-        if 'processing' in tr.stats.keys() \
-                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
-        stime = tr.stats.starttime
-        prefilt = get_prefilt(tr)
-        if invtype == 'resp':
-            fresp = find_in_list(inobj, seed_id)
-            if not fresp:
-                raise IOError('no response file found '
-                              'for trace {0}'.format(seed_id))
-            fname = fresp
-            seedresp = dict(filename=fname,
-                            date=stime,
-                            units=unit)
-            kwargs = dict(paz_remove=None, pre_filt=prefilt, seedresp=seedresp)
-        elif invtype == 'dless':
-            if type(inobj) is list:
-                fname = Parser(find_in_list(inobj, seed_id))
-            else:
-                fname = inobj
-            seedresp = dict(filename=fname,
-                            date=stime,
-                            units=unit)
-            kwargs = dict(pre_filt=prefilt, seedresp=seedresp)
-        elif invtype == 'xml':
-            invlist = inobj
-            if len(invlist) > 1:
-                finv = find_in_list(invlist, seed_id)
-            else:
-                finv = invlist[0]
-            inventory = read_inventory(finv, format='STATIONXML')
-        else:
-            data.remove(tr)
-            continue
-        # apply restitution to data
-        try:
-            if invtype in ['resp', 'dless']:
-                tr.simulate(**kwargs)
-            else:
-                tr.attach_response(inventory)
-                tr.remove_response(output=unit,
-                                   pre_filt=prefilt)
-        except ValueError as e:
-            msg0 = 'Response for {0} not found in Parser'.format(seed_id)
-            msg1 = 'evalresp failed to calculate response'
-            if msg0 not in e.message or msg1 not in e.message:
-                raise
-            else:
-                # restitution done to copies of data thus deleting traces
-                # that failed should not be a problem
-                data.remove(tr)
-                continue
-        restflag.append(True)
+        input_tuples.append((tr, invtype, inobj, unit, force))
+        data.remove(tr)
+
+    pool = gen_Pool(ncores)
+    result = pool.map(restitute_trace, input_tuples)
+    pool.close()
+
+    for tr, remove_trace in result:
+        if not remove_trace:
+            data.traces.append(tr)
+
     # check if ALL traces could be restituted, take care of large datasets
     # better try restitution for smaller subsets of data (e.g. station by
     # station)
-    if len(restflag) > 0:
-        restflag = bool(np.all(restflag))
-    else:
-        restflag = False
-    return data, restflag
+
+    # if len(restflag) > 0:
+    #     restflag = bool(np.all(restflag))
+    # else:
+    #     restflag = False
+    return data
 
 
 def get_prefilt(trace, tlow=(0.5, 0.9), thi=(5., 2.), verbosity=0):
@@ -312,8 +342,8 @@ def get_prefilt(trace, tlow=(0.5, 0.9), thi=(5., 2.), verbosity=0):
             trace.stats.station, trace.stats.channel))
     # get corner frequencies for pre-filtering
     fny = trace.stats.sampling_rate / 2
-    fc21 = fny - (fny * thi[0]/100.)
-    fc22 = fny - (fny * thi[1]/100.)
+    fc21 = fny - (fny * thi[0] / 100.)
+    fc22 = fny - (fny * thi[1] / 100.)
     return (tlow[0], tlow[1], fc21, fc22)
 
 

pylot/core/util/defaults.py

@@ -7,45 +7,29 @@ Created on Wed Feb 26 12:31:25 2014
 """
 
 import os
+import platform
+
+from pylot.core.util.utils import readDefaultFilterInformation
+from pylot.core.loc import hypo71
+from pylot.core.loc import hypodd
+from pylot.core.loc import hyposat
 from pylot.core.loc import nll
-from pylot.core.loc import hsat
 from pylot.core.loc import velest
 
 
-def readFilterInformation(fname):
-    def convert2FreqRange(*args):
-        if len(args) > 1:
-            return [float(arg) for arg in args]
-        elif len(args) == 1:
-            return float(args[0])
-        return None
+# determine system dependent path separator
+system_name = platform.system()
+if system_name in ["Linux", "Darwin"]:
+    SEPARATOR = '/'
+elif system_name == "Windows":
+    SEPARATOR = '\\'
 
-    filter_file = open(fname, 'r')
-    filter_information = dict()
-    for filter_line in filter_file.readlines():
-        filter_line = filter_line.split(' ')
-        for n, pos in enumerate(filter_line):
-            if pos == '\n':
-                filter_line[n] = ''
-        filter_information[filter_line[0]] = {'filtertype': filter_line[1]
-        if filter_line[1]
-        else None,
-                                              'order': int(filter_line[2])
-                                              if filter_line[1]
-                                              else None,
-                                              'freq': convert2FreqRange(*filter_line[3:])
-                                              if filter_line[1]
-                                              else None}
-    return filter_information
+# suffix for phase name if not phase identified by last letter (P, p, etc.)
+ALTSUFFIX = ['diff', 'n', 'g', '1', '2', '3']
 
-
-FILTERDEFAULTS = readFilterInformation(os.path.join(os.path.expanduser('~'),
-                                                    '.pylot',
-                                                    'filter.in'))
-
-AUTOMATIC_DEFAULTS = os.path.join(os.path.expanduser('~'),
-                                  '.pylot',
-                                  'autoPyLoT.in')
+FILTERDEFAULTS = readDefaultFilterInformation(os.path.join(os.path.expanduser('~'),
+                                                           '.pylot',
+                                                           'pylot.in'))
 
 TIMEERROR_DEFAULTS = os.path.join(os.path.expanduser('~'),
                                   '.pylot',
@@ -55,11 +39,57 @@ OUTPUTFORMATS = {'.xml': 'QUAKEML',
                  '.cnv': 'CNV',
                  '.obs': 'NLLOC_OBS'}
 
-LOCTOOLS = dict(nll=nll, hsat=hsat, velest=velest)
+LOCTOOLS = dict(nll=nll, hyposat=hyposat, velest=velest, hypo71=hypo71, hypodd=hypodd)
 
-COMPPOSITION_MAP = dict(Z=2, N=1, E=0)
-COMPPOSITION_MAP['1'] = 1
-COMPPOSITION_MAP['2'] = 0
-COMPPOSITION_MAP['3'] = 2
 
-COMPNAME_MAP = dict(Z='3', N='1', E='2')
+class SetChannelComponents(object):
+    def __init__(self):
+        self.setDefaultCompPosition()
+
+    def setDefaultCompPosition(self):
+        # default component order
+        self.compPosition_Map = dict(Z=2, N=1, E=0)
+        self.compName_Map = {'3': 'Z',
+                             '1': 'N',
+                             '2': 'E'}
+
+    def _getCurrentPosition(self, component):
+        for key, value in self.compName_Map.items():
+            if value == component:
+                return key, value
+        errMsg = 'getCurrentPosition: Could not find former position of component {}.'.format(component)
+        raise ValueError(errMsg)
+
+    def _switch(self, component, component_alter):
+        # Without switching, multiple definitions of the same alter_comp are possible
+        old_alter_comp, _ = self._getCurrentPosition(component)
+        old_comp = self.compName_Map[component_alter]
+        if not old_alter_comp == component_alter and not old_comp == component:
+            self.compName_Map[old_alter_comp] = old_comp
+            print('switch: Automatically switched component {} to {}'.format(old_alter_comp, old_comp))
+
+    def setCompPosition(self, component_alter, component, switch=True):
+        component_alter = str(component_alter)
+        if not component_alter in self.compName_Map.keys():
+            errMsg = 'setCompPosition: Unrecognized alternative component {}. Expecting one of {}.'
+            raise ValueError(errMsg.format(component_alter, self.compName_Map.keys()))
+        if not component in self.compPosition_Map.keys():
+            errMsg = 'setCompPosition: Unrecognized target component {}. Expecting one of {}.'
+            raise ValueError(errMsg.format(component, self.compPosition_Map.keys()))
+        print('setCompPosition: set component {} to {}'.format(component_alter, component))
+        if switch:
+            self._switch(component, component_alter)
+        self.compName_Map[component_alter] = component
+
+    def getCompPosition(self, component):
+        return self._getCurrentPosition(component)[0]
+
+    def getPlotPosition(self, component):
+        component = str(component)
+        if component in self.compPosition_Map.keys():
+            return self.compPosition_Map[component]
+        elif component in self.compName_Map.keys():
+            return self.compPosition_Map[self.compName_Map[component]]
+        else:
+            errMsg = 'getCompPosition: Unrecognized component {}. Expecting one of {} or {}.'
+            raise ValueError(errMsg.format(component, self.compPosition_Map.keys(), self.compName_Map.keys()))

pylot/core/util/errors.py

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

pylot/core/util/event.py

@@ -0,0 +1,172 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import os
+
+from obspy import UTCDateTime
+from obspy.core.event import Event as ObsPyEvent
+from obspy.core.event import Origin, ResourceIdentifier
+from pylot.core.io.phases import picks_from_picksdict
+
+
+class Event(ObsPyEvent):
+    '''
+    Pickable class derived from ~obspy.core.event.Event containing information on a single event.
+    '''
+
+    def __init__(self, path):
+        self.pylot_id = path.split('/')[-1]
+        # initialize super class
+        super(Event, self).__init__(resource_id=ResourceIdentifier('smi:local/' + self.pylot_id))
+        self.path = path
+        self.database = path.split('/')[-2]
+        self.datapath = path.split('/')[-3]
+        self.rootpath = '/' + os.path.join(*path.split('/')[:-3])
+        self.pylot_autopicks = {}
+        self.pylot_picks = {}
+        self.notes = ''
+        self._testEvent = False
+        self._refEvent = False
+        self.get_notes()
+
+    def get_notes_path(self):
+        notesfile = os.path.join(self.path, 'notes.txt')
+        return notesfile
+
+    def get_notes(self):
+        notesfile = self.get_notes_path()
+        if os.path.isfile(notesfile):
+            with open(notesfile) as infile:
+                path = str(infile.readlines()[0].split('\n')[0])
+                text = '[eventInfo: ' + path + ']'
+                self.addNotes(text)
+                try:
+                    datetime = UTCDateTime(path.split('/')[-1])
+                    origin = Origin(resource_id=self.resource_id, time=datetime, latitude=0, longitude=0, depth=0)
+                    self.origins.append(origin)
+                except:
+                    pass
+
+    def addNotes(self, notes):
+        self.notes = str(notes)
+
+    def clearNotes(self):
+        self.notes = None
+
+    def isRefEvent(self):
+        return self._refEvent
+
+    def isTestEvent(self):
+        return self._testEvent
+
+    def setRefEvent(self, bool):
+        self._refEvent = bool
+        if bool: self._testEvent = False
+
+    def setTestEvent(self, bool):
+        self._testEvent = bool
+        if bool: self._refEvent = False
+
+    def clearObsPyPicks(self, picktype):
+        for index, pick in reversed(list(enumerate(self.picks))):
+            if picktype in str(pick.method_id):
+                self.picks.pop(index)
+
+    def addPicks(self, picks):
+        '''
+        add pylot picks and overwrite existing ones
+        '''
+        for station in picks:
+            self.pylot_picks[station] = picks[station]
+        # add ObsPy picks (clear old manual and copy all new manual from pylot)
+        self.clearObsPyPicks('manual')
+        self.picks += picks_from_picksdict(self.pylot_picks)
+
+    def addAutopicks(self, autopicks):
+        for station in autopicks:
+            self.pylot_autopicks[station] = autopicks[station]
+        # add ObsPy picks (clear old auto and copy all new auto from pylot)
+        self.clearObsPyPicks('auto')
+        self.picks += picks_from_picksdict(self.pylot_autopicks)
+
+    def setPick(self, station, pick):
+        if pick:
+            self.pylot_picks[station] = pick
+        else:
+            try:
+                self.pylot_picks.pop(station)
+            except Exception as e:
+                print('Could not remove pick {} from station {}: {}'.format(pick, station, e))
+        self.clearObsPyPicks('manual')
+        self.picks += picks_from_picksdict(self.pylot_picks)
+
+    def setPicks(self, picks):
+        '''
+        set pylot picks and delete and overwrite all existing
+        '''
+        self.pylot_picks = picks
+        self.clearObsPyPicks('manual')
+        self.picks += picks_from_picksdict(self.pylot_picks)
+
+    def getPick(self, station):
+        if station in self.pylot_picks.keys():
+            return self.pylot_picks[station]
+
+    def getPicks(self):
+        return self.pylot_picks
+
+    def setAutopick(self, station, pick):
+        if pick:
+            self.pylot_autopicks[station] = pick
+        else:
+            try:
+                self.pylot_autopicks.pop(station)
+            except Exception as e:
+                print('Could not remove pick {} from station {}: {}'.format(pick, station, e))
+        self.clearObsPyPicks('auto')
+        self.picks += picks_from_picksdict(self.pylot_autopicks)
+
+    def setAutopicks(self, picks):
+        '''
+        set pylot picks and delete and overwrite all existing
+        '''
+        self.pylot_autopicks = picks
+        self.clearObsPyPicks('auto')
+        self.picks += picks_from_picksdict(self.pylot_autopicks)
+
+    def getAutopick(self, station):
+        if station in self.pylot_autopicks.keys():
+            return self.pylot_autopicks[station]
+
+    def getAutopicks(self):
+        return self.pylot_autopicks
+
+    def save(self, filename):
+        '''
+        Save PyLoT Event to a file. 
+        Can be loaded by using event.load(filename).
+        '''
+        try:
+            import cPickle
+        except ImportError:
+            import _pickle as cPickle
+
+        try:
+            outfile = open(filename, 'wb')
+            cPickle.dump(self, outfile, -1)
+        except Exception as e:
+            print('Could not pickle PyLoT event. Reason: {}'.format(e))
+
+    @staticmethod
+    def load(filename):
+        '''
+        Load project from filename.
+        '''
+        try:
+            import cPickle
+        except ImportError:
+            import _pickle as cPickle
+        infile = open(filename, 'rb')
+        event = cPickle.load(infile)
+        print('Loaded %s' % filename)
+        return event

pylot/core/util/map_projection.py

@@ -0,0 +1,376 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import matplotlib.pyplot as plt
+import numpy as np
+import obspy
+from PySide import QtGui
+from matplotlib.backends.backend_qt4agg import NavigationToolbar2QT as NavigationToolbar
+from mpl_toolkits.basemap import Basemap
+from pylot.core.util.widgets import PickDlg
+from scipy.interpolate import griddata
+
+plt.interactive(False)
+
+
+class map_projection(QtGui.QWidget):
+    def __init__(self, parent, figure=None):
+        '''
+
+        :param: picked, can be False, auto, manual
+        :value: str
+        '''
+        QtGui.QWidget.__init__(self)
+        self._parent = parent
+        self.metadata = parent.metadata
+        self.parser = parent.metadata[1]
+        self.picks = None
+        self.picks_dict = None
+        self.eventLoc = None
+        self.figure = figure
+        self.init_graphics()
+        self.init_stations()
+        self.init_basemap(resolution='l')
+        self.init_map()
+        # self.show()
+
+    def init_map(self):
+        self.init_lat_lon_dimensions()
+        self.init_lat_lon_grid()
+        self.init_x_y_dimensions()
+        self.connectSignals()
+        self.draw_everything()
+
+    def onpick(self, event):
+        ind = event.ind
+        button = event.mouseevent.button
+        if ind == [] or not button == 1:
+            return
+        data = self._parent.get_data().getWFData()
+        for index in ind:
+            station = str(self.station_names[index].split('.')[-1])
+            try:
+                pickDlg = PickDlg(self, parameter=self._parent._inputs,
+                                  data=data.select(station=station),
+                                  station=station,
+                                  picks=self._parent.get_current_event().getPick(station),
+                                  autopicks=self._parent.get_current_event().getAutopick(station))
+            except Exception as e:
+                message = 'Could not generate Plot for station {st}.\n {er}'.format(st=station, er=e)
+                self._warn(message)
+                print(message, e)
+                return
+            pyl_mw = self._parent
+            try:
+                if pickDlg.exec_():
+                    pyl_mw.setDirty(True)
+                    pyl_mw.update_status('picks accepted ({0})'.format(station))
+                    replot = pyl_mw.get_current_event().setPick(station, pickDlg.getPicks())
+                    self._refresh_drawings()
+                    if replot:
+                        pyl_mw.plotWaveformData()
+                        pyl_mw.drawPicks()
+                        pyl_mw.draw()
+                    else:
+                        pyl_mw.drawPicks(station)
+                        pyl_mw.draw()
+                else:
+                    pyl_mw.update_status('picks discarded ({0})'.format(station))
+            except Exception as e:
+                message = 'Could not save picks for station {st}.\n{er}'.format(st=station, er=e)
+                self._warn(message)
+                print(message, e)
+
+    def connectSignals(self):
+        self.comboBox_phase.currentIndexChanged.connect(self._refresh_drawings)
+        self.zoom_id = self.basemap.ax.figure.canvas.mpl_connect('scroll_event', self.zoom)
+
+    def init_graphics(self):
+        if not self.figure:
+            if not hasattr(self._parent, 'am_figure'):
+                self.figure = plt.figure()
+                self.toolbar = NavigationToolbar(self.figure.canvas, self)
+            else:
+                self.figure = self._parent.am_figure
+                self.toolbar = self._parent.am_toolbar
+
+        self.main_ax = self.figure.add_subplot(111)
+        self.canvas = self.figure.canvas
+
+        self.main_box = QtGui.QVBoxLayout()
+        self.setLayout(self.main_box)
+
+        self.top_row = QtGui.QHBoxLayout()
+        self.main_box.addLayout(self.top_row)
+
+        self.comboBox_phase = QtGui.QComboBox()
+        self.comboBox_phase.insertItem(0, 'P')
+        self.comboBox_phase.insertItem(1, 'S')
+
+        self.comboBox_am = QtGui.QComboBox()
+        self.comboBox_am.insertItem(0, 'auto')
+        self.comboBox_am.insertItem(1, 'manual')
+
+        self.top_row.addWidget(QtGui.QLabel('Select a phase: '))
+        self.top_row.addWidget(self.comboBox_phase)
+        self.top_row.setStretch(1, 1)  # set stretch of item 1 to 1
+
+        self.main_box.addWidget(self.canvas)
+        self.main_box.addWidget(self.toolbar)
+
+    def init_stations(self):
+        def get_station_names_lat_lon(parser):
+            station_names = []
+            lat = []
+            lon = []
+            for station in parser.stations:
+                station_name = station[0].station_call_letters
+                network = station[0].network_code
+                if not station_name in station_names:
+                    station_names.append(network + '.' + station_name)
+                    lat.append(station[0].latitude)
+                    lon.append(station[0].longitude)
+            return station_names, lat, lon
+
+        station_names, lat, lon = get_station_names_lat_lon(self.parser)
+        self.station_names = station_names
+        self.lat = lat
+        self.lon = lon
+
+    def init_picks(self):
+        phase = self.comboBox_phase.currentText()
+
+        def get_picks(station_names):
+            picks = []
+            for station in station_names:
+                try:
+                    station = station.split('.')[-1]
+                    picks.append(self.picks_dict[station][phase]['mpp'])
+                except:
+                    picks.append(np.nan)
+            return picks
+
+        def get_picks_rel(picks):
+            picks_rel = []
+            picks_utc = []
+            for pick in picks:
+                if type(pick) is obspy.core.utcdatetime.UTCDateTime:
+                    picks_utc.append(pick)
+            minp = min(picks_utc)
+            for pick in picks:
+                if type(pick) is obspy.core.utcdatetime.UTCDateTime:
+                    pick -= minp
+                picks_rel.append(pick)
+            return picks_rel
+
+        self.picks = get_picks(self.station_names)
+        self.picks_rel = get_picks_rel(self.picks)
+
+    def init_picks_active(self):
+        def remove_nan_picks(picks):
+            picks_no_nan = []
+            for pick in picks:
+                if not np.isnan(pick):
+                    picks_no_nan.append(pick)
+            return picks_no_nan
+
+        self.picks_no_nan = remove_nan_picks(self.picks_rel)
+
+    def init_stations_active(self):
+        def remove_nan_lat_lon(picks, lat, lon):
+            lat_no_nan = []
+            lon_no_nan = []
+            for index, pick in enumerate(picks):
+                if not np.isnan(pick):
+                    lat_no_nan.append(lat[index])
+                    lon_no_nan.append(lon[index])
+            return lat_no_nan, lon_no_nan
+
+        self.lat_no_nan, self.lon_no_nan = remove_nan_lat_lon(self.picks_rel, self.lat, self.lon)
+
+    def init_lat_lon_dimensions(self):
+        def get_lon_lat_dim(lon, lat):
+            londim = max(lon) - min(lon)
+            latdim = max(lat) - min(lat)
+            return londim, latdim
+
+        self.londim, self.latdim = get_lon_lat_dim(self.lon, self.lat)
+
+    def init_x_y_dimensions(self):
+        def get_x_y_dim(x, y):
+            xdim = max(x) - min(x)
+            ydim = max(y) - min(y)
+            return xdim, ydim
+
+        self.x, self.y = self.basemap(self.lon, self.lat)
+        self.xdim, self.ydim = get_x_y_dim(self.x, self.y)
+
+    def init_basemap(self, resolution='l'):
+        # basemap = Basemap(projection=projection, resolution = resolution, ax=self.main_ax)
+        basemap = Basemap(projection='lcc', resolution=resolution, ax=self.main_ax,
+                          width=5e6, height=2e6,
+                          lat_0=(min(self.lat) + max(self.lat)) / 2.,
+                          lon_0=(min(self.lon) + max(self.lon)) / 2.)
+
+        # basemap.fillcontinents(color=None, lake_color='aqua',zorder=1)
+        basemap.drawmapboundary(zorder=2)  # fill_color='darkblue')
+        basemap.shadedrelief(zorder=3)
+        basemap.drawcountries(zorder=4)
+        basemap.drawstates(zorder=5)
+        basemap.drawcoastlines(zorder=6)
+        self.basemap = basemap
+        self.figure.tight_layout()
+
+    def init_lat_lon_grid(self):
+        def get_lat_lon_axis(lat, lon):
+            steplat = (max(lat) - min(lat)) / 250
+            steplon = (max(lon) - min(lon)) / 250
+
+            lataxis = np.arange(min(lat), max(lat), steplat)
+            lonaxis = np.arange(min(lon), max(lon), steplon)
+            return lataxis, lonaxis
+
+        def get_lat_lon_grid(lataxis, lonaxis):
+            longrid, latgrid = np.meshgrid(lonaxis, lataxis)
+            return latgrid, longrid
+
+        self.lataxis, self.lonaxis = get_lat_lon_axis(self.lat, self.lon)
+        self.latgrid, self.longrid = get_lat_lon_grid(self.lataxis, self.lonaxis)
+
+    def init_picksgrid(self):
+        self.picksgrid_no_nan = griddata((self.lat_no_nan, self.lon_no_nan),
+                                         self.picks_no_nan, (self.latgrid, self.longrid),
+                                         method='linear')  ##################
+
+    def draw_contour_filled(self, nlevel='50'):
+        levels = np.linspace(min(self.picks_no_nan), max(self.picks_no_nan), nlevel)
+        self.contourf = self.basemap.contourf(self.longrid, self.latgrid, self.picksgrid_no_nan,
+                                              levels, latlon=True, zorder=9, alpha=0.5)
+
+    def scatter_all_stations(self):
+        self.sc = self.basemap.scatter(self.lon, self.lat, s=50, facecolor='none', latlon=True,
+                                       zorder=10, picker=True, edgecolor='m', label='Not Picked')
+        self.cid = self.canvas.mpl_connect('pick_event', self.onpick)
+        if self.eventLoc:
+            lat, lon = self.eventLoc
+            self.sc_event = self.basemap.scatter(lon, lat, s=100, facecolor='red',
+                                                 latlon=True, zorder=11, label='Event (might be outside map region)')
+
+    def scatter_picked_stations(self):
+        lon = self.lon_no_nan
+        lat = self.lat_no_nan
+
+        # workaround because of an issue with latlon transformation of arrays with len <3
+        if len(lon) <= 2 and len(lat) <= 2:
+            self.sc_picked = self.basemap.scatter(lon[0], lat[0], s=50, facecolor='white',
+                                                  c=self.picks_no_nan[0], latlon=True, zorder=11, label='Picked')
+        if len(lon) == 2 and len(lat) == 2:
+            self.sc_picked = self.basemap.scatter(lon[1], lat[1], s=50, facecolor='white',
+                                                  c=self.picks_no_nan[1], latlon=True, zorder=11)
+        else:
+            self.sc_picked = self.basemap.scatter(lon, lat, s=50, facecolor='white',
+                                                  c=self.picks_no_nan, latlon=True, zorder=11, label='Picked')
+
+    def annotate_ax(self):
+        self.annotations = []
+        for index, name in enumerate(self.station_names):
+            self.annotations.append(self.main_ax.annotate(' %s' % name, xy=(self.x[index], self.y[index]),
+                                                          fontsize='x-small', color='white', zorder=12))
+        self.legend = self.main_ax.legend(loc=1)
+
+    def add_cbar(self, label):
+        cbar = self.main_ax.figure.colorbar(self.sc_picked, fraction=0.025)
+        cbar.set_label(label)
+        return cbar
+
+    def refresh_drawings(self, picks=None):
+        self.picks_dict = picks
+        self._refresh_drawings()
+
+    def _refresh_drawings(self):
+        self.remove_drawings()
+        self.draw_everything()
+
+    def draw_everything(self):
+        if self.picks_dict:
+            self.init_picks()
+            self.init_picks_active()
+            self.init_stations_active()
+            if len(self.picks_no_nan) >= 3:
+                self.init_picksgrid()
+                self.draw_contour_filled()
+        self.scatter_all_stations()
+        if self.picks_dict:
+            self.scatter_picked_stations()
+            self.cbar = self.add_cbar(label='Time relative to first onset [s]')
+            self.comboBox_phase.setEnabled(True)
+        else:
+            self.comboBox_phase.setEnabled(False)
+        self.annotate_ax()
+        self.canvas.draw()
+
+    def remove_drawings(self):
+        if hasattr(self, 'sc_picked'):
+            self.sc_picked.remove()
+            del (self.sc_picked)
+        if hasattr(self, 'sc_event'):
+            self.sc_event.remove()
+            del (self.sc_event)
+        if hasattr(self, 'cbar'):
+            self.cbar.remove()
+            del (self.cbar)
+        if hasattr(self, 'contourf'):
+            self.remove_contourf()
+            del (self.contourf)
+        if hasattr(self, 'cid'):
+            self.canvas.mpl_disconnect(self.cid)
+            del (self.cid)
+        try:
+            self.sc.remove()
+        except Exception as e:
+            print('Warning: could not remove station scatter plot.\nReason: {}'.format(e))
+        try:
+            self.legend.remove()
+        except Exception as e:
+            print('Warning: could not remove legend. Reason: {}'.format(e))
+        self.canvas.draw()
+
+    def remove_contourf(self):
+        for item in self.contourf.collections:
+            item.remove()
+
+    def remove_annotations(self):
+        for annotation in self.annotations:
+            annotation.remove()
+
+    def zoom(self, event):
+        map = self.basemap
+        xlim = map.ax.get_xlim()
+        ylim = map.ax.get_ylim()
+        x, y = event.xdata, event.ydata
+        zoom = {'up': 1. / 2.,
+                'down': 2.}
+
+        if not event.xdata or not event.ydata:
+            return
+
+        if event.button in zoom:
+            factor = zoom[event.button]
+            xdiff = (xlim[1] - xlim[0]) * factor
+            xl = x - 0.5 * xdiff
+            xr = x + 0.5 * xdiff
+            ydiff = (ylim[1] - ylim[0]) * factor
+            yb = y - 0.5 * ydiff
+            yt = y + 0.5 * ydiff
+
+            if xl < map.xmin or yb < map.ymin or xr > map.xmax or yt > map.ymax:
+                xl, xr = map.xmin, map.xmax
+                yb, yt = map.ymin, map.ymax
+            map.ax.set_xlim(xl, xr)
+            map.ax.set_ylim(yb, yt)
+            map.ax.figure.canvas.draw()
+
+    def _warn(self, message):
+        self.qmb = QtGui.QMessageBox(QtGui.QMessageBox.Icon.Warning,
+                                     'Warning', message)
+        self.qmb.show()

pylot/core/util/pdf.py

@@ -2,20 +2,23 @@
 # -*- coding: utf-8 -*-
 
 import warnings
+
 import numpy as np
 from obspy import UTCDateTime
-from pylot.core.util.utils import fit_curve, find_nearest, clims
+from pylot.core.util.utils import fit_curve, clims
 from pylot.core.util.version import get_git_version as _getVersionString
 
 __version__ = _getVersionString()
 __author__ = 'sebastianw'
 
+
 def create_axis(x0, incr, npts):
     ax = np.zeros(npts)
     for i in range(npts):
         ax[i] = x0 + incr * i
     return ax
 
+
 def gauss_parameter(te, tm, tl, eta):
     '''
     takes three onset times and returns the parameters sig1, sig2, a1 and a2
@@ -51,12 +54,15 @@ def exp_parameter(te, tm, tl, eta):
 
     sig1 = np.log(eta) / (te - tm)
     sig2 = np.log(eta) / (tm - tl)
+    if np.isinf(sig1) == True:
+        sig1 = np.log(eta) / (tm - tl)
+    if np.isinf(sig2) == True:
+        sig2 = np.log(eta) / (te - tm)
     a = 1 / (1 / sig1 + 1 / sig2)
-
     return tm, sig1, sig2, a
 
 
-def gauss_branches(k, (mu, sig1, sig2, a1, a2)):
+def gauss_branches(k, param_tuple):
     '''
     function gauss_branches takes an axes x, a center value mu, two sigma
     values sig1 and sig2 and two scaling factors a1 and a2 and return a
@@ -76,6 +82,9 @@ def gauss_branches(k, (mu, sig1, sig2, a1, a2)):
     :returns fun_vals: list with function values along axes x
     '''
 
+    # python 3 workaround
+    mu, sig1, sig2, a1, a2 = param_tuple
+
     def _func(k, mu, sig1, sig2, a1, a2):
         if k < mu:
             rval = a1 * 1 / (np.sqrt(2 * np.pi) * sig1) * np.exp(-((k - mu) / sig1) ** 2 / 2)
@@ -90,7 +99,7 @@ def gauss_branches(k, (mu, sig1, sig2, a1, a2)):
         return _func(k, mu, sig1, sig2, a1, a2)
 
 
-def exp_branches(k, (mu, sig1, sig2, a)):
+def exp_branches(k, param_tuple):
     '''
     function exp_branches takes an axes x, a center value mu, two sigma
     values sig1 and sig2 and a scaling factor a and return a
@@ -104,6 +113,9 @@ def exp_branches(k, (mu, sig1, sig2, a)):
     :returns fun_vals: list with function values along axes x:
     '''
 
+    # python 3 workaround
+    mu, sig1, sig2, a = param_tuple
+
     def _func(k, mu, sig1, sig2, a):
         mu = float(mu)
         if k < mu:
@@ -236,8 +248,8 @@ class ProbabilityDensityFunction(object):
         self._x = np.array(x)
 
     @classmethod
-    def from_pick(self, lbound, barycentre, rbound, incr=0.001, decfact=0.01,
-                  type='gauss'):
+    def from_pick(self, lbound, barycentre, rbound, incr=0.1, decfact=0.01,
+                  type='exp'):
         '''
         Initialize a new ProbabilityDensityFunction object.
         Takes incr, lbound, barycentre and rbound to derive x0 and the number
@@ -304,10 +316,14 @@ class ProbabilityDensityFunction(object):
         :return float: rval
         '''
 
-        rval = 0
-        for x in self.axis:
-            rval += x * self.data(x)
-        return rval * self.incr
+        # rval = 0
+        # for x in self.axis:
+        #    rval += x * self.data(x)
+        rval = self.mu
+        # Not sure about this! That might not be the barycentre.
+        # However, for std calculation (next function)
+        # self.mu is also used!! (LK, 02/2017) 
+        return rval
 
     def standard_deviation(self):
         mu = self.mu
@@ -381,7 +397,6 @@ class ProbabilityDensityFunction(object):
         qu = self.quantile(1 - prob_value)
         return qu - ql
 
-
     def quantile_dist_frac(self, x):
         """
         takes a probability value and returns the fraction of two
@@ -398,8 +413,7 @@ class ProbabilityDensityFunction(object):
         """
         if x <= 0 or x >= 0.25:
             raise ValueError('Value out of range.')
-        return self.quantile_distance(0.5-x)/self.quantile_distance(x)
-
+        return self.quantile_distance(0.5 - x) / self.quantile_distance(x)
 
     def plot(self, label=None):
         import matplotlib.pyplot as plt
@@ -473,4 +487,3 @@ class ProbabilityDensityFunction(object):
         x0, npts = self.commonlimits(incr, other)
 
         return x0, incr, npts
-

pylot/core/util/plotting.py

@@ -3,6 +3,7 @@
 
 import matplotlib.pyplot as plt
 
+
 def create_bin_list(l_boundary, u_boundary, nbins=100):
     """
     takes two boundaries and a number of bins and creates a list of bins for
@@ -54,4 +55,4 @@ def histplot(array, binlist, xlab='Values',
     if fnout:
         plt.savefig(fnout)
     else:
-        plt.show()
+        plt.show()

pylot/core/util/thread.py

@@ -1,33 +1,187 @@
 # -*- coding: utf-8 -*-
-import sys
-from PySide.QtCore import QThread, Signal
+import sys, os, traceback
+import multiprocessing
+from PySide.QtCore import QThread, Signal, Qt, Slot, QRunnable, QObject
+from PySide.QtGui import QDialog, QProgressBar, QLabel, QHBoxLayout, QPushButton
 
 
-class AutoPickThread(QThread):
+class Thread(QThread):
     message = Signal(str)
-    finished = Signal()
 
-    def __init__(self, parent, func, data, param):
-        super(AutoPickThread, self).__init__()
-        self.setParent(parent)
+    def __init__(self, parent, func, arg=None, progressText=None,
+                 pb_widget=None, redirect_stdout=False, abortButton=False):
+        QThread.__init__(self, parent)
         self.func = func
-        self.data = data
-        self.param = param
+        self.arg = arg
+        self.progressText = progressText
+        self.pb_widget = pb_widget
+        self.redirect_stdout = redirect_stdout
+        self.abortButton = abortButton
+        self.finished.connect(self.hideProgressbar)
+        self.showProgressbar()
 
     def run(self):
-        sys.stdout = self
-
-        picks = self.func(self.data, self.param)
-
-        print("Autopicking finished!\n")
-
+        if self.redirect_stdout:
+            sys.stdout = self
         try:
-            for station in picks:
-                self.parent().addPicks(station, picks[station], type='auto')
-        except AttributeError:
-            print(picks)
+            if self.arg:
+                self.data = self.func(self.arg)
+            else:
+                self.data = self.func()
+            self._executed = True
+        except Exception as e:
+            self._executed = False
+            self._executedError = e
+            traceback.print_exc()
+            exctype, value = sys.exc_info ()[:2]
+            self._executedErrorInfo = '{} {} {}'.\
+                format(exctype, value, traceback.format_exc())
         sys.stdout = sys.__stdout__
-        self.finished.emit()
+
+    def showProgressbar(self):
+        if self.progressText:
+
+            # generate widget if not given in init
+            if not self.pb_widget:
+                self.pb_widget = QDialog(self.parent())
+                self.pb_widget.setWindowFlags(Qt.SplashScreen)
+                self.pb_widget.setModal(True)
+
+            # add button
+            delete_button = QPushButton('X')
+            delete_button.clicked.connect(self.exit)
+            hl = QHBoxLayout()
+            pb = QProgressBar()
+            pb.setRange(0, 0)
+            hl.addWidget(pb)
+            hl.addWidget(QLabel(self.progressText))
+            if self.abortButton:
+                hl.addWidget(delete_button)
+            self.pb_widget.setLayout(hl)
+            self.pb_widget.show()
+
+    def hideProgressbar(self):
+        if self.pb_widget:
+            self.pb_widget.hide()
 
     def write(self, text):
         self.message.emit(text)
+
+    def flush(self):
+        pass
+
+
+class Worker(QRunnable):
+    '''
+    Worker class to be run by MultiThread(QThread).
+    '''
+    def __init__(self, fun, args,
+                 progressText=None,
+                 pb_widget=None,
+                 redirect_stdout=False):
+        super(Worker, self).__init__()
+        self.fun = fun
+        self.args = args
+        #self.kwargs = kwargs
+        self.signals = WorkerSignals()
+        self.progressText = progressText
+        self.pb_widget = pb_widget
+        self.redirect_stdout = redirect_stdout
+
+    @Slot()
+    def run(self):
+        if self.redirect_stdout:
+            sys.stdout = self
+
+        try:
+            result = self.fun(self.args)
+        except:
+            exctype, value = sys.exc_info ()[:2]
+            print(exctype, value, traceback.format_exc())
+            self.signals.error.emit ((exctype, value, traceback.format_exc ()))
+        else:
+            self.signals.result.emit(result)
+        finally:
+            self.signals.finished.emit('Done')
+        sys.stdout = sys.__stdout__
+
+    def write(self, text):
+        self.signals.message.emit(text)
+
+    def flush(self):
+        pass
+
+
+class WorkerSignals(QObject):
+    '''
+    Class to provide signals for Worker Class
+    '''
+    finished = Signal(str)
+    message = Signal(str)
+    error = Signal(tuple)
+    result = Signal(object)
+
+
+class MultiThread(QThread):
+    finished = Signal(str)
+    message = Signal(str)
+
+    def __init__(self, parent, func, args, ncores=1,
+                 progressText=None, pb_widget=None, redirect_stdout=False):
+        QThread.__init__(self, parent)
+        self.func = func
+        self.args = args
+        self.ncores = ncores
+        self.progressText = progressText
+        self.pb_widget = pb_widget
+        self.redirect_stdout = redirect_stdout
+        self.finished.connect(self.hideProgressbar)
+        self.showProgressbar()
+
+    def run(self):
+        if self.redirect_stdout:
+             sys.stdout = self
+        try:
+            if not self.ncores:
+                self.ncores = multiprocessing.cpu_count()
+            pool = multiprocessing.Pool(self.ncores)
+            self.data = pool.map_async(self.func, self.args, callback=self.emitDone)
+            #self.data = pool.apply_async(self.func, self.shotlist, callback=self.emitDone) #emit each time returned
+            pool.close()
+            self._executed = True
+        except Exception as e:
+            self._executed = False
+            self._executedError = e
+            exc_type, exc_obj, exc_tb = sys.exc_info()
+            fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
+            print('Exception: {}, file: {}, line: {}'.format(exc_type, fname, exc_tb.tb_lineno))
+        sys.stdout = sys.__stdout__
+
+    def showProgressbar(self):
+        if self.progressText:
+            if not self.pb_widget:
+                self.pb_widget = QDialog(self.parent())
+                self.pb_widget.setWindowFlags(Qt.SplashScreen)
+                self.pb_widget.setModal(True)
+            hl = QHBoxLayout()
+            pb = QProgressBar()
+            pb.setRange(0, 0)
+            hl.addWidget(pb)
+            hl.addWidget(QLabel(self.progressText))
+            self.pb_widget.setLayout(hl)
+            self.pb_widget.show()
+
+    def hideProgressbar(self):
+        if self.pb_widget:
+            self.pb_widget.hide()
+
+    def write(self, text):
+        self.message.emit(text)
+
+    def flush(self):
+        pass
+
+    def emitDone(self, result):
+        print('emitDone!')
+        self.finished.emit('Done thread!')
+        self.hideProgressbar()

pylot/core/util/utils.py

@@ -2,15 +2,28 @@
 # -*- coding: utf-8 -*-
 
 import hashlib
-import numpy as np
-from scipy.interpolate import splrep, splev
 import os
-import pwd
+import platform
 import re
 import subprocess
-from obspy import UTCDateTime, read
-from pylot.core.io.inputs import AutoPickParameter
 
+import numpy as np
+from obspy import UTCDateTime, read
+from obspy.core import AttribDict
+from obspy.signal.rotate import rotate2zne
+from obspy.io.xseed.utils import SEEDParserException
+
+from pylot.core.io.inputs import PylotParameter
+from pylot.styles import style_settings
+
+from scipy.interpolate import splrep, splev
+from PySide import QtCore, QtGui
+
+try:
+    import pyqtgraph as pg
+except Exception as e:
+    print('PyLoT: Could not import pyqtgraph. {}'.format(e))
+    pg = None
 
 def _pickle_method(m):
     if m.im_self is None:
@@ -18,9 +31,28 @@ def _pickle_method(m):
     else:
         return getattr, (m.im_self, m.im_func.func_name)
 
+
+def readDefaultFilterInformation(fname):
+    pparam = PylotParameter(fname)
+    return readFilterInformation(pparam)
+
+
+def readFilterInformation(pylot_parameter):
+    p_filter = {'filtertype': pylot_parameter['filter_type'][0],
+                'freq': [pylot_parameter['minfreq'][0], pylot_parameter['maxfreq'][0]],
+                'order': int(pylot_parameter['filter_order'][0])}
+    s_filter = {'filtertype': pylot_parameter['filter_type'][1],
+                'freq': [pylot_parameter['minfreq'][1], pylot_parameter['maxfreq'][1]],
+                'order': int(pylot_parameter['filter_order'][1])}
+    filter_information = {'P': p_filter,
+                          'S': s_filter}
+    return filter_information
+
+
 def fit_curve(x, y):
     return splev, splrep(x, y)
 
+
 def getindexbounds(f, eta):
     mi = f.argmax()
     m = max(f)
@@ -29,19 +61,55 @@ def getindexbounds(f, eta):
     u = find_nearest(f[mi:], b) + mi
     return mi, l, u
 
-def worker(func, input, cores='max', async=False):
+
+def gen_Pool(ncores=0):
+    '''
+    :param ncores: number of CPU cores for multiprocessing.Pool, if ncores == 0 use all available
+    :return: multiprocessing.Pool object
+    '''
     import multiprocessing
 
-    if cores == 'max':
-        cores = multiprocessing.cpu_count()
+    if ncores == 0:
+        ncores = multiprocessing.cpu_count()
+
+    print('gen_Pool: Generated multiprocessing Pool with {} cores\n'.format(ncores))
+
+    pool = multiprocessing.Pool(ncores)
+    return pool
+
+
+def excludeQualityClasses(picks, qClasses, timeerrorsP, timeerrorsS):
+    '''
+    takes PyLoT picks dictionary and returns a new dictionary with certain classes excluded.
+    :param picks: PyLoT picks dictionary
+    :param qClasses: list (or int) of quality classes (0-4) to exclude
+    :param timeerrorsP: time errors for classes (0-4) for P
+    :param timeerrorsS: time errors for classes (0-4) for S
+    :return: new picks dictionary
+    '''
+    from pylot.core.pick.utils import getQualityFromUncertainty
+
+    if type(qClasses) in [int, float]:
+        qClasses = [qClasses]
+
+    picksdict_new = {}
+
+    phaseError = {'P': timeerrorsP,
+                  'S': timeerrorsS}
+
+    for station, phases in picks.items():
+        for phase, pick in phases.items():
+            if not type(pick) in [AttribDict, dict]:
+                continue
+            pickerror = phaseError[identifyPhaseID(phase)]
+            quality = getQualityFromUncertainty(pick['spe'], pickerror)
+            if not quality in qClasses:
+                if not station in picksdict_new:
+                    picksdict_new[station] = {}
+                picksdict_new[station][phase] = pick
+
+    return picksdict_new
 
-    pool = multiprocessing.Pool(cores)
-    if async == True:
-        result = pool.map_async(func, input)
-    else:
-        result = pool.map(func, input)
-    pool.close()
-    return result
 
 def clims(lim1, lim2):
     """
@@ -108,6 +176,7 @@ def findComboBoxIndex(combo_box, val):
     """
     return combo_box.findText(val) if combo_box.findText(val) is not -1 else 0
 
+
 def find_in_list(list, str):
     """
     takes a list of strings and a string and returns the first list item
@@ -137,6 +206,7 @@ def find_in_list(list, str):
         return rlist[0]
     return None
 
+
 def find_nearest(array, value):
     '''
     function find_nearest takes an array and a value and returns the
@@ -184,6 +254,22 @@ def fnConstructor(s):
     return fn
 
 
+def real_None(value):
+    if value == 'None':
+        return None
+    else:
+        return value
+
+
+def real_Bool(value):
+    if value == 'True':
+        return True
+    elif value == 'False':
+        return False
+    else:
+        return value
+
+
 def four_digits(year):
     """
     takes a two digit year integer and returns the correct four digit equivalent
@@ -260,7 +346,7 @@ def getLogin():
     returns the actual user's login ID
     :return: login ID
     '''
-    return pwd.getpwuid(os.getuid())[0]
+    return os.getlogin()
 
 
 def getOwner(fn):
@@ -270,7 +356,15 @@ def getOwner(fn):
     :type fn: str
     :return: login ID of the file's owner
     '''
-    return pwd.getpwuid(os.stat(fn).st_uid).pw_name
+    system_name = platform.system()
+    if system_name in ["Linux", "Darwin"]:
+        import pwd
+        return pwd.getpwuid(os.stat(fn).st_uid).pw_name
+    elif system_name == "Windows":
+        import win32security
+        f = win32security.GetFileSecurity(fn, win32security.OWNER_SECURITY_INFORMATION)
+        (username, domain, sid_name_use) = win32security.LookupAccountSid(None, f.GetSecurityDescriptorOwner())
+        return username
 
 
 def getPatternLine(fn, pattern):
@@ -296,6 +390,7 @@ def getPatternLine(fn, pattern):
 
     return None
 
+
 def is_executable(fn):
     """
     takes a filename and returns True if the file is executable on the system
@@ -364,7 +459,7 @@ def key_for_set_value(d):
     return r
 
 
-def prepTimeAxis(stime, trace):
+def prepTimeAxis(stime, trace, verbosity=0):
     '''
     takes a starttime and a trace object and returns a valid time axis for
     plotting
@@ -378,15 +473,19 @@ def prepTimeAxis(stime, trace):
     etime = stime + nsamp / srate
     time_ax = np.arange(stime, etime, tincr)
     if len(time_ax) < nsamp:
-        print('elongate time axes by one datum')
+        if verbosity:
+            print('elongate time axes by one datum')
         time_ax = np.arange(stime, etime + tincr, tincr)
     elif len(time_ax) > nsamp:
-        print('shorten time axes by one datum')
+        if verbosity:
+            print('shorten time axes by one datum')
         time_ax = np.arange(stime, etime - tincr, tincr)
     if len(time_ax) != nsamp:
-        raise ValueError('{0} samples of data \n '
-                         '{1} length of time vector \n'
-                         'delta: {2}'.format(nsamp, len(time_ax), tincr))
+        print('Station {0}, {1} samples of data \n '
+              '{2} length of time vector \n'
+              'delta: {3}'.format(trace.stats.station,
+                                  nsamp, len(time_ax), tincr))
+        time_ax = None
     return time_ax
 
 
@@ -413,6 +512,91 @@ def find_horizontals(data):
     return rval
 
 
+def make_pen(picktype, phase, key, quality):
+    if pg:
+        rgba = pick_color(picktype, phase, quality)
+        linestyle, width = pick_linestyle_pg(picktype, key)
+        pen = pg.mkPen(rgba, width=width, style=linestyle)
+        return pen
+
+
+def pick_color(picktype, phase, quality=0):
+    min_quality = 3
+    bpc = base_phase_colors(picktype, phase)
+    rgba = bpc['rgba']
+    modifier = bpc['modifier']
+    intensity = 255.*quality/min_quality
+    rgba = modify_rgba(rgba, modifier, intensity)
+    return rgba
+
+
+def pick_color_plt(picktype, phase, quality=0):
+    rgba = list(pick_color(picktype, phase, quality))
+    for index, val in enumerate(rgba):
+        rgba[index] /= 255.
+    return rgba
+
+
+def pick_linestyle_plt(picktype, key):
+    linestyles_manu = {'mpp': ('solid', 2.),
+                       'epp': ('dashed', 1.),
+                       'lpp': ('dashed', 1.),
+                       'spe': ('dashed', 1.)}
+    linestyles_auto = {'mpp': ('dotted', 2.),
+                       'epp': ('dashdot', 1.),
+                       'lpp': ('dashdot', 1.),
+                       'spe': ('dashdot', 1.)}
+    linestyles = {'manual': linestyles_manu,
+                  'auto': linestyles_auto}
+    return linestyles[picktype][key]
+
+
+def pick_linestyle_pg(picktype, key):
+    linestyles_manu = {'mpp': (QtCore.Qt.SolidLine, 2.),
+                       'epp': (QtCore.Qt.DashLine, 1.),
+                       'lpp': (QtCore.Qt.DashLine, 1.),
+                       'spe': (QtCore.Qt.DashLine, 1.)}
+    linestyles_auto = {'mpp': (QtCore.Qt.DotLine, 2.),
+                       'epp': (QtCore.Qt.DashDotLine, 1.),
+                       'lpp': (QtCore.Qt.DashDotLine, 1.),
+                       'spe': (QtCore.Qt.DashDotLine, 1.)}
+    linestyles = {'manual': linestyles_manu,
+                  'auto': linestyles_auto}
+    return linestyles[picktype][key]
+
+
+def modify_rgba(rgba, modifier, intensity):
+    rgba = list(rgba)
+    index = {'r': 0,
+             'g': 1,
+             'b': 2}
+    val = rgba[index[modifier]] + intensity
+    if val > 255.:
+        val = 255.
+    elif val < 0.:
+        val = 0
+    rgba[index[modifier]] = val
+    return tuple(rgba)
+
+
+def base_phase_colors(picktype, phase):
+    phasecolors = style_settings.phasecolors
+    return phasecolors[picktype][phase]
+
+def transform_colors_mpl_str(colors, no_alpha=False):
+    colors = list(colors)
+    colors_mpl = tuple([color / 255. for color in colors])
+    if no_alpha:
+        colors_mpl = '({}, {}, {})'.format(*colors_mpl)
+    else:
+        colors_mpl = '({}, {}, {}, {})'.format(*colors_mpl)
+    return colors_mpl
+
+def transform_colors_mpl(colors):
+    colors = list(colors)
+    colors_mpl = tuple([color / 255. for color in colors])
+    return colors_mpl
+
 def remove_underscores(data):
     """
     takes a `obspy.core.stream.Stream` object and removes all underscores
@@ -427,6 +611,176 @@ def remove_underscores(data):
     return data
 
 
+def trim_station_components(data, trim_start=True, trim_end=True):
+    '''
+    cut a stream so only the part common to all three traces is kept to avoid dealing with offsets
+    :param data: stream of seismic data
+    :type data: `obspy.core.stream.Stream`
+    :param trim_start: trim start of stream
+    :type trim_start: bool
+    :param trim_end: trim end of stream
+    :type trim_end: bool
+    :return: data stream
+    '''
+    starttime = {False: None}
+    endtime = {False: None}
+
+    stations = get_stations(data)
+
+    print('trim_station_components: Will trim stream for trim_start: {} and for '
+          'trim_end: {}.'.format(trim_start, trim_end))
+    for station in stations:
+        wf_station = data.select(station=station)
+        starttime[True] = max([trace.stats.starttime for trace in wf_station])
+        endtime[True] = min([trace.stats.endtime for trace in wf_station])
+        wf_station.trim(starttime=starttime[trim_start], endtime=endtime[trim_end])
+
+    return data
+
+
+def check4gaps(data):
+    '''
+    check for gaps in Stream and remove them
+    :param data: stream of seismic data
+    :return: data stream
+    '''
+    stations = get_stations(data)
+
+    for station in stations:
+        wf_station = data.select(station=station)
+        if wf_station.get_gaps():
+            for trace in wf_station:
+                data.remove(trace)
+            print('check4gaps: Found gaps and removed station {} from waveform data.'.format(station))
+
+    return data
+
+
+def check4doubled(data):
+    '''
+    check for doubled stations for same channel in Stream and take only the first one
+    :param data: stream of seismic data
+    :return: data stream
+    '''
+    stations = get_stations(data)
+
+    for station in stations:
+        wf_station = data.select(station=station)
+        # create list of all possible channels
+        channels = []
+        for trace in wf_station:
+            channel = trace.stats.channel
+            if not channel in channels:
+                channels.append(channel)
+            else:
+                print('check4doubled: removed the following trace for station {}, as there is'
+                      ' already a trace with the same channel given:\n{}'.format(
+                    station, trace
+                ))
+                data.remove(trace)
+    return data
+
+
+def get_stations(data):
+    stations = []
+    for tr in data:
+        station = tr.stats.station
+        if not station in stations:
+            stations.append(station)
+
+    return stations
+
+
+def check4rotated(data, metadata=None, verbosity=1):
+
+    def rotate_components(wfstream, metadata=None):
+        """rotates components if orientation code is numeric.
+        azimut and dip are fetched from metadata"""
+        try:
+            # indexing fails if metadata is None
+            metadata[0]
+        except:
+            if verbosity:
+                msg = 'Warning: could not rotate traces since no metadata was given\nset Inventory file!'
+                print(msg)
+            return wfstream
+        if metadata[0] is None:
+            # sometimes metadata is (None, (None,))
+            if verbosity:
+                msg = 'Warning: could not rotate traces since no metadata was given\nCheck inventory directory!'
+                print(msg)
+            return wfstream
+        else:
+            parser = metadata[1]
+
+        def get_dip_azimut(parser, trace_id):
+            """gets azimut and dip for a trace out of the metadata parser"""
+            dip = None
+            azimut = None
+            try:
+                blockettes = parser._select(trace_id)
+            except SEEDParserException as e:
+                print(e)
+                raise ValueError
+            for blockette_ in blockettes:
+                if blockette_.id != 52:
+                    continue
+                dip = blockette_.dip
+                azimut = blockette_.azimuth
+                break
+            if dip is None or azimut is None:
+                error_msg = 'Dip and azimuth not available for trace_id {}'.format(trace_id)
+                raise ValueError(error_msg)
+            return dip, azimut
+
+        trace_ids = [trace.id for trace in wfstream]
+        for trace_id in trace_ids:
+            orientation = trace_id[-1]
+            if orientation.isnumeric():
+                # misaligned channels have a number as orientation
+                azimuts = []
+                dips = []
+                for trace_id in trace_ids:
+                    try:
+                        dip, azimut = get_dip_azimut(parser, trace_id)
+                    except ValueError as e:
+                        print(e)
+                        print('Failed to rotate station {}, no azimuth or dip available in metadata'.format(trace_id))
+                        return wfstream
+                    azimuts.append(azimut)
+                    dips.append(dip)
+                # to rotate all traces must have same length
+                wfstream = trim_station_components(wfstream, trim_start=True, trim_end=True)
+                z, n, e = rotate2zne(wfstream[0], azimuts[0], dips[0],
+                                          wfstream[1], azimuts[1], dips[1],
+                                          wfstream[2], azimuts[2], dips[2])
+                print('check4rotated: rotated station {} to ZNE'.format(trace_id))
+                z_index = dips.index(min(dips)) # get z-trace index (dip is measured from 0 to -90
+                wfstream[z_index].data = z
+                wfstream[z_index].stats.channel = wfstream[z_index].stats.channel[0:-1] + 'Z'
+                del trace_ids[z_index]
+                for trace_id in trace_ids:
+                    dip, az = get_dip_azimut(parser, trace_id)
+                    trace = wfstream.select(id=trace_id)[0]
+                    if az > 315 and az <= 45 or az > 135 and az <= 225:
+                        trace.data = n
+                        trace.stats.channel = trace.stats.channel[0:-1] + 'N'
+                    elif az > 45 and az <= 135 or az > 225 and az <= 315:
+                        trace.data = e
+                        trace.stats.channel = trace.stats.channel[0:-1] + 'E'
+                break
+            else:
+                continue
+        return wfstream
+
+    stations = get_stations(data)
+
+    for station in stations:
+        wf_station = data.select(station=station)
+        wf_station = rotate_components(wf_station, metadata)
+    return data
+
+
 def scaleWFData(data, factor=None, components='all'):
     """
     produce scaled waveforms from given waveform data and a scaling factor,
@@ -477,7 +831,8 @@ def runProgram(cmd, parameter=None):
 
     subprocess.check_output('{} | tee /dev/stderr'.format(cmd), shell=True)
 
-def which(program):
+
+def which(program, infile=None):
     """
     takes a program name and returns the full path to the executable or None
     modified after: http://stackoverflow.com/questions/377017/test-if-executable-exists-in-python
@@ -490,9 +845,14 @@ def which(program):
         for key in settings.allKeys():
             if 'binPath' in key:
                 os.environ['PATH'] += ':{0}'.format(settings.value(key))
-        bpath = os.path.join(os.path.expanduser('~'), '.pylot', 'autoPyLoT.in')
+        if infile is None:
+            # use default parameter-file name
+            bpath = os.path.join(os.path.expanduser('~'), '.pylot', 'pylot.in')
+        else:
+            bpath = os.path.join(os.path.expanduser('~'), '.pylot', infile)
+
         if os.path.exists(bpath):
-            nllocpath = ":" + AutoPickParameter(bpath).get('nllocbin')
+            nllocpath = ":" + PylotParameter(bpath).get('nllocbin')
             os.environ['PATH'] += nllocpath
     except ImportError as e:
         print(e.message)
@@ -518,6 +878,61 @@ def which(program):
 
     return None
 
+
+def loopIdentifyPhase(phase):
+    '''
+    Loop through phase string and try to recognize its type (P or S wave).
+    Global variable ALTSUFFIX gives alternative suffix for phases if they do not end with P, p or S, s.
+    If ALTSUFFIX is not given, the function will cut the last letter of the phase string until string ends
+    with P or S.
+    :param phase: phase name (str)
+    :return:
+    '''
+    from pylot.core.util.defaults import ALTSUFFIX
+
+    phase_copy = phase
+    while not identifyPhase(phase_copy):
+        identified = False
+        for alt_suf in ALTSUFFIX:
+            if phase_copy.endswith(alt_suf):
+                phase_copy = phase_copy.split(alt_suf)[0]
+                identified = True
+        if not identified:
+            phase_copy = phase_copy[:-1]
+        if len(phase_copy) < 1:
+            print('Warning: Could not identify phase {}!'.format(phase))
+            return
+    return phase_copy
+
+
+def identifyPhase(phase):
+    '''
+    Returns capital P or S if phase string is identified by last letter. Else returns False.
+    :param phase: phase name (str)
+    :return: 'P', 'S' or False
+    '''
+    # common phase suffix for P and S
+    common_P = ['P', 'p']
+    common_S = ['S', 's']
+    if phase[-1] in common_P:
+        return 'P'
+    if phase[-1] in common_S:
+        return 'S'
+    else:
+        return False
+
+
+def identifyPhaseID(phase):
+    return identifyPhase(loopIdentifyPhase(phase))
+
+
+def has_spe(pick):
+    if not 'spe' in pick.keys():
+        return None
+    else:
+        return pick['spe']
+
+
 if __name__ == "__main__":
     import doctest